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

$INCLUDE(8086LIB.D)

$INCLUDE(DI8274.DEC)

ASSUME CS:C_CODE, DS:C_DATA

; #include	"ec.h"

; extern Block();

; extern EnableInt();

; extern CallDebugger();

; extern InitRingBuffer();

; extern WriteRingBuffer();

; extern RingBufferEmpty();

; extern ReadRingBuffer();

; extern OutByte();

; extern InByte();

; extern /* FORWARD */ mySIOInt();

; static struct CBuf rb[2];

; static struct CBuf tb[2];

; static int busy[2];

; Init8274()
_Init8274:
PUSH BP
MOV BP,SP

;   {

;   FlushInput(0);
XOR BX,BX
CALL _FlushInput

;   FlushInput(1);
MOV BX,1
CALL _FlushInput

;   InitRingBuffer(&tb[0], tb[0].abuf, CBS-2);
LEA BX,_tb
PUSH BX
MOV BX,03EX
LEA CX,_tb+8
CALL _InitRingBuffer
POP DX

;   InitRingBuffer(&tb[1], tb[1].abuf, CBS-2);
LEA BX,_tb+048X
PUSH BX
MOV BX,03EX
LEA CX,_tb+050X
CALL _InitRingBuffer
POP DX

;   busy[0] = busy[1] = false;
MOV _busy+2,0
MOV _busy,0

;   Baud(1200, 0);
XOR BX,BX
MOV CX,04B0X
CALL _Baud

;   Baud(1200, 1);
MOV BX,1
MOV CX,04B0X
CALL _Baud

;   EnableInt(&mySIOInt, SIOTyp);
MOV BX,3
MOV CX,OFFSET _mySIOInt
CALL _EnableInt

;   };
MOV SP,BP
POP BP
RET;

; FlushInput(ch)
_FlushInput:

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

;   {

;   if (ch) InitRingBuffer(&rb[1], rb[1].abuf, CBS-2);

;	BX _ _ch
POP BX
PUSH BX
OR BX,BX
JZ X1
LEA BX,_rb+048X
PUSH BX
MOV BX,03EX
LEA CX,_rb+050X
CALL _InitRingBuffer
POP DX

;   else InitRingBuffer(&rb[0], rb[0].abuf, CBS-2);
JR X2
X1:
LEA BX,_rb
PUSH BX
MOV BX,03EX
LEA CX,_rb+8
CALL _InitRingBuffer
POP DX
X2:

;   };
MOV SP,BP
POP BP
RET;

; nbPutChar(c)
_nbPutChar:

;   char c;
PUSH BP
MOV BP,SP
PUSH BX

;   {

;   struct CBuf *p;
PUSH DX

;   p = &tb[0];
LEA BX,_tb

;	_p _ BX
POP DX
PUSH BX

;   while (!WriteRingBuffer(p, c));
X3:

;	AX _ _c
MOV AX,[BP-2]
CBW
MOV BX,AX

;	CX _ _p
POP CX
PUSH CX
CALL _WriteRingBuffer
OR BX,BX
JNZ X4
JR X3
X4:

;   if (!busy[0] && !RingBufferEmpty(p)) {
MOV BX,_busy
OR BX,BX
JNZ X6

;	BX _ _p
POP BX
PUSH BX
CALL _RingBufferEmpty
OR BX,BX
X6:
JNZ X5

;     busy[0] = 1;
MOV _busy,1

;     SIOPutC(0, ReadRingBuffer(p));

;	BX _ _p
POP BX
PUSH BX
CALL _ReadRingBuffer
XOR CX,CX
CALL _SIOPutC

;     };
X5:

;   };
MOV SP,BP
POP BP
RET;

; PutChar(c)
_PutChar:

;   char c;
PUSH BP
MOV BP,SP
PUSH BX

;   {

;   PutC(0, c);

;	AX _ _c
POP AX
PUSH AX
CBW
MOV BX,AX
XOR CX,CX
CALL _PutC

;   };
MOV SP,BP
POP BP
RET;

; PutCRChar(c)
_PutCRChar:

;   char c;
PUSH BP
MOV BP,SP
PUSH BX

;   {

;   PutChar(c);

;	AX _ _c
POP AX
PUSH AX
CBW
MOV BX,AX
CALL _PutChar

;   if (c=='\r') PutChar('\n');

;	AL _ _c
POP AX
PUSH AX
CMP AL,0DX
JNZ X7
MOV BX,0AX
CALL _PutChar
X7:

;   };
MOV SP,BP
POP BP
RET;

