{ File: [Iris]DLion>RS232CGet.asm Modification History: Dennis Grundler: 6-Nov-84 17:14:25: Pick up Michael Thatcher's fix for check of LastBufferFlag of 21-Aug-84 17:12:40 Dennis Grundler: 1-Sep-84 17:09:06 Added copyright notice Michael Thatcher: 21-Dec-83 14:39:46: Add Async Flow Control Handling Dennis Grundler: 9-Oct-83 16:32:55: Cleanup code. Amy Fasnacht : 13-Jun-83 16:05:12: Add CTS test at start of task Chuck Fay : 10-Nov-82 17:58:24: Fixed FifoOverflow handling. Jim Frandeen : September 17, 1982 9:01 AM: allow for async blocks to be bigger than the client's buffer. Jim Frandeen : September 9, 1982 8:39 AM: turn off Success bit when error code is returned. Change handling of Abort. Jim Frandeen : July 30, 1982 1:30 PM: new IO Page format. Add CRC error as 20H and FramingError as 8. Jim Frandeen : March 14, 1982 2:23 PM: created file} { Copyright (C) 1982, 1983 by Xerox Corporation. All rights reserved.} Get "SysDefs" Get "CommonDefs" Get "RS232CDefs" IMP ByteToWord ;From CPSubs IMP CharLengthMask ;From RS232CInterrupts IMP CharLengthMask1 ;From RS232CInterrupts IMP CharactersLeftInClientBuffer ;From RS232CInterrupts IMP CharactersUntilBoundary ;From RS232CInterrupts IMP CheckCPDmaComplete ;From CPSubs IMP CurrentCharLengthMask ;From RS232CMisc IMP CurrentFrameToFillPtr ;From RS232CInterrupts IMP CurrentFrameToSendPtr ;From RS232CInterrupts IMP DmaActive ;From CPSubs IMP DoNakedNotify ;From CPSubs IMP FCState ;From RS232CInterrupts IMP FifoStateSwitch ;From RS232CInterrupts IMP FirstFrameToFillPtr ;From RS232CInterrupts IMP FirstMaxFrameBoundary ;From RS232CInterrupts IMP FirstRxCharPtr ;From RS232CInterrupts IMP FlowControlFlag ;From RS232CInterrupts IMP LastBufferFlag ;From RS232CInterrupts IMP LastNewFrameAddressHigh ;From RS232CInterrupts IMP LastNewFrameAddressLow ;From RS232CInterrupts IMP MaxFrameSize ;From RS232CInterrupts IMP MainLoop ;From BookKeepingTask IMP OutputXon IMP PortBusyFlag ;From CPSubs IMP ReadCPBuffer ;From CPSubs IMP RS232CGetFlag ;From BookKeepingTask IMP RS232CMode ;From RS232CMisc IMP RS232CTaskWakeMask ;From RS232CMisc IMP RxBisyncStateSwitch ;From Common IMP RxBisyncInitial ;From BisyncInput IMP RxFIFO ;From Buffer IMP RxFifoEnd ;From RS232CInterrupts IMP RxFifoState ;From RS232CInterrupts IMP RxMaxFrameSize ;From BisyncInterrupts IMP RxWR3 ;From RS232CMisc IMP SetLastBufferFlag ;From RS232CInterrupts IMP SdlcFrameFlag ;From RS232CInterrupts IMP TerminateFrame ;From RS232CInterrupts IMP TerminateBisyncFrame ;From BisyncInput IMP TestAsyncTimer ;From RS232CSubs IMP TxWR1 ;From RS232CMisc IMP WriteCPBuffer ;From CPSubs IMP ZeroCommand ;From Common EXP AbortGetFlag EXP AsyncGetLoop EXP BisyncGetLoop EXP FloppyActiveSwitch4 EXP GetByteCount EXP GetFifoOverflow EXP GetModeSwitch EXP GetTaskResumeAddress EXP GetTaskStartAddress EXP GetTaskQuiet EXP PrevFrameToSendPtr ;***DEBUGGING EXP SdlcGetLoop EXP StartGetTask EXP StatusChangeFlag EXP TestStatusChange ; RS232CGetTask: DB opJMP GetTaskStartAddress: DW GetTaskQuiet ; JMP GetTaskQuiet ; Set by Misc Off command ; JMP NotifyStatusChange ; Set in code below ; JMP TestStatusChange ; Set by Misc SetParameters {Check StatusChangeFlag. This gets set by the External Interrupt routine if we detect CTS (Clear to Send) or DCD (Data Carrier Detect). If this is set, we do a Naked Notify.} TestStatusChange: LDA StatusChangeFlag ORA A JZ RS232CTaskStart NotifyStatusChange: LDA PortBusyFlag ORA A JZ SendStatusNotify LXI H, NotifyStatusChange SHLD GetTaskStartAddress JMP RS232CTaskStart SendStatusNotify: XRA A STA StatusChangeFlag LHLD RS232CTaskWakeMask CALL DoNakedNotify LXI H, TestStatusChange SHLD GetTaskStartAddress RS232CTaskStart: DB opJMP GetTaskResumeAddress: DW GetTaskQuiet ; JMP WaitForIocbTransfer ; JMP StartGetTask ;Set by Misc SetParameters Command ; JMP WaitForIocb ; JMP GetLoop ; JMP SendFrame ; JMP WaitForDataTransfer ; JMP ReturnGetIocb ; StatusChangeFlag: DB 0 RS232CGetCSB: GetIOCBAddressPointerLo: DS 2 ;14033 GetIOCBAddressPointerHi: DS 2 ;14034 {The Iocb is arranged so that we can write the Iocb, the CSB, and the NakedNotify in one transaction. Note that the IOCB is in reverse byte form because it is read and written with the DMA.} RS232CGetIocbSize EQU 10 {This is the Get IOCB that is transferred to and from the CP.} GetIocbBuffer: GetBufferAddressLo: DB 0 GetBufferAddressMid: DB 0 ; blockPointer: LONG POINTER GetBufferAddressHi: DB 0 DB 0 ;Not used GetByteCount: DB 0 ; byteCount: CARDINAL GetByteCountHi: DB 0 GetDataByteCount: DB 0 ; returnedByteCount: CARDINAL GetDataByteCountHi: DB 0 GetTransferStatus: DB 0 ; transferStatus: iopTransferStatus GetTransferStatusHi: DB 0 GetIocbPcb: { Port Control Block to Read and Write the Get IOCB.} GetPcbAddressLo: DW 0 GetPcbAddressHi: DW 0 ; = 0 (0 MDS) DW RS232CGetIocbSize ; Size in bytes DW GetIocbBuffer RS232CGetCPPort: { Port Control Block to read the RS232C CSB from the IOPage } DW RS232CGetCSBLoc ; CP Buffer Pointer Low DW CPIOPageHi ; CP Buffer Pointer Hi DW RS232CGetCSBSize ; Size in bytes DW RS232CGetCSB ; Pointer to Buffer in Common ResetGetFlag: { Port Control Block to reset the Get flag in the IOPage } DW RS232CGetFlagLoc ; CP Buffer Pointer Low DW CPIOPageHi ; CP Buffer Pointer Hi DW 2 ; Size in bytes DW ZeroCommand PrevFrameToSendPtr: DW 0 ;***FOR DEBUGGING ; {The interrupt routine puts characters into the Fifo, and the Get routine removes one frame at a time. Each time a frame is ready, the Fifo routine notifies the Get routine by posting a completion code in the frame header. The interrupt routine fills a frame and sets the FrameCompletionFlag # 0 when a frame is ready to send. The interrupt routine stores the address of the last character stored + 1 in FrameLastChar. We never start a new frame unless there is room in the Fifo for the maximum frame size + the size of the frame header. RxMaxFrameSize contains the maximum frame size. We get an overflow when there is no room in the Fifo for a new frame. The first frame begins at RxFifo. The next frame begins at the next address following the first frame. If the following calculation is negative, we need to start a new frame at the beginning of the RxFifo: LastNewFrameAddress - NextFrameToFillPtr. This is what a frame looks like:} FrameKey: EQU 0 ;# FrameValid => frame has been stored over FrameReadyFlag: EQU 1 ;#0 => frame is ready to send FrameLastCharLow: EQU 2 FrameLastCharHigh: EQU 3 ;stored by interrupt routine FrameCPAddrLow: EQU 4 ;low byte of CP address FrameCPAddrMid: EQU 5 ;middle byte of CP address FrameCPAddrHigh: EQU 6 ;high byte of CP address FrameSizeLow: EQU 7 ;number of data bytes in frame FrameSizeHigh: EQU 8 FrameCommand: EQU 9 ;WriteBlock command for CP micrrocode FrameData: EQU 10 ;First character of data FrameValid EQU 7EH ; StartGetTask: FetchGetIocb: LDA RS232CGetFlag ORA A JNZ ReadGetCSB GetTaskQuiet: {Nothing to do yet because there is no Iocb Ready. Turn off the AbortGetFlag in case Misc is waiting for AbortGet.} XRA A STA AbortGetFlag JMP GetTaskYield {The FullFlag is on to indicate that an IOCB is ready. See if the CP port is free.} ReadGetCSB: LDA PortBusyFlag ORA A JNZ GetTaskYield {Read the CSB to assure that we have the correct IOCB data.} LXI H,RS232CGetCPPort CALL ReadCPBuffer {Copy IOCB address from the CSB into the Port Control Block. We know that the IOCB is in MDS zero, so don't bother to copy the high address. Then copy the IOCB from the CP into IOP memory.} LHLD GetIocbAddressPointerLo SHLD GetPcbAddressLo LXI H,GetIocbPcb CALL ReadCPBuffer ; Copy IOCB from Main Memory {Initialize the address of the data buffer in CP memory. This will be incremented if the data is transferred back to the CP in blocks.} LHLD GetBufferAddressLo MOV A,L STA BufferAddressLo MOV A,H STA BufferAddressMid LDA GetBufferAddressHi STA BufferAddressHi LXI H,0 SHLD GetDataByteCount ;Zero bytes returned field LXI H,XferSuccess ;Assume Get will be successful SHLD GetTransferStatus {Initialize the size of the CPBuffer so that the interupt routine will know when to end a frame. For Async Bisync mode, the IOCB size can be greater than 4K bytes, so we must choose a smaller number and send the data back to the CP in smaller blocks.} LHLD GetByteCount MOV A,L STA RxClientBufferSizeLow MOV A,H STA RxClientBufferSizeHigh LDA RS232CMode CPI CPSDLCMode JZ SetMaxFrameSize ;if SDLC LXI H,600 ;Set max block size if Async or Bisync SetMaxFrameSize: SHLD RxMaxFrameSize {Enable Rx if not yet enabled. We must not enable until we have received the first IOCB so we will know how big the CP buffer is. The interrupt routine needs to know when it fills the IOCB.} LDA RxWR3 ANI RxEnable JNZ GetLoop ; {Start here when the first IOCB is ready and we have not yet done our first Get. We also come through here if we get an invalid frame that wipes out a frame, and we must re-initialize the Fifo. This can happen if we get a block bigger than the maximum size.} LDA CurrentCharLengthMask STA CharLengthMask STA CharLengthMask1 {Disable interrupts here. If we are re-initializing because of a Fifo overflow, we don't want the interrupt routine to change anything until we have re-initialized.} DI {HL = max frame size. Initialize CharactersUntilBoundary to the size of the frame. We assume that our first boundary will be when we fill the first frameor client buffer. The FifoState starts in the Open sate.} SHLD CharactersUntilBoundary LHLD GetByteCount SHLD CharactersLeftInClientBuffer MVI A,opJNZ ;Set FifoState to Open STA FifoStateSwitch STA RxFifoState {Initialize the Fifo address. Note that CurrentFrameToFillPtr points to FrameCompletionCode, and other pointers point to FrameValid.} LXI H,RxFIFO ;HL points to RxFifo SHLD FirstFrameToFillPtr SHLD CurrentFrameToSendPtr SHLD CurrentFrameToSendPtr1 SHLD CurrentFrameToSendPtr2 XRA A STA StatusChangeFlag STA SdlcFrameFlag MVI M,FrameValid INX H ;HL points to FrameCompletionFlag SHLD CurrentFrameToFillPtr MOV M,A ;Turn off FrameCompletionFlag LXI D,FrameData-1 DAD D ;HL points to first data char of first frame SHLD FirstRxCharPtr {Set NextRxCharPtr. Note that BC are reserved for this. BC are not used anywhere else in Domino.} MOV B,H MOV C,L ;BC Ź NextRxCharPtr LXI H,RxBisyncInitial SHLD RxBisyncStateSwitch EI LXI H,ReturnGetIocb SHLD FrameSentSwitch LXI H,YieldForTransfer SHLD WaitForTransferSwitch {Calculate the minimum frame size: RxMaxFrameSize + FrameData. The interrupt routine needs to know if there is room for another frame in the Fifo.} LHLD RxMaxFrameSize LXI D,FrameData DAD D ;HL Ź MaxFrameSize SHLD MaxFrameSize XCHG ;DE Ź MaxFrameSize LHLD FirstFrameToFillPtr DAD D SHLD FirstMaxFrameBoundary {Calculate the last new frame address in the RxFifo: FifoBoundary - MaxFrameSize. When a frame ends, the interrupt routine needs to know if we can start another frame following the previous frame, or if we should start the next frame at the beginning of the RxFifo. If the following calculation is negative, we need to start at the beginning of the RxFifo: LastNewFrameAddress - NextNewFrameAddress.} LHLD RxFifoEnd MOV A,L SUB E ;Subtract MaxFrameSize STA LastNewFrameAddressLow STA LastNewFrameAddressLow1 MOV A,H SBB D STA LastNewFrameAddressHigh STA LastNewFrameAddressHigh1 {Turn on the receiver.} LXI H,8000H+RxCont LDA RxWR3 ORI RxEnable STA RxWR3 DI MVI M,PointToWR3+ResetRxCRCChecker MOV M,A EI {Now that WR3 is set up to enable Rx, we will start getting interrupts from the SIO chip, and we can start receiving data.} GetLoop: DB opJMP GetModeSwitch: DW AsyncGetLoop ; JMP AsyncGetLoop ; JMP SdlcGetLoop ; JMP BisyncGetLoop ; BisyncGetLoop: {Test to see if the interrupt routine has filled a frame.} DB opLHLD ;H Ź FrameCompletionFlag, L Ź FrameValid CurrentFrameToSendPtr2: DW 0 MOV A,H ;A Ź FrameCompletionFlag ORA A JZ TestBisyncAbort BisyncFrameCompletion: {Come here when the interrupt routine has terminated a frame. H = FrameCompletionFlag, L = FrameValid A indicates the reason for the termination: bit 0 (mask 80) End of Frame bit 1 (mask 40) CRC Error or Framing Error bit 2 (mask 20) Overrun bit 3 (mask 10) Parity Error bit 4 (mask 8) Invalid character sequence bit 5 (mask 4) End Of Block bit 6 (mask 2) Fifo Overflow bit 7 (mask 1) Abort } MOV A,L CPI FrameValid JNZ InvalidFrame MOV A,H CPI 8 JNZ FrameCompletion MVI L,InvalidCharacter JMP StoreErrorStatus TestBisyncAbort: LDA AbortGetFlag ORA A JNZ AbortFlagSet LXI H,GetLoop JMP SaveGetResumeAddressAndYield AbortFlagSet: MVI E,1 ;Set CompletionCode for Aborted {Set up the stack so we can call the interrupt routine. We need 3 words plus a return address on the stack. CompletionCode is in E.} LXI H,BisyncGetLoop PUSH H ;push return address PUSH PSW PUSH D DI CALL TerminateBisyncFrame ;push one more word and JMP ; SdlcGetLoop: {Test to see if the interrupt routine has filled a frame.} DB opLHLD ;H Ź FrameCompletionFlag, L Ź FrameValid CurrentFrameToSendPtr1: DW 0 MOV A,H ;A Ź FrameCompletionFlag ORA A JZ TestAbort SdlcFrameCompletion: {Come here when the interrupt routine has terminated a frame. H = FrameCompletionFlag, L = FrameValid A indicates the reason for the termination: bit 0 (mask 80) End of Frame bit 1 (mask 40) CRC Error or Framing Error bit 2 (mask 20) Overrun bit 3 (mask 10) Parity Error bit 4 (mask 8) Not Used bit 5 (mask 4) Not Used bit 6 (mask 2) Fifo Overflow bit 7 (mask 1) Abort } MOV A,L CPI FrameValid MOV A,H JZ FrameCompletion InvalidFrame: {Come here if the frame has been stored over. In SDLC mode, there is no time to check to see if we are storing over a frame to send. We must trust that we will not get a frame that is larger than the client's IOCB. If a frame gets stored, over, return an error code and reinitialize the Fifo.} {Turn off the receiver.} LXI H,8000H+RxCont LDA RxWR3 ANI 0FFH-RxEnable DI MVI M,PointToWR3 MOV M,A EI STA RxWR3 MVI A,DataLost STA GetTransferStatusHi JMP ReturnGetIocb ; AsyncGetLoop: {When running in Async mode, we must test for timeout. If we get a timeout, we end the frame and ship this one back to the CP.} LDA LastBufferFlag ORA A JNZ TestCFTS CALL TestAsyncTimer MVI E,80H ;Set CompletionCode for Timeout JZ AsyncTimeout TestCFTS: {Test to see if the interrupt routine has filled a frame.} LHLD CurrentFrameToSendPtr INX H ;Point to FrameCompletionCode MOV A,M ORA A JNZ FrameCompletion TestAbort: DB opORI ;A Ź AbortGetFlag AbortGetFlag: DB 0 ;Check for AbortInput Command JNZ AbortGet ;Jump if abort LXI H,GetLoop JMP SaveGetResumeAddressAndYield {We will return to GetLoop when it is our turn to run again.} FrameCompletion: {Come here when the interrupt routine has terminated a frame. A = FrameCompletionFlag A indicates the reason for the termination: bit 0 (mask 80) End of Frame bit 1 (mask 40) CRC Error or Framing Error bit 2 (mask 20) Overrun bit 3 (mask 10) Parity Error bit 4 (mask 8) Not Used bit 5 (mask 4) End Of Block bit 6 (mask 2) Fifo Overflow bit 7 (mask 1) Abort } CPI 80H ;Test for End of Frame JZ SendFrame CPI 4 JZ EndOfBlock CPI 1 JZ AbortDetected MOV H,A ANI FifoOverflowed JNZ GetFifoOverflow MOV A,H ANI 40H JNZ CRCErrorDetected MOV A,H ANI 10H JNZ ParityErrorDetected OverrunErrorDetected: MVI L,DeviceError JMP StoreErrorStatus AbortDetected: {Store Aborted in TransferStatus, 0 in TransferStatusHi.} MVI L,Aborted JMP StoreErrorStatus CRCErrorDetected: MVI L,CRCError JMP StoreErrorStatus FramingErrorDetected: MVI L,FramingError JMP StoreErrorStatus ParityErrorDetected: MVI L,ParityError StoreErrorStatus: MVI H,0 ;Zero success bit SHLD GetTransferStatus JMP SendFrame AbortGet: {Come here if we get an Abort command from Misc. Abort this block. Store Aborted in TransferStatus, 0 in TransferStatusHi.} MVI E,1 ;Set CompletionCode for Aborted LXI H,GetLoop ;Set return address JMP PushReturnFromTerminateFrame AsyncTimeout: {When we get a timeout in Async mode, we end the current frame. Set up the stack so we can call the interrupt routine. We need 3 words plus a return address on the stack. CompletionCode is in E.} LXI H,SendFrame PushReturnFromTerminateFrame: PUSH H ;push return address PUSH PSW PUSH D DI CALL TerminateFrame ;push one more word and JMP EndOfBlock: {Come here if this is the end of a block in Async or Bisync mode. Send this frame back to the CP. Return to BlockSent when the transfer is complete.} LXI H,BlockSent SHLD FrameSentSwitch LXI H,WaitForTransfer SHLD WaitForTransferSwitch JMP SendFrame BlockSent: LXI H,YieldForTransfer SHLD WaitForTransferSwitch LXI H,ReturnGetIocb SHLD FrameSentSwitch {Increment the CP buffer address.} LDA BufferAddressLo MOV E,A LDA BufferAddressMid MOV D,A LHLD CurrentFrameDataBytes CALL ByteToWord DAD D MOV A,L STA BufferAddressLo MOV A,H STA BufferAddressMid LDA BufferAddressHi ACI 0 STA BufferAddressHi {Update the number of characters left in the IOCB so that the SendFrame routine can test to be sure we don't send more characters than will fit in the IOCB.} LHLD CurrentFrameDataBytes LDA RxClientBufferSizeLow SUB L STA RxClientBufferSizeLow LDA RxClientBufferSizeHigh SBB H STA RxClientBufferSizeHigh JMP GetLoop GetFifoOverflow: {Come here if the RxFifo has overflowed. Either we could not keep up with the input, or the Fifo is not big enough. The interrupt routine has stored this frame over another frame. This means it threw away a frame. Return this frame to the CP with DataLost error code } MVI A,DataLost STA GetTransferStatusHi SendFrame: {Come here when we have a frame ready to send to the CP. The interrupt routine has stored the pointer to the last character stored into the FrameLastChar field of the frame. Prepare to send this frame to the CP. We will send the WriteBlock Command and the data in one transaction.} LDA PortBusyFlag ORA A JZ StartFrameTransfer LXI H,SendFrame JMP SaveGetResumeAddressAndYield StartFrameTransfer: LHLD CurrentFrameToSendPtr INX H INX H ;HL points to FrameLastCharLow MOV A,M ;A Ź LastCharLow INX H ;HL points to FrameLastCharHigh SUB L ;Addr(LastChar) - Addr(FrameLastCharHigh) MOV E,A MOV A,M ;A Ź LastCharHigh SBB H MOV D,A {DE contains Addr(last char stored+1) - Addr(FrameLastCharHigh) = number of data bytes + 7} MOV A,E SUI 7 MOV E,A MOV A,D SBI 0 MOV D,A INX H ;HL points to FrameCPAddrLow {Now DE contains the number of data characters in the frame. Be sure the block will fit in the client's buffer. Calculate RxClientBufferSize - DE. If this is negative, the block is too big, and we may have stored over another frame in the Fifo.} DB opMVIA ;A Ź RxClientBufferSizeLow RxClientBufferSizeLow: DB 0 SUB E DB opMVIA ;A Ź RxClientBufferSizeHigh RxClientBufferSizeHigh: DB 0 SBB D JM InvalidFrame {DE contains the number of data characters in the frame. HL points to the first character that we will send to the CP. Send the address in HL to the DMA.} MOV A,L OUT DmaCh1Addr ;Send low address MOV A,H OUT DmaCh1Addr ;Send high address {Make the number of data bytes even. We must send an even number to the CP.} XCHG ;DE points to FrameCPAddrLow ;HL Ź count SHLD CurrentFrameDataBytes INX H MOV A,L ANI 0FEH ;Make it even MOV L,A ;HL Ź even data byte count ORA H ;Test for zero count JZ UpdateCurrentFrameToSend PUSH H ;Stack Ź CurrentFrameEvenDataBytes {DE points to FrameCPAddrLow. HL contains the even number of data bytes. Calculate the FrameByteCount, the next field of the CPTransferControlBlock. This is the total number of bytes we send to the CP - 1: (data byte count) + (WriteBlock Command byte count) - 1 = (data byte count) + 5 = HL + 5. FrameByteCountHigh must contain the DMA transfer command in the high two bits. For Read, we want DmaFuncRead = 80H in the high byte.} PUSH D LXI D,8005H ;BC Ź 5 + DmaFuncRead DAD D ;HL Ź HL + 5 = data byte count + 5 POP D {Send the count and the command to the DMA.} MOV A,L OUT DmaCh1Count MOV A,H OUT DmaCh1Count {Store the CPAddress in FrameCPAddrLow, Mid, High} XCHG ;HL points to FrameCPAddrLow DB opMVIM ;M Ź BufferAddressLo BufferAddressLo: DB 0 INX H ;HL points to FrameCPAddrMid DB opMVIM ;M Ź BufferAddressMid BufferAddressMid: DB 0 INX H ;HL points to FrameCPAddrHigh DB opMVIM ;M Ź BufferAddressHi BufferAddressHi: DB 0 INX H ;HL points to FrameSizeLow {Store the number of data bytes in FrameSizeLow, High. } POP D ;DE Ź CurrentFrameEvenDataBytes MOV M,E ;Store FrameSizeLow INX H ;HL points to FrameSizeHigh MOV M,D ;Store FrameSizeHigh INX H ;HL points to FrameCommand MVI M,CPWriteCmd ;Store WriteBlockCommand {One final check to be sure the interrupt routine has not stored into our frame header. This can happen if we get a block that is bigger than the client's Iocb. We don't have time to check for this in the interrupt routine.} LHLD CurrentFrameToSendPtr MOV A,M CPI FrameValid JNZ InvalidFrame {Now we are ready to start the DMA for the CP channel. When we send the command to the DMA controller, the low 4 bits of the command specify which channels to start. We must start the CP channel as well as any other channels that are currently busy. The problem is to know what channels are currently busy so we can send the proper command to the controller. DmaActive is the command we last sent to the DMA to start one or more channels. The low 4 bits of this command indicate which channels were last started. Some of these channels may have completed since then. In order to find out what channels have completed, we must read the Status Register. The low 4 bits of this register indicate what channels have completed. However, we cannot read this register and use this information to restart channels that have not completed, because a channel could complete in this interval. To leave a channel enabled is like pointing a loaded gun at our memory. So what me must do is to stop all channels except for the floppy channel before we read the Status Register. We must not stop the floppy channel if it is busy because it cannot afford the time. Set up A with the ModeSetRegister contents. If the floppy was busy, we will set the floppy active and turn all other channels off. If the floppy was not busy, we will turn off all channels.} LXI H,DmaActive {If the floppy and RS232C are running at the same time, we must disable interrupts when DmaActive is being updated. The following op code will be a NOP whenever the floppy is NOT active. It will be DI whenever the floppy IS active.} FloppyActiveSwitch4: NOP MOV A,M ;A Ź DmaActive ANI DmaCh0Mask ;A Ź 1 if floppy was busy OUT DmaMode ;Point to DmaMode register IN DmaStatus ;Disable channels CMA ;A Ź inverted TerminalCount Flags {Now A contains zero in bit positions of channels that have completed and ones in all other bit positions. We AND this with DmaActive. This gives us a command to restart all channels that need to be restarted. We then OR in the bit for the CP channel, send the command to the DMA, and save DmaActive.} ANA M ORI DmaCh1Mask ;Start CP Channel OUT DmaMode ;Send command to DMA MOV M,A ;Save DmaActive EI ;If disabled by FloppyActiveSwitch4 {The DMA is now programmed and enabled.} MVI A,CPEnable+CPDmaMode OUT CPControl ;Set DmaMode (clear IOPWait, SwTAddr, DmaIn) STA PortBusyFlag {If we are sending a block of data for Bisync mode, wait for the transfer to complete. Otherwise the frames will catch up with us and we will get a Fifo overflow.} DB opJMP WaitForTransferSwitch: DW YieldForTransfer ; JMP YieldForTransfer ; JMP WaitForTransfer WaitForTransfer: CALL CheckCPDmaComplete JNZ UpdateCurrentFrameToSend JMP WaitForTransfer YieldForTransfer: LXI H,WaitForDataTransfer JMP SaveGetResumeAddressAndYield WaitForDataTransfer: CALL CheckCPDmaComplete JZ GetTaskYield ; UpdateCurrentFrameToSend: {Now that the transfer has completed, it is safe to update the CurrentFrameToSendPtr to point to the next frame in the Fifo.. If we update before the completion, it is possible that a frame being filled will run into the frame being sent. The interrupt routine is already filling the next frame. Set HL to point to the next character after the current frame: CurrentFrameToSendPtr + CurrentFrameDataBytes + FrameData} LHLD CurrentFrameDataBytes XCHG ;DE Ź CurrentFrameDataBytes LHLD GetDataByteCount DAD D ;HL Ź total bytes this IOCB SHLD GetDataByteCount LHLD CurrentFrameToSendPtr SHLD PrevFrameToSendPtr ;*** FOR DEBUGGING DB opLXID ;DE Ź CurrentFrameDataBytes CurrentFrameDataBytes: DW 0 DAD D ;HL + CurrentFrameDataBytes LXI D,FrameData DAD D ;HL Ź address of next character {If the following calculation is negative, we need to start a new frame at the beginning of the RxFifo: LastNewFrameAddress - NextFrameToSendPtr} DB opMVIA ;A Ź LastNewFrameAddressLow LastNewFrameAddressLow1: DB 0 SUB L DB opMVIA ;A Ź LastNewFrameAddressHigh LastNewFrameAddressHigh1: DB 0 SBB H JP UpdateFrameToSend {Come here if the next frame starts at the beginning of the RxFifo. The Fifo State changes from Closed to Open. Disable interrupts for as short a time as possible.} LHLD FirstFrameToFillPtr MVI A,opJNZ ;Set FifoState to Open DI STA FifoStateSwitch STA RxFifoState UpdateFrameToSend: SHLD CurrentFrameToSendPtr EI LDA FlowControlFlag ;IF ~FlowControl ORA A JNZ TestLastBuffer SHLD CurrentFrameToSendPtr1 ;Then save CFTS SHLD CurrentFrameToSendPtr2 JMP FrameSentSwitch-1 TestLastBuffer: DI LHLD CurrentFrameToFillPtr ;Else {SetLasBufferFlag CALL SetLastBufferFlag EI LDA LastBufferFlag ORA A JNZ FrameSentSwitch-1 ; IF ~LastBuffer & (SendingXoff | XoffSent) TestXoffSent: LDA FCState ANI SendingXoff+XoffSent JZ FrameSentSwitch-1 DI CALL OutputXon ; THEN Send Xon Char} EI {If we have sent a block of data for Bisync mode, return to Bisync processing.} DB opJMP FrameSentSwitch: DW ReturnGetIocb ; JMP ReturnGetIocb ; JMP BlockSent ; ReturnGetIocb: { Copy the IOCB back to the CP. Reset the Full flag so we will wait for the next IOCB. Notify the CP that we have completed this IOCB.} LDA PortBusyFlag ORA A JZ SendGetIocb LXI H,ReturnGetIocb JMP SaveGetResumeAddressAndYield SendGetIocb: STA AbortGetFlag ;Reset AbortGetFlag LXI H,GetIocbPcb CALL WriteCPBuffer ;Send IOCB back to CP LXI H,ResetGetFlag CALL WriteCPBuffer LHLD RS232CTaskWakeMask CALL DoNakedNotify LXI H,FetchGetIocb SaveGetResumeAddressAndYield: SHLD GetTaskResumeAddress GetTaskYield: {Continue to next task. RS232CGet is the last task in Domino.cfg, so we jump back to the top of round-robin task management.} JMP MainLoop END