473 lines
9.8 KiB
ArmAsm
473 lines
9.8 KiB
ArmAsm
;; 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)
|
|
.alias ScanResult $250 ;// 8 bytes
|
|
;; Other variables are in RS232 ZP locations for now
|
|
;; (Carefully avoiding $A7 which is used by 64NET)
|
|
.alias BufferNew $A9 ;// 3 bytes
|
|
.alias KeyQuantity $A8 ;// 1 byte
|
|
.alias TempZP $B6 ;// 1 byte
|
|
|
|
;; Reuse RS232 variables, since they should not be used
|
|
;; by other things
|
|
;; These are initialised in cinit all to $FF
|
|
.alias BufferOld $293 ; 3 bytes
|
|
.alias Buffer $297 ; 4 bytes
|
|
.alias BufferQuantity $B4 ; 1 byte
|
|
|
|
|
|
|
|
;// Operational Variables
|
|
.alias MaxKeyRollover 3
|
|
|
|
scan_keyboard:
|
|
;; Call main keyboard scanning routine
|
|
jsr Main
|
|
bcc +
|
|
rts
|
|
*
|
|
;; 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 +
|
|
;; 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 key_bucky_state
|
|
and #$7
|
|
tax
|
|
pla
|
|
and #$3f
|
|
ora keyboard_matrix_lookup,x
|
|
tax
|
|
lda keyboard_matrixes,x
|
|
;; But don't insert $00 characters
|
|
beq +
|
|
|
|
;; Stash key into keyboard buffer
|
|
ldx keys_in_key_buffer
|
|
cpx key_buffer_size
|
|
beq +
|
|
sta keyboard_buffer,x
|
|
inc keys_in_key_buffer
|
|
|
|
*
|
|
|
|
rts
|
|
|
|
|
|
;; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
;; // Routine for Scanning a Matrix Row
|
|
|
|
KeyInRow:
|
|
ldy #7
|
|
*
|
|
ror
|
|
bcs nokey
|
|
jsr KeyFound
|
|
nokey:
|
|
inx
|
|
dey
|
|
bpl -
|
|
|
|
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.
|
|
sec
|
|
lda #$ff
|
|
rts
|
|
|
|
|
|
;; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
;; // Exit Routine for: No Activity
|
|
|
|
NoActivityDetected:
|
|
;; So cancel all bucky keys
|
|
lda key_bucky_state
|
|
sta key_last_bucky_state
|
|
lda #$00
|
|
sta key_bucky_state
|
|
|
|
stx BufferOld
|
|
stx BufferOld+1
|
|
stx BufferOld+2
|
|
sec
|
|
lda #$ff
|
|
;; Reset key repeat, so that pressing a key that was
|
|
;; after letting it go in the meantime doesn't result
|
|
;; in continued repeating
|
|
sta last_key_matrix_position
|
|
rts
|
|
|
|
|
|
;; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
;; // Exit Routine for Control Port Activity
|
|
|
|
ControlPort:
|
|
;; // Exit with A = #$02, Carry Set. Keep BufferOld to verify input after Control Port activity ceases
|
|
sec
|
|
lda #$ff
|
|
rts
|
|
|
|
|
|
;; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
;; // Configure Data Direction Registers
|
|
Main:
|
|
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
|
|
beq NoActivityDetected
|
|
|
|
skip0:
|
|
|
|
;; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
;; // Check for Control Port #1 Activity
|
|
|
|
stx $dc00 ;// Disconnect all Keyboard Rows
|
|
cpx $dc01 ;// Only Control Port activity will be detected
|
|
bne ControlPort
|
|
|
|
|
|
;; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
;; // Scan Keyboard Matrix
|
|
|
|
ldx #7
|
|
lda #%11111110
|
|
* sta $dc00
|
|
pha
|
|
lda $dc01
|
|
sta ScanResult,x
|
|
pla
|
|
sec
|
|
rol
|
|
dex
|
|
bpl -
|
|
|
|
;; 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
|
|
bne ControlPort
|
|
|
|
|
|
;; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
;; // Initialize Buffer, Flags and Max Keys
|
|
|
|
;; // Reset current read buffer
|
|
stx BufferNew
|
|
stx BufferNew+1
|
|
stx BufferNew+2
|
|
|
|
;; Make X = $00, assumed below
|
|
inx
|
|
|
|
;; // Set max keys allowed before ignoring result
|
|
lda #MaxKeyRollover
|
|
sta KeyQuantity
|
|
|
|
;; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
;; // Check and flag Non Alphanumeric Keys
|
|
|
|
;; Store last row of keyboard scan result,
|
|
;; so that RUN/STOP etc can be checked easily
|
|
;; (Compute's Mapping the 64, p27)
|
|
lda ScanResult+0
|
|
sta BUCKYSTATUS
|
|
|
|
;; Store de-bounce data for bucky keys
|
|
;; (Compute's Mapping the 64, p58-59)
|
|
lda key_bucky_state
|
|
sta key_last_bucky_state
|
|
|
|
;; Build bucky state
|
|
lda #$00
|
|
sta key_bucky_state
|
|
lda ScanResult+6
|
|
eor #$ff
|
|
and #%10000000 ;// Left Shift
|
|
rol
|
|
rol
|
|
and #$01
|
|
ora key_bucky_state
|
|
sta key_bucky_state
|
|
|
|
;; Right shift
|
|
lda ScanResult+1
|
|
eor #$ff
|
|
lsr
|
|
lsr
|
|
lsr
|
|
lsr
|
|
and #$01
|
|
ora key_bucky_state
|
|
sta key_bucky_state
|
|
|
|
;; Control
|
|
lda ScanResult+0
|
|
eor #$ff
|
|
and #$04
|
|
ora key_bucky_state
|
|
sta key_bucky_state
|
|
|
|
;; C= key
|
|
lda ScanResult+0
|
|
eor #$ff
|
|
lsr
|
|
lsr
|
|
lsr
|
|
lsr
|
|
and #$02
|
|
ora key_bucky_state
|
|
sta key_bucky_state
|
|
|
|
;; Chick for shift + Vendor
|
|
cmp #$05
|
|
bne no_case_toggle
|
|
lda key_last_bucky_state
|
|
cmp #$05
|
|
beq no_case_toggle
|
|
|
|
lda enable_case_switch
|
|
beq no_case_toggle
|
|
|
|
lda $D018
|
|
eor #$02
|
|
sta $d018
|
|
|
|
no_case_toggle:
|
|
|
|
;; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
;; // Check for pressed key(s)
|
|
|
|
lda ScanResult+7
|
|
cmp #$ff
|
|
beq +
|
|
jsr KeyInRow
|
|
*
|
|
ldx #8
|
|
lda ScanResult+6
|
|
beq +
|
|
jsr KeyInRow
|
|
*
|
|
ldx #16
|
|
lda ScanResult+5
|
|
beq +
|
|
jsr KeyInRow
|
|
*
|
|
ldx #24
|
|
lda ScanResult+4
|
|
beq +
|
|
jsr KeyInRow
|
|
*
|
|
ldx #32
|
|
lda ScanResult+3
|
|
beq +
|
|
jsr KeyInRow
|
|
*
|
|
ldx #40
|
|
lda ScanResult+2
|
|
beq +
|
|
jsr KeyInRow
|
|
*
|
|
ldx #48
|
|
lda ScanResult+1
|
|
beq +
|
|
jsr KeyInRow
|
|
*
|
|
ldx #56
|
|
lda ScanResult+0
|
|
beq +
|
|
jsr KeyInRow
|
|
*
|
|
|
|
|
|
|
|
;; //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
;; // Key Scan Completed
|
|
|
|
;; // Put any new key (not in old scan) into buffer
|
|
ldx #MaxKeyRollover-1
|
|
* lda BufferNew,x
|
|
cmp #$ff
|
|
beq Exist ;; // Handle 'null' values
|
|
cmp BufferOld
|
|
beq KeyHeld
|
|
cmp BufferOld+1
|
|
beq KeyHeld
|
|
cmp BufferOld+2
|
|
beq KeyHeld
|
|
RecordKeypress:
|
|
;; // New Key Detected
|
|
ldy BufferQuantity
|
|
cpy #MaxKeyRollover
|
|
bcc TooManyNewKeys
|
|
|
|
iny
|
|
sty BufferQuantity
|
|
sta Buffer,y
|
|
Exist:
|
|
dex
|
|
bpl -
|
|
|
|
;; // Anything in Buffer?
|
|
ldy BufferQuantity
|
|
bmi BufferEmpty
|
|
;; // Yes: Then return it and tidy up the buffer
|
|
dec BufferQuantity
|
|
lda Buffer
|
|
ldx Buffer+1
|
|
stx Buffer
|
|
ldx Buffer+2
|
|
stx Buffer+1
|
|
jmp Return
|
|
|
|
KeyHeld:
|
|
;; The key in A is still held down.
|
|
;; compare with key in last_key_matrix_position
|
|
;; (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 last_key_matrix_position
|
|
beq SameKeyHeld
|
|
;; Different key held
|
|
sta last_key_matrix_position
|
|
pha
|
|
lda key_first_repeat_delay
|
|
sta key_repeat_counter
|
|
pla
|
|
BuckyHeld:
|
|
jmp Exist
|
|
|
|
SameKeyHeld:
|
|
dec key_repeat_counter
|
|
bne +
|
|
;; Count down ended, so repeat key now
|
|
|
|
;; Reload key repeat counter
|
|
;; (Compute's Mapping the 64 p58)
|
|
pha
|
|
lda #6-2 ; Fudge factor to match speed
|
|
sta key_repeat_counter
|
|
pla
|
|
|
|
jmp RecordKeypress
|
|
|
|
* jmp Exist
|
|
|
|
BufferEmpty: ;; // No new Alphanumeric keys to handle.
|
|
lda #$ff
|
|
|
|
Return: ;; // A is preset
|
|
clc
|
|
;; // Copy BufferNew to BufferOld
|
|
ldx BufferNew
|
|
stx BufferOld
|
|
ldx BufferNew+1
|
|
stx BufferOld+1
|
|
ldx BufferNew+2
|
|
stx BufferOld+2
|
|
|
|
rts
|
|
|
|
TooManyNewKeys:
|
|
sec
|
|
lda #$ff
|
|
sta BufferQuantity
|
|
rts
|
|
|