URL https://opencores.org/ocsvn/rtf65002/rtf65002/trunk

Subversion Repositories rtf65002

[/] [rtf65002/] [trunk/] [software/] [asm/] [bootrom.asm] - Blame information for rev 11

Go to most recent revision | Details | Compare with Previous | View Log


; ============================================================================
;        __
;   \\__/ o\    (C) 2013  Robert Finch, Stratford
;    \  __ /    All rights reserved.
;     \/_//     robfinch@opencores.org
;       ||
;
;
; This source file is free software: you can redistribute it and/or modify
; it under the terms of the GNU Lesser General Public License as published
; by the Free Software Foundation, either version 3 of the License, or
; (at your option) any later version.
;
; This source file is distributed in the hope that it will be useful,
; but WITHOUT ANY WARRANTY; without even the implied warranty of
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
; GNU General Public License for more details.
;
; You should have received a copy of the GNU General Public License
; along with this program.  If not, see .
;
; ============================================================================
;
CR      EQU     0x0D            ;ASCII equates
LF      EQU     0x0A
TAB     EQU     0x09
CTRLC   EQU     0x03
CTRLH   EQU     0x08
CTRLI   EQU     0x09
CTRLJ   EQU     0x0A
CTRLK   EQU     0x0B
CTRLM   EQU 0x0D
CTRLS   EQU     0x13
CTRLX   EQU     0x18
XON             EQU     0x11
XOFF    EQU     0x13
 
TEXTSCR         EQU             0xFFD00000
COLORSCR        EQU             0xFFD10000
TEXTREG         EQU             0xFFDA0000
TEXT_COLS       EQU             0x0
TEXT_ROWS       EQU             0x1
TEXT_CURPOS     EQU             11
KEYBD           EQU             0xFFDC0000
KEYBDCLR        EQU             0xFFDC0001
 
SPIMASTER       EQU             0xFFDC0500
SPI_MASTER_VERSION_REG  EQU     0x00
SPI_MASTER_CONTROL_REG  EQU     0x01
SPI_TRANS_TYPE_REG      EQU             0x02
SPI_TRANS_CTRL_REG      EQU             0x03
SPI_TRANS_STATUS_REG    EQU     0x04
SPI_TRANS_ERROR_REG             EQU     0x05
SPI_DIRECT_ACCESS_DATA_REG              EQU     0x06
SPI_SD_SECT_7_0_REG             EQU     0x07
SPI_SD_SECT_15_8_REG    EQU     0x08
SPI_SD_SECT_23_16_REG   EQU     0x09
SPI_SD_SECT_31_24_REG   EQU     0x0a
SPI_RX_FIFO_DATA_REG    EQU     0x10
SPI_RX_FIFO_DATA_COUNT_MSB      EQU     0x12
SPI_RX_FIFO_DATA_COUNT_LSB  EQU 0x13
SPI_RX_FIFO_CTRL_REG            EQU     0x14
SPI_TX_FIFO_DATA_REG    EQU     0x20
SPI_TX_FIFO_CTRL_REG    EQU     0x24
SPI_RESP_BYTE1                  EQU     0x30
SPI_RESP_BYTE2                  EQU     0x31
SPI_RESP_BYTE3                  EQU     0x32
SPI_RESP_BYTE4                  EQU     0x33
SPI_INIT_SD                     EQU             0x01
SPI_TRANS_START         EQU             0x01
SPI_TRANS_BUSY          EQU             0x01
SPI_INIT_NO_ERROR       EQU             0x00
SPI_READ_NO_ERROR       EQU             0x00
RW_READ_SD_BLOCK        EQU             0x02
RW_WRITE_SD_BLOCK       EQU             0x03
 
BITMAPSCR       EQU             0x00200000
 
macro m_lsr8
lsr
lsr
lsr
lsr
lsr
lsr
lsr
lsr
endm
 
CharColor       EQU             0x210
ScreenColor     EQU             0x211
CursorRow       EQU             0x212
CursorCol       EQU             0x213
 
        cpu             rtf65002
        code
        org             $FFFFC000
start
        sei                                             ; disable interrupts
        cld                                             ; disable decimal mode
        ldx             #$1000                  ; setup stack pointer
        txs
        lda             #$CE                    ; CE =blue on blue FB = grey on grey
        sta             ScreenColor
        sta             CharColor
        jsr             ClearScreen
        stz             CursorRow
        stz             CursorCol
        lda             #msgStart>>2    ; convert to data address
        jsr             DisplayStringB
 
        stp
        bra             start
 
        align   4
msgStart
        db              "RTF65002 system starting.",$0d,$0a,00
 
;------------------------------------------------------------------------------
; Clear the screen and the screen color memory
; We clear the screen to give a visual indication that the system
; is working at all.
;------------------------------------------------------------------------------
;
ClearScreen:
        pha                                                     ; holds a space character
        phx                                                     ; loop counter
        phy                                                     ; memory addressing
        push    r4                                      ; holds the screen color
        lda             TEXTREG+TEXT_COLS       ; calc number to clear
        ldx             TEXTREG+TEXT_ROWS
        mul             r2,r1,r2                        ; r2 = # chars to clear
        lda             #' '                            ; space char
        ld              r4,ScreenColor
        jsr             AsciiToScreen
        ldy             #TEXTSCR                        ; text screen address
csj4:
        sta             (y)
        st              r4,$10000,y                     ; color screen is 0x10000 higher
        iny
        dex
        bne             csj4
        pop             r4
        ply
        plx
        pla
        rts
 
;------------------------------------------------------------------------------
; Scroll text on the screen upwards
;------------------------------------------------------------------------------
;
ScrollUp:
        pha
        phx
        phy
        push    r4
        push    r5
        lda             TEXTREG+TEXT_COLS       ; acc = # text columns
        ldx             TEXTREG+TEXT_ROWS
        mul             r2,r1,r2                        ; calc number of chars to scroll
        sub             r2,r2,r1                        ; one less row
        ldy             #TEXTSCR
