INLINE(

$FB/ { STI ;Allow interrupts}

{;}

{; Begin major polling loop over pending interrupts.}

{;}

{; The polling loop is needed because the 8259 cannot handle another 8250}

{; interrupt while we service this interrupt. We keep polling here as long}

{; as an interrupt is received.}

{;}

$8B/$16/>ASYNC_UART_IIR/ {Poll: MOV DX,[>Async_Uart_IIR] ;Get Interrupt ident register}

$EC/ { IN AL,DX ;Pick up interrupt type}

{;}

$A8/$01/ { TEST AL,1 ;See if any interrupt signalled.}

$74/$03/ { JZ Polla ;Yes --- continue}

$E9/$7F/$01/ { JMP NEAR Back ;No --- return to invoker}

{;}

{; Determine type of interrupt.}

{; Possibilities:}

{;}

{; 0 = Modem status changed}

{; 2 = Transmit hold register empty (write char)}

{; 4 = Character received from port}

{; 6 = Line status changed}

{;}

$24/$06/ {Polla: AND AL,6 ;Strip unwanted bits from interrupt type}

$3C/$04/ { CMP AL,4 ;Check if interrupt >= 4}

$74/$03/ { JE Pollb ;}

$E9/$A1/$00/ { JMP NEAR Int2}

{;}

{; Write interrupts must be turned on if a higher-priority interrupt}

{; has been received, else the characters may not be sent (and a lockup}

{; may occur).}

{;}

$50/ {Pollb: PUSH AX ;Save interrupt type}

$E8/$65/$01/ { CALL EnabWI ;Enable write interrupts}

$58/ { POP AX ;Restore interrupt type}

{;}

{; --- Received a character ----}

{;}

$3C/$04/ {Int4: CMP AL,4 ;Check for received char interrupt}

$74/$03/ { JE Int4a ;Yes -- process it.}

$E9/$95/$00/ { JMP NEAR Int2 ;No -- skip.}

{;}

{; Read the character from the serial port.}

{;}

$8B/$16/>ASYNC_BASE/ {Int4a: MOV DX,[>Async_Base] ;Read character from port}

$EC/ { IN AL,DX}

{;}

{; Check if XON/XOFF honored. If so, check if incoming character is}

{; an XON or an XOFF.}

{;}

$90/$90/$90/$90/$90/ { NOP NOP NOP NOP NOP }

$EB/$25/ { JMP Int4d ;No -- skip XON/XOFF checks}

(* $F6/$06/>ASYNC_DO_XONXOFF/$01/ { TEST BYTE [<Async_Do_XonXoff],1 ;See if we honor XON/XOFF}*)

(* $74/$25/ { JZ Int4d ;No -- skip XON/XOFF checks}*)

{;}

$3C/<XON/ { CMP AL,<XON ;See if XON found}

$74/$11/ { JE Int4b ;Skip if XON found}

$3C/<XOFF/ { CMP AL,<XOFF ;See if XOFF found}

$75/$1D/ { JNE Int4d ;Skip if XOFF not found}

{;}

{; XOFF received -- set flag indicating sending of chars isn't possible}

{;}

$C6/$06/>ASYNC_XOFF_RECEIVED/$01/ { MOV BYTE [<Async_XOFF_Received],1 ;Turn on received XOFF flag}

$C6/$06/>ASYNC_XOFF_REC_DISPLAY/$01/ { MOV BYTE [<Async_XOFF_Rec_Display],1 ;Turn on display flag}

$E9/$BE/$FF/ { JMP NEAR Poll}

{;}

{; XON received -- allow more characters to be sent.}

{;}

$C6/$06/>ASYNC_XOFF_RECEIVED/$00/ {Int4b: MOV BYTE [<Async_XOFF_Received],0 ;Turn off received XOFF flag}

$C6/$06/>ASYNC_XON_REC_DISPLAY/$01/ { MOV BYTE [<Async_XON_Rec_Display],1 ;Turn on display flag}

{;}

$E8/$2F/$01/ { CALL EnabWI ;Enable write interrupts}

$E9/$61/$00/ { JMP NEAR Int4z}

{;}

{; Not XON/XOFF -- handle other character.}

{;}

$90/$90/$90/$90/$90/ {Int4d: NOP NOP NOP NOP NOP }

$90/$90/ { NOP NOP }

(* $F6/$06/>ASYNC_LINE_STATUS/$02/ {Int4d: TEST BYTE [>Async_Line_Status],2 ;Check for buffer overrun}*)

(* $75/$5A/ { JNZ Int4z ;Yes --- don't store anything}*)

(* Commented out to prevent lockups. Needs better coding. *)

{;}

$8B/$1E/>ASYNC_BUFFER_HEAD/ { MOV BX,[>Async_Buffer_Head] ;Current position in input buffer}

$C4/$3E/>ASYNC_BUFFER_PTR/ { LES DI,[>Async_Buffer_Ptr] ;Pick up buffer address}

$01/$DF/ { ADD DI,BX ;Update position}

$26/$88/$05/ { ES: MOV [DI],AL ;Store received character in buffer}

$FF/$06/>ASYNC_BUFFER_USED/ { INC WORD [>Async_Buffer_Used] ;Increment count of chars in buffer}

{;}

$A1/>ASYNC_BUFFER_USED/ { MOV AX,[>Async_Buffer_Used] ;Pick up buffer usage count}

$3B/$06/>ASYNC_MAXBUFFERUSED/ { CMP AX,[>Async_MaxBufferUsed] ;See if greater usage than ever before}

$7E/$03/ { JLE Int4f ;Skip if not}

$A3/>ASYNC_MAXBUFFERUSED/ { MOV [>Async_MaxBufferUsed],AX ;This is greatest use thus far}

{;}

$43/ {Int4f: INC BX ;Increment buffer pointer}

$3B/$1E/>ASYNC_BUFFER_SIZE/ { CMP BX,[>Async_Buffer_Size] ;Check if past end of buffer}

$7E/$02/ { JLE Int4h}

$31/$DB/ { XOR BX,BX ;If so, wrap around to front}

{;}

$39/$1E/>ASYNC_BUFFER_TAIL/ {Int4h: CMP WORD [>Async_Buffer_Tail],BX ;Check for overflow}

$74/$29/ { JE Int4s ;Jump if head ran into tail}

{;}

$89/$1E/>ASYNC_BUFFER_HEAD/ { MOV [>Async_Buffer_Head],BX ;Update head pointer}

{;}

{; If XON/XOFF available, and buffer getting full, set up to send}

{; XOFF to remote system.}

{;}

{; This happens in two possible stages:}

{;}

{; (1) An XOFF is sent right when the buffer becomes 'Async_Buffer_High'}

{; characters full.}

{;}

{; (2) A second XOFF is sent right when the buffer becomes}

{; 'Async_Buffer_High_2' characters full; this case is likely the}

{; result of the remote not having seen our XOFF because it was}

{; lost in transmission.}

{;}

$90/$90/$90/$90/$90/ { NOP NOP NOP NOP NOP }

$EB/$23/ { JMP Int4z ;No -- skip XON/XOFF checks}

(* $F6/$06/>ASYNC_DO_XONXOFF/$01/ { TEST BYTE [<Async_Do_XonXoff],1 ;See if we honor XON/XOFF}*)

(* $74/$23/ { JZ Int4z ;No -- skip XON/XOFF checks}*)

{;}

{; Check against first high-water mark.}

{;}

$3B/$06/>ASYNC_BUFFER_HIGH/ { CMP AX,[>Async_Buffer_High] ;AX still has Async_Buffer_Used}

$7C/$1D/ { JL Int4z ;Not very full, so keep going.}

{;}

{; Check if we've already sent XOFF.}

{;}

$F6/$06/>ASYNC_XOFF_SENT/$01/ { TEST BYTE [<Async_XOFF_Sent],1 ;Remember if we sent XOFF or not}

$74/$06/ { JZ Int4j ;No -- go send it now.}

{;}

{; Check against second high-water mark.}

{; If we are right at it, send an XOFF regardless of whether we've}

{; already sent one or not. (Perhaps the first got lost.)}

{;}

$3B/$06/>ASYNC_BUFFER_HIGH_2/ { CMP AX,[>Async_Buffer_High_2]}

$75/$10/ { JNE Int4z ;Not at 2nd mark -- skip}

{;}

$C6/$06/>ASYNC_SEND_XOFF/$01/ {Int4j: MOV BYTE [<Async_Send_XOFF],1 ;Indicate we need to send XOFF}

$E8/$D3/$00/ { CALL EnabWI ;Ensure write interrupts enabled}

$E9/$52/$FF/ { JMP NEAR Poll ;}

{;}

{; If we come here, then the input buffer has overflowed.}

{; Characters will be thrown away until the buffer empties at least one slot.}

{;}

$80/$0E/>ASYNC_LINE_STATUS/$02/ {Int4s: OR BYTE PTR [>Async_Line_Status],2 ;Flag overrun}

{;}

$E9/$4A/$FF/ {Int4z: JMP NEAR Poll}

{;}

{; --- Write a character ---}

{;}

$3C/$02/ {Int2: CMP AL,2 ;Check for THRE interrupt}

$74/$03/ { JE Int2a ;Yes -- process it.}

$E9/$97/$00/ { JMP NEAR Int6 ;No -- skip.}

{;}

{; Check first if we need to send an XOFF to remote system.}

{;}

$F6/$06/>ASYNC_SEND_XOFF/$01/ {Int2a: TEST BYTE [<Async_Send_Xoff],1 ;See if we are sending XOFF}

$74/$34/ { JZ Int2d ;No -- skip it}

{;}

{; Yes, we are to send XOFF to remote.}

{;}

{; First, check DSR and CTS as requested.}

{; If those status lines aren't ready, turn off write interrupts and}

{; try later, after a line status change.}

{;}

$F6/$06/>ASYNC_DO_DSR/$01/ { TEST BYTE [<Async_Do_DSR],1 ;See if DSR checking required}

$74/$09/ { JZ Int2b ;No -- skip it}

{;}

$8B/$16/>ASYNC_UART_MSR/ { MOV DX,[>Async_Uart_MSR] ;Get modem status register}

$EC/ { IN AL,DX}

$A8/<ASYNC_DSR/ { TEST AL,<Async_DSR ;Check for Data Set Ready}

$74/$2E/ { JZ Int2e ;If not DSR, turn off write interrupts}

{;}

$F6/$06/>ASYNC_DO_CTS/$01/ {Int2b: TEST BYTE [<Async_Do_CTS],1 ;See if CTS checking required}

$74/$09/ { JZ Int2c ;No -- skip it}

{;}

$8B/$16/>ASYNC_UART_MSR/ { MOV DX,[>Async_Uart_MSR] ;Get modem status register}

$EC/ { IN AL,DX}

$A8/<ASYNC_CTS/ { TEST AL,<Async_CTS ;Check for Clear To Send}

$74/$1E/ { JZ Int2e ;If not CTS, turn off write ints}

{;}

{; All status lines look OK.}

{; Send the XOFF.}

{;}

$B0/<XOFF/ {Int2c: MOV AL,<XOFF ;Get XOFF Character}

$8B/$16/>ASYNC_BASE/ { MOV DX,[>Async_Base] ;Get transmit hold register address}

$EE/ { OUT DX,AL ;Output the XOFF}

$C6/$06/>ASYNC_SEND_XOFF/$00/ { MOV BYTE [<Async_Send_XOFF],0 ;Turn off send XOFF flag}

$C6/$06/>ASYNC_XOFF_SENT/$01/ { MOV BYTE [<Async_XOFF_Sent],1 ;Turn on sent XOFF flag}

$E9/$08/$FF/ { JMP NEAR Poll ;Return}

{;}

{; Not sending XOFF -- see if any character in buffer to be sent.}

{;}

$8B/$1E/>ASYNC_OBUFFER_TAIL/ {Int2d: MOV BX,[>Async_OBuffer_Tail] ;Pick up output buffer pointers}

$3B/$1E/>ASYNC_OBUFFER_HEAD/ { CMP BX,[>Async_OBuffer_Head]}

$75/$0B/ { JNE Int2m ;Skip if not equal --> something to send}

{;}

{; If nothing to send, turn off write interrupts to avoid unnecessary}

{; time spent handling useless THRE interrupts.}

{;}

$8B/$16/>ASYNC_UART_IER/ {Int2e: MOV DX,[>Async_Uart_IER] ;If nothing -- or can't -- send ...}

$EC/ { IN AL,DX ;}

$24/$FD/ { AND AL,$FD ;}

$EE/ { OUT DX,AL ;... disable write interrupts}

$E9/$F3/$FE/ { JMP NEAR Poll ;}

{;}

{; If something to send, ensure that remote system didn't send us XOFF.}

{; If it did, we can't send anything, so turn off write interrupts and}

{; wait for later (after an XON has been received).}

{;}

$F6/$06/>ASYNC_XOFF_RECEIVED/$01/ {Int2m: TEST BYTE [<Async_XOFF_Received],1 ;See if we received XOFF}

$75/$EE/ { JNZ Int2e ;Yes -- can't send anything now}

{;}

{; If we can send character, check DSR and CTS as requested.}

{; If those status lines aren't ready, turn off write interrupts and}

{; try later, after a line status change.}

{;}

$8B/$16/>ASYNC_UART_MSR/ { MOV DX,[>Async_Uart_MSR] ;Otherwise get modem status}

$EC/ { IN AL,DX}

$A2/>ASYNC_MODEM_STATUS/ { MOV [>Async_Modem_Status],AL ;and save modem status for later}

{;}

$F6/$06/>ASYNC_DO_DSR/$01/ { TEST BYTE [<Async_Do_DSR],1 ;See if DSR checking required}

$74/$04/ { JZ Int2n ;No -- skip it}

{;}

$A8/<ASYNC_DSR/ { TEST AL,<Async_DSR ;Check for Data Set Ready}

$74/$DB/ { JZ Int2e ;If not DSR, turn off write ints}

{;}

$F6/$06/>ASYNC_DO_CTS/$01/ {Int2n: TEST BYTE [<Async_Do_CTS],1 ;See if CTS checking required}

$74/$04/ { JZ Int2o ;No -- skip it}

{;}

$A8/<ASYNC_CTS/ { TEST AL,<Async_CTS ;Check for Clear To Send}

$74/$D0/ { JZ Int2e ;If not CTS, turn off write ints}

{;}

{; Everything looks OK for sending, so send the character.}

{;}

$C4/$3E/>ASYNC_OBUFFER_PTR/ {Int2o: LES DI,[>Async_OBuffer_Ptr] ;Get output buffer pointer}

$01/$DF/ { ADD DI,BX ;Position to character to output}

$26/$8A/$05/ { ES: MOV AL,[DI] ;Get character to output}

$8B/$16/>ASYNC_BASE/ { MOV DX,[>Async_Base] ;Get transmit hold register address}

$EE/ { OUT DX,AL ;Output the character}

{;}

$FF/$0E/>ASYNC_OBUFFER_USED/ { DEC WORD [>Async_OBuffer_Used] ;Decrement count of chars in buffer}

$43/ { INC BX ;Increment tail pointer}

$3B/$1E/>ASYNC_OBUFFER_SIZE/ { CMP BX,[>Async_OBuffer_Size] ;See if past end of buffer}

$7E/$02/ { JLE Int2z}

$31/$DB/ { XOR BX,BX ;If so, wrap to front}

{;}

$89/$1E/>ASYNC_OBUFFER_TAIL/ {Int2z: MOV [>Async_OBuffer_Tail],BX ;Store updated buffer tail}

$E9/$AC/$FE/ { JMP NEAR Poll}

{;}

{; --- Line status change ---}

{;}

$3C/$06/ {Int6: CMP AL,6 ;Check for line status interrupt}

$75/$11/ { JNE Int0 ;No -- skip.}

{;}

$8B/$16/>ASYNC_UART_LSR/ { MOV DX,[>Async_Uart_LSR] ;Yes -- pick up line status register}

$EC/ { IN AL,DX ;and its contents}

$24/$1E/ { AND AL,$1E ;Strip unwanted bits}

$A2/>ASYNC_LINE_STATUS/ { MOV [>Async_Line_Status],AL ;Store for future reference}

$08/$06/>ASYNC_LINE_ERROR_FLAGS/ { OR [>Async_Line_Error_Flags],AL ;Add to any past transgressions}

$E9/$97/$FE/ { JMP NEAR Poll}

{;}

{; --- Modem status change ---}

{;}

$3C/$00/ {Int0: CMP AL,0 ;Check for modem status change}

$74/$03/ { JE Int0a ;Yes -- handle it}

$E9/$90/$FE/ { JMP NEAR Poll ;Else get next interrupt}

{;}

$8B/$16/>ASYNC_UART_MSR/ {Int0a: MOV DX,[>Async_Uart_MSR] ;Pick up modem status reg. address}

$EC/ { IN AL,DX ;and its contents}

$A2/>ASYNC_MODEM_STATUS/ { MOV [>Async_Modem_Status],AL ;Store for future reference}

$E8/$03/$00/ { CALL EnabWI ;Turn on write interrupts, in case}

{; ;status change resulted from CTS/DSR}

{; ;changing state.}

$E9/$82/$FE/ { JMP NEAR Poll}

{;}

{; Internal subroutine to enable write interrupts.}

{;}

{EnabWI: ;PROC NEAR}

$8B/$16/>ASYNC_UART_IER/ { MOV DX,[>Async_Uart_IER] ;Get interrupt enable register}

$EC/ { IN AL,DX ;Check contents of IER}

$A8/$02/ { TEST AL,2 ;See if write interrupt enabled}

$75/$03/ { JNZ EnabRet ;Skip if so}

$0C/$02/ { OR AL,2 ;Else enable write interrupts ...}

$EE/ { OUT DX,AL ;... by rewriting IER contents}

$C3/ {EnabRet: RET ;Return to caller}

{;}

{; Send non-specific EOI to 8259 controller.}

{;}

$B0/$20/ {Back: MOV AL,$20 ;EOI = $20}

$E6/$20); { OUT $20,AL}