/*
ssx.c Personal PBX Call Processing Source Code

(c) 1994-2006 Richard Newman 1110 W. North Ave, Pittsburgh PA 15233


*/

/* 
#define DEBUG 1    this is commented out for PRODUCTION CODE  
*/


#define TRUE 1
#include <8051io.h>     /* for putc,printf,getch i/o functions  */
#include <8051int.h>    /* for interupt service macro           */
#include <8051reg.h>    /* to access registers by name          */
#include <8051bit.h>    /* to access bits in registers directly */

/* Extention Related Process                                               */
#define exhm      1      /* 00 - 32  Extention Hook Monitor Process        */
#define exdm      33     /* 33 - 64  Extention Dialing Monitor Process     */
#define exsm      97     /* 65 - 96  Extention Signaling Monitor           */
#define excm      65     /* 97 - 128 Extention Conversation Monitor        */

/* Global Definitions used by various functions                            */
#define maxstat     16    /* Number of stations in system                   */
#define maxpath     8     /* Max talk paths and conversations               */
#define maxrecs     1     /* Max number of dtmf reciever- cpg sender combos */
#define maxsend     1     /* Max number of cpg reciever- dtmf sender combos */
#define maxdigits   20    /* Max number of digits to collect on call        */
#define first_digit 20    /* time until busy on first dialed digit          */
#define inter_digit 6     /* timeout between dialed digits                  */
#define lock_out    30    /* time until station lockout is performed */


#define acs_register_length    16
#define total_routes        4
#define registers_per_route    7
#define maxrad				1		/* max recorded anouncement device */

#define BUSY    1
#define IDLE    0xFF

#define SILENCE 0xFF
#define DIAL    0x00
#define SPECIALA 0x02
#define ALERT    0x04
#define RING    0x06
#define PREMPT  0x08
#define HIBELL  0x0A
#define LOBELL  0x0C    /* also re-order */
#define REORDER 0x0C
#define SPECIALB 0x0E
#define SPECIALC 0x10
#define DTMF*    0x18

/* Call Control Block                                                      */
static unsigned char ccb_acp[maxpath];        /* associated completion path   */
static unsigned char ccb_path[maxpath];                 /* idle means whole CCB free, else marked busy */
static unsigned char ccb_digits[maxpath][maxdigits];    /* max collected digits */
static unsigned char ccb_enque[maxpath];
static unsigned char ccb_route[maxpath];
static unsigned char ccb;
static unsigned char route;

/* Common Resource Control Block                                           */
static unsigned char recs_status[maxrecs];
static unsigned char send_status[maxsend];
static unsigned char ccb_deque[maxpath];

/*  Global Variables accessable from any module  */
static unsigned int hour,minute,hundsec,second,tens;
static unsigned char rfreq;
static unsigned char ext_process[maxstat];  /* ext process to execute  0 - 15 */
static unsigned char ext_substate[maxstat];
static unsigned char ext_status[maxstat];   /* marks the associated CCB and SPEECH path talking on */
static unsigned char ext_return[maxstat];
static unsigned char ext_temp[maxstat];

static unsigned char *rap[maxrad];			/* recorded announcement device directory pointer */
static unsigned char rads[maxrad];			/* recorded announcemtnt device status */
static unsigned char radm[maxrad];			/* recorded announcement device message */

static unsigned char ext_check;             /* Scheduler process to execute   */
static unsigned char table_pointer_begin[16];     /* pointer to 8xx tables */
static unsigned char table_pointer_end;
static unsigned char table_8xx[200];         /* actual 8xx table      */
static unsigned char *port;
static unsigned char cross;            /* speech path cross connect variable */
static unsigned int ext_timer[maxstat];    /* station timing variable */
static unsigned char ext_route[maxstat];    /* route selected for station */
static unsigned char ring_trip;         /* counter to determine ring trip */
static unsigned char ring_hv;              /* flag to generate ringing hv */
static unsigned char message_hv;           /* flag to generate message waiting hv */
static unsigned char shadow_D006;
static unsigned char shadow_D000;
static unsigned char shadow_D002;
static unsigned char shadow_D004;
static unsigned char shadow_C002;
static unsigned char route_update_next;        /* this is the current route being examined by the route routine */
static unsigned char acs[total_routes*registers_per_route][acs_register_length];

#ifdef DEBUG
static unsigned char rtdisp;
#endif

char cpg(tone)
char tone;
{
/* is a generator connected to this call ? */
/* if so then send the desired tone- return sucess by indicating the */
/* associated CCB/Path. If not locate a free generator and associate */
/* it with the call and indicate sucess by returning the associated  */
/* CCB/path. if no generator is available and there is no generator  */
/* currently assigned to the call indicate unsucessful operation by  */
/* returning IDLE indication of 0xFF                     */

char i,j,k,enable;

if (tone==SILENCE)
   {
   enable=0xFF;
   }
else
   {
   enable=0xFE;
   }

k=0;        /* start by indicating not found     */

/* check for a generator connected to this call     */
for (i=0;i<maxrecs;i++)
   {
   if (recs_status[i] == ext_status[ext_check])
      {
      k=1;    /* found a generator connected indicate so */
      break;
      }
   }

if (!k)    /* there is not generator attached, locate a free one and accociate it */
   {

   for (i=0;i<maxrecs;i++)
      {
      if (recs_status[i] == IDLE)
	 {   /* This reciever is idle, assign phones ccb to it */
	 recs_status[i] = ext_status[ext_check]; /* CCB number is path number */
	 k=1;    /* we found one and attached it */

	 break;
	 }
      }
   }


if (k==0)
   {
   /* we have failed indicate so and return */
   return(IDLE);
   }

    else
   {
   if (i==0)
      {
      port=0xC007;    /* point to the second m093b1 (#2) */
      j=0x0A;         /* address path of 1st generator/reciever */
      j=j*0x10;   /* move to most significant nibble */
      j=j+0x08;   /* set bit 3 (0000 1000) means to connect */
      j=j+recs_status[i]; /* control block/path so add it too. */
      *port=j;   /* send the constructed control byte to the xpoint */
      port=0xD006;
      shadow_D006=shadow_D006 & 0xE0;    /* clear the first 5 bits */
      shadow_D006=shadow_D006 | ((tone & 0x1F) | 0x01); /* send tone and not enable */
      *port=shadow_D006;
      shadow_D006=shadow_D006 & enable;    /* send enable */
      *port=shadow_D006;
      }

   if (i==1)
      {
      port=0xC007;    /* point to the second m093b1 (#2) */
      j=0x0C;         /* address path of 2nd generator/reciever */
      j=j*0x10;       /* move to most significant nibble */
      j=j+0x08;       /* set bit 3 (0000 1000) means to connect */
      j=j+recs_status[i]; /* control block/path so add it too. */
      *port=j;        /* send the constructed control byte to the xpoint */
      port=0xC002;
      shadow_C002=shadow_C002 & 0xE0;    /* clear the first 5 bits */
      shadow_C002=shadow_C002 | ((tone & 0x1F) | 0x01); /* send tone and not enable */
      *port=shadow_C002;
      shadow_C002=shadow_C002 & enable;    /* send enable */
      port=0xC002;
      *port=shadow_C002;

      }
		return(recs_status[i]); /* return the associated CCB/ Speech path */

   }

}