scrup1:
        add             r5,r3,r1
        ld              r4,(r5)                         ; move character
        st              r4,(y)
        ld              r4,$10000,r5            ; and move color code
        st              r4,$10000,y
        iny
        dex
        bne             scrup1
        lda             TEXTREG+TEXT_ROWS
        dea
        jsr             BlankLine
        pop             r5
        pop             r4
        ply
        plx
        pla
        rts
 
;------------------------------------------------------------------------------
; Blank out a line on the display
; line number to blank is in acc
;------------------------------------------------------------------------------
;
BlankLine:
        pha
        phx
        phy
        ldx             TEXTREG+TEXT_COLS       ; x = # chars to blank out from video controller
        mul             r3,r2,r1                        ; y = screen index (row# * #cols)
        add             r3,r3,#TEXTSCR          ; y = screen address
        lda             #' '
blnkln1:
        sta             (y)
        iny
        dex
        bne             blnkln1
        ply
        plx
        pla
        rts
 
;------------------------------------------------------------------------------
; Convert ASCII character to screen display character.
;------------------------------------------------------------------------------
;
AsciiToScreen:
        and             #$FF
        cmp             #'A'
        bcc             atoscr1         ; blt
        cmp             #'Z'
        bcc             atoscr1
        beq             atoscr1
        cmp             #'z'
        bcs             atoscr1
        cmp             #'a'
        bcc             atoscr1
        sub             #$60
atoscr1:
        or              #$100
        rts
 
;------------------------------------------------------------------------------
; Convert screen character to ascii character
;------------------------------------------------------------------------------
;
ScreenToAscii:
        and             #$FF
        cmp             #26
        bcs             stasc1
        add             #$60
stasc1:
        rts
 
;------------------------------------------------------------------------------
; Calculate screen memory location from CursorRow,CursorCol.
; Also refreshes the cursor location.
; Returns:
; r1 = screen location
;------------------------------------------------------------------------------
;
CalcScreenLoc:
        phx
        lda             CursorRow
        ldx             TEXTREG+TEXT_COLS
        mul             r2,r2,r1
        add             r2,r2,CursorCol
        stx             TEXTREG+TEXT_CURPOS
        add             r1,r2,#TEXTSCR  ; r1 = screen location
        plx
        rts
 
;------------------------------------------------------------------------------
; Display a character on the screen
; r1 = char to display
;------------------------------------------------------------------------------
;
DisplayChar:
        cmp             #'\r'                           ; carriage return ?
        bne             dccr
        stz             CursorCol                       ; just set cursor column to zero on a CR
        jsr             CalcScreenLoc
        rts
dccr:
        cmp             #$91                            ; cursor right ?
        bne             dcx6
        pha
        lda             CursorCol
        cmp             #83
        bcs             dcx7
        ina
        sta             CursorCol
dcx7:
        jsr             CalcScreenLoc
        pla
        rts
dcx6:
        cmp             #$90                            ; cursor up ?
        bne             dcx8
        pha
        lda             CursorRow
        beq             dcx7
        dea
        sta             CursorRow
        bra             dcx7
dcx8:
        cmp             #$93                            ; cursor left ?
        bne             dcx9
        pha
        lda             CursorCol
        beq             dcx7
        dea
        sta             CursorCol
        bra             dcx7
dcx9:
        cmp             #$92                            ; cursor down ?
        bne             dcx10
        pha
        lda             CursorRow
        cmp             #46
        beq             dcx7
        ina
        sta             CursorRow
        bra             dcx7
dcx10:
        cmp             #$94                            ; cursor home ?
        bne             dcx11
        pha
        lda             CursorCol
        beq             dcx12
        stz             CursorCol
        bra             dcx7
dcx12:
        stz             CursorRow
        bra             dcx7
dcx11:
        pha
        phx
        phy
        cmp             #$99                            ; delete ?
        bne             dcx13
        jsr             CalcScreenLoc
        tay                                                     ; y = screen location
        lda             CursorCol                       ; acc = cursor column
        bra             dcx5
dcx13
        cmp             #CTRLH                          ; backspace ?
        bne             dcx3
        lda             CursorCol
        beq             dcx4
        dea
        sta             CursorCol
        jsr             CalcScreenLoc           ; acc = screen location
        tay                                                     ; y = screen location
        lda             CursorCol
dcx5:
        ldx             $4,y
        stx             (y)
        iny
        ina
        cmp             TEXTREG+TEXT_COLS
        bcc             dcx5
        lda             #' '
        jsr             AsciiToScreen
        dey
        sta             (y)
        bra             dcx4
dcx3:
        cmp             #'\n'                   ; linefeed ?
        beq             dclf
        tax                                             ; save acc in x
        jsr     CalcScreenLoc   ; acc = screen location
        tay                                             ; y = screen location
        txa                                             ; restore r1
        jsr             AsciiToScreen   ; convert ascii char to screen char
        sta             (y)
        lda             CharColor
        sta             $10000,y
        jsr             IncCursorPos
        bra             dcx4
dclf:
        jsr             IncCursorRow
dcx4:
        ply
        plx
        pla
        rts
 
;------------------------------------------------------------------------------
; Increment the cursor position, scroll the screen if needed.
;------------------------------------------------------------------------------
;
IncCursorPos:
        pha
        phx
        lda             CursorCol
        ina
        sta             CursorCol
        ldx             TEXTREG+TEXT_COLS
        cmp             r1,r2
        bcc             icc1
        stz             CursorCol               ; column = 0
        bra             icr1
IncCursorRow:
        pha
        phx
icr1:
        lda             CursorRow
        ina
        sta             CursorRow
        ldx             TEXTREG+TEXT_ROWS
        cmp             r1,r2
        bcc             icc1
        beq             icc1
        dex                                                     ; backup the cursor row, we are scrolling up
        stx             CursorRow
        jsr             ScrollUp
icc1:
        jsr             CalcScreenLoc
        plx
        pla
        rts
 
;------------------------------------------------------------------------------
; Display a string on the screen.
; The characters are packed 4 per word
;------------------------------------------------------------------------------
;
DisplayStringB:
        pha
        phx
        tax                                             ; r2 = pointer to string
dspj1B:
        lda             (x)                             ; move string char into acc
        inx                                             ; increment pointer
        pha
        and             #$FF
        cmp             #0                              ; is it end of string ?
        beq             dsretB
        jsr             DisplayChar             ; display character
        pla
        m_lsr8
        pha
        and             #$FF
        cmp             #0
        beq             dsretB
        jsr             DisplayChar
        pla
        m_lsr8
        pha
        and             #$FF
        cmp             #0
        beq             dsretB
        jsr             DisplayChar
        pla
        m_lsr8
        pha
        and             #$FF
        cmp             #0
        beq             dsretB
        jsr             DisplayChar
        pla
        bra             dspj1B                  ; go back for next character
dsretB:
        pla
        plx
        pla
        rts
 
;------------------------------------------------------------------------------
; Display a string on the screen.
; The characters are packed 1 per word
;------------------------------------------------------------------------------
;
DisplayStringW:
        pha
        phx
        tax                                             ; r2 = pointer to string
dspj1W:
        lda             (x)                             ; move string char into acc
        inx                                             ; increment pointer
        cmp             #0                              ; is it end of string ?
        beq             dsretW
        jsr             DisplayChar             ; display character
        bra             dspj1W                  ; go back for next character
dsretW:
        plx
        pla
        rts
 
DisplayStringCRLFB:
        jsr             DisplayStringB
CRLF:
        pha
        lda             #'\r'
        jsr             DisplayChar
        lda             #'\n'
        jsr             DisplayChar
        pla
        rts
 
;------------------------------------------------------------------------------
; Display nybble in r1
;------------------------------------------------------------------------------
;
DisplayNybble:
        pha
        and             #$0F
        add             #'0'
        cmp             #'9'
        bcc             dispnyb1
        add             #7
dispnyb1:
        jsr             DisplayChar
        pla
        rts
 
;------------------------------------------------------------------------------
; Display the byte in r1
;------------------------------------------------------------------------------
;
DisplayByte:
        pha
        lsr
        lsr
        lsr
        lsr
        jsr             DisplayNybble
        pla
        jmp             DisplayNybble   ; tail rts
 
;------------------------------------------------------------------------------
;------------------------------------------------------------------------------
ClearBmpScreen:
        pha
        phx
        phy
        ldx             #(1364*768)>>2          ; x = # words to clear
        lda             #0x29292929                     ; acc = color for four pixels
        ldy             #BITMAPSCR                      ; y = screen address
csj4
        sta             (y)                                     ; store pixel data
        iny                                                     ; advance screen address
        dex                                                     ; decrement pixel count and loop back
        bne             csj4
        ply
        plx
        pla
        rts
 
;==============================================================================
;==============================================================================
;
; Initialize the SD card
; Returns
; acc = 0 if successful, 1 otherwise
;
spi_init
        lda             #SPI_INIT_SD
        sta             SPIMASTER+SPI_TRANS_TYPE_REG
        lda             #SPI_TRANS_START
        sta             SPIMASTER+SPI_TRANS_CTRL_REG
        nop
spi_init1
        lda             SPIMASTER+SPI_TRANS_STATUS_REG
        nop
        nop
        cmp             #SPI_TRANS_BUSY
        beq             spi_init1
        lda             SPIMASTER+SPI_TRANS_ERROR_REG
        and             #3
        cmp             #SPI_INIT_NO_ERROR
        bne             spi_error
        lda             #spi_init_ok_msg>>2
        jsr             DisplayStringB
        lda             #0
        bra             spi_init_exit
spi_error
        jsr             DisplayByte
        lda             #spi_init_error_msg>>2
        jsr             DisplayStringB
        lda             SPIMASTER+SPI_RESP_BYTE1
        jsr             DisplayByte
        lda             SPIMASTER+SPI_RESP_BYTE2
        jsr             DisplayByte
        lda             SPIMASTER+SPI_RESP_BYTE3
        jsr             DisplayByte
        lda             SPIMASTER+SPI_RESP_BYTE4
        jsr             DisplayByte
        lda             #1
spi_init_exit
        rts
 
 
 
; SPI read sector
;
; r1= sector number to read
; r2= address to place read data
; Returns:
; r1 = 0 if successful
;
spi_read_sector:
        phx
        phy
        push    r4
 
        sta             SPIMASTER+SPI_SD_SECT_7_0_REG
        m_lsr8
        sta             SPIMASTER+SPI_SD_SECT_15_8_REG
        m_lsr8
        sta             SPIMASTER+SPI_SD_SECT_23_16_REG
        m_lsr8
        sta             SPIMASTER+SPI_SD_SECT_31_24_REG
 
        ld              r4,#20  ; retry count
 
spi_read_retry:
        ; Force the reciever fifo to be empty, in case a prior error leaves it
        ; in an unknown state.
        lda             #1
        sta             SPIMASTER+SPI_RX_FIFO_CTRL_REG
 
        lda             #RW_READ_SD_BLOCK
        sta             SPIMASTER+SPI_TRANS_TYPE_REG
        lda             #SPI_TRANS_START
        sta             SPIMASTER+SPI_TRANS_CTRL_REG
        nop
spi_read_sect1:
        lda             SPIMASTER+SPI_TRANS_STATUS_REG
        nop                                     ; just a delay between consecutive status reg reads
        nop
        cmp             #SPI_TRANS_BUSY
        beq             spi_read_sect1
        lda             SPIMASTER+SPI_TRANS_ERROR_REG
        lsr
        lsr
        and             #3
        cmp             #SPI_READ_NO_ERROR
        bne             spi_read_error
        ldy             #512            ; read 512 bytes from fifo
spi_read_sect2:
        lda             SPIMASTER+SPI_RX_FIFO_DATA_REG
        sta             (x)
        inx
        dey
        bne             spi_read_sect2
        lda             #0
        bra             spi_read_ret
spi_read_error:
        sub             r4,r4,#1
        bne             spi_read_retry
        jsr             DisplayByte
        lda             #spi_read_error_msg>>2
        jsr             DisplayStringB
        lda             #1
spi_read_ret:
        pop             r4
        ply
        plx
        rts
 
; SPI write sector
;
; r1= sector number to write
; r2= address to get data from
; Returns:
; r1 = 0 if successful
;
spi_write_sector:
        phx
        phy
        pha
        ; Force the transmitter fifo to be empty, in case a prior error leaves it
        ; in an unknown state.
        lda             #1
        sta             SPIMASTER+SPI_TX_FIFO_CTRL_REG
        nop                     ; give I/O time to respond
        nop
 
        ; now fill up the transmitter fifo
        ldy             #512
spi_write_sect1:
        lda             (x)
        sta             SPIMASTER+SPI_TX_FIFO_DATA_REG
        nop                     ; give the I/O time to respond
        nop
        inx
        dey
        bne             spi_write_sect1
 
        ; set the sector number in the spi master address registers
        pla
        sta             SPIMASTER+SPI_SD_SECT_7_0_REG
        m_lsr8
        sta             SPIMASTER+SPI_SD_SECT_15_8_REG
        m_lsr8
        sta             SPIMASTER+SPI_SD_SECT_23_16_REG
        m_lsr8
        sta             SPIMASTER+SPI_SD_SECT_31_24_REG
 
        ; issue the write command
        lda             #RW_WRITE_SD_BLOCK
        sta             SPIMASTER+SPI_TRANS_TYPE_REG
        lda             #SPI_TRANS_START
        sta             SPIMASTER+SPI_TRANS_CTRL_REG
        nop
spi_write_sect2:
        lda             SPIMASTER+SPI_TRANS_STATUS_REG
        nop                                                     ; just a delay between consecutive status reg reads
        nop
        cmp             #SPI_TRANS_BUSY
        beq             spi_write_sect2
        lda             SPIMASTER+SPI_TRANS_ERROR_REG
        lsr
        lsr
        lsr
        lsr
        and             #3
        cmp             #SPI_WRITE_NO_ERROR
        bne             spi_write_error
        lda             #0
        bra             spi_write_ret
spi_write_error:
        jsr             DisplayByte
        lda             #spi_write_error_msg>>2
        jsr             DisplayStringB
        lda             #1
 
spi_write_ret:
        ply
        plx
        rts
 
        align   4
msgJumpingToBoot:
        db      "Jumping to boot",0
        align   4
msgNotBootable:
        db      "SD card not bootable.",0
        align   4
spi_init_ok_msg:
        db "SD card initialized okay.",0
        align   4
spi_init_error_msg:
        db      ": error occurred initializing the SD card.",0
        align   4
spi_boot_error_msg:
        db      "SD card boot error",0
        align   4
spi_read_error_msg:
        db      "SD card read error",0
        align   4
spi_write_error_msg:
        db      "SD card write error",0
 
nmirout
        rti
 
        org $0FFFFFFF4          ; NMI vector
        dw      nmirout
 
        org     $0FFFFFFF8              ; reset vector, native mode
        dw      start
 
        end
 

Browse

Tools

Subversion Repositories rtf65002

[/] [rtf65002/] [trunk/] [software/] [asm/] [bootrom.asm] - Blame information for rev 11

Line No.	Rev	Author	Line
1	11	robfinch	`; ============================================================================`
2			`; __`
3			`; \\__/ o\ (C) 2013 Robert Finch, Stratford`
4			`; \ __ / All rights reserved.`
5			`; \/_// robfinch@opencores.org`
6			`; \|\|`
7			`;`
8			`;`
9			`; This source file is free software: you can redistribute it and/or modify`
10			`; it under the terms of the GNU Lesser General Public License as published`
11			`; by the Free Software Foundation, either version 3 of the License, or`
12			`; (at your option) any later version.`
13			`;`
14			`; This source file is distributed in the hope that it will be useful,`
15			`; but WITHOUT ANY WARRANTY; without even the implied warranty of`
16			`; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
17			`; GNU General Public License for more details.`
18			`;`
19			`; You should have received a copy of the GNU General Public License`
20			`; along with this program. If not, see .`
21			`;`
22			`; ============================================================================`
23			`;`
24			`CR EQU 0x0D ;ASCII equates`
25			`LF EQU 0x0A`
26			`TAB EQU 0x09`
27			`CTRLC EQU 0x03`
28			`CTRLH EQU 0x08`
29			`CTRLI EQU 0x09`
30			`CTRLJ EQU 0x0A`
31			`CTRLK EQU 0x0B`
32			`CTRLM EQU 0x0D`
33			`CTRLS EQU 0x13`
34			`CTRLX EQU 0x18`
35			`XON EQU 0x11`
36			`XOFF EQU 0x13`
37
38			`TEXTSCR EQU 0xFFD00000`
39			`COLORSCR EQU 0xFFD10000`
40			`TEXTREG EQU 0xFFDA0000`
41			`TEXT_COLS EQU 0x0`
42			`TEXT_ROWS EQU 0x1`
43			`TEXT_CURPOS EQU 11`
44			`KEYBD EQU 0xFFDC0000`
45			`KEYBDCLR EQU 0xFFDC0001`
46
47			`SPIMASTER EQU 0xFFDC0500`
48			`SPI_MASTER_VERSION_REG EQU 0x00`
49			`SPI_MASTER_CONTROL_REG EQU 0x01`
50			`SPI_TRANS_TYPE_REG EQU 0x02`
51			`SPI_TRANS_CTRL_REG EQU 0x03`
52			`SPI_TRANS_STATUS_REG EQU 0x04`
53			`SPI_TRANS_ERROR_REG EQU 0x05`
54			`SPI_DIRECT_ACCESS_DATA_REG EQU 0x06`
55			`SPI_SD_SECT_7_0_REG EQU 0x07`
56			`SPI_SD_SECT_15_8_REG EQU 0x08`
57			`SPI_SD_SECT_23_16_REG EQU 0x09`
58			`SPI_SD_SECT_31_24_REG EQU 0x0a`
59			`SPI_RX_FIFO_DATA_REG EQU 0x10`
60			`SPI_RX_FIFO_DATA_COUNT_MSB EQU 0x12`
61			`SPI_RX_FIFO_DATA_COUNT_LSB EQU 0x13`
62			`SPI_RX_FIFO_CTRL_REG EQU 0x14`
63			`SPI_TX_FIFO_DATA_REG EQU 0x20`
64			`SPI_TX_FIFO_CTRL_REG EQU 0x24`
65			`SPI_RESP_BYTE1 EQU 0x30`
66			`SPI_RESP_BYTE2 EQU 0x31`
67			`SPI_RESP_BYTE3 EQU 0x32`
68			`SPI_RESP_BYTE4 EQU 0x33`
69			`SPI_INIT_SD EQU 0x01`
70			`SPI_TRANS_START EQU 0x01`
71			`SPI_TRANS_BUSY EQU 0x01`
72			`SPI_INIT_NO_ERROR EQU 0x00`
73			`SPI_READ_NO_ERROR EQU 0x00`
74			`RW_READ_SD_BLOCK EQU 0x02`
75			`RW_WRITE_SD_BLOCK EQU 0x03`
76
77			`BITMAPSCR EQU 0x00200000`
78
79			`macro m_lsr8`
80			`lsr`
81			`lsr`
82			`lsr`
83			`lsr`
84			`lsr`
85			`lsr`
86			`lsr`
87			`lsr`
88			`endm`
89
90			`CharColor EQU 0x210`
91			`ScreenColor EQU 0x211`
92			`CursorRow EQU 0x212`
93			`CursorCol EQU 0x213`
94
95			`cpu rtf65002`
96			`code`
97			`org $FFFFC000`
98			`start`
99			`sei ; disable interrupts`
100			`cld ; disable decimal mode`
101			`ldx #$1000 ; setup stack pointer`
102			`txs`
103			`lda #$CE ; CE =blue on blue FB = grey on grey`
104			`sta ScreenColor`
105			`sta CharColor`
106			`jsr ClearScreen`
107			`stz CursorRow`
108			`stz CursorCol`
109			`lda #msgStart>>2 ; convert to data address`
110			`jsr DisplayStringB`
111
112			`stp`
113			`bra start`
114
115			`align 4`
116			`msgStart`
117			`db "RTF65002 system starting.",$0d,$0a,00`
118
119			`;------------------------------------------------------------------------------`
120			`; Clear the screen and the screen color memory`
121			`; We clear the screen to give a visual indication that the system`
122			`; is working at all.`
123			`;------------------------------------------------------------------------------`
124			`;`
125			`ClearScreen:`
126			`pha ; holds a space character`
127			`phx ; loop counter`
128			`phy ; memory addressing`
129			`push r4 ; holds the screen color`
130			`lda TEXTREG+TEXT_COLS ; calc number to clear`
131			`ldx TEXTREG+TEXT_ROWS`
132			`mul r2,r1,r2 ; r2 = # chars to clear`
133			`lda #' ' ; space char`
134			`ld r4,ScreenColor`
135			`jsr AsciiToScreen`
136			`ldy #TEXTSCR ; text screen address`
137			`csj4:`
138			`sta (y)`
139			`st r4,$10000,y ; color screen is 0x10000 higher`
140			`iny`
141			`dex`
142			`bne csj4`
143			`pop r4`
144			`ply`
145			`plx`
146			`pla`
147			`rts`
148
149			`;------------------------------------------------------------------------------`
150			`; Scroll text on the screen upwards`
151			`;------------------------------------------------------------------------------`
152			`;`
153			`ScrollUp:`
154			`pha`
155			`phx`
156			`phy`
157			`push r4`
158			`push r5`
159			`lda TEXTREG+TEXT_COLS ; acc = # text columns`
160			`ldx TEXTREG+TEXT_ROWS`
161			`mul r2,r1,r2 ; calc number of chars to scroll`
162			`sub r2,r2,r1 ; one less row`
163			`ldy #TEXTSCR`
164			`scrup1:`
165			`add r5,r3,r1`
166			`ld r4,(r5) ; move character`
167			`st r4,(y)`
168			`ld r4,$10000,r5 ; and move color code`
169			`st r4,$10000,y`
170			`iny`
171			`dex`
172			`bne scrup1`
173			`lda TEXTREG+TEXT_ROWS`
174			`dea`
175			`jsr BlankLine`
176			`pop r5`
177			`pop r4`
178			`ply`
179			`plx`
180			`pla`
181			`rts`
182
183			`;------------------------------------------------------------------------------`
184			`; Blank out a line on the display`
185			`; line number to blank is in acc`
186			`;------------------------------------------------------------------------------`
187			`;`
188			`BlankLine:`
189			`pha`
190			`phx`
191			`phy`
192			`ldx TEXTREG+TEXT_COLS ; x = # chars to blank out from video controller`
193			`mul r3,r2,r1 ; y = screen index (row# * #cols)`
194			`add r3,r3,#TEXTSCR ; y = screen address`
195			`lda #' '`
196			`blnkln1:`
197			`sta (y)`
198			`iny`
199			`dex`
200			`bne blnkln1`
201			`ply`
202			`plx`
203			`pla`
204			`rts`
205
206			`;------------------------------------------------------------------------------`
207			`; Convert ASCII character to screen display character.`
208			`;------------------------------------------------------------------------------`
209			`;`
210			`AsciiToScreen:`
211			`and #$FF`
212			`cmp #'A'`
213			`bcc atoscr1 ; blt`
214			`cmp #'Z'`
215			`bcc atoscr1`
216			`beq atoscr1`
217			`cmp #'z'`
218			`bcs atoscr1`
219			`cmp #'a'`
220			`bcc atoscr1`
221			`sub #$60`
222			`atoscr1:`
223			`or #$100`
224			`rts`
225
226			`;------------------------------------------------------------------------------`
227			`; Convert screen character to ascii character`
228			`;------------------------------------------------------------------------------`
229			`;`
230			`ScreenToAscii:`
231			`and #$FF`
232			`cmp #26`
233			`bcs stasc1`
234			`add #$60`
235			`stasc1:`
236			`rts`
237
238			`;------------------------------------------------------------------------------`
239			`; Calculate screen memory location from CursorRow,CursorCol.`
240			`; Also refreshes the cursor location.`
241			`; Returns:`
242			`; r1 = screen location`
243			`;------------------------------------------------------------------------------`
244			`;`
245			`CalcScreenLoc:`
246			`phx`
247			`lda CursorRow`
248			`ldx TEXTREG+TEXT_COLS`
249			`mul r2,r2,r1`
250			`add r2,r2,CursorCol`
251			`stx TEXTREG+TEXT_CURPOS`
252			`add r1,r2,#TEXTSCR ; r1 = screen location`
253			`plx`
254			`rts`
255
256			`;------------------------------------------------------------------------------`
257			`; Display a character on the screen`
258			`; r1 = char to display`
259			`;------------------------------------------------------------------------------`
260			`;`
261			`DisplayChar:`
262			`cmp #'\r' ; carriage return ?`
263			`bne dccr`
264			`stz CursorCol ; just set cursor column to zero on a CR`
265			`jsr CalcScreenLoc`
266			`rts`
267			`dccr:`
268			`cmp #$91 ; cursor right ?`
269			`bne dcx6`
270			`pha`
271			`lda CursorCol`
272			`cmp #83`
273			`bcs dcx7`
274			`ina`
275			`sta CursorCol`
276			`dcx7:`
277			`jsr CalcScreenLoc`
278			`pla`
279			`rts`
280			`dcx6:`
281			`cmp #$90 ; cursor up ?`
282			`bne dcx8`
283			`pha`
284			`lda CursorRow`
285			`beq dcx7`
286			`dea`
287			`sta CursorRow`
288			`bra dcx7`
289			`dcx8:`
290			`cmp #$93 ; cursor left ?`
291			`bne dcx9`
292			`pha`
293			`lda CursorCol`
294			`beq dcx7`
295			`dea`
296			`sta CursorCol`
297			`bra dcx7`
298			`dcx9:`
299			`cmp #$92 ; cursor down ?`
300			`bne dcx10`
301			`pha`
302			`lda CursorRow`
303			`cmp #46`
304			`beq dcx7`
305			`ina`
306			`sta CursorRow`
307			`bra dcx7`
308			`dcx10:`
309			`cmp #$94 ; cursor home ?`
310			`bne dcx11`
311			`pha`
312			`lda CursorCol`
313			`beq dcx12`
314			`stz CursorCol`
315			`bra dcx7`
316			`dcx12:`
317			`stz CursorRow`
318			`bra dcx7`
319			`dcx11:`
320			`pha`
321			`phx`
322			`phy`
323			`cmp #$99 ; delete ?`
324			`bne dcx13`
325			`jsr CalcScreenLoc`
326			`tay ; y = screen location`
327			`lda CursorCol ; acc = cursor column`
328			`bra dcx5`
329			`dcx13`
330			`cmp #CTRLH ; backspace ?`
331			`bne dcx3`
332			`lda CursorCol`
333			`beq dcx4`
334			`dea`
335			`sta CursorCol`
336			`jsr CalcScreenLoc ; acc = screen location`
337			`tay ; y = screen location`
338			`lda CursorCol`
339			`dcx5:`
340			`ldx $4,y`
341			`stx (y)`
342			`iny`
343			`ina`
344			`cmp TEXTREG+TEXT_COLS`
345			`bcc dcx5`
346			`lda #' '`
347			`jsr AsciiToScreen`
348			`dey`
349			`sta (y)`
350			`bra dcx4`
351			`dcx3:`
352			`cmp #'\n' ; linefeed ?`
353			`beq dclf`
354			`tax ; save acc in x`
355			`jsr CalcScreenLoc ; acc = screen location`
356			`tay ; y = screen location`
357			`txa ; restore r1`
358			`jsr AsciiToScreen ; convert ascii char to screen char`
359			`sta (y)`
360			`lda CharColor`
361			`sta $10000,y`
362			`jsr IncCursorPos`
363			`bra dcx4`
364			`dclf:`
365			`jsr IncCursorRow`
366			`dcx4:`
367			`ply`
368			`plx`
369			`pla`
370			`rts`
371
372			`;------------------------------------------------------------------------------`
373			`; Increment the cursor position, scroll the screen if needed.`
374			`;------------------------------------------------------------------------------`
375			`;`
376			`IncCursorPos:`
377			`pha`
378			`phx`
379			`lda CursorCol`
380			`ina`
381			`sta CursorCol`
382			`ldx TEXTREG+TEXT_COLS`
383			`cmp r1,r2`
384			`bcc icc1`
385			`stz CursorCol ; column = 0`
386			`bra icr1`
387			`IncCursorRow:`
388			`pha`
389			`phx`
390			`icr1:`
391			`lda CursorRow`
392			`ina`
393			`sta CursorRow`
394			`ldx TEXTREG+TEXT_ROWS`
395			`cmp r1,r2`
396			`bcc icc1`
397			`beq icc1`
398			`dex ; backup the cursor row, we are scrolling up`
399			`stx CursorRow`
400			`jsr ScrollUp`
401			`icc1:`
402			`jsr CalcScreenLoc`
403			`plx`
404			`pla`
405			`rts`
406
407			`;------------------------------------------------------------------------------`
408			`; Display a string on the screen.`
409			`; The characters are packed 4 per word`
410			`;------------------------------------------------------------------------------`
411			`;`
412			`DisplayStringB:`
413			`pha`
414			`phx`
415			`tax ; r2 = pointer to string`
416			`dspj1B:`
417			`lda (x) ; move string char into acc`
418			`inx ; increment pointer`
419			`pha`
420			`and #$FF`
421			`cmp #0 ; is it end of string ?`
422			`beq dsretB`
423			`jsr DisplayChar ; display character`
424			`pla`
425			`m_lsr8`
426			`pha`
427			`and #$FF`
428			`cmp #0`
429			`beq dsretB`
430			`jsr DisplayChar`
431			`pla`
432			`m_lsr8`
433			`pha`
434			`and #$FF`
435			`cmp #0`
436			`beq dsretB`
437			`jsr DisplayChar`
438			`pla`
439			`m_lsr8`
440			`pha`
441			`and #$FF`
442			`cmp #0`
443			`beq dsretB`
444			`jsr DisplayChar`
445			`pla`
446			`bra dspj1B ; go back for next character`
447			`dsretB:`
448			`pla`
449			`plx`
450			`pla`
451			`rts`
452
453			`;------------------------------------------------------------------------------`
454			`; Display a string on the screen.`
455			`; The characters are packed 1 per word`
456			`;------------------------------------------------------------------------------`
457			`;`
458			`DisplayStringW:`
459			`pha`
460			`phx`
461			`tax ; r2 = pointer to string`
462			`dspj1W:`
463			`lda (x) ; move string char into acc`
464			`inx ; increment pointer`
465			`cmp #0 ; is it end of string ?`
466			`beq dsretW`
467			`jsr DisplayChar ; display character`
468			`bra dspj1W ; go back for next character`
469			`dsretW:`
470			`plx`
471			`pla`
472			`rts`
473
474			`DisplayStringCRLFB:`
475			`jsr DisplayStringB`
476			`CRLF:`
477			`pha`
478			`lda #'\r'`
479			`jsr DisplayChar`
480			`lda #'\n'`
481			`jsr DisplayChar`
482			`pla`
483			`rts`
484
485			`;------------------------------------------------------------------------------`
486			`; Display nybble in r1`
487			`;------------------------------------------------------------------------------`
488			`;`
489			`DisplayNybble:`
490			`pha`
491			`and #$0F`
492			`add #'0'`
493			`cmp #'9'`
494			`bcc dispnyb1`
495			`add #7`
496			`dispnyb1:`
497			`jsr DisplayChar`
498			`pla`
499			`rts`
500
501			`;------------------------------------------------------------------------------`
502			`; Display the byte in r1`
503			`;------------------------------------------------------------------------------`
504			`;`
505			`DisplayByte:`
506			`pha`
507			`lsr`
508			`lsr`
509			`lsr`
510			`lsr`
511			`jsr DisplayNybble`
512			`pla`
513			`jmp DisplayNybble ; tail rts`
514
515			`;------------------------------------------------------------------------------`
516			`;------------------------------------------------------------------------------`
517			`ClearBmpScreen:`
518			`pha`
519			`phx`
520			`phy`
521			`ldx #(1364*768)>>2 ; x = # words to clear`
522			`lda #0x29292929 ; acc = color for four pixels`
523			`ldy #BITMAPSCR ; y = screen address`
524			`csj4`
525			`sta (y) ; store pixel data`
526			`iny ; advance screen address`
527			`dex ; decrement pixel count and loop back`
528			`bne csj4`
529			`ply`
530			`plx`
531			`pla`
532			`rts`
533
534			`;==============================================================================`
535			`;==============================================================================`
536			`;`
537			`; Initialize the SD card`
538			`; Returns`
539			`; acc = 0 if successful, 1 otherwise`
540			`;`
541			`spi_init`
542			`lda #SPI_INIT_SD`
543			`sta SPIMASTER+SPI_TRANS_TYPE_REG`
544			`lda #SPI_TRANS_START`
545			`sta SPIMASTER+SPI_TRANS_CTRL_REG`
546			`nop`
547			`spi_init1`
548			`lda SPIMASTER+SPI_TRANS_STATUS_REG`
549			`nop`
550			`nop`
551			`cmp #SPI_TRANS_BUSY`
552			`beq spi_init1`
553			`lda SPIMASTER+SPI_TRANS_ERROR_REG`
554			`and #3`
555			`cmp #SPI_INIT_NO_ERROR`
556			`bne spi_error`
557			`lda #spi_init_ok_msg>>2`
558			`jsr DisplayStringB`
559			`lda #0`
560			`bra spi_init_exit`
561			`spi_error`
562			`jsr DisplayByte`
563			`lda #spi_init_error_msg>>2`
564			`jsr DisplayStringB`
565			`lda SPIMASTER+SPI_RESP_BYTE1`
566			`jsr DisplayByte`
567			`lda SPIMASTER+SPI_RESP_BYTE2`
568			`jsr DisplayByte`
569			`lda SPIMASTER+SPI_RESP_BYTE3`
570			`jsr DisplayByte`
571			`lda SPIMASTER+SPI_RESP_BYTE4`
572			`jsr DisplayByte`
573			`lda #1`
574			`spi_init_exit`
575			`rts`
576
577
578
579			`; SPI read sector`
580			`;`
581			`; r1= sector number to read`
582			`; r2= address to place read data`
583			`; Returns:`
584			`; r1 = 0 if successful`
585			`;`
586			`spi_read_sector:`
587			`phx`
588			`phy`
589			`push r4`
590
591			`sta SPIMASTER+SPI_SD_SECT_7_0_REG`
592			`m_lsr8`
593			`sta SPIMASTER+SPI_SD_SECT_15_8_REG`
594			`m_lsr8`
595			`sta SPIMASTER+SPI_SD_SECT_23_16_REG`
596			`m_lsr8`
597			`sta SPIMASTER+SPI_SD_SECT_31_24_REG`
598
599			`ld r4,#20 ; retry count`
600
601			`spi_read_retry:`
602			`; Force the reciever fifo to be empty, in case a prior error leaves it`
603			`; in an unknown state.`
604			`lda #1`
605			`sta SPIMASTER+SPI_RX_FIFO_CTRL_REG`
606
607			`lda #RW_READ_SD_BLOCK`
608			`sta SPIMASTER+SPI_TRANS_TYPE_REG`
609			`lda #SPI_TRANS_START`
610			`sta SPIMASTER+SPI_TRANS_CTRL_REG`
611			`nop`
612			`spi_read_sect1:`
613			`lda SPIMASTER+SPI_TRANS_STATUS_REG`
614			`nop ; just a delay between consecutive status reg reads`
615			`nop`
616			`cmp #SPI_TRANS_BUSY`
617			`beq spi_read_sect1`
618			`lda SPIMASTER+SPI_TRANS_ERROR_REG`
619			`lsr`
620			`lsr`
621			`and #3`
622			`cmp #SPI_READ_NO_ERROR`
623			`bne spi_read_error`
624			`ldy #512 ; read 512 bytes from fifo`
625			`spi_read_sect2:`
626			`lda SPIMASTER+SPI_RX_FIFO_DATA_REG`
627			`sta (x)`
628			`inx`
629			`dey`
630			`bne spi_read_sect2`
631			`lda #0`
632			`bra spi_read_ret`
633			`spi_read_error:`
634			`sub r4,r4,#1`
635			`bne spi_read_retry`
636			`jsr DisplayByte`
637			`lda #spi_read_error_msg>>2`
638			`jsr DisplayStringB`
639			`lda #1`
640			`spi_read_ret:`
641			`pop r4`
642			`ply`
643			`plx`
644			`rts`
645
646			`; SPI write sector`
647			`;`
648			`; r1= sector number to write`
649			`; r2= address to get data from`
650			`; Returns:`
651			`; r1 = 0 if successful`
652			`;`
653			`spi_write_sector:`
654			`phx`
655			`phy`
656			`pha`
657			`; Force the transmitter fifo to be empty, in case a prior error leaves it`
658			`; in an unknown state.`
659			`lda #1`
660			`sta SPIMASTER+SPI_TX_FIFO_CTRL_REG`
661			`nop ; give I/O time to respond`
662			`nop`
663
664			`; now fill up the transmitter fifo`
665			`ldy #512`
666			`spi_write_sect1:`
667			`lda (x)`
668			`sta SPIMASTER+SPI_TX_FIFO_DATA_REG`
669			`nop ; give the I/O time to respond`
670			`nop`
671			`inx`
672			`dey`
673			`bne spi_write_sect1`
674
675			`; set the sector number in the spi master address registers`
676			`pla`
677			`sta SPIMASTER+SPI_SD_SECT_7_0_REG`
678			`m_lsr8`
679			`sta SPIMASTER+SPI_SD_SECT_15_8_REG`
680			`m_lsr8`
681			`sta SPIMASTER+SPI_SD_SECT_23_16_REG`
682			`m_lsr8`
683			`sta SPIMASTER+SPI_SD_SECT_31_24_REG`
684
685			`; issue the write command`
686			`lda #RW_WRITE_SD_BLOCK`
687			`sta SPIMASTER+SPI_TRANS_TYPE_REG`
688			`lda #SPI_TRANS_START`
689			`sta SPIMASTER+SPI_TRANS_CTRL_REG`
690			`nop`
691			`spi_write_sect2:`
692			`lda SPIMASTER+SPI_TRANS_STATUS_REG`
693			`nop ; just a delay between consecutive status reg reads`
694			`nop`
695			`cmp #SPI_TRANS_BUSY`
696			`beq spi_write_sect2`
697			`lda SPIMASTER+SPI_TRANS_ERROR_REG`
698			`lsr`
699			`lsr`
700			`lsr`
701			`lsr`
702			`and #3`
703			`cmp #SPI_WRITE_NO_ERROR`
704			`bne spi_write_error`
705			`lda #0`
706			`bra spi_write_ret`
707			`spi_write_error:`
708			`jsr DisplayByte`
709			`lda #spi_write_error_msg>>2`
710			`jsr DisplayStringB`
711			`lda #1`
712
713			`spi_write_ret:`
714			`ply`
715			`plx`
716			`rts`
717
718			`align 4`
719			`msgJumpingToBoot:`
720			`db "Jumping to boot",0`
721			`align 4`
722			`msgNotBootable:`
723			`db "SD card not bootable.",0`
724			`align 4`
725			`spi_init_ok_msg:`
726			`db "SD card initialized okay.",0`
727			`align 4`
728			`spi_init_error_msg:`
729			`db ": error occurred initializing the SD card.",0`
730			`align 4`
731			`spi_boot_error_msg:`
732			`db "SD card boot error",0`
733			`align 4`
734			`spi_read_error_msg:`
735			`db "SD card read error",0`
736			`align 4`
737			`spi_write_error_msg:`
738			`db "SD card write error",0`
739
740			`nmirout`
741			`rti`
742
743			`org $0FFFFFFF4 ; NMI vector`
744			`dw nmirout`
745
746			`org $0FFFFFFF8 ; reset vector, native mode`
747			`dw start`
748
749			`end`
750