{SDLC.mc, HGM,  4-Nov-84  3:01:52}

{Transmitter states.}
Set[TS.readyToSend, 0];
Set[TS.sendLeft, 1];
Set[TS.sendRight, 2];
Set[TS.waitingForEOP, 3];
Set[TS.readyToResend, 4];

{Receiver states.}
Set[RS.readyToRecv, 0];
Set[RS.skipping, 1];
Set[RS.recvLeft, 2];
Set[RS.recvRight, 3];
Set[RS.activeMask, 2]; {on => IOCB valid}

Set[IOCB.next, 0];
Set[IOCB.status, 1];
Set[IOCB.bufferLo, 2];
Set[IOCB.bufferHi, 3];
Set[IOCB.bytes, 4];
Set[IOCB.bytesLeft, 05];

{Scratch area for microcode}
Set[IOCB.fingerLo, 8];
Set[IOCB.fingerHi, 9];
Set[IOCB.mappedLo, 0A];
Set[IOCB.mappedHi, 0B];

Set[CSB.tState, 00];
Set[CSB.tIOCB, 01];
Set[CSB.tIOCBm, 02];
Set[CSB.tIOCBmh, 03];

Set[CSB.rState, 04];
Set[CSB.rIOCB, 05];
Set[CSB.rIOCBm, 06];
Set[CSB.rIOCBmh, 07];

Set[CSB.tUnder, 08];
Set[CSB.rNoBuffer, 0C];
Set[CSB.rAborted, 0D];
Set[CSB.rAbortIdle, 0E];
Set[CSB.rAbortEx, 0F];

Set[Bump.tUnder, 00]; {Odd}
Set[Bump.rNoBuffer, 01];
Set[Bump.rAborted, 02];
Set[Bump.rAbortIdle, 03];



{
We need to leave 6*400+200 ns (2.6 microseconds) between references to the SCC chip.
With a 16mhz Xtal, 6 clicks takes 2.25 microseconds and 7 clicks takes 2.6 microseconds.
Memory reads will take a bit longer.}

PhoneInterrupt: {SCCH+SCC ¬ [0,1000] before we get here}
	IO ¬ [SCCh, SCC+00], {Int Ack}			c1;
{0}	Q ¬ uPhoneCSB,					c2;
	temp ¬ MD,					c3;
	
	SCC ¬ LShift1 temp and ~07,			c1;
{1}	CSB ¬ SCC + Q,					c2;
	CSB ¬ CSB xor 10,				c3;

	Q ¬ SCC and 010,				c1;
{2}	SCCh ¬ temp LRot12, Ybus ¬ temp, YDisp,		c2;
	SCC ¬ Q or u9000, DISP4[SCCDisp, 9],		c3;
	

{Request to send next data byte}
TxTranByte:
	MAR ¬ [CSBh, CSB + CSB.tState],			c1, at[09, 10, SCCDisp];
{3}	Noop, CANCELBR[$, 0],				c2;
	state ¬ MD,					c3;

	MAR ¬ [CSBh, CSB + CSB.tIOCBm],			c1;
{4}	Noop, CANCELBR[$, 0],				c2;
	IOCB ¬ MD,					c3;

	MAR ¬ [CSBh, CSB + CSB.tIOCBmh],		c1;
{5}	Ybus ¬ state, CANCELBR[$, 0], YDisp,		c2;
	IOCBh ¬ MD, DISP3[TranData],			c3;


{Start sending new frame}
TxStart:
	IO ¬ [SCCh, SCC+00], {WR0}			c1, at[TS.readyToResend, 8, TranData];
{0}	MDR ¬ 080, {Reset Tx CRC}			c2;
	Noop,						c3;
	
	MAR ¬ [CSBh, CSB + CSB.tIOCB],			c1, at[TS.readyToSend, 8, TranData];
{1}	tempH ¬ 0, CANCELBR[$, 0],			c2;
	temp ¬ MD,					c3;

	Map ¬ [tempH, temp],				c1;
{2}	Q ¬ temp, ZeroBr,				c2;
	IOCBh ¬ IOCB ¬ MD, BRANCH[$, TxNothingToSend],	c3;

