;Alto->8086 small-c compiler rev 2.0
C_CODE SEGMENT

$INCLUDE(8086LIB.D)

$INCLUDE(Analog.DEC)

ASSUME CS:C_CODE, DS:C_DATA

; #include	"Env.h"

; extern PIOOn();

; extern PIOOff();

; extern SetPIO();

; extern GetPIO();

; extern SetCodec();

; extern ReadIRR();

; extern EnableInt();

; extern StoreW();

; extern OutByte();

; int inAn;

; char xBarState[8];

; extern /* FORWARD */ myAlDInt();

; InitAnalog()
_InitAnalog:
PUSH BP
MOV BP,SP

;   {

;   int row, col;
ADD SP,0FFFCX

;   OutByte(apioctl, 0x0088);
MOV BX,088X
MOV CX,070X
CALL _OutByte

;   SetPIO(0x00c0, iapioa);  /* both relays OFF */
MOV BX,3
MOV CX,0C0X
CALL _SetPIO

;   SetPIO(0x0000, iapiob);
MOV BX,4
XOR CX,CX
CALL _SetPIO

;   SetPIO(0x000c, iapioc);  /* no ring or sidetone */
MOV BX,5
MOV CX,0CX
CALL _SetPIO

;   SetPIO(0x00e1, ipioa);  /* LED Off */
XOR BX,BX
MOV CX,0E1X
CALL _SetPIO

;   SetPIO(0x0000, ipiob);  /* Host ID really */
MOV BX,1
XOR CX,CX
CALL _SetPIO

;   SetPIO(0x0030, ipioc);  /* both relays off */
MOV BX,2
MOV CX,030X
CALL _SetPIO

;   SetCodec(0x0c);   /* timeslot 13 */
MOV BX,0CX
CALL _SetCodec

;   ResetAnalogInt();
CALL _ResetAnalogInt

;   myAlDInt();		/* get it set correctly on initialization */
CALL _myAlDInt

;   XbarClear();
CALL _XbarClear

;   EnableInt(&myAlDInt, AlDTyp);
MOV BX,7
MOV CX,OFFSET _myAlDInt
CALL _EnableInt

;   };
MOV SP,BP
POP BP
RET;

; myAlDInt()
_myAlDInt:
PUSH BP
MOV BP,SP

;   {

;   inAn = 0;
MOV _inAn,0

;   for (;;) {
X1:

;     PIOOff(0x000f, iapioa);
MOV BX,3
MOV CX,0FX
CALL _PIOOff

;     PIOOn(inAn, iapioa);
MOV BX,3
MOV CX,_inAn
CALL _PIOOn

;     ResetAnalogInt();
CALL _ResetAnalogInt

;     if ((ReadIRR() & 0x0080) == 0) break;
CALL _ReadIRR
AND BX,080X
OR BX,BX
JNZ X3
JR X2
X3:

;     inAn += 1;
INC _inAn

;     if (inAn == 16) inAn = 0;
MOV BX,_inAn
CMP BX,010X
JNZ X4
MOV _inAn,0
X4:

;     };
JR X1
X2:

;   return(true);
MOV BX,0FFFFX
MOV SP,BP
POP BP
RET;

;   };

; SetXbar(row, col)
_SetXbar:

;   int row, col;
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   int r;

;   if (row == 4) {
PUSH DX

;	BX _ _row
MOV BX,[BP-2]
CMP BX,4
JNZ X5

;     for (r = 0; r < 8; r += 1) xbarcom(r, col, false);
MOV WORD PTR [BP-6],0
X8:

;	BX _ _r
POP BX
PUSH BX
CMP BX,8
JGE X7
JR X6
X9:
INC WORD PTR [BP-6]
JR X8
X6:

;	BX _ _r
POP BX
PUSH BX
PUSH BX
XOR BX,BX

;	CX _ _col
MOV CX,[BP-4]
CALL _xbarcom
POP DX
JR X9
X7:

;     };