; PutC(ch, c)
_PutC:

;   int ch;

;   char c;
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   struct CBuf *p;
PUSH DX

;   p = &tb[ch];

;	BX _ _ch
MOV BX,[BP-2]
LEA CX,_tb
MOV AX,048X
IMUL AX,BX
ADD AX,CX

;	_p _ AX
POP DX
PUSH AX

;   while (!WriteRingBuffer(p, c)) Block();
X8:

;	AX _ _c
MOV AX,[BP-4]
CBW
MOV BX,AX

;	CX _ _p
POP CX
PUSH CX
CALL _WriteRingBuffer
OR BX,BX
JNZ X9
CALL _Block
JR X8
X9:

;   if (!busy[ch] && !RingBufferEmpty(p)) {

;	BX _ _ch
MOV BX,[BP-2]
LEA CX,_busy
SAL BX
ADD BX,CX
MOV CX,[BX]
OR CX,CX
JNZ X11

;	BX _ _p
POP BX
PUSH BX
CALL _RingBufferEmpty
OR BX,BX
X11:
JNZ X10

;     busy[ch] = 1;

;	BX _ _ch
MOV BX,[BP-2]
LEA CX,_busy
SAL BX
ADD BX,CX
MOV WORD PTR [BX],1

;     SIOPutC(ch, ReadRingBuffer(p));

;	BX _ _p
POP BX
PUSH BX
CALL _ReadRingBuffer

;	CX _ _ch
MOV CX,[BP-2]
CALL _SIOPutC

;     };
X10:

;   };
MOV SP,BP
POP BP
RET;

; int GetChar()
_GetChar:
PUSH BP
MOV BP,SP

;   {

;   return(GetC(0));
XOR BX,BX
CALL _GetC
MOV SP,BP
POP BP
RET;

;   };

; int GetC(ch)
_GetC:

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

;   {

;   struct CBuf *p;
PUSH DX

;   p = &rb[ch];

;	BX _ _ch
MOV BX,[BP-2]
LEA CX,_rb
MOV AX,048X
IMUL AX,BX
ADD AX,CX

;	_p _ AX
POP DX
PUSH AX

;   while (RingBufferEmpty(p)) Block();
X12:

;	BX _ _p
POP BX
PUSH BX
CALL _RingBufferEmpty
OR BX,BX
JZ X13
CALL _Block
JR X12
X13:

;   return(ReadRingBuffer(p) & 0177);

;	BX _ _p
POP BX
PUSH BX
CALL _ReadRingBuffer
AND BX,07FX
MOV SP,BP
POP BP
RET;

;   };

; int Chav()
_Chav:
PUSH BP
MOV BP,SP

;   {

;   return(AvC(0));
XOR BX,BX
CALL _AvC
MOV SP,BP
POP BP
RET;

;   };

; int AvC(ch)
_AvC:

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

;   {

;   return(!RingBufferEmpty(&rb[ch]));

;	BX _ _ch
POP BX
PUSH BX
LEA CX,_rb
MOV AX,048X
IMUL AX,BX
ADD AX,CX
MOV BX,AX
CALL _RingBufferEmpty
OR BX,BX
JNZ X14
MOV BX,1
JR X15
X14:
XOR BX,BX
X15:
MOV SP,BP
POP BP
RET;

;   };

; Baud(mbr, ch)
_Baud:

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