{cycle memory for the side effects of MAR ¬}
	MAR ¬ IOCB ¬ [IOCBh, temp + 0],			c1;
{3}	Noop,						c2;
	Noop,						c3;

	MAR ¬ [CSBh, CSB + CSB.tIOCBm],			c1;
{4}	MDR ¬ IOCB, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	Noop,						c3;

	MAR ¬ [CSBh, CSB + CSB.tIOCBmh],		c1;
{5}	MDR ¬ IOCBh, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	Noop,						c3;

	IO ¬ [SCCh, SCC+0A], {WR10}			c1;
{0}	MDR ¬ 084, {CRC¬1, Abort on Underrun} 		c2;
	Noop,						c3;

	MAR ¬ [IOCBh, IOCB + IOCB.bufferHi],		c1;
{1}	Noop, CANCELBR[$, 0],				c2;
	tempH ¬ temp ¬ MD,				c3;

	MAR ¬ [IOCBh, IOCB + IOCB.fingerHi],		c1;
{2}	MDR ¬ temp, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	Noop,						c3;

	MAR ¬ [IOCBh, IOCB + IOCB.bufferLo],		c1;
{3}	Noop, CANCELBR[$, 0],				c2;
	temp ¬ MD,					c3;

	MAR ¬ [IOCBh, IOCB + IOCB.fingerLo],		c1;
{4}	MDR ¬ temp, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	Noop,						c3;

	Map ¬ [tempH, temp],				c1;
{5}	Q ¬ temp, CANCELBR[$, 0],			c2;
	BufferH ¬ Buffer ¬ MD,				c3;

{cycle memory for the side effects of MAR ¬}
	MAR ¬ Buffer ¬ [BufferH, temp + 0],		c1;
{6}	Noop,						c2;
	Noop,						c3;

TxStarting:
	IO ¬ [SCCh, SCC+00], {WR0}			c1;
{0}	MDR ¬ 0C0, {Reset EOM}				c2;
	Noop,						c3;
	
	MAR ¬ [IOCBh, IOCB + IOCB.mappedHi],		c1;
{1}	MDR ¬ BufferH, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	Noop,						c3;

	MAR ¬ [IOCBh, IOCB + IOCB.mappedLo],		c1;
{2}	MDR ¬ Buffer, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	Noop,						c3;

	MAR ¬ [IOCBh, IOCB + IOCB.bytes],		c1;
{3}	[] ¬ state, NegBr, CANCELBR[$, 0], {Flag from TxSent} c2;
	count ¬ MD, BRANCH[$, TxSendLeftByte],		c3;

{This is the first-on-the-chain path.  The driver has already sent the first byte.}
	Noop,						c1;
{4}	Noop,						c2;
	count ¬ count - 1, GOTO[TxSendRightByte], 	c3;

TxLeftByte:
	IO ¬ [SCCh, SCC+00], {RR0} L4 ¬ 01,		c1, at[TS.sendLeft, 8, TranData];
{0-3}	CALL[TxBufferSetup],				c2;

TxSendLeftByte:
	MAR ¬ [BufferH, Buffer + 0],			c1, at[01, 04, TxBufferRet];
{4}	state ¬ TS.sendRight,				c2;
	temp ¬ MD,					c3;
	
	temp ¬ temp LRot8,				c1;
{5}	count ¬ count - 1, NegBr,			c2;
	BRANCH[TxSendByte, TxEnd],			c3;


TxRightByte:
	IO ¬ [SCCh, SCC+00], {RR0} L4 ¬ 02,		c1, at[TS.sendRight, 8, TranData];
{0-3}	CALL[TxBufferSetup],				c2;
	
TxSendRightByte:
	MAR ¬ [BufferH, Buffer], Buffer ¬ Buffer + 1,	c1, at[02, 04, TxBufferRet];
{4}	state ¬ TS.sendLeft, BRANCH[$, TxNewPage, 1],	c2;
	temp ¬ MD, GOTO[TxSaveBuffer],			c3;
	