;   else {
JR X10
X5:

;     if (xBarState[col] & 0x10) xbarcom(4, col, false);

;	BX _ _col
MOV BX,[BP-4]
LEA CX,_xBarState
ADD BX,CX
MOV AL,[BX]
AND AL,010X
OR AL,AL
JZ X11
MOV BX,4
PUSH BX
XOR BX,BX

;	CX _ _col
MOV CX,[BP-4]
CALL _xbarcom
POP DX
X11:

;     };
X10:

;   xbarcom(row, col, true);

;	BX _ _row
MOV BX,[BP-2]
PUSH BX
MOV BX,0FFFFX

;	CX _ _col
MOV CX,[BP-4]
CALL _xbarcom
POP DX

;   };
MOV SP,BP
POP BP
RET;

; ClearXbar(row, col)
_ClearXbar:

;   int row, col;
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   xbarcom(row, col, false);

;	BX _ _row
MOV BX,[BP-2]
PUSH BX
XOR BX,BX

;	CX _ _col
MOV CX,[BP-4]
CALL _xbarcom
POP DX

;   if (xBarState[col] == 0) xbarcom(4, col, true);

;	BX _ _col
POP BX
PUSH BX
LEA CX,_xBarState
ADD BX,CX
MOV AL,[BX]
OR AL,AL
JNZ X12
MOV BX,4
PUSH BX
MOV BX,0FFFFX

;	CX _ _col
MOV CX,[BP-4]
CALL _xbarcom
POP DX
X12:

;   };
MOV SP,BP
POP BP
RET;

; static xbarcom(row, col, on)
_xbarcom:

;   int row, col, on;
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   int data, clock, shift;

;   if (on) {
ADD SP,0FFFAX

;	BX _ _on
MOV BX,[BP-4]
OR BX,BX
JZ X13

;     PIOOn(SwData, iapioc);
MOV BX,5
MOV CX,1
CALL _PIOOn

;     xBarState[col] |= (1 << row);

;	BX _ _col
MOV BX,[BP-2]
LEA CX,_xBarState
ADD BX,CX

;	CX _ _row
MOV CX,[BP+4]
MOV AX,1
SAL AX,CX
OR [BX],AL

;     };

;   else {
JR X14
X13:

;     PIOOff(SwData, iapioc);
MOV BX,5
MOV CX,1
CALL _PIOOff

;     xBarState[col] &= ((1 << row) ^ 0xff);

;	BX _ _col
MOV BX,[BP-2]
LEA CX,_xBarState
ADD BX,CX

;	CX _ _row
MOV CX,[BP+4]
MOV AX,1
SAL AX,CX
PUSH BX
MOV BX,AX
XOR BX,0FFX
MOV CX,BX
POP BX
AND [BX],CL

;     };
X14:

;   data = (col & 3) | ((row & 3) << 2);

;	BX _ _col
MOV BX,[BP-2]
AND BX,3
PUSH BX

;	BX _ _row
MOV BX,[BP+4]
AND BX,3
MOV CX,2
SAL BX,CX
POP CX
OR CX,BX

;	_data _ CX
MOV [BP-6],CX

;   if (row < 4) shift = 0;

;	BX _ _row
MOV BX,[BP+4]
CMP BX,4
JGE X15
MOV WORD PTR [BP-10],0

;   else shift = 1;
JR X16
X15:
MOV WORD PTR [BP-10],1
X16:

;   if (col >= 4) shift += 2;

;	BX _ _col
MOV BX,[BP-2]
CMP BX,4
JL X17
ADD WORD PTR [BP-10],2
X17:

;   clock = (SwStb0 << shift);

;	CX _ _shift
POP CX
PUSH CX
MOV BX,010X
SAL BX,CX

;	_clock _ BX
MOV [BP-8],BX

;   SetPIO(data, iapiob);
MOV BX,4

;	CX _ _data
MOV CX,[BP-6]
CALL _SetPIO

;   SetPIO(clock + data, iapiob);

;	BX _ _data
MOV BX,[BP-6]

;	CX _ _clock
MOV CX,[BP-8]
ADD CX,BX
MOV BX,4
CALL _SetPIO

