IDE_READ_LBA                            ;Read a Block of data from IDE device
;
; This routine requires loading the requested LBA into the appropriate registers and
; issuing the READ command 20h. The LBA count supported for the BIOS are bits 0-23,
; so bits 24-27 are always set to 0. This provides access to IDE devices up to 8GB.
;
; Once the registers/parameters are setup, the Read Block command is issued.
; This results in an interrupt being generated. The ISR handles the transfer of LBA
; data from the CF Card to memory.
;
; The registers used are the same for read/write/verify. These are:
;
;       IDE_COMMAND = function requested (20h = READ LBA command)
;       IDE_DRV_HEAD = (Upper 4 bits) used as:
;               bit 7 = 1 per Sandisk documentation
;               bit 6 = 1 for LBA mode
;               bit 5 = 1 per Sandisk documentation
;               bit 4 = 0 for Drive 0
;       IDE_DRV_HEAD = LBA Address bits 27-24 (lower 4 bits) - not used, always 0000
;       IDE_CYL_HIGH = LBA Address bits 23-16
;       IDE_CYL_LOW = LBA Address bits 15-8
;       IDE_SCT_NUM = LBA Address bits 7-0
;       IDE_SCT_CNT = number of blocks to read (most CF-Cards are limited to 1)
;
                JSR     IDE_SET_PARMS   ;Setup required parameters (6)
;
                SMB3    MATCH           ;Set Read LBA bit (5)
                STZ     IDE_STATUS_RAM  ;Clear RAM Status Register, ISR updates it (3)
                LDA     #$20            ;Get Read LBA command (2)
IDENT_READ      STA     IDE_COMMAND     ;Send command to IDE Controller (4)
LBA_RD_CMD
                LDA     IDE_ALT_STATUS  ;Get IDE Alternate Status register (4)
                BPL     LBA_RD_CMD      ;Loop until IDE controller Busy (2/3)
;
LBA_RD_WAIT
                LDA     IDE_ALT_STATUS  ;Get IDE Alternate Status register (4)
                CMP     #$50            ;Compare for ready (2)
                BEQ     LBA_RD_NORM     ;If normal status, finish up and exit (2/3)
                CMP     #$51            ;Compare for error bit set (2)
                BEQ     LBA_RD_ERR      ;Branch to handle error (2/3)
                BRA     LBA_RD_WAIT     ;Else branch back (waiting on IDE controller) (3)
;
LBA_RD_ERR
                RMB3    MATCH           ;Reset Read LBA bit (no ISR invoked) (5)
                LDA     IDE_ALT_STATUS  ;Get IDE Alternate Status register (4)
                STA     IDE_STATUS_RAM  ;Update RAM Status Register (3)
                RTS                     ;Return to caller (7)
;
LBA_RD_NORM
                BBS2    MATCH,LBA_RD_NORM       ;Wait for Read completed via ISR (5)
                RTS                     ;Return to caller (status in A Reg) (7)
;

; This routine sets the LBA number used for all transfers.
; - The IDE Controller is checked first to ensure it's ready to receive parameters
; - then the requested LBA (stored in Page Zero variables) are loaded into the
; - IDE Controller registers, followed by the required Mode parameters.
; - Last, the transfer address is setup which points to the location in memory that
; - will be used to transfer Data to or from.
;
IDE_SET_PARMS                           ;Set All parameters for LBA transfers
;
                LDA     IDE_ALT_STATUS  ;Get IDE Alternate Status register (4)
                BMI     IDE_SET_PARMS   ;Loop until it's clear (2/3)
;
                LDA     LBA_EXT_BYTE    ;Set LBA bits 23-16 (3)
                STA     IDE_CYL_HIGH    ;Send to IDE (4)
                LDA     LBA_HIGH_BYTE   ;Set LBA bits 15-8 (3)
                STA     IDE_CYL_LOW     ;Send to IDE (4)
                LDA     LBA_LOW_BYTE    ;Get LBA bits 7-0 (3)
                STA     IDE_SCT_NUM     ;Send to IDE (4)
                LDA     LBA_XFER_CNT    ;Get Block count to read (CF always 1) (3)
                STA     IDE_SCT_CNT     ;Send to IDE (4)
;
IDE_SET_PARMS2                          ;Set partial parameters (non LBA xfer commands)
;
                LDA     #%11100000      ;Set Drive 0, LBA mode, LBA bits 27-24 as 0 (2)
                STA     IDE_DRV_HEAD    ;Send to IDE (4)
;
                LDA     LBA_ADDR_LOW    ;Setup buffer address (3)
                STA     BIOS_XFERL      ;Store low byte (3)
                LDA     LBA_ADDR_HIGH   ;Block Buffer Address (3)
                STA     BIOS_XFERH      ;Store high byte (3)
                RTS                     ;Return to caller (7)

