;
;==================================================================================================
; UART DRIVER (SERIAL PORT)
;==================================================================================================
;
UART_DEBUG		.EQU	FALSE
;
UART_NONE		.EQU	0	; UNKNOWN OR NOT PRESENT
UART_8250		.EQU	1
UART_16450		.EQU	2
UART_16550		.EQU	3
UART_16550A		.EQU	4
UART_16550C		.EQU	5
UART_16650		.EQU	6
UART_16750		.EQU	7
UART_16850		.EQU	8
;
UART_RBR		.EQU	0	; DLAB=0: RCVR BUFFER REG (READ)
UART_THR		.EQU	0	; DLAB=0: XMIT HOLDING REG (WRITE)
UART_IER		.EQU	1	; DLAB=0: INT ENABLE REG (READ)
UART_IIR		.EQU	2	; INT IDENT REGISTER (READ)
UART_FCR		.EQU	2	; FIFO CONTROL REG (WRITE)
UART_LCR		.EQU	3	; LINE CONTROL REG (READ/WRITE)
UART_MCR		.EQU	4	; MODEM CONTROL REG (READ/WRITE)
UART_LSR		.EQU	5	; LINE STATUS REG (READ)
UART_MSR		.EQU	6	; MODEM STATUS REG (READ)
UART_SCR		.EQU	7	; SCRATCH REGISTER (READ/WRITE)
UART_DLL		.EQU	0	; DLAB=1: DIVISOR LATCH (LS) (READ/WRITE)
UART_DLM		.EQU	1	; DLAB=1: DIVISOR LATCH (MS) (READ/WRITE)
UART_EFR		.EQU	2	; LCR=$BF: ENHANCED FEATURE REG (READ/WRITE)
;
UART_FIFO		.EQU	0	; FIFO ENABLE BIT
UART_AFC		.EQU	1	; AUTO FLOW CONTROL ENABLE BIT
;
#DEFINE	UART_INP(RID)	CALL UART_INP_IMP \ .DB RID
#DEFINE	UART_OUTP(RID)	CALL UART_OUTP_IMP \ .DB RID
;
; CHARACTER DEVICE DRIVER ENTRY
;   A: RESULT (OUT), CF=ERR
;   B: FUNCTION (IN)
;   C: CHARACTER (IN/OUT)
;   E: DEVICE/UNIT (IN)
;
UART_INIT:
;
; INIT UART4 BOARD CONFIG REGISTER (NO HARM IF IT IS NOT THERE)
;
	LD	A,$80			; SELECT 7.3728MHZ OSC & LOCK CONFIG REGISTER
	OUT	($CF),A			; DO IT
;
; SETUP THE DISPATCH TABLE ENTRIES
;
	LD	B,UARTCNT		; LOOP CONTROL
	LD	C,0			; PHYSICAL UNIT INDEX
	XOR	A			; ZERO TO ACCUM
	LD	(UART_DEV),A		; CURRENT DEVICE NUMBER
UART_INIT0:	
	PUSH	BC			; SAVE LOOP CONTROL
	LD	A,C			; PHYSICAL UNIT TO A
	RLCA				; MULTIPLY BY CFG TABLE ENTRY SIZE (8 BYTES)
	RLCA				; ...
	RLCA				; ... TO GET OFFSET INTO CFG TABLE
	LD	HL,UART_CFG		; POINT TO START OF CFG TABLE
	CALL	ADDHLA			; HL := ENTRY ADDRESS
	PUSH	HL			; SAVE IT
	CALL	UART_INIT1		; DO HARDWARE INIT FOR CURRENT UART
	POP	DE			; GET ENTRY ADDRESS BACK, BUT PUT IN DE
	POP	BC			; RESTORE LOOP CONTROL
	
	LD	A,(UART_TYPE)		; GET THE UART TYPE DETECTED
	OR	A			; SET FLAGS
	JR	Z,UART_INIT00		; SKIP IT IF NOTHING FOUND
		
	PUSH	BC			; SAVE LOOP CONTROL
	LD	BC,UART_DISPATCH	; BC := DISPATCH ADDRESS
	CALL	NZ,CIO_ADDENT		; ADD ENTRY IF UART FOUND, BC:DE
	POP	BC			; RESTORE LOOP CONTROL
	
