@ -44,16 +44,35 @@
; LD A,04H
; CALL SUB12
;
NABUKB_DAT .EQU $ 90
NABUKB_IODAT .EQU $ 90 ; KEYBOARD DATA (READ)
NABUKB_IOSTAT .EQU $ 91 ; STATUS (READ), CMD (WRITE)
;
DEVECHO "NABUKB: IO="
DEVECHO NABUKB_DAT
DEVECHO NABUKB_IO DAT
DEVECHO "\n"
;
; SETUP INTERRUPT HANDLING, IF ENABLED
;
NABUKB_PREINIT:
# IF ( INTMODE = = 1 )
; ADD TO INTERRUPT CHAIN
LD HL , NABUKB_INT
CALL HB_ADDIM1 ; ADD TO IM1 CALL LIST
# ENDIF
;
# IF ( INTMODE = = 2 )
; INSTALL VECTOR
LD HL , NABUKB_INT
LD ( IVT ( INT_NABUKB )), HL ; IVT INDEX
# ENDIF
RET
;
; INITIALZIZE THE KEYBOARD CONTROLLER.
;
NABUKB_INIT:
CALL NEWLINE
PRTS ( "NABUKB: IO=0x$" )
LD A , NABUKB_DAT
LD A , NABUKB_IO DAT
CALL PRTHEXBYTE
;
XOR A
@ -72,36 +91,82 @@ NABUKB_INIT:
XOR A
RET
;
# IF ( INTMODE > 0 )
;
; INTERRUPT HANDLER FOR NABU KEYBOARD. HANDLES INTERRUPTS FOR EITHER
; INT MODE 1 OR INT MODE 2. THE KEYBOARD BUFFER IS JUST A SINGLE CHAR
; AT THIS POINT. NEW CHARACTERS ARRIVING WHEN THE BUFFER IS FULL WILL
; BE DISCARDED.
;
NABUKB_INT:
IN A ,( NABUKB_IOSTAT ) ; GET KBD STATUS
AND $ 02 ; CHECK DATA RDY BIT
RET Z ; ABORT W/ Z (INT NOT HANDLED)
;
;CALL PC_LT ; *DEBUG*
IN A ,( NABUKB_IODAT ) ; GET THE KEY
LD E , A ; STASH IN REG E
;CALL PRTHEXBYTE ; *DEBUG*
;CALL PC_GT ; *DEBUG*
;
LD A ,( NABUKB_KSTAT ) ; GET KEY BUFFER STAT
OR A ; SET FLAGS
RET NZ ; BUFFER FULL, BAIL OUT W/ NZ (INT HANDLED), KEY DISCARDED
;
LD A , E ; RECOVER THE KEY CODE
CALL NABUKB_XB ; TRANSLATE AND BUFFER KEY
OR $ FF ; SIGNAL INT HANDLED
RET ; DONE
;
# ENDIF
;
; NORMAL HBIOS CHAR INPUT STATUS. IF INTERRUPTS ARE NOT ACTIVE, THEN
; KEYBOARD POLLING IS IMPLEMENTED HERE.
;
NABUKB_STAT:
LD A ,( NABUKB_KSTAT ) ; GET KEY WAITING STATUS
OR A ; SET FLAGS
# IF ( INTMODE > 0 )
JR Z , NABUKB_STATX ; BAIL OUT W/ Z (NO KEY)
RET ; KEY WAITING, ALL SET
# ELSE
RET NZ ; KEY WAITING, ALL SET
IN A ,( NABUKB_DAT + 1 ) ; GET BKD STATUS
IN A ,( NABUKB_IOSTAT ) ; GET KB D STATUS
AND $ 02 ; CHECK DATA RDY BIT
JR Z , NABUKB_STATX ; BAIL OUT IF NOT
IN A ,( NABUKB_DAT ) ; GET THE KEY
JR Z , NABUKB_STATX ; BAIL OUT W/ Z (NO KEY)
IN A ,( NABUKB_IODAT ) ; GET THE KEY
CALL NABUKB_XB ; TRANSLATE AND BUFFER KEY
LD A ,( NABUKB_KSTAT ) ; GET NEW KEY WAITING STATUS
OR A ; SET FLAGS
RET ; DONE
# ENDIF
;
NABUKB_STATX:
XOR A ; SIGNAL NO CHAR READY
JP CIO_IDLE ; RETURN VIA IDLE PROCESSOR
;
; ROUTINE TO TRANSLATE AND BUFFER INCOMING NABU KEYBOARD KEYCODES
;
NABUKB_XB:
BIT 7 , A ; HIGH BIT IS SPECIAL CHAR
JR Z , NABUKB_STAT2 ; IF NORMAL CHAR, BUFFER IT
JR Z , NABUKB_XB 2 ; IF NORMAL CHAR, BUFFER IT
CP $ 90 ; START OF ERR CODES
JR C , NABUKB_STAT1 ; NOT ERR CODE, CONTINUE
JR C , NABUKB_XB 1 ; NOT ERR CODE, CONTINUE
CP $ A0 ; END OF ERR CODES
JR NC , NABUKB_STAT1 ; NOT ERR CODE, CONTINUE
JR NABUKB_STATX ; IS ERR CODE, IGNORE IT
NABUKB_STAT1:
JR NC , NABUKB_XB 1 ; NOT ERR CODE, CONTINUE
RET ; DISCARD ERR CODE AND RETURN
NABUKB_XB 1:
CP $ E0 ; SPECIAL CHARACTER?
JR C , NABUKB_STAT2 ; IF NOT, SKIP XLAT, BUFFER KEY
JR C , NABUKB_XB 2 ; IF NOT, SKIP XLAT, BUFFER KEY
CALL NABUKB_XLAT ; IF SO, TRANSLATE IT
JR C , NABUKB_STATX ; CF INDICATES INVALID
NABUKB_STAT2:
RET C ; CF INDICATES INVALID, DISCARD AND RETURN
NABUKB_XB 2:
LD ( NABUKB_KEY ), A ; BUFFER IT
LD A , 1 ; SIGNAL KEY WAITING
LD ( NABUKB_KSTAT ), A ; SAVE IT
OR A ; SET FLAGS
RET ; DONE
;
NABUKB_STATX:
XOR A ; SIGNAL NO CHAR READY
JP CIO_IDLE ; RETURN VIA IDLE PROCESSOR
; ROUTINE TO TRANSLATE SPECIAL NABU KEYBOARD KEY CODES
;
NABUKB_XLAT:
; NABU KEYBOARD USES $E0-$FF FOR SPECIAL KEYS
@ -121,10 +186,15 @@ NABUKB_XLAT1:
SCF ; SIGNAL INVALID
RET ; AND DONE
;
; FLUSH KEYBOARD BUFFER
;
NABUKB_FLUSH:
XOR A
LD ( NABUKB_KSTAT ), A
RET
;
; WAIT FOR A KEY TO BE READY AND RETURN IT.
;
NABUKB_READ:
CALL NABUKB_STAT ; CHECK FOR KEY READY
JR Z , NABUKB_READ ; LOOP TIL ONE IS READY
@ -136,8 +206,10 @@ NABUKB_READ:
LD ( NABUKB_KSTAT ), A ; CLEAR KEY WAITING STATUS
RET ; AND RETURN
;
; HELPER ROUTINE TO WRITE
;
NABUKB_PUT:
OUT ( NABUKB_DAT + 1 ), A
OUT ( NABUKB_IOSTAT ), A
NOP
NOP
NOP
@ -155,36 +227,37 @@ NABUKB_KEY .DB 0 ; KEY BUFFER
; NABU KEY CODE $E0 AND HANDLES $20 POSSIBLE VALUES ($E0-$FF)
; THE SPECIAL KEYS SEND A SPECIFIC KEYCODE TO INDICATE DOWN (KEY
; PRESSED) AND UP (KEY RELEASED). WE WILL ARBITRARILY CHOOSE TO
; RESPOND TO KEY RELEASED.
; RESPOND TO KEY PRESSED. a TRANSLATION VALUE OF $00 MEANS THAT THE
; KEY CODE SHOULD BE DISCARDED.
;
NABUKB_XTBL:
.DB $ 00 ; $E0, RIGHT ARROW (DN)
.DB $ 00 ; $E1, LEFT ARROW (DN)
.DB $ 00 ; $E2, UP ARROW (DN)
.DB $ 00 ; $E3, DOWN ARROW (DN)
.DB $ 00 ; $E4, PAGE RIGHT (DN)
.DB $ 00 ; $E5, PAGE LEFT (DN)
.DB $ 00 ; $E6, NO (DN)
.DB $ 00 ; $E7, YES (DN)
.DB $ 00 ; $E8, SYM (DN)
.DB $ 00 ; $E9, PAUSE (DN)
.DB $ 00 ; $EA, TV/NABU (DN)
.DB $ F9 ; $E0, RIGHT ARROW (DN) -> RIGHT ARROW
.DB $ F8 ; $E1, LEFT ARROW (DN) -> LEFT ARROW
.DB $ F6 ; $E2, UP ARROW (DN) -> UP ARROW
.DB $ F7 ; $E3, DOWN ARROW (DN) -> DOWN ARROW
.DB $ F5 ; $E4, PAGE RIGHT (DN) -> PAGE DOWN
.DB $ F4 ; $E5, PAGE LEFT (DN) -> PAGE UP
.DB $ F3 ; $E6, NO (DN) -> END
.DB $ F2 ; $E7, YES (DN) -> HOME
.DB $ EE ; $E8, SYM (DN) -> SYSRQ
.DB $ EF ; $E9, PAUSE (DN) -> PAUSE
.DB $ 00 ; $EA, TV/NABU (DN) -> APP
.DB $ 00 ; $EB, N/A
.DB $ 00 ; $EC, N/A
.DB $ 00 ; $ED, N/A
.DB $ 00 ; $EE, N/A
.DB $ 00 ; $EF, N/A
.DB $ F9 ; $F0, RIGHT ARROW (UP) -> RIGHT ARROW
.DB $ F8 ; $F1, LEFT ARROW (UP) -> LEFT ARROW
.DB $ F6 ; $F2, UP ARROW (UP) -> UP ARROW
.DB $ F7 ; $F3, DOWN ARROW (UP) -> DOWN ARROW
.DB $ F5 ; $F4, PAGE RIGHT (UP) -> PAGE DOWN
.DB $ F4 ; $F5, PAGE LEFT (UP) -> PAGE UP
.DB $ F3 ; $F6, NO (UP) -> END
.DB $ F2 ; $F7, YES (UP) -> HOME
.DB $ EC ; $F8, SYM (UP) -> SYSRQ
.DB $ EE ; $F9, PAUSE (UP) -> PAUSE
.DB $ EF ; $FA, TV/NABU (UP) -> APP
.DB $ 00 ; $F0, RIGHT ARROW (UP)
.DB $ 00 ; $F1, LEFT ARROW (UP)
.DB $ 00 ; $F2, UP ARROW (UP)
.DB $ 00 ; $F3, DOWN ARROW (UP)
.DB $ 00 ; $F4, PAGE RIGHT (UP)
.DB $ 00 ; $F5, PAGE LEFT (UP)
.DB $ 00 ; $F6, NO (UP)
.DB $ 00 ; $F7, YES (UP)
.DB $ 00 ; $F8, SYM (UP)
.DB $ 00 ; $F9, PAUSE (UP)
.DB $ 00 ; $FA, TV/NABU (UP)
.DB $ 00 ; $FB, N/A
.DB $ 00 ; $FC, N/A
.DB $ 00 ; $FD, N/A
Wayne Warthen
2 years ago