;
;       NOTE: 25 clock cycles to here if UART ISR is second!
;       NOTE: 40 clock cycles to here if NO UART interrupt occurs!
;
INTERUPT1                               ;Interrupt 1
                LDA     IDE_ALT_STATUS  ;Get Alternate Status Register (4)
                BMI     REGEXT01        ;If Busy bit active, just exit (2/3)
;
; - Check for Data Request (DRQ), as it's the only function that will require servicing
; against the IDE controller.
;
                LDA     IDE_STATUS      ;Get Status (resets IRQ) (4)
                AND     #%00001000      ;Check for DRQ (2)
                BNE     IDE_READ_BLK    ;Branch if active (2/3)
;
; - If no DRQ, possible Write or Verify Block command, check for these next.
;
                BBS2    MATCH,IDE_WRIT_BLK      ;If Bit 2 set, Write operation (5)
                BBS1    MATCH,IDE_VRFY_BLK      ;If Bit 1 set, Verify operation (5)
                BRA     REGEXT01        ;No IDE interrupt, exit the ISR handler (3)
;
IDE_READ_BLK                            ;IDE Read a Block of data
                BBR3    MATCH,REGEXT01  ;If Bit 3 not set, exit ISR (rogue IRQ?) (5)
;
LBA_XFER        LDA     IDE_ALT_STATUS  ;Get Status (4)
                AND     #%00001000      ;Check for DRQ (2)
                BEQ     IDE_RD_DONE     ;If not active, done, exit (2/3)
;
IDE_RD_RBLK     
                LDA     IDE_DATA        ;Read low byte (high byte in latch) (4)
                STA     (BIOS_XFERL)    ;Store low byte (5)
                INC     BIOS_XFERL      ;Increment pointers (5)
                BNE     IDE_RD_BLK1     ; (2/3)
                INC     BIOS_XFERH      ; (5)
IDE_RD_BLK1
                LDA     IDE_16_READ     ;Read high byte from latch (4)
                STA     (BIOS_XFERL)    ;Store high byte (5)
                INC     BIOS_XFERL      ;Increment pointers (5)
                BNE     LBA_XFER        ;Loop back to Xfer, saves 3 clock cycles (2/3)
                INC     BIOS_XFERH      ; (5)
IDE_RD_BLK2
                BRA     LBA_XFER        ;Loop back till no more DRQs (3)
;
IDE_RD_DONE     RMB3    MATCH           ;Clear Read Block flag (5)
;
IDE_ALL_DONE    LDA     IDE_ALT_STATUS  ;Get IDE status (4)
                STA     IDE_STATUS_RAM  ;Save it to RAM location (3)
REGEXT01        JMP     (VECINSRT0)     ;Exit ISR handler (6)
;
IDE_WRIT_BLK                            ;IDE Write a Block of data
                RMB2    MATCH           ;Clear Write Block flag (5)
                BRA     IDE_ALL_DONE    ;Branch and finish ISR (3)
;
IDE_VRFY_BLK                            ;IDE Verify a Block of data
                RMB1    MATCH           ;Clear Verify Block flag (5)
                BRA     IDE_ALL_DONE    ;Branch and finish ISR (3)

;
IRQ_VECTOR                              ;This is the ROM start for the BRK/IRQ handler
                PHA                     ;Save A Reg (3)
                PHX                     ;Save X Reg (3)
                PHY                     ;Save Y Reg (3)
                TSX                     ;Get Stack pointer (2)
                LDA     $0100+4,X       ;Get Status Register (4)
                AND     #$10            ;Mask for BRK bit set (2)
                BNE     DO_BRK          ;If set, handle BRK (2/3)
                JMP     (IRQVEC0)       ;Jump to Soft vectored IRQ Handler (6)
DO_BRK          JMP     (BRKVEC0)       ;Jump to Soft vectored BRK Handler (6)
NMI_ROM         JMP     (NMIVEC0)       ;Jump to Soft vectored NMI handler (6)
;
;This is the standard return for the IRQ/BRK handler routines
;
IRQ_EXIT0       PLY                     ;Restore Y Reg (4)
                PLX                     ;Restore X Reg (4)
                PLA                     ;Restore A Reg (4)
                RTI                     ;Return from IRQ/BRK routine (6)
;

; Simple test program to transfer multiple sectors - READ
;
        LDA     #$00            ;Get transfer address
        LDY     #$10            ; of $1000
        LDX     #$01            ;Sector count of 1
        JSR     $FF15           ;Call BIOS routine to set it
        LDA     #$00            ;Get LBA starting block
        LDY     #$00            ; of $000000
        LDX     #$00            ;
        JSR     $FF12           ;Call BIOS to set it