char off_hook(station)
char station;
{
/* Check to see if the port pointed to by the global variable
   ext_check is off hook. ext_check is updated by the dispatcher and
   should not be changed by the programmer at any time to ensure
   proper system operation.
   Off_hook should be used to check the current station being serviced
   by the system in its round robbin service sequence.
   if you call this routine with 0xFF then the routine returns
   the status of the port currently under service.
   if you call this routine with a physical port number between 0
   to 16 then you get the status of that station.

*/


char i,j,k;

if (station==0xFF)
   {
   station=ext_check;
   }

j=1;
port=0xD001;

if (station >7)
   {
   port=port+2;
   k=station-8;
   }
else
   {
   k=station;
   }

for (i=1; i <= k;i++)
   {
   j=j+j;            /* j now contains bit to AND against */
   }                 /* port contains port number to READ from */

if (!((*port) & j))   /* Is the phone off hook? */
   {
   /* The phone IS off hook so return a 1 */
   return(1);
   }
else
   {
   /* The phone is NOT off hook so return a 0 */
   return(0);
   }

}

cleanup(void)
{
/* Clean up the call control block associated with the */
/* station. 1) Disconnect all hardware from the associated */
/* speech path. 2) see if any call progress resources assigned */
/* if so clear their control blocks making them idle   */
/* 3) specify that the speech path is now idle         */

unsigned char i,j,k;
ccb=ext_status[ext_check];  /* locate phones ccb/speech path  */

#ifdef DEBUG
printf("Cleanup ccb= %x\n",ccb);
#endif

if (ext_status[ext_check]!=IDLE)  /* is cleanup already performed? lockout ? */
   {
   clear_common();             /* release common controls/ reciever-generator */


   ext_route[ext_check]=0x27;     /* route is dont do anything */
   ext_status[ext_check]=IDLE;    /* unassociate phone with ccb  */

   /* if we are the only phone left on ccb then free if */
   /* otherwise leave ccb busy indication alone         */
   j=0;                        /* start by reseting this byte */
   for (k=0;k<maxstat;k++)          /* search all phones assigned ccb's     */
      {
      if (ext_status[k]==ccb)   /* we dont have a ccb anymore and we */
	 {                     /* found someone who does have the ccb */
	 j=1;                  /* which we did have so its still busy */
#ifdef DEBUG
	 printf("Cleanup found another station using ccb\n");
#endif
	 }
      }
   if (j==0)                  /* noone else had the ccb */
      {
#ifdef DEBUG
      printf("Path %x marked idle by cleanup\n",ccb);
#endif
      ccb_path[ccb]=IDLE;    /* mark the path free for other calls */
      }

   disconnect(ccb);  /* this was erased during editing */
#ifdef DEBUG
   printf("Physical cleanup performed ext %d\n",ext_check);
#endif
   return;              /* dont go further */
   }
#ifdef DEBUG
printf("Control Block cleanup performed ext %d\n",ext_check);
#endif

}

disconnect(path)
char path;
{
unsigned char i,j,k;

if (cross<=12)
   {
   port=0xC006;    /* point to the first m093b1 (#1) */

   if (cross>=6)
      {
      j=cross+2;
      }
   else
      {
      j=cross;
      }

   }

if (cross>12)
   {
   port=0xC007;    /* point to the second m093b1 (#2) */
   if (cross>=19)
      {
      j=(cross-12)+2;
      }
   else
      {
      j=(cross-12);
      }

   }


j=j*0x10;   /* move to most significant nibble */
/* do not set bit 3 (0000 0000) means to disconnect */
j=j+path;   /* path is control block/path so add it too. */
*port=j;    /* send the constructed control byte to the xpoint */
#ifdef DEBUG
printf("DISCONNECT cross:%02x path:%02x port:%02x control word %02x \n"
   ,cross,path,port,j);
#endif


}


connect(path)
char path;
{

unsigned char i,j,k;

if (cross<=12)
   {
   port=0xC006;    /* point to the first m093b1 (#1) */

   if (cross >=6)
      {
      j=cross+2;
      }
   else
      {
      j=cross;
      }

   }

if (cross>12)
   {
   port=0xC007;    /* point to the second m093b1 (#2) */
   if (cross>=19)
      {
      j=(cross-12)+2;
      }
   else
      {
      j=(cross-12);
      }


   }


j=j*0x10;   /* move to most significant nibble */
j=j+0x08;   /* set bit 3 (0000 1000) means to connect */
j=j+path;      /* i is control block/path so add it too. */
*port=j;   /* send the constructed control byte to the xpoint */

#ifdef DEBUG
printf("CONNECT cross:%02 path:%02x port:%02x control word %02x \n"
   ,cross,path,port,j);
#endif
}



INTERRUPT(_TF0_) clock_int_handler()
{
unsigned char *port;    /* use a local variable register in interupt  */
unsigned char i;

clrbit(IE.7);
tens++;
rfreq++;
	if (rfreq==5) rfreq=0;

if (tens==10)
	{
	tens=0;
	hundsec++;

/* update the dast used segment directory */
for (i=0;i<maxrad;i++)
	{
	if ((radm[i] & 0xf0)==0x20)
		{
		*rap[i]=radm[i] & 0x0f; /* place the message number that owns the segment into directory */
		rap[i]++;
		}
	}

if (hundsec==10)
   {
   hundsec=0;
   second++;
   if (second==60)
      {
      second=0;
      minute++;
      if (minute==60)
	 {
	 minute=0;
	 hour++;
	 if (hour==24)
	    {
	    hour=0;
	    }
	 }
      }
   }
	}


if (ring_hv)
   {
   port=0xD007;
   if ((*port & 0x80)==0x00)  /* check for ring trip */
      {
      ring_trip++;       /* if so advance counter */

      }
   else
      {
      ring_trip=0;       /* reset counter probably just */
      /* lots of ringers              */
      }


   port=0xD006;
   if (rfreq>=0 && rfreq<=1)
      {                   /* reset bit 6 set bit 5 */
      shadow_D006=shadow_D006 & 0x1F;  /* clear upper 3 bits */
      shadow_D006=shadow_D006 | 0x20;  /* set bit 5          */
      *port=shadow_D006;
      }
   else if (rfreq>=2 && rfreq<=3)
      {
      shadow_D006=shadow_D006 & 0x1F;  /* clear upper 3 bits */
      shadow_D006=shadow_D006 | 0x40;  /* set bit 6          */
      *port=shadow_D006;
      }


        }
else
   {
   port=0xD006;
   shadow_D006=shadow_D006 | 0x60;  /* set bits 5 and 6 */
   *port=shadow_D006;
   }


if (ring_trip > 3)   /* This is 3/100 of a second */
   {
   ring_hv=0;    /* turn off ring generator coils */
   ring_trip++;

   }


if (ring_trip>20)
   {
   shadow_D006=shadow_D006 | 0x60;  /* set bits 5 and 6 */
   *port=shadow_D006;

   shadow_D000=0x00;    /* open all ringing relays */
   port=0xD000;
   *port=shadow_D000;

   shadow_D002=0x00;
   port=0xD002;
   *port=shadow_D002;

   }




TL0=0;
TH0=0;            /* Reset TH0         */
setbit(IE.7);

}


set_timer_int()
{
/* Setup timer 0 to create an interupt 100 times per second. */

clrbit(TMOD.3); /* Gate=0 in TMOD, indicates internal count of clock */
clrbit(TMOD.2); /* C/T=0 in TMOD, indicating counter mode */
clrbit(TMOD.1); /* M1=0 in TMOD */
setbit(TMOD.0); /* M0=1 in TMOD & M1=0 indicates timer mode 1 */
setbit(IP.1);   /* PT0=0 in IP, indicating timer 0 int. is low prio. */
TL0=0x00;      /* Set TL0 to 31 hex */
TH0=0x00;
setbit(TCON.4); /* TR0=1 in TCON, indicating RUN */
setbit(IE.7);
setbit(IE.1);
}