TxNewPage:
	temp ¬ MD,					c3;
	
	MAR ¬ [IOCBh, IOCB + IOCB.fingerLo],		c1;
	Q ¬ 0FF + 1, CANCELBR[$, 0],			c2;
	Buffer ¬ MD,					c3;

	MAR ¬ [IOCBh, IOCB + IOCB.fingerHi],		c1;
	Buffer ¬ Buffer + Q, CarryBr, CANCELBR[$, 0],	c2;
	BufferH ¬ MD, BRANCH[TxNoBankCross, $],	c3;

TxNewBank:
	Q ¬ BufferH,					c1;
	Q ¬ Q + 1,					c2;
	BufferH ¬ Q LRot0,				c3;

	MAR ¬ [IOCBh, IOCB + IOCB.fingerHi],		c1;
	MDR ¬ BufferH, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	Noop,						c3;

TxNoBankCross:
	MAR ¬ [IOCBh, IOCB + IOCB.fingerLo],		c1;
	MDR ¬ Buffer, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	Noop,						c3;

	Map ¬ [BufferH, Buffer],			c1;
	Noop,						c2;
	BufferH ¬ Buffer ¬ MD,				c3;

	MAR ¬ [IOCBh, IOCB + IOCB.mappedHi],		c1;
	MDR ¬ BufferH, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	Buffer ¬ Buffer and ~0FF,			c3;

TxSaveBuffer:
	MAR ¬ [IOCBh, IOCB + IOCB.mappedLo],		c1;
{5}	MDR ¬ Buffer, count ¬ count - 1, NegBr, CANCELBR[$, 0],	c2, LOOPHOLE[wok];
	BRANCH[TxSendByte, TxEnd],			c3;

TxSendByte:
	IO ¬ [SCCh, SCC+08], {WR8}			c1;
{0}	MDR ¬ temp, {Transmit Data}			c2;
	Noop,						c3;

TxSaveCountAndState:
	MAR ¬ [IOCBh, IOCB + IOCB.bytesLeft],		c1;
{1}	MDR ¬ count, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	Noop,						c3;

TxSaveState:
	MAR ¬ [CSBh, CSB + CSB.tState],			c1;
{2}	MDR ¬ state, CANCELBR[PreAckInt, 0],		c2, LOOPHOLE[wok];



{Finish sending frame}
{It could underrun right now.  ????}
TxEnd:	IO ¬ [SCCh, SCC+0A], {WR10}			c1;
{0}	MDR ¬ 080, {Send CRC}				c2;
	Noop,						c3;
	
	IO ¬ [SCCh, SCC+00], {WR0}			c1;
{0}	MDR ¬ 028, {Reset Tx Int}			c2;
	state ¬ TS.waitingForEOP, GOTO[TxSaveState],	c3;


{Extra interrupt after packet has been sent.}
TxSent:	MAR ¬ [IOCBh, IOCB + IOCB.status],		c1, at[TS.waitingForEOP, 8, TranData];
{7}	MDR ¬ state ¬ state xor ~state, CANCELBR[$, 0],	c2, LOOPHOLE[wok];
	Q ¬ uWP,					c3;

TxNextBuffer:
	MAR ¬ [IOCBh, IOCB + IOCB.next],		c1;
{8}	Q ¬ Q or uIntPhone, CANCELBR[$, 0],		c2;
	temp ¬ MD,					c3;

	MAR ¬ [CSBh, CSB + CSB.tIOCB],			c1;
{9}	MDR ¬ temp, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	uWP ¬ Q, GOTO[TxStart],				c3;



TxBufferSetup:
	temp ¬ MD,					c3;
	
	MAR ¬ [IOCBh, IOCB + IOCB.mappedHi],		c1;
{1}	Q ¬ temp and 040, CANCELBR[$, 0],		c2;
	BufferH ¬ MD,					c3;

	MAR ¬ [IOCBh, IOCB + IOCB.mappedLo],		c1;
{2}	[] ¬ Q, NZeroBr, CANCELBR[$, 0],		c2;
	Buffer ¬ MD, BRANCH[$, TxUnderrun],		c3;

	MAR ¬ [IOCBh, IOCB + IOCB.bytesLeft],		c1;
{3}	L4Disp, CANCELBR[$, 0],				c2;
	count ¬ MD, DISP2[TxBufferRet],			c3;

