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.
695 lines
17 KiB
695 lines
17 KiB
; PIO driver sets up the parallel port as a subtype of Serial/Char device.
|
|
;
|
|
;
|
|
; HBIOS initializes driver by:
|
|
;
|
|
; 1) Performing Pre-initialization
|
|
;
|
|
; This involves setting up all the data structures decribing the devices.
|
|
; If possible, do a hardware test to verify it is available for adding to available devices.
|
|
;
|
|
; 2) Performing individual device/unit initialization.
|
|
;
|
|
; Hardware initialization.
|
|
; Configure to initial state or to a new state.
|
|
; Implementation limitations:
|
|
;
|
|
; The fully functionality of the Z80 PIO can only be realized by using Z80 interrupt mode 2.
|
|
; Registers cannot be interrogated for interrupts status and the originating interrupt
|
|
; device cannot be determine.
|
|
;
|
|
; Full implementation of IM2 functionality in an ECB-ZP and ECB-4P board would require the
|
|
; allocation of an interrupt handler for each chip channel. Thus, 10 interrupt handler
|
|
; would be required to support this configuration. As the HBIOS only has an allocation of
|
|
; 16, a full implmentation is impractical.
|
|
;
|
|
; The compromise solution is for the driver to allow IM2 only on the first PIO on each board.
|
|
; So, a ECB-4PIO would be fully interrupt drived in all modes but a ECB-ZP would only allow
|
|
; PIO 0 to be interrupt drived and PIO 1,2,3 would be limited to Bit mode or blind read and
|
|
; writed to the input/output ports.
|
|
;
|
|
; Zilog PIO reset state:
|
|
;
|
|
; Both port mask registers are reset to inhibit All port data bits.
|
|
; Port data bus lines are set to a high-impedance state and the Ready "handshake"
|
|
; Mode 1 is automatically selected.
|
|
; The vector address registers are not reset.
|
|
; Both port interrupt enable flip-flops are reset.
|
|
; Both port output registers are reset.
|
|
;
|
|
; Program a channel
|
|
;
|
|
; LD C,PIOBC ; C -> PIO Channel B control
|
|
; LD B,5 ; 5 bytes to send
|
|
; LD HL,PT ; HL -> Initialization data
|
|
; OTIR ; send bytes
|
|
;
|
|
PIODEBUG .EQU 1
|
|
;
|
|
M_Output .EQU $00 << 6
|
|
M_Input .EQU $01 << 6
|
|
M_Bidir .EQU $02 << 6
|
|
M_BitCtrl .EQU $03 << 6
|
|
M_BitAllIn .EQU $FF
|
|
M_BitAllOut .EQU $00
|
|
;
|
|
PIO_NONE .EQU 0
|
|
PIO_ZPIO .EQU 1
|
|
PIO_8255 .EQU 2
|
|
PIO_PORT .EQU 3
|
|
|
|
;INT_POOL .EQU HBX_IVT+IVT_PIO0
|
|
|
|
INT_ALLOC .DB 0
|
|
INT_N .EQU 00000000B
|
|
#IF (INTMODE == 2)
|
|
INT_Y .EQU INT_N
|
|
INT_ALLOW .EQU 4
|
|
#ELSE
|
|
INT_Y .EQU 00000100B
|
|
INT_ALLOW .EQU 0
|
|
#ENDIF
|
|
|
|
INT_0 .EQU 00000000B
|
|
INT_1 .EQU 00000001B
|
|
INT_2 .EQU 00000010B
|
|
INT_3 .EQU 00000011B
|
|
;
|
|
;
|
|
; SETUP THE DISPATCH TABLE ENTRIES
|
|
;
|
|
; WE CANT PRINT ANYTHING TO HBIOS CONSOLE AT THIS POINT
|
|
; PIO_CNT HOLDS THE NUMBER OF DEVICED CALCULATED FROM THE NUMBER OF DEFPIO MACROS
|
|
; PIO_CNT SHOULD INCREASE BY 2 FOR EVERY PIO CHIP ADDED.
|
|
;
|
|
PIO_PREINIT:
|
|
LD B,PIO_CNT ; LOOP CONTROL
|
|
LD C,0 ; PHYSICAL UNIT INDEX
|
|
XOR A ; ZERO TO ACCUM
|
|
LD (PIO_DEV),A ; CURRENT DEVICE NUMBER
|
|
PIO_PREINIT0:
|
|
PUSH BC ; SAVE LOOP CONTROL
|
|
LD A,C ; PHYSICAL UNIT TO A
|
|
RLCA ; MULTIPLY BY CFG TABLE ENTRY SIZE (8 BYTES)
|
|
RLCA ; ...
|
|
RLCA ; ... TO GET OFFSET INTO CFG TABLE
|
|
LD HL,PIO_CFG ; POINT TO START OF CFG TABLE
|
|
CALL ADDHLA ; HL := ENTRY ADDRESS
|
|
PUSH HL ; SAVE IT
|
|
PUSH HL ; COPY CFG DATA PTR
|
|
POP IY ; ... TO IY
|
|
CALL PIO_INITUNIT ; HAND OFF TO GENERIC INIT CODE
|
|
POP DE ; GET ENTRY ADDRESS BACK, BUT PUT IN DE
|
|
POP BC ; RESTORE LOOP CONTROL
|
|
;
|
|
LD A,(IY+1) ; GET THE PIO TYPE DETECTED
|
|
OR A ; SET FLAGS
|
|
JR Z,PIO_PREINIT2 ; SKIP IT IF NOTHING FOUND
|
|
;
|
|
PUSH BC ; SAVE LOOP CONTROL
|
|
PUSH AF
|
|
DEC A
|
|
LD BC,PIO_FNTBL ; BC := FUNCTION TABLE ADDRESS
|
|
JR Z,TYPFND ; ADD ENTRY IF PIO FOUND, BC:D
|
|
DEC A
|
|
LD BC,PPI_FNTBL ; BC := FUNCTION TABLE ADDRESS
|
|
JR Z,TYPFND
|
|
DEC A
|
|
LD BC,PRT_FNTBL
|
|
JR NZ,TYPDUN
|
|
TYPFND: CALL CIO_ADDENT ; ADD ENTRY IF PIO FOUND, BC:DE
|
|
TYPDUN: POP AF
|
|
POP BC ; RESTORE LOOP CONTROL
|
|
;
|
|
PIO_PREINIT2:
|
|
INC C ; NEXT PHYSICAL UNIT
|
|
DJNZ PIO_PREINIT0 ; LOOP UNTIL DONE
|
|
;
|
|
#IF (INTMODE == 2)
|
|
; SETUP PIO INTERRUPT VECTOR IN IVT
|
|
LD HL,PIO0INT
|
|
LD (HBX_IVT + IVT_PIO0),HL
|
|
#ENDIF
|
|
PIO_PREINIT3:
|
|
XOR A ; SIGNAL SUCCESS
|
|
RET ; AND RETURN
|
|
;
|
|
; WHEN WE GET HERE IY POINTS TO THE PIO_CFG TABLE WE ARE WORKING ON.
|
|
;
|
|
PIO_INITUNIT:
|
|
LD A,C ; SET THE UNIT NUMBER
|
|
LD (IY),A
|
|
|
|
LD DE,-1 ; LEAVE CONFIG ALONE
|
|
JP PIO_INITDEV ; IMPLEMENT IT AND RETURN
|
|
; XOR A ; SIGNAL SUCCESS
|
|
; RET ; AND RETURN
|
|
;
|
|
PIO_INIT:
|
|
LD B,PIO_CNT ; COUNT OF POSSIBLE PIO UNITS
|
|
LD C,0 ; INDEX INTO PIO CONFIG TABLE
|
|
PIO_INIT1:
|
|
PUSH BC ; SAVE LOOP CONTROL
|
|
|
|
LD A,C ; PHYSICAL UNIT TO A
|
|
RLCA ; MULTIPLY BY CFG TABLE ENTRY SIZE (8 BYTES)
|
|
RLCA ; ...
|
|
RLCA ; ... TO GET OFFSET INTO CFG TABLE
|
|
LD HL,PIO_CFG ; POINT TO START OF CFG TABLE
|
|
CALL ADDHLA ; HL := ENTRY ADDRESS
|
|
PUSH HL ; COPY CFG DATA PTR
|
|
POP IY ; ... TO IY
|
|
|
|
LD A,(IY+1) ; GET PIO TYPE
|
|
OR A ; SET FLAGS
|
|
CALL NZ,PIO_PRTCFG ; PRINT IF NOT ZERO
|
|
|
|
PUSH DE
|
|
LD DE,$FFFF ; INITIALIZE DEVICE/CHANNEL
|
|
CALL PIO_INITDEV ; BASED ON DPW
|
|
POP DE
|
|
|
|
POP BC ; RESTORE LOOP CONTROL
|
|
INC C ; NEXT UNIT
|
|
DJNZ PIO_INIT1 ; LOOP TILL DONE
|
|
;
|
|
XOR A ; SIGNAL SUCCESS
|
|
RET ; DONE
|
|
;
|
|
; EXAMPLE CODE
|
|
;
|
|
PIO_LPT:
|
|
IN A,($F6) ; get device status
|
|
AND $20 ; device ready?
|
|
JR Z,PIO_LPT ; no, busy wait
|
|
IN A,($F5) ; get transmit buffer register status ready?
|
|
AND $20 ; ready?
|
|
JR Z,PIO_LPT ; no, busy wait
|
|
LD A,C ; ready, char A for output through data port
|
|
OUT ($F0),A ; output char
|
|
RET
|
|
|
|
|
|
|
|
; ------------------------------------
|
|
; ZILOG PIO FUNCTION TABLE ROUTINES
|
|
;-------------------------------------
|
|
|
|
PIO_IN:
|
|
LD C,(IY+3)
|
|
IN A,(C)
|
|
LD E,A
|
|
XOR A ; SIGNAL SUCCESS
|
|
RET
|
|
|
|
;
|
|
PIO0INT:
|
|
PIO1INT:
|
|
PIO2INT:
|
|
PIO3INT:
|
|
PIO4INT:
|
|
PIO5INT:
|
|
PIO6INT:
|
|
PIO7INT:
|
|
PIO8INT:
|
|
PIO9INT:
|
|
OR $FF ; NZ SET TO INDICATE INT HANDLED
|
|
RET
|
|
;
|
|
; ON ENTRY IY POINTS TO THE DEVICE RECORD
|
|
; E CONTAINS THE CHARACTER TO OUTPUT
|
|
; WE RETREIVE THE CMD PORT ADDRESS AND CALCULATE THE
|
|
; DATA PORT AND WRITE THE CHARACTER TO IT.
|
|
;
|
|
PIO_OUT:
|
|
LD C,(IY+3)
|
|
OUT (C),E
|
|
XOR A ; SIGNAL SUCCESS
|
|
RET
|
|
|
|
LD C,(IY+3) ; GET PORT
|
|
LD A,(IY+4) ; GET MODE (B7B6)
|
|
|
|
|
|
PIO_IST:
|
|
RET
|
|
;
|
|
PIO_OST:
|
|
RET
|
|
;
|
|
; PIO_INITDEV - Configure device.
|
|
; If DE = FFFF then extract the configuration information from the table of devices and program the device using those settings.
|
|
; Otherwise use the configuration information in DE to program those settings and save them in the device table
|
|
;
|
|
; SETUP PARAMETER WORD:
|
|
; +-------------------------------+ +-------+-----------+---+-------+
|
|
; | BIT CONTROL | | MODE | C2 C1 C0 | A | INT |
|
|
; +-------------------------------+ --------------------+-----------+
|
|
; F E D C B A 9 8 7 6 5 4 3 2 1 0
|
|
; -- MSB (D REGISTER) -- -- LSB (E REGISTER) --
|
|
;
|
|
;
|
|
; MSB = BIT MAP USE IN MODE 3
|
|
; MODE B7 B6 = 00 Mode 0 Output
|
|
; 01 Mode 1 Input
|
|
; 10 Mode 2 Bidir
|
|
; 11 Mode 3 Bit Mode
|
|
; CHIP CHANNEL B5 B4 B3 001 Channel 1
|
|
; 010 Channel 2
|
|
; 100 Channel 3
|
|
; INTERRUPT ALLOCATED B2 = 0 NOT ALLOCATED
|
|
; = 1 IS ALLOCATED
|
|
;
|
|
; WHICH IVT IS ALLOCATES B1 B0 00 IVT_PIO0
|
|
; 01 IVT_PIO1
|
|
; 10 IVT_PIO2
|
|
; 11 IVT_PIO3
|
|
PIO_INITDEV:
|
|
; TEST FOR -1 (FFFF) WHICH MEANS USE CURRENT CONFIG (JUST REINIT)
|
|
LD A,D ; TEST DE FOR
|
|
AND E ; ... VALUE OF -1
|
|
INC A ; ... SO Z SET IF -1
|
|
JR NZ,PIO_INITDEV1 ; IF DE == -1, REINIT CURRENT CONFIG
|
|
;
|
|
; LOAD EXISTING CONFIG TO REINIT
|
|
LD E,(IY+4) ; LOW BYTE
|
|
LD D,(IY+5) ; HIGH BYTE
|
|
;
|
|
PIO_INITDEV1:
|
|
; WHICH DEVICE TYPE?
|
|
LD A,(IY+1)
|
|
CP PIO_ZPIO
|
|
JR Z,SET_PIO
|
|
CP PIO_8255
|
|
JR Z,SET_8255
|
|
CP PIO_PORT
|
|
JR Z,SET_PORT
|
|
PIO_BAD:OR $FF ; UNKNOWN DEVICE
|
|
RET
|
|
|
|
SET_PORT:
|
|
; DEVICE TYPE IS I/O PORT SO JUST WRITE $00 TO IT
|
|
LD C,(IY+3)
|
|
OUT (C),A
|
|
XOR A
|
|
RET
|
|
;
|
|
SET_PIO:
|
|
; DEVICE TYPE IS Z80 PIO SO DETERMINE MODE TO SET
|
|
; BIDIR MODE CAN ONLY BE SET ON CHANNEL 0
|
|
; BITCTRL MODE REQUIRES A I/O DIRECTION TO BE SET
|
|
LD C,(IY+3) ; GET DATA PORT
|
|
INC C ; POINT TO CMD
|
|
INC C ; PORT
|
|
LD A,(IY+4) ; GET MODE (B7B6)
|
|
AND 11010000B ; KEEP MODE & CHANNEL
|
|
CP 10010000B ; SET CH1 & BIDIR
|
|
JR Z,PIO_BAD ; CAN'T DO ON CH1
|
|
AND 11000000B ; $B0
|
|
OR 00001111B ; $0F
|
|
OUT (C),A ; SET MODE
|
|
CP (M_BitCtrl | $0F) ; IF MODE 3
|
|
JR NZ,SET_NM3
|
|
LD A,(IY+5) ; SET I/O
|
|
OUT (C),A ; FOR MODE 3
|
|
SET_NM3:; INTERUPT HANDLING
|
|
LD A,(IY+4) ; CHECK IF INTERRUPT
|
|
BIT 2,A ; REQUEST BIT SET
|
|
JR Z,NOINT1
|
|
|
|
LD A,(INT_ALLOC) ; DO WE HAVE AN
|
|
CP INT_ALLOW+1 ; INTERRUPT FREE?
|
|
JR NC,BADSET
|
|
|
|
INC A ; ONE INTERRUPT
|
|
LD (INT_ALLOC),A ; USED
|
|
|
|
; THE TRICKY BIT - SETUP THE RIGHT INTERRUPT VECTOR
|
|
|
|
NOINT1: LD A,00000111B ; $07
|
|
OUT (C),A ; NO INTERRUPTS
|
|
DEC C
|
|
DEC C
|
|
LD A,$FF ; DEFAULT VALUE
|
|
OUT (C),A
|
|
XOR A
|
|
RET
|
|
BADSET: LD A,$FF
|
|
RET
|
|
|
|
SET_8255:
|
|
RET
|
|
|
|
SET_BYE:
|
|
XOR A ; SIGNAL SUCCESS
|
|
RET
|
|
;
|
|
PIO_ZP0:
|
|
PIO_ZP1:
|
|
PIO_4P0:
|
|
PIO_4P1:
|
|
PIO_4P2:
|
|
PIO_4P3:
|
|
PIO_4P4:
|
|
PIO_4P5:
|
|
PIO_4P6:
|
|
PIO_4P7:OR $FF ; NZ SET TO INDICATE INT HANDLED
|
|
RET
|
|
;
|
|
; ON ENTRY IY POINTS TO THE DEVICE RECORD
|
|
; WE GET AND RETURN THE CONFIGURATION WORD IN DE
|
|
;
|
|
PIO_QUERY:
|
|
PPI_QUERY:
|
|
LD E,(IY+4) ; FIRST CONFIG BYTE TO E
|
|
LD D,(IY+5) ; SECOND CONFIG BYTE TO D
|
|
XOR A ; SIGNAL SUCCESS
|
|
RET
|
|
;
|
|
; ON ENTRY IY POINTS TO THE DEVICE RECORD
|
|
; FOR CHARACTER DEVICES BIT 6 OF ATTRIBUTE
|
|
; INDICATES PARALLEL PORT IF 1 SO WE SET IT.
|
|
;
|
|
PIO_DEVICE:
|
|
PPI_DEVICE:
|
|
LD D,CIODEV_PIO ; D := DEVICE TYPE
|
|
LD E,(IY) ; E := PHYSICAL UNIT
|
|
LD C,$40 ; C := ATTRIBUTE
|
|
XOR A ; SIGNAL SUCCESS
|
|
RET
|
|
|
|
; ------------------------------------
|
|
; i8255 FUNCTION TABLE ROUTINES
|
|
;-------------------------------------
|
|
|
|
PPI_IN:
|
|
XOR A ; SIGNAL SUCCESS
|
|
RET
|
|
;
|
|
PPI_OUT:
|
|
XOR A ; SIGNAL SUCCESS
|
|
RET
|
|
;
|
|
PPI_IST:
|
|
RET
|
|
;
|
|
PPI_OST:
|
|
RET
|
|
;
|
|
; PIO_INITDEV - Configure device.
|
|
; If DE = FFFF then extract the configuratio information from the table of devices and program the device using those settings.
|
|
; Otherwise use the configuration information in DE to program those settings and save them in the device table
|
|
|
|
PPI_INITDEV:
|
|
XOR A ; SIGNAL SUCCESS
|
|
RET
|
|
PPI_INT:OR $FF ; NZ SET TO INDICATE INT HANDLED
|
|
RET
|
|
;
|
|
PIO_PRTCFG:
|
|
; ANNOUNCE PORT
|
|
CALL NEWLINE ; FORMATTING
|
|
PRTS("PIO$") ; FORMATTING
|
|
LD A,(IY) ; DEVICE NUM
|
|
CALL PRTDECB ; PRINT DEVICE NUM
|
|
PRTS(": IO=0x$") ; FORMATTING
|
|
LD A,(IY+3) ; GET BASE PORT
|
|
CALL PRTHEXBYTE ; PRINT BASE PORT
|
|
;
|
|
; PRINT THE PIO TYPE
|
|
CALL PC_SPACE ; FORMATTING
|
|
LD A,(IY+1) ; GET PIO TYPE BYTE
|
|
RLCA ; MAKE IT A WORD OFFSET
|
|
LD HL,PIO_TYPE_MAP ; POINT HL TO TYPE MAP TABLE
|
|
CALL ADDHLA ; HL := ENTRY
|
|
LD E,(HL) ; DEREFERENCE
|
|
INC HL ; ...
|
|
LD D,(HL) ; ... TO GET STRING POINTER
|
|
CALL WRITESTR ; PRINT IT
|
|
;
|
|
; ALL DONE IF NO PIO WAS DETECTED
|
|
LD A,(IY+1) ; GET SIO TYPE BYTE
|
|
OR A ; SET FLAGS
|
|
RET Z ; IF ZERO, NOT PRESENT
|
|
;
|
|
PRTS(" MODE=$") ; FORMATTING
|
|
LD E,(IY+4) ; LOAD CONFIG
|
|
LD D,(IY+5) ; ... WORD TO DE
|
|
CALL PS_PRTPC0 ; PRINT CONFIG
|
|
;
|
|
XOR A
|
|
RET
|
|
;
|
|
; WORKING VARIABLES
|
|
;
|
|
PIO_DEV .DB 0 ; DEVICE NUM USED DURING INIT
|
|
;
|
|
; DESCRIPTION OF DIFFERENT PORT TYPES
|
|
;
|
|
PIO_TYPE_MAP:
|
|
.DW PIO_STR_NONE
|
|
.DW PIO_STR_PIO
|
|
.DW PIO_STR_8255
|
|
.DW PIO_STR_PORT
|
|
|
|
PIO_STR_NONE .DB "<NOT PRESENT>$"
|
|
PIO_STR_PIO .DB "Zilog PIO$"
|
|
PIO_STR_8255 .DB "i8255 PPI$"
|
|
PIO_STR_PORT .DB "IO Port$"
|
|
;
|
|
; Z80 PIO PORT TABLE - EACH ENTRY IS FOR 1 CHIP I.E. TWO PORTS
|
|
;
|
|
#DEFINE DEFPIO(MPIO_TYPE,MPIO_BASE,MPIO_CH0,MPIO_CH1,MPIO_CH0X,MPIO_CH1X,MPIO_FT0,MPIO_FT1,MPIO_IN0,MPIO_IN1) \
|
|
#DEFCONT \ .DB 0
|
|
#DEFCONT \ .DB MPIO_TYPE
|
|
#DEFCONT \ .DB 0
|
|
#DEFCONT \ .DB MPIO_BASE
|
|
#DEFCONT \ .DB (MPIO_CH0 | 00001000B | MPIO_IN0)
|
|
#DEFCONT \ .DB MPIO_CH0X
|
|
#DEFCONT \ .DW MPIO_FT0
|
|
#DEFCONT \ .DB 0
|
|
#DEFCONT \ .DB MPIO_TYPE
|
|
#DEFCONT \ .DB 1
|
|
#DEFCONT \ .DB MPIO_BASE+1
|
|
#DEFCONT \ .DB (MPIO_CH1 | 00010000B | MPIO_IN1)
|
|
#DEFCONT \ .DB MPIO_CH1X
|
|
#DEFCONT \ .DW MPIO_FT1
|
|
;
|
|
; i8255 PORT TABLE - EACH ENTRY IS FOR 1 CHIP I.E. THREE PORTS
|
|
;
|
|
#DEFINE DEFPPI(MPPI_TYPE,MPPI_BASE,MPPI_CH1,MPPI_CH2,MPPI_CH3,MPPI_CH1X,MPPI_CH2X,MPPI_CH3X) \
|
|
#DEFCONT \ .DB 0
|
|
#DEFCONT \ .DB MPPI_TYPE
|
|
#DEFCONT \ .DB 0
|
|
#DEFCONT \ .DB MPPI_BASE+0
|
|
#DEFCONT \ .DB (MPPI_CH1 | 00001000B)
|
|
#DEFCONT \ .DB MPPI_CH1X
|
|
#DEFCONT \ .DW
|
|
#DEFCONT \ .DB 0
|
|
#DEFCONT \ .DB MPPI_TYPE
|
|
#DEFCONT \ .DB 1
|
|
#DEFCONT \ .DB MPPI_BASE+2
|
|
#DEFCONT \ .DB (MPPI_CH2 | 00010000B)
|
|
#DEFCONT \ .DB MPPI_CH2X
|
|
#DEFCONT \ .DW 0
|
|
#DEFCONT \ .DB 0
|
|
#DEFCONT \ .DB MPPI_TYPE
|
|
#DEFCONT \ .DB 2
|
|
#DEFCONT \ .DB MPPI_BASE+4
|
|
#DEFCONT \ .DB (MPPI_CH3 | 00100000B)
|
|
#DEFCONT \ .DB MPPI_CH3X
|
|
#DEFCONT \ .DW 0
|
|
;
|
|
; HERE WE ACTUALLY DEFINE THE HARDWARE THAT THE HBIOS CAN ACCESS
|
|
; THE INIT ROUTINES READ AND SET THE INITIAL MODES FROM THIS INFO
|
|
;
|
|
PIO_CFG:
|
|
|
|
#IF PIO_ZP
|
|
DEFPIO(PIO_ZPIO,PIOZBASE+0,M_Output,M_BitCtrl,M_BitAllOut,M_BitAllOut,PIO0FT,PIO1FT,INT_Y,INT_N)
|
|
DEFPIO(PIO_ZPIO,PIOZBASE+4,M_Output,M_BitCtrl,M_BitAllOut,M_BitAllOut,PIO2FT,PIO3FT,INT_Y,INT_N)
|
|
#ENDIF
|
|
#IF PIO_4P
|
|
DEFPIO(PIO_ZPIO,PIO4BASE+0,M_Output,M_BitCtrl,M_BitAllOut,M_BitAllOut,PIO4FT,PIO5FT,INT_N,INT_N)
|
|
DEFPIO(PIO_ZPIO,PIO4BASE+4,M_Output,M_Input,M_BitAllOut,M_BitAllOut,PIO6FT,PIO7FT,INT_N,INT_N)
|
|
DEFPIO(PIO_ZPIO,PIO4BASE+8,M_Output,M_Output,M_BitAllOut,M_BitAllOut,PIO8FT,PIO9FT,INT_N,INT_N)
|
|
DEFPIO(PIO_ZPIO,PIO4BASE+12,M_Output,M_Output,M_BitAllOut,M_Output,PIO10FT,PIO11FT,INT_N,INT_N)
|
|
#ENDIF
|
|
; PPI_SBC & (PLATFORM == PLT_SBC) & (PPIDEMODE != PPIDEMODE_SBC))
|
|
|
|
#IF PPI_SBC
|
|
DEFPPI(PIO_8255,PPIBASE,M_Output,M_Output,M_Output,M_BitAllOut,M_BitAllOut,M_BitAllOut)
|
|
#ENDIF
|
|
;
|
|
; ; PIO CHANNEL A
|
|
; .DB 0 ; CIO DEVICE NUMBER (SET DURING PRE-INIT, THEN FIXED)
|
|
; .DB 0 ; PIO TYPE (SET AT ASSEMBLY, FIXED)
|
|
; .DB 0 ; FREE
|
|
; .DB PIOBASE+2 ; BASE DATA PORT (DATA PORT) (SET AT ASSEMBLY, FIXED)
|
|
; .DB 0 ; SPW - MODE 3 I/O DIRECTION BYTE (SET AT ASSEMBLE, SET WITH INIT)
|
|
.DB 0 ; SPW - MODE, CHANNEL (SET AT ASSEMBLY, SET WITH INIT, CHANNEL FIXED)
|
|
; .DW 0 ; FUNCTION TABLE (SET AT ASSEMBLY, SET DURING PRE-INIT AND AT INIT)
|
|
|
|
PIO_CNT .EQU ($ - PIO_CFG) / 8
|
|
;
|
|
|
|
; DRIVER FUNCTION TABLE FOR Z80 PIO's
|
|
; EACH PIO NEEDS A FUNCTION TABLE
|
|
; ECB-ZP : PIO0FT-PIO3FT
|
|
; ECB-4P : PIO4FT-PIO11FT
|
|
|
|
PIO_FNTBL:
|
|
;
|
|
#IF PIO_ZP
|
|
PIO0FT .DW PIO_IN
|
|
.DW PIO_OUT
|
|
.DW PIO_IST
|
|
.DW PIO_OST
|
|
.DW PIO_INITDEV
|
|
.DW PIO_QUERY
|
|
.DW PIO_DEVICE
|
|
#IF (($ - PIO0FT) != (CIO_FNCNT * 2))
|
|
.ECHO "*** INVALID PIO FUNCTION TABLE ***\n"
|
|
#ENDIF
|
|
PIO1FT .DW PIO_IN
|
|
.DW PIO_OUT
|
|
.DW PIO_IST
|
|
.DW PIO_OST
|
|
.DW PIO_INITDEV
|
|
.DW PIO_QUERY
|
|
.DW PIO_DEVICE
|
|
#IF (($ - PIO1FT) != (CIO_FNCNT * 2))
|
|
.ECHO "*** INVALID PIO FUNCTION TABLE ***\n"
|
|
#ENDIF
|
|
PIO2FT .DW PIO_IN
|
|
.DW PIO_OUT
|
|
.DW PIO_IST
|
|
.DW PIO_OST
|
|
.DW PIO_INITDEV
|
|
.DW PIO_QUERY
|
|
.DW PIO_DEVICE
|
|
#IF (($ - PIO2FT) != (CIO_FNCNT * 2))
|
|
.ECHO "*** INVALID PIO FUNCTION TABLE ***\n"
|
|
#ENDIF
|
|
PIO3FT .DW PIO_IN
|
|
.DW PIO_OUT
|
|
.DW PIO_IST
|
|
.DW PIO_OST
|
|
.DW PIO_INITDEV
|
|
.DW PIO_QUERY
|
|
.DW PIO_DEVICE
|
|
#IF (($ - PIO3FT) != (CIO_FNCNT * 2))
|
|
.ECHO "*** INVALID PIO FUNCTION TABLE ***\n"
|
|
#ENDIF
|
|
#ENDIF
|
|
;
|
|
#IF PIO_4P
|
|
PIO4FT .DW PIO_IN
|
|
.DW PIO_OUT
|
|
.DW PIO_IST
|
|
.DW PIO_OST
|
|
.DW PIO_INITDEV
|
|
.DW PIO_QUERY
|
|
.DW PIO_DEVICE
|
|
#IF (($ - PIO4FT) != (CIO_FNCNT * 2))
|
|
.ECHO "*** INVALID PIO FUNCTION TABLE ***\n"
|
|
#ENDIF
|
|
PIO5FT .DW PIO_IN
|
|
.DW PIO_OUT
|
|
.DW PIO_IST
|
|
.DW PIO_OST
|
|
.DW PIO_INITDEV
|
|
.DW PIO_QUERY
|
|
.DW PIO_DEVICE
|
|
#IF (($ - PIO5FT) != (CIO_FNCNT * 2))
|
|
.ECHO "*** INVALID PIO FUNCTION TABLE ***\n"
|
|
#ENDIF
|
|
PIO6FT .DW PIO_IN
|
|
.DW PIO_OUT
|
|
.DW PIO_IST
|
|
.DW PIO_OST
|
|
.DW PIO_INITDEV
|
|
.DW PIO_QUERY
|
|
.DW PIO_DEVICE
|
|
#IF (($ - PIO6FT) != (CIO_FNCNT * 2))
|
|
.ECHO "*** INVALID PIO FUNCTION TABLE ***\n"
|
|
#ENDIF
|
|
PIO7FT .DW PIO_IN
|
|
.DW PIO_OUT
|
|
.DW PIO_IST
|
|
.DW PIO_OST
|
|
.DW PIO_INITDEV
|
|
.DW PIO_QUERY
|
|
.DW PIO_DEVICE
|
|
#IF (($ - PIO7FT) != (CIO_FNCNT * 2))
|
|
.ECHO "*** INVALID PIO FUNCTION TABLE ***\n"
|
|
#ENDIF
|
|
PIO8FT .DW PIO_IN
|
|
.DW PIO_OUT
|
|
.DW PIO_IST
|
|
.DW PIO_OST
|
|
.DW PIO_INITDEV
|
|
.DW PIO_QUERY
|
|
.DW PIO_DEVICE
|
|
#IF (($ - PIO8FT) != (CIO_FNCNT * 2))
|
|
.ECHO "*** INVALID PIO FUNCTION TABLE ***\n"
|
|
#ENDIF
|
|
PIO9FT .DW PIO_IN
|
|
.DW PIO_OUT
|
|
.DW PIO_IST
|
|
.DW PIO_OST
|
|
.DW PIO_INITDEV
|
|
.DW PIO_QUERY
|
|
.DW PIO_DEVICE
|
|
#IF (($ - PIO9FT) != (CIO_FNCNT * 2))
|
|
.ECHO "*** INVALID PIO FUNCTION TABLE ***\n"
|
|
#ENDIF
|
|
PIO10FT .DW PIO_IN
|
|
.DW PIO_OUT
|
|
.DW PIO_IST
|
|
.DW PIO_OST
|
|
.DW PIO_INITDEV
|
|
.DW PIO_QUERY
|
|
.DW PIO_DEVICE
|
|
#IF (($ - PIO10FT) != (CIO_FNCNT * 2))
|
|
.ECHO "*** INVALID PIO FUNCTION TABLE ***\n"
|
|
#ENDIF
|
|
PIO11FT .DW PIO_IN
|
|
.DW PIO_OUT
|
|
.DW PIO_IST
|
|
.DW PIO_OST
|
|
.DW PIO_INITDEV
|
|
.DW PIO_QUERY
|
|
.DW PIO_DEVICE
|
|
#IF (($ - PIO11FT) != (CIO_FNCNT * 2))
|
|
.ECHO "*** INVALID PIO FUNCTION TABLE ***\n"
|
|
#ENDIF
|
|
#ENDIF
|
|
;
|
|
; DRIVER FUNCTION TABLE FOR i8255's
|
|
;
|
|
PPI_FNTBL:
|
|
.DW PPI_IN
|
|
.DW PPI_OUT
|
|
.DW PPI_IST
|
|
.DW PPI_OST
|
|
.DW PPI_INITDEV
|
|
.DW PPI_QUERY
|
|
.DW PPI_DEVICE
|
|
#IF (($ - PPI_FNTBL) != (CIO_FNCNT * 2))
|
|
.ECHO "*** INVALID PPI FUNCTION TABLE ***\n"
|
|
#ENDIF
|
|
;
|
|
; DRIVER FUNCTION TABLE FOR I/O PORT
|
|
;
|
|
PRT_FNTBL:
|
|
.DW PPI_IN
|
|
.DW PPI_OUT
|
|
.DW PPI_IST
|
|
.DW PPI_OST
|
|
.DW PPI_INITDEV
|
|
.DW PPI_QUERY
|
|
.DW PPI_DEVICE
|
|
#IF (($ - PRT_FNTBL) != (CIO_FNCNT * 2))
|
|
.ECHO "*** INVALID PPI FUNCTION TABLE ***\n"
|
|
#ENDIF
|