Read/Wrte UART code

After adding RAM to my system I needed a way to test it. I decided that I would start by expanding on what I already knew - working with the UART - and read some data
from the serial terminal, via the UART, into RAM. To do this, I'd need to figure out how to read from the UART in the first place. As it turned out, I was testing my
RAM unintentionally - I was using a call/return in my code and had forgotten that it required a working writable stack space to do this. This ended up helping me figure
out that my RAM space address decoding was a load of cobblers, but initially gave me some frustrations.
Ignoring this, as it happens reading from the UART is just as easy as writing to it.

I should point out that the code below is far from peak efficiency - the right way to push a known string ("Ready") is to use a word define in assembly, but as I
said, I was starting from what I knew, and I knew how to send one character at a time, so that's the way I began.

; Set Divisor Latch Enable
Setup:
        ; Bring up OUT2 GPIO pin first, so we know things are starting like they're supposed to
        IN A,($04)
        OR 00001000b
        OUT ($04), A

        ; Set Divisor Latch Enable
        LD A,10000000b          ; Set Div Latch Enable to 1
        OUT ($03),A             ; Write LCR
        ; Set divisor to 104 (16mHz / 104 / 16 = 9615bps)
        LD A,$68
        OUT ($00),A             ; DLL 0x68 (#104)
        LD A,$00
        OUT ($01),A             ; DLM 0x00

        LD A,00000011b          ; Set DLE to 0, Break to 0, No parity, 1 stop bit, 8 bytes
        OUT ($03),A             ; Write now configured LCR

        LD C,$00                ; Write output UART port to reg C for use later
	LD SP,$ff00		; Initialise the stack pointer to $ff00 (it will grow DOWN in RAM)


Alert:				; Print a prompt so we know it's up
        LD B,'R'                ; Load first character to print into reg B
	CALL Output
	LD B,'e'
	CALL Output
	LD B,'a'
	CALL Output
	LD B, 'd'
	CALL Output
	LD B, 'y'
	CALL Output
	LD B, ':'
	CALL Output
	LD B, ' '
	CALL Output


Main:				; Main read/write loop
	CALL Input		; Read a byte from serial terminal
	CALL Output		; Echo it straight back out

	LD B, ' '		; Print a space between echo
	CALL Output
	
	JP Main

;; Take a character in register B and output to the UART, toggling the GPIO LED
Output:
        IN A,($04)              ; Toggle OUT1 GPIO LED
        XOR 00000100b
        OUT ($04), A

        OUT (C),B		; Send character to UART
LoopOut:			; Ensure the byte was transmitted
        IN A,($05)              ; Read LSR
        BIT 6,A                 ; Check bit 6 (THR empty, line idle)
        JP Z,LoopOut
        RET

;; Read a character from the UART and place in register B
Input:
LoopIn:
	IN A,($05)		; Read LSR
	BIT 0,A			; Check bit 0 (RHR byte ready)
	JP Z,LoopIn

	IN B,(C)		; Place ready character into B
	RET
  

What's it doing?
The initialisation of the UART works in the same manner as it does in the UART test code, the only addition is setting the stack pointer. I then, character by character, print
a banner - 'Ready: ' - to let me know it's working. The code then works as a very simple echo, by:

• Enter Main:, whose first instruction is to...
• Jump to Input:
• Poll the LSR checking to see if the Ready Holding Register has a byte ready (bit 0) - it will indicate this by holding a binary 1
• If a byte isn't available, jump back to LoopIn:
• Elsewise if a byte is available, read this byte from the RHR into register B
• Return to Main:'s next instruction, which is:
• Call Output: and toggle the /OUT1 LED and output the byte we just read (same way as we did in the UART test code)
• Load an ASCII space character into B, and Output: that, too
• Loop back to Main: to read the next byte