;   {

;   int dr, load, hold;

;   if (ch == 0) {  /* use 9513 channel 0 (FOUT) */
ADD SP,0FFFAX

;	BX _ _ch
MOV BX,[BP-4]
OR BX,BX
JNZ X16

;     if (mbr == 300) { MM(0x0ac0); WR4(ch, 0x008c); };

;	BX _ _mbr
MOV BX,[BP-2]
CMP BX,012CX
JNZ X17
MOV BX,0AC0X
CALL _MM
MOV BX,08CX

;	CX _ _ch
MOV CX,[BP-4]
CALL _WR4

;     else WR4(ch, 0x4c);
JR X18
X17:
MOV BX,04CX

;	CX _ _ch
MOV CX,[BP-4]
CALL _WR4
X18:

;     if (mbr==600) MM(0x0ac0);

;	BX _ _mbr
MOV BX,[BP-2]
CMP BX,0258X
JNZ X19
MOV BX,0AC0X
CALL _MM
X19:

;     if (mbr==1200) MM(0x088c0);

;	BX _ _mbr
MOV BX,[BP-2]
CMP BX,04B0X
JNZ X20
MOV BX,088C0X
CALL _MM
X20:

;     if (mbr==2400) MM(0x084c0);

;	BX _ _mbr
MOV BX,[BP-2]
CMP BX,0960X
JNZ X21
MOV BX,084C0X
CALL _MM
X21:

;     if (mbr==4800) MM(0x082c0);

;	BX _ _mbr
MOV BX,[BP-2]
CMP BX,012C0X
JNZ X22
MOV BX,082C0X
CALL _MM
X22:

;     if (mbr==9600) MM(0x08a00);

;	BX _ _mbr
MOV BX,[BP-2]
CMP BX,02580X
JNZ X23
MOV BX,08A00X
CALL _MM
X23:

;     if (mbr==19200) MM(0x08500);

;	BX _ _mbr
JR $+5
X16:
JMP X25
MOV BX,[BP-2]
CMP BX,04B00X
JNZ X24
MOV BX,08500X
CALL _MM
X24:

;     };
X25:

;   if (ch==1) {  /* use 9513 channel 4 */

;	BX _ _ch
MOV BX,[BP-4]
CMP BX,1
JNZ X26

;     WR4(ch, 0x4c);  /* always use /16 mode */
MOV BX,04CX

;	CX _ _ch
MOV CX,[BP-4]
CALL _WR4

;     mbr = mbr/100;

;	AX _ _mbr
MOV AX,[BP-2]
MOV BX,064X
CWD
IDIV AX,BX

;	_mbr _ AX
MOV [BP-2],AX

;     dr = 960/mbr;  /* 960 = 15360/16 (16 for 8274 division ratio)  */
MOV AX,03C0X

;	BX _ _mbr
MOV BX,[BP-2]
CWD
IDIV AX,BX

;	_dr _ AX
MOV [BP-6],AX

;     hold = dr/2;

;	BX _ _dr
MOV BX,[BP-6]
SAR BX

;	_hold _ BX
POP DX
PUSH BX

;     load = dr-hold;

;	BX _ _hold
POP BX
PUSH BX

;	CX _ _dr
MOV CX,[BP-6]
SUB CX,BX

;	_load _ CX
MOV [BP-8],CX

;     OutByte(TimCtl, 0xc8);  /* disarm ch 4 */
MOV BX,0C8X
MOV CX,060X
CALL _OutByte

;     OutByte(TimCtl, 0x04);  /* set data pointer for ch 4 */
MOV BX,4
MOV CX,060X
CALL _OutByte

;     OutWord(TimData, 0x1b62);  /* Mode J, src F1, toggle, count up, binary */
MOV BX,01B62X
MOV CX,062X
CALL _OutWord

;     OutWord(TimData, load);

;	BX _ _load
MOV BX,[BP-8]
MOV CX,062X
CALL _OutWord

;     OutWord(TimData, hold);

;	BX _ _hold
POP BX
PUSH BX
MOV CX,062X
CALL _OutWord

;     OutByte(TimCtl, 0x48);  /* load ch 4 */
MOV BX,048X
MOV CX,060X
CALL _OutByte

;     OutByte(TimCtl, 0x28);  /* arm ch 4 */
MOV BX,028X
MOV CX,060X
CALL _OutByte

;     };
X26:

;   };
MOV SP,BP
POP BP
RET;

; static int iretCode;

; static mySIOInt()
_mySIOInt:
PUSH BP
MOV BP,SP