TxUnderrun:
	MAR ¬ [IOCBh, IOCB + IOCB.status],		c1;
{2}	MDR ¬ temp, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	L4 ¬ Bump.tUnder,				c3;

{3-4}	MAR ¬ Q ¬ [CSBh, CSB + CSB.tUnder], CALL[BumpCSB], c1;

	Q ¬ uWP,					c1, at[Bump.tUnder, 10, BumpRet];
{5}	Q ¬ Q or uIntPhone,				c2;
	Noop,						c3;

	MAR ¬ [CSBh, CSB + CSB.tIOCB],			c1;
	MDR ¬ 0, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	uWP ¬ Q,					c3;

TxNothingToSend:
	IO ¬ [SCCh, SCC+00], {WR0}			c1;
{0}	MDR ¬ 028, {Reset Tx Int}			c2;
	state ¬ TS.readyToSend, GOTO[TxSaveState],	c3;



ExternalStatusChange:
	MAR ¬ [CSBh, CSB + CSB.rIOCBm],			c1, at[0B, 10, SCCDisp];
{3}	Noop, CANCELBR[$, 0],				c2;
	IOCB ¬ MD,					c3;

	MAR ¬ [CSBh, CSB + CSB.rIOCBmh],		c1;
{4}	Noop, CANCELBR[$, 0],				c2;
	IOCBh ¬ MD,					c3;

	MAR ¬ [CSBh, CSB + CSB.rState],			c1;
{5}	Noop, CANCELBR[$, 0],				c2;
	state ¬ MD,					c3;

	IO ¬ [SCCh, SCC+00], {RR0}			c1;
{0}	Noop,						c2;
	temp ¬ MD,					c3;
	
	IO ¬ [SCCh, SCC+00], {WR0}			c1;
{0}	MDR ¬ 010, {Reset Ext/Sts Int}			c2;
	Q ¬ 80,						c3;
	
	Q ¬ temp and Q, NZeroBr, {Abort}		c1;
{1}	Q ¬ CSB + CSB.rAbortEx, BRANCH[$, RxAbortedExt], c2;
	Q ¬ uInts, GOTO[AckInt],			c3;
	

	
{Grab next character of frame}
RxDataByte:
	MAR ¬ [CSBh, CSB + CSB.rState],			c1, at[0D, 10, SCCDisp];
{3}	Noop, CANCELBR[$, 0],				c2;
	state ¬ MD,					c3;

	MAR ¬ [CSBh, CSB + CSB.rIOCBm],			c1;
{4}	Noop, CANCELBR[$, 0],				c2;
	IOCB ¬ MD,					c3;

	MAR ¬ [CSBh, CSB + CSB.rIOCBmh],		c1;
{5}	Ybus ¬ state, CANCELBR[$, 0], YDisp,		c2;
	IOCBh ¬ MD, DISP3[RecvData],			c3;

{Here comes a new frame}
RxStart:
	IO ¬ [SCCh, SCC+00], {RR0}			c1, at[RS.readyToRecv, 8, RecvData];
{0}	Noop,						c2;
	temp ¬ MD,					c3;

	Q ¬ temp and 80,				c1;
{1}	[] ¬ Q, NZeroBr, L4 ¬ Bump.rAbortIdle,		c2;
	BRANCH[$, RxAbortStray],			c3;

	MAR ¬ [CSBh, CSB + CSB.rIOCB],			c1;
{2}	tempH ¬ 0, CANCELBR[$, 0],			c2;
	temp ¬ MD,					c3;

	Map ¬ [tempH, temp],				c1;
{3}	Q ¬ temp, ZeroBr, L4 ¬ Bump.rNoBuffer,		c2;
	IOCBh ¬ IOCB ¬ MD, BRANCH[$, RxNoBuffer],	c3;