UART_INIT00:	
	INC	C			; NEXT PHYSICAL UNIT
	DJNZ	UART_INIT0		; LOOP UNTIL DONE
	XOR	A			; SIGNAL SUCCESS
	RET				; AND RETURN
;
UART_INIT1:
	PUSH	HL			; COPY CFG DATA PTR
	POP	IY			; ... TO IY
;
	JP	UART_INITP		; HAND OFF TO GENERIC INIT CODE
;
;
;
UART_DISPATCH:
	; DISPATCH TO FUNCTION HANDLER
	PUSH	HL			; SAVE HL FOR NOW
	LD	A,B			; GET FUNCTION
	AND	$0F			; ISOLATE LOW NIBBLE
	RLCA				; X 2 FOR WORD OFFSET INTO FUNCTION TABLE
	LD	HL,UART_FTBL		; START OF FUNC TABLE
	CALL	ADDHLA			; HL := ADDRESS OF ADDRESS OF FUNCTION
	LD	A,(HL)			; DEREF HL
	INC	HL			; ...
	LD	H,(HL)			; ...
	LD	L,A			; ... TO GET ADDRESS OF FUNCTION
	EX	(SP),HL			; RESTORE HL & PUT FUNC ADDRESS -> (SP)
	RET				; EFFECTIVELY A JP TO TGT ADDRESS

UART_FTBL:
	.DW	UART_IN
	.DW	UART_OUT
	.DW	UART_IST
	.DW	UART_OST
	.DW	UART_INITDEV
	.DW	UART_QUERY
	.DW	UART_DEVICE
;
;
;
UART_IN:
	CALL	UART_IST		; RECEIVED CHAR READY?
	JR	Z,UART_IN		; LOOP IF NOT
	LD	C,(IY + 1)		; C := BASE UART PORT (WHICH IS ALSO RBR REG)
	IN	E,(C)			; CHAR READ TO E
	XOR	A			; SIGNAL SUCCESS
	RET				; AND DONE
;
;
;
UART_OUT:
	CALL	UART_OST		; READY FOR CHAR?
	JR	Z,UART_OUT		; LOOP IF NOT
	LD	C,(IY + 1)		; C := BASE UART PORT (WHICH IS ALSO THR REG)
	OUT	(C),E			; SEND CHAR FROM E
	XOR	A			; SIGNAL SUCCESS
	RET
;
;
;
UART_IST:
	LD	C,(IY + 2)		; C := LINE STATUS REG (LSR)
	IN	A,(C)			; GET STATUS
	AND	$01			; ISOLATE BIT 0 (RECEIVE DATA READY)
	JP	Z,CIO_IDLE		; NOT READY, RETURN VIA IDLE PROCESSING
	XOR	A			; ZERO ACCUM
	INC	A			; ACCUM := 1 TO SIGNAL 1 CHAR WAITING
	RET				; DONE
;
;
;
UART_OST:
	LD	C,(IY + 2)		; C := LINE STATUS REG (LSR)
	IN	A,(C)			; GET STATUS
	AND	$20			; ISOLATE BIT 5 ()
	JP	Z,CIO_IDLE		; NOT READY, RETURN VIA IDLE PROCESSING
	XOR	A			; ZERO ACCUM
	INC	A			; ACCUM := 1 TO SIGNAL 1 BUFFER POSITION
	RET				; DONE
;
;
;
UART_INITDEV:
	XOR	A			; NOT IMPLEMENTED!!!
	RET
;
;
;
UART_QUERY:
	PUSH	IY			; COPY CFG ENTRY POINTER (IY)
	POP	HL			; ... TO HL
	LD	A,4			; OFFSET OF BAUD RATE IS 4
	CALL	ADDHLA			; BUMP HL TO START OF BAUD RATE DWORD
	CALL	LD32			; LOAD IT
	XOR	A			; SIGNAL SUCCESS
	RET				; DONE
;
;
;
UART_DEVICE:
	LD	D,CIODEV_UART	; D := DEVICE TYPE
	LD	E,C		; E := PHYSICAL UNIT
	XOR	A		; SIGNAL SUCCESS
	RET
;
; UART INITIALIZATION ROUTINE
;
UART_INITP:
	; WAIT FOR ANY IN-FLIGHT DATA TO BE SENT
	LD	B,0			; LOOP TIMEOUT COUNTER