/* Extention Service Routines       */
f_exhm()
{                   /* Extention Off Hook Monitor */
unsigned char i,j,k;

if (k=off_hook(0xff))   /* Is the phone off hook? */
   {

   if (ext_status[ext_check] == IDLE) /* is phone not assigned to a CCB?*/
      {   /* no ccb assigned, locate a free ccb and assign it */
      for (i=0; i<maxpath; i++)
	 {
#ifdef DEBUG
	 printf("checking ccb_path[%x]=%x \n",i,ccb_path[i]);
#endif
	 if (ccb_path[i] == IDLE)
	    { /* This ccb is idle, assign it to port and assign port to it */
	    ccb_path[i] = BUSY;   /* Mark path busy */

	    ext_status[ext_check] = i; /* Associate extention with CCB */

	    /* Now physicaly connect the phone to the speech path */
	    /* 416aos speech path number is same as call control block number */

	    connect(i);

#ifdef DEBUG
	    printf("Port %x assigned to ccb %x \n",ext_check,i);
#endif
	    break;
	    }
	 }
      }
   /* Phone is assigned to a ccb if it is marked BUSY, now assign a DTMF
   reciever/CPG generator to the same speech path, call control block
   and give dial tone
*/
   if (ext_status[ext_check] != IDLE)
      {
      if ((j=cpg(DIAL))!=IDLE)
	 {

#ifdef DEBUG
	 printf("f_exhm() assigned reciever to ccb %x \n",j);
#endif
	 ext_process[ext_check] = 33; /* Send call to ext dialing monitor */

	 /* Clear call control block enque pointer and ect. */
	 ccb=ext_status[ext_check];
	 ccb_enque[ccb]=0;
	 ccb_acp[ccb]=IDLE;
	 ext_timer[ext_check]=first_digit*50;  /* load first digit timer */
	 ext_route[ext_check]=0x27;            /* preselect first route to #7 */
	 }
      }

    }

}

f_exdm()
{
/* this is the extention dialing monitor */
/* we need to detect touch tones and do something */
/* with them based on the 8XX lookup tables */
unsigned char i,j,k;
ccb=ext_status[ext_check];
if (k=off_hook(0xff))
   {                                   /* Phone is off hook still */
   /* Locate dtmf reciever assigned */

   for (i=0;i<maxrecs;i++)
      {
      if(recs_status[i]==ext_status[ext_check])
	 {
	 if (i==0)
	    {
	    port=0xD007;
	    }
	 else if (i==1)
	    {
	    port=0xC003;
	    }

	 if (ext_process[ext_check]==33)        /* proc 33 = station dialing waiting for a digit */
	    {                                 /* to be pressed           */
	    ext_timer[ext_check]--;                 /* decrement digit/offhook timer */


	    if ((ext_timer[ext_check]==0) && (ext_route[ext_check]==0x27))
	       {                             /* no route selected and timer expired */
	       ext_process[ext_check]=35;    /* give reorder tone while offhook */
	       ext_timer[ext_check]=lock_out*50;   /* setup for lockout */
	       }


	    /* check for a route call after extention interdigit timer has expired */
	    if ((ext_timer[ext_check]==0) & (ext_route[ext_check]>=0)
	       & (ext_route[ext_check]<=0x10))
	       {
	       ext_process[ext_check]=99;
	       clear_common();        /* remove this if we want fake ringback */
#ifdef DEBUG
	       printf("f_exdm changed station process to 99\n");
#endif
	       return;
	       }

	    /* check for an extention call after dialing timer has expired */
	    if ((ext_timer[ext_check]==0) && ((ext_route[ext_check]>0x2F)
	       && (ext_route[ext_check]<0x40)))
	       {
#ifdef DEBUG
	       printf("Extention call placed \n");
#endif
	       /* route is between 0x30 - 0x40 so we have dialed      */
               /* another station on the system. 1st check to see     */
	       /* if the called station is busy                       */

	       /* determine the physical port number             */
	       i=ext_route[ext_check]-0x30;              /* route 0x31 becomes port 0x01 */
	       /* i is now the physical port number */

	       if ((ext_process[i]==1) && (off_hook(i)==0))
		  {
#ifdef DEBUG
		  printf("Destination is idle \n");
#endif
		  /* the port being called is indeed idle     */
		  ext_process[i]=66;                 /* ring the called station  */
		  ext_status[i]=ext_status[ext_check];  /* associate the dest ccb with the source ccb */
		  ext_process[ext_check]=37;               /* we get ringback tone */
		  return;
		  }
	       else
		  {
#ifdef DEBUG
		  printf("Destination is busy \n");
#endif
		  ext_process[ext_check]=38;    /* give busy tone while offhook */
		  ext_timer[ext_check]=lock_out*100;   /* setup for lockout */
		  return;
		  }
	       }





	    if ((j=*port) & 0x10)             /* quiet, qaiting for tones */
	       {
	       if ((j=j & 0x0F)==0x0A) j=0; /* convert 0x0a to 0x00 */

#ifdef DEBUG
	       printf("Digit detected %02x \n",j);
#endif
	       ext_process[ext_check]=34;     /* we hear a tone */

	       /* Store the digit away */
	       if (ccb_enque[ccb] < maxdigits)
		  {
		  ext_timer[ext_check]=inter_digit*50;  /*load interdigit timeout timer */

#ifdef DEBUG
		  printf("ccb_enque[%02x] = %02x ",ccb,
		     ccb_enque[ccb]);
#endif

		  ccb_digits[ccb][ccb_enque[ccb]]=j;


                         ccb_enque[ccb]++;              /* advance the enque pointer */

		  /* remove any tones being supplied */
		  cpg(SILENCE);

		  search(ccb_enque[ccb]);       /* see if what user has dialed matches a route table */
		  /* search routine updates stations route       */

		  }
	       else
		  {
#ifdef DEBUG
		  printf("Max digit collection exceeded.\n");
#endif

		  }

	       }
	    }
	 else if (ext_process[ext_check]==34)     /* waiting for quiet */
	    {
	    if (!(*port & 0x10))                     /* see if we still hear a tone */
	       {
	       ext_process[ext_check]=33;
	       }
	    }
	 else if (ext_process[ext_check]==35)        /* proc 35 = station error occured, reorder tone being played */
	    {                               /* Give reorder tone while offhook */
	    ext_timer[ext_check]--;
	    if (ext_timer[ext_check]==0)      /* dialing time expired do lockout */
	       {
	       cleanup();                     /* Cleanup ? */
	       ext_process[ext_check]=36;     /* lockout station */

	       }


	    if (hundsec & 0x04)                /* 0110 0000            */
	       {                              /* turn tones on        */
	       if (ext_substate[ext_check] != 0)
		  {
		  ext_substate[ext_check]=0;
		  cpg(REORDER);
		  }

	       }
	    else
	       {                              /* turn tones off       */
	       if (ext_substate[ext_check] != 1)
		  {
		  ext_substate[ext_check]=1;
		  cpg(SILENCE);
		  }

	       }

            }
	 else if (ext_process[ext_check]==36)        /* proc 36 = station locked out waiting for onhook */
	    {
	    /* dont do anything , just wait around until on hook */
	    }

	 else if (ext_process[ext_check]==37)
	    {                   /* we give ringback tone wait until station */
	    /* in route goes into conversation mode. we then */
	    /* free up any common controls associated with our */
	    /* CCB (recievers/senders) and go into conversation */
	    /* mode ourselves                                   */

	    if ((second & 0x03)==3)            /* 0000 0011 = 0000 0011 */
	       {                              /* turn tones on        */
	       if (ext_substate[ext_check] != 0)
		  {
		  ext_substate[ext_check]=0;
		  cpg(RING);
		  }
	       }
	    else
	       {                              /* turn tones off       */
	       if (ext_substate[ext_check] != 1)
		  {
		  ext_substate[ext_check]=1;
		  cpg(SILENCE);
		  }
	       }

	    i=ext_route[ext_check]-0x30;        /* point to dest */
	    if (ext_process[i]==98)             /* dest has answered */
	       {
	       clear_common();                 /* release common control */
	       ext_process[ext_check]=98;      /* go into conversation ourselves */

	       }



	    }

	 else if (ext_process[ext_check]==38)   /* do busy tone while offhook  */
	    {

	    ext_timer[ext_check]--;
	    if (ext_timer[ext_check]==0)      /* dialing time expired do lockout */
	       {
	       cleanup();                         /* Cleanup ? */
	       ext_process[ext_check]=36;         /* lockout station */

	       }


	    if (second & 0x01)                /* 0110 0000            */
            {                              /* turn tones on  -busy      */
	       if (ext_substate[ext_check] != 0)
		  {
		  ext_substate[ext_check]=0;
		  cpg(LOBELL);
		  }
	       }
	    else
	       {                              /* turn tones off       */
	       if (ext_substate[ext_check] != 1)
		  {
		  ext_substate[ext_check]=1;
		  cpg(SILENCE);
		  }
	       }

	    }
	 return;           /* we found associated reciever- why continue */
	 }
      }
   }
else
   {   /* Phone is no longer off hook */

   if (ext_route[ext_check]>0x29 & ext_route[ext_check]<0x40)
      {
      i=ext_route[ext_check]-0x30;
      ext_process[i]=67;  /* command destination to exit ringing */
      }
   else if (ext_route[ext_check]>=0 & ext_route[ext_check]<=0x0A)
      {
      for (i=0;i<maxtrnk;i++)
	 {
	 if ((trunk_status[i]==ccb_acp[ccb])
	    & (ccb_acp[ccb] != IDLE))
	    {
	    /* this trunk is accociated */
	    trunk_process[i]=72;
#ifdef DEBUG
	    printf("f_exdm set trunk %02x process to 72 \n",i);
#endif
	    ccb_acp[ccb]=IDLE;
	    break;
	    }

	 }
      }

   cleanup();                                 /* Clean up this call control block */
   ext_process[ext_check]=1;                  /* go back to check for offhook */

   }
}