;
        LDX     #$00            ;Set for 256 blocks (128KB)
        LDY     #$80            ;Set multiplier of 128 (* 256)
        JSR     B_CNT_STRT      ;Reset and start benchmark counter
;
LBA_RBLK
        JSR     $FF09           ;Call BIOS Read Block
        LDA     IDE_STATUS_RAM  ;Get IDE Status (RAM)
        LSR     A               ;Shift error bit into carry
        BCS     RD_ERR          ;Branch if error
        INC     $FA             ;Else, increment LBA low number
        BNE     SKP_HI_RD       ;Skip if no rollover
        INC     $FB             ;Else, increment LBA high byte
;
SKP_HI_RD
        DEX                     ;Decrement low index
        BNE     LBA_RBLK        ;Loop back until zero
        DEY                     ;Decrement multiplier index
        BNE     LBA_RBLK        ;Loop back until done
        JSR     M_CROUT         ;Send CR/LF
        JSR     M_QUITB         ;Quit Benchmark counter, print results
        RTS                     ;Return to caller
;
RD_ERR
        JSR     B_IDE_GET_STAT  ;Get Extended error code (X reg)
        BRK                     ;Enter Monitor, display registers
;

;NOTE: Stop timer cmd resets the interrupt flag, counter continues to generate interrupts.
; NOTE: 25 clock cycles to here from INTERUPT0 - 50 in total
;
UART_RTC        LDA     #%10010000      ;Get Command mask for stop timer (2)
                STA     UART_COMMAND    ;Send command to 2691 (4)
;
; Check the MATCH flag bit7 to see if a Delay is active. If yes, decrement the MSDELAY
; variable once each pass until it is zero, then clear the MATCH flag bit7
;
                BBR7    MATCH,SKIP_DLY  ;Skip Delay if bit7 is clear (5)
                DEC     MSDELAY         ;Decrement Millisecond delay variable (5)
                BNE     SKIP_DLY        ;If not zero, skip (2/3)
                RMB7    MATCH           ;Else clear MATCH flag (5)
;
; Check the MATCH flag bit6 to see if Benchmarking is active. If yes, increment the
; variables once each pass until the MATCH flag bit6 is inactive.
;
SKIP_DLY        BBR6    MATCH,SKIP_CNT  ;Skip Count if bit6 bit is clear (5)
                INC     MS10_CNT        ;Else, increment 10ms count (5)
                LDA     MS10_CNT        ;Load current value (3)
                CMP     #100            ;Compare for 1 second elapsed time (2)
                BCC     SKIP_CNT        ;If not, skip to RTC update (2/3)
                STZ     MS10_CNT        ;Else, zero 10ms count (3)
                INC     SECL_CNT        ;Increment low byte elapsed seconds (5)
                BNE     SKIP_CNT        ;If no overflow, skip to RTC update (2/3)
                INC     SECH_CNT        ;Else, increment high byte elapsed seconds (5)
;
SKIP_CNT        DEC     TICKS           ;Decrement RTC tick count (5)
                BNE     REGEXT0         ;Exit if not zero (2/3)
                LDA     #DF_TICKS       ;Get default tick count (2)
                STA     TICKS           ;Reset tick count (3)
;
                INC     SECS            ;Increment seconds (5)
                LDA     SECS            ;Load it to A reg (3)
                CMP     #60             ;Check for 60 seconds (2)
                BCC     REGEXT0         ;If not, exit (2/3)
                STZ     SECS            ;Else, reset seconds, inc Minutes (3)
;
                INC     MINS            ;Increment Minutes (5)
                LDA     MINS            ;Load it to A reg (3)
                CMP     #60             ;Check for 60 minutes (2)
                BCC     REGEXT0         ;If not, exit (2/3)
                STZ     MINS            ;Else, reset Minutes, inc Hours (3)
;
                INC     HOURS           ;Increment Hours (5)
                LDA     HOURS           ;Load it to A reg (3)
                CMP     #24             ;Check for 24 hours (2)
                BCC     REGEXT0         ;If not, exit (2/3)
                STZ     HOURS           ;Else, reset hours, inc Days (3)
;
;This is the tricky part ;-)
; One variable holds the Day of the week and the Date of the Month!
; First, update the Day of the Week, which is the upper 3 bits of the variable
; Valid days are 1 to 7. Mask off the upper 3 bits, and add #%00100000 to it,
; if the result is zero, it was #%11100000, so start over by making the Day
; #%00100000, then save it to RTC_TEMP variable.
;
;Once that's done, load the variable again, mask off the Date and increase by
; one, then check against days of the month, update as required and check for
; Leap year and February 29th stuff. When all updated, OR in the Day from the
; RTC_TEMP variable and finish updating the DAY_DATE variable.
;
                LDA     DAY_DATE        ;Get Day and Date variable (3)
                AND     #%11100000      ;Mask off for Day of Week (1-7) (2)
                CLC                     ;Clear carry for add (2)
                ADC     #%00100000      ;Add effective "1" to Day of week (2)
                CLC                     ;Clear carry to avoid extra day add (2)
                BNE     NO_DAY_ADD      ;If non-zero, don't reset to "1" (2/3)
                LDA     #%00100000      ;Else, reset Day to "1" (2)