UART_INITP00:
	UART_INP(UART_LSR)		; GET LINE STATUS REGISTER
	BIT	6,A			; TEST BIT 6 (TRANSMITTER EMPTY)
	JR	NZ,UART_INITP0		; EMPTY, CONTINUE
	LD	DE,100			; DELAY 100 * 16US
	CALL	VDELAY			; NORMALIZE TIMEOUT TO CPU SPEED
	DJNZ	UART_INITP00		; KEEP CHECKING UNTIL TIMEOUT

UART_INITP0:
	; DETECT THE UART TYPE
	CALL	UART_DETECT		; DETERMINE UART TYPE
	LD	(UART_TYPE),A		; SAVE TYPE
	OR	A			; SET FLAGS
	RET	Z			; ABORT IF NOTHING THERE
	
	; UPDATE WORKING UART DEVICE NUM
	LD	HL,UART_DEV		; POINT TO CURRENT UART DEVICE NUM
	LD	A,(HL)			; PUT IN ACCUM
	INC	(HL)			; INCREMENT IT (FOR NEXT LOOP)
	LD	(IY),A			; UDPATE UNIT NUM
	
	; SETUP FOR GENERIC INIT ROUTINE
	LD	A,(IY + 3)		; GET FEATURES BYTE
	LD	(UART_FUNC),A		; SAVE IT

	; RESET FEATURE BITS
	LD	HL,UART_FEAT		; HL POINTS TO FEATURE FLAGS BYTE
	XOR	A			; RESET ALL FEATURES
	LD	(HL),A			; SAVE IT

	; START OF UART INITIALIZATION, SET BAUD RATE
	LD	A,80H
	UART_OUTP(UART_LCR)		; DLAB ON
	CALL	UART_COMPDIV		; COMPUTE DIVISOR TO BC
	LD	A,B
	UART_OUTP(UART_DLM)		; SET DIVISOR (MS)
	LD	A,C
	UART_OUTP(UART_DLL)		; SET DIVISOR (LS)
	
	; SET LCR TO DEFAULT
	LD	A,$03			; DLAB OFF, 8 DATA, 1 STOP, NO PARITY
	UART_OUTP(UART_LCR)		; SAVE IT

	; SET MCR TO DEFAULT
	LD	A,$03			; DTR + RTS
	UART_OUTP(UART_MCR)		; SAVE IT
	
	LD	A,(UART_TYPE)		; GET UART TYPE
	CP	UART_16550A		; 16550A OR BETTER?
	JP	C,UART_INITP1		; NOPE, SKIP FIFO & AFC FEATURES

	LD	B,0			; START BY ASSUMING NO FIFOS, FCR=0
	LD	A,(UART_FUNC)		; LOAD FIFO ENABLE REQUEST VALUE
	BIT	UART_FIFO,A		; TEST FOR FIFO REQUESTED
	JR	Z,UART_FIFO1		; NOPE
	LD	B,$07			; VALUE TO ENABLE AND RESET FIFOS
	LD	HL,UART_FEAT		; HL POINTS TO FEATURE FLAGS BYTE
	SET	UART_FIFO,(HL)		; RECORD FEATURE ENABLED
UART_FIFO1:
	LD	A,B			; MOVE VALUE TO A
	UART_OUTP(UART_FCR)		; DO IT

	LD	A,(UART_TYPE)		; GET UART TYPE
	CP	UART_16550C		; 16550C OR BETTER?
	JR	C,UART_INITP1		; NOPE, SKIP AFC FEATURES

	; BRANCH BASED ON TYPE AFC CONFIGURATION (EFR OR MCR)
	LD	A,(UART_TYPE)		; GET UART TYPE
	CP	UART_16650		; 16650?
	JR	Z,UART_AFC2		; USE EFR REGISTER
	CP	UART_16850		; 16750?
	JR	Z,UART_AFC2		; USE EFR REGISTER
	
	; SET AFC VIA MCR
	LD	B,$03			; START WITH DEFAULT MCR
	LD	A,(UART_FUNC)		; LOAD AFC ENABLE REQUEST VALUE
	BIT	UART_AFC,A		; TEST FOR AFC REQUESTED
	JR	Z,UART_AFC1		; NOPE
	SET	5,B			; SET MCR BIT TO ENABLE AFC
	LD	HL,UART_FEAT		; HL POINTS TO FEATURE FLAGS BYTE
	SET	UART_AFC,(HL)		; RECORD FEATURE ENABLED