;   SetPIO(data, iapiob);
MOV BX,4

;	CX _ _data
MOV CX,[BP-6]
CALL _SetPIO

;   };
MOV SP,BP
POP BP
RET;

; Revert(active)
_Revert:

;   int active;
PUSH BP
MOV BP,SP
PUSH BX

;   {

;   if (active) PIOOn(0x0080, iapioa);

;	BX _ _active
POP BX
PUSH BX
OR BX,BX
JZ X18
MOV BX,3
MOV CX,080X
CALL _PIOOn

;   else PIOOff(0x0080, iapioa);
JR X19
X18:
MOV BX,3
MOV CX,080X
CALL _PIOOff
X19:

;   };
MOV SP,BP
POP BP
RET;

; GoOffHook(active)
_GoOffHook:

;   int active;
PUSH BP
MOV BP,SP
PUSH BX

;   {

;   if (active) PIOOff(0x0040, iapioa);

;	BX _ _active
POP BX
PUSH BX
OR BX,BX
JZ X20
MOV BX,3
MOV CX,040X
CALL _PIOOff

;   else PIOOn(0x0040, iapioa);
JR X21
X20:
MOV BX,3
MOV CX,040X
CALL _PIOOn
X21:

;   };
MOV SP,BP
POP BP
RET;

; ARelay(active)
_ARelay:

;   int active;
PUSH BP
MOV BP,SP
PUSH BX

;   {

;   if (active) PIOOff(0x0010, ipioc);

;	BX _ _active
POP BX
PUSH BX
OR BX,BX
JZ X22
MOV BX,2
MOV CX,010X
CALL _PIOOff

;   else PIOOn(0x0010, ipioc);
JR X23
X22:
MOV BX,2
MOV CX,010X
CALL _PIOOn
X23:

;   };
MOV SP,BP
POP BP
RET;

; RevertHS(active)
_RevertHS:

;   int active;
PUSH BP
MOV BP,SP
PUSH BX

;   {

;   if (active) PIOOn(0x0020, ipioc);

;	BX _ _active
POP BX
PUSH BX
OR BX,BX
JZ X24
MOV BX,2
MOV CX,020X
CALL _PIOOn

;   else PIOOff(0x0020, ipioc);
JR X25
X24:
MOV BX,2
MOV CX,020X
CALL _PIOOff
X25:

;   };
MOV SP,BP
POP BP
RET;

; SideTone(active)
_SideTone:

;   int active;
PUSH BP
MOV BP,SP
PUSH BX

;   {

;   if (active) PIOOff(0x0004, iapioc);

;	BX _ _active
POP BX
PUSH BX
OR BX,BX
JZ X26
MOV BX,5
MOV CX,4
CALL _PIOOff

;   else PIOOn(0x0004, iapioc);
JR X27
X26:
MOV BX,5
MOV CX,4
CALL _PIOOn
X27:

;   };
MOV SP,BP
POP BP
RET;

; RingEnable(active)
_RingEnable:

;   int active;
PUSH BP
MOV BP,SP
PUSH BX

;   {

;   if (active) PIOOff(0x0008, iapioc);

;	BX _ _active
POP BX
PUSH BX
OR BX,BX
JZ X28
MOV BX,5
MOV CX,8
CALL _PIOOff

;   else PIOOn(0x0008, iapioc);
JR X29
X28:
MOV BX,5
MOV CX,8
CALL _PIOOn
X29:

;   };
MOV SP,BP
POP BP
RET;

; int GetDTMF()
_GetDTMF:
PUSH BP
MOV BP,SP