;   {

;   int type;
PUSH DX

;   type = RR2(1) & 07;
MOV BX,1
CALL _RR2
AND BX,7

;	_type _ BX
POP DX
PUSH BX

;   switch (type) {

;	BX _ _type
POP BX
PUSH BX
JR X27

;     case 0: txe(1); break;
X29:
MOV BX,1
CALL _txe
JR X28

;     case 1: CallD(ecInt+2); break;
X30:
MOV BX,06002X
CALL _CallD
JR X28

;     case 2: rxa(1); break;
X31:
MOV BX,1
CALL _rxa
JR X28

;     case 3: sprx(1); break;
X32:
MOV BX,1
CALL _sprx
JR X28

;     case 4: txe(0); break;
X33:
XOR BX,BX
CALL _txe
JR X28

;     case 5: CallD(ecInt+3); break;
X34:
MOV BX,06003X
CALL _CallD
JR X28

;     case 6: rxa(0); break;
X35:
XOR BX,BX
CALL _rxa
JR X28

;     case 7: sprx(0); break;
X36:
XOR BX,BX
CALL _sprx
JR X28

;     default: CallD(ecInt+1);
X37:
MOV BX,06001X
CALL _CallD

;     };
JR X28
X27:
MOV AL,BH
OR AL,AL
JNZ X37
MOV AL,BL
CMP AL,0
JZ X29
CMP AL,1
JZ X30
CMP AL,2
JZ X31
CMP AL,3
JZ X32
CMP AL,4
JZ X33
CMP AL,5
JZ X34
CMP AL,6
JZ X35
CMP AL,7
JZ X36
JR X37
X28:

;   if (iretCode) WR0(0, 0x38);  /* eoi */
MOV BX,_iretCode
OR BX,BX
JZ X38
MOV BX,038X
XOR CX,CX
CALL _WR0
X38:

;   return(iretCode);
MOV BX,_iretCode
MOV SP,BP
POP BP
RET;

;   };

; CallD(n)
_CallD:

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

;   {

;   WR0(0, 0x38);  /* eoi */
MOV BX,038X
XOR CX,CX
CALL _WR0

;   DoEOI();
CALL _DoEOI

;   iretCode = false;
MOV _iretCode,0

;   CallDebugger(n);

;	BX _ _n
POP BX
PUSH BX
CALL _CallDebugger

;   };
MOV SP,BP
POP BP
RET;

; static rxa(ch)
_rxa:

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

;   {

;   char c;
PUSH DX

;   iretCode = true;
MOV _iretCode,0FFFFX

;   c = SIOGetC(ch);

;	BX _ _ch
MOV BX,[BP-2]
CALL _SIOGetC

;	_c _ BL
POP DX
PUSH BX

;   if (c == 0) CallD(0);

;	AL _ _c
POP AX
PUSH AX
OR AL,AL
JNZ X39
XOR BX,BX
CALL _CallD

;   else WriteRingBuffer(&rb[ch], c);
JR X40
X39:

;	BX _ _ch
MOV BX,[BP-2]
LEA CX,_rb
MOV AX,048X
IMUL AX,BX
ADD AX,CX

;	BX _ _c
POP BX
PUSH BX
PUSH AX
MOV AL,BL
CBW
MOV BX,AX
POP AX
MOV CX,AX
CALL _WriteRingBuffer
X40:

;   };
MOV SP,BP
POP BP
RET;

; static txe(ch)
_txe:

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

;   {

;   struct CBuf *p;
PUSH DX

;   iretCode = true;
MOV _iretCode,0FFFFX

;   p = &tb[ch];

;	BX _ _ch
MOV BX,[BP-2]
LEA CX,_tb
MOV AX,048X
IMUL AX,BX
ADD AX,CX

;	_p _ AX
POP DX
PUSH AX

;   if (RingBufferEmpty(p)) {

;	BX _ _p
POP BX
PUSH BX
CALL _RingBufferEmpty
OR BX,BX
JZ X41

;     WR0(ch, 0x28);
MOV BX,028X

;	CX _ _ch
MOV CX,[BP-2]
CALL _WR0

;     busy[ch] = 0;

;	BX _ _ch
MOV BX,[BP-2]
LEA CX,_busy
SAL BX
ADD BX,CX
MOV WORD PTR [BX],0

;     };

;   else SIOPutC(ch, ReadRingBuffer(p));
JR X42
X41:

;	BX _ _p
POP BX
PUSH BX
CALL _ReadRingBuffer

;	CX _ _ch
MOV CX,[BP-2]
CALL _SIOPutC
X42:

;   };
MOV SP,BP
POP BP
RET;

; static sprx(ch)
_sprx:

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

;   {

;   iretCode = true;
MOV _iretCode,0FFFFX

;   WR0(ch, 0xf0);	/* forget it */
MOV BX,0F0X

;	CX _ _ch
POP CX
PUSH CX
CALL _WR0

;   };
MOV SP,BP
POP BP
RET;

; static WR0(ch, rv)
_WR0:

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

;   {

;   ch = SIOCmdP(ch);

;	BX _ _ch
MOV BX,[BP-2]
CALL _SIOCmdP

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

;   OutByte(ch, rv&0xff);

;	BX _ _rv
POP BX
PUSH BX
AND BX,0FFX

;	CX _ _ch
MOV CX,[BP-2]
CALL _OutByte

;   };
MOV SP,BP
POP BP
RET;