UART_AFC1:
	LD	A,B			; MOVE VALUE TO Ar
	UART_OUTP(UART_MCR)		; SET AFC VALUE VIA MCR
	JR	UART_INITP1		; AND CONTINUE
	
UART_AFC2:	; SET AFC VIA EFR
	LD	A,$BF			; VALUE TO ACCESS EFR
	UART_OUTP(UART_LCR)		; SET VALUE IN LCR
	
	LD	B,0			; ASSUME AFC OFF, EFR=0
	LD	A,(UART_FUNC)		; LOAD AFC ENABLE REQUEST VALUE
	BIT	UART_AFC,A		; TEST FOR AFC REQUESTED
	JR	Z,UART_AFC3		; NOPE
	LD	B,$C0			; ENABLE CTS/RTS FLOW CONTROL
	LD	HL,UART_FEAT		; HL POINTS TO FEATURE FLAGS BYTE
	SET	UART_AFC,(HL)		; RECORD FEATURE ENABLED
UART_AFC3:
	LD	A,B			; MOVE VALUE TO A
	UART_OUTP(UART_EFR)		; SAVE IT
	LD	A,$03			; NORMAL LCR VALUE
	UART_OUTP(UART_LCR)		; SAVE IT

UART_INITP1:
#IF (UART_DEBUG)
	PRTS(" [$")
	
	; DEBUG: DUMP UART TYPE
	LD	A,(UART_TYPE)
	CALL	PRTHEXBYTE

	; DEBUG: DUMP IIR
	UART_INP(UART_IIR)
	CALL	PC_SPACE
	CALL	PRTHEXBYTE

	; DEBUG: DUMP LCR
	UART_INP(UART_LCR)
	CALL	PC_SPACE
	CALL	PRTHEXBYTE

	; DEBUG: DUMP MCR
	UART_INP(UART_MCR)
	CALL	PC_SPACE
	CALL	PRTHEXBYTE

	; DEBUG: DUMP EFR
	LD	A,$BF
	UART_OUTP(UART_LCR)
	UART_INP(UART_EFR)
	PUSH	AF
	LD	A,$03
	UART_OUTP(UART_LCR)
	POP	AF
	CALL	PC_SPACE
	CALL	PRTHEXBYTE
	
	PRTC(']')
#ENDIF
	
	; ANNOUNCE PORT
	CALL	NEWLINE			; FORMATTING
	PRTS("UART$")			; FORMATTING
	LD	A,(IY)			; DEVICE NUM
	CALL	PRTDECB			; PRINT DEVICE NUM
	PRTS(": IO=0x$")		; FORMATTING
	LD	A,(IY + 1)		; GET BASE PORT
	CALL	PRTHEXBYTE		; PRINT BASE PORT

	; PRINT THE UART TYPE
	LD	A,(UART_TYPE)
	RLCA
	LD	HL,UART_TYPE_MAP
	LD	D,0
	LD	E,A
	ADD	HL,DE			; HL NOW POINTS TO MAP ENTRY
	LD	A,(HL)
	INC	HL
	LD	D,(HL)
	LD	E,A			; HL NOW POINTS TO STRING
	CALL	PC_SPACE
	CALL	WRITESTR		; PRINT THE STRING
;
	; ALL DONE IF NO UART WAS DETECTED
	LD	A,(UART_TYPE)
	OR	A
	JR	Z,UART_INITP3
;
	; PRINT BAUD RATE
	PRTS(" BAUD=$")
;	CALL	PRTDEC
	
	; BAUD RATE -> DE:HL
	PUSH	IY			; DATA PTR
	POP	HL			; ... TO HL
	INC	HL
	INC	HL
	INC	HL
	INC	HL
	CALL	LD32			; BAUD RATE -> DE:HL
	LD	BC,UART_INITBUF
	CALL	BIN2BCD
	CALL	PRTBCD
;
	; PRINT FEATURES ENABLED
	LD	A,(UART_FEAT)
	BIT	UART_FIFO,A
	JR	Z,UART_INITP2
	PRTS(" FIFO$")