;   {

;   int i, digit;

;   if (!(inAn & AIDTMF)) return(0);
ADD SP,0FFFCX
MOV BX,_inAn
AND BX,1
OR BX,BX
JNZ X30
XOR BX,BX
MOV SP,BP
POP BP
RET;
X30:

;   i = GetPIO(iapioc) >> 4;
MOV BX,5
CALL _GetPIO
MOV CX,4
SHR BX,CX

;	_i _ BX
MOV [BP-2],BX

;   if ((i > 0) && (i < 10)) digit = i + '0';

;	BX _ _i
MOV BX,[BP-2]
CMP BX,0
JLE X32

;	BX _ _i
MOV BX,[BP-2]
CMP BX,0AX
JGE X32
MOV AL,1
JR X33
X32:
XOR AL,AL
X33:
OR AL,AL
JZ X31

;	BX _ _i
MOV BX,[BP-2]
ADD BX,030X

;	_digit _ BX
POP DX
PUSH BX

;   else switch (i) {
JR X34
X31:

;	BX _ _i
MOV BX,[BP-2]
JR X35

;     case 0: digit = 'd'; break;
X37:
MOV WORD PTR [BP-4],064X
JR X36

;     case 10: digit = '0'; break;
X38:
MOV WORD PTR [BP-4],030X
JR X36

;     case 11: digit = '*'; break;
X39:
MOV WORD PTR [BP-4],02AX
JR X36

;     case 12: digit = '#'; break;
X40:
MOV WORD PTR [BP-4],023X
JR X36

;     case 13: digit = 'a'; break;
X41:
MOV WORD PTR [BP-4],061X
JR X36

;     case 14: digit = 'b'; break;
X42:
MOV WORD PTR [BP-4],062X
JR X36

;     case 15: digit = 'c'; break;
X43:
MOV WORD PTR [BP-4],063X
JR X36

;     default: digit = 0;
X44:
MOV WORD PTR [BP-4],0

;     };
JR X36
X35:
MOV AL,BH
OR AL,AL
JNZ X44
MOV AL,BL
CMP AL,0
JZ X37
CMP AL,0AX
JZ X38
CMP AL,0BX
JZ X39
CMP AL,0CX
JZ X40
CMP AL,0DX
JZ X41
CMP AL,0EX
JZ X42
CMP AL,0FX
JZ X43
JR X44
X36:
X34:

;   return(digit);

;	BX _ _digit
POP BX
PUSH BX
MOV SP,BP
POP BP
RET;

;   };

; int ScanIn()
_ScanIn:
PUSH BP
MOV BP,SP

;   {

;   return(inAn);
MOV BX,_inAn
MOV SP,BP
POP BP
RET;

;   };

; ResetAnalogInt()
_ResetAnalogInt:
PUSH BP
MOV BP,SP

;   {

;   PIOOff(0x0080, ipioa);
XOR BX,BX
MOV CX,080X
CALL _PIOOff

;   PIOOn(0x0080, ipioa);
XOR BX,BX
MOV CX,080X
CALL _PIOOn

;   };
MOV SP,BP
POP BP
RET;

; Led(active)
_Led:

;   int active;
PUSH BP
MOV BP,SP
PUSH BX

;   {

;   if (active) PIOOff(0x0040, ipioa);

;	BX _ _active
POP BX
PUSH BX
OR BX,BX
JZ X45
XOR BX,BX
MOV CX,040X
CALL _PIOOff

;   else PIOOn(0x0040, ipioa);
JR X46
X45:
XOR BX,BX
MOV CX,040X
CALL _PIOOn
X46:

;   };
MOV SP,BP
POP BP
RET;

; KickWDT()
_KickWDT:
PUSH BP
MOV BP,SP

;   {

;   PIOOn(0x0008, ipioa);
XOR BX,BX
MOV CX,8
CALL _PIOOn

;   PIOOff(0x0008, ipioa);
XOR BX,BX
MOV CX,8
CALL _PIOOff

;   };
MOV SP,BP
POP BP
RET;

; ResetEncInt()
_ResetEncInt:
PUSH BP
MOV BP,SP

;   {

;   PIOOff(0x0001, ipioa);
XOR BX,BX
MOV CX,1
CALL _PIOOff

;   PIOOn(0x0001, ipioa);
XOR BX,BX
MOV CX,1
CALL _PIOOn

;   };
MOV SP,BP
POP BP
RET;

