;
;==================================================================================================
; PARPORTPROP DRIVER
;==================================================================================================
;
; TODO:
;   1) ADD SUPPORT FOR DSKY
;
PPP_IO		.EQU	PPIBASE + 0	; PPP DATA I/O (PPI PORT A)
PPP_CTL		.EQU	PPIBASE + 2	; PPP CTL LINES (PPI PORT C)
PPP_PPICTL	.EQU	PPIBASE + 3	; PPI CONTROL PORT
;
; COMMAND BYTES
;
PPP_CMDNOP	.EQU	$00		; DO NOTHING
PPP_CMDECHOBYTE	.EQU	$01		; RECEIVE A BYTE, INVERT IT, SEND IT BACK
PPP_CMDECHOBUF	.EQU	$02		; RECEIVE 512 BYTE BUFFER, SEND IT BACK
;
PPP_CMDDSKRES	.EQU	$10		; RESTART SD CARD SUPPORT
PPP_CMDDSKSTAT	.EQU	$11		; SEND LAST SD CARD STATUS (4 BYTES)
PPP_CMDDSKPUT	.EQU	$12		; PPI -> SECTOR BUFFER -> PPP
PPP_CMDDSKGET	.EQU	$13		; PPP -> SECTOR BUFFER -> PPI
PPP_CMDDSKRD	.EQU	$14		; READ SCTOR FROM SD CARD INTO PPP BUFFER, RETURN 1 BYTE STATUS
PPP_CMDDSKWR	.EQU	$15		; WRITE SECTOR TO SD CARD FROM PPP BUFFER, RETURN 1 BYTE STATUS
PPP_CMDDSKTYPE	.EQU	$16		; GET SD CARD TYPE
PPP_CMDDSKCAP	.EQU	$17		; GET CURRENT DISK CAPACITY
PPP_CMDDSKCSD	.EQU	$18		; GET CURRENT SD CARD CSD REGISTER
;
PPP_CMDVIDOUT	.EQU	$20		; WRITE A BYTE TO THE TERMINAL EMULATOR
;
PPP_CMDKBDSTAT	.EQU	$30		; RETURN A BYTE WITH NUMBER OF CHARACTERS IN BUFFER
PPP_CMDKBDRD	.EQU	$31		; RETURN A CHARACTER, WAIT IF NECESSARY
;
PPP_CMDSPKTONE	.EQU	$40		; EMIT SPEAKER TONE AT SPECIFIED FREQUENCY AND DURATION
;
PPP_CMDSIOINIT	.EQU	$50		; RESET SERIAL PORT AND ESTABLISH A NEW BAUD RATE (4 BYTE BAUD RATE)
PPP_CMDSIORX	.EQU	$51		; RECEIVE A BYTE IN FROM SERIAL PORT
PPP_CMDSIOTX	.EQU	$52		; TRANSMIT A BYTE OUT OF THE SERIAL PORT
PPP_CMDSIORXST	.EQU	$53		; SERIAL PORT RECEIVE STATUS (RETURNS # BYTES OF RX BUFFER USED)
PPP_CMDSIOTXST	.EQU	$54		; SERIAL PORT TRANSMIT STATUS (RETURNS # BYTES OF TX BUFFER SPACE AVAILABLE)
PPP_CMDSIORXFL	.EQU	$55		; SERIAL PORT RECEIVE BUFFER FLUSH
PPP_CMDSIOTXFL	.EQU	$56		; SERIAL PORT TRANSMIT BUFFER FLUSH (NOT IMPLEMENTED)
;
PPP_CMDRESET	.EQU	$F0		; SOFT RESET PROPELLER
PPP_CMDVER	.EQU	$F1		; SEND FIRMWARE VERSION
;
; GLOBAL PARPORTPROP INITIALIZATION
;
PPP_INIT:
	CALL	NEWLINE			; FORMATTING
	PRTS("PPP: IO=0x$")
	LD	A,PPIBASE
	CALL	PRTHEXBYTE
;
	CALL	PPP_INITPPP		; INIT PPP BOARD
	RET	NZ			; BAIL OUT ON ERROR
;
	CALL	PPP_DETECT		; DETECT PPP PRESENCE
	;CALL	PC_SPACE		; *DEBUG*
	;CALL	PRTHEXWORD		; *DEBUG*
	LD	DE,PPP_STR_NOHW		; PREPARE FOR NOT PRESENT
	JP	NZ,WRITESTR		; BAIL OUT WITH NZ IF NOT DETECTED
;
	CALL	PPP_GETVER		; GET F/W VERSION
	RET	NZ			; ABORT ON FAILURE
;
	; PRINT FIRMWARE VERSION
	PRTS(" F/W=$")
	LD	HL,PPP_FWVER
	CALL	LD32
	LD	A,D
	CALL	PRTDECB
	CALL	PC_PERIOD
	LD	A,E
	CALL	PRTDECB
	CALL	PC_PERIOD
	CALL	PRTDEC
;
	; CHECK F/W VERSION & NOTIFY USER IF UPGRADE REQUIRED
	LD	HL,PPP_FWVER
	CALL	LD32
	XOR	A
	CP	D
	JR	NZ,PPP_INIT1
	CP	E
	JR	NZ,PPP_INIT1
	LD	DE,PPP_STR_UPGRADE
	CALL	WRITESTR
;
PPP_INIT1:
	CALL	PPPCON_INIT		; CONSOLE INITIALIZATION
	CALL	PPPSD_INIT		; SD CARD INITIALIZATION
;
	RET
;
;
;
PPP_INITPPP:
	; SETUP PARALLEL PORT (8255)
	LD	A,%11000010		; PPI MODE 2 (BI HANDSHAKE), PC0-2 OUT, PB IN
	OUT	(PPP_PPICTL),A		; NOTE: ALL OUTPUTS SET TO LOGIC ZERO ON MODE CHANGE
	CALL	DELAY			; PROBABLY NOT NEEDED
	
	; RESET PROPELLER
	LD	A,%00000101		; SET PC2 (ASSERT PROP RESET LINE)
	OUT	(PPP_PPICTL),A
	CALL	DELAY			; PROBABLY NOT NEEDED
	IN	A,(PPP_IO)		; CLEAR GARBAGE???
	CALL	DELAY			; PROBABLY NOT NEEDED
	LD	A,%00000001		; SET PC0 (CMD FLAG)
	OUT	(PPP_PPICTL),A		; DO IT
	LD	A,PPP_CMDRESET		; RESET COMMAND
	CALL	PPP_PUTBYTE		; SEND IT
	CALL	DELAY			; DELAY FOR PPP TO PROCESS COMMAND
	LD	A,%00000000		; CLEAR PC0 (CMD FLAG)
	OUT	(PPP_PPICTL),A		; DO IT
	LD	A,%00000100		; CLEAR PC2 (DEASSERT PROP RESET LINE)
	OUT	(PPP_PPICTL),A		; DO IT
	;CALL	DELAY			; PROBABLY NOT NEEDED
	LD	DE,1024			; ONE SECOND
	CALL	VDELAY			; ... DELAY

	XOR	A			; SIGNAL SUCCESS
	RET
;
;
;
PPP_DETECT:
	LD	BC,4096			; TRY FOR ABOUT 4 SECONDS
PPP_DETECT1:
	LD	DE,64			; 1 MS
	CALL	VDELAY

	IN	A,(PPP_CTL)
	BIT	5,A
	JR	Z,PPP_DETECT2

	IN	A,(PPP_IO)
	;CALL	PC_SPACE
	;CALL	PRTHEXBYTE
	CP	$AA
	RET	Z			; RETURN IF MATCH
;
PPP_DETECT2:
	DEC	BC
	LD	A,B
	OR	C
	JR	NZ,PPP_DETECT1
	OR	$FF			; SIGNAL FAILURE
	RET
;
;
;
PPP_GETVER:
#IF (PPPSDTRACE >= 3)
	CALL	PPP_PRTPREFIX
	PRTS(" VER$")
#ENDIF
	LD	D,PPP_CMDVER		; COMMAND = GET VERSION
	CALL	PPP_SNDCMD		; SEND COMMAND
	RET	NZ
	LD	B,4			; GET 4 BYTES
	LD	HL,PPP_FWVER
PPP_GETVER1:
	CALL	PPP_GETBYTE
	LD	(HL),A
	INC	HL
	DJNZ	PPP_GETVER1
;
#IF (PPPSDTRACE >= 3)
	CALL	PC_SPACE
	LD	HL,PPP_FWVER
	CALL	LD32
	CALL	PRTHEX32
#ENDIF
;
	XOR	A			; SIGNAL SUCCESS
	RET
;
;
;
PPP_SNDCMD:
	IN	A,(PPP_IO)		; DISCARD ANYTHING PENDING
	; WAIT FOR OBF HIGH (OUTPUT BUFFER TO BE EMPTY)
	IN	A,(PPP_CTL)
	BIT	7,A
	JR	Z,PPP_SNDCMD

	LD	A,%00000001		; SET CMD FLAG
	OUT	(PPP_PPICTL),A		; SEND IT

PPP_SNDCMD0:
	IN	A,(PPP_CTL)
	BIT	7,A
	JR	Z,PPP_SNDCMD0
	LD	A,D
	OUT	(PPP_IO),A

PPP_SNDCMD1:
	; WAIT FOR OBF HIGH (BYTE HAS BEEN RECEIVED)
	IN	A,(PPP_CTL)
	BIT	7,A
	JR	Z,PPP_SNDCMD1
	; TURN OFF CMD
	LD	A,%00000000		; CLEAR CMD FLAG
	OUT	(PPP_PPICTL),A

	XOR	A			; SIGNAL SUCCESS
	RET
;
;
;
PPP_PUTBYTE:
	PUSH	AF
PPP_PUTBYTE1:
	IN	A,(PPP_CTL)
	BIT	7,A
	JR	Z,PPP_PUTBYTE1
	POP	AF
	OUT	(PPP_IO),A
	RET
;
;
;
PPP_GETBYTE:
	IN	A,(PPP_CTL)
	BIT	5,A
	JR	Z,PPP_GETBYTE
	IN	A,(PPP_IO)
	RET
;
; PRINT DIAGNONSTIC PREFIX
;
PPP_PRTPREFIX:
	CALL	NEWLINE
	PRTS("PPP:$")
	RET
;
;
;
PPP_STR_NOHW		.TEXT	" NOT PRESENT$"
PPP_STR_UPGRADE		.TEXT	" !!!UPGRADE REQUIRED!!!$"
;
PPP_FWVER		.DB	$00, $00, $00, $00	; MMNNBBB (M=MAJOR, N=MINOR, B=BUILD)
;
;==================================================================================================
; PARPORTPROP CONSOLE DRIVER
;==================================================================================================
;
PPPCON_INIT:
	CALL	NEWLINE
	PRTS("PPPCON:$")
;
; ADD OURSELVES TO CIO DISPATCH TABLE
;
	;LD	B,0			; PHYSICAL UNIT IS ZERO
	;LD	C,CIODEV_PPPCON		; DEVICE TYPE
	;LD	DE,0			; UNIT DATA BLOB ADDRESS
	LD	D,0			; PHYSICAL UNIT IS ZERO
	LD	E,CIODEV_PPPCON		; DEVICE TYPE
	LD	BC,PPPCON_DISPATCH	; BC := DISPATCH ADDRESS
	CALL	CIO_ADDENT		; ADD ENTRY, A := UNIT ASSIGNED
	LD	(HCB + HCB_CRTDEV),A	; SET OURSELVES AS THE CRT DEVICE
;
	XOR	A
	RET
;
; DISPATCH FOR CONSOLE SUBFUNCTIONS
;
PPPCON_DISPATCH:
	LD	A,B			; GET REQUESTED FUNCTION
	AND	$0F			; ISOLATE SUB-FUNCTION
	JR	Z,PPPCON_IN		; JUMP IF CHARACTER IN
	DEC	A			; NEXT SUBFUNCTION
	JR	Z,PPPCON_OUT		; JUMP IF CHARACTER OUT
	DEC	A			; NEXT SUBFUCNTION
	JR	Z,PPPCON_IST		; JUMP IF INPUT STATUS
	DEC	A			; NEXT SUBFUNCTION
	JR	Z,PPPCON_OST		; JUMP IF OUTPUT STATUS
	DEC	A			; NEXT SUBFUNCTION
	JR	Z,PPPCON_INITDEV	; JUMP IF INIT DEVICE
	DEC	A			; NEXT SUBFUNCTION
	JR	Z,PPPCON_QUERY		; JUMP IF QUERY
	DEC	A			; NEXT SUBFUNCTION
	JR	Z,PPPCON_DEVICE		; JUMP IF DEVICE REPORT
	CALL	PANIC			; OTHERWISE SOMETHING IS BADLY BROKEN
;
; CHARACTER INPUT
;   WAIT FOR A CHARACTER AND RETURN IT IN E
;
PPPCON_IN:
	CALL	PPPCON_IST		; CHECK FOR CHAR PENDING
	JR	Z,PPPCON_IN		; WAIT FOR IT IF NECESSARY
	LD	D,PPP_CMDKBDRD		; CMD = KEYBOARD READ
	CALL	PPP_SNDCMD		; SEND COMMAND
	CALL	PPP_GETBYTE		; GET CHARACTER READ
	LD	E,A			; PUT IN E
	XOR	A			; CLEAR A (SUCCESS)
	RET				; AND RETURN
;
; CHARACTER INPUT STATUS
;   RETURN STATUS IN A, 0 = NOTHING PENDING, > 0 CHAR PENDING
;
PPPCON_IST:
	LD	D,PPP_CMDKBDSTAT	; CMD = KEYBOARD STATUS
	CALL	PPP_SNDCMD		; SEND COMMAND
	CALL	PPP_GETBYTE		; GET RESPONSE
	OR	A			; SET FLAGS
	RET	NZ			; A <> 0, CHAR(S) PENDING
	JP	CIO_IDLE		; OTHERWISE RET VIA IDLE PROCESSING
;
; CHARACTER OUTPUT
;   WRITE CHARACTER IN E
;
PPPCON_OUT:
	CALL	PPPCON_OST		; CHECK FOR OUTPUT READY
	JR	Z,PPPCON_OUT		; WAIT IF NECESSARY
	LD	D,PPP_CMDVIDOUT		; CMD = VIDEO OUTPUT
	CALL	PPP_SNDCMD		; SEND COMMAND
	LD	A,E			; MOVE TO A
	CALL	PPP_PUTBYTE		; SEND IT
	RET				; RETURN
;
; CHARACTER OUTPUT STATUS
;   RETURN STATUS IN A, 0 = NOT READY, > 0 READY TO SEND
;   CONSOLE IS ALWAYS READY TO SEND (SYNCHRONOUS OUTPUT)
;
PPPCON_OST:
	XOR	A			; SET A=$01 TO SIGNAL READY
	INC	A
	RET
;
;
;
PPPCON_INITDEV:
	CALL	PANIC
;
;
;
PPPCON_QUERY:
	LD	DE,0
	LD	HL,0
	XOR	A
	RET
;
;
;
PPPCON_DEVICE:
	LD	D,CIODEV_PPPCON	; D := DEVICE TYPE
	LD	E,0		; E := DEVICE NUM, ALWAYS 0
	LD	C,$FF		; $FF MEANS TERM W/ NO ATTACHED VDA
	XOR	A		; SIGNAL SUCCESS
	RET
;
;==================================================================================================
; PARPORTPROP SD CARD DRIVER
;==================================================================================================
;
PPPSD_UNITCNT	.EQU	1
;
; SD CARD TYPE
;
PPPSD_TYPEUNK	.EQU	0		; CARD TYPE UNKNOWN/UNDETERMINED
PPPSD_TYPEMMC	.EQU	1		; MULTIMEDIA CARD (MMC STANDARD)
PPPSD_TYPESDSC	.EQU	2		; SDSC CARD (V1)
PPPSD_TYPESDHC	.EQU	3		; SDHC CARD (V2)
PPPSD_TYPESDXC	.EQU	4		; SDXC CARD (V3)
;
; SD CARD STATUS (PPPSD_STAT)
;
PPPSD_STOK	.EQU	0		; OK
PPPSD_STINVUNIT	.EQU	-1		; INVALID UNIT
PPPSD_STRDYTO	.EQU	-2		; TIMEOUT WAITING FOR CARD TO BE READY
PPPSD_STINITTO	.EQU	-3		; INITIALIZATOIN TIMEOUT
PPPSD_STCMDTO	.EQU	-4		; TIMEOUT WAITING FOR COMMAND RESPONSE
PPPSD_STCMDERR	.EQU	-5		; COMMAND ERROR OCCURRED (REF SD_RC)
PPPSD_STDATAERR	.EQU	-6		; DATA ERROR OCCURRED (REF SD_TOK)
PPPSD_STDATATO	.EQU	-7		; DATA TRANSFER TIMEOUT
PPPSD_STCRCERR	.EQU	-8		; CRC ERROR ON RECEIVED DATA PACKET
PPPSD_STNOMEDIA	.EQU	-9		; NO MEDIA IN CONNECTOR
PPPSD_STWRTPROT	.EQU	-10		; ATTEMPT TO WRITE TO WRITE PROTECTED MEDIA
;
; SD CARD INITIALIZATION
;
PPPSD_INIT:
;
; SETUP THE DISPATCH TABLE ENTRIES
;
	LD	B,0		; PHYSICAL UNIT
	LD	C,DIODEV_PPPSD	; DEVICE TYPE
	LD	DE,0		; UNIT DATA BLOB ADDRESS
	CALL	DIO_ADDENT	; ADD ENTRY, BC IS NOT DESTROYED
;
	; REINITIALIZE THE CARD HERE
	CALL	PPPSD_INITCARD
#IF (PPPSDTRACE < 2)
	JP	NZ,PPPSD_PRTSTAT	; IF ERROR, SHOW IT
#ENDIF
;
	CALL	NEWLINE
	PRTS("PPPSD:$")
;
	; PRINT CARD TYPE
	PRTS(" TYPE=$")
	CALL	PPPSD_PRTTYPE
;
	; PRINT STORAGE CAPACITY (BLOCK COUNT)
	PRTS(" BLOCKS=0x$")		; PRINT FIELD LABEL
	LD	HL,PPPSD_BLKCNT		; POINT TO BLOCK COUNT
	CALL	LD32			; GET THE CAPACITY VALUE
	CALL	PRTHEX32		; PRINT HEX VALUE
;
	; PRINT STORAGE SIZE IN MB
	PRTS(" SIZE=$")			; PRINT FIELD LABEL
	LD	B,11			; 11 BIT SHIFT TO CONVERT BLOCKS --> MB
	CALL	SRL32			; RIGHT SHIFT
	CALL	PRTDEC			; PRINT LOW WORD IN DECIMAL (HIGH WORD DISCARDED)
	PRTS("MB$")			; PRINT SUFFIX
;
	XOR	A			; SIGNAL SUCCESS
	RET
;
;
;
PPPSD_DISPATCH:
	; VERIFY AND SAVE THE TARGET DEVICE/UNIT LOCALLY IN DRIVER
	LD	A,C			; DEVICE/UNIT FROM C
	AND	$0F			; ISOLATE UNIT NUM
	CP	PPPSD_UNITCNT
	CALL	NC,PANIC		; PANIC IF TOO HIGH
	LD	(PPPSD_UNIT),A		; SAVE IT
;
	; DISPATCH ACCORDING TO DISK SUB-FUNCTION
	LD	A,B		; GET REQUESTED FUNCTION
	AND	$0F		; ISOLATE SUB-FUNCTION
	JP	Z,PPPSD_STATUS	; SUB-FUNC 0: STATUS
	DEC	A
	JP	Z,PPPSD_RESET	; SUB-FUNC 1: RESET
	DEC	A
	JP	Z,PPPSD_SEEK	; SUB-FUNC 2: SEEK
	DEC	A
	JP	Z,PPPSD_READ	; SUB-FUNC 3: READ SECTORS
	DEC	A
	JP	Z,PPPSD_WRITE	; SUB-FUNC 4: WRITE SECTORS
	DEC	A
	JP	Z,PPPSD_VERIFY	; SUB-FUNC 5: VERIFY SECTORS
	DEC	A
	JP	Z,PPPSD_FORMAT	; SUB-FUNC 6: FORMAT TRACK
	DEC	A
	JP	Z,PPPSD_DEVICE	; SUB-FUNC 7: DEVICE REPORT
	DEC	A
	JP	Z,PPPSD_MEDIA	; SUB-FUNC 8: MEDIA REPORT
	DEC	A
	JP	Z,PPPSD_DEFMED	; SUB-FUNC 9: DEFINE MEDIA
	DEC	A
	JP	Z,PPPSD_CAP	; SUB-FUNC 10: REPORT CAPACITY
	DEC	A
	JP	Z,PPPSD_GEOM	; SUB-FUNC 11: REPORT GEOMETRY
;
PPPSD_VERIFY:
PPPSD_FORMAT:
PPPSD_DEFMED:
	CALL	PANIC		; INVALID SUB-FUNCTION
;
; READ AN LBA BLOCK FROM THE SD CARD
;
PPPSD_READ:
	LD	(PPPSD_DSKBUF),HL	; SAVE DISK BUFFER ADDRESS

#IF (PPPSDTRACE == 1)
	LD	HL,PPPSD_PRTERR		; SET UP PPPSD_PRTERR
	PUSH	HL			; ... TO FILTER ALL EXITS
#ENDIF

	CALL	PPPSD_CHKCARD		; CHECK / REINIT CARD AS NEEDED
	RET	NZ			; BAIL OUT ON ERROR

#IF (PPPSDTRACE >= 3)
	CALL	PPPSD_PRTPREFIX
#ENDIF

#IF (PPPSDTRACE >= 3)
	PRTS(" READ$")
#ENDIF

	; READ A SECTOR
	LD	D,PPP_CMDDSKRD		; COMMAND = DSKRD
	CALL	PPP_SNDCMD		; SEND COMMAND
	RET	NZ

	CALL	PPPSD_SENDBLK		; SEND THE LBA BLOCK NUMBER
	CALL	PPP_GETBYTE		; GET READ RESULT
	LD	(PPPSD_DSKSTAT),A	; SAVE IT

#IF (PPPSDTRACE >= 3)
	CALL	PC_SPACE
	CALL	PRTHEXBYTE
#ENDIF

	OR	A			; SET FLAGS
	JR	Z,PPPSD_READ1

	; HANDLE ERROR
	CALL	PPPSD_GETDSKSTAT	; GET FULL ERROR CODE
	JP	PPPSD_ERRCMD		; HANDLE ERRORS

PPPSD_READ1:
	; GET THE SECTOR DATA
	LD	D,PPP_CMDDSKGET		; COMMAND = DSKGET
	CALL	PPP_SNDCMD		; SEND COMMAND
	RET	NZ

	; READ THE SECTOR DATA
	LD	BC,512
	LD	HL,(PPPSD_DSKBUF)
PPPSD_READ2:
	CALL	PPP_GETBYTE
	LD	(HL),A
	INC	HL
	DEC	BC
	LD	A,B
	OR	C
	JP	NZ,PPPSD_READ2

	XOR	A			; SIGNAL SUCCESS
	RET
;
; WRITE AN LBA BLOCK TO THE SD CARD
;
PPPSD_WRITE:
	LD	(PPPSD_DSKBUF),HL	; SAVE DISK BUFFER ADDRESS

#IF (PPPSDTRACE == 1)
	LD	HL,PPPSD_PRTERR		; SET UP PPPSD_PRTERR
	PUSH	HL			; ... TO FILTER ALL EXITS
#ENDIF

	CALL	PPPSD_CHKCARD		; CHECK / REINIT CARD AS NEEDED
	RET	NZ			; BAIL OUT ON ERROR

#IF (PPPSDTRACE >= 3)
	CALL	PPPSD_PRTPREFIX
#ENDIF

#IF (PPPSDTRACE >= 3)
	PRTS(" WRITE$")
#ENDIF

	; PUT THE SECTOR DATA
	LD	D,PPP_CMDDSKPUT		; COMMAND = DSKPUT
	CALL	PPP_SNDCMD		; SEND COMMAND
	RET	NZ

	; SEND OVER THE SECTOR CONTENTS
	LD	BC,512
	LD	HL,(PPPSD_DSKBUF)
PPPSD_WRITE1:
	LD	A,(HL)
	INC	HL
	CALL	PPP_PUTBYTE
	DEC	BC
	LD	A,B
	OR	C
	JP	NZ,PPPSD_WRITE1

	; WRITE THE SECTOR
	LD	D,PPP_CMDDSKWR		; COMMAND = DSKWR
	CALL	PPP_SNDCMD
	RET	NZ
	CALL	PPPSD_SENDBLK		; SEND THE LBA BLOCK NUMBER
	CALL	PPP_GETBYTE
	LD	(PPPSD_DSKSTAT),A	; SAVE IT

#IF (PPPSDTRACE >= 3)
	CALL	PC_SPACE
	CALL	PRTHEXBYTE
#ENDIF

	OR	A			; SET FLAGS
	RET	Z			; DONE IF NO ERRORS

	; HANDLE ERROR
	CALL	PPPSD_GETDSKSTAT	; GET FULL ERROR CODE
	JP	PPPSD_ERRCMD		; EXIT VIA ERROR HANDLER
;
; REPORT SD CARD READY STATE
;
PPPSD_STATUS:
	LD	A,(PPPSD_STAT)		; GET THE CURRENT READY STATUS
	OR	A
	RET
;
;
;
PPPSD_RESET:
	XOR	A		; ALWAYS OK
	RET
;
;
;
PPPSD_DEVICE:
	LD	D,DIODEV_PPPSD	; D := DEVICE TYPE
	LD	E,C		; E := PHYSICAL UNIT
	LD	C,%01010000	; C := ATTRIBUTES, REMOVABLE, SD CARD
	XOR	A		; SIGNAL SUCCESS
	RET
;
; SETUP FOR SUBSEQUENT ACCESS
; INIT CARD IF NOT READY OR ON DRIVE LOG IN
;
PPPSD_MEDIA:
	; REINITIALIZE THE CARD HERE TO DETERMINE PRESENCE
	CALL	PPPSD_INITCARD
#IF (PPPSDTRACE == 1)
	CALL	PPPSD_PRTERR		; PRINT ANY ERRORS
#ENDIF
	LD	E,MID_HD		; ASSUME WE ARE OK
	RET	Z			; RETURN IF GOOD INIT
	LD	E,MID_NONE		; SIGNAL NO MEDA
	RET				; AND RETURN
;
;
;
PPPSD_SEEK:
	BIT	7,D		; CHECK FOR LBA FLAG
	CALL	Z,HB_CHS2LBA	; CLEAR MEANS CHS, CONVERT TO LBA
	RES	7,D		; CLEAR FLAG REGARDLESS (DOES NO HARM IF ALREADY LBA)
	LD	BC,HSTLBA	; POINT TO LBA STORAGE
	CALL	ST32		; SAVE LBA ADDRESS
	XOR	A		; SIGNAL SUCCESS
	RET			; AND RETURN
;
;
;
PPPSD_CAP:
	LD	HL,PPPSD_BLKCNT		; GET BLOCK COUNT
	CALL	LD32			; GET THE CURRENT CAPACITY DO DE:HL
	LD	BC,512			; 512 BYTES PER BLOCK
	LD	A,(PPPSD_STAT)		; GET CURRENT STATUS
	OR	A			; SET FLAGS
	RET
;
;
;
PPPSD_GEOM:
	; FOR LBA, WE SIMULATE CHS ACCESS USING 16 HEADS AND 16 SECTORS
	; RETURN HS:CC -> DE:HL, SET HIGH BIT OF D TO INDICATE LBA CAPABLE
	CALL	PPPSD_CAP		; GET TOTAL BLOCKS IN DE:HL, BLOCK SIZE TO BC
	LD	L,H			; DIVIDE BY 256 FOR # TRACKS
	LD	H,E			; ... HIGH BYTE DISCARDED, RESULT IN HL
	LD	D,16 | $80		; HEADS / CYL = 16, SET LBA CAPABILITY BIT
	LD	E,16			; SECTORS / TRACK = 16
	RET				; DONE, A STILL HAS PPPSD_CAP STATUS
;
; TAKE ANY ACTIONS REQUIRED TO SELECT DESIRED PHYSICAL UNIT
; UNIT IS SPECIFIED IN A
;
PPPSD_SELUNIT:
	XOR	A			; SIGNAL SUCCESS
	RET				; DONE
;
; REINITIALIZE THE SD CARD
;
PPPSD_INITCARD:
	; CLEAR ALL STATUS DATA
	LD	HL,PPPSD_UNITDATA
	LD	BC,PPPSD_UNITDATALEN
	XOR	A
	CALL	FILL

#IF (PPPSDTRACE >= 3)
	CALL	PPPSD_PRTPREFIX
	PRTS(" RESET$")
#ENDIF

	; RESET & STATUS DISK
	LD	D,PPP_CMDDSKRES		; COMMAND = DSKRESET
	CALL	PPP_SNDCMD
	RET	NZ
	CALL	PPP_GETBYTE		; GET STATUS
	LD	(PPPSD_DSKSTAT),A	; SAVE STATUS

#IF (PPPSDTRACE >= 3)
	CALL	PC_SPACE
	CALL	PRTHEXBYTE
#ENDIF

	OR	A
	JR	Z,PPPSD_INITCARD1
	
	; HANDLE ERROR
	CALL	PPPSD_GETDSKSTAT	; GET FULL ERROR CODE
	;JP	PPPSD_ERRCMD		; HANDLE ERRORS
	JP	PPPSD_NOMEDIA		; RETURN W/ NO MEDIA ERROR

PPPSD_INITCARD1:

#IF (PPPSDTRACE >= 3)
	; GET CSD IF DEBUGGING
	CALL	PPPSD_GETCSD
	RET	NZ
#ENDIF

	; GET CARD TYPE
	CALL	PPPSD_GETTYPE
	RET	NZ

	; GET CAPACITY
	CALL	PPPSD_GETCAP
	RET	NZ

	RET
;
; CHECK THE SD CARD, ATTEMPT TO REINITIALIZE IF NEEDED
;
PPPSD_CHKCARD:
	LD	A,(PPPSD_STAT)		; GET STATUS
	OR	A			; SET FLAGS
	CALL	NZ,PPPSD_INITCARD	; INIT CARD IF NOT READY
	RET				; RETURN WITH STATUS IN A
;
;
;
PPPSD_GETDSKSTAT:
#IF (PPPSDTRACE >= 3)
	CALL	PPPSD_PRTPREFIX
	PRTS(" STAT$")
#ENDIF

	LD	D,PPP_CMDDSKSTAT	; COMMAND = GET DISK STATUS
	CALL	PPP_SNDCMD		; SEND COMMAND
	RET	NZ			; ABORT ON ERROR

	LD	B,4			; GET 4 BYTES
	LD	HL,PPPSD_ERRCODE	; TO ERROR CODE
PPPSD_GETDSKSTAT1:
	CALL	PPP_GETBYTE
	LD	(HL),A
	INC	HL
	DJNZ	PPPSD_GETDSKSTAT1

#IF (PPPSDTRACE >= 3)
	CALL	PC_SPACE
	LD	HL,PPPSD_ERRCODE
	CALL	LD32
	CALL	PRTHEX32
#ENDIF

	XOR	A
	RET
;
;
;
PPPSD_GETTYPE:
#IF (PPPSDTRACE >= 3)
	CALL	PPPSD_PRTPREFIX
	PRTS(" TYPE$")
#ENDIF

	LD	D,PPP_CMDDSKTYPE	; COMMAND = GET DISK TYPE
	CALL	PPP_SNDCMD		; SEND COMMAND
	RET	NZ			; ABORT ON ERROR
	CALL	PPP_GETBYTE		; GET DISK TYPE VALUE
	LD	(PPPSD_CARDTYPE),A	; SAVE IT

#IF (PPPSDTRACE >= 3)
	CALL	PC_SPACE
	CALL	PRTHEXBYTE
#ENDIF

	XOR	A			; SIGNAL SUCCESS
	RET
;
;
;
PPPSD_GETCAP:
#IF (PPPSDTRACE >= 3)
	CALL	PPPSD_PRTPREFIX
	PRTS(" CAP$")
#ENDIF

	LD	D,PPP_CMDDSKCAP		; COMMAND = GET CAPACITY
	CALL	PPP_SNDCMD		; SEND COMMAND
	RET	NZ			; ABORT ON ERROR

	LD	B,4			; GET 4 BYTES
	LD	HL,PPPSD_BLKCNT
PPPSD_GETCAP1:
	CALL	PPP_GETBYTE
	LD	(HL),A
	INC	HL
	DJNZ	PPPSD_GETCAP1

#IF (PPPSDTRACE >= 3)
	CALL	PC_SPACE
	LD	HL,PPPSD_BLKCNT
	CALL	LD32
	CALL	PRTHEX32
#ENDIF

	XOR	A
	RET
;
;
;
PPPSD_GETCSD:
#IF (PPPSDTRACE >= 3)
	CALL	PPPSD_PRTPREFIX
	PRTS(" CSD$")
#ENDIF

	LD	D,PPP_CMDDSKCSD		; COMMAND = GET CAPACITY
	CALL	PPP_SNDCMD		; SEND COMMAND
	RET	NZ			; ABORT ON ERROR

	LD	B,16			; GET 4 BYTES
	LD	HL,PPPSD_CSDBUF
PPPSD_GETCSD1:
	CALL	PPP_GETBYTE
	LD	(HL),A
	INC	HL
	DJNZ	PPPSD_GETCSD1

#IF (PPPSDTRACE >= 3)
	CALL	PC_SPACE
	LD	DE,PPPSD_CSDBUF
	LD	A,16
	CALL	PRTHEXBUF
#ENDIF

	XOR	A
	RET
;
; SEND INDEX OF BLOCK TO READ FROM SD CARD
; 32 BIT VALUE (4 BYTES)
; NOTE THAT BYTES ARE SENT REVERSED, PROPELLER IS LITTLE ENDIAN
;
PPPSD_SENDBLK:
#IF (PPPSDTRACE >= 3)
	PRTS(" BLK$")
#ENDIF

#IF (PPPSDTRACE >= 3)
	CALL	PC_SPACE
	LD	HL,HSTLBA
	CALL	LD32
	CALL	PRTHEX32
#ENDIF

	LD	HL,HSTLBA
	LD	B,4
PPPSD_SENDBLK1:
	LD	A,(HL)

	;CALL	PC_SPACE
	;CALL	PRTHEXBYTE

	INC	HL
	CALL	PPP_PUTBYTE
	DJNZ	PPPSD_SENDBLK1
	RET
;
;=============================================================================
; ERROR HANDLING AND DIAGNOSTICS
;=============================================================================
;
; ERROR HANDLERS
;
PPPSD_INVUNIT:
	LD	A,PPPSD_STINVUNIT
	JR	PPPSD_ERR2		; SPECIAL CASE FOR INVALID UNIT
;
PPPSD_ERRRDYTO:
	LD	A,PPPSD_STRDYTO
	JR	PPPSD_ERR
;
PPPSD_ERRINITTO:
	LD	A,PPPSD_STINITTO
	JR	PPPSD_ERR
;
PPPSD_ERRCMDTO:
	LD	A,PPPSD_STCMDTO
	JR	PPPSD_ERR
;
PPPSD_ERRCMD:
	LD	A,PPPSD_STCMDERR
	JR	PPPSD_ERR
;
PPPSD_ERRDATA:
	LD	A,PPPSD_STDATAERR
	JR	PPPSD_ERR
;
PPPSD_ERRDATATO:
	LD	A,PPPSD_STDATATO
	JR	PPPSD_ERR
;
PPPSD_ERRCRC:
	LD	A,PPPSD_STCRCERR
	JR	PPPSD_ERR
;
PPPSD_NOMEDIA:
	LD	A,PPPSD_STNOMEDIA
	JR	PPPSD_ERR
;
PPPSD_WRTPROT:
	LD	A,PPPSD_STWRTPROT
	JR	PPPSD_ERR2		; DO NOT UPDATE UNIT STATUS!
;
PPPSD_ERR:
	LD	(PPPSD_STAT),A		; UPDATE STATUS
PPPSD_ERR2:
#IF (PPPSDTRACE >= 2)
	CALL	PPPSD_PRTSTAT
#ENDIF
	OR	A			; SET FLAGS
	RET
;
;
;
PPPSD_PRTERR:
	RET	Z			; DONE IF NO ERRORS
	; FALL THRU TO PPPSD_PRTSTAT
;
; PRINT STATUS STRING
;
PPPSD_PRTSTAT:
	PUSH	AF
	PUSH	DE
	PUSH	HL
	OR	A
	LD	DE,PPPSD_STR_STOK
	JR	Z,PPPSD_PRTSTAT1
	INC	A
	LD	DE,PPPSD_STR_STINVUNIT
	JR	Z,PPPSD_PRTSTAT1	; INVALID UNIT IS SPECIAL CASE
	INC	A
	LD	DE,PPPSD_STR_STRDYTO
	JR	Z,PPPSD_PRTSTAT1
	INC	A
	LD	DE,PPPSD_STR_STINITTO
	JR	Z,PPPSD_PRTSTAT1
	INC	A
	LD	DE,PPPSD_STR_STCMDTO
	JR	Z,PPPSD_PRTSTAT1
	INC	A
	LD	DE,PPPSD_STR_STCMDERR
	JR	Z,PPPSD_PRTSTAT1
	INC	A
	LD	DE,PPPSD_STR_STDATAERR
	JR	Z,PPPSD_PRTSTAT1
	INC	A
	LD	DE,PPPSD_STR_STDATATO
	JR	Z,PPPSD_PRTSTAT1
	INC	A
	LD	DE,PPPSD_STR_STCRCERR
	JR	Z,PPPSD_PRTSTAT1
	INC	A
	LD	DE,PPPSD_STR_STNOMEDIA
	JR	Z,PPPSD_PRTSTAT1
	INC	A
	LD	DE,PPPSD_STR_STWRTPROT
	JR	Z,PPPSD_PRTSTAT1
	LD	DE,PPPSD_STR_STUNK
PPPSD_PRTSTAT1:
	CALL	PPPSD_PRTPREFIX		; PRINT UNIT PREFIX
	CALL	PC_SPACE		; FORMATTING
	CALL	WRITESTR
	LD	A,(PPPSD_STAT)
	CP	PPPSD_STCMDERR
	CALL	Z,PPPSD_PRTSTAT2
	POP	HL
	POP	DE
	POP	AF
	RET
PPPSD_PRTSTAT2:
	CALL	PC_SPACE
	LD	A,(PPPSD_DSKSTAT)
	CALL	PRTHEXBYTE
	CALL	PC_SPACE
	JP	PPPSD_PRTERRCODE
	RET

;
;
;
PPPSD_PRTERRCODE:
	PUSH	HL
	PUSH	DE
	LD	HL,PPPSD_ERRCODE
	CALL	LD32
	CALL	PRTHEX32
	POP	DE
	POP	HL
	RET
;
; PRINT DIAGNONSTIC PREFIX
;
PPPSD_PRTPREFIX:
	CALL	NEWLINE
	PRTS("PPPSD0:$")
	RET
;
; PRINT THE CARD TYPE
;
PPPSD_PRTTYPE:
	LD	A,(PPPSD_CARDTYPE)
	LD	DE,PPPSD_STR_TYPEMMC
	CP	PPPSD_TYPEMMC
	JR	Z,PPPSD_PRTTYPE1
	LD	DE,PPPSD_STR_TYPESDSC
	CP	PPPSD_TYPESDSC
	JR	Z,PPPSD_PRTTYPE1
	LD	DE,PPPSD_STR_TYPESDHC
	CP	PPPSD_TYPESDHC
	JR	Z,PPPSD_PRTTYPE1
	LD	DE,PPPSD_STR_TYPESDXC
	CP	PPPSD_TYPESDXC
	JR	Z,PPPSD_PRTTYPE1
	LD	DE,PPPSD_STR_TYPEUNK
PPPSD_PRTTYPE1:
	JP	WRITESTR
;
;=============================================================================
; STRING DATA
;=============================================================================
;
;
PPPSD_STR_STOK		.TEXT	"OK$"
PPPSD_STR_STINVUNIT	.TEXT	"INVALID UNIT$"
PPPSD_STR_STRDYTO	.TEXT	"READY TIMEOUT$"
PPPSD_STR_STINITTO	.TEXT	"INITIALIZATION TIMEOUT$"
PPPSD_STR_STCMDTO	.TEXT	"COMMAND TIMEOUT$"
PPPSD_STR_STCMDERR	.TEXT	"COMMAND ERROR$"
PPPSD_STR_STDATAERR	.TEXT	"DATA ERROR$"
PPPSD_STR_STDATATO	.TEXT	"DATA TIMEOUT$"
PPPSD_STR_STCRCERR	.TEXT	"CRC ERROR$"
PPPSD_STR_STNOMEDIA	.TEXT	"NO MEDIA$"
PPPSD_STR_STWRTPROT	.TEXT	"WRITE PROTECTED$"
PPPSD_STR_STUNK		.TEXT	"UNKNOWN$"
;
PPPSD_STR_TYPEUNK	.TEXT	"UNK$"
PPPSD_STR_TYPEMMC	.TEXT	"MMC$"
PPPSD_STR_TYPESDSC	.TEXT	"SDSC$"
PPPSD_STR_TYPESDHC	.TEXT	"SDHC$"
PPPSD_STR_TYPESDXC	.TEXT	"SDXC$"
;
;=============================================================================
; DATA STORAGE
;=============================================================================
;
PPPSD_UNIT		.DB	0
PPPSD_DSKBUF		.DW	0
;
PPPSD_UNITDATA:
PPPSD_STAT		.DB	0
PPPSD_DSKSTAT		.DB	0
PPPSD_ERRCODE		.DB	$00, $00, $00, $00
PPPSD_CARDTYPE		.DB	0
PPPSD_BLKCNT		.DB	$00, $00, $00, $00	; ASSUME 1GB (LITTLE ENDIAN DWORD)
PPPSD_CSDBUF		.FILL	16,0
PPPSD_UNITDATALEN	.EQU	$ - PPPSD_UNITDATA