UART_INITP2:
	BIT	UART_AFC,A
	JR	Z,UART_INITP3
	PRTS(" AFC$")
UART_INITP3:
;
	RET
;
UART_INITBUF	.FILL	5,0		; WORKING BUFFER FOR BCD NUMBER
;
; UART DETECTION ROUTINE
;
UART_DETECT:
;
	; SEE IF UART IS THERE BY CHECKING DLAB FUNCTIONALITY
	XOR	A			; ZERO ACCUM
	UART_OUTP(UART_IER)		; IER := 0
	LD	A,$80			; DLAB BIT ON
	UART_OUTP(UART_LCR)		; OUTPUT TO LCR (DLAB REGS NOW ACTIVE)
	LD	A,$5A			; LOAD TEST VALUE
	UART_OUTP(UART_DLM)		; OUTPUT TO DLM
	UART_INP(UART_DLM)		; READ IT BACK
	CP	$5A			; CHECK FOR TEST VALUE
	JP	NZ,UART_DETECT_NONE	; NOPE, UNKNOWN UART OR NOT PRESENT
	XOR	A			; DLAB BIT OFF
	UART_OUTP(UART_LCR)		; OUTPUT TO LCR (DLAB REGS NOW INACTIVE)
	UART_INP(UART_IER)		; READ IER
	CP	$5A			; CHECK FOR TEST VALUE
	JP	Z,UART_DETECT_NONE	; IF STILL $5A, UNKNOWN OR NOT PRESENT
;
	; TEST FOR FUNCTIONAL SCRATCH REG, IF NOT, WE HAVE AN 8250
	LD	A,$5A			; LOAD TEST VALUE
	UART_OUTP(UART_SCR)		; PUT IT IN SCRATCH REGISTER
	UART_INP(UART_SCR)		; READ IT BACK
	CP	$5A			; CHECK IT
	JR	NZ,UART_DETECT_8250	; STUPID 8250
;
	; TEST FOR EFR REGISTER WHICH IMPLIES 16650/850
	LD	A,$BF			; VALUE TO ENABLE EFR
	UART_OUTP(UART_LCR)		; WRITE IT TO LCR
	UART_INP(UART_SCR)		; READ SCRATCH REGISTER
	CP	$5A			; SPR STILL THERE?
	JR	NZ,UART_DETECT1		; NOPE, HIDDEN, MUST BE 16650/850
;
	; RESET LCR TO DEFAULT
	LD	A,$80			; DLAB BIT ON
	UART_OUTP(UART_LCR)		; RESET LCR
;
	; TEST FCR TO ISOLATE 16450/550/550A
	LD	A,$E7			; TEST VALUE
	UART_OUTP(UART_FCR)		; PUT IT IN FCR
	UART_INP(UART_IIR)		; READ BACK FROM IIR
	BIT	6,A			; BIT 6 IS FIFO ENABLE, LO BIT
	JR	Z,UART_DETECT_16450	; IF NOT SET, MUST BE 16450
	BIT	7,A			; BIT 7 IS FIFO ENABLE, HI BIT
	JR	Z,UART_DETECT_16550	; IF NOT SET, MUST BE 16550
	BIT	5,A			; BIT 5 IS 64 BYTE FIFO
	JR	Z,UART_DETECT2		; IF NOT SET, MUST BE 16550A/C
	JR	UART_DETECT_16750	; ONLY THING LEFT IS 16750
;
UART_DETECT1:	; PICK BETWEEN 16650/850
	; NOT SURE HOW TO DIFFERENTIATE 16650 FROM 16850 YET
	JR	UART_DETECT_16650	; ASSUME 16650
	RET
;
UART_DETECT2:	; PICK BETWEEN 16550A/C
	; SET AFC BIT IN FCR
	LD	A,$20			; SET AFC BIT, MCR:5
	UART_OUTP(UART_MCR)		; WRITE NEW FCR VALUE
;
	; READ IT BACK, IF SET, WE HAVE 16550C
	UART_INP(UART_MCR)		; READ BACK MCR
	BIT	5,A			; CHECK AFC BIT
	JR	Z,UART_DETECT_16550A	; NOT SET, SO 16550A
	JR	UART_DETECT_16550C	; IS SET, SO 16550C