f_exsm()                /* Extention Signaling Monitor    EXSM */
{
/* for in system calls rings the destination phone */
/* when answered places the phone onto talk path   */
/* transfers control to the extention conversation */
/* monitor                                         */
/* 66 -                                            */
char i,j,k;
ccb=ext_status[ext_check];



if (ext_process[ext_check]==66)
   {
   /* ring this station until answered   */
   /* put this station into conversation */
   /* mode and connect to speech path    */
   /* when answered                      */
   /* remember that the central ringer will */
   /* return all ring relays to normal when */
   /* ringing cycle ring trip is detected   */
   if (ext_timer[ext_check]>5)
      {

      if (off_hook(0xFF))
	 {
	 if (ext_substate[ext_check]!=1)
	    {
	    ring_hv=0;
	    ext_timer[ext_check]=0;
	    ext_substate[ext_check]=1;

	    }
	 else
	    {
	    connect(ccb);
	    ext_process[ext_check]=98;

	    }


	 }
      else
	 {

	 if ((second & 0x03)==3)
	    {                               /* we are in the ringing cycle */
	    if (ext_substate[ext_check] !=2)    /* lets not keep reseting rint_trip */
	       {
	       ring_relay(1);
	       ext_substate[ext_check]=2;
	       ring_hv=1;
	       ring_trip=0;
	       }
	    }

        else
	    {
	    if (ext_substate[ext_check]!=0)
	       {
	       ring_hv=0;
	       ext_timer[ext_check]=0;
	       ext_substate[ext_check]=0;
	       }
	    else
	       {
	       ring_relay(0);
	       }


	    }

	 }
      }
   else
      {
      ext_timer[ext_check]++;

      }


   }

else if (ext_process[ext_check]==67)
   {
   /* exit ringing mode, stop any current */
   /* ringing cycles on the hardware clean */
   /* up any data if necissary and change  */
   /* ext process back to a 1        */
   ring_hv=0;
   ext_process[ext_check]=68;
   ext_timer[ext_check]=0;

   }

else if (ext_process[ext_check]==68)
   {                    /* This is the post ringing debounce cycle */
   ext_timer[ext_check]++;
   if (ext_timer[ext_check]>5)
      {
      ring_relay(0);
      cleanup();
      ext_process[ext_check]=1;
      }
   }
}