; static int RR2(ch)
_RR2:

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

;   {

;   ch = SIOCmdP(ch);

;	BX _ _ch
POP BX
PUSH BX
CALL _SIOCmdP

;	_ch _ BX
POP DX
PUSH BX

;   OutByte(ch, 2);
MOV BX,2

;	CX _ _ch
POP CX
PUSH CX
CALL _OutByte

;   return(InByte(ch) & 0xff);

;	BX _ _ch
POP BX
PUSH BX
CALL _InByte
AND BX,0FFX
MOV SP,BP
POP BP
RET;

;   };

; static SIOGetC(ch)
_SIOGetC:

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

;   {

;   ch = SIODataP(ch);

;	BX _ _ch
POP BX
PUSH BX
CALL _SIODataP

;	_ch _ BX
POP DX
PUSH BX

;   return(InByte(ch)&0177);

;	BX _ _ch
POP BX
PUSH BX
CALL _InByte
AND BX,07FX
MOV SP,BP
POP BP
RET;

;   };

; static SIOPutC(ch, v)
_SIOPutC:

;   int ch;

;   char v;
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   ch = SIODataP(ch);

;	BX _ _ch
MOV BX,[BP-2]
CALL _SIODataP

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

;   OutByte(ch, v);

;	AX _ _v
POP AX
PUSH AX
CBW
MOV BX,AX

;	CX _ _ch
MOV CX,[BP-2]
CALL _OutByte

;   };
MOV SP,BP
POP BP
RET;

; static SIOCmdP(ch)
_SIOCmdP:

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

;   {

;   if (ch==0) ch = sioctla;

;	BX _ _ch
POP BX
PUSH BX
OR BX,BX
JNZ X43
MOV WORD PTR [BP-2],032X

;   else ch = sioctlb;
JR X44
X43:
MOV WORD PTR [BP-2],030X
X44:

;   return(ch);

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

;   };

; static SIODataP(ch)
_SIODataP:

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

;   {

;   if (ch==0) ch = siodata;

;	BX _ _ch
POP BX
PUSH BX
OR BX,BX
JNZ X45
MOV WORD PTR [BP-2],036X

;   else ch = siodatb;
JR X46
X45:
MOV WORD PTR [BP-2],034X
X46:

;   return(ch);

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

;   };

; static MM(rv)
_MM:

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

;   {

;   OutByte(TimCtl, 0x17);
MOV BX,017X
MOV CX,060X
CALL _OutByte

;   OutWord(TimData, rv);

;	BX _ _rv
POP BX
PUSH BX
MOV CX,062X
CALL _OutWord

;   };
MOV SP,BP
POP BP
RET;

; static WR4(ch, rv)
_WR4:

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

;   {

;   ch = SIOCmdP(ch);

;	BX _ _ch
MOV BX,[BP-2]
CALL _SIOCmdP

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

;   OutByte(ch, 0x04);
MOV BX,4

;	CX _ _ch
MOV CX,[BP-2]
CALL _OutByte

;   OutByte(ch, rv&0xff);

;	BX _ _rv
POP BX
PUSH BX
AND BX,0FFX

;	CX _ _ch
MOV CX,[BP-2]
CALL _OutByte

;   };
MOV SP,BP
POP BP
RET;

; static OutWord(port, val)
_OutWord:

;   int port, val;
PUSH BP
MOV BP,SP
PUSH CX
PUSH BX

;   {

;   OutByte(port, val&0xff);

;	BX _ _val
POP BX
PUSH BX
AND BX,0FFX

;	CX _ _port
MOV CX,[BP-2]
CALL _OutByte

;   OutByte(port, (val >> 8)&0xff);
MOV CX,8

;	BX _ _val
POP BX
PUSH BX
SHR BX,CX
AND BX,0FFX

;	CX _ _port
MOV CX,[BP-2]
CALL _OutByte

;   };
MOV SP,BP
POP BP
RET;

; Externals Declared Here
PUBLIC _Init8274
PUBLIC _FlushInput
PUBLIC _Baud
PUBLIC _nbPutChar
PUBLIC _PutChar
PUBLIC _PutC
PUBLIC _PutCRChar
PUBLIC _GetChar
PUBLIC _GetC
PUBLIC _Chav
PUBLIC _AvC
PUBLIC _CallD

C_CODE ENDS

; Number of Bytes of Code = 053BX, (1339)