;
UART_DETECT_NONE:
	LD	A,(IY + 1)
	CP	$68
	JR	Z,UART_DETECT_8250	; SPECIAL CASE FOR PRIMARY UART!
	LD	A,UART_NONE
	RET
;
UART_DETECT_8250:
	LD	A,UART_8250
	RET
;
UART_DETECT_16450:
	LD	A,UART_16450
	RET
;
UART_DETECT_16550:
	LD	A,UART_16550
	RET
;
UART_DETECT_16550A:
	LD	A,UART_16550A
	RET
;
UART_DETECT_16550C:
	LD	A,UART_16550C
	RET
;
UART_DETECT_16650:
	LD	A,UART_16650
	RET
;
UART_DETECT_16750:
	LD	A,UART_16750
	RET
;
UART_DETECT_16850:
	LD	A,UART_16850
	RET
;
; COMPUTE DIVISOR TO BC
;
UART_COMPDIV:
	; SETUP DE:HL WITH OSC FREQUENCY
	;LD	DE,(UART_OSCHI)
	;LD	HL,(UART_OSCLO)
	LD	DE,UARTOSC >> 16	; GET HI WORD OF UART OSC FREQ
	LD	HL,UARTOSC & $FFFF	; GET LO WORD OF UART OSC FREQ
	; DIVIDE OSC FREQ BY PRESCALE FACTOR OF 16
	LD	B,4	; 4 ITERATIONS
UART_COMPDIV1:
	SRL	D
	RR	E
	RR	H
	RR	L
	DJNZ	UART_COMPDIV1
	; CONVERT FROM DE:HL -> A:HL (THROW AWAY HIGH BYTE)
	LD	A,E
	PUSH	AF
	PUSH	HL
	; SETUP C:DE WITH TARGET BAUD RATE
	;LD	BC,(UART_BAUDHI)
	;LD	DE,(UART_BAUDLO)
	PUSH	IY
	POP	HL
	INC	HL
	INC	HL
	INC	HL
	INC	HL
	CALL	LD32
	PUSH	DE
	POP	BC
	EX	DE,HL
	; RECOVER OSC FREQ IN A:HL
	POP	HL
	POP	AF
	; DIVIDE OSC FREQ AND BAUD BY 2 UNTIL FREQ FITS IN 16 BITS
UART_COMPDIV2:
	SRL	A
	RR	H
	RR	L
	SRL	C
	RR	D
	RR	E
	OR	A
	JR	NZ,UART_COMPDIV2
	; DIVIDE ADJUSTED VALUES (OSC FREQ / BAUD RATE)
	CALL	DIV16
	RET
;
; ROUTINES TO READ/WRITE PORTS INDIRECTLY
;
; READ VALUE OF UART PORT ON TOS INTO REGISTER A
;
UART_INP_IMP:
	EX	(SP),HL		; SWAP HL AND TOS
	PUSH	BC		; PRESERVE BC
	LD	A,(IY + 1)	; GET UART IO BASE PORT
	OR	(HL)		; OR IN REGISTER ID BITS
	LD	C,A		; C := PORT
	IN	A,(C)		; READ PORT INTO A
	POP	BC		; RESTORE BC
	INC	HL		; BUMP HL PAST REG ID PARM
	EX	(SP),HL		; SWAP BACK HL AND TOS
	RET
;
; WRITE VALUE IN REGISTER A TO UART PORT ON TOS
;
UART_OUTP_IMP:
	EX	(SP),HL		; SWAP HL AND TOS
	PUSH	BC		; PRESERVE BC
	LD	B,A		; PUT VALUE TO WRITE IN B
	LD	A,(IY + 1)	; GET UART IO BASE PORT
	OR	(HL)		; OR IN REGISTER ID BITS
	LD	C,A		; C := PORT
	OUT	(C),B		; WRITE VALUE TO PORT
	POP	BC		; RESTORE BC
	INC	HL		; BUMP HL PAST REG ID PARM
	EX	(SP),HL		; SWAP BACK HL AND TOS
	RET
;
;
;
UART_TYPE_MAP:
			.DW	UART_STR_NONE
			.DW	UART_STR_8250
			.DW	UART_STR_16450
			.DW	UART_STR_16550
			.DW	UART_STR_16550A
			.DW	UART_STR_16550C
			.DW	UART_STR_16650
			.DW	UART_STR_16750
			.DW	UART_STR_16850

