2020-08-25 23:56:26 +00:00
; Prog8 definitions for the CommanderX16
; Including memory registers, I/O registers, Basic and Kernal subroutines.
2023-04-28 21:13:03 +00:00
cbm {
2020-08-26 17:34:12 +00:00
2023-04-28 21:13:03 +00:00
; Commodore (CBM) common variables, vectors and kernal routines
2020-08-25 23:56:26 +00:00
2023-06-29 22:29:50 +00:00
%option no_symbol_prefixing
2020-10-14 22:58:41 +00:00
; STROUT --> use txt.print
; CLEARSCR -> use txt.clear_screen
2021-12-22 21:59:36 +00:00
; HOMECRSR -> use txt.home or txt.plot
2020-08-25 23:56:26 +00:00
2020-10-05 17:14:32 +00:00
romsub $FF81 = CINT() clobbers(A,X,Y) ; (alias: SCINIT) initialize screen editor and video chip
romsub $FF84 = IOINIT() clobbers(A, X) ; initialize I/O devices (CIA, SID, IRQ)
romsub $FF87 = RAMTAS() clobbers(A,X,Y) ; initialize RAM, tape buffer, screen
romsub $FF8A = RESTOR() clobbers(A,X,Y) ; restore default I/O vectors
2023-05-07 20:59:30 +00:00
romsub $FF8D = VECTOR(uword userptr @ XY, bool dir @ Pc) clobbers(A,Y) ; read/set I/O vector table
2020-08-25 23:56:26 +00:00
romsub $FF90 = SETMSG(ubyte value @ A) ; set Kernal message control flag
2020-10-05 17:14:32 +00:00
romsub $FF93 = SECOND(ubyte address @ A) clobbers(A) ; (alias: LSTNSA) send secondary address after LISTEN
romsub $FF96 = TKSA(ubyte address @ A) clobbers(A) ; (alias: TALKSA) send secondary address after TALK
2023-05-07 20:59:30 +00:00
romsub $FF99 = MEMTOP(uword address @ XY, bool dir @ Pc) -> uword @ XY ; read/set top of memory pointer. NOTE: as a Cx16 extension, also returns the number of RAM memory banks in register A ! See cx16.numbanks()
romsub $FF9C = MEMBOT(uword address @ XY, bool dir @ Pc) -> uword @ XY ; read/set bottom of memory pointer
2020-10-05 17:14:32 +00:00
romsub $FF9F = SCNKEY() clobbers(A,X,Y) ; scan the keyboard
2020-08-25 23:56:26 +00:00
romsub $FFA2 = SETTMO(ubyte timeout @ A) ; set time-out flag for IEEE bus
romsub $FFA5 = ACPTR() -> ubyte @ A ; (alias: IECIN) input byte from serial bus
romsub $FFA8 = CIOUT(ubyte databyte @ A) ; (alias: IECOUT) output byte to serial bus
2020-10-05 17:14:32 +00:00
romsub $FFAB = UNTLK() clobbers(A) ; command serial bus device to UNTALK
romsub $FFAE = UNLSN() clobbers(A) ; command serial bus device to UNLISTEN
romsub $FFB1 = LISTEN(ubyte device @ A) clobbers(A) ; command serial bus device to LISTEN
romsub $FFB4 = TALK(ubyte device @ A) clobbers(A) ; command serial bus device to TALK
2020-08-25 23:56:26 +00:00
romsub $FFB7 = READST() -> ubyte @ A ; read I/O status word
2021-03-20 01:39:53 +00:00
romsub $FFBA = SETLFS(ubyte logical @ A, ubyte device @ X, ubyte secondary @ Y) ; set logical file parameters
2020-08-25 23:56:26 +00:00
romsub $FFBD = SETNAM(ubyte namelen @ A, str filename @ XY) ; set filename parameters
2023-05-07 20:59:30 +00:00
romsub $FFC0 = OPEN() clobbers(X,Y) -> bool @Pc, ubyte @A ; (via 794 ($31A)) open a logical file
2020-10-05 17:14:32 +00:00
romsub $FFC3 = CLOSE(ubyte logical @ A) clobbers(A,X,Y) ; (via 796 ($31C)) close a logical file
2023-05-07 20:59:30 +00:00
romsub $FFC6 = CHKIN(ubyte logical @ X) clobbers(A,X) -> bool @Pc ; (via 798 ($31E)) define an input channel
2020-10-05 17:14:32 +00:00
romsub $FFC9 = CHKOUT(ubyte logical @ X) clobbers(A,X) ; (via 800 ($320)) define an output channel
romsub $FFCC = CLRCHN() clobbers(A,X) ; (via 802 ($322)) restore default devices
romsub $FFCF = CHRIN() clobbers(X, Y) -> ubyte @ A ; (via 804 ($324)) input a character (for keyboard, read a whole line from the screen) A=byte read.
2023-08-28 15:35:53 +00:00
romsub $FFD2 = CHROUT(ubyte character @ A) ; (via 806 ($326)) output a character
2023-05-07 20:59:30 +00:00
romsub $FFD5 = LOAD(ubyte verify @ A, uword address @ XY) -> bool @Pc, ubyte @ A, uword @ XY ; (via 816 ($330)) load from device
2023-05-19 20:06:49 +00:00
romsub $FFD8 = SAVE(ubyte zp_startaddr @ A, uword endaddr @ XY) clobbers (X, Y) -> bool @ Pc, ubyte @ A ; (via 818 ($332)) save to a device
2020-08-25 23:56:26 +00:00
romsub $FFDB = SETTIM(ubyte low @ A, ubyte middle @ X, ubyte high @ Y) ; set the software clock
2021-04-01 16:31:33 +00:00
romsub $FFDE = RDTIM() -> ubyte @ A, ubyte @ X, ubyte @ Y ; read the software clock (A=lo,X=mid,Y=high)
2023-05-07 20:59:30 +00:00
romsub $FFE1 = STOP() clobbers(X) -> bool @ Pz, ubyte @ A ; (via 808 ($328)) check the STOP key (and some others in A)
romsub $FFE4 = GETIN() clobbers(X,Y) -> bool @Pc, ubyte @ A ; (via 810 ($32A)) get a character
2020-10-05 17:14:32 +00:00
romsub $FFE7 = CLALL() clobbers(A,X) ; (via 812 ($32C)) close all files
romsub $FFEA = UDTIM() clobbers(A,X) ; update the software clock
2020-08-25 23:56:26 +00:00
romsub $FFED = SCREEN() -> ubyte @ X, ubyte @ Y ; read number of screen rows and columns
2023-05-07 20:59:30 +00:00
romsub $FFF0 = PLOT(ubyte col @ Y, ubyte row @ X, bool dir @ Pc) -> ubyte @ X, ubyte @ Y ; read/set position of cursor on screen. Use txt.plot for a 'safe' wrapper that preserves X.
2020-08-25 23:56:26 +00:00
romsub $FFF3 = IOBASE() -> uword @ XY ; read base address of I/O devices
2020-12-22 02:35:00 +00:00
; ---- utility
2023-07-15 13:18:26 +00:00
asmsub STOP2() clobbers(X) -> ubyte @A {
2020-12-22 02:35:00 +00:00
; -- check if STOP key was pressed, returns true if so. More convenient to use than STOP() because that only sets the carry status flag.
%asm {{
2023-04-28 21:13:03 +00:00
jsr cbm.STOP
2020-12-22 02:35:00 +00:00
beq +
lda #0
rts
2023-07-15 13:18:26 +00:00
+ lda #1
2020-12-22 02:35:00 +00:00
rts
}}
}
2023-07-15 13:18:26 +00:00
asmsub RDTIM16() clobbers(X) -> uword @AY {
2023-05-21 14:08:42 +00:00
; -- like RDTIM() but only returning the lower 16 bits in AY for convenience. Also avoids ram bank issue for irqs.
2021-01-02 19:59:48 +00:00
%asm {{
2023-05-22 18:36:33 +00:00
php
2023-05-21 13:03:33 +00:00
sei
2023-04-28 21:13:03 +00:00
jsr cbm.RDTIM
2023-05-22 18:36:33 +00:00
plp
2023-05-21 13:03:33 +00:00
cli
2021-01-02 19:59:48 +00:00
pha
txa
tay
pla
2021-01-05 00:48:23 +00:00
rts
}}
}
2020-08-26 17:34:12 +00:00
}
cx16 {
2023-06-29 22:29:50 +00:00
%option no_symbol_prefixing
2022-04-01 19:41:38 +00:00
; irq, system and hardware vectors:
2023-04-28 21:13:03 +00:00
&uword IERROR = $0300
&uword IMAIN = $0302
&uword ICRNCH = $0304
&uword IQPLOP = $0306
&uword IGONE = $0308
&uword IEVAL = $030a
&ubyte SAREG = $030c ; register storage for A for SYS calls
&ubyte SXREG = $030d ; register storage for X for SYS calls
&ubyte SYREG = $030e ; register storage for Y for SYS calls
&ubyte SPREG = $030f ; register storage for P (status register) for SYS calls
&uword USRADD = $0311 ; vector for the USR() basic command
2022-12-05 20:14:45 +00:00
; $0313 is unused.
2023-04-28 21:13:03 +00:00
&uword CINV = $0314 ; IRQ vector (in ram)
&uword CBINV = $0316 ; BRK vector (in ram)
&uword NMINV = $0318 ; NMI vector (in ram)
&uword IOPEN = $031a
&uword ICLOSE = $031c
&uword ICHKIN = $031e
&uword ICKOUT = $0320
&uword ICLRCH = $0322
&uword IBASIN = $0324
&uword IBSOUT = $0326
&uword ISTOP = $0328
&uword IGETIN = $032a
&uword ICLALL = $032c
&uword KEYHDL = $032e ; keyboard scan code handler see examples/cx16/keyboardhandler.p8
&uword ILOAD = $0330
&uword ISAVE = $0332
&uword NMI_VEC = $FFFA ; 65c02 nmi vector, determined by the kernal if banked in
&uword RESET_VEC = $FFFC ; 65c02 reset vector, determined by the kernal if banked in
&uword IRQ_VEC = $FFFE ; 65c02 interrupt vector, determined by the kernal if banked in
2020-09-06 15:58:05 +00:00
2021-11-13 01:42:21 +00:00
; the sixteen virtual 16-bit registers in both normal unsigned mode and signed mode (s)
2020-09-19 23:14:53 +00:00
&uword r0 = $0002
&uword r1 = $0004
&uword r2 = $0006
&uword r3 = $0008
&uword r4 = $000a
&uword r5 = $000c
&uword r6 = $000e
&uword r7 = $0010
&uword r8 = $0012
&uword r9 = $0014
&uword r10 = $0016
&uword r11 = $0018
&uword r12 = $001a
&uword r13 = $001c
&uword r14 = $001e
&uword r15 = $0020
2020-08-26 17:34:12 +00:00
2021-11-13 01:42:21 +00:00
&word r0s = $0002
&word r1s = $0004
&word r2s = $0006
&word r3s = $0008
&word r4s = $000a
&word r5s = $000c
&word r6s = $000e
&word r7s = $0010
&word r8s = $0012
&word r9s = $0014
&word r10s = $0016
&word r11s = $0018
&word r12s = $001a
&word r13s = $001c
&word r14s = $001e
&word r15s = $0020
2021-04-18 11:53:02 +00:00
&ubyte r0L = $0002
&ubyte r1L = $0004
&ubyte r2L = $0006
&ubyte r3L = $0008
&ubyte r4L = $000a
&ubyte r5L = $000c
&ubyte r6L = $000e
&ubyte r7L = $0010
&ubyte r8L = $0012
&ubyte r9L = $0014
&ubyte r10L = $0016
&ubyte r11L = $0018
&ubyte r12L = $001a
&ubyte r13L = $001c
&ubyte r14L = $001e
&ubyte r15L = $0020
&ubyte r0H = $0003
&ubyte r1H = $0005
&ubyte r2H = $0007
&ubyte r3H = $0009
&ubyte r4H = $000b
&ubyte r5H = $000d
&ubyte r6H = $000f
&ubyte r7H = $0011
&ubyte r8H = $0013
&ubyte r9H = $0015
&ubyte r10H = $0017
&ubyte r11H = $0019
&ubyte r12H = $001b
&ubyte r13H = $001d
&ubyte r14H = $001f
&ubyte r15H = $0021
2021-11-13 01:42:21 +00:00
&byte r0sL = $0002
&byte r1sL = $0004
&byte r2sL = $0006
&byte r3sL = $0008
&byte r4sL = $000a
&byte r5sL = $000c
&byte r6sL = $000e
&byte r7sL = $0010
&byte r8sL = $0012
&byte r9sL = $0014
&byte r10sL = $0016
&byte r11sL = $0018
&byte r12sL = $001a
&byte r13sL = $001c
&byte r14sL = $001e
&byte r15sL = $0020
&byte r0sH = $0003
&byte r1sH = $0005
&byte r2sH = $0007
&byte r3sH = $0009
&byte r4sH = $000b
&byte r5sH = $000d
&byte r6sH = $000f
&byte r7sH = $0011
&byte r8sH = $0013
&byte r9sH = $0015
&byte r10sH = $0017
&byte r11sH = $0019
&byte r12sH = $001b
&byte r13sH = $001d
&byte r14sH = $001f
&byte r15sH = $0021
2021-04-18 11:53:02 +00:00
2020-08-31 16:23:52 +00:00
; VERA registers
2021-01-17 17:28:43 +00:00
const uword VERA_BASE = $9F20
&ubyte VERA_ADDR_L = VERA_BASE + $0000
&ubyte VERA_ADDR_M = VERA_BASE + $0001
&ubyte VERA_ADDR_H = VERA_BASE + $0002
&ubyte VERA_DATA0 = VERA_BASE + $0003
&ubyte VERA_DATA1 = VERA_BASE + $0004
&ubyte VERA_CTRL = VERA_BASE + $0005
&ubyte VERA_IEN = VERA_BASE + $0006
&ubyte VERA_ISR = VERA_BASE + $0007
&ubyte VERA_IRQ_LINE_L = VERA_BASE + $0008
2023-03-23 17:29:28 +00:00
&ubyte VERA_DC_VIDEO = VERA_BASE + $0009 ; DCSEL= 0
&ubyte VERA_DC_HSCALE = VERA_BASE + $000A ; DCSEL= 0
&ubyte VERA_DC_VSCALE = VERA_BASE + $000B ; DCSEL= 0
&ubyte VERA_DC_BORDER = VERA_BASE + $000C ; DCSEL= 0
&ubyte VERA_DC_HSTART = VERA_BASE + $0009 ; DCSEL= 1
&ubyte VERA_DC_HSTOP = VERA_BASE + $000A ; DCSEL= 1
&ubyte VERA_DC_VSTART = VERA_BASE + $000B ; DCSEL= 1
&ubyte VERA_DC_VSTOP = VERA_BASE + $000C ; DCSEL= 1
&ubyte VERA_DC_VER0 = VERA_BASE + $0009 ; DCSEL=63
&ubyte VERA_DC_VER1 = VERA_BASE + $000A ; DCSEL=63
&ubyte VERA_DC_VER2 = VERA_BASE + $000B ; DCSEL=63
&ubyte VERA_DC_VER3 = VERA_BASE + $000C ; DCSEL=63
2021-01-17 17:28:43 +00:00
&ubyte VERA_L0_CONFIG = VERA_BASE + $000D
&ubyte VERA_L0_MAPBASE = VERA_BASE + $000E
&ubyte VERA_L0_TILEBASE = VERA_BASE + $000F
&ubyte VERA_L0_HSCROLL_L = VERA_BASE + $0010
&ubyte VERA_L0_HSCROLL_H = VERA_BASE + $0011
&ubyte VERA_L0_VSCROLL_L = VERA_BASE + $0012
&ubyte VERA_L0_VSCROLL_H = VERA_BASE + $0013
&ubyte VERA_L1_CONFIG = VERA_BASE + $0014
&ubyte VERA_L1_MAPBASE = VERA_BASE + $0015
&ubyte VERA_L1_TILEBASE = VERA_BASE + $0016
&ubyte VERA_L1_HSCROLL_L = VERA_BASE + $0017
&ubyte VERA_L1_HSCROLL_H = VERA_BASE + $0018
&ubyte VERA_L1_VSCROLL_L = VERA_BASE + $0019
&ubyte VERA_L1_VSCROLL_H = VERA_BASE + $001A
&ubyte VERA_AUDIO_CTRL = VERA_BASE + $001B
&ubyte VERA_AUDIO_RATE = VERA_BASE + $001C
&ubyte VERA_AUDIO_DATA = VERA_BASE + $001D
&ubyte VERA_SPI_DATA = VERA_BASE + $001E
&ubyte VERA_SPI_CTRL = VERA_BASE + $001F
2023-09-24 21:00:40 +00:00
; experimental Vera FX registers: (depends on particular value set in VERA_CTRL!!!)
&ubyte VERA_FX_CTRL = VERA_BASE + $0009
&ubyte VERA_FX_MULT = VERA_BASE + $000C
&ubyte VERA_FX_CACHE_L = VERA_BASE + $0009
&ubyte VERA_FX_CACHE_M = VERA_BASE + $000A
&ubyte VERA_FX_CACHE_H = VERA_BASE + $000B
&ubyte VERA_FX_CACHE_U = VERA_BASE + $000C
&ubyte VERA_FX_ACCUM_RESET = VERA_BASE + $0009 ; (DCSEL=6)
2020-08-31 16:23:52 +00:00
; VERA_PSG_BASE = $1F9C0
; VERA_PALETTE_BASE = $1FA00
; VERA_SPRITES_BASE = $1FC00
2020-09-07 01:09:09 +00:00
; I/O
2023-03-17 21:28:09 +00:00
const uword VIA1_BASE = $9f00 ;VIA 6522 #1
2023-04-28 21:13:03 +00:00
&ubyte via1prb = VIA1_BASE + 0
&ubyte via1pra = VIA1_BASE + 1
&ubyte via1ddrb = VIA1_BASE + 2
&ubyte via1ddra = VIA1_BASE + 3
&ubyte via1t1l = VIA1_BASE + 4
&ubyte via1t1h = VIA1_BASE + 5
&ubyte via1t1ll = VIA1_BASE + 6
&ubyte via1t1lh = VIA1_BASE + 7
&ubyte via1t2l = VIA1_BASE + 8
&ubyte via1t2h = VIA1_BASE + 9
&ubyte via1sr = VIA1_BASE + 10
&ubyte via1acr = VIA1_BASE + 11
&ubyte via1pcr = VIA1_BASE + 12
&ubyte via1ifr = VIA1_BASE + 13
&ubyte via1ier = VIA1_BASE + 14
&ubyte via1ora = VIA1_BASE + 15
2020-09-07 01:09:09 +00:00
2023-03-17 21:28:09 +00:00
const uword VIA2_BASE = $9f10 ;VIA 6522 #2
2023-04-28 21:13:03 +00:00
&ubyte via2prb = VIA2_BASE + 0
&ubyte via2pra = VIA2_BASE + 1
&ubyte via2ddrb = VIA2_BASE + 2
&ubyte via2ddra = VIA2_BASE + 3
&ubyte via2t1l = VIA2_BASE + 4
&ubyte via2t1h = VIA2_BASE + 5
&ubyte via2t1ll = VIA2_BASE + 6
&ubyte via2t1lh = VIA2_BASE + 7
&ubyte via2t2l = VIA2_BASE + 8
&ubyte via2t2h = VIA2_BASE + 9
&ubyte via2sr = VIA2_BASE + 10
&ubyte via2acr = VIA2_BASE + 11
&ubyte via2pcr = VIA2_BASE + 12
&ubyte via2ifr = VIA2_BASE + 13
&ubyte via2ier = VIA2_BASE + 14
&ubyte via2ora = VIA2_BASE + 15
2020-09-07 01:09:09 +00:00
2022-11-10 21:45:07 +00:00
; YM-2151 sound chip
&ubyte YM_ADDRESS = $9f40
2023-04-28 21:13:03 +00:00
&ubyte YM_DATA = $9f41
2021-03-27 21:20:46 +00:00
const uword extdev = $9f60
2020-09-07 01:09:09 +00:00
; ---- Commander X-16 additions on top of C64 kernal routines ----
; spelling of the names is taken from the Commander X-16 rom sources
2020-08-26 17:34:12 +00:00
; supported C128 additions
2023-10-09 20:10:36 +00:00
romsub $ff4a = CLOSE_ALL(ubyte device @A) clobbers(A,X,Y)
romsub $ff59 = LKUPLA(ubyte la @A) clobbers(A,X,Y)
romsub $ff5c = LKUPSA(ubyte sa @Y) clobbers(A,X,Y)
2023-07-08 09:37:29 +00:00
romsub $ff5f = screen_mode(ubyte mode @A, bool getCurrent @Pc) clobbers(X, Y) -> ubyte @A, bool @Pc ; note: X,Y size result is not supported, use SCREEN or get_screen_mode routine for that
2020-09-14 22:14:36 +00:00
romsub $ff62 = screen_set_charset(ubyte charset @A, uword charsetptr @XY) clobbers(A,X,Y) ; incompatible with C128 dlchr()
2020-10-02 21:31:49 +00:00
; not yet supported: romsub $ff65 = pfkey() clobbers(A,X,Y)
2023-10-09 20:10:36 +00:00
romsub $ff6e = JSRFAR() ; following word = address to call, byte after that=rom/ram bank it is in
2020-10-02 21:31:49 +00:00
romsub $ff74 = fetch(ubyte bank @X, ubyte index @Y) clobbers(X) -> ubyte @A
romsub $ff77 = stash(ubyte data @A, ubyte bank @X, ubyte index @Y) clobbers(X)
2023-10-09 20:10:36 +00:00
romsub $ff7d = PRIMM()
2020-08-26 17:34:12 +00:00
2021-12-09 20:13:13 +00:00
; It's not documented what registers are clobbered, so we assume the worst for all following kernal routines...:
2020-08-26 17:34:12 +00:00
; high level graphics & fonts
2020-12-21 19:38:00 +00:00
romsub $ff20 = GRAPH_init(uword vectors @R0) clobbers(A,X,Y)
2020-09-07 02:06:46 +00:00
romsub $ff23 = GRAPH_clear() clobbers(A,X,Y)
2020-12-21 19:38:00 +00:00
romsub $ff26 = GRAPH_set_window(uword x @R0, uword y @R1, uword width @R2, uword height @R3) clobbers(A,X,Y)
2020-09-14 22:14:36 +00:00
romsub $ff29 = GRAPH_set_colors(ubyte stroke @A, ubyte fill @X, ubyte background @Y) clobbers (A,X,Y)
2020-12-21 19:38:00 +00:00
romsub $ff2c = GRAPH_draw_line(uword x1 @R0, uword y1 @R1, uword x2 @R2, uword y2 @R3) clobbers(A,X,Y)
2023-05-07 20:59:30 +00:00
romsub $ff2f = GRAPH_draw_rect(uword x @R0, uword y @R1, uword width @R2, uword height @R3, uword cornerradius @R4, bool fill @Pc) clobbers(A,X,Y)
2020-12-21 19:38:00 +00:00
romsub $ff32 = GRAPH_move_rect(uword sx @R0, uword sy @R1, uword tx @R2, uword ty @R3, uword width @R4, uword height @R5) clobbers(A,X,Y)
2023-05-07 20:59:30 +00:00
romsub $ff35 = GRAPH_draw_oval(uword x @R0, uword y @R1, uword width @R2, uword height @R3, bool fill @Pc) clobbers(A,X,Y)
2020-12-21 19:38:00 +00:00
romsub $ff38 = GRAPH_draw_image(uword x @R0, uword y @R1, uword ptr @R2, uword width @R3, uword height @R4) clobbers(A,X,Y)
romsub $ff3b = GRAPH_set_font(uword fontptr @R0) clobbers(A,X,Y)
2023-05-07 20:59:30 +00:00
romsub $ff3e = GRAPH_get_char_size(ubyte baseline @A, ubyte width @X, ubyte height_or_style @Y, bool is_control @Pc) clobbers(A,X,Y)
2023-08-28 15:35:53 +00:00
romsub $ff41 = GRAPH_put_char(uword x @R0, uword y @R1, ubyte character @A) clobbers(A,X,Y)
romsub $ff41 = GRAPH_put_next_char(ubyte character @A) clobbers(A,X,Y) ; alias for the routine above that doesn't reset the position of the initial character
2020-08-28 19:42:53 +00:00
; framebuffer
2020-09-14 22:14:36 +00:00
romsub $fef6 = FB_init() clobbers(A,X,Y)
2020-12-21 19:38:00 +00:00
romsub $fef9 = FB_get_info() clobbers(X,Y) -> byte @A, uword @R0, uword @R1 ; width=r0, height=r1
2023-03-24 00:56:29 +00:00
romsub $fefc = FB_set_palette(uword pointer @R0, ubyte index @A, ubyte colorcount @X) clobbers(A,X,Y)
2020-12-21 19:38:00 +00:00
romsub $feff = FB_cursor_position(uword x @R0, uword y @R1) clobbers(A,X,Y)
2020-12-21 20:04:29 +00:00
romsub $feff = FB_cursor_position2() clobbers(A,X,Y) ; alias for the previous routine, but avoiding having to respecify both x and y every time
2020-12-21 19:38:00 +00:00
romsub $ff02 = FB_cursor_next_line(uword x @R0) clobbers(A,X,Y)
2020-09-14 22:14:36 +00:00
romsub $ff05 = FB_get_pixel() clobbers(X,Y) -> ubyte @A
2020-12-21 19:38:00 +00:00
romsub $ff08 = FB_get_pixels(uword pointer @R0, uword count @R1) clobbers(A,X,Y)
2020-09-14 22:14:36 +00:00
romsub $ff0b = FB_set_pixel(ubyte color @A) clobbers(A,X,Y)
2020-12-21 19:38:00 +00:00
romsub $ff0e = FB_set_pixels(uword pointer @R0, uword count @R1) clobbers(A,X,Y)
2020-09-14 22:14:36 +00:00
romsub $ff11 = FB_set_8_pixels(ubyte pattern @A, ubyte color @X) clobbers(A,X,Y)
2020-12-21 23:59:07 +00:00
romsub $ff14 = FB_set_8_pixels_opaque(ubyte pattern @R0, ubyte mask @A, ubyte color1 @X, ubyte color2 @Y) clobbers(A,X,Y)
romsub $ff17 = FB_fill_pixels(uword count @R0, uword pstep @R1, ubyte color @A) clobbers(A,X,Y)
2020-12-21 19:38:00 +00:00
romsub $ff1a = FB_filter_pixels(uword pointer @ R0, uword count @R1) clobbers(A,X,Y)
romsub $ff1d = FB_move_pixels(uword sx @R0, uword sy @R1, uword tx @R2, uword ty @R3, uword count @R4) clobbers(A,X,Y)
2020-08-28 19:42:53 +00:00
; misc
2023-05-19 20:06:49 +00:00
romsub $FEBA = BSAVE(ubyte zp_startaddr @ A, uword endaddr @ XY) clobbers (X, Y) -> bool @ Pc, ubyte @ A ; like cbm.SAVE, but omits the 2-byte prg header
2023-05-07 20:59:30 +00:00
romsub $fec6 = i2c_read_byte(ubyte device @X, ubyte offset @Y) clobbers (X,Y) -> ubyte @A, bool @Pc
romsub $fec9 = i2c_write_byte(ubyte device @X, ubyte offset @Y, ubyte data @A) clobbers (A,X,Y) -> bool @Pc
romsub $fef0 = sprite_set_image(uword pixels @R0, uword mask @R1, ubyte bpp @R2, ubyte number @A, ubyte width @X, ubyte height @Y, bool apply_mask @Pc) clobbers(A,X,Y) -> bool @Pc
2020-12-21 23:59:07 +00:00
romsub $fef3 = sprite_set_position(uword x @R0, uword y @R1, ubyte number @A) clobbers(A,X,Y)
2020-12-21 19:38:00 +00:00
romsub $fee4 = memory_fill(uword address @R0, uword num_bytes @R1, ubyte value @A) clobbers(A,X,Y)
romsub $fee7 = memory_copy(uword source @R0, uword target @R1, uword num_bytes @R2) clobbers(A,X,Y)
romsub $feea = memory_crc(uword address @R0, uword num_bytes @R1) clobbers(A,X,Y) -> uword @R2
romsub $feed = memory_decompress(uword input @R0, uword output @R1) clobbers(A,X,Y) -> uword @R1 ; last address +1 is result in R1
romsub $fedb = console_init(uword x @R0, uword y @R1, uword width @R2, uword height @R3) clobbers(A,X,Y)
2023-08-28 15:35:53 +00:00
romsub $fede = console_put_char(ubyte character @A, bool wrapping @Pc) clobbers(A,X,Y)
2020-09-14 22:14:36 +00:00
romsub $fee1 = console_get_char() clobbers(X,Y) -> ubyte @A
2020-12-21 19:38:00 +00:00
romsub $fed8 = console_put_image(uword pointer @R0, uword width @R1, uword height @R2) clobbers(A,X,Y)
romsub $fed5 = console_set_paging_message(uword msgptr @R0) clobbers(A,X,Y)
2020-08-28 19:42:53 +00:00
romsub $fecf = entropy_get() -> ubyte @A, ubyte @X, ubyte @Y
2020-09-14 22:14:36 +00:00
romsub $fecc = monitor() clobbers(A,X,Y)
2020-08-26 17:34:12 +00:00
2023-10-09 20:10:36 +00:00
romsub $ff44 = MACPTR(ubyte length @A, uword buffer @XY, bool dontAdvance @Pc) clobbers(A) -> bool @Pc, uword @XY
romsub $feb1 = MCIOUT(ubyte length @A, uword buffer @XY, bool dontAdvance @Pc) clobbers(A) -> bool @Pc, uword @XY
2023-05-07 20:59:30 +00:00
romsub $ff47 = enter_basic(bool cold_or_warm @Pc) clobbers(A,X,Y)
2022-04-01 19:41:38 +00:00
romsub $ff4d = clock_set_date_time(uword yearmonth @R0, uword dayhours @R1, uword minsecs @R2, ubyte jiffies @R3) clobbers(A, X, Y)
romsub $ff50 = clock_get_date_time() clobbers(A, X, Y) -> uword @R0, uword @R1, uword @R2, ubyte @R3 ; result registers see clock_set_date_time()
; keyboard, mouse, joystick
2022-09-01 16:34:06 +00:00
; note: also see the kbdbuf_clear() helper routine below!
2022-04-01 21:47:09 +00:00
romsub $febd = kbdbuf_peek() -> ubyte @A, ubyte @X ; key in A, queue length in X
romsub $febd = kbdbuf_peek2() -> uword @AX ; alternative to above to not have the hassle to deal with multiple return values
2022-04-01 19:41:38 +00:00
romsub $fec0 = kbdbuf_get_modifiers() -> ubyte @A
romsub $fec3 = kbdbuf_put(ubyte key @A) clobbers(X)
2023-09-06 19:18:01 +00:00
romsub $fed2 = keymap(uword identifier @XY, bool read @Pc) -> bool @Pc
2022-04-01 19:41:38 +00:00
romsub $ff68 = mouse_config(ubyte shape @A, ubyte resX @X, ubyte resY @Y) clobbers (A, X, Y)
romsub $ff6b = mouse_get(ubyte zpdataptr @X) -> ubyte @A
romsub $ff71 = mouse_scan() clobbers(A, X, Y)
romsub $ff53 = joystick_scan() clobbers(A, X, Y)
romsub $ff56 = joystick_get(ubyte joynr @A) -> ubyte @A, ubyte @X, ubyte @Y
romsub $ff56 = joystick_get2(ubyte joynr @A) clobbers(Y) -> uword @AX ; alternative to above to not have the hassle to deal with multiple return values
2023-06-23 21:36:59 +00:00
; Audio (rom bank 10)
2023-09-06 19:18:01 +00:00
romsub $C04B = psg_init() clobbers(A,X,Y) ; (re)init Vera PSG
2023-05-07 20:59:30 +00:00
romsub $C063 = ym_init() clobbers(A,X,Y) -> bool @Pc ; (re)init YM chip
romsub $C066 = ym_loaddefpatches() clobbers(A,X,Y) -> bool @Pc ; load default YM patches
2023-09-06 19:18:01 +00:00
romsub $C09F = audio_init() clobbers(A,X,Y) -> bool @Pc ; (re)initialize both vera PSG and YM audio chips
2023-04-06 19:19:21 +00:00
; TODO: add more of the audio routines?
2023-03-19 19:58:02 +00:00
2023-07-08 09:37:29 +00:00
asmsub set_screen_mode(ubyte mode @A) clobbers(A,X,Y) -> bool @Pc {
; -- convenience wrapper for screen_mode() to just set a new mode (and return success)
%asm {{
clc
jmp screen_mode
}}
}
asmsub get_screen_mode() -> byte @A, byte @X, byte @Y {
2023-07-08 09:42:29 +00:00
; -- convenience wrapper for screen_mode() to just get the current mode in A, and size in characters in X+Y
2023-07-08 09:37:29 +00:00
; this does need a piece of inlined asm to call it ans store the result values if you call this from prog8 code
2023-07-08 09:42:29 +00:00
; Note: you can also just do the SEC yourself and simply call screen_mode() directly,
; or use the existing SCREEN kernal routine for just getting the size in characters.
2023-07-08 09:37:29 +00:00
%asm {{
sec
jmp screen_mode
}}
}
2022-09-01 16:34:06 +00:00
asmsub kbdbuf_clear() {
; -- convenience helper routine to clear the keyboard buffer
%asm {{
2023-04-28 21:13:03 +00:00
- jsr cbm.GETIN
2022-09-01 16:34:06 +00:00
bne -
rts
}}
}
2022-04-01 19:41:38 +00:00
asmsub mouse_config2(ubyte shape @A) clobbers (A, X, Y) {
; -- convenience wrapper function that handles the screen resolution for mouse_config() for you
%asm {{
2022-10-29 21:10:06 +00:00
pha ; save shape
2022-04-01 19:41:38 +00:00
sec
jsr cx16.screen_mode ; set current screen mode and res in A, X, Y
2022-10-29 21:10:06 +00:00
pla ; get shape back
2022-04-01 19:41:38 +00:00
jmp cx16.mouse_config
}}
}
2023-07-15 13:18:26 +00:00
asmsub mouse_pos() clobbers(X) -> ubyte @A {
2022-04-01 19:41:38 +00:00
; -- short wrapper around mouse_get() kernal routine:
; -- gets the position of the mouse cursor in cx16.r0 and cx16.r1 (x/y coordinate), returns mouse button status.
%asm {{
ldx #cx16.r0
2023-07-15 13:18:26 +00:00
jmp cx16.mouse_get
2022-04-01 19:41:38 +00:00
}}
}
2020-08-25 23:56:26 +00:00
; ---- end of kernal routines ----
2021-01-03 01:36:45 +00:00
2020-12-03 17:14:49 +00:00
; ---- utilities -----
2021-01-17 18:16:21 +00:00
2021-11-21 21:12:35 +00:00
inline asmsub rombank(ubyte bank @A) {
2021-01-17 18:16:21 +00:00
; -- set the rom banks
%asm {{
2022-06-10 20:19:54 +00:00
sta $01
2021-01-17 18:16:21 +00:00
}}
}
2021-11-21 21:12:35 +00:00
inline asmsub rambank(ubyte bank @A) {
2021-01-17 18:16:21 +00:00
; -- set the ram bank
%asm {{
2022-06-10 20:19:54 +00:00
sta $00
2021-01-17 18:16:21 +00:00
}}
}
2021-12-04 14:27:54 +00:00
inline asmsub getrombank() -> ubyte @A {
; -- get the current rom bank
%asm {{
2022-06-10 20:19:54 +00:00
lda $01
2021-12-04 14:27:54 +00:00
}}
}
inline asmsub getrambank() -> ubyte @A {
2023-02-13 22:45:01 +00:00
; -- get the current RAM bank
2021-12-04 14:27:54 +00:00
%asm {{
2022-06-10 20:19:54 +00:00
lda $00
2021-12-04 14:27:54 +00:00
}}
}
2023-07-15 13:18:26 +00:00
asmsub numbanks() clobbers(X) -> uword @AY {
2023-02-13 22:45:01 +00:00
; -- Returns the number of available RAM banks according to the kernal (each bank is 8 Kb).
; Note that the number of such banks can be 256 so a word is returned.
; But just looking at the A register (the LSB of the result word) could suffice if you know that A=0 means 256 banks:
; The maximum number of RAM banks in the X16 is currently 256 (2 Megabytes of banked RAM).
; Kernal's MEMTOP routine reports 0 in this case but that doesn't mean 'zero banks', instead it means 256 banks,
; as there is no X16 without at least 1 page of banked RAM. So this routine returns 256 instead of 0.
2021-04-07 23:03:31 +00:00
%asm {{
sec
2023-04-28 21:13:03 +00:00
jsr cbm.MEMTOP
2023-02-07 23:51:34 +00:00
ldy #0
cmp #0
bne +
iny
2023-07-15 13:18:26 +00:00
+ rts
2021-04-07 23:03:31 +00:00
}}
}
2020-12-12 02:32:15 +00:00
asmsub vpeek(ubyte bank @A, uword address @XY) -> ubyte @A {
2020-12-03 17:14:49 +00:00
; -- get a byte from VERA's video memory
; note: inefficient when reading multiple sequential bytes!
%asm {{
2020-12-26 00:25:52 +00:00
pha
2023-08-31 21:24:46 +00:00
lda cx16.VERA_CTRL
ora #1
2020-12-26 00:25:52 +00:00
sta cx16.VERA_CTRL
pla
2020-12-03 17:14:49 +00:00
and #1
sta cx16.VERA_ADDR_H
sty cx16.VERA_ADDR_M
stx cx16.VERA_ADDR_L
2020-12-26 00:25:52 +00:00
lda cx16.VERA_DATA1
2020-12-03 17:14:49 +00:00
rts
}}
2020-12-12 02:32:15 +00:00
}
2020-12-03 17:14:49 +00:00
2020-12-30 15:59:31 +00:00
asmsub vaddr(ubyte bank @A, uword address @R0, ubyte addrsel @R1, byte autoIncrOrDecrByOne @Y) clobbers(A) {
2020-12-26 00:25:52 +00:00
; -- setup the VERA's data address register 0 or 1
2023-07-21 20:40:07 +00:00
; with optional auto increment or decrement of 1.
; Note that the vaddr_autoincr() and vaddr_autodecr() routines allow to set all possible strides, not just 1.
2020-12-23 04:04:19 +00:00
%asm {{
2020-12-25 14:43:48 +00:00
and #1
pha
lda cx16.r1
2020-12-23 04:04:19 +00:00
and #1
sta cx16.VERA_CTRL
2020-12-24 06:12:59 +00:00
lda cx16.r0
2020-12-23 04:04:19 +00:00
sta cx16.VERA_ADDR_L
2020-12-24 06:12:59 +00:00
lda cx16.r0+1
2020-12-23 04:04:19 +00:00
sta cx16.VERA_ADDR_M
2020-12-25 14:43:48 +00:00
pla
2020-12-24 06:12:59 +00:00
cpy #0
2020-12-25 14:43:48 +00:00
bmi ++
beq +
2020-12-23 04:04:19 +00:00
ora #%00010000
2020-12-25 14:43:48 +00:00
+ sta cx16.VERA_ADDR_H
rts
+ ora #%00011000
sta cx16.VERA_ADDR_H
2020-12-23 04:04:19 +00:00
rts
}}
}
2023-07-23 21:29:09 +00:00
asmsub vaddr_clone(ubyte port @A) clobbers (A,X,Y) {
; -- clones Vera addresses from the given source port to the other one.
; leaves CTRL on the destination port.
%asm {{
sta VERA_CTRL
ldx VERA_ADDR_L
ldy VERA_ADDR_H
phy
ldy VERA_ADDR_M
eor #1
sta VERA_CTRL
stx VERA_ADDR_L
sty VERA_ADDR_M
ply
sty VERA_ADDR_H
rts
}}
}
2023-07-21 20:40:07 +00:00
asmsub vaddr_autoincr(ubyte bank @A, uword address @R0, ubyte addrsel @R1, uword autoIncrAmount @R2) clobbers(A,Y) {
; -- setup the VERA's data address register 0 or 1
; including setting up optional auto increment amount.
2023-07-21 21:04:21 +00:00
; Specifiying an unsupported amount results in amount of zero. See the Vera docs about what amounts are possible.
2023-07-21 20:40:07 +00:00
%asm {{
jsr _setup
lda cx16.r2H
ora cx16.r2L
beq +
jsr _determine_incr_bits
+ ora P8ZP_SCRATCH_REG
sta cx16.VERA_ADDR_H
rts
_setup and #1
sta P8ZP_SCRATCH_REG
lda cx16.r1
and #1
sta cx16.VERA_CTRL
lda cx16.r0
sta cx16.VERA_ADDR_L
lda cx16.r0+1
sta cx16.VERA_ADDR_M
rts
_determine_incr_bits
lda cx16.r2H
bne _large
lda cx16.r2L
ldy #13
- cmp _strides_lsb,y
beq +
dey
bpl -
+ tya
asl a
asl a
asl a
asl a
rts
_large ora cx16.r2L
cmp #1 ; 256
bne +
lda #9<<4
rts
+ cmp #2 ; 512
bne +
lda #10<<4
rts
+ cmp #65 ; 320
bne +
lda #14<<4
rts
+ cmp #130 ; 640
bne +
lda #15<<4
rts
+ lda #0
rts
_strides_lsb .byte 0,1,2,4,8,16,32,64,128,255,255,40,80,160,255,255
}}
}
asmsub vaddr_autodecr(ubyte bank @A, uword address @R0, ubyte addrsel @R1, uword autoDecrAmount @R2) clobbers(A,Y) {
; -- setup the VERA's data address register 0 or 1
; including setting up optional auto decrement amount.
2023-07-21 21:04:21 +00:00
; Specifiying an unsupported amount results in amount of zero. See the Vera docs about what amounts are possible.
2023-07-21 20:40:07 +00:00
%asm {{
jsr vaddr_autoincr._setup
lda cx16.r2H
ora cx16.r2L
beq +
jsr vaddr_autoincr._determine_incr_bits
ora #%00001000 ; autodecrement
+ ora P8ZP_SCRATCH_REG
sta cx16.VERA_ADDR_H
rts
}}
}
2020-12-30 15:59:31 +00:00
asmsub vpoke(ubyte bank @A, uword address @R0, ubyte value @Y) clobbers(A) {
2021-03-20 01:39:53 +00:00
; -- write a single byte to VERA's video memory
; note: inefficient when writing multiple sequential bytes!
%asm {{
stz cx16.VERA_CTRL
and #1
sta cx16.VERA_ADDR_H
lda cx16.r0
sta cx16.VERA_ADDR_L
lda cx16.r0+1
sta cx16.VERA_ADDR_M
sty cx16.VERA_DATA0
rts
}}
2020-12-12 02:32:15 +00:00
}
2020-12-03 17:14:49 +00:00
2020-12-30 15:59:31 +00:00
asmsub vpoke_or(ubyte bank @A, uword address @R0, ubyte value @Y) clobbers (A) {
2021-03-20 01:39:53 +00:00
; -- or a single byte to the value already in the VERA's video memory at that location
; note: inefficient when writing multiple sequential bytes!
%asm {{
stz cx16.VERA_CTRL
and #1
sta cx16.VERA_ADDR_H
lda cx16.r0
sta cx16.VERA_ADDR_L
lda cx16.r0+1
sta cx16.VERA_ADDR_M
tya
ora cx16.VERA_DATA0
sta cx16.VERA_DATA0
rts
}}
2020-12-23 00:02:43 +00:00
}
2020-12-30 15:59:31 +00:00
asmsub vpoke_and(ubyte bank @A, uword address @R0, ubyte value @Y) clobbers(A) {
2021-03-20 01:39:53 +00:00
; -- and a single byte to the value already in the VERA's video memory at that location
; note: inefficient when writing multiple sequential bytes!
%asm {{
stz cx16.VERA_CTRL
and #1
sta cx16.VERA_ADDR_H
lda cx16.r0
sta cx16.VERA_ADDR_L
lda cx16.r0+1
sta cx16.VERA_ADDR_M
tya
and cx16.VERA_DATA0
sta cx16.VERA_DATA0
rts
}}
2020-12-23 00:02:43 +00:00
}
2020-12-30 15:59:31 +00:00
asmsub vpoke_xor(ubyte bank @A, uword address @R0, ubyte value @Y) clobbers (A) {
2021-03-20 01:39:53 +00:00
; -- xor a single byte to the value already in the VERA's video memory at that location
; note: inefficient when writing multiple sequential bytes!
%asm {{
stz cx16.VERA_CTRL
and #1
sta cx16.VERA_ADDR_H
lda cx16.r0
sta cx16.VERA_ADDR_L
lda cx16.r0+1
sta cx16.VERA_ADDR_M
tya
eor cx16.VERA_DATA0
sta cx16.VERA_DATA0
rts
}}
2020-12-23 00:02:43 +00:00
}
2023-04-26 15:22:27 +00:00
asmsub vpoke_mask(ubyte bank @A, uword address @R0, ubyte mask @X, ubyte value @Y) clobbers (A) {
; -- bitwise or a single byte to the value already in the VERA's video memory at that location
; after applying the and-mask. Note: inefficient when writing multiple sequential bytes!
%asm {{
sty P8ZP_SCRATCH_B1
stz cx16.VERA_CTRL
and #1
sta cx16.VERA_ADDR_H
lda cx16.r0
sta cx16.VERA_ADDR_L
lda cx16.r0+1
sta cx16.VERA_ADDR_M
txa
and cx16.VERA_DATA0
ora P8ZP_SCRATCH_B1
sta cx16.VERA_DATA0
rts
}}
}
2021-03-20 01:39:53 +00:00
2023-06-24 19:04:47 +00:00
asmsub save_virtual_registers() clobbers(A,Y) {
%asm {{
ldy #31
- lda cx16.r0,y
sta _cx16_vreg_storage,y
dey
bpl -
rts
_cx16_vreg_storage
.word 0,0,0,0,0,0,0,0
.word 0,0,0,0,0,0,0,0
}}
}
asmsub restore_virtual_registers() clobbers(A,Y) {
%asm {{
ldy #31
- lda save_virtual_registers._cx16_vreg_storage,y
sta cx16.r0,y
dey
bpl -
rts
}}
}
2023-04-28 21:13:03 +00:00
asmsub save_vera_context() clobbers(A) {
; -- use this at the start of your IRQ handler if it uses Vera registers, to save the state
%asm {{
; note cannot store this on cpu hardware stack because this gets called as a subroutine
lda cx16.VERA_ADDR_L
sta _vera_storage
lda cx16.VERA_ADDR_M
sta _vera_storage+1
lda cx16.VERA_ADDR_H
sta _vera_storage+2
lda cx16.VERA_CTRL
sta _vera_storage+3
eor #1
2023-05-08 21:15:30 +00:00
sta _vera_storage+7
2023-04-28 21:13:03 +00:00
sta cx16.VERA_CTRL
lda cx16.VERA_ADDR_L
sta _vera_storage+4
lda cx16.VERA_ADDR_M
sta _vera_storage+5
lda cx16.VERA_ADDR_H
sta _vera_storage+6
rts
_vera_storage: .byte 0,0,0,0,0,0,0,0
}}
}
asmsub restore_vera_context() clobbers(A) {
; -- use this at the end of your IRQ handler if it uses Vera registers, to restore the state
%asm {{
lda cx16.save_vera_context._vera_storage+7
sta cx16.VERA_CTRL
lda cx16.save_vera_context._vera_storage+6
sta cx16.VERA_ADDR_H
lda cx16.save_vera_context._vera_storage+5
sta cx16.VERA_ADDR_M
lda cx16.save_vera_context._vera_storage+4
sta cx16.VERA_ADDR_L
lda cx16.save_vera_context._vera_storage+3
sta cx16.VERA_CTRL
lda cx16.save_vera_context._vera_storage+2
sta cx16.VERA_ADDR_H
lda cx16.save_vera_context._vera_storage+1
sta cx16.VERA_ADDR_M
lda cx16.save_vera_context._vera_storage+0
sta cx16.VERA_ADDR_L
rts
}}
}
}
sys {
; ------- lowlevel system routines --------
2023-06-29 22:29:50 +00:00
%option no_symbol_prefixing
2023-04-28 21:13:03 +00:00
const ubyte target = 16 ; compilation target specifier. 64 = C64, 128 = C128, 16 = CommanderX16.
2021-02-21 22:41:50 +00:00
asmsub init_system() {
2020-08-25 23:56:26 +00:00
; Initializes the machine to a sane starting state.
; Called automatically by the loader program logic.
%asm {{
sei
2023-02-27 22:35:42 +00:00
lda #0
tax
tay
jsr cx16.mouse_config ; disable mouse
2020-08-25 23:56:26 +00:00
cld
2023-04-28 21:13:03 +00:00
lda cx16.VERA_DC_VIDEO
2022-11-20 18:19:01 +00:00
and #%00000111 ; retain chroma + output mode
sta P8ZP_SCRATCH_REG
2023-03-19 19:58:02 +00:00
lda #$0a
sta $01 ; rom bank 10 (audio)
2023-04-28 21:13:03 +00:00
jsr cx16.audio_init ; silence
2023-03-02 23:47:12 +00:00
stz $01 ; rom bank 0 (kernal)
2023-04-28 21:13:03 +00:00
jsr cbm.IOINIT
jsr cbm.RESTOR
jsr cbm.CINT
lda cx16.VERA_DC_VIDEO
2022-11-20 18:19:01 +00:00
and #%11111000
ora P8ZP_SCRATCH_REG
2023-04-28 21:13:03 +00:00
sta cx16.VERA_DC_VIDEO ; restore old output mode
2020-09-19 20:37:24 +00:00
lda #$90 ; black
2023-04-28 21:13:03 +00:00
jsr cbm.CHROUT
2023-02-21 20:53:32 +00:00
lda #1
2023-04-28 21:13:03 +00:00
jsr cbm.CHROUT ; swap fg/bg
2020-09-19 20:10:33 +00:00
lda #$9e ; yellow
2023-04-28 21:13:03 +00:00
jsr cbm.CHROUT
2020-09-19 20:37:24 +00:00
lda #147 ; clear screen
2023-04-28 21:13:03 +00:00
jsr cbm.CHROUT
2023-06-26 22:27:34 +00:00
lda #PROG8_VARSHIGH_RAMBANK
sta $00 ; select ram bank
2020-08-25 23:56:26 +00:00
lda #0
tax
tay
clc
clv
cli
rts
}}
}
2021-02-21 22:41:50 +00:00
asmsub init_system_phase2() {
%asm {{
sei
lda cx16.CINV
sta restore_irq._orig_irqvec
lda cx16.CINV+1
sta restore_irq._orig_irqvec+1
2023-06-26 22:27:34 +00:00
lda #PROG8_VARSHIGH_RAMBANK
sta $00 ; select ram bank
2021-02-21 22:41:50 +00:00
cli
rts
}}
}
2022-05-15 14:44:26 +00:00
asmsub cleanup_at_exit() {
; executed when the main subroutine does rts
%asm {{
2022-06-30 22:14:38 +00:00
lda #1
sta $00 ; ram bank 1
lda #4
2023-03-02 23:47:12 +00:00
sta $01 ; rom bank 4 (basic)
2022-06-30 22:14:38 +00:00
stz $2d ; hack to reset machine code monitor bank to 0
2022-05-15 14:44:26 +00:00
rts
}}
}
2023-05-07 20:59:30 +00:00
asmsub set_irq(uword handler @AY, bool useKernal @Pc) clobbers(A) {
2021-02-21 22:41:50 +00:00
%asm {{
sta _modified+1
sty _modified+2
lda #0
2023-05-07 19:03:14 +00:00
rol a
2021-02-21 22:41:50 +00:00
sta _use_kernal
sei
lda #<_irq_handler
sta cx16.CINV
lda #>_irq_handler
sta cx16.CINV+1
lda cx16.VERA_IEN
ora #%00000001 ; enable the vsync irq
sta cx16.VERA_IEN
cli
rts
_irq_handler jsr _irq_handler_init
_modified jsr $ffff ; modified
jsr _irq_handler_end
lda _use_kernal
bne +
; end irq processing - don't use kernal's irq handling
2023-03-03 20:54:02 +00:00
lda #1
2021-02-21 22:41:50 +00:00
sta cx16.VERA_ISR ; clear Vera Vsync irq status
ply
plx
pla
rti
+ jmp (restore_irq._orig_irqvec) ; continue with normal kernal irq routine
_use_kernal .byte 0
_irq_handler_init
2023-03-10 22:29:34 +00:00
; save all zp scratch registers as these might be clobbered by the irq routine
2021-02-21 22:41:50 +00:00
lda P8ZP_SCRATCH_B1
sta IRQ_SCRATCH_ZPB1
lda P8ZP_SCRATCH_REG
sta IRQ_SCRATCH_ZPREG
lda P8ZP_SCRATCH_W1
sta IRQ_SCRATCH_ZPWORD1
lda P8ZP_SCRATCH_W1+1
sta IRQ_SCRATCH_ZPWORD1+1
lda P8ZP_SCRATCH_W2
sta IRQ_SCRATCH_ZPWORD2
lda P8ZP_SCRATCH_W2+1
sta IRQ_SCRATCH_ZPWORD2+1
cld
rts
_irq_handler_end
2023-03-10 22:29:34 +00:00
; restore all zp scratch registers
2021-02-21 22:41:50 +00:00
lda IRQ_SCRATCH_ZPB1
sta P8ZP_SCRATCH_B1
lda IRQ_SCRATCH_ZPREG
sta P8ZP_SCRATCH_REG
lda IRQ_SCRATCH_ZPWORD1
sta P8ZP_SCRATCH_W1
lda IRQ_SCRATCH_ZPWORD1+1
sta P8ZP_SCRATCH_W1+1
lda IRQ_SCRATCH_ZPWORD2
sta P8ZP_SCRATCH_W2
lda IRQ_SCRATCH_ZPWORD2+1
sta P8ZP_SCRATCH_W2+1
rts
IRQ_SCRATCH_ZPB1 .byte 0
IRQ_SCRATCH_ZPREG .byte 0
IRQ_SCRATCH_ZPWORD1 .word 0
IRQ_SCRATCH_ZPWORD2 .word 0
}}
2020-09-21 20:35:07 +00:00
}
2021-02-21 22:41:50 +00:00
asmsub restore_irq() clobbers(A) {
%asm {{
sei
lda _orig_irqvec
sta cx16.CINV
lda _orig_irqvec+1
sta cx16.CINV+1
lda cx16.VERA_IEN
and #%11110000 ; disable all Vera IRQs
ora #%00000001 ; enable only the vsync Irq
sta cx16.VERA_IEN
cli
rts
_orig_irqvec .word 0
}}
}
asmsub set_rasterirq(uword handler @AY, uword rasterpos @R0) clobbers(A) {
%asm {{
sta _modified+1
sty _modified+2
lda cx16.r0
ldy cx16.r0+1
sei
lda cx16.VERA_IEN
and #%11110000 ; clear other IRQs
ora #%00000010 ; enable the line (raster) irq
sta cx16.VERA_IEN
lda cx16.r0
2021-02-22 00:44:07 +00:00
ldy cx16.r0+1
jsr set_rasterline
2021-02-21 22:41:50 +00:00
lda #<_raster_irq_handler
sta cx16.CINV
lda #>_raster_irq_handler
sta cx16.CINV+1
cli
rts
_raster_irq_handler
jsr set_irq._irq_handler_init
_modified jsr $ffff ; modified
jsr set_irq._irq_handler_end
; end irq processing - don't use kernal's irq handling
lda cx16.VERA_ISR
ora #%00000010
sta cx16.VERA_ISR ; clear Vera line irq status
ply
plx
pla
rti
}}
}
2021-02-22 00:44:07 +00:00
asmsub set_rasterline(uword line @AY) {
%asm {{
sta cx16.VERA_IRQ_LINE_L
lda cx16.VERA_IEN
and #%01111111
sta cx16.VERA_IEN
tya
lsr a
ror a
and #%10000000
ora cx16.VERA_IEN
sta cx16.VERA_IEN
rts
}}
}
2021-01-03 01:36:45 +00:00
asmsub reset_system() {
2021-04-01 16:31:33 +00:00
; Soft-reset the system back to initial power-on Basic prompt.
2023-04-18 21:20:28 +00:00
; We do this via the SMC so that a true reset is performed that also resets the Vera fully.
2021-01-03 01:36:45 +00:00
%asm {{
sei
2023-04-18 21:20:28 +00:00
ldx #$42
2023-07-19 23:59:20 +00:00
ldy #2
lda #0
2023-04-18 21:20:28 +00:00
jsr cx16.i2c_write_byte
bra *
2021-01-03 01:36:45 +00:00
}}
}
2023-04-18 21:20:28 +00:00
sub poweroff_system() {
; use the SMC to shutdown the computer
2023-04-18 21:47:31 +00:00
void cx16.i2c_write_byte($42, $01, $00)
2023-04-18 21:20:28 +00:00
}
sub set_leds_brightness(ubyte activity, ubyte power) {
2023-04-18 21:47:31 +00:00
void cx16.i2c_write_byte($42, $04, power)
void cx16.i2c_write_byte($42, $05, activity)
2023-04-18 21:20:28 +00:00
}
2023-07-15 13:18:26 +00:00
asmsub wait(uword jiffies @AY) clobbers(X) {
2021-05-17 16:44:42 +00:00
; --- wait approximately the given number of jiffies (1/60th seconds) (N or N+1)
2023-01-20 02:10:41 +00:00
; note: the system irq handler has to be active for this to work as it depends on the system jiffy clock
2023-05-22 18:36:33 +00:00
; note: this routine cannot be used from inside a irq handler
2021-05-17 16:44:42 +00:00
%asm {{
2023-01-20 02:10:41 +00:00
sta P8ZP_SCRATCH_W1
sty P8ZP_SCRATCH_W1+1
_loop lda P8ZP_SCRATCH_W1
ora P8ZP_SCRATCH_W1+1
2021-05-17 16:44:42 +00:00
bne +
rts
2023-01-20 02:10:41 +00:00
2023-05-21 13:03:33 +00:00
+ sei
2023-05-21 13:05:17 +00:00
jsr cbm.RDTIM
2023-05-21 13:03:33 +00:00
cli
2023-01-20 02:10:41 +00:00
sta P8ZP_SCRATCH_B1
2023-05-21 13:03:33 +00:00
- sei
2023-05-21 13:05:17 +00:00
jsr cbm.RDTIM
2023-05-21 13:03:33 +00:00
cli
2023-01-20 02:10:41 +00:00
cmp P8ZP_SCRATCH_B1
beq -
lda P8ZP_SCRATCH_W1
bne +
dec P8ZP_SCRATCH_W1+1
+ dec P8ZP_SCRATCH_W1
bra _loop
2021-05-17 16:44:42 +00:00
}}
2021-01-03 01:36:45 +00:00
}
2021-05-17 16:44:42 +00:00
inline asmsub waitvsync() {
; --- suspend execution until the next vsync has occurred, without depending on custom irq handling.
2021-06-24 18:33:20 +00:00
; note: system vsync irq handler has to be active for this routine to work (and no other irqs-- which is the default).
2021-05-17 16:44:42 +00:00
; note: a more accurate way to wait for vsync is to set up a vsync irq handler instead.
2021-04-01 16:31:33 +00:00
%asm {{
2021-05-17 16:44:42 +00:00
wai
2021-04-01 16:31:33 +00:00
}}
}
2022-04-23 00:15:51 +00:00
asmsub internal_stringcopy(uword source @R0, uword target @AY) clobbers (A,Y) {
; Called when the compiler wants to assign a string value to another string.
%asm {{
sta P8ZP_SCRATCH_W1
sty P8ZP_SCRATCH_W1+1
lda cx16.r0
ldy cx16.r0+1
jmp prog8_lib.strcpy
}}
}
2022-02-08 19:01:33 +00:00
asmsub memcopy(uword source @R0, uword target @R1, uword count @AY) clobbers(A,X,Y) {
2022-03-02 22:31:07 +00:00
; note: only works for NON-OVERLAPPING memory regions!
; If you have to copy overlapping memory regions, consider using
; the cx16 specific kernal routine `memory_copy` (make sure kernal rom is banked in).
; note: can't be inlined because is called from asm as well.
2022-02-22 20:07:19 +00:00
; also: doesn't use cx16 ROM routine so this always works even when ROM is not banked in.
2021-01-08 00:05:26 +00:00
%asm {{
2022-02-22 20:07:19 +00:00
cpy #0
bne _longcopy
; copy <= 255 bytes
tay
bne _copyshort
rts ; nothing to copy
_copyshort
; decrease source and target pointers so we can simply index by Y
lda cx16.r0
bne +
dec cx16.r0+1
+ dec cx16.r0
lda cx16.r1
bne +
dec cx16.r1+1
+ dec cx16.r1
- lda (cx16.r0),y
sta (cx16.r1),y
dey
bne -
rts
_longcopy
pha ; lsb(count) = remainder in last page
tya
tax ; x = num pages (1+)
ldy #0
- lda (cx16.r0),y
sta (cx16.r1),y
iny
bne -
inc cx16.r0+1
inc cx16.r1+1
dex
bne -
ply
bne _copyshort
rts
2021-01-08 00:05:26 +00:00
}}
}
2022-02-22 20:07:19 +00:00
asmsub memset(uword mem @R0, uword numbytes @R1, ubyte value @A) clobbers(A,X,Y) {
2021-01-08 00:05:26 +00:00
%asm {{
2022-02-22 20:07:19 +00:00
ldy cx16.r0
sty P8ZP_SCRATCH_W1
ldy cx16.r0+1
sty P8ZP_SCRATCH_W1+1
ldx cx16.r1
ldy cx16.r1+1
jmp prog8_lib.memset
2021-01-08 00:05:26 +00:00
}}
}
asmsub memsetw(uword mem @R0, uword numwords @R1, uword value @AY) clobbers (A,X,Y) {
%asm {{
ldx cx16.r0
stx P8ZP_SCRATCH_W1
ldx cx16.r0+1
stx P8ZP_SCRATCH_W1+1
ldx cx16.r1
stx P8ZP_SCRATCH_W2
ldx cx16.r1+1
stx P8ZP_SCRATCH_W2+1
jmp prog8_lib.memsetw
}}
}
2021-01-08 15:20:56 +00:00
inline asmsub read_flags() -> ubyte @A {
%asm {{
php
pla
}}
}
inline asmsub clear_carry() {
%asm {{
2021-11-27 17:09:15 +00:00
clc
2021-01-08 15:20:56 +00:00
}}
}
inline asmsub set_carry() {
%asm {{
2021-11-27 17:09:15 +00:00
sec
2021-01-08 15:20:56 +00:00
}}
}
inline asmsub clear_irqd() {
%asm {{
2021-11-27 17:09:15 +00:00
cli
2021-01-08 15:20:56 +00:00
}}
}
inline asmsub set_irqd() {
%asm {{
2021-11-27 17:09:15 +00:00
sei
2021-01-08 15:20:56 +00:00
}}
}
2023-05-22 19:13:20 +00:00
inline asmsub irqsafe_set_irqd() {
%asm {{
php
sei
}}
}
inline asmsub irqsafe_clear_irqd() {
%asm {{
plp
}}
}
2021-01-08 15:20:56 +00:00
inline asmsub exit(ubyte returnvalue @A) {
; -- immediately exit the program with a return code in the A register
%asm {{
2023-04-28 21:13:03 +00:00
jsr cbm.CLRCHN ; reset i/o channels
2021-01-08 15:20:56 +00:00
ldx prog8_lib.orig_stackpointer
txs
rts ; return to original caller
}}
}
inline asmsub progend() -> uword @AY {
%asm {{
lda #<prog8_program_end
ldy #>prog8_program_end
}}
}
2020-08-25 23:56:26 +00:00
}