f_excm()                /* Extention Conversation Monitor  EXCM */
{
/* checks for onhooks , determines if flash has  */
/* occured, initiates conferencing if so,        */
/* generates smdr records or call pricing ticket */
/* touch tone administration                     */
/* 98 -                                          */



char i,j,k;
ccb=ext_status[ext_check];

if (ext_process[ext_check]==98) /* ext to ext conversation monitor */
   {
   if (!off_hook(0xFF))
      {                       /* station has hung up, clear everything */
      cleanup();
      ext_process[ext_check]=1;    /* go to check for off hook */
      }
   else
      {

      }

   }


else if (ext_process[ext_check]==99)
   {
   if (!off_hook(0xFF))
      {
      /* locate the associated trunk and can it */
      /* check to see if acp is IDLE            */
      /* if so then locate trunk by ccb else    */
      /* locate the trunk by acp                */

      if (ccb_acp[ccb]==IDLE)
	 {     /* trunk is cut throught because we dont have a seperate acp */
	 for (i=0;i<maxtrnk;i++)
	    {
	    if (trunk_status[i]==ext_status[ext_check])
	       {
	       trunk_process[i]=100;
	       break;
	       }
	    }
	 }
      else
	 {    /* acp is not IDLE so there is one assigned */
	 for (i=0;i<maxtrnk;i++)
	    {
	    if (trunk_status[i]==ccb_acp[ccb])
	       {
	       trunk_process[i]=72;
	       ccb_acp[ccb]=IDLE;
	       break;
	       }
	    }
            }

      cleanup();
      ext_process[ext_check]=1;
      }
   }


if (ext_process[ext_check]>=100 && ext_process[ext_check]<=128)
	{
	if (!off_hook(0xFF))
		{
		cleanup();
		ext_process[ext_check]=1;
		return;
		}
	}




if (ext_process[ext_check]==100)  /* enter programming from tt phone */
	{
	ext_substate[ext_check]=2;	/* beep twice to confirm programing entry */
	ext_return[ext_check]=103;	/* after beeping twice goto get register routine */
	ext_process[ext_check]=101; /* goto sound tones routine */
	return;
	}
 
else if (ext_process[ext_check]==101)  /* sound hi bell for short period */
	{
	if (ext_timer[ext_check]==0)
		{
		ext_timer[ext_check]=20;
		cpg(HIBELL);
		ext_process[ext_check]=102;
		}
	else	
		{
		ext_timer[ext_check]--;
		}
	return;
	}

else if (ext_process[ext_check]==102)  /* sound silence for short period */
	{
    if (ext_timer[ext_check]==0)
    	{
    	ext_timer[ext_check]=20;
    	cpg(SILENCE);
    	ext_substate[ext_check]--;
    	if (ext_substate[ext_check]!=0)
    		{
    		ext_process[ext_check]=101;
    		}
    	else
    		{
    		ext_process[ext_check]=ext_return[ext_check];
    		}
    	}
    else
    	{
    	ext_timer[ext_check]--;
    	}
    return;
    }


else if (ext_process[ext_check]==103)
	{
		/* collect a digit to see which maint routine to jump to */
		ccb_enque[ccb]=0x00;	/* reset the digit collection pointer */
		ext_temp[ext_check]=1;	/* collect one digit */
		ext_return[ext_check]=106; /* goto 106 to process it */
		ext_process[ext_check]=104;
		return;
	}

for (i=0;i<maxrecs;i++)
	{
	if (recs_status[i]==ext_status[ext_check])
		{
		if (i==0) port=0xD007;
		else if (i==1) port=0xC003;
		}
	}	/* we have now located the DTMF reciever assigned to this phone */

if (ext_process[ext_check]==104) /* check for a dtmf signal and goto 105 if */
	{                            /* we hear one */
	if ((j=*port) & 0x10)
		{
		if ((j=j & 0x0F)==0x0A) j=0; /* convert 0x0a to 0x00 */
		ext_process[ext_check]=105; 
		if (ccb_enque[ccb]<maxdigits)
			{
			ccb_digits[ccb][ccb_enque[ccb]]=j;
			ccb_enque[ccb]++;
			}
		return;
		}
	}
/* We may want to add an option to return immediate on detection of
   a tone and another option for return after tone stops so that routines
   like the rad record does not record the burst and force the user
   to press a very short keypress for the message to sound good */

if (ext_process[ext_check]==105) /* wait for dtmf signal to go away and return */
	{					         /* to 104 when it does */
	if (! (*port & 0x10))
		{
		ext_temp[ext_check]--; /* reduce by one the number of digits to collect */

		if (ext_temp[ext_check]==0)
			{
			ext_process[ext_check]=ext_return[ext_check]; /* if we have collected */
			}											/* all digits go onto next process */
		else										/* indicated in ext_return  */
			{
			ext_process[ext_check]=104;	/* else continue to collect more digits */
			}
		}
	}

else if (ext_process[ext_check]==106)
	{ /* we have collected one digit now see which maint routine to jump to */
	switch(ccb_digits[ccb][0])
		{
		case 4: ext_process[ext_check]=107;
				break;
		case 1: ext_process[ext_check]=115;
				break;

		default: 
				ext_substate[ext_check]=10;	/* beep 10 times signaling error  */
				ext_return[ext_check]=103;	/* after beeping goto get register routine */
				ext_process[ext_check]=101; /* goto sound tones routine */
		}
	return;
	}

else if (ext_process[ext_check]==107)
	{ /* this is maint option 4 RAD maintenance */
	ext_temp[ext_check]=3; 	/* collect 3 digits */
	ext_return[ext_check]=108;
	ext_process[ext_check]=104;
	return;
	}

else if (ext_process[ext_check]==108)
	{
	switch(ccb_digits[ccb][1])
		{
		case 0: /* this is the record option goto 109 */
				ext_process[ext_check]=109;
				break;
		case 1: /* this is the play option */
				ext_process[ext_check]=112;
				break;
		default: ext_substate[ext_check]=10;	/* signal error */
		         ext_return[ext_check]=103;		/* goto get register routine */
		         ext_process[ext_check]=101;	/* goto sound tones routine */
		}
	return;
	}


else if (ext_process[ext_check]==109)
	{
	/* locate a free RAD */
	for (i=0;i<maxrad;i++)
		{
		if (rads[i]==IDLE) 
			{
			/* now place this free rad on the same speech path as phone */
			rads[i]=ccb;
			if (i==0)
				{
				port=0xC007;		/* point to the second xpoint */
				j=0x09;				/* address of the first RAD  */
				j=j*0x10;			/* move to most significant nibble */
				j=j+0x08;			/* set bit 3 (0000 1000) means connect */
				j=j+ccb;			/* control block/ path to connect to */
				*port=j;			/* sent the constructed control byte to the xpoint */
				break;
				}
			}
		}
	
	/* setup the message number to record here located at digits 2 & 3 */
	/* be sure the message is from 1 to 15				*/
	radm[i]=(ccb_digits[ccb][2]*10)+ccb_digits[ccb][3];
#ifdef DEBUG
	printf("i= %02x  radm[i]= %02x \n",i,radm[i]);
#endif

	if ((radm[i]<1) || (radm[i]>15)) /* if not more than 0 or less than 15 signal error */
		{
		ext_substate[ext_check]=10;	/* signal error */
		ext_return[ext_check]=103;		/* goto get register routine */
		ext_process[ext_check]=101;	/* goto sound tones routine */
		return;
		}
	
	/* scan directory for this message and delete it if it exists */
	for (rap[i]=0xFF00;rap[i]<0xFFFF;rap[i]++)
		{
		if (*rap[i]==(radm[i] & 0x0F)) *rap[i]=0x00;
		}
	
	/* scan directory for the first blank message space */
	for (rap[i]=0xFF00;rap[i]<0xFFFF;rap[i]++)
		{
		if (*rap[i]==0x00) break;
		}

#ifdef DEBUG
	printf("First blank segment *rap[i] set to %04x\n",rap[i]);
#endif 

	/* address the dast to this space */
	if (i==0)
		{
		port=0xD002;
		*port=rap[i]-0xff00;

		}

	ext_substate[ext_check]=1;	/* beep once  */
	ext_return[ext_check]=110 ;	/* after beeping */
	ext_process[ext_check]=101; /* goto sound tones routine */
	
	return;
	}


else if (ext_process[ext_check]==110)
	{ 	/* command dast to begin recording here */

	for (i=0;i<maxrad;i++)
		{
		if (rads[i]==ccb) break;
		}

#ifdef DEBUG
	printf("Dast found %02x\n",i);
#endif

    j=0xFF;
    P1=j;		/* set DAST /CE high */
    
    j=0xFB;
    P1=j;		/* set P/R to low */

	j=0xF9;		
	P1=j;		/* set PD to low */

	j=0xF8;	
	P1=j;		/* set /CE low, this starts recording */

	radm[i]=(radm[i] & 0x0F) | 0x20;	/* set the interupt routine to timing and */
	                        /* writing to directory space */
	


	ext_temp[ext_check]=1;	/* collect one digit to stop recording */
	ext_return[ext_check]=111;  /* 111 is stop recording */
	ext_process[ext_check]=104;	/* collect the digit */
	return;
	}

else if (ext_process[ext_check]==111)
	{
	/* command dast to stop recording here,
	   cleanup the dast message and return to 
	   th programming prompt */

	for (i=0;i<maxrad;i++)
		{
		if (rads[i]==ccb) break;
		}

	radm[i]=radm[i] & 0x0F;	/* set the interupt routine to stop writing */

	j=0xF9;	
	P1=j;		/* dast has stopped recording */

	/* rap[x] now points to the end of the message- re address DAST */
	/* and remove some of the message */

#ifdef DEBUG
	printf("DAST end segment %04x\n",rap[i]);
#endif
	ext_timer[ext_check]=100;	/* delay for dast settling */
	ext_process[ext_check]=114; /* we are going to dispatch to waste a */
							    /* little time for the device to settle */

	return;
	}
	
else if (ext_process[ext_check]==112)
	{
	/* locate the message number to play */
	for (i=0;i<maxrad;i++)
		{
		if (rads[i]==IDLE)
			{
			/* place this rad on the same path as the phone */
			rads[i]=ccb;
			if (i==0)
				{
				port=0xC007;		/* point to the second xpoint */
				j=0x09;				/* address of the first RAD  */
				j=j*0x10;			/* move to most significant nibble */
				j=j+0x08;			/* set bit 3 (0000 1000) means connect */
				j=j+ccb;			/* control block/ path to connect to */
				*port=j;			/* sent the constructed control byte to the xpoint */
				break;
				}
			}
		}
	/* setup the message number to play back */
	radm[i]=(ccb_digits[ccb][2]*10)+ccb_digits[ccb][3];
	/* check to be sure message number is in allowed range */
	if ((radm[i]<1) || (radm[i]>15))
		{
		ext_substate[ext_check]=10;
		ext_return[ext_check]=103;
		ext_process[ext_check]=101;
		return;
		}

	/* scan directory for message starting point */
	for (rap[i]=0xff00;rap[i]<0xffff;rap[i]++)
		{
		if (*rap[i]==(radm[i] & 0x0f)) break;
		}

	/* if message is not in directory then signal error */
	if (rap[i]==0xffff)
		{
		ext_substate[ext_check]=10;
		ext_return[ext_check]=103;
		ext_process[ext_check]=101;
		return;
		}
	
	/* address the dast to the message */
	if (i==0)
		{
		port=0xD002;
		*port=rap[i]-0xff00;
#ifdef DEBUG
	printf("DAST address %04x\n",rap[i]-0xff00);
#endif
		}

	/* start the DAST device playing */
	j=0xFB;
	P1=j;		/* set PD high */

	j=0xF9;	
	P1=j;		/* set PD low now */

	j=0xFD;	
	P1=j;		/* set P/R to high for playback */

	j=0xFC;
	P1=j;		/* set /CE to low */

	j=0xFD;
	P1=j;		/* set /CE to high, this will start playback */

#ifdef DEBUG
	printf("Dast playing message ");
#endif 
	ext_process[ext_check]=113; /* goto wait for end of message */
	return;
	}

else if (ext_process[ext_check]==113)
	{ /* the rad is playing , wait for it to stop */
	/* look to P1 bit 4 to go high, then disconnect the dast */
	/* idle it and exit */

for (i=0;i<maxrad;i++)	/* locate the rad associated with this procedure */
	{
	if (rads[i]==ccb) break;
	}

   if (!(P1 & 0x08))
   	{
#ifdef DEBUG
	printf("Dast finished \n");
#endif 
		
	/* disconnect the rad from our speech path */
			if (i==0)
				{
				port=0xC007;		/* point to the second xpoint */
				j=0x09;				/* address of the first RAD  */
				j=j*0x10;			/* move to most significant nibble */
				
							/* do not set bit 3 (0000 1000) means disconnect */
				j=j+ccb;			/* control block/ path to connect to */
				*port=j;			/* sent the constructed control byte to the xpoint */
				}

    rads[i]=IDLE;	/* release the rad from our service */
	ext_process[ext_check]=100;
	}
	}

else if (ext_process[ext_check]==114)
	{

if (ext_timer[ext_check]>0) /* we need to delay for the dast to settle */
	{
	ext_timer[ext_check]--;
	return;
	}

for (i=0;i<maxrad;i++)	/* locate the rad associated with this procedure */
	{
	if (rads[i]==ccb) break;
	}

	/* disconnect the rad from our speech path */
			if (i==0)
				{
				port=0xC007;		/* point to the second xpoint */
				j=0x09;				/* address of the first RAD  */
				j=j*0x10;			/* move to most significant nibble */
				
							/* do not set bit 3 (0000 1000) means disconnect */
				j=j+ccb;			/* control block/ path to connect to */
				*port=j;			/* sent the constructed control byte to the xpoint */
				}

	/* take a little off of the message 300 ms to be precise */
	rap[i]=rap[i]-8;
	
	/* now re-address the dast at this point */
	if (i==0)
		{
		port=0xD002;
		*port=rap[i]-0xff00;
#ifdef DEBUG
		printf("Dast re-addressed to %04x \n",rap[i]-0xff00);
#endif
		}

	/* now start and immediatly stop recording to make a new eom marker */
    j=0xFF;
    P1=j;		/* set DAST /CE high */
    
    j=0xFB;
    P1=j;		/* set P/R to low */

	j=0xF9;		
	P1=j;		/* set PD to low */

	j=0xF8;	
	P1=j;		/* set /CE low, this starts recording */
	
	j=0xF9;	
	P1=j;		/* dast has stopped recording */

    rads[i]=IDLE;	/* release the rad from our service */

	rap[i]++;		/* go just beyond the end of message */
	*rap[i]=0x00;   /* and adjust the directory to reflect the new eom point */

	ext_process[ext_check]=100;
	return;
		
	}

else if (ext_process[ext_check]==115)
	{ /* this is maint option 1 Trunk Data Maint */
	ext_temp[ext_check]=4;	/* collect 4 digits trunk# and register # */
	ext_return[ext_check]=116;	/* goto process 116 after this */
	ext_process[ext_check]=104;	
	return;
	}

else if (ext_process[ext_check]==116)
	{
	/* beep once */
	ext_substate[ext_check]=1;
	ext_return[ext_check]=117;
	ext_process[ext_check]=101;
	return;
	}
else if (ext_process[ext_check]==117)
	{
	/* collect 2 more digits */
	ext_temp[ext_check]=2;
	ext_return[ext_check]=118;
	ext_process[ext_check]=104;
	return;
	}
else if (ext_process[ext_check]==118)
	{
	/* decode the place to put the information and put it */
	i=(ccb_digits[ccb][1]*10)+ccb_digits[ccb][2]; /* get the trunk */
	j=(ccb_digits[ccb][3]*10)+ccb_digits[ccb][4]; /* get the option */
	k=(ccb_digits[ccb][5]*10)+ccb_digits[ccb][6]; /* get the data */
	tdr[i][j]=k;  /* store the data away */

#ifdef DEBUG
	for (i=0;i<20;i++)
		{
		printf("option %02x tk0: %02x  tk1: %02x tk2: %02x \n",
		        i,tdr[0][i],tdr[1][i],tdr[2][i]);
		}
#endif

	/* go back to programming prompt, it will beep twice confirming */
	ext_process[ext_check]=100;
	return;
	}


} /* end of f_excm() */


