bslathi19/cc65
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Merge branch 'cc65:master' into kim1

Browse Source
This commit is contained in:
Rutger van Bergen
2022-09-19 20:03:23 +02:00
committed by GitHub
parent d2a8e907ae 65ce036b2e
commit 2b07204952
218 changed files with 92413 additions and 995 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
libsrc/apple2/ser/a2.ssc.s
View File

@@ -57,7 +57,9 @@
;----------------------------------------------------------------------------
; I/O definitions
ACIA = $C088
Offset = $8F ; Move 6502 false read out of I/O to page $BF
ACIA = $C088-Offset
ACIA_DATA = ACIA+0 ; Data register
ACIA_STATUS = ACIA+1 ; Status register
ACIA_CMD = ACIA+2 ; Command register
@@ -197,6 +199,7 @@ SER_OPEN:
asl
asl
asl
adc Offset ; Assume carry to be clear
tax
; Check if the handshake setting is valid

363
libsrc/c64/emd/c64-rrr.s Normal file
View File

@@ -0,0 +1,363 @@
;
; Extended Memory Driver for the Action Replay/Retro Replay RAM
;
; original Version 1.0 by Johannes Braun 2006-08-22 <hannenz@freenet.de>
; ------------------------------------------------------------------------
.include "zeropage.inc"
.include "em-kernel.inc"
.include "em-error.inc"
.macpack generic
.macpack module
; ------------------------------------------------------------------------
c64_ram = ptr1 ; use some more expressive identifiers...
rr_ram = ptr2
len = ptr3
aux = ptr4
temp = tmp1
Lo_Mem = $0100 ; location of Lo_Code (must be below $1000 or above $e000)
RRMODE_OFF = $02
RRMODE_CART_RAM = $23
; ------------------------------------------------------------------------
; Header. Includes jump table
module_header _c64_rrr_emd
; Driver signature
.byte $65, $6d, $64 ; "emd"
.byte EMD_API_VERSION ; EM API version number
; Library reference
.addr $0000
; Jump table
.addr INSTALL
.addr UNINSTALL
.addr PAGECOUNT
.addr MAP
.addr USE
.addr COMMIT
.addr COPYFROM
.addr COPYTO
; ------------------------------------------------------------------------
; Data.
.bss
window: .res 256 ; the memory window (256 bytes)
pagecount: .res 1 ; Number of available pages
.rodata
dummy:
.word window ; a "pseudo"-em_copy_struct, used by em_map/ em_commit
.byte 0 ; to pass over to COPYTO/COPYFROM
curpage:
.byte $ff ; just this byte is changed according to the desired page
.byte 0
.word 256
.code
;----------------------------------------------------------------------------------------
;unsigned char __fastcall__ em_install(void *driver);
;returns an error code
;----------------------------------------------------------------------------------------
INSTALL:
ldx #c2-c1
: lda c1,x
sta Lo_Mem,x
dex
bpl :-
;ldx #$ff
stx curpage ; invalidate current page
ldy #RRMODE_OFF
sei
jmp Lo_Mem+8 ; jump to the code below
; copied to Lo_Mem
c1:
;detectmodes:
.byte RRMODE_CART_RAM | $00
.byte RRMODE_CART_RAM | $08
.byte RRMODE_CART_RAM | $10
.byte RRMODE_CART_RAM | $18
.byte RRMODE_CART_RAM | $80
.byte RRMODE_CART_RAM | $88
.byte RRMODE_CART_RAM | $90
.byte RRMODE_CART_RAM | $98
; first save c64 memory
lda $8888
pha
; tag c64 memory
lda #$00
sta $8888
ldx #$07
:
; try accessing rr-ram
;lda detectmodes, x
lda Lo_Mem, x
sta $de00
; tag (hopefully) rr memory
txa
ora #$80
sta $8888
dex
bpl :-
;ldy #RRMODE_OFF
sty $de00
; now if C64 memory is $80, there is no AR/RR
; if C64 memory is $00, there is a AR/RR.
lda $8888
beq detectpages
lda #0
beq hasnopages
detectpages:
; we can now read the highest available bank nr from the highest bank :)
lda #RRMODE_CART_RAM | $98
sta $de00
ldx $8888
inx
txa
; 8k = 32 pages
asl
asl
asl
asl
asl
hasnopages:
;ldy #RRMODE_OFF
sty $de00 ; c64 ram again
sta pagecount
; restore c64 memory
pla
sta $8888
cli
ldx pagecount
beq no
; no error
lda #0
tax
rts
no:
lda #4 ; return #4: error code for "device not present"
rts
c2:
;----------------------------------------------------------------------------------------
;void em_uninstall(void);
;----------------------------------------------------------------------------------------
UNINSTALL:
return_null:
lda #$00
tax
rts
;----------------------------------------------------------------------------------------
;unsigned __fastcall__ em_pagecount(void);
;----------------------------------------------------------------------------------------
PAGECOUNT:
lda pagecount ; always return 32kb (128 pages)
ldx #$00
rts
;----------------------------------------------------------------------------------------
;void* __fastcall__ em_use(unsigned page);
;----------------------------------------------------------------------------------------
USE:
cmp #$80 ; valid page?
bcs return_null ; no, return NULL pointer
sta curpage ; set to current page
return_win:
lda #<window ; return pointer to window
ldx #>window
return: rts
;----------------------------------------------------------------------------------------
;void* __fastcall__ em_map(unsigned page);
;----------------------------------------------------------------------------------------
MAP:
cmp pagecount
bcs return_null
sta curpage
lda #<dummy ; load .A/.X with adress of data for COPYFROM-call (which expects the
ldx #>dummy ; adress in .A/.X)
jsr COPYFROM
bcs return_win ; function returns pointer to window (returns always with carry set!)
;----------------------------------------------------------------------------------------
;void __fastcall__ em_commit(void);
;----------------------------------------------------------------------------------------
COMMIT:
lda curpage
cmp pagecount
bcs return
lda #<dummy ; load .A/.X with adress of data for COPYTO-call (which expects the
ldx #>dummy ; adress in .A/.X)
;----------------------------------------------------------------------------------------
;void __fastcall__ em_copyto (struct em_copy *copy_data);
;----------------------------------------------------------------------------------------
COPYTO:
jsr get_struct_data ;read the parameters passed in the em_struct pointed to by .A/.X upon call
;copy the main copyto routine into Lo_Mem
ldy #Lo_Code1_End - Lo_Code1
: lda Lo_Code1-1,y
sta Lo_Mem-1,y
dey
bne :-
COMMON:
sei
jmp Lo_Mem
;this part will be executed in Lo_Mem (!) by COPYFROM
Lo_Code2:
; copy byte rr -> c64
stx $de00 ;map in rr-ram
lda (rr_ram),y ;get byte from rr-ram
sty $de00 ;RR-ROM will be mapped to $8000-$a000 but write access will go to c64-ram anyway!!
sta (c64_ram),y ;and write to c64-ram
nop ;pad to same size as Lo_Code1
nop
Lo_Code2_End:
;this part will be executed in Lo_Mem (!) by COPYTO
Lo_Code1:
; copy byte c64 -> rr
lda (c64_ram),y ;read 1 byte from c64-ram
stx $de00 ;map in rr-ram
sta (rr_ram),y ;write byte to rr-ram
lda #$02 ;map in c64-ram again
sta $de00
;12 bytes
;this part is common for both COPYFROM/COPYTO and executed in Lo_Mem, too
Lo_Code_Common:
inc c64_ram ;increase pointers
bne :+
inc c64_ram+1
: inc rr_ram
bne @skip
inc rr_ram+1
lda rr_ram+1
cmp #$a0 ;wrap around 16k boundary in rr-ram window ($8000-$a000)
bne @skip
lda #$80 ;reset pointer to $8000
sta rr_ram+1
txa ;adjust value in .X to map in next 16k-bank in rr-ram
adc #7 ;carry is set because of former CMP, so it adds 8
tax
;27 bytes
@skip: lda c64_ram
cmp len
lda c64_ram+1
sbc len+1
bcc Lo_Code1
lda #2 ;CHANGE to LDA #0 if driver is called from ROM
sta $de00
cli
rts ;17 bytes = 56 bytes Lo_Code ($38)
Lo_Code1_End:
;----------------------------------------------------------------------------------------
;void __fastcall__ em_copyfrom(struct em_copy *copy_data);
;copy from extended memory into linear memory
;----------------------------------------------------------------------------------------
COPYFROM:
jsr get_struct_data
ldy #Lo_Code2_End - Lo_Code2 ;copy routine into Lo_Mem
: lda Lo_Code2-1,y
sta Lo_Mem-1,y
dey
bne :-
ldy #Lo_Code1_End-Lo_Code_Common
: lda Lo_Code_Common-1,y
sta Lo_Mem+11,y
dey
bne :-
beq COMMON ;and execute...
;----------------------------------------------------------------------------------------
;read the struct data located at (.A/.X)
;and setup parameters for stash/ fetch operation
;----------------------------------------------------------------------------------------
get_struct_data:
;read and process the values from the em_copy struct passed to as parameters rameter to the
;functions em_copyto and em_copyfrom
sta aux ;store adress of struct (passed in .A/.X) into a zp pointer
stx aux+1
ldy #0 ;index 0
lda (aux),y ;read c64-adress lo
sta c64_ram
iny
lda (aux),y ;read c64-adress hi
sta c64_ram+1 ;(c64_ram) --> points to c64-adress space
iny
lda (aux),y ;read rr-adress lo
sta rr_ram
iny
lda (aux),y ;rr-adress hi
pha ;remember
and #$1f
ora #$80 ;adjust into 16k-window ($8000-$a000)
sta rr_ram+1
pla ;re-get hi byte of rr-adress
and #$60 ;isolate bits 5 and 6
lsr
lsr ;shift into bits 3 and 4
ora #$23 ;set bit 5 (select ram) and 1+2 (game/exrom setting for ULTIMAX-mode)
tax ;.X has now the value to write into $de00 to acess rr-ram at desired 16k-bank
iny
iny ;skip unused byte
lda (aux),y ;read length lo-byte
clc
adc c64_ram ;add to c64-addres
sta len
iny
lda (aux),y ;length hi-byte
adc c64_ram+1
sta len+1 ;tmp2: length, tmp3 contains end adress of transfer in c64-ram.
rts
;55 bytes