; StartSlave(prog, length)
_StartSlave:

;   int prog, length;
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   int i;
PUSH DX

;   StoreW(prog, CodeLoc);
MOV BX,0D9FCX

;	CX _ _prog
MOV CX,[BP-2]
CALL _StoreW

;   StoreW(length, CodeLen);
MOV BX,0D9FEX

;	CX _ _length
MOV CX,[BP-4]
CALL _StoreW

;   PIOOn(0x20, ipioa);
XOR BX,BX
MOV CX,020X
CALL _PIOOn

;   for (i=0; i< 20; i+= 1);
MOV WORD PTR [BP-6],0
X49:

;	BX _ _i
POP BX
PUSH BX
CMP BX,014X
JGE X48
JR X47
X50:
INC WORD PTR [BP-6]
JR X49
X47:
JR X50
X48:

;   OutByte(dmamode, 0xc0);
MOV BX,0C0X
MOV CX,01BX
CALL _OutByte

;   OutByte(dmasmsk, 0x00);
XOR BX,BX
MOV CX,01AX
CALL _OutByte

;   PIOOff(0x20, ipioa);
XOR BX,BX
MOV CX,020X
CALL _PIOOff

;   for (i=0; i< 20; i+= 1);
MOV WORD PTR [BP-6],0
X53:

;	BX _ _i
POP BX
PUSH BX
CMP BX,014X
JGE X52
JR X51
X54:
INC WORD PTR [BP-6]
JR X53
X51:
JR X54
X52:

;   if (prog != 0) {

;	BX _ _prog
MOV BX,[BP-2]
OR BX,BX
JZ X55

;     PIOOff(0x10, ipioa);
XOR BX,BX
MOV CX,010X
CALL _PIOOff

;     PIOOn(0x10, ipioa);
XOR BX,BX
MOV CX,010X
CALL _PIOOn

;     PIOOff(0x10, ipioa);
XOR BX,BX
MOV CX,010X
CALL _PIOOff

;     };
X55:

;   };
MOV SP,BP
POP BP
RET;

; SetIngain(ch, gain)
_SetIngain:

;   int ch, gain;
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   int v;

;   switch (gain) {
PUSH DX

;	BX _ _gain
MOV BX,[BP-4]
JR X56

;     case 0: v = InTab00; break;
X58:
MOV WORD PTR [BP-6],0FA00X
JR X57

;     case 1: v = InTab05; break;
X59:
MOV WORD PTR [BP-6],0FB00X
JR X57

;     case 2: v = InTab10; break;
X60:
MOV WORD PTR [BP-6],0FC00X
JR X57

;     case 3: v = InTab15; break;
X61:
MOV WORD PTR [BP-6],0FD00X
JR X57

;     case 4: v = InTab20; break;
X62:
MOV WORD PTR [BP-6],0FE00X
JR X57

;     default: v = InTab00;
X63:
MOV WORD PTR [BP-6],0FA00X

;     };
JR X57
X56:
MOV AL,BH
OR AL,AL
JNZ X63
MOV AL,BL
CMP AL,0
JZ X58
CMP AL,1
JZ X59
CMP AL,2
JZ X60
CMP AL,3
JZ X61
CMP AL,4
JZ X62
JR X63
X57:

;   if (ch & 1) StoreW(v, In1Gain);

;	BX _ _ch
MOV BX,[BP-2]
AND BX,1
OR BX,BX
JZ X64
MOV BX,0D9F2X

;	CX _ _v
POP CX
PUSH CX
CALL _StoreW
X64:

;   if (ch & 2) StoreW(v, In2Gain);

;	BX _ _ch
MOV BX,[BP-2]
AND BX,2
OR BX,BX
JZ X65
MOV BX,0D9F0X

;	CX _ _v
POP CX
PUSH CX
CALL _StoreW
X65:

;   };
MOV SP,BP
POP BP
RET;

; SetOutgain(gain)
_SetOutgain:

;   int gain;
PUSH BP
MOV BP,SP
PUSH BX