/* Misc. Process Related funtions */
init_proc()
{
char i,j,k,x;

ring_hv=0;
ring_trip=3;            /* address ring generator hardware */
message_hv=0;
route_update_next=0;

shadow_D000=0x00;
port=0xD000;
*port=shadow_D000;

shadow_D002=0x00;
port=0xD002;
*port=shadow_D002;

shadow_D004=0x0A;
port=0xD004;
*port=shadow_D004;

shadow_D006=0xF0;		/* this is important to set bit 7 low */
port=0xD006;			/* so that cpdetector is in high gain mode */
*port=shadow_D006;

rads[0]=IDLE;
for (x=0;x<maxstat;x++)      /* init 0 - 15 */
   {
   ext_process[x]=1; /* Check for offhook */
   ext_status[x]=IDLE;
   ext_route[x]=0x27; /* no route selected, dont do anythiing */
   ext_timer[x]=0;
   }
for (x=0;x<maxrecs;x++)
   {
   recs_status[x]=IDLE;
   }

for (x=0;x<maxpath;x++)
   {
   ccb_path[x]=IDLE;
   ccb_acp[x]=IDLE;

   }


}


init_tables()        /* initialize tables   */
{
char x;

for (x=0;x<16;x++)
   {
   table_pointer_begin[x]=0;
   table_pointer_end=0;
   }
}


p_table(length,pointer)    /* Print a single table */
char length;
char *pointer;
{
char x;
length--;
printf("Print single table %d ",length);
for(x=table_pointer_begin[length];
              x<table_pointer_begin[length+1];x++)
   {
   printf("%02x",table_8xx[x]);
   }



}


p_tables()
{
char x;
char y;
for (y=1;y<=15;y++)
   {
   printf("%02x table_pointer_begin[%02x] ",y,table_pointer_begin[y]);

   for(x=table_pointer_begin[y];
                    x<table_pointer_begin[y+1];x++)
      {
      printf("%02x",table_8xx[x]);
      }
   printf("\n");
   }

}