{cycle memory for the side effects of MAR ¬}
	MAR ¬ IOCB ¬ [IOCBh, temp + 0],			c1;
{4}	Noop,						c2;
	Noop,						c3;

	MAR ¬ [CSBh, CSB + CSB.rIOCBm],			c1;
{5}	MDR ¬ IOCB, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	Noop,						c3;

	MAR ¬ [CSBh, CSB + CSB.rIOCBmh],		c1;
{6}	MDR ¬ IOCBh, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	Noop,						c3;

	MAR ¬ [IOCBh, IOCB + IOCB.bufferHi],		c1;
{7}	Noop, CANCELBR[$, 0],				c2;
	tempH ¬ temp ¬ MD,				c3;

	MAR ¬ [IOCBh, IOCB + IOCB.fingerHi],		c1;
{8}	MDR ¬ temp, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	Noop,						c3;

	MAR ¬ [IOCBh, IOCB + IOCB.bufferLo],		c1;
{9}	Noop, CANCELBR[$, 0],				c2;
	temp ¬ MD,					c3;

	MAR ¬ [IOCBh, IOCB + IOCB.fingerLo],		c1;
{10}	MDR ¬ temp, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	Noop,						c3;

	Map ¬ [tempH, temp],				c1;
{11}	Q ¬ temp, CANCELBR[$, 0],			c2;
	BufferH ¬ Buffer ¬ MD,				c3;

{cycle memory for the side effects of MAR ¬}
	MAR ¬ Buffer ¬ [BufferH, temp + 0],		c1;
{12}	Noop,						c2;
	Noop,						c3;

	MAR ¬ [IOCBh, IOCB + IOCB.mappedHi],		c1;
{13}	MDR ¬ BufferH, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	Noop,						c3;

	MAR ¬ [IOCBh, IOCB + IOCB.mappedLo],		c1;
{14}	MDR ¬ Buffer, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	Noop,						c3;

	MAR ¬ [IOCBh, IOCB + IOCB.bytes],		c1;
{15}	Noop, CANCELBR[$, 0],				c2;
	count ¬ MD, GOTO[RxGrabLeftByte],		c3;

	
	
RxLeftByte:
	IO ¬ [SCCh, SCC+00], {RR0} L4 ¬ 00,		c1, at[RS.recvLeft, 8, RecvData];
{0-3}	CALL[RxBufferSetup],				c2;

RxGrabLeftByte:
	IO ¬ [SCCh, SCC+08], {RR8}			c1, at[00, 04, RxBufferRet];
{0}	Noop,						c2;
	temp ¬ MD,					c3;

{1}	count ¬ count - 1, NegBr,			c1;
	state ¬ RS.skipping, BRANCH[$, RxOverflowLeft],	c2;
	temp ¬ temp LRot8,				c3;
	
	MAR ¬ [BufferH, Buffer + 0],			c1;
{2}	MDR ¬ temp,					c2;
	state ¬ RS.recvRight,				c3;

RxSaveCountAndState:
	MAR ¬ [IOCBh, IOCB + IOCB.bytesLeft],		c1;
{3}	MDR ¬ count, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	Noop,						c3;

RxSaveState:
	MAR ¬ [CSBh, CSB + CSB.rState],			c1;
{4}	MDR ¬ state, CANCELBR[PreAckInt, 0],		c2, LOOPHOLE[wok];


RxRightByte:
	IO ¬ [SCCh, SCC+00], {RR0} L4 ¬ 01,		c1, at[RS.recvRight, 8, RecvData];
{0-3}	CALL[RxBufferSetup],				c2;

RxRecvRightByte:
	MAR ¬ [BufferH, Buffer + 0],			c1, at[01, 04, RxBufferRet];
{4}	count ¬ count - 1, NegBr,			c2;
	temp ¬ MD, BRANCH[$, RxOverflowRight],		c3;

	IO ¬ [SCCh, SCC+08], {RR8}			c1;
{0}	state ¬ RS.recvLeft,				c2;
	temp ¬ temp or MD,				c3;
	
	MAR ¬ [BufferH, Buffer], Buffer ¬ Buffer + 1,	c1;
{2}	MDR ¬ temp, BRANCH[$, RxNewPage, 1],		c2;
	GOTO[RxSaveBuffer],				c3;