11
libsrc/common/asctime.c
View File

@@ -42,15 +42,18 @@
/* Code */
/*****************************************************************************/
/*
CAUTION: we need to reserve enough space to be able to hold the maximum
length string:
1234567890123456789012345678901234567
"Wednesday September ..1 00:00:00 1970"
*/
char* __fastcall__ asctime (const struct tm* timep)
{
static char buf[26];
static char buf[38];
/* Format into given buffer and return the result */
return strftime (buf, sizeof (buf), "%c\n", timep)? buf : 0;
}

5
libsrc/common/isascii.s
View File

@@ -11,6 +11,7 @@
;
.export _isascii
.import return0
_isascii:
asl a ; high-bit to carry
@@ -19,6 +20,4 @@ _isascii:
adc #$FF ; calculate return value based on carry
rts
@L1: lda #$00 ; return false
tax
rts
@L1: jmp return0 ; return false

23
libsrc/cx16/waitvsync.s
View File

@@ -5,17 +5,20 @@
; /* Wait for the start of the next video field. */
;
; VERA's vertical sync causes IRQs which increment the jiffy timer.
;
; Updated by ZeroByteOrg to use Kernal API RDTIM to retreive the TIMER variable
;
.export _waitvsync
.importzp tmp1
.import RDTIM
.include "cx16.inc"
_waitvsync:
ldx RAM_BANK ; (TIMER is in RAM bank 0)
stz RAM_BANK
lda TIMER + 2
: cmp TIMER + 2
beq :- ; Wait for next jiffy
stx RAM_BANK
rts
.proc _waitvsync: near
jsr RDTIM
sta tmp1
keep_waiting:
jsr RDTIM
cmp tmp1
beq keep_waiting
rts
.endproc

2
libsrc/dbg/dbg.c
View File

@@ -1063,7 +1063,7 @@ static char StackHandler (void)
break;
case 'a':
#ifdef CH_CURS_UP:
#ifdef CH_CURS_UP
case CH_CURS_UP:
#endif
--StackAddr;

2
libsrc/tgi/tgi_unload.s
View File

@@ -29,6 +29,6 @@ _tgi_unload:
jmp _mod_free ; Free the driver
no_driver:
lda #<TGI_ERR_NO_DRIVER
lda #TGI_ERR_NO_DRIVER
sta _tgi_error
rts