;   {

;   int v;

;   switch (gain) {
PUSH DX

;	BX _ _gain
MOV BX,[BP-2]
JR X66

;     case 0: v = OutTab00; break;
X68:
MOV WORD PTR [BP-4],0EA00X
JR X67

;     case 1: v = OutTab03; break;
X69:
MOV WORD PTR [BP-4],0EC00X
JR X67

;     case 2: v = OutTab06; break;
X70:
MOV WORD PTR [BP-4],0EE00X
JR X67

;     default: v = OutTab00;
X71:
MOV WORD PTR [BP-4],0EA00X

;     };
JR X67
X66:
MOV AL,BH
OR AL,AL
JNZ X71
MOV AL,BL
CMP AL,0
JZ X68
CMP AL,1
JZ X69
CMP AL,2
JZ X70
JR X71
X67:

;   StoreW(v, OutGain);
MOV BX,0D9F4X

;	CX _ _v
POP CX
PUSH CX
CALL _StoreW

;   };
MOV SP,BP
POP BP
RET;

; XbarClear()
_XbarClear:
PUSH BP
MOV BP,SP

;   {

;   int row, col;

;   for (col = 0; col < 8; col += 1) {
ADD SP,0FFFCX
MOV WORD PTR [BP-4],0
X74:

;	BX _ _col
POP BX
PUSH BX
CMP BX,8
JGE X73
JR X72
X75:
INC WORD PTR [BP-4]
JR X74
X72:

;     for (row = 0; row < 8; row += 1) xbarcom(row, col, false);
MOV WORD PTR [BP-2],0
X78:

;	BX _ _row
MOV BX,[BP-2]
CMP BX,8
JGE X77
JR X76
X79:
INC WORD PTR [BP-2]
JR X78
X76:

;	BX _ _row
MOV BX,[BP-2]
PUSH BX
XOR BX,BX

;	CX _ _col
MOV CX,[BP-4]
CALL _xbarcom
POP DX
JR X79
X77:

;     xbarcom(4, col, true);
MOV BX,4
PUSH BX
MOV BX,0FFFFX

;	CX _ _col
MOV CX,[BP-4]
CALL _xbarcom
POP DX

;     };
JR X75
X73:

;   };
MOV SP,BP
POP BP
RET;

; int GetBootSwitches()
_GetBootSwitches:
PUSH BP
MOV BP,SP

;   {

;   int i;
PUSH DX

;   i = (GetPIO(ipiob) >> 6) & 3;
MOV BX,1
CALL _GetPIO
MOV CX,6
SHR BX,CX
AND BX,3

;	_i _ BX
POP DX
PUSH BX

;   return (i + (GetPIO(ipioc) & 4));
MOV BX,2
CALL _GetPIO
AND BX,4

;	CX _ _i
POP CX
PUSH CX
ADD CX,BX
MOV BX,CX
MOV SP,BP
POP BP
RET;

;   };

; char *GetXBarState()
_GetXBarState:
PUSH BP
MOV BP,SP

;   {

;   return (xBarState);
LEA BX,_xBarState
MOV SP,BP
POP BP
RET;

;   };

; Externals Declared Here
PUBLIC _inAn
PUBLIC _xBarState
PUBLIC _myAlDInt
PUBLIC _InitAnalog
PUBLIC _ResetAnalogInt
PUBLIC _XbarClear
PUBLIC _SetXbar
PUBLIC _ClearXbar
PUBLIC _Revert
PUBLIC _GoOffHook
PUBLIC _ARelay
PUBLIC _RevertHS
PUBLIC _SideTone
PUBLIC _RingEnable
PUBLIC _GetDTMF
PUBLIC _ScanIn
PUBLIC _Led
PUBLIC _KickWDT
PUBLIC _ResetEncInt
PUBLIC _StartSlave
PUBLIC _SetIngain
PUBLIC _SetOutgain
PUBLIC _GetBootSwitches
PUBLIC _GetXBarState

C_CODE ENDS

; Number of Bytes of Code = 05B2X, (1458)