add(length,pointer)
char length;
char *pointer;
{
/* this routine is entered with the exact number of digits to be */
/* processed. i/e if you have entered an 802 table then this     */
/* routine is entered with length=3                */
/* pointer points to the first digit to be processed        */


char x;
char *save;
char i;
#ifdef DEBUG
printf("Add routine %x digits\n",length);
#endif
save=pointer;

/*    for (x=0;x<length;x++)
    {
    i=*pointer;
    pointer++;
#ifdef DEBUG
    printf("%02x",i);
#endif
    }
#ifdef DEBUG
    printf("\n");
#endif
*/
pointer=save;

for (x=table_pointer_begin[length-1]
                 ;x<=table_pointer_end;x++) /* make room in the table for the new entry */
   {
   table_8xx[(table_pointer_end+length)-x]=  /* point to dest */
   table_8xx[table_pointer_end-x];   /* point to source */
   }

for (x=length;x<=16;x++) /* update all the pointers in tables */
   {                 /* larger that were adding to        */
   table_pointer_begin[x]=
   table_pointer_begin[x]+length;
   }

for (x=table_pointer_begin[length-1];x<table_pointer_begin[length-1]
                 +length;x++) /* add in the information */
   {
   table_8xx[x]=*pointer;
   pointer++;
   }

table_pointer_end=table_pointer_end+length;
}

search(length)
char length;
{

char x;
char y;
char i;
char match;
#ifdef DEBUG
printf("Search single table %d\n",length);
#endif

if (length > 15) return;    /* we only search through 15 digits, ignoring all others */

for(x=table_pointer_begin[length]
              ;x<table_pointer_begin[length+1];x=x+length+1)
   {
   match=0;
   for (y=0;y<length;y++)
      {
#ifdef DEBUG
      printf("%02x %02x \n",
	 table_8xx[y+x],ccb_digits[ccb][y]);
#endif

      if (table_8xx[y+x]>0x0b)
	 {    /* search wildcards here */
	 switch(table_8xx[y+x])
	 {
	 case 0x0c:    /* compare against user dialed # */
	    if (ccb_digits[ccb][y]==0x0c)
	       {
	       match=1;
	       }
	    else
	       {
	       match=0;
	       }

	    break;

	 case 0x0d:      /* compare against a user dialed 0 or 1 */
	    if ((ccb_digits[ccb][y]==0x01) |
	       (ccb_digits[ccb][y]==0x00))
	       {
	       match=1;
	       }
	    else
	       {
	       match=0;
	       }
	    break;

	 case 0x0e:      /* compare against any user dialed digit 2-9 */
	    for (i=2;i<=9;i++)
                {
	       if (ccb_digits[ccb][y]==i)
		  {
		  match=1;
		  break;
		  }
	       else
		  {
		  match=0;
		  break;
		  }

	       }
	    break;

	 case 0x0f:      /* compare against anything */
	    match=1;
	    break;

	 }
	 }
      else
	 {  /* search exact match */

	 if (ccb_digits[ccb][y]==table_8xx[y+x])
	    {
	    match=1;
	    }
	 else
	    {
	    match=0;
	    break;
	    }
	 }
      }
   if (match==1)
      {
#ifdef DEBUG
      printf("Match found %x\n",table_8xx[y+x]);
#endif

      if(((table_8xx[y+x]>=0)&(table_8xx[y+x]<=0x10)) |
	 ((table_8xx[y+x]>=0x30) & (table_8xx[y+x]<=0x40)))
	 {
#ifdef DEBUG
	 printf("ext_route updated \n");
#endif
	 ext_route[ext_check]=table_8xx[y+x]; /* update route table */
	 }
      else
	 {
	 /* or change ext process to go to programming  */
	 /* or change ext process to go to speed dial or alarm call */
	 /* or personal speed programming */
	 switch(table_8xx[y+x])
            {
	 case 0x21:    /* deny this call */
	    ext_timer[ext_check]=lock_out*50;
	    ext_route[ext_check]=0x27; /* do nothing */
	    ext_process[ext_check]=35; /* give re-order */
	    break;

	 case 0x24: 	/* go into touch tone programming mode */
		ext_route[ext_check]=0x24;
		ext_process[ext_check]=100;
		ext_timer[ext_check]=0;
	    break;

	 case 0x26:    /* last digit of phone number dialed */
	    if (ext_route[ext_check]!=0x27)
	       {   /* we have a route in process */
	       ext_timer[ext_check]=1;
	       /* extention dialing monitor will update process based on route */

	       }
	    else
	       {  /* no route yes selected and dialing is finished */
	       /* send to re-order tone */
	       ext_timer[ext_check]=lock_out*50;
	       ext_process[ext_check]=35; /* give ro-order */
	       }
	    break;
	 }
	 }
      return; /* exact match found return */
      }

#ifdef DEBUG
   printf("\n");
#endif
   }
}

clear_common()
{

char i,j;


for (i=0;i<maxrecs;i++)
   {
   if (recs_status[i]==ext_status[ext_check])
      {

      if (i==0)
	 {
	 port=0xC007;    /* point to the second m093b1 (#2) */
	 j=0x0A;         /* address path of 1st generator/reciever */
	 j=j*0x10;       /* move to most significant nibble */
	 /* do not set bit 3 (0000 0000) means to disconnect */
	 j=j+recs_status[i]; /* control block/path so add it too. */
	 *port=j;   /* send the constructed control byte to the xpoint */
#ifdef DEBUG
	 printf("CLEANUP reciever 1 control word %x address %x\n",j,port);
#endif
	 }

      if (i==1)
	 {
	 port=0xC007;    /* point to the second m093b1 (#2) */
	 j=0x0C;         /* address path of 2nd generator/reciever */
	 j=j*0x10;       /* move to most significant nibble */
	 /* do not set bit 3 (0000 0000) means to disconnect */
	 j=j+recs_status[i]; /* control block/path so add it too. */
	 *port=j;        /* send the constructed control byte to the xpoint */
	 }

      recs_status[i]=IDLE;
      }
   }

}


debug_display(ch)
char ch;
{
char i,j,k;


printf("\n- Station Debug --   --- CCB ------\n");
printf("PRT PRC STS RTE TMR  PTH ENQ DQE RTE ACP Digits \n");
for (i=0;i<6;i++)
   {
   printf("%02x  %02d  %02x  %02x  %03x  ",
      i, ext_process[i], ext_status[i], ext_route[i], ext_timer[i]);

   for (j=0;j<maxpath;j++)
      {
      /* search all ccb's, looking for associated extention */
      /* ext_status[i] contains assigned ccb              */
      if (ext_status[i]==j)
	 {
	 /* first print the path enq and deq */
	 printf("%02x  %02x  %02x  %02x  %02x  ",ccb_path[j]
	    ,ccb_enque[j],ccb_deque[j],ccb_route[j],
	    ccb_acp[j]);

	 /* print the enqued digits */
	 for (k=0;k<ccb_enque[j];k++)
	    {
	    printf("%x",(ccb_digits[j][k] & 0x0F));

	    }
	 }
      }
   printf("\n");    /* end of line */
   }


printf("Call control block ");
for (i=0;i<maxpath;i++)
   {
   printf("%x=%x  ",i,ccb_path[i]);
   }
printf("\n");
printf("Route process updating ccb %x\n",route_update_next);
printf("Time: %02d:%02d:%02d:%02d \n",hour,minute,second,hundsec);
printf("Trunk_Check %02x  Ext_Check %02x \n",trunk_check,ext_check);

for (i=0;i<maxrad;i++)
	{
	printf("Rad #%02x rap %04x rads %02x radm %02x\n",i,rap[i],rads[i],radm[i]);
	}

printf("End of debug display\n");
}




ring_relay(state)
char state;
{
char i,j,k;

j=1;
port=0xD000;

if (ext_check >7)
   {
   port=port+2;
   k=ext_check-8;
   }
else
   {
   k=ext_check;
   }

for (i=1; i <= k;i++)
   {
   j=j+j;            /* j now contains bit to AND against */
   }                 /* port contains port number to READ from */

if (port==0xD000)
   {
   if (state==1)                  /* we want to set */
      {
      shadow_D000=shadow_D000 | j;
      *port=shadow_D000;
      }
   else
      {            /* we want to reset */
      j=0xFF-j;
      shadow_D000=shadow_D000 & j;
      *port=shadow_D000;
      }
   }
else if (port==0xD002)
   {
   if (state==1)                  /* we want to set */
      {
      shadow_D002=shadow_D002 | j;
      *port=shadow_D002;
      }
   else
      {            /* we want to reset */
      j=0xFF-j;
      shadow_D002=shadow_D002 & j;
      *port=shadow_D002;
      }
   }


}