NO_DAY_ADD
                STA     RTC_TEMP        ;Store the updated Day into temp (3)
;
;Get the Month and Year variable, move the upper 4-bits down to get the
; current Month. Xfer it the X reg, then get the Date, increment by one
; and check against the number of days in that month.
;
                LDA     MONTH_CENTURY   ;Get Month and Year variable (3)
                LSR     A               ;Shift Month to lower 4 bits (2)
                LSR     A               ; (2)
                LSR     A               ; (2)
                LSR     A               ; (2)
                TAX                     ;Move to X reg (2)
                LDA     DAY_DATE        ;Get Day and Date variable (3)
                AND     #%00011111      ;Mask off for Date of Month (1-31) (2)
                INC     A               ;Increment by one (2)
                CMP     MAX_DATE-1,X    ;Check for Max Day per Month+1 (4)
                BCS     MONTH_ADD       ;Branch if we need to update the Month (2/3)
DO_29           ORA     RTC_TEMP        ;Else OR in updated Date to updated Day (3)
                STA     DAY_DATE        ;Update Day and Date variable (3)
                BRA     REGEXT00        ;Then exit IRQ Handler (3)
;
MONTH_ADD       CPX     #$02            ;Check for Month = February (2)
                BNE     MONTH_INC       ;If not, increment Month (2/3)
                LDA     YEAR            ;Else, Get current year low byte (3)
                AND     #%00000011      ;Mask off lower 2 bits (2)
                BNE     MONTH_INC       ;If not a Leap Year, continue on (2/3)
                LDA     DAY_DATE        ;Get Day and Date variable (3)
                AND     #%00011111      :Mask off Date (2)
                INC     A               ;Increment by one (2)
                CMP     #30             ;Check for 29th+1 Day for Leap Year (2)
                BCC     DO_29           ;Save Date as 29th and exit IRQ handler (2/3)
;
MONTH_INC       LDA     RTC_TEMP        ;Get updated Day (Date is effective zero)
                ORA     #%00000001      ;OR in the 1st Day of the Month
                STA     DAY_DATE        ;Save updated Day and Date of the Month
;
                LDA     MONTH_CENTURY   ;Get Month and Year variable
                CLC                     ;Clear Carry for add
                ADC     #$10            ;Add "1" to Month (upper 4 bits)
                STA     RTC_TEMP        ;Save it to work temp
                AND     #%11110000      ;Mask off Century (lower 4 bits)
                CMP     #$D0            ;Check for "13" (December + 1)
                BCS     YEAR_ADD        ;If 13 go add to YEAR
                LDA     RTC_TEMP        ;Else, Get updated Month and Century
                STA     MONTH_CENTURY   ;Save it
                BRA     REGEXT00        ;Exit IRQ Handler
;
YEAR_ADD        LDA     MONTH_CENTURY   ;Get Month and Century
                AND     #%00001111      ;Mask off old month
                ORA     #%00010000      ;OR in $10 for January
                STA     MONTH_CENTURY   ;Save updated Month and existing upper 4 bits
                INC     YEAR            ;Increment Year low byte (0-255)
                BNE     REGEXT00        ;If no rollver, exit ISR
                LDA     MONTH_CENTURY   ;Get Month and Year variable
                TAX                     ;Save to X reg
                AND     #%11110000      ;Mask off upper 4-bits for year
                STA     RTC_TEMP        ;Save it in the temp area
                TXA                     ;Get the Month and Year back
                AND     #%00001111      ;Mask off the month
                CLC                     ;Clear carry for add
                ADC     #$01            ;Add 1 to upper 4 bits
                ORA     RTC_TEMP        ;OR in the Month
                STA     MONTH_CENTURY   ;Update Month and Century variable
REGEXT00        JMP     (IRQRTVEC0)     ;If no rollover, then exit IRQ handler (6)

; Status Register bits as defined as follows:
;       - Bit 7 = Busy (a Command has been accepted)
;       - Bit 6 = Ready (IDE controller is ready to accept a command)
;       - Bit 5 = Write Fault (A write command failed against the media)
;       - Bit 4 = DSC (is set when the CF Card is ready)
;       - Bit 3 = Data Request (set when there is data to transfer, read or write)
;       - Bit 2 = Correction (set when a recoverable data error was corrected)
;       - Bit 1 = 0 (not used)
;       - Bit 0 = Error (set when the previous command had an unrecoverable error)
;