mirror of
https://github.com/cc65/cc65.git
synced 2024-07-05 06:28:57 +00:00
757 lines
12 KiB
ArmAsm
757 lines
12 KiB
ArmAsm
;
|
|
; Atari XL shadow RAM handlers
|
|
;
|
|
; Christian Groessler, chris@groessler.org, 2013
|
|
;
|
|
|
|
DEBUG = 1
|
|
|
|
.if .defined(__ATARIXL__)
|
|
|
|
.include "atari.inc"
|
|
.include "save_area.inc"
|
|
.include "zeropage.inc"
|
|
.import __CHARGEN_START__
|
|
|
|
.export sram_init
|
|
.export KEYBDV_wrapper
|
|
|
|
BUFSZ = 128
|
|
BUFSZ_CIO = BUFSZ
|
|
BUFSZ_SIO = BUFSZ
|
|
|
|
.macro disable_rom
|
|
lda PORTB
|
|
and #$fe
|
|
sta PORTB
|
|
lda #>__CHARGEN_START__
|
|
sta CHBAS
|
|
sta CHBASE
|
|
.endmacro
|
|
.macro enable_rom
|
|
lda PORTB
|
|
ora #1
|
|
sta PORTB
|
|
lda #$E0
|
|
sta CHBAS
|
|
sta CHBASE
|
|
.endmacro
|
|
|
|
.segment "INIT"
|
|
|
|
;enable_count: .res 1
|
|
|
|
; Turn off ROMs, install system and interrupt wrappers, set new chargen pointer
|
|
|
|
sram_init:
|
|
|
|
; disable all interrupts
|
|
sei
|
|
ldx #0
|
|
stx NMIEN ; disable NMI
|
|
|
|
; disable ROMs
|
|
disable_rom
|
|
|
|
; setup interrupt vectors
|
|
lda #<my_IRQ_han
|
|
sta $fffe
|
|
lda #>my_IRQ_han
|
|
sta $ffff
|
|
|
|
lda #<my_RESET_han
|
|
sta $fffc
|
|
lda #>my_RESET_han
|
|
sta $fffd
|
|
|
|
lda #<my_NMI_han
|
|
sta $fffa
|
|
lda #>my_NMI_han
|
|
sta $fffb
|
|
|
|
; setup pointers to CIOV and SIOV wrappers
|
|
lda #$4C ; JMP opcode
|
|
sta CIOV
|
|
lda #<my_CIOV
|
|
sta CIOV+1
|
|
lda #>my_CIOV
|
|
sta CIOV+2
|
|
lda #$4C ; JMP opcode
|
|
sta SIOV
|
|
lda #<my_SIOV
|
|
sta SIOV+1
|
|
lda #>my_SIOV
|
|
sta SIOV+2
|
|
|
|
; enable interrupts
|
|
lda #$40
|
|
sta NMIEN
|
|
cli
|
|
|
|
rts
|
|
|
|
.segment "EXTZP" : zeropage
|
|
|
|
zpptr1: .res 2
|
|
|
|
|
|
.segment "LOWBUFS"
|
|
|
|
; bounce buffers for CIO and SIO calls
|
|
CIO_buffer: .res BUFSZ_CIO
|
|
SIO_buffer: .res BUFSZ_SIO
|
|
|
|
|
|
.segment "LOWCODE"
|
|
|
|
|
|
; Interrupt handlers
|
|
; ------------------
|
|
|
|
; The interrupt handlers don't look at the current state of PORTB and
|
|
; unconditionally disable the ROMs on exit.
|
|
; Please note that this works, since if the ROMs are enabled we anyway
|
|
; aren't being called here because the vectors are pointing to their
|
|
; original ROM locations.
|
|
|
|
.macro int_wrap orgvec
|
|
.local ret
|
|
pha
|
|
enable_rom
|
|
lda #>ret
|
|
pha
|
|
lda #<ret
|
|
pha
|
|
php
|
|
jmp (orgvec)
|
|
ret: disable_rom
|
|
pla
|
|
rti
|
|
.endmacro
|
|
|
|
my_IRQ_han:
|
|
.ifdef DEBUG
|
|
php
|
|
pha
|
|
tya
|
|
pha
|
|
ldy #0
|
|
lda (SAVMSC),y
|
|
clc
|
|
adc #1
|
|
sta (SAVMSC),y
|
|
pla
|
|
tay
|
|
pla
|
|
plp
|
|
.endif
|
|
int_wrap IRQ_save
|
|
|
|
my_NMI_han:
|
|
.ifdef DEBUG
|
|
php
|
|
pha
|
|
tya
|
|
pha
|
|
ldy #39
|
|
lda (SAVMSC),y
|
|
clc
|
|
adc #1
|
|
sta (SAVMSC),y
|
|
pla
|
|
tay
|
|
pla
|
|
plp
|
|
.endif
|
|
; set I bit to interrupted value
|
|
pha
|
|
txa
|
|
pha
|
|
tsx
|
|
lda $103,x
|
|
pha
|
|
plp
|
|
pla
|
|
tax
|
|
pla
|
|
int_wrap NMI_save
|
|
|
|
my_RESET_han:
|
|
enable_rom
|
|
jmp (RESET_save)
|
|
|
|
|
|
; System request handlers
|
|
; -----------------------
|
|
|
|
|
|
; for filenames we assume they will fit into our bounce buffer
|
|
|
|
; one filename, terminated by "invalid character", located at ICBAL/ICBAH
|
|
|
|
CIO_filename:
|
|
jsr setup_zpptr1_y0
|
|
jsr copy_filename
|
|
CIO_fn_cont:
|
|
jsr ciobuf_to_iocb
|
|
ldy CIO_y
|
|
jsr CIO_call_a ; call CIO (maybe A isn't needed, then we could call CIO_call)
|
|
php
|
|
pha
|
|
jsr restore_icba ; restore original ICBAL/ICBAH
|
|
pla
|
|
plp
|
|
rts ; back to application
|
|
|
|
|
|
; two filenames, terminated and separated by "invalid character", located at ICBAL/ICBAH
|
|
|
|
CIO_filename2:
|
|
jsr setup_zpptr1_y0
|
|
jsr copy_filename
|
|
iny
|
|
jsr copy_filename
|
|
jmp CIO_fn_cont
|
|
|
|
|
|
|
|
CIO_call_a:
|
|
lda CIO_a
|
|
|
|
CIOV_call:
|
|
pha
|
|
lda PORTB
|
|
sta cur_CIOV_PORTB
|
|
enable_rom
|
|
pla
|
|
jsr CIOV_org
|
|
php
|
|
pha
|
|
lda cur_CIOV_PORTB
|
|
sta PORTB
|
|
pla
|
|
plp
|
|
rts
|
|
|
|
|
|
; CIO handler
|
|
; We have buffer pointer and length entries in the IOCB, but their
|
|
; usage depends on the function.
|
|
; Some functions don't care about any of them (pointer and length),
|
|
; and some only use the pointer (like e.g. OPEN), and some use both.
|
|
; So we need function specific handlers to correctly deal with
|
|
; buffers which are overlapping with the ROM area.
|
|
; All input and output registers need to be preserved (I'm not 100%
|
|
; sure about Y as input, but let's preserve it for now.)
|
|
;
|
|
; FIXME: Currently only the requests used by the runtime lib are handled.
|
|
|
|
my_CIOV:
|
|
|
|
; @@@ TODO: check X for valid IOCB index ((X < $80) and ((X & $F) == 0))
|
|
|
|
sta CIO_a
|
|
sty CIO_y
|
|
stx CIO_x
|
|
|
|
lda ICCOM,x ; get function
|
|
cmp #OPEN
|
|
beq CIO_filename ; filename as input parameter in buffer, length not used
|
|
cmp #PUTREC
|
|
bcc CIO_read ; input (GETREC or GETCHR)
|
|
cmp #CLOSE
|
|
bcc CIO_write_jmp ; output (PUTREC or PUTCHR)
|
|
beq CIO_call_a ; pass through, buffer not used
|
|
cmp #RENAME ; 2 filenames as input parameters in buffer, length not used
|
|
beq CIO_filename2
|
|
cmp #GETCWD
|
|
bcc CIO_filename ; filename as input parameter in buffer, length not used
|
|
beq CIO_read ; input
|
|
bcs CIO_call_a ; other commands: assume no buffer
|
|
; not reached
|
|
|
|
CIO_write_jmp:
|
|
jmp CIO_write
|
|
|
|
|
|
; READ handler
|
|
; ------------
|
|
|
|
CIO_read:
|
|
lda ICBLL,x
|
|
ora ICBLH,x
|
|
beq CIO_call_a ; special I/O through A register in case buffer length is 0
|
|
|
|
; @@@ TODO: check if bounce buffer is really needed because buffer is in ROM area
|
|
|
|
; If the data length is larger than our bounce buffer, we have to split the request into smaller ones.
|
|
; Otherwise we can get away with one call and a copy to the final destination afterwards.
|
|
|
|
lda ICBLH,x ; get high byte of length
|
|
bne big_read ; not zero -> data too large for our buffers
|
|
; CHANGE HERE TO SUPPORT BOUNCE BUFFERS > 255 BYTES
|
|
lda #<BUFSZ_CIO
|
|
cmp ICBLL,x
|
|
bcc big_read
|
|
|
|
; Data size fits into bounce buffer
|
|
|
|
jsr setup_zpptr1
|
|
jsr ciobuf_to_iocb
|
|
jsr CIO_call_a ; call CIO
|
|
php
|
|
bpl @no_err
|
|
cpy #EOFERR
|
|
beq @no_err
|
|
pha
|
|
jsr restore_icba
|
|
pla
|
|
plp
|
|
rts ; return with error
|
|
|
|
@no_err:
|
|
sta CIO_a
|
|
sty CIO_y
|
|
|
|
jsr copy_to_user ; copy data into user buffer
|
|
jsr restore_icba
|
|
|
|
lda CIO_a
|
|
ldy CIO_y
|
|
plp
|
|
rts ; return with success
|
|
|
|
; Data size does not fit into bounce buffer
|
|
|
|
big_read:
|
|
lda #0
|
|
sta retlen ; initialize return length
|
|
sta retlen+1
|
|
jsr iocblen_to_orig_len
|
|
jsr iocbptr_to_orig_ptr
|
|
jsr setup_zpptr1
|
|
jsr ciobuf_to_iocb ; let ICBAL/ICBAH point to bounce buffer
|
|
|
|
br_loop:
|
|
jsr cmp_orig_len_cio_bufsz ; is transfer length > bounce buffer size?
|
|
bcs br_last ; no, last transfer, use remaining size
|
|
|
|
lda #>BUFSZ_CIO
|
|
sta ICBLH,x ; set data length
|
|
lda #<BUFSZ_CIO
|
|
sta ICBLL,x
|
|
bne br_cont
|
|
|
|
br_last:
|
|
lda orig_len+1
|
|
sta ICBLH,x ; set data length
|
|
lda orig_len
|
|
sta ICBLL,x
|
|
|
|
br_cont:
|
|
sta req_len ; remember length of this request
|
|
lda ICBLH,x
|
|
sta req_len+1
|
|
jsr CIO_call_a ; do the request
|
|
php
|
|
bpl br_no_err
|
|
cpy #EOFERR
|
|
beq br_no_err
|
|
|
|
pha
|
|
jsr restore_icba
|
|
pla
|
|
plp
|
|
rts ; return with error
|
|
|
|
br_no_err:
|
|
sta CIO_a
|
|
sty CIO_y
|
|
pla
|
|
sta CIO_p
|
|
jsr copy_to_user
|
|
|
|
; update retlen
|
|
clc
|
|
lda retlen
|
|
adc ICBLL,x
|
|
sta retlen
|
|
lda retlen+1
|
|
adc #0
|
|
sta retlen+1
|
|
|
|
; if the request read less bytes than requested, we're done
|
|
lda ICBLL,x
|
|
cmp req_len
|
|
bne br_done
|
|
lda ICBLH,x
|
|
cmp req_len+1
|
|
bne br_done
|
|
|
|
; update user buffer pointer (zpptr1)
|
|
clc
|
|
lda zpptr1
|
|
adc ICBLL,x
|
|
sta zpptr1
|
|
lda zpptr1+1
|
|
adc #0
|
|
sta zpptr1+1
|
|
|
|
; update remaining length
|
|
sec
|
|
lda orig_len
|
|
sbc ICBLL,x
|
|
sta orig_len
|
|
lda orig_len+1
|
|
sbc #0
|
|
sta orig_len+1
|
|
|
|
; still something left to do (remaining length != 0)?
|
|
lda orig_len
|
|
ora orig_len+1
|
|
beq br_done
|
|
jmp br_loop
|
|
|
|
; done, write original buffer pointer and total transfer length to IOCB and return to application
|
|
br_done:
|
|
lda retlen
|
|
sta ICBLL,x
|
|
lda retlen+1
|
|
sta ICBLH,x
|
|
jsr orig_ptr_to_iocbptr
|
|
lda CIO_p
|
|
pha
|
|
lda CIO_a
|
|
ldy CIO_y
|
|
plp
|
|
rts ; return with success
|
|
|
|
|
|
|
|
CIO_call_a_jmp:
|
|
jmp CIO_call_a
|
|
|
|
|
|
|
|
; WRITE handler
|
|
; -------------
|
|
|
|
|
|
CIO_write:
|
|
lda ICBLL,x
|
|
ora ICBLH,x
|
|
beq CIO_call_a_jmp ; special I/O through A register in case buffer length is 0
|
|
|
|
; @@@ TODO: check if bounce buffer is really needed because buffer is in ROM area
|
|
|
|
; If the data length is larger than our bounce buffer, we have to split the request into smaller ones.
|
|
; Otherwise we can get away with a copy to the bounce buffer and the call.
|
|
|
|
lda ICBLH,x ; get high byte of length
|
|
bne big_write ; not zero -> data too large for our buffers
|
|
; CHANGE HERE TO SUPPORT BOUNCE BUFFERS > 255 BYTES
|
|
lda #<BUFSZ_CIO
|
|
cmp ICBLL,x
|
|
bcc big_write
|
|
|
|
|
|
; Data size fits into bounce buffer
|
|
|
|
jsr setup_zpptr1
|
|
jsr ciobuf_to_iocb
|
|
jsr copy_from_user
|
|
ldy CIO_y
|
|
jsr CIO_call_a
|
|
php
|
|
pha
|
|
jsr restore_icba
|
|
pla
|
|
plp
|
|
rts ; return to application
|
|
|
|
|
|
; Data size does not fit into bounce buffer
|
|
|
|
big_write:
|
|
lda #0
|
|
sta retlen ; initialize return length
|
|
sta retlen+1
|
|
jsr iocblen_to_orig_len
|
|
jsr iocbptr_to_orig_ptr
|
|
jsr setup_zpptr1
|
|
jsr ciobuf_to_iocb ; let ICBAL/ICBAH point to bounce buffer
|
|
|
|
bw_loop:
|
|
jsr cmp_orig_len_cio_bufsz ; is transfer length > bounce buffer size?
|
|
bcs bw_last ; no, last transfer, use remaining size
|
|
|
|
lda #>BUFSZ_CIO
|
|
sta ICBLH,x ; set data length
|
|
lda #<BUFSZ_CIO
|
|
sta ICBLL,x
|
|
bne bw_cont
|
|
|
|
bw_last:
|
|
lda orig_len+1
|
|
sta ICBLH,x ; set data length
|
|
lda orig_len
|
|
sta ICBLL,x
|
|
|
|
bw_cont:
|
|
sta req_len ; remember length of this request
|
|
lda ICBLH,x
|
|
sta req_len+1
|
|
jsr copy_from_user
|
|
jsr CIO_call_a ; do the request
|
|
php
|
|
bpl bw_no_err
|
|
|
|
plp
|
|
rts ; error return
|
|
|
|
bw_no_err:
|
|
sta CIO_a
|
|
sty CIO_y
|
|
pla
|
|
sta CIO_p
|
|
|
|
; update retlen
|
|
clc
|
|
lda retlen
|
|
adc ICBLL,x
|
|
sta retlen
|
|
lda retlen+1
|
|
adc #0
|
|
sta retlen+1
|
|
|
|
; if the request wrote less bytes than requested, we're done
|
|
lda ICBLL,x
|
|
cmp req_len
|
|
bne bw_done
|
|
lda ICBLH,x
|
|
cmp req_len+1
|
|
bne bw_done
|
|
|
|
; update user buffer pointer (zpptr1)
|
|
clc
|
|
lda zpptr1
|
|
adc ICBLL,x
|
|
sta zpptr1
|
|
lda zpptr1+1
|
|
adc #0
|
|
sta zpptr1+1
|
|
|
|
; update remaining length
|
|
sec
|
|
lda orig_len
|
|
sbc ICBLL,x
|
|
sta orig_len
|
|
lda orig_len+1
|
|
sbc #0
|
|
sta orig_len+1
|
|
|
|
; still something left to do (remaining length != 0)?
|
|
lda orig_len
|
|
ora orig_len+1
|
|
beq bw_done
|
|
jmp bw_loop
|
|
|
|
bw_done:
|
|
lda retlen
|
|
sta ICBLL,x
|
|
lda retlen+1
|
|
sta ICBLH,x
|
|
jsr orig_ptr_to_iocbptr
|
|
lda CIO_p
|
|
pha
|
|
lda CIO_a
|
|
ldy CIO_y
|
|
plp
|
|
rts ; return with success
|
|
|
|
|
|
|
|
; check if length is larger than bounce buffer size
|
|
; input: orig_len - length
|
|
; output: A - destroyed
|
|
; CF - 0/1 for larger/not larger
|
|
cmp_orig_len_cio_bufsz:
|
|
sec
|
|
lda #<BUFSZ_CIO
|
|
sbc orig_len
|
|
lda #>BUFSZ_CIO
|
|
sbc orig_len+1
|
|
rts
|
|
|
|
|
|
; copy data from bounce buffer into user buffer
|
|
; input: X - IOCB index
|
|
; zpptr1 - pointer to user buffer
|
|
; output: A - destroyed
|
|
; Y - 0
|
|
copy_to_user:
|
|
ldy ICBLL,x ; get # of bytes read (CHANGE HERE TO SUPPORT BOUNCE BUFFERS > 255 BYTES)
|
|
beq @copy_done
|
|
@copy: dey
|
|
lda CIO_buffer,y
|
|
sta (zpptr1),y
|
|
cpy #0
|
|
bne @copy
|
|
@copy_done:
|
|
rts
|
|
|
|
|
|
; copy data from user buffer into bounce buffer
|
|
; input: X - IOCB index
|
|
; zpptr1 - pointer to user buffer
|
|
; output: A - destroyed
|
|
; Y - 0
|
|
copy_from_user:
|
|
ldy ICBLL,x ; get # of bytes to write (CHANGE HERE TO SUPPORT BOUNCE BUFFERS > 255 BYTES)
|
|
beq @copy_done
|
|
@copy: dey
|
|
lda (zpptr1),y
|
|
sta CIO_buffer,y
|
|
cpy #0
|
|
bne @copy
|
|
@copy_done:
|
|
rts
|
|
|
|
|
|
; copy ICBLL/ICBLH to 'orig_len'
|
|
; input: X - IOCB index
|
|
; output: A - destroyed
|
|
iocblen_to_orig_len:
|
|
lda ICBLL,x
|
|
sta orig_len
|
|
lda ICBLH,x
|
|
sta orig_len+1
|
|
rts
|
|
|
|
|
|
; copy ICBAL/ICBAH to 'orig_ptr'
|
|
; input: X - IOCB index
|
|
; output: A - destroyed
|
|
iocbptr_to_orig_ptr:
|
|
lda ICBAL,x
|
|
sta orig_ptr
|
|
lda ICBAH,x
|
|
sta orig_ptr+1
|
|
rts
|
|
|
|
|
|
; copy 'orig_ptr' to ICBAL/ICBAH
|
|
; input: X - IOCB index
|
|
; output: A - destroyed
|
|
orig_ptr_to_iocbptr:
|
|
lda orig_ptr
|
|
sta ICBAL,x
|
|
lda orig_ptr+1
|
|
sta ICBAH,x
|
|
rts
|
|
|
|
|
|
; restore original contents of ICBAL/ICBAH from 'zpptr1'
|
|
; input: X - IOCB index
|
|
; output: A - destroyed
|
|
restore_icba:
|
|
lda zpptr1
|
|
sta ICBAL,x
|
|
lda zpptr1+1
|
|
sta ICBAH,x
|
|
rts
|
|
|
|
|
|
; put bounce buffer address into ICBAL/ICBAH
|
|
; input: X - IOCB index
|
|
; output: A - destroyed
|
|
ciobuf_to_iocb:
|
|
lda #<CIO_buffer
|
|
sta ICBAL,x
|
|
lda #>CIO_buffer
|
|
sta ICBAH,x
|
|
rts
|
|
|
|
|
|
; copy file name pointed to by 'zpptr1' to bounce buffer 'CIO_buffer'
|
|
; input: Y - index into file name buffer and CIO_buffer
|
|
; output: Y - points to first invalid byte after file name
|
|
; A - destroyed
|
|
copy_filename:
|
|
lda (zpptr1),y
|
|
sta CIO_buffer,y
|
|
beq copy_fn_done
|
|
iny
|
|
cmp #ATEOL
|
|
bne copy_filename
|
|
dey
|
|
copy_fn_done:
|
|
rts
|
|
|
|
|
|
; write IOCB buffer address into zpptr1
|
|
; input: X - IOCB index
|
|
; output: Y - 0 (for setup_zpptr1_y0, else unchanged)
|
|
; A - destroyed
|
|
setup_zpptr1_y0:
|
|
ldy #0
|
|
setup_zpptr1:
|
|
lda ICBAL,x ; put buffer address into zp pointer
|
|
sta zpptr1
|
|
lda ICBAH,x
|
|
sta zpptr1+1
|
|
rts
|
|
|
|
;---------------------------------------------------------
|
|
|
|
my_SIOV:
|
|
pha
|
|
lda PORTB
|
|
sta cur_SIOV_PORTB
|
|
enable_rom
|
|
pla
|
|
jsr SIOV_org
|
|
php
|
|
pha
|
|
lda cur_SIOV_PORTB
|
|
sta PORTB
|
|
pla
|
|
plp
|
|
rts
|
|
|
|
;---------------------------------------------------------
|
|
|
|
KEYBDV_wrapper:
|
|
|
|
lda #>(kret-1)
|
|
pha
|
|
lda #<(kret-1)
|
|
pha
|
|
lda PORTB
|
|
sta cur_KEYBDV_PORTB
|
|
enable_rom
|
|
lda KEYBDV+5
|
|
pha
|
|
lda KEYBDV+4
|
|
pha
|
|
rts ; call keyboard handler
|
|
kret: pha
|
|
lda cur_KEYBDV_PORTB
|
|
sta PORTB
|
|
pla
|
|
rts
|
|
|
|
CIO_a: .res 1
|
|
CIO_x: .res 1
|
|
CIO_y: .res 1
|
|
CIO_p: .res 1
|
|
cur_CIOV_PORTB: .res 1
|
|
cur_SIOV_PORTB: .res 1
|
|
cur_KEYBDV_PORTB: .res 1
|
|
orig_ptr: .res 2
|
|
orig_len: .res 2
|
|
req_len: .res 2
|
|
retlen: .res 2
|
|
|
|
.endif ; .if .defined(__ATARIXL__)
|