UART_STR_NONE		.DB	"<NOT PRESENT>$"
UART_STR_8250		.DB	"8250$"
UART_STR_16450		.DB	"16450$"
UART_STR_16550		.DB	"16550$"
UART_STR_16550A		.DB	"16550A$"
UART_STR_16550C		.DB	"16550C$"
UART_STR_16650		.DB	"16650$"
UART_STR_16750		.DB	"16750$"
UART_STR_16850		.DB	"16850$"
;
; WORKING VARIABLES
;
UART_TYPE		.DB	0		; UART TYPE DISCOVERED
UART_FUNC		.DB	0		; UART FUNCTIONS REQUESTED
UART_FEAT		.DB	0		; UART FEATURES DISCOVERED
UART_DEV		.DB	0		; DEVICE NUM USED DURING INIT
;
; UART PORT TABLE
;
UART_CFG:
#IF (UARTCNT >= 1)
	.DB	0				; DEVICE NUMBER (UPDATED DURING INIT)
	.DB	UART0IOB			; IO PORT BASE (RBR, THR)
	.DB	UART0IOB + UART_LSR		; LINE STATUS PORT (LSR)
	.DB	UART0FEAT
	.DW	UART0BAUD & $FFFF
	.DW	UART0BAUD >> 16
#ENDIF
#IF (UARTCNT >= 2)
	.DB	0				; DEVICE NUMBER (UPDATED DURING INIT)
	.DB	UART1IOB			; IO PORT BASE
	.DB	UART1IOB + UART_LSR		; LINE STATUS PORT (LSR)
	.DB	UART1FEAT
	.DW	UART1BAUD & $FFFF
	.DW	UART1BAUD >> 16
#ENDIF
#IF (UARTCNT >= 3)
	.DB	0				; DEVICE NUMBER (UPDATED DURING INIT)
	.DB	UART2IOB			; IO PORT BASE
	.DB	UART2IOB + UART_LSR		; LINE STATUS PORT (LSR)
	.DB	UART2FEAT
	.DW	UART2BAUD & $FFFF
	.DW	UART2BAUD >> 16
#ENDIF
#IF (UARTCNT >= 4)
	.DB	0				; DEVICE NUMBER (UPDATED DURING INIT)
	.DB	UART3IOB			; IO PORT BASE
	.DB	UART3IOB + UART_LSR		; LINE STATUS PORT (LSR)
	.DB	UART3FEAT
	.DW	UART3BAUD & $FFFF
	.DW	UART3BAUD >> 16
#ENDIF
#IF (UARTCNT >= 5)
	.DB	0				; DEVICE NUMBER (UPDATED DURING INIT)
	.DB	UART4IOB			; IO PORT BASE
	.DB	UART4IOB + UART_LSR		; LINE STATUS PORT (LSR)
	.DB	UART4FEAT
	.DW	UART4BAUD & $FFFF
	.DW	UART4BAUD >> 16
#ENDIF
#IF (UARTCNT >= 6)
	.DB	0				; DEVICE NUMBER (UPDATED DURING INIT)
	.DB	UART5IOB			; IO PORT BASE
	.DB	UART5IOB + UART_LSR		; LINE STATUS PORT (LSR)
	.DB	UART5FEAT
	.DW	UART5BAUD & $FFFF
	.DW	UART5BAUD >> 16
#ENDIF
#IF (UARTCNT >= 7)
	.DB	0				; DEVICE NUMBER (UPDATED DURING INIT)
	.DB	UART6IOB			; IO PORT BASE
	.DB	UART6IOB + UART_LSR		; LINE STATUS PORT (LSR)
	.DB	UART6FEAT
	.DW	UART6BAUD & $FFFF
	.DW	UART6BAUD >> 16
#ENDIF
#IF (UARTCNT >= 8)
	.DB	0				; DEVICE NUMBER (UPDATED DURING INIT)
	.DB	UART7IOB			; IO PORT BASE
	.DB	UART7IOB + UART_LSR		; LINE STATUS PORT (LSR)
	.DB	UART7FEAT
	.DW	UART7BAUD & $FFFF
	.DW	UART7BAUD >> 16
#ENDIF