mirror of https://github.com/wwarthen/RomWBW.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
887 lines
20 KiB
887 lines
20 KiB
;
|
|
;==================================================================================================
|
|
; DSKY NEXT GENERATION PKD (DISPLAY AND KEYBOARD) ROUTINES
|
|
;==================================================================================================
|
|
;
|
|
; A PKD CAN SHARE A PPI BUS WITH EITHER A PPIDE OR PPISD.
|
|
; SEE PPI_BUS.TXT FOR MORE INFORMATION.
|
|
;
|
|
; LED SEGMENTS (BIT VALUES)
|
|
;
|
|
; +--01--+
|
|
; 20 02
|
|
; +--40--+
|
|
; 10 04
|
|
; +--08--+ 80
|
|
;
|
|
; KEY CODE MAP (KEY CODES) CSCCCRRR
|
|
; ||||||||
|
|
; |||||+++-- ROW
|
|
; ||+++----- COL
|
|
; |+-------- SHIFT
|
|
; +--------- CONTROL
|
|
;
|
|
; _____C0_________C1_________C2_________C3__________C4____
|
|
; R0 | $00 [D] $08 [E] $10 [F] $18 [BO] $20 [F4]
|
|
; R1 | $01 [A] $09 [B] $11 [C] $19 [GO] $21 [F3]
|
|
; R2 | $02 [7] $0A [8] $12 [9] $1A [EX] $22 [F2]
|
|
; R3 | $03 [4] $0B [5] $13 [6] $1B [DE] $23 [F1]
|
|
; R5 | $04 [1] $0C [2] $14 [3] $1C [EN] +$40 [SH]
|
|
; R6 | $05 [FW] $0D [0] $15 [BK] $1D [CL] +$80 [CTL]
|
|
;
|
|
; LED BIT MAP (BIT VALUES)
|
|
;
|
|
; $08 $09 $0A $0B $0C $0D $0E $0F
|
|
; --- --- --- --- --- --- --- ---
|
|
; 01 01 01 01 01
|
|
; 02 02 02 02 02
|
|
; 04 04 04 04 04
|
|
; 08 08 08 08 08
|
|
; 10 10 10 10 10
|
|
; 20 20 20 20 20 L1 L2 BUZZ
|
|
;
|
|
PKD_PPIA .EQU PKDPPIBASE + 0 ; PORT A
|
|
PKD_PPIB .EQU PKDPPIBASE + 1 ; PORT B
|
|
PKD_PPIC .EQU PKDPPIBASE + 2 ; PORT C
|
|
PKD_PPIX .EQU PKDPPIBASE + 3 ; PPI CONTROL PORT
|
|
;
|
|
PKD_PPIX_RD .EQU %10010010 ; PPIX VALUE FOR READS
|
|
PKD_PPIX_WR .EQU %10000010 ; PPIX VALUE FOR WRITES
|
|
;
|
|
PKD_ROWS .EQU 1 ; DISPLAY ROWS
|
|
PKD_COLS .EQU 8 ; DISPLAY COLUMNS
|
|
;
|
|
; PIO CHANNEL C:
|
|
;
|
|
; 7 6 5 4 3 2 1 0
|
|
; RES 0 0 CS CS /RD /WR A0
|
|
;
|
|
; SETTING BITS 3 & 4 WILL ASSERT /CS ON 3279
|
|
; CLEAR BITS 1 OR 2 TO ASSERT READ/WRITE
|
|
;
|
|
PKD_PPI_IDLE .EQU %00000110
|
|
;
|
|
PKD_CMD_CLR .EQU %11011111 ; CLEAR (ALL OFF)
|
|
PKD_CMD_CLRX .EQU %11010011 ; CLEAR (ALL ON)
|
|
PKD_CMD_WDSP .EQU %10010000 ; WRITE DISPLAY RAM
|
|
PKD_CMD_RDSP .EQU %01110000 ; READ DISPLAY RAM
|
|
PKD_CMD_CLK .EQU %00100000 ; SET CLK PRESCALE
|
|
PKD_CMD_FIFO .EQU %01000000 ; READ FIFO
|
|
;
|
|
PKD_PRESCL .EQU PKDOSC/100000 ; PRESCALER
|
|
;
|
|
DEVECHO "PKD: IO="
|
|
DEVECHO PKDPPIBASE
|
|
DEVECHO ", SIZE="
|
|
DEVECHO PKD_COLS
|
|
DEVECHO "X"
|
|
DEVECHO PKD_ROWS
|
|
DEVECHO "\n"
|
|
;
|
|
;__PKD_PREINIT_____________________________________________________________________________________
|
|
;
|
|
; CONFIGURE PARALLEL PORT AND INITIALIZE 8279
|
|
;__________________________________________________________________________________________________
|
|
;
|
|
;
|
|
; HARDWARE RESET 8279 BY PULSING RESET LINE
|
|
;
|
|
PKD_PREINIT:
|
|
LD A,(DSKY_DISPACT) ; DSKY DISPATCHER ALREADY SET?
|
|
OR A ; SET FLAGS
|
|
RET NZ ; IF ALREADY ACTIVE, ABORT
|
|
;
|
|
; CHECK FOR PPI
|
|
CALL PKD_PPIDETECT ; TEST FOR PPI HARDWARE
|
|
RET NZ ; BAIL OUT IF NOT THERE
|
|
;
|
|
; SETUP PPI TO IDLE STATE
|
|
CALL PKD_PPIIDLE
|
|
LD A,PKD_PPI_IDLE
|
|
OUT (PKD_PPIC),A
|
|
;
|
|
; PULSE RESET SIGNAL ON 8279
|
|
SET 7,A
|
|
OUT (PKD_PPIC),A
|
|
RES 7,A
|
|
OUT (PKD_PPIC),A
|
|
;
|
|
; INITIALIZE 8279
|
|
CALL PKD_REINIT
|
|
;
|
|
; NOW SEE IF A PKD IS REALLY THERE...
|
|
LD A,$71
|
|
LD C,0
|
|
CALL PKD_PUTBYTE
|
|
LD C,0
|
|
CALL PKD_GETBYTE
|
|
CP $71
|
|
RET NZ ; BAIL OUT IF MISCOMPARE
|
|
;
|
|
; RECORD HARDWARE PRESENT
|
|
LD A,$FF
|
|
LD (PKD_PRESENT),A
|
|
;
|
|
; REGISTER DRIVER WITH HBIOS
|
|
LD BC,PKD_DISPATCH
|
|
CALL DSKY_SETDISP
|
|
;
|
|
CALL PKD_SHOWVER
|
|
;
|
|
RET
|
|
;
|
|
PKD_REINIT:
|
|
CALL PKD_PPIIDLE
|
|
; SET CLOCK SCALER TO 20
|
|
LD A,PKD_CMD_CLK | PKD_PRESCL
|
|
CALL PKD_CMD
|
|
JP PKD_RESET
|
|
;
|
|
PKD_SHOWVER:
|
|
LD HL,PKD_VERSTR
|
|
LD DE,PKD_BUF
|
|
LD BC,PKD_COLS
|
|
LDIR
|
|
LD HL,PKD_BUF + 5
|
|
LD A,RMJ
|
|
LD A,(PKD_SEGMAP + RMJ)
|
|
OR $80
|
|
LD (HL),A
|
|
INC HL
|
|
LD A,(PKD_SEGMAP + RMN)
|
|
OR $80
|
|
LD (HL),A
|
|
INC HL
|
|
LD A,(PKD_SEGMAP + RUP)
|
|
LD (HL),A
|
|
;
|
|
; DISPLAY VERSION ON PKD
|
|
LD C,0
|
|
LD B,8
|
|
LD HL,PKD_BUF
|
|
CALL PKD_PUTSTR
|
|
RET
|
|
;
|
|
;__PKD_INIT________________________________________________________________________________________
|
|
;
|
|
; DISPLAY DSKY INFO
|
|
;__________________________________________________________________________________________________
|
|
;
|
|
PKD_INIT:
|
|
CALL NEWLINE ; FORMATTING
|
|
PRTS("PKD:$") ; FORMATTING
|
|
;
|
|
PRTS(" IO=0x$") ; FORMATTING
|
|
LD A,PKDPPIBASE ; GET BASE PORT
|
|
CALL PRTHEXBYTE ; PRINT BASE PORT
|
|
;
|
|
LD A,(PKD_PRESENT) ; PRESENT?
|
|
OR A ; SET FLAGS
|
|
JR NZ,PKD_INIT1 ; YES, CONTINUE
|
|
PRTS(" NOT PRESENT$") ; NOT PRESENT
|
|
RET
|
|
;
|
|
PKD_INIT1:
|
|
CALL PC_SPACE
|
|
LD A,PKD_COLS
|
|
CALL PRTDEC8
|
|
LD A,'X'
|
|
CALL COUT
|
|
LD A,PKD_ROWS
|
|
CALL PRTDEC8
|
|
RET
|
|
;
|
|
; DSKY DEVICE FUNCTION DISPATCH ENTRY
|
|
; A: RESULT (OUT), 0=OK, Z=OK, NZ=ERR
|
|
; B: FUNCTION (IN)
|
|
;
|
|
PKD_DISPATCH:
|
|
LD A,B ; GET REQUESTED FUNCTION
|
|
AND $0F ; ISOLATE SUB-FUNCTION
|
|
JP Z,PKD_RESET ; RESET DSKY HARDWARE
|
|
DEC A
|
|
JP Z,PKD_STAT ; GET KEYPAD STATUS
|
|
DEC A
|
|
JP Z,PKD_GETKEY ; READ A KEY FROM THE KEYPAD
|
|
DEC A
|
|
JP Z,PKD_SHOWHEX ; DISPLAY A 32-BIT BINARY VALUE IN HEX
|
|
DEC A
|
|
JP Z,PKD_SHOWSEG ; DISPLAY SEGMENTS
|
|
DEC A
|
|
JP Z,PKD_KEYLEDS ; SET KEYPAD LEDS
|
|
DEC A
|
|
JP Z,PKD_STATLED ; SET STATUS LED
|
|
DEC A
|
|
JP Z,PKD_BEEP ; BEEP DSKY SPEAKER
|
|
DEC A
|
|
JP Z,PKD_DEVICE ; DEVICE INFO
|
|
DEC A
|
|
JP Z,PKD_MESSAGE ; HANDLE MESSAGE
|
|
DEC A
|
|
JP Z,PKD_EVENT ; HANDLE EVENT
|
|
SYSCHKERR(ERR_NOFUNC)
|
|
RET
|
|
;
|
|
; RESET DSKY -- CLEAR RAM AND FIFO
|
|
;
|
|
PKD_RESET:
|
|
LD A,PKD_CMD_CLR
|
|
CALL PKD_CMD
|
|
;
|
|
; 8259 TAKES ~160US TO CLEAR RAM DURING WHICH TIME WRITES TO
|
|
; DISPLAY RAM ARE INHIBITED. HIGH BIT OF STATUS BYTE IS SET
|
|
; DURING THIS WINDOW. TO PREVENT A DEADLOCK, A LOOP COUNTER
|
|
; IS USED TO IMPLEMENT A TIMEOUT.
|
|
LD B,0 ; TIMEOUT LOOP COUNTER
|
|
PKD_RESET1:
|
|
PUSH BC ; SAVE COUNTER
|
|
CALL PKD_ST ; GET STATUS BYTE
|
|
POP BC ; RECOVER COUNTER
|
|
BIT 7,A ; BIT 7 IS DISPLAY RAM BUSY
|
|
JR Z,PKD_RESET2 ; MOVE ON IF DONE
|
|
DJNZ PKD_RESET1 ; LOOP TILL TIMEOUT
|
|
;
|
|
PKD_RESET2:
|
|
RET
|
|
;
|
|
; CHECK FOR KEY PRESS, SAVE RAW VALUE, RETURN STATUS
|
|
;
|
|
PKD_STAT:
|
|
LD A,(PKD_PRESENT) ; DOES IT EXIST?
|
|
OR A ; SET FLAGS
|
|
RET Z ; ABORT WITH A=0 IF NOT THERE
|
|
CALL PKD_ST
|
|
AND $0F ; ISOLATE THE CUR FIFO LEN
|
|
RET
|
|
;
|
|
; WAIT FOR A DSKY KEYPRESS AND RETURN
|
|
;
|
|
PKD_GETKEY:
|
|
LD A,(PKD_PRESENT) ; DOES IT EXIST?
|
|
OR A ; SET FLAGS
|
|
JR Z,PKD_GETKEY1A ; ABORT IF NOT PRESENT
|
|
CALL PKD_STAT
|
|
JR Z,PKD_GETKEY ; LOOP IF NOTHING THERE
|
|
LD A,PKD_CMD_FIFO
|
|
CALL PKD_CMD
|
|
CALL PKD_DIN
|
|
XOR %11000000 ; FLIP POLARITY OF SHIFT/CTL BITS
|
|
PUSH AF ; SAVE VALUE
|
|
AND $3F ; STRIP SHIFT/CTL BITS FOR LOOKUP
|
|
LD B,28 ; SIZE OF DECODE TABLE
|
|
LD C,0 ; INDEX
|
|
LD HL,PKD_KEYMAP ; POINT TO BEGINNING OF TABLE
|
|
PKD_GETKEY1:
|
|
CP (HL) ; MATCH?
|
|
JR Z,PKD_GETKEY2 ; FOUND, DONE
|
|
INC HL
|
|
INC C ; BUMP INDEX
|
|
DJNZ PKD_GETKEY1 ; LOOP UNTIL EOT
|
|
POP AF ; FIX STACK
|
|
PKD_GETKEY1A:
|
|
LD A,$FF ; NOT FOUND ERR, RETURN $FF
|
|
RET
|
|
PKD_GETKEY2:
|
|
; RETURN THE INDEX POSITION WHERE THE SCAN CODE WAS FOUND
|
|
; THE ORIGINAL SHIFT/CTRL BITS ARE RESTORED
|
|
POP AF ; RESTORE RAW VALUE
|
|
AND %11000000 ; ISOLATE SHIFT/CTRL BITS
|
|
OR C ; COMBINE WITH INDEX VALUE
|
|
LD E,A ; PUT IN E FOR RETURN
|
|
XOR A ; SIGNAL SUCCESS
|
|
RET
|
|
;
|
|
; DISPLAY HEX VALUE FROM DE:HL
|
|
;
|
|
PKD_SHOWHEX:
|
|
LD BC,PKD_TMP32 ; POINT TO HEX BUFFER
|
|
CALL ST32 ; STORE 32-BIT BINARY THERE
|
|
LD HL,PKD_TMP32 ; FROM: BINARY VALUE (HL)
|
|
LD DE,PKD_BUF ; TO: SEGMENT BUFFER (DE)
|
|
CALL PKD_BIN2SEG ; CONVERT
|
|
LD HL,PKD_BUF ; POINT TO SEGMENT BUFFER
|
|
LD B,PKD_COLS ; LENGTH TO DISPLAY
|
|
LD C,0 ; STARTING POSITION
|
|
CALL PKD_PUTSTR ; DO IT
|
|
XOR A ; SUCCESS
|
|
RET ; AND RETURN
|
|
;
|
|
; DRAW DISPLAY USING DEBUG ALPHABET
|
|
; HL = SOURCE BUFFER
|
|
;
|
|
PKD_SHOWSEG:
|
|
; CONVERT FROM DBG ALPHABET TO SEG CODES
|
|
LD B,PKD_COLS ; DO FOR ALL CHARS
|
|
LD DE,PKD_BUF ; DESTINATION BUFFER
|
|
PKD_SHOWSEG1:
|
|
LD A,(HL) ; GET SOURCE VALUE
|
|
INC HL ; BUMP FOR NEXT TIME
|
|
PUSH AF ; SAVE IT
|
|
AND $80 ; ISOLATE HI BIT (DP)
|
|
LD C,A ; SAVE IN C
|
|
POP AF ; RECOVER ORIGINAL
|
|
AND $7F ; REMOVE HI BIT (DP)
|
|
PUSH HL ; SAVE IT
|
|
LD HL,PKD_SEGMAP ; POINT TO XLAT MAP
|
|
CALL ADDHLA ; OFFSET BY VALUE
|
|
LD A,(HL) ; GET NEW VALUE
|
|
OR C ; RECOMBINE WITH DP BIT
|
|
LD (DE),A ; SAVE IT
|
|
INC DE ; BUMP PTR
|
|
POP HL ; RESTORE SOURCE PTR
|
|
DJNZ PKD_SHOWSEG1 ; LOOP TILL DONE
|
|
;
|
|
; DISPLAY CONVERTED BUFFER
|
|
LD C,0 ; STARTING DISPLAY POSITION
|
|
LD B,PKD_COLS ; NUMBER OF CHARS
|
|
LD HL,PKD_BUF ; BUFFER
|
|
CALL PKD_PUTSTR ; DO IT
|
|
XOR A ; SIGNAL SUCCESS
|
|
RET
|
|
;
|
|
;
|
|
;
|
|
PKD_KEYLEDS:
|
|
CALL PKD_PUTLED ; DO IT
|
|
XOR A ; SIGNAL SUCCESS
|
|
RET
|
|
;
|
|
;
|
|
;
|
|
PKD_STATLED:
|
|
LD A,$0D ; PORT FOR FIRST LED
|
|
ADD A,D ; ADD LED NUM
|
|
LD C,A ; PUT IN C
|
|
LD A,E ; LED STATE INDICATOR
|
|
OR A ; SET FLAGS
|
|
JR NZ,PKD_STATLED1 ; HANDLE "ON"
|
|
;
|
|
; TURN LED OFF
|
|
PUSH BC ; SAVE LED NUM
|
|
CALL PKD_GETBYTE ; GET CUR VALUE
|
|
AND ~$20 ; BIT 5 OFF
|
|
JR PKD_STATLED2 ; FINISH UP
|
|
;
|
|
PKD_STATLED1:
|
|
; TURN LED ON
|
|
PUSH BC ; SAVE LED NUM
|
|
CALL PKD_GETBYTE ; GET CUR VALUE
|
|
OR $20 ; BIT 5 ON
|
|
;
|
|
PKD_STATLED2:
|
|
POP BC ; RECOVER LED NUM
|
|
CALL PKD_PUTBYTE ; PUT NEW VALUE
|
|
XOR A ; SIGNAL SUCCESS
|
|
RET
|
|
;
|
|
; BEEP THE SPEAKER ON THE PKD
|
|
;
|
|
PKD_BEEP:
|
|
PUSH BC
|
|
LD C,$0F
|
|
CALL PKD_GETBYTE
|
|
OR $20
|
|
LD C,$0F
|
|
CALL PKD_PUTBYTE
|
|
;
|
|
; TIMER
|
|
PUSH HL
|
|
LD HL,$8FFF
|
|
PKD_BEEP1:
|
|
DEC HL
|
|
LD A,H
|
|
CP 0
|
|
JR NZ,PKD_BEEP1
|
|
POP HL
|
|
LD C,$0F
|
|
CALL PKD_GETBYTE
|
|
AND $DF
|
|
LD C,$0F
|
|
CALL PKD_PUTBYTE
|
|
POP BC
|
|
XOR A ; SIGNAL SUCCESS
|
|
RET
|
|
;
|
|
; DEVICE INFORMATION
|
|
;
|
|
PKD_DEVICE:
|
|
LD D,DSKYDEV_PKD ; D := DEVICE TYPE
|
|
LD E,0 ; E := PHYSICAL DEVICE NUMBER
|
|
LD H,0 ; H := MODE
|
|
LD L,PKDPPIBASE ; L := BASE I/O ADDRESS
|
|
XOR A ; SIGNAL SUCCESS
|
|
RET
|
|
;
|
|
; MESSAGE HANDLER
|
|
;
|
|
PKD_MESSAGE:
|
|
LD A,C ; GET MESSAGE ID
|
|
ADD A,A ; WORD OFFSET
|
|
LD HL,PKD_MSGTBL ; START OF MESSAGE TABLE
|
|
CALL ADDHLA ; ADD OFFSET
|
|
LD A,(HL) ; SAVE LSB
|
|
INC HL ; BUMP TO MSB
|
|
LD H,(HL) ; GET MSB
|
|
LD L,A ; GET LSB
|
|
;
|
|
; HL HAS POINTER TO MESSAGE
|
|
LD C,0 ; STARTING DISPLAY POSITION
|
|
LD B,PKD_COLS ; NUMBER OF CHARS
|
|
CALL PKD_PUTSTR ; DISPLAY IT
|
|
XOR A ; SIGNAL SUCCESS
|
|
RET
|
|
;
|
|
; EVENT HANDLER
|
|
;
|
|
PKD_EVENT:
|
|
LD A,C ; EVENT ID
|
|
OR A ; 0=CPUSPD
|
|
JR Z,PKD_EVT_CPUSPD ; HANDLE CPU SPD CHANGE
|
|
DEC A ; 1=DSKACT
|
|
JR Z,PKD_EVT_DSKACT ; HANDLE DISK ACTIVITY
|
|
XOR A
|
|
RET
|
|
;
|
|
; CPU SPEED CHANGE
|
|
;
|
|
PKD_EVT_CPUSPD:
|
|
XOR A
|
|
RET
|
|
;
|
|
; DISK ACTIVITY
|
|
;
|
|
PKD_EVT_DSKACT:
|
|
;
|
|
; USE DISK UNIT NUMBER FOR MSB
|
|
LD A,(HB_DSKUNIT) ; GET DISK UNIT NUM
|
|
LD (HB_DSKADR+3),A ; REPLACE HIGH BYTE W/ DISK #
|
|
;
|
|
; CONVERT TO SEGMENT DISPLAY
|
|
LD HL,HB_DSKADR ; INPUT POINTER
|
|
LD DE,PKD_BUF ; BUF FOR OUTPUT
|
|
CALL PKD_BIN2SEG ; CONVERT TO SEG DISPLAY
|
|
;
|
|
; DECIMAL POINT FOR DISK UNIT SEPARATION
|
|
LD HL,PKD_BUF+1 ; SECOND CHAR OF DISP
|
|
SET 7,(HL) ; TURN ON DECIMAL PT
|
|
;
|
|
; DECIMAL POINT TO INDICATE WRITE ACTION
|
|
LD A,(HB_DSKFUNC) ; GET CURRENT I/O FUNCTION
|
|
CP BF_DIOWRITE ; IS IT A WRITE?
|
|
JR NZ,PKD_EVT_DSKACT2 ; IF NOT, SKIP
|
|
LD HL,PKD_BUF+7 ; POINT TO CHAR 7
|
|
SET 7,(HL) ; SET WRITE DOT
|
|
;
|
|
PKD_EVT_DSKACT2:
|
|
; UPDATE DISPLAY
|
|
LD HL,PKD_BUF ; SEG DISPLAY BUF TO HL
|
|
LD B,PKD_COLS
|
|
LD C,0
|
|
CALL PKD_PUTSTR
|
|
;
|
|
XOR A
|
|
RET
|
|
;
|
|
;__PKD_PPIDETECT___________________________________________________________________________________
|
|
;
|
|
; PROBE FOR PPI HARDWARE
|
|
;__________________________________________________________________________________________________
|
|
;
|
|
PKD_PPIDETECT:
|
|
;
|
|
; TEST FOR PPI EXISTENCE
|
|
; WE SETUP THE PPI TO WRITE, THEN WRITE A VALUE OF ZERO
|
|
; TO PORT A (DATALO), THEN READ IT BACK. IF THE PPI IS THERE
|
|
; THEN THE BUS HOLD CIRCUITRY WILL READ BACK THE ZERO. SINCE
|
|
; WE ARE IN WRITE MODE, AN IDE CONTROLLER WILL NOT BE ABLE TO
|
|
; INTERFERE WITH THE VALUE BEING READ.
|
|
CALL PKD_PPIWR
|
|
;
|
|
LD C,PKD_PPIA ; PPI PORT A
|
|
XOR A ; VALUE ZERO
|
|
OUT (C),A ; PUSH VALUE TO PORT
|
|
IN A,(C) ; GET PORT VALUE
|
|
OR A ; SET FLAGS
|
|
RET ; AND RETURN
|
|
;
|
|
;__KEYMAP_TABLE____________________________________________________________________________________
|
|
;
|
|
PKD_KEYMAP:
|
|
; POS $00 $01 $02 $03 $04 $05 $06 $07
|
|
; KEY [0] [1] [2] [3] [4] [5] [6] [7]
|
|
.DB $0D, $04, $0C, $14, $03, $0B, $13, $02
|
|
;
|
|
; POS $08 $09 $0A $0B $0C $0D $0E $0F
|
|
; KEY [8] [9] [A] [B] [C] [D] [E] [F]
|
|
.DB $0A, $12, $01, $09, $11, $00, $08, $10
|
|
;
|
|
; POS $10 $11 $12 $13 $14 $15 $16 $17
|
|
; KEY [FW] [BK] [CL] [EN] [DE] [EX] [GO] [BO]
|
|
.DB $05, $15, $1D, $1C, $1B, $1A, $19, $18
|
|
|
|
; POS $18 $19 $1A $1B
|
|
; KEY [F4] [F3] [F2] [F1]
|
|
.DB $23, $22, $21, $20
|
|
;
|
|
;==================================================================================================
|
|
; PKD OUTPUT ROUTINES
|
|
;==================================================================================================
|
|
;
|
|
; SEND DSKY COMMAND BYTE IN REGISTER A
|
|
; TRASHES BC
|
|
;
|
|
PKD_CMD:
|
|
LD B,$01
|
|
JR PKD_DOUT2
|
|
;
|
|
; SEND DSKY DATA BYTE IN REGISTER A
|
|
; TRASHES BC
|
|
;
|
|
PKD_DOUT:
|
|
LD B,$00
|
|
;
|
|
PKD_DOUT2:
|
|
;
|
|
; SAVE INCOMING DATA BYTE
|
|
PUSH AF
|
|
;
|
|
; SET PPI LINE CONFIG TO WRITE MODE
|
|
CALL PKD_PPIWR
|
|
;
|
|
; SETUP
|
|
LD C,PKD_PPIC
|
|
;
|
|
; SET ADDRESS FIRST
|
|
LD A,PKD_PPI_IDLE
|
|
OR B
|
|
OUT (C),A
|
|
;
|
|
; ASSERT 8279 /CS
|
|
SET 3,A
|
|
SET 4,A
|
|
OUT (C),A
|
|
;
|
|
; PPIC WORKING VALUE TO REG B NOW
|
|
LD B,A
|
|
;
|
|
; ASSERT DATA BYTE VALUE
|
|
POP AF
|
|
OUT (PKD_PPIA),A
|
|
;
|
|
; PULSE /WR
|
|
RES 1,B
|
|
OUT (C),B
|
|
NOP ; MAY NOT BE NEEDED
|
|
SET 1,B
|
|
OUT (C),B
|
|
;
|
|
; DEASSERT /CS
|
|
RES 3,B
|
|
RES 4,B
|
|
OUT (C),B
|
|
;
|
|
; CLEAR ADDRESS BIT
|
|
RES 0,B
|
|
OUT (C),B
|
|
;
|
|
; DONE
|
|
CALL PKD_PPIIDLE
|
|
RET
|
|
;
|
|
;==================================================================================================
|
|
; PKD INPUT ROUTINES
|
|
;==================================================================================================
|
|
;
|
|
; RETURN DSKY STATUS VALUE IN A
|
|
; TRASHES BC
|
|
;
|
|
PKD_ST:
|
|
LD B,$01
|
|
JR PKD_DIN2
|
|
;
|
|
; RETURN NEXT DATA VALUE IN A
|
|
; TRASHES BC
|
|
;
|
|
PKD_DIN:
|
|
LD B,$00
|
|
;
|
|
PKD_DIN2:
|
|
; SET PPI LINE CONFIG TO READ MODE
|
|
CALL PKD_PPIRD
|
|
;
|
|
; SETUP
|
|
LD C,PKD_PPIC
|
|
;
|
|
; SET ADDRESS FIRST
|
|
LD A,PKD_PPI_IDLE
|
|
OR B
|
|
OUT (C),A
|
|
;
|
|
; ASSERT 8279 /CS
|
|
SET 3,A
|
|
SET 4,A
|
|
OUT (C),A
|
|
;
|
|
; PPIC WORKING VALUE TO REG B NOW
|
|
LD B,A
|
|
;
|
|
; ASSERT /RD
|
|
RES 2,B
|
|
OUT (C),B
|
|
;
|
|
; GET VALUE
|
|
IN A,(PKD_PPIA)
|
|
;
|
|
; DEASSERT /RD
|
|
SET 2,B
|
|
OUT (C),B
|
|
;
|
|
; DEASSERT /CS
|
|
RES 3,B
|
|
RES 4,B
|
|
OUT (C),B
|
|
;
|
|
; CLEAR ADDRESS BIT
|
|
RES 0,B
|
|
OUT (C),B
|
|
;
|
|
; DONE
|
|
CALL PKD_PPIIDLE
|
|
RET
|
|
;
|
|
;==================================================================================================
|
|
; PKD UTILITY ROUTINES
|
|
;==================================================================================================
|
|
;
|
|
; BLANK PKD DISPLAY (WITHOUT USING CLEAR)
|
|
;
|
|
PKD_BLANK:
|
|
LD A,PKD_CMD_WDSP
|
|
CALL PKD_CMD
|
|
LD B,16
|
|
PKD_BLANK1:
|
|
PUSH BC
|
|
LD A,$FF
|
|
CALL PKD_DOUT
|
|
POP BC
|
|
DJNZ PKD_BLANK1
|
|
RET
|
|
;
|
|
; WRITE A RAW BYTE VALUE TO DSKY DISPLAY RAM
|
|
; AT LOCATION IN REGISTER C, VALUE IN A.
|
|
;
|
|
PKD_PUTBYTE:
|
|
PUSH BC
|
|
PUSH AF
|
|
LD A,C
|
|
ADD A,PKD_CMD_WDSP
|
|
CALL PKD_CMD
|
|
POP AF
|
|
XOR $FF
|
|
CALL PKD_DOUT
|
|
POP BC
|
|
RET
|
|
;
|
|
; READ A RAW BYTE VALUE FROM DSKY DISPLAY RAM
|
|
; AT LOCATION IN REGISTER C, VALUE RETURNED IN A
|
|
;
|
|
PKD_GETBYTE:
|
|
PUSH BC
|
|
LD A,C
|
|
ADD A,PKD_CMD_RDSP
|
|
CALL PKD_CMD
|
|
CALL PKD_DIN
|
|
XOR $FF
|
|
POP BC
|
|
RET
|
|
;
|
|
; WRITE A STRING OF RAW BYTE VALUES TO DSKY DISPLAY RAM
|
|
; AT LOCATION IN REGISTER C, LENGTH IN B, ADDRESS IN HL.
|
|
;
|
|
PKD_PUTSTR:
|
|
PUSH BC
|
|
LD A,C
|
|
ADD A,PKD_CMD_WDSP
|
|
CALL PKD_CMD
|
|
POP BC
|
|
;
|
|
PKD_PUTSTR1:
|
|
LD A,(HL)
|
|
XOR $FF
|
|
INC HL
|
|
PUSH BC
|
|
CALL PKD_DOUT
|
|
POP BC
|
|
DJNZ PKD_PUTSTR1
|
|
RET
|
|
;
|
|
; READ A STRING OF RAW BYTE VALUES FROM DSKY DISPLAY RAM
|
|
; AT LOCATION IN REGISTER C, LENGTH IN B, ADDRESS IN HL.
|
|
;
|
|
PKD_GETSTR:
|
|
PUSH BC
|
|
LD A,C
|
|
ADD A,PKD_CMD_RDSP
|
|
CALL PKD_CMD
|
|
POP BC
|
|
;
|
|
PKD_GETSTR1:
|
|
PUSH BC
|
|
CALL PKD_DIN
|
|
POP BC
|
|
XOR $FF
|
|
LD (HL),A
|
|
INC HL
|
|
DJNZ PKD_GETSTR1
|
|
RET
|
|
;
|
|
; UPDATE THE KEYPAD KEY LEDS. HL POINTS TO AN 8 BYTE BITMAP BUFFER
|
|
; THAT DEFINES ALL KEYPAD LED VALUES. THE ENTIRE MATRIX IS UPDATED.
|
|
;
|
|
PKD_PUTLED:
|
|
PUSH AF
|
|
PUSH BC
|
|
LD C,8
|
|
PKD_PUTLED_1:
|
|
LD A,(HL)
|
|
PUSH BC
|
|
CALL PKD_PUTBYTE
|
|
POP BC
|
|
INC C
|
|
INC HL
|
|
LD A,C
|
|
CP $10
|
|
JP NZ,PKD_PUTLED_1
|
|
POP BC
|
|
POP AF
|
|
RET
|
|
;
|
|
;==================================================================================================
|
|
; PKD LINE CONTROL ROUTINES
|
|
;==================================================================================================
|
|
;
|
|
; SETUP PPI FOR WRITING: PUT PPI PORT A IN OUTPUT MODE
|
|
; AVOID REWRTING PPIX IF ALREADY IN OUTPUT MODE
|
|
;
|
|
PKD_PPIWR:
|
|
PUSH AF
|
|
;
|
|
; CHECK FOR WRITE MODE
|
|
LD A,(PKD_PPIX_VAL)
|
|
CP PKD_PPIX_WR
|
|
JR Z,PKD_PPIWR1
|
|
;
|
|
; SET PPI TO WRITE MODE
|
|
LD A,PKD_PPIX_WR
|
|
OUT (PKD_PPIX),A
|
|
LD (PKD_PPIX_VAL),A
|
|
;
|
|
; RESTORE PORT C (MAY NOT BE NEEDED)
|
|
LD A,PKD_PPI_IDLE
|
|
OUT (PKD_PPIC),A
|
|
;
|
|
PKD_PPIWR1:
|
|
;
|
|
POP AF
|
|
RET
|
|
;
|
|
; SETUP PPI FOR READING: PUT PPI PORT A IN INPUT MODE
|
|
; AVOID REWRTING PPIX IF ALREADY IN INPUT MODE
|
|
;
|
|
PKD_PPIRD:
|
|
PUSH AF
|
|
;
|
|
; CHECK FOR READ MODE
|
|
LD A,(PKD_PPIX_VAL)
|
|
CP PKD_PPIX_RD
|
|
JR Z,PKD_PPIRD1
|
|
;
|
|
; SET PPI TO READ MODE
|
|
LD A,PKD_PPIX_RD
|
|
OUT (PKD_PPIX),A
|
|
LD (PKD_PPIX_VAL),A
|
|
;
|
|
PKD_PPIRD1:
|
|
POP AF
|
|
RET
|
|
;
|
|
; RELEASE USE OF PPI
|
|
;
|
|
PKD_PPIIDLE:
|
|
JR PKD_PPIRD ; SAME AS READ MODE
|
|
;
|
|
;==================================================================================================
|
|
; UTILTITY FUNCTIONS
|
|
;==================================================================================================
|
|
;
|
|
; CONVERT 32 BIT BINARY TO 8 BYTE HEX SEGMENT DISPLAY
|
|
;
|
|
; HL: ADR OF 32 BIT BINARY
|
|
; DE: ADR OF DEST LED SEGMENT DISPLAY BUFFER (8 BYTES)
|
|
;
|
|
PKD_BIN2SEG:
|
|
LD B,4 ; 4 BYTES OF INPUT
|
|
LD A,B ; PUT IN ACCUM
|
|
CALL ADDHLA ; PROCESS FROM END (LITTLE ENDIAN)
|
|
PKD_BIN2SEG1:
|
|
DEC HL ; DEC PTR (LITTLE ENDIAN)
|
|
LD A,(HL) ; HIGH NIBBLE
|
|
RRCA \ RRCA \ RRCA \ RRCA ; ROTATE BITS
|
|
CALL PKD_BIN2SEG_NIB ; CONVERT NIBBLE INTO OUTPUT BUF
|
|
LD A,(HL) ; LOW NIBBLE
|
|
CALL PKD_BIN2SEG_NIB ; CONVERT NIBBLE INTO OUTPUT BUF
|
|
DJNZ PKD_BIN2SEG1 ; LOOP FOR ALL INPUT BYTES
|
|
RET ; DONE
|
|
;
|
|
PKD_BIN2SEG_NIB:
|
|
PUSH HL ; SAVE HL
|
|
LD HL,PKD_SEGMAP ; POINT TO SEG MAP TABLE
|
|
AND $0F ; ISOLATE LOW NIBBLE
|
|
CALL ADDHLA ; OFFSET INTO TABLE
|
|
LD A,(HL) ; LOAD VALUE FROM TABLE
|
|
POP HL ; RESTORE HL
|
|
LD (DE),A ; SAVE VALUE TO OUTPUT BUF
|
|
INC DE ; BUMP TO NEXT OUTPUT BYTE
|
|
RET ; DONE
|
|
;
|
|
;==================================================================================================
|
|
; STORAGE
|
|
;==================================================================================================
|
|
;
|
|
PKD_PPIX_VAL .DB 0 ; PPIX SHADOW REG
|
|
PKD_PRESENT .DB 0 ; HARDWARE PRESENT FLAG
|
|
PKD_BUF .FILL PKD_COLS
|
|
PKD_TMP32 .FILL 4,0 ; TEMP DWORD
|
|
;
|
|
PKD_VERSTR .DB $76,$7F,$30,$3F,$6D,$00,$00,$00 ; "HBIOS "
|
|
;
|
|
PKD_SEGMAP:
|
|
;
|
|
; POS $00 $01 $02 $03 $04 $05 $06 $07
|
|
; GLYPH '0' '1' '2' '3' '4' '5' '6' '7'
|
|
|
|
.DB $3F, $06, $5B, $4F, $66, $6D, $7D, $07
|
|
;
|
|
; POS $08 $09 $0A $0B $0C $0D $0E $0F
|
|
; GLYPH '8' '9' 'A' 'B' 'C' 'D' 'E' 'F'
|
|
.DB $7F, $67, $77, $7C, $39, $5E, $79, $71
|
|
;
|
|
; POS $10 $11 $12 $13 $14 $15 $16 $17 $18 $19 $1A
|
|
; GLYPH ' ' '-' '.' 'P' 'o' 'r' 't' 'A' 'd' 'r' 'G'
|
|
.DB $00, $40, $00, $73, $5C, $50, $78, $77, $5E, $50, $3D
|
|
|
|
;
|
|
PKD_MSGTBL:
|
|
.DW PKD_MSG_LDR_SEL
|
|
.DW PKD_MSG_LDR_BOOT
|
|
.DW PKD_MSG_LDR_LOAD
|
|
.DW PKD_MSG_LDR_GO
|
|
.DW PKD_MSG_MON_RDY
|
|
.DW PKD_MSG_MON_BOOT
|
|
;
|
|
PKD_MSG_LDR_SEL .DB $7F,$5C,$5C,$78,$53,$00,$00,$00 ; "Boot? "
|
|
PKD_MSG_LDR_BOOT .DB $7F,$5C,$5C,$78,$80,$80,$80,$00 ; "Boot... "
|
|
PKD_MSG_LDR_LOAD .DB $38,$5C,$5F,$5E,$80,$80,$80,$00 ; "Load... "
|
|
PKD_MSG_LDR_GO .DB $3D,$5C,$80,$80,$80,$00,$00,$00 ; "Go... "
|
|
PKD_MSG_MON_RDY .DB $40,$39,$73,$3E,$00,$3E,$73,$40 ; "-CPU UP-"
|
|
PKD_MSG_MON_BOOT .DB $7F,$5C,$5C,$78,$82,$00,$00,$00 ; "Boot! "
|
|
|