535 lines
9.8 KiB
ArmAsm
535 lines
9.8 KiB
ArmAsm
|
|
//
|
|
// Official Kernal routine, described in:
|
|
//
|
|
// - [RG64] C64 Programmer's Reference Guide - page 295
|
|
// - [CM64] Compute's Mapping the Commodore 64 - page 220
|
|
//
|
|
// CPU registers that has to be preserved (see [RG64]): none
|
|
//
|
|
|
|
// Scan the keyboard..
|
|
// Here we don't use the horrible buggy original routine,
|
|
// not just because of copyright. Instead, we use the
|
|
// nice one with joystick interference removal and
|
|
// key roll-over support from
|
|
// http://codebase64.org/doku.php?id=base:scanning_the_keyboard_the_correct_and_non_kernal_way
|
|
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Keyboard IO Routine
|
|
// ~~~~~~~~~~~~~~~~~~~
|
|
// By: TWW/CTR
|
|
|
|
|
|
// Information
|
|
// ~~~~~~~~~~~
|
|
// The routine uses "2 Key rollower" or up to 3 if the key-combination doesen't induce shadowing.
|
|
// If 2 or 3 keys are pressed simultaneously (within 1 scan) a "No Activity" state has to occur before new valid keys are returned.
|
|
// RESTORE is not detectable and must be handled by NMI IRQ.
|
|
// SHIFT LOCK is not detected due to unreliability.
|
|
|
|
|
|
// History:
|
|
// ~~~~~~~~
|
|
// V3.0 - Hacked to pieces by PGS to work as KERNAL keyboard scan routine
|
|
// V2.5 - New test tool.
|
|
// Added return of error codes.
|
|
// Fixed a bug causing Buffer Overflow.
|
|
// Fixed a bug in Non Alphanumerical Flags from 2.0.
|
|
// V2.1 - Shortened the source by adding .for loops & Updated the header and some comments.
|
|
// Added "simultaneous keypress" check.
|
|
// V2.0 - Added return of non-Alphanumeric keys into X & Y-Registers.
|
|
// Small optimizations here and there.
|
|
// V1.1 - Unrolled code to make it faster and optimized other parts of it.
|
|
// Removed SHIFT LOCK scanning.
|
|
// V1.0 - First Working Version along with test tool.
|
|
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
|
|
|
|
// // ZERO PAGE Varibles
|
|
// $250-$258 is the 81st - 88th characters in BASIC input, a carry over from VIC-20
|
|
// and not used on C64, so safe for us to use, probably.
|
|
// (Compute's Mapping the 64 p51)
|
|
.label ScanResult = $250 // 8 bytes
|
|
// Other variables are in RS232 ZP locations for now
|
|
// (Carefully avoiding $A7 which is used by 64NET)
|
|
.label BufferNew = $A9 // 3 bytes
|
|
.label KeyQuantity = $A8 // 1 byte
|
|
.label TempZP = $B6 // 1 byte
|
|
|
|
// Reuse RS232 variables, since they should not be used
|
|
// by other things
|
|
// These are initialised in cinit all to $FF
|
|
.label BufferOld = $293 // 3 bytes
|
|
.label Buffer = $297 // 4 bytes
|
|
.label BufferQuantity = $B4 // 1 byte
|
|
|
|
|
|
// Operational Variables
|
|
.const MaxKeyRollover = 3
|
|
|
|
SCNKEY:
|
|
|
|
lda #$00
|
|
sta BufferQuantity
|
|
|
|
// Decrement key repeat timeout if non-zero
|
|
ldx KOUNT
|
|
beq sk_start
|
|
dec KOUNT
|
|
|
|
sk_start:
|
|
// Call main keyboard scanning routine
|
|
jsr Main
|
|
|
|
lda BufferQuantity
|
|
beq no_keys_waiting
|
|
|
|
// Stuff each key pressed into the keyboard buffer
|
|
|
|
ldy #$00
|
|
!:
|
|
lda Buffer,y
|
|
jsr accept_key
|
|
iny
|
|
cpy BufferQuantity
|
|
bne !-
|
|
no_keys_waiting:
|
|
|
|
rts
|
|
|
|
accept_key:
|
|
// Work out what is new and needs to be added
|
|
// to the input buffer.
|
|
// Also update the bucky key status flags etc
|
|
cmp #$ff
|
|
beq sk_nokey
|
|
// Got a key, turn it from matrix position to key value,
|
|
// and stuff it in the keyboard buffer
|
|
|
|
// Convert matrix position to key code
|
|
// XXX - Add offset of $40, $80 or $C0 if shift, CONTROL or C= are held down
|
|
pha
|
|
lda SHFLAG
|
|
and #$7
|
|
tax
|
|
pla
|
|
and #$3f
|
|
ora keyboard_matrix_lookup,x
|
|
tax
|
|
lda keyboard_matrixes,x
|
|
// But don't insert $00 characters
|
|
beq sk_nokey
|
|
|
|
// Stash key into keyboard buffer
|
|
ldx NDX
|
|
cpx XMAX
|
|
beq sk_nokey
|
|
sta KEYD,x
|
|
inc NDX
|
|
|
|
sk_nokey:
|
|
|
|
rts
|
|
|
|
// //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// // Routine for Scanning a Matrix Row
|
|
|
|
KeyInRow:
|
|
ldy #7
|
|
NextKeyInRow:
|
|
ror
|
|
bcs nokey
|
|
jsr KeyFound
|
|
nokey:
|
|
inx
|
|
dey
|
|
bpl NextKeyInRow
|
|
|
|
rts
|
|
|
|
|
|
// //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// // Routine for handling: Key Found
|
|
|
|
KeyFound:
|
|
stx TempZP
|
|
dec KeyQuantity
|
|
bmi OverFlow
|
|
|
|
// Originally, we resolved the keys.
|
|
// Now we just return the matrix position, so that
|
|
// we can do C64-style bucky modifications as normal
|
|
// was: ldy KeyTable,x
|
|
pha
|
|
txa
|
|
|
|
ldx KeyQuantity
|
|
sta BufferNew,x
|
|
pla
|
|
ldx TempZP
|
|
rts
|
|
|
|
// //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// // Routine for handling: Overflow
|
|
|
|
OverFlow:
|
|
pla // Dirty hack to handle 2 layers of JSR
|
|
pla
|
|
pla
|
|
pla
|
|
// Don't manipulate last legal buffer as the routine will fix itself once it gets valid input again.
|
|
|
|
ReturnNoKeys:
|
|
sec
|
|
lda #$00
|
|
sta BufferQuantity
|
|
lda #$FF
|
|
sta LSTX
|
|
ldx #MaxKeyRollover-1
|
|
!:
|
|
sta Buffer,x
|
|
sta BufferOld,x
|
|
dex
|
|
bpl !-
|
|
|
|
rts
|
|
|
|
|
|
// //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// // Exit Routine for: No Activity
|
|
|
|
NoActivityDetected:
|
|
|
|
// So cancel all bucky keys
|
|
lda SHFLAG
|
|
sta LSTSHF
|
|
lda #$00
|
|
sta SHFLAG
|
|
|
|
jmp ReturnNoKeys
|
|
|
|
// //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// // Configure Data Direction Registers
|
|
Main:
|
|
// Begin with no key events
|
|
lda #$ff
|
|
sta BufferNew+0
|
|
sta BufferNew+1
|
|
sta BufferNew+2
|
|
|
|
ldx #$ff
|
|
stx $dc02 // Port A - Output
|
|
ldy #$00
|
|
sty $dc03 // Port B - Input
|
|
|
|
|
|
// //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// // Check for Port Activity
|
|
|
|
sty $dc00 // Connect all Keyboard Rows
|
|
cpx $dc01
|
|
bne skip0
|
|
|
|
jmp NoActivityDetected
|
|
|
|
JoystickActivity:
|
|
|
|
// Clear bucky key status
|
|
lda #$00
|
|
sta SHFLAG
|
|
|
|
lda $dc01
|
|
and #$03
|
|
cmp #$01
|
|
bne !+
|
|
// down
|
|
ldx #$07 // UP/DOWN
|
|
jsr KeyFound
|
|
!:
|
|
cmp #$02
|
|
bne !+
|
|
// Up
|
|
// Mark shift as pressed
|
|
ldx #$01
|
|
stx SHFLAG
|
|
ldx #$07 // UP/DOWN
|
|
jsr KeyFound
|
|
!:
|
|
// Only allow up/down OR left/right, since
|
|
// else we have confusing situation with SHIFT required
|
|
// for one, but not the other.
|
|
// XXX - We could fix this by making the joystick activity
|
|
// feed the key input at a higher level, rather than
|
|
// simulating directly pressing the cursor keys.
|
|
cmp #$03
|
|
beq !+
|
|
jmp skdone
|
|
!:
|
|
lda $dc01
|
|
and #$0c
|
|
cmp #$04
|
|
bne !+
|
|
ldx #$02
|
|
jsr KeyFound // LEFT/RIGHT
|
|
!:
|
|
cmp #$08
|
|
bne !+
|
|
ldx #$01
|
|
stx SHFLAG
|
|
ldx #$02
|
|
jsr KeyFound // LEFT/RIGHT
|
|
!:
|
|
jmp skdone
|
|
|
|
|
|
skip0:
|
|
|
|
// // Set max keys allowed before ignoring result
|
|
lda #MaxKeyRollover
|
|
sta KeyQuantity
|
|
|
|
// //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// // Check for Control Port #1 Activity
|
|
|
|
stx $dc00 // Disconnect all Keyboard Rows
|
|
cpx $dc01 // Only Control Port activity will be detected
|
|
bne JoystickActivity
|
|
|
|
// //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// // Scan Keyboard Matrix
|
|
|
|
ldx #7
|
|
lda #%11111110
|
|
next_row:
|
|
sta $dc00
|
|
pha
|
|
lda $dc01
|
|
sta ScanResult,x
|
|
pla
|
|
sec
|
|
rol
|
|
dex
|
|
bpl next_row
|
|
|
|
// X gets back to $FF here, which is assumed below
|
|
|
|
// //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// // Check for Control Port #1 Activity (again)
|
|
|
|
stx $dc00 // Disconnect all Keyboard Rows
|
|
cpx $dc01 // Only Control Port activity will be detected
|
|
beq !+
|
|
jmp ReturnNoKeys
|
|
!:
|
|
// Make X = $00, assumed below
|
|
inx
|
|
|
|
// //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// // Check and flag Non Alphanumeric Keys
|
|
|
|
// Store de-bounce data for bucky keys
|
|
// (Compute's Mapping the 64, p58-59)
|
|
lda SHFLAG
|
|
sta LSTSHF
|
|
|
|
// Build bucky state
|
|
lda #$00
|
|
sta SHFLAG
|
|
lda ScanResult+6
|
|
eor #%10000000
|
|
and #%10000000 // Left shift
|
|
rol
|
|
rol
|
|
and #$01
|
|
ora SHFLAG
|
|
sta SHFLAG
|
|
|
|
// Right shift
|
|
lda ScanResult+1
|
|
eor #$10
|
|
lsr
|
|
lsr
|
|
lsr
|
|
lsr
|
|
and #$01
|
|
ora SHFLAG
|
|
sta SHFLAG
|
|
|
|
// Control
|
|
lda ScanResult+0
|
|
eor #$04
|
|
and #$04
|
|
ora SHFLAG
|
|
sta SHFLAG
|
|
|
|
// Vendor key
|
|
lda ScanResult+0
|
|
eor #$ff
|
|
lsr
|
|
lsr
|
|
lsr
|
|
lsr
|
|
and #$02
|
|
ora SHFLAG
|
|
sta SHFLAG
|
|
|
|
// Chick for shift + Vendor
|
|
cmp #$03
|
|
bne no_case_toggle
|
|
lda LSTSHF
|
|
cmp #$03
|
|
beq no_case_toggle
|
|
|
|
lda MODE
|
|
beq no_case_toggle
|
|
|
|
lda $D018
|
|
eor #$02
|
|
sta $d018
|
|
|
|
no_case_toggle:
|
|
|
|
// //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// // Check for pressed key(s)
|
|
|
|
lda ScanResult+7
|
|
cmp #$ff
|
|
beq sk6
|
|
jsr KeyInRow
|
|
sk6:
|
|
ldx #8
|
|
lda ScanResult+6
|
|
beq sk5
|
|
jsr KeyInRow
|
|
sk5:
|
|
ldx #16
|
|
lda ScanResult+5
|
|
beq sk4
|
|
jsr KeyInRow
|
|
sk4:
|
|
ldx #24
|
|
lda ScanResult+4
|
|
beq sk3
|
|
jsr KeyInRow
|
|
sk3:
|
|
ldx #32
|
|
lda ScanResult+3
|
|
beq sk2
|
|
jsr KeyInRow
|
|
sk2:
|
|
ldx #40
|
|
lda ScanResult+2
|
|
beq sk1
|
|
jsr KeyInRow
|
|
sk1:
|
|
ldx #48
|
|
lda ScanResult+1
|
|
beq sk0
|
|
jsr KeyInRow
|
|
sk0:
|
|
ldx #56
|
|
lda ScanResult+0
|
|
beq skdone
|
|
jsr KeyInRow
|
|
skdone:
|
|
|
|
|
|
|
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
// Key Scan Completed
|
|
|
|
// Put any new key (not in old scan) into buffer
|
|
ldx #MaxKeyRollover-1
|
|
|
|
ProcessPressedKeys:
|
|
|
|
// Check if the currently pressed key is continuing to be held down
|
|
lda BufferNew,x
|
|
cmp #$ff
|
|
beq ConsiderNextKey
|
|
cmp BufferOld
|
|
beq KeyHeld
|
|
cmp BufferOld+1
|
|
beq KeyHeld
|
|
cmp BufferOld+2
|
|
beq KeyHeld
|
|
|
|
RecordKeypress:
|
|
|
|
// New Key Detected
|
|
ldy BufferQuantity
|
|
cpy #MaxKeyRollover
|
|
bcc !+
|
|
jmp ReturnNoKeys // too many new keys
|
|
!:
|
|
AcceptKeyEvent:
|
|
sta Buffer,y
|
|
iny
|
|
sty BufferQuantity
|
|
|
|
ConsiderNextKey:
|
|
dex
|
|
bpl ProcessPressedKeys
|
|
|
|
// Copy new presses to old list
|
|
ldx #MaxKeyRollover-1
|
|
!:
|
|
lda BufferNew,x
|
|
sta BufferOld,x
|
|
dex
|
|
bpl !-
|
|
|
|
// Return success and set of pressed keys
|
|
clc
|
|
rts
|
|
|
|
KeyHeld:
|
|
// The key in A is still held down.
|
|
// compare with key in LSTX
|
|
// (Compute's Mapping the 64 p36-37)
|
|
// if different, reset repeat count down.
|
|
|
|
// Ignore bucky keys, so that repeat can work when a
|
|
// bucky is held down.
|
|
cmp #15
|
|
beq BuckyHeld
|
|
cmp #52
|
|
beq BuckyHeld
|
|
cmp #58
|
|
beq BuckyHeld
|
|
cmp #61
|
|
beq BuckyHeld
|
|
|
|
cmp LSTX
|
|
beq SameKeyHeld
|
|
|
|
// Different key held
|
|
sta LSTX
|
|
pha
|
|
lda DELAY
|
|
sta KOUNT
|
|
pla
|
|
BuckyHeld:
|
|
jmp ConsiderNextKey
|
|
|
|
SameKeyHeld:
|
|
pha
|
|
lda KOUNT
|
|
bmi KeyCanRepeat
|
|
bne KeyRepeatWait
|
|
// Count down ended, so repeat key now
|
|
KeyCanRepeat:
|
|
|
|
// (Compute's Mapping the 64 p58)
|
|
pha
|
|
lda #6-2 // Fudge factor to match speed
|
|
sta KOUNT
|
|
pla
|
|
pla
|
|
|
|
jmp RecordKeypress
|
|
KeyRepeatWait:
|
|
pla
|
|
jmp ConsiderNextKey
|