do_route()
{
/* This process runs once after all the extention's have */
/* been processed. When it runs it processes one active ccb */
/* and then returns. So if four ccb's are active it takes four */
/* trips around to update them all.                */
char i,j,k;

route_update_next++;

if (route_update_next==maxpath+1)
   {
   route_update_next=0;
   }


/* search for a active ccb */
if (ccb_path[route_update_next]!=IDLE)
   {                   /* we found active ccb         */
   for (j=0;j<maxstat;j++)        /* now locate the phone assigned to this ccb */
      {
      if (ext_status[j]==route_update_next)
	 {        /* this is the extention */
	 if (ext_route[j]!=ccb_route[route_update_next])
	    {    /* routes dont match so cancel the current */
	    /* route and activate the route specified in ext_route */
	    /* then update ccb_route                   */

	    /* search for and cancel the associated trunk */
	    if (ccb_acp[route_update_next]!=IDLE)
	       {
	       for (i=0;i<maxtrnk;i++)
		  {
		  if (ccb_acp[route_update_next]==trunk_status[i])
		     {    /* we found the associated trunk*/
#ifdef DEBUG
		     printf("trunk %02x process canceled \n",i);
#endif
		     ccb_acp[route_update_next]=IDLE;
		     trunk_process[i]=72;    /* change process to cancel */
		     return;
		     }
		  }
	       }

	    /* now locate a free trunk and set it to work */
	    /* locate a trunk in the routes acs register 6 */
	    if (ext_route[j]>=0 & ext_route[j]<=0x0C)
	       {

	       for (i=0;i<16;i++)
		  {
		  k=acs[((ext_route[j]-1)*7)+6][i];     /* k points to trunks in acs */
#ifdef DEBUG
		  printf("do route looking at trunk %02x process=%02x \n",k,trunk_process[k]);
#endif

		  if (k==0xFF) break;     /* end of list, check again later */

		  if (trunk_process[k] == 1)
		     {
		     /* this trunk is not busy */
#ifdef DEBUG
		     printf("route activated %02x \n",k);
#endif
		     trunk_status[k]=route_update_next;    /* associate ccb */
		     trunk_process[k]=65;
		     ccb_route[route_update_next]=ext_route[j];
		     /* update the route */
		     break;
		     }

		  }
	       }
	    else
	       {
	       ccb_route[route_update_next]=ext_route[j];

	       }

	    }
	 return;
	 }
      }
   }
}

acs_add(rte,reg,che)
unsigned char rte;
unsigned char reg;
unsigned char *che;
{
unsigned char i,j,k;

i=0;
while (*(che-1) != 0xFF)
   {
   acs[((rte-1)*7)+reg][i]=*che;
#ifdef DEBUG
   printf("%02x",*che);
#endif

   i++;
   che++;

   }

#ifdef DEBUG
printf(" \n");
#endif



}


defx() /* default volatile database */
{
unsigned char i,j;

printf("Default data loaded\n");

/* clear misc data memory */
for (port=0xFF00;port<0xFFFF;port++)
	{
	*port=0x00;
	}

/* set up default route tables */
init_tables();

add(4,"\x09\x05\x00\x01");  /* send 950 to route 1 */
add(4,"\x0F\x0F\x0C\x26");  /* #9 #9 # end of dialing */
add(3,"\x0C\x0C\x24");   /* ## programming security code  */
add(3,"\x04\x00\x30");   /* ext 40 route to port 10       */
add(3,"\x04\x01\x31");   /* ext 41 route to port 11       */
add(3,"\x04\x02\x32");	 /* ext 42 route to port 12		  */
add(3,"\x04\x03\x33");	 /* ext 43 route to port 13       */
add(2,"\x03\x01");       /* send 3 anything to route 1    */
add(2,"\x06\x01");       /* send 6 anything to route 1 also */
add(2,"\x02\x01");		 /* send 2 anything to route 1 */
add(2,"\x07\x01");		 /* send 7 anything to route 1 */
add(2,"\x05\x04");		/* send 5 anything to route 4 */
add(2,"\x08\x21");    /* deny 8 anything calls */
add(2,"\x00\x02");    /* 0 anything to route 2 */
add(2,"\x01\x03");    /* 1 anything to route 3 */


/* Clear all route registers - Routes 1-X Registers 1-X */
for (i=0;i<total_routes;i++)    /* store 0xff in all route registers */
   {
   for (j=0;j<registers_per_route;j++)
      {
      acs[(i*7)+j][0]=0xFF;
      }
   }



}


main()
{
char ch;                      /* debug get character routine */
#ifdef DEBUG
unsigned int rtlp;
unsigned int dtime;
unsigned int last;
unsigned int augd;
unsigned int rtp;
rtlp=dtime=last=augd=rtp=0;
#endif
tens=hour=minute=second=hundsec=0;   /* Initialize time variables  */

init_proc();
set_timer_int();            /* Set up and start interupts */
ext_check=0;



#ifdef DEBUG
printf("DEBUG MODE.\n");
#else
printf("(c)1992 Richard Newman\n");
#endif

while (TRUE)
   {
   /* debug display code */
   if (ch=chkch())
      {
      /* key was pressed, check what to do  */
	   switch(ch)
	   		{
	   		case 'd':
            debug_display(ch);
			break;

		    case 'c':
		    check_sum(ch);
		    break;

			case 'n':
			defx();
			break;

#ifdef DEBUG
			case 'r':
			if (rtdisp==0)
				{
				rtdisp=1;
				printf("Processor load display on.\n");
				}
			else
				{
				rtdisp=0;
				printf("Processor load display off.\n");
				}
			break;
#endif

 			}
      }

#ifdef DEBUG
    /* this display gives an estamation of the realtime being consumed */
	if (rtdisp==1)
		{
		rtlp++;
		if (rtlp==100)
			{
			rtlp=0;
		dtime=((second*100)+hundsec)-last; /* compute time from last dispatch */

		last=(second*100)+hundsec;
			

	    rtp++;
	    if (rtp==20)
	    	{
			printf("LOAD --> %04x\n",dtime);
			rtp=0;
			}
			}

		}

#endif 

/* dispatch extentions */
   ext_check=0;
   do 
      {
	 cross=ext_check;    /* so we know which port to connect to */
	 if (ext_process[ext_check] >= 0 && ext_process[ext_check] <=32) f_exhm();
	 else if (ext_process[ext_check] >= 33 && ext_process[ext_check] <=64) f_exdm();
	 else if (ext_process[ext_check] >= 65 && ext_process[ext_check] <=96) f_exsm();
	 else if (ext_process[ext_check] >= 97 && ext_process[ext_check] <=128) f_excm();

	    ext_check++;      /* Point to next extention equipt. to service */
      }
      while (ext_check < maxstat);	/* Process from 0-15 */
	
	do_route();   				/* Now update routes */

   }
}

check_sum(ch)
char ch;
{
int *l;
int k;
char *m;



printf("Regs: SP: %02x \n",SP);

l=0x0008;        /* point to external stack pointer */
printf("External Stack Pointer: %04x \n",*l);

/* Perform checksum of CODE space */
k=0;		/* start the checksum at 0 */
printf("CODE Checksum running... ");
for (m=0x2000;m<0xBFFF;m++)
	{
	k = k + *m;
	}
printf("%04x\n",k);
}