RxNewPage: {Rats, write canceled}
	Noop,						c3;
	
	MAR ¬ [BufferH, Buffer + 0FF],			c1;
	MDR ¬ temp, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	Noop,						c3;

	MAR ¬ [IOCBh, IOCB + IOCB.fingerLo],		c1;
	Q ¬ 0FF + 1, CANCELBR[$, 0],			c2;
	Buffer ¬ MD,					c3;

	MAR ¬ [IOCBh, IOCB + IOCB.fingerHi],		c1;
	Buffer ¬ Buffer + Q, CarryBr, CANCELBR[$, 0],	c2;
	BufferH ¬ MD, BRANCH[RxNoBankCross, $],	c3;

RxNewBank:
	Q ¬ BufferH,					c1;
	Q ¬ Q + 1,					c2;
	BufferH ¬ Q LRot0,				c3;

	MAR ¬ [IOCBh, IOCB + IOCB.fingerHi],		c1;
	MDR ¬ BufferH, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	Noop,						c3;

RxNoBankCross:
	MAR ¬ [IOCBh, IOCB + IOCB.fingerLo],		c1;
	MDR ¬ Buffer, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	Noop,						c3;

	Map ¬ [BufferH, Buffer],			c1;
	Noop,						c2;
	BufferH ¬ Buffer ¬ MD,				c3;

	MAR ¬ [IOCBh, IOCB + IOCB.mappedHi],		c1;
	MDR ¬ BufferH, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	Buffer ¬ Buffer and ~0FF,			c3;

RxSaveBuffer:
	MAR ¬ [IOCBh, IOCB + IOCB.mappedLo],		c1;
{6}	MDR ¬ Buffer, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	GOTO[RxSaveCountAndState],			c3;



{Buffer ended before packet}
RxOverflowRight:
	Noop,						c1;
{-}	state ¬ RS.skipping,				c2;
RxOverflowLeft:
	temp ¬ 1, GOTO[RxNextBuffer],			c3;


RxNoBuffer:
	MAR ¬ Q ¬ [CSBh, CSB + CSB.rNoBuffer], CALL[BumpCSB], c1;

	MAR ¬ [CSBh, CSB + CSB.rState],			c1, at[Bump.rNoBuffer, 10, BumpRet];
{6}	MDR ¬ state ¬ RS.skipping, CANCELBR[$, 0],	c2, LOOPHOLE[wok];
	GOTO[RxDiscardDataByte],			c3;




RxSkipByte:
	IO ¬ [SCCh, SCC+00], {RR0}			c1, at[RS.skipping, 8, RecvData];
{0}	Noop,						c2;
	temp ¬ MD,					c3;
	
	Q ¬ temp and 80,				c1;
{1}	[] ¬ Q, NZeroBr,				c2;
	Q ¬ CSB + CSB.rAborted, BRANCH[$, RxAbortedSkip], c3;
	
RxDiscardDataByte:
	IO ¬ [SCCh, SCC+08], {RR8},			c1;
{0}	Q ¬ uInts,					c2;
	temp ¬ MD, GOTO[AckInt],			c3;


RxBufferSetup:
	temp ¬ MD,					c3;
	
	MAR ¬ [IOCBh, IOCB + IOCB.mappedHi],		c1;
{1}	Q ¬ temp and 80, CANCELBR[$, 0],		c2;
	BufferH ¬ MD,					c3;

	MAR ¬ [IOCBh, IOCB + IOCB.mappedLo],		c1;
{2}	[] ¬ Q, NZeroBr, CANCELBR[$, 0],		c2;
	Buffer ¬ MD, BRANCH[$, RxAborted],		c3;

	MAR ¬ [IOCBh, IOCB + IOCB.bytesLeft],		c1;
{3}	L4Disp, CANCELBR[$, 0],				c2;
	count ¬ MD, DISP2[RxBufferRet],			c3;


RxAborted:
	Q ¬ CSB + CSB.rAborted,				c1;
	Noop,						c2;
RxAbortedExt:
	Noop,						c3;

RxAbortedSkip:
	MAR ¬ [CSBh, CSB + CSB.rState], L4 ¬ Bump.rAborted, c1;
{4}	MDR ¬ state ¬ RS.readyToRecv, CANCELBR[$, 0],	c2, LOOPHOLE[wok];
	Noop,						c3;

	MAR ¬ Q ¬ [CSBh, Q + 0], CALL[BumpCSB],		c1;
	
	IO ¬ [SCCh, SCC+00], {WR0}			c1, at[Bump.rAborted, 10, BumpRet];
ResetExtStatus:
{0}	MDR ¬ 010, {Reset Ext/Sts Int} GOTO[PreAckInt],	c2;
	
RxAbortStray:
{2}	MAR ¬ Q ¬ [CSBh, CSB + CSB.rAbortIdle], CALL[BumpCSB], c1;
	
	IO ¬ [SCCh, SCC+00], {WR0} GOTO[ResetExtStatus],c1, at[Bump.rAbortIdle, 10, BumpRet];
	
		

{RecvChar is "special", hopefully it's the End of a frame}
RxSpecial:
	MAR ¬ [CSBh, CSB + CSB.rIOCBm],			c1, at[0F, 10, SCCDisp];
{3}	Noop, CANCELBR[$, 0],				c2;
	IOCB ¬ MD,					c3;

	MAR ¬ [CSBh, CSB + CSB.rIOCBmh],		c1;
{4}	Noop, CANCELBR[$, 0],				c2;
	IOCBh ¬ MD,					c3;

	MAR ¬ [CSBh, CSB + CSB.rState],			c1;
{5}	Noop, CANCELBR[$, 0],				c2;
	state ¬ MD,					c3;
	
	IO ¬ [SCCh, SCC+00], {RR0}			c1;
{0}	Noop,						c2;
	temp ¬ MD,					c3;
	
	IO ¬ [SCCh, SCC+01], {RR1}			c1;
{0}	temp ¬ temp LRot8,				c2;
	temp ¬ temp or MD,				c3;
	
	IO ¬ [SCCh, SCC+08], {RR8}			c1;
{0}	Noop,						c2;
	Xbus ¬ MD,					c3;
{Discard shifted last byte of the CRC.}

	IO ¬ [SCCh, SCC+00], {WR0}			c1;
{0}	MDR ¬ 030, {Reset Errs}				c2;
	Noop,						c3;
	
	[] ¬ state and RS.activeMask, ZeroBr,		c1;
{2}	BRANCH[$, RxSpecialNoBuffer],			c2;
	state ¬ RS.readyToRecv,	GOTO[RxNextBuffer],	c3;
	
RxSpecialNoBuffer:
	state ¬ RS.readyToRecv,	GOTO[RxSaveState],	c3;

	

{Store final status and chain to next recv buffer.
  state has new state (RS.skipping or RS.readyToRecv)
  temp has status}
RxNextBuffer:
	MAR ¬ [IOCBh, IOCB + IOCB.status],		c1;
{1}	MDR ¬ temp, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	Q ¬ uWP,					c3;

	MAR ¬ [IOCBh, IOCB + IOCB.next],		c1;
{2}	Q ¬ Q or uIntPhone, CANCELBR[$, 0],		c2;
	temp ¬ MD,					c3;

	MAR ¬ [CSBh, CSB + CSB.rIOCB],			c1;
{3}	MDR ¬ temp, CANCELBR[$, 0],			c2, LOOPHOLE[wok];
	uWP ¬ Q, GOTO[RxSaveState],			c3;


PreAckInt:
	Q ¬ uInts,					c3;

AckInt:
	IO ¬ [SCCh, SCC+00], {WR0x}			c1;
{0}	MDR ¬ 38, {Reset Highest IUS}			c2;
	Q ¬ Q and ~u800,				c3;
	
	uInts ¬ Q,					c1;
{1}	temp ¬ u800,					c2;
	TT ¬ TT and ~temp, GOTO[NoPhoneInterrupt],	c3;
	
	
{-----------------------------------------------------------}

BumpCSB:
{1+}	CANCELBR[$, 0],					c2;
	temp ¬ MD,					c3;
	
	MAR ¬ [CSBh, Q + 0],				c1;
{2+}	MDR ¬ temp + 1, L4Disp,				c2;
	DISP4[BumpRet],					c3;