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.
1639 lines
44 KiB
1639 lines
44 KiB
;
|
|
;=============================================================================
|
|
; PPIDE DISK DRIVER
|
|
;=============================================================================
|
|
;
|
|
; TODO:
|
|
; - FIX SCALER CONSTANT
|
|
; - GOPARTNER NEEDS TO HANDLE "NO PARTNER" CONDITION
|
|
;
|
|
; NOTES:
|
|
; - WELL KNOWN PPIDE PORT ADDRESSES:
|
|
; $60 - SBC/ZETA ONBOARD PPI
|
|
; $20 - ECB DISKIO3, RC FAMILY
|
|
; $44 - ECB MULTI-FUNCTION PIC
|
|
; $80 - N8 ONBOARD PPI
|
|
; $4C - DYNO ONBOARD PPI
|
|
;
|
|
; THE CONTROL PORT OF THE 8255 IS PROGRAMMED AS NEEDED TO READ OR WRITE
|
|
; DATA ON THE IDE BUS. PORT C OF THE 8255 IS ALWAYS IN OUTPUT MODE BECAUSE
|
|
; IT IS DRIVING THE ADDRESS BUS AND CONTROL SIGNALS. PORTS A & B WILL BE
|
|
; PLACED IN READ OR WRITE MODE DEPENDING ON THE DIRECTION OF THE DATA BUS.
|
|
;
|
|
PPIDE_DIR_READ .EQU %10010010 ; IDE BUS DATA INPUT MODE
|
|
PPIDE_DIR_WRITE .EQU %10000000 ; IDE BUS DATA OUTPUT MODE
|
|
;
|
|
; PORT C OF THE 8255 IS USED TO DRIVE THE IDE INTERFACE ADDRESS BUS
|
|
; AND VARIOUS CONTROL SIGNALS. THE CONSTANTS BELOW REFLECT THESE
|
|
; ASSIGNMENTS.
|
|
;
|
|
PPIDE_CTL_DA0 .EQU %00000001 ; DRIVE ADDRESS BUS - BIT 0 (DA0)
|
|
PPIDE_CTL_DA1 .EQU %00000010 ; DRIVE ADDRESS BUS - BIT 1 (DA1)
|
|
PPIDE_CTL_DA2 .EQU %00000100 ; DRIVE ADDRESS BUS - BIT 2 (DA2)
|
|
PPIDE_CTL_CS1 .EQU %00001000 ; DRIVE CHIP SELECT 0 (ACTIVE LOW, INVERTED)
|
|
PPIDE_CTL_CS3 .EQU %00010000 ; DRIVE CHIP SELECT 1 (ACTIVE LOW, INVERTED)
|
|
PPIDE_CTL_DIOW .EQU %00100000 ; DRIVE I/O WRITE (ACTIVE LOW, INVERTED)
|
|
PPIDE_CTL_DIOR .EQU %01000000 ; DRIVE I/O READ (ACTIVE LOW, INVERTED)
|
|
PPIDE_CTL_RESET .EQU %10000000 ; DRIVE RESET (ACTIVE LOW, INVERTED)
|
|
;
|
|
; +-----------------------------------------------------------------------+
|
|
; | CONTROL BLOCK REGISTERS (CS3FX) |
|
|
; +-----------------------+-------+-------+-------------------------------+
|
|
; | REGISTER | PORT | DIR | DESCRIPTION |
|
|
; +-----------------------+-------+-------+-------------------------------+
|
|
; | PPIDE_REG_ALTSTAT | 0x06 | R | ALTERNATE STATUS REGISTER |
|
|
; | PPIDE_REG_CTRL | 0x06 | W | DEVICE CONTROL REGISTER |
|
|
; | PPIDE_REG_DRVADR | 0x07 | R | DRIVE ADDRESS REGISTER |
|
|
; +-----------------------+-------+-------+-------------------------------+
|
|
;
|
|
; +-----------------------+-------+-------+-------------------------------+
|
|
; | COMMAND BLOCK REGISTERS (CS1FX) |
|
|
; +-----------------------+-------+-------+-------------------------------+
|
|
; | REGISTER | PORT | DIR | DESCRIPTION |
|
|
; +-----------------------+-------+-------+-------------------------------+
|
|
; | PPIDE_REG_DATA | 0x00 | R/W | DATA INPUT/OUTPUT |
|
|
; | PPIDE_REG_ERR | 0x01 | R | ERROR REGISTER |
|
|
; | PPIDE_REG_FEAT | 0x01 | W | FEATURES REGISTER |
|
|
; | PPIDE_REG_COUNT | 0x02 | R/W | SECTOR COUNT REGISTER |
|
|
; | PPIDE_REG_SECT | 0x03 | R/W | SECTOR NUMBER REGISTER |
|
|
; | PPIDE_REG_CYLLO | 0x04 | R/W | CYLINDER NUM REGISTER (LSB) |
|
|
; | PPIDE_REG_CYLHI | 0x05 | R/W | CYLINDER NUM REGISTER (MSB) |
|
|
; | PPIDE_REG_DRVHD | 0x06 | R/W | DRIVE/HEAD REGISTER |
|
|
; | PPIDE_REG_LBA0* | 0x03 | R/W | LBA BYTE 0 (BITS 0-7) |
|
|
; | PPIDE_REG_LBA1* | 0x04 | R/W | LBA BYTE 1 (BITS 8-15) |
|
|
; | PPIDE_REG_LBA2* | 0x05 | R/W | LBA BYTE 2 (BITS 16-23) |
|
|
; | PPIDE_REG_LBA3* | 0x06 | R/W | LBA BYTE 3 (BITS 24-27) |
|
|
; | PPIDE_REG_STAT | 0x07 | R | STATUS REGISTER |
|
|
; | PPIDE_REG_CMD | 0x07 | W | COMMAND REGISTER (EXECUTE) |
|
|
; +-----------------------+-------+-------+-------------------------------+
|
|
; * LBA0-3 ARE ALTERNATE DEFINITIONS OF SECT, CYL, AND DRVHD PORTS
|
|
;
|
|
; === STATUS REGISTER ===
|
|
;
|
|
; 7 6 5 4 3 2 1 0
|
|
; +-------+-------+-------+-------+-------+-------+-------+-------+
|
|
; | BSY | DRDY | DWF | DSC | DRQ | CORR | IDX | ERR |
|
|
; +-------+-------+-------+-------+-------+-------+-------+-------+
|
|
;
|
|
; BSY: BUSY
|
|
; DRDY: DRIVE READY
|
|
; DWF: DRIVE WRITE FAULT
|
|
; DSC: DRIVE SEEK COMPLETE
|
|
; DRQ: DATA REQUEST
|
|
; CORR: CORRECTED DATA
|
|
; IDX: INDEX
|
|
; ERR: ERROR
|
|
;
|
|
; === ERROR REGISTER ===
|
|
;
|
|
; 7 6 5 4 3 2 1 0
|
|
; +-------+-------+-------+-------+-------+-------+-------+-------+
|
|
; | BBK | UNC | MC | IDNF | MCR | ABRT | TK0NF | AMNF |
|
|
; +-------+-------+-------+-------+-------+-------+-------+-------+
|
|
; (VALID WHEN ERR BIT IS SET IN STATUS REGISTER)
|
|
;
|
|
; BBK: BAD BLOCK DETECTED
|
|
; UNC: UNCORRECTABLE DATA ERROR
|
|
; MC: MEDIA CHANGED
|
|
; IDNF: ID NOT FOUND
|
|
; MCR: MEDIA CHANGE REQUESTED
|
|
; ABRT: ABORTED COMMAND
|
|
; TK0NF: TRACK 0 NOT FOUND
|
|
; AMNF: ADDRESS MARK NOT FOUND
|
|
;
|
|
; === DRIVE/HEAD / LBA3 REGISTER ===
|
|
;
|
|
; 7 6 5 4 3 2 1 0
|
|
; +-------+-------+-------+-------+-------+-------+-------+-------+
|
|
; | 1 | L | 1 | DRV | HS3 | HS2 | HS1 | HS0 |
|
|
; +-------+-------+-------+-------+-------+-------+-------+-------+
|
|
;
|
|
; L: 0 = CHS ADDRESSING, 1 = LBA ADDRESSING
|
|
; DRV: 0 = DRIVE 0 (PRIMARY) SELECTED, 1 = DRIVE 1 (SLAVE) SELECTED
|
|
; HS: CHS = HEAD ADDRESS (0-15), LBA = BITS 24-27 OF LBA
|
|
;
|
|
; === DEVICE CONTROL REGISTER ===
|
|
;
|
|
; 7 6 5 4 3 2 1 0
|
|
; +-------+-------+-------+-------+-------+-------+-------+-------+
|
|
; | X | X | X | X | 1 | SRST | ~IEN | 0 |
|
|
; +-------+-------+-------+-------+-------+-------+-------+-------+
|
|
;
|
|
; SRST: SOFTWARE RESET
|
|
; ~IEN: INTERRUPT ENABLE
|
|
;
|
|
; CONTROL VALUES TO USE WHEN ACCESSING THE VARIOUS IDE DEVICE REGISTERS
|
|
;
|
|
PPIDE_REG_DATA .EQU PPIDE_CTL_CS1 | $00 ; DATA INPUT/OUTPUT (R/W)
|
|
PPIDE_REG_ERR .EQU PPIDE_CTL_CS1 | $01 ; ERROR REGISTER (R)
|
|
PPIDE_REG_FEAT .EQU PPIDE_CTL_CS1 | $01 ; FEATURES REGISTER (W)
|
|
PPIDE_REG_COUNT .EQU PPIDE_CTL_CS1 | $02 ; SECTOR COUNT REGISTER (R/W)
|
|
PPIDE_REG_SECT .EQU PPIDE_CTL_CS1 | $03 ; SECTOR NUMBER REGISTER (R/W)
|
|
PPIDE_REG_CYLLO .EQU PPIDE_CTL_CS1 | $04 ; CYLINDER NUM REGISTER (LSB) (R/W)
|
|
PPIDE_REG_CYLHI .EQU PPIDE_CTL_CS1 | $05 ; CYLINDER NUM REGISTER (MSB) (R/W)
|
|
PPIDE_REG_DRVHD .EQU PPIDE_CTL_CS1 | $06 ; DRIVE/HEAD REGISTER (R/W)
|
|
PPIDE_REG_LBA0 .EQU PPIDE_CTL_CS1 | $03 ; LBA BYTE 0 (BITS 0-7) (R/W)
|
|
PPIDE_REG_LBA1 .EQU PPIDE_CTL_CS1 | $04 ; LBA BYTE 1 (BITS 8-15) (R/W)
|
|
PPIDE_REG_LBA2 .EQU PPIDE_CTL_CS1 | $05 ; LBA BYTE 2 (BITS 16-23) (R/W)
|
|
PPIDE_REG_LBA3 .EQU PPIDE_CTL_CS1 | $06 ; LBA BYTE 3 (BITS 24-27) (R/W)
|
|
PPIDE_REG_STAT .EQU PPIDE_CTL_CS1 | $07 ; STATUS REGISTER (R)
|
|
PPIDE_REG_CMD .EQU PPIDE_CTL_CS1 | $07 ; COMMAND REGISTER (EXECUTE) (W)
|
|
PPIDE_REG_ALTSTAT .EQU PPIDE_CTL_CS3 | $06 ; ALTERNATE STATUS REGISTER (R)
|
|
PPIDE_REG_CTRL .EQU PPIDE_CTL_CS3 | $06 ; DEVICE CONTROL REGISTER (W)
|
|
PPIDE_REG_DRVADR .EQU PPIDE_CTL_CS3 | $07 ; DRIVE ADDRESS REGISTER (R)
|
|
;
|
|
; COMMAND BYTES
|
|
;
|
|
PPIDE_CMD_RECAL .EQU $10
|
|
PPIDE_CMD_READ .EQU $20
|
|
PPIDE_CMD_WRITE .EQU $30
|
|
PPIDE_CMD_IDDEV .EQU $EC
|
|
PPIDE_CMD_SETFEAT .EQU $EF
|
|
;
|
|
; FEATURE BYTES
|
|
;
|
|
PPIDE_FEAT_ENABLE8BIT .EQU $01
|
|
PPIDE_FEAT_DISABLE8BIT .EQU $81
|
|
;
|
|
; PPIDE DEVICE TYPES
|
|
;
|
|
PPIDE_TYPEUNK .EQU 0
|
|
PPIDE_TYPEATA .EQU 1
|
|
PPIDE_TYPEATAPI .EQU 2
|
|
;
|
|
; PPIDE DEVICE STATUS CODES
|
|
;
|
|
PPIDE_STOK .EQU 0
|
|
PPIDE_STINVUNIT .EQU -1
|
|
PPIDE_STNOMEDIA .EQU -2
|
|
PPIDE_STCMDERR .EQU -3
|
|
PPIDE_STIOERR .EQU -4
|
|
PPIDE_STRDYTO .EQU -5
|
|
PPIDE_STDRQTO .EQU -6
|
|
PPIDE_STBSYTO .EQU -7
|
|
;
|
|
; DRIVE SELECTION BYTES (FOR USE IN DRIVE/HEAD REGISTER)
|
|
;
|
|
;PPIDE_DRVSEL:
|
|
PPIDE_DRVMASTER .EQU %11100000 ; LBA, MASTER DEVICE
|
|
PPIDE_DRVSLAVE .EQU %11110000 ; LBA, SLAVE DEVICE
|
|
;
|
|
; PPIDE DEVICE CONFIGURATION
|
|
;
|
|
PPIDE_CFGSIZ .EQU 18 ; SIZE OF CFG TBL ENTRIES
|
|
;
|
|
; PER DEVICE DATA OFFSETS
|
|
;
|
|
PPIDE_DEV .EQU 0 ; OFFSET OF DEVICE NUMBER (BYTE)
|
|
PPIDE_STAT .EQU 1 ; LAST STATUS (BYTE)
|
|
PPIDE_TYPE .EQU 2 ; DEVICE TYPE (BYTE)
|
|
PPIDE_ACC .EQU 3 ; ACCESS FLAG BITS BIT 0=MASTER, 1=8BIT (BYTE)
|
|
PPIDE_MED .EQU 4 ; MEDIA FLAG BITS BIT 0=CF, 1=LBA (BYTE)
|
|
PPIDE_MEDCAP .EQU 5 ; MEDIA CAPACITY (DWORD)
|
|
PPIDE_LBA .EQU 9 ; OFFSET OF LBA (DWORD)
|
|
PPIDE_DATALO .EQU 13 ; BASE PORT AND IDE DATA BUS LSB (8255 PORT A) (BYTE)
|
|
PPIDE_CTL .EQU 14 ; IDE ADDRESS BUS AND CONTROL SIGNALS (8255 PORT C)(BYTE)
|
|
PPIDE_PPI .EQU 15 ; 8255 CONTROL PORT(BYTE)
|
|
PPIDE_PARTNER .EQU 16 ; PARTNER DEVICE (MASTER <-> SLAVE) (WORD)
|
|
;
|
|
PPIDE_ACC_MAS .EQU %00000001 ; UNIT IS MASTER (ELSE SLAVE)
|
|
PPIDE_ACC_8BIT .EQU %00000010 ; UNIT WANTS 8 BIT I/O (ELSE 16 BIT)
|
|
;
|
|
PPIDE_MED_CF .EQU %00000001 ; MEDIA IS CF CARD
|
|
PPIDE_MED_LBA .EQU %00000010 ; MEDIA HAS LBA CAPABILITY
|
|
;
|
|
PPIDE_DEVCNT .EQU PPIDECNT * 2
|
|
;
|
|
PPIDE_CFGTBL:
|
|
;
|
|
#IF (PPIDECNT >= 1)
|
|
;
|
|
PPIDE_DEV0M: ; DEVICE 0, MASTER
|
|
.DB 0 ; DRIVER RELATIVE DEVICE NUMBER (ASSIGNED DURING INIT)
|
|
.DB 0 ; DEVICE STATUS
|
|
.DB 0 ; DEVICE TYPE
|
|
.DB PPIDE_ACC_MAS | (PPIDE0A8BIT & PPIDE_ACC_8BIT) ; UNIT ACCESS FLAGS
|
|
.DB 0 ; MEDIA FLAGS
|
|
.DW 0,0 ; DEVICE CAPACITY
|
|
.DW 0,0 ; CURRENT LBA
|
|
.DB PPIDE0BASE ; DATALO
|
|
.DB PPIDE0BASE+2 ; CTL
|
|
.DB PPIDE0BASE+3 ; PPI
|
|
.DW PPIDE_DEV0S ; PARTNER
|
|
;
|
|
PPIDE_DEV0S: ; DEVICE 0, SLAVE
|
|
.DB 0 ; DRIVER RELATIVE DEVICE NUMBER (ASSIGNED DURING INIT)
|
|
.DB 0 ; DEVICE STATUS
|
|
.DB 0 ; DEVICE TYPE
|
|
.DB (PPIDE0B8BIT & PPIDE_ACC_8BIT) ; UNIT ACCESS FLAGS
|
|
.DB 0 ; MEDIA FLAGS
|
|
.DW 0,0 ; DEVICE CAPACITY
|
|
.DW 0,0 ; CURRENT LBA
|
|
.DB PPIDE0BASE ; DATALO
|
|
.DB PPIDE0BASE+2 ; CTL
|
|
.DB PPIDE0BASE+3 ; PPI
|
|
.DW PPIDE_DEV0M ; PARTNER
|
|
;
|
|
#ENDIF
|
|
;
|
|
#IF (PPIDECNT >= 2)
|
|
;
|
|
PPIDE_DEV1M: ; DEVICE 1, MASTER
|
|
.DB 0 ; DRIVER RELATIVE DEVICE NUMBER (ASSIGNED DURING INIT)
|
|
.DB 0 ; DEVICE STATUS
|
|
.DB 0 ; DEVICE TYPE
|
|
.DB PPIDE_ACC_MAS | (PPIDE1A8BIT & PPIDE_ACC_8BIT) ; UNIT ACCESS FLAGS
|
|
.DB 0 ; MEDIA FLAGS
|
|
.DW 0,0 ; DEVICE CAPACITY
|
|
.DW 0,0 ; CURRENT LBA
|
|
.DB PPIDE1BASE ; DATALO
|
|
.DB PPIDE1BASE+2 ; CTL
|
|
.DB PPIDE1BASE+3 ; PPI
|
|
.DW PPIDE_DEV1S ; PARTNER
|
|
;
|
|
PPIDE_DEV1S: ; DEVICE 1, SLAVE
|
|
.DB 0 ; DRIVER RELATIVE DEVICE NUMBER (ASSIGNED DURING INIT)
|
|
.DB 0 ; DEVICE STATUS
|
|
.DB 0 ; DEVICE TYPE
|
|
.DB (PPIDE1B8BIT & PPIDE_ACC_8BIT) ; UNIT ACCESS FLAGS
|
|
.DB 0 ; MEDIA FLAGS
|
|
.DW 0,0 ; DEVICE CAPACITY
|
|
.DW 0,0 ; CURRENT LBA
|
|
.DB PPIDE1BASE ; DATALO
|
|
.DB PPIDE1BASE+2 ; CTL
|
|
.DB PPIDE1BASE+3 ; PPI
|
|
.DW PPIDE_DEV1M ; PARTNER
|
|
;
|
|
#ENDIF
|
|
;
|
|
#IF (PPIDECNT >= 3)
|
|
;
|
|
PPIDE_DEV2M: ; DEVICE 2, MASTER
|
|
.DB 0 ; DRIVER RELATIVE DEVICE NUMBER (ASSIGNED DURING INIT)
|
|
.DB 0 ; DEVICE STATUS
|
|
.DB 0 ; DEVICE TYPE
|
|
.DB PPIDE_ACC_MAS | (PPIDE2A8BIT & PPIDE_ACC_8BIT) ; UNIT ACCESS FLAGS
|
|
.DB 0 ; MEDIA FLAGS
|
|
.DW 0,0 ; DEVICE CAPACITY
|
|
.DW 0,0 ; CURRENT LBA
|
|
.DB PPIDE2BASE ; DATALO
|
|
.DB PPIDE2BASE+2 ; CTL
|
|
.DB PPIDE2BASE+3 ; PPI
|
|
.DW PPIDE_DEV2S ; PARTNER
|
|
;
|
|
PPIDE_DEV2S: ; DEVICE 2, SLAVE
|
|
.DB 0 ; DRIVER RELATIVE DEVICE NUMBER (ASSIGNED DURING INIT)
|
|
.DB 0 ; DEVICE STATUS
|
|
.DB 0 ; DEVICE TYPE
|
|
.DB (PPIDE2B8BIT & PPIDE_ACC_8BIT) ; UNIT ACCESS FLAGS
|
|
.DB 0 ; MEDIA FLAGS
|
|
.DW 0,0 ; DEVICE CAPACITY
|
|
.DW 0,0 ; CURRENT LBA
|
|
.DB PPIDE2BASE ; DATALO
|
|
.DB PPIDE2BASE+2 ; CTL
|
|
.DB PPIDE2BASE+3 ; PPI
|
|
.DW PPIDE_DEV2M ; PARTNER
|
|
;
|
|
#ENDIF
|
|
;
|
|
#IF ($ - PPIDE_CFGTBL) != (PPIDE_DEVCNT * PPIDE_CFGSIZ)
|
|
.ECHO "*** INVALID PPIDE CONFIG TABLE ***\n"
|
|
#ENDIF
|
|
;
|
|
.DB $FF ; END OF TABLE MARKER
|
|
;
|
|
; THE IDE_WAITXXX FUNCTIONS ARE BUILT TO TIMEOUT AS NEEDED SO DRIVER WILL
|
|
; NOT HANG IF DEVICE IS UNRESPONSIVE. DIFFERENT TIMEOUTS ARE USED DEPENDING
|
|
; ON THE SITUATION. GENERALLY, THE FAST TIMEOUT IS USED TO PROBE FOR DEVICES
|
|
; USING FUNCTIONS THAT PERFORM NO I/O. OTHERWISE THE NORMAL TIMEOUT IS USED.
|
|
; IDE SPEC ALLOWS FOR UP TO 30 SECS MAX TO RESPOND. IN PRACTICE, THIS IS WAY
|
|
; TOO LONG, BUT IF YOU ARE USING A VERY OLD DEVICE, THESE TIMEOUTS MAY NEED TO
|
|
; BE ADJUSTED. NOTE THAT THESE ARE BYTE VALUES, SO YOU CANNOT EXCEED 255.
|
|
; THE TIMEOUTS ARE IN UNITS OF .05 SECONDS.
|
|
;
|
|
PPIDE_TONORM .EQU 200 ; NORMAL TIMEOUT IS 10 SECS
|
|
PPIDE_TOFAST .EQU 10 ; FAST TIMEOUT IS 0.5 SECS
|
|
;
|
|
;=============================================================================
|
|
; INITIALIZATION ENTRY POINT
|
|
;=============================================================================
|
|
;
|
|
PPIDE_INIT:
|
|
; COMPUTE CPU SPEED COMPENSATED TIMEOUT SCALER
|
|
; AT 1MHZ, THE SCALER IS 218 (50000US / 229TS = 218)
|
|
; SCALER IS THEREFORE 218 * CPU SPEED IN MHZ
|
|
LD DE,218 ; LOAD SCALER FOR 1MHZ
|
|
LD A,(CB_CPUMHZ) ; LOAD CPU SPEED IN MHZ
|
|
CALL MULT8X16 ; HL := DE * A
|
|
LD (PPIDE_TOSCALER),HL ; SAVE IT
|
|
;
|
|
XOR A ; ZERO ACCUM
|
|
LD (PPIDE_DEVNUM),A ; INIT DEV UNIT NUM FOR DYNAMIC ASSIGNMENT
|
|
LD IY,PPIDE_CFGTBL ; POINT TO START OF CONFIG TABLE
|
|
;
|
|
PPIDE_INIT1:
|
|
LD A,(IY) ; LOAD FIRST BYTE TO CHECK FOR END
|
|
CP $FF ; CHECK FOR END OF TABLE VALUE
|
|
JR NZ,PPIDE_INIT2 ; IF NOT END OF TABLE, CONTINUE
|
|
XOR A ; SIGNAL SUCCESS
|
|
RET ; AND RETURN
|
|
;
|
|
PPIDE_INIT2:
|
|
BIT 0,(IY+PPIDE_ACC) ; MASTER?
|
|
JR Z,PPIDE_INIT4 ; IF NOT MASTER, SKIP AHEAD
|
|
;
|
|
CALL NEWLINE ; FORMATTING
|
|
PRTS("PPIDE:$") ; LABEL FOR IO ADDRESS
|
|
;
|
|
PRTS(" IO=0x$") ; LABEL FOR IO ADDRESS
|
|
LD A,(IY+PPIDE_DATALO) ; GET IO BASE ADDRES
|
|
CALL PRTHEXBYTE ; DISPLAY IT
|
|
;
|
|
CALL PPIDE_DETECT ; PROBE FOR INTERFACE
|
|
JR Z,PPIDE_INIT3 ; GOT IT, MOVE ON TO INIT UNITS
|
|
CALL PC_SPACE ; FORMATTING
|
|
LD DE,PPIDE_STR_NOPPI ; NO PPI MESSAGE
|
|
CALL WRITESTR ; DISPLAY IT
|
|
JR PPIDE_INIT4 ; SKIP CFG ENTRY
|
|
;
|
|
PPIDE_INIT3:
|
|
CALL PPIDE_RESET ; RESET THE BUS
|
|
CALL PPIDE_INIT5 ; DETECT/INIT MASTER
|
|
PUSH IY ; SAVE CFG PTR
|
|
CALL PPIDE_GOPARTNER ; SWITCH IY TO PARTNER CFG
|
|
CALL PPIDE_INIT5 ; DETECT/INIT SLAVE
|
|
POP IY ; RESTORE CFG PTR
|
|
;
|
|
PPIDE_INIT4:
|
|
LD DE,PPIDE_CFGSIZ ; SIZE OF CFG TABLE ENTRY
|
|
ADD IY,DE ; BUMP POINTER
|
|
JR PPIDE_INIT1 ; AND LOOP
|
|
;
|
|
PPIDE_INIT5:
|
|
; UPDATE DRIVER RELATIVE UNIT NUMBER IN CONFIG TABLE
|
|
LD A,(PPIDE_DEVNUM) ; GET NEXT UNIT NUM TO ASSIGN
|
|
LD (IY+PPIDE_DEV),A ; UPDATE IT
|
|
INC A ; BUMP TO NEXT UNIT NUM TO ASSIGN
|
|
LD (PPIDE_DEVNUM),A ; SAVE IT
|
|
;
|
|
; ADD UNIT TO GLOBAL DISK UNIT TABLE
|
|
LD BC,PPIDE_FNTBL ; BC := FUNC TABLE ADR
|
|
PUSH IY ; CFG ENTRY POINTER
|
|
POP DE ; COPY TO DE
|
|
CALL DIO_ADDENT ; ADD ENTRY TO GLOBAL DISK DEV TABLE
|
|
;
|
|
; CHECK FOR BAD STATUS
|
|
LD A,(IY+PPIDE_STAT) ; GET STATUS
|
|
OR A ; SET FLAGS
|
|
JP NZ,PPIDE_PRTSTAT ; EXIT VIA PRINT STATUS
|
|
;
|
|
CALL PPIDE_PRTPREFIX ; PRINT DEVICE PREFIX
|
|
;
|
|
LD DE,PPIDE_STR_8BIT
|
|
BIT 1,(IY+PPIDE_ACC) ; 8 BIT ACCESS?
|
|
CALL NZ,WRITESTR
|
|
;
|
|
; PRINT LBA/NOLBA
|
|
CALL PC_SPACE ; FORMATTING
|
|
BIT 1,(IY+PPIDE_MED) ; TEST LBA FLAG
|
|
LD DE,PPIDE_STR_NO ; POINT TO "NO" STRING
|
|
CALL Z,WRITESTR ; PRINT "NO" BEFORE "LBA" IF LBA NOT SUPPORTED
|
|
PRTS("LBA$") ; PRINT "LBA" REGARDLESS
|
|
;
|
|
; PRINT STORAGE CAPACITY (BLOCK COUNT)
|
|
PRTS(" BLOCKS=0x$") ; PRINT FIELD LABEL
|
|
LD A,PPIDE_MEDCAP ; OFFSET TO CAPACITY FIELD
|
|
CALL LDHLIYA ; HL := IY + A, REG A TRASHED
|
|
CALL LD32 ; GET THE CAPACITY VALUE
|
|
CALL PRTHEX32 ; PRINT HEX VALUE
|
|
;
|
|
; PRINT STORAGE SIZE IN MB
|
|
PRTS(" SIZE=$") ; PRINT FIELD LABEL
|
|
LD B,11 ; 11 BIT SHIFT TO CONVERT BLOCKS --> MB
|
|
CALL SRL32 ; RIGHT SHIFT
|
|
CALL PRTDEC ; PRINT LOW WORD IN DECIMAL (HIGH WORD DISCARDED)
|
|
PRTS("MB$") ; PRINT SUFFIX
|
|
;
|
|
RET
|
|
;
|
|
;----------------------------------------------------------------------
|
|
; PROBE FOR PPI HARDWARE
|
|
;----------------------------------------------------------------------
|
|
;
|
|
; ON RETURN, ZF SET INDICATES HARDWARE FOUND
|
|
;
|
|
PPIDE_DETECT:
|
|
;
|
|
; 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.
|
|
;
|
|
LD A,PPIDE_DIR_WRITE ; SET DATA BUS DIRECTION TO WRITE
|
|
LD C,(IY+PPIDE_PPI) ; PPI CONTROL WORD
|
|
OUT (C),A ; WRITE IT
|
|
;
|
|
LD C,(IY+PPIDE_DATALO) ; PPI PORT A, DATALO
|
|
XOR A ; VALUE ZERO
|
|
OUT (C),A ; PUSH VALUE TO PORT
|
|
IN A,(C) ; GET PORT VALUE
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PC_SPACE
|
|
CALL PRTHEXBYTE
|
|
#ENDIF
|
|
OR A ; SET FLAGS
|
|
RET ; AND RETURN
|
|
;
|
|
;=============================================================================
|
|
; DRIVER FUNCTION TABLE
|
|
;=============================================================================
|
|
;
|
|
PPIDE_FNTBL:
|
|
.DW PPIDE_STATUS
|
|
.DW PPIDE_RESET
|
|
.DW PPIDE_SEEK
|
|
.DW PPIDE_READ
|
|
.DW PPIDE_WRITE
|
|
.DW PPIDE_VERIFY
|
|
.DW PPIDE_FORMAT
|
|
.DW PPIDE_DEVICE
|
|
.DW PPIDE_MEDIA
|
|
.DW PPIDE_DEFMED
|
|
.DW PPIDE_CAP
|
|
.DW PPIDE_GEOM
|
|
#IF (($ - PPIDE_FNTBL) != (DIO_FNCNT * 2))
|
|
.ECHO "*** INVALID PPIDE FUNCTION TABLE ***\n"
|
|
#ENDIF
|
|
;
|
|
PPIDE_VERIFY:
|
|
PPIDE_FORMAT:
|
|
PPIDE_DEFMED:
|
|
CALL SYSCHK ; NOT IMPLEMENTED
|
|
LD A,ERR_NOTIMPL
|
|
OR A
|
|
RET
|
|
;
|
|
;
|
|
;
|
|
PPIDE_READ:
|
|
CALL HB_DSKREAD ; HOOK HBIOS DISK READ SUPERVISOR
|
|
LD BC,PPIDE_RDSEC ; GET ADR OF SECTOR READ FUNC
|
|
LD (PPIDE_IOFNADR),BC ; SAVE IT AS PENDING IO FUNC
|
|
JR PPIDE_IO ; CONTINUE TO GENERIC IO ROUTINE
|
|
;
|
|
;
|
|
;
|
|
PPIDE_WRITE:
|
|
CALL HB_DSKWRITE ; HOOK HBIOS DISK WRITE SUPERVISOR
|
|
LD BC,PPIDE_WRSEC ; GET ADR OF SECTOR WRITE FUNC
|
|
LD (PPIDE_IOFNADR),BC ; SAVE IT AS PENDING IO FUNC
|
|
JR PPIDE_IO ; CONTINUE TO GENERIC IO ROUTINE
|
|
;
|
|
;
|
|
;
|
|
PPIDE_IO:
|
|
LD (PPIDE_DSKBUF),HL ; SAVE DISK BUFFER ADDRESS
|
|
LD A,E ; BLOCK COUNT TO A
|
|
OR A ; SET FLAGS
|
|
RET Z ; ZERO SECTOR I/O, RETURN W/ E=0 & A=0
|
|
LD B,A ; INIT SECTOR DOWNCOUNTER
|
|
LD C,0 ; INIT SECTOR READ/WRITE COUNT
|
|
#IF (PPIDETRACE == 1)
|
|
LD HL,PPIDE_PRTERR ; SET UP PPIDE_PRTERR
|
|
PUSH HL ; ... TO FILTER ALL EXITS
|
|
#ENDIF
|
|
PUSH BC ; SAVE COUNTERS
|
|
CALL PPIDE_SELUNIT ; HARDWARE SELECTION OF TARGET UNIT
|
|
CALL PPIDE_CHKERR ; CHECK FOR ERR STATUS AND RESET IF SO
|
|
POP BC ; RESTORE COUNTERS
|
|
JR NZ,PPIDE_IO3 ; BAIL OUT ON ERROR
|
|
PPIDE_IO1:
|
|
PUSH BC ; SAVE COUNTERS
|
|
LD HL,(PPIDE_IOFNADR) ; GET PENDING IO FUNCTION ADDRESS
|
|
CALL JPHL ; ... AND CALL IT
|
|
JR NZ,PPIDE_IO2 ; IF ERROR, SKIP INCREMENT
|
|
; INCREMENT LBA
|
|
LD A,PPIDE_LBA ; LBA OFFSET
|
|
CALL LDHLIYA ; HL := IY + A, REG A TRASHED
|
|
CALL INC32HL ; INCREMENT THE VALUE
|
|
; INCREMENT DMA
|
|
LD HL,PPIDE_DSKBUF+1 ; POINT TO MSB OF BUFFER ADR
|
|
INC (HL) ; BUMP DMA BY
|
|
INC (HL) ; ... 512 BYTES
|
|
XOR A ; SIGNAL SUCCESS
|
|
PPIDE_IO2:
|
|
POP BC ; RECOVER COUNTERS
|
|
JR NZ,PPIDE_IO3 ; IF ERROR, BAIL OUT
|
|
INC C ; BUMP COUNT OF SECTORS READ
|
|
DJNZ PPIDE_IO1 ; LOOP AS NEEDED
|
|
PPIDE_IO3:
|
|
LD E,C ; SECTOR READ COUNT TO E
|
|
LD HL,(PPIDE_DSKBUF) ; CURRENT DMA TO HL
|
|
OR A ; SET FLAGS BASED ON RETURN CODE
|
|
RET Z ; RETURN IF SUCCESS
|
|
LD A,ERR_IO ; SIGNAL IO ERROR
|
|
OR A ; SET FLAGS
|
|
RET ; AND DONE
|
|
;
|
|
;
|
|
;
|
|
PPIDE_STATUS:
|
|
; RETURN UNIT STATUS
|
|
LD A,(IY+PPIDE_STAT) ; GET STATUS OF SELECTED DEVICE
|
|
OR A ; SET FLAGS
|
|
RET ; AND RETURN
|
|
;
|
|
;
|
|
;
|
|
PPIDE_DEVICE:
|
|
LD D,DIODEV_PPIDE ; D := DEVICE TYPE
|
|
LD E,(IY+PPIDE_DEV) ; E := PHYSICAL DEVICE NUMBER
|
|
BIT 0,(IY+PPIDE_MED) ; TEST CF BIT IN FLAGS
|
|
LD C,%00000000 ; ASSUME NON-REMOVABLE HARD DISK
|
|
JR Z,PPIDE_DEVICE1 ; IF Z, WE ARE DONE
|
|
LD C,%01001000 ; OTHERWISE REMOVABLE COMPACT FLASH
|
|
PPIDE_DEVICE1:
|
|
LD H,0 ; H := 0, DRIVER HAS NO MODES
|
|
LD L,(IY+PPIDE_DATALO) ; L := BASE I/O ADDRESS
|
|
XOR A ; SIGNAL SUCCESS
|
|
RET
|
|
;
|
|
; IDE_GETMED
|
|
;
|
|
PPIDE_MEDIA:
|
|
LD A,E ; GET FLAGS
|
|
OR A ; SET FLAGS
|
|
JR Z,PPIDE_MEDIA2 ; JUST REPORT CURRENT STATUS AND MEDIA
|
|
;
|
|
; GET CURRENT STATUS
|
|
LD A,(IY+PPIDE_STAT) ; GET STATUS
|
|
OR A ; SET FLAGS
|
|
JR NZ,PPIDE_MEDIA1 ; ERROR ACTIVE, GO RIGHT TO RESET
|
|
;
|
|
; USE IDENTIFY COMMAND TO CHECK DEVICE
|
|
LD HL,PPIDE_TIMEOUT ; POINT TO TIMEOUT
|
|
LD (HL),PPIDE_TOFAST ; USE FAST TIMEOUT DURING IDENTIFY COMMAND
|
|
CALL PPIDE_SELUNIT ; HARDWARE SELECTION OF TARGET UNIT
|
|
CALL PPIDE_IDENTIFY ; EXECUTE IDENTIFY COMMAND
|
|
LD HL,PPIDE_TIMEOUT ; POINT TO TIMEOUT
|
|
LD (HL),PPIDE_TONORM ; BACK TO NORMAL TIMEOUT
|
|
JR Z,PPIDE_MEDIA2 ; IF SUCCESS, BYPASS RESET
|
|
;
|
|
PPIDE_MEDIA1:
|
|
CALL PPIDE_RESET ; RESET IDE INTERFACE
|
|
;
|
|
PPIDE_MEDIA2:
|
|
LD A,(IY+PPIDE_STAT) ; GET STATUS
|
|
OR A ; SET FLAGS
|
|
LD D,0 ; NO MEDIA CHANGE DETECTED
|
|
LD E,MID_HD ; ASSUME WE ARE OK
|
|
RET Z ; RETURN IF GOOD INIT
|
|
LD E,MID_NONE ; SIGNAL NO MEDIA
|
|
LD A,ERR_NOMEDIA ; NO MEDIA ERROR
|
|
OR A ; SET FLAGS
|
|
RET ; AND RETURN
|
|
;
|
|
;
|
|
;
|
|
PPIDE_SEEK:
|
|
BIT 7,D ; CHECK FOR LBA FLAG
|
|
CALL Z,HB_CHS2LBA ; CLEAR MEANS CHS, CONVERT TO LBA
|
|
RES 7,D ; CLEAR FLAG REGARDLESS (DOES NO HARM IF ALREADY LBA)
|
|
LD (IY+PPIDE_LBA+0),L ; SAVE NEW LBA
|
|
LD (IY+PPIDE_LBA+1),H ; ...
|
|
LD (IY+PPIDE_LBA+2),E ; ...
|
|
LD (IY+PPIDE_LBA+3),D ; ...
|
|
XOR A ; SIGNAL SUCCESS
|
|
RET ; AND RETURN
|
|
;
|
|
;
|
|
;
|
|
PPIDE_CAP:
|
|
LD A,(IY+PPIDE_STAT) ; GET STATUS
|
|
PUSH AF ; SAVE IT
|
|
LD A,PPIDE_MEDCAP ; OFFSET TO CAPACITY FIELD
|
|
CALL LDHLIYA ; HL := IY + A, REG A TRASHED
|
|
CALL LD32 ; GET THE CURRENT CAPACITY INTO DE:HL
|
|
LD BC,512 ; 512 BYTES PER BLOCK
|
|
POP AF ; RECOVER STATUS
|
|
OR A ; SET FLAGS
|
|
RET
|
|
;
|
|
;
|
|
;
|
|
PPIDE_GEOM:
|
|
; FOR LBA, WE SIMULATE CHS ACCESS USING 16 HEADS AND 16 SECTORS
|
|
; RETURN HS:CC -> DE:HL, SET HIGH BIT OF D TO INDICATE LBA CAPABLE
|
|
CALL PPIDE_CAP ; GET TOTAL BLOCKS IN DE:HL, BLOCK SIZE TO BC
|
|
LD L,H ; DIVPPIDE BY 256 FOR # TRACKS
|
|
LD H,E ; ... HIGH BYTE DISCARDED, RESULT IN HL
|
|
LD D,16 | $80 ; HEADS / CYL = 16, SET LBA CAPABILITY BIT
|
|
LD E,16 ; SECTORS / TRACK = 16
|
|
RET ; DONE, A STILL HAS PPIDE_CAP STATUS
|
|
;
|
|
;=============================================================================
|
|
; FUNCTION SUPPORT ROUTINES
|
|
;=============================================================================
|
|
;
|
|
;
|
|
;
|
|
PPIDE_SETFEAT:
|
|
PUSH AF
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PPIDE_PRTPREFIX
|
|
PRTS(" SETFEAT$")
|
|
#ENDIF
|
|
LD A,(PPIDE_DRVHD)
|
|
;OUT (PPIDE_REG_DRVHD),A
|
|
CALL PPIDE_OUT
|
|
.DB PPIDE_REG_DRVHD
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PC_SPACE
|
|
CALL PRTHEXBYTE
|
|
#ENDIF
|
|
POP AF
|
|
;OUT (PPIDE_REG_FEAT),A ; SET THE FEATURE VALUE
|
|
CALL PPIDE_OUT
|
|
.DB PPIDE_REG_FEAT
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PC_SPACE
|
|
CALL PRTHEXBYTE
|
|
#ENDIF
|
|
LD A,PPIDE_CMD_SETFEAT ; CMD = SETFEAT
|
|
LD (PPIDE_CMD),A ; SAVE IT
|
|
JP PPIDE_RUNCMD ; RUN COMMAND AND EXIT
|
|
;
|
|
;
|
|
;
|
|
PPIDE_IDENTIFY:
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PPIDE_PRTPREFIX
|
|
PRTS(" IDDEV$")
|
|
#ENDIF
|
|
LD A,(PPIDE_DRVHD)
|
|
;OUT (PPIDE_REG_DRVHD),A
|
|
CALL PPIDE_OUT
|
|
.DB PPIDE_REG_DRVHD
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PC_SPACE
|
|
CALL PRTHEXBYTE
|
|
#ENDIF
|
|
LD A,PPIDE_CMD_IDDEV
|
|
LD (PPIDE_CMD),A
|
|
CALL PPIDE_RUNCMD
|
|
RET NZ
|
|
LD HL,HB_WRKBUF
|
|
JP PPIDE_GETBUF ; EXIT THRU BUFRD
|
|
;
|
|
;
|
|
;
|
|
PPIDE_RDSEC:
|
|
;
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PPIDE_PRTPREFIX
|
|
PRTS(" READ$")
|
|
#ENDIF
|
|
LD A,(PPIDE_DRVHD)
|
|
;OUT (PPIDE_REG_DRVHD),A
|
|
CALL PPIDE_OUT
|
|
.DB PPIDE_REG_DRVHD
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PC_SPACE
|
|
CALL PRTHEXBYTE
|
|
#ENDIF
|
|
CALL PPIDE_SETADDR ; SETUP CYL, TRK, HEAD
|
|
LD A,PPIDE_CMD_READ
|
|
LD (PPIDE_CMD),A
|
|
CALL PPIDE_RUNCMD
|
|
RET NZ
|
|
LD HL,(PPIDE_DSKBUF)
|
|
JP PPIDE_GETBUF
|
|
;
|
|
;
|
|
;
|
|
PPIDE_WRSEC:
|
|
;
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PPIDE_PRTPREFIX
|
|
PRTS(" WRITE$")
|
|
#ENDIF
|
|
LD A,(PPIDE_DRVHD)
|
|
;OUT (PPIDE_REG_DRVHD),A
|
|
CALL PPIDE_OUT
|
|
.DB PPIDE_REG_DRVHD
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PC_SPACE
|
|
CALL PRTHEXBYTE
|
|
#ENDIF
|
|
CALL PPIDE_SETADDR ; SETUP CYL, TRK, HEAD
|
|
LD A,PPIDE_CMD_WRITE
|
|
LD (PPIDE_CMD),A
|
|
CALL PPIDE_RUNCMD
|
|
RET NZ
|
|
LD HL,(PPIDE_DSKBUF)
|
|
JP PPIDE_PUTBUF
|
|
;
|
|
;
|
|
;
|
|
PPIDE_SETADDR:
|
|
; SEND 3 LOWEST BYTES OF LBA IN REVERSE ORDER
|
|
; IDE_IO_LBA3 HAS ALREADY BEEN SET
|
|
; HSTLBA2-0 --> IDE_IO_LBA2-0
|
|
LD A,(IY+PPIDE_LBA+2)
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PC_SPACE
|
|
CALL PRTHEXBYTE
|
|
#ENDIF
|
|
CALL PPIDE_OUT
|
|
.DB PPIDE_REG_LBA2
|
|
;
|
|
LD A,(IY+PPIDE_LBA+1)
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PC_SPACE
|
|
CALL PRTHEXBYTE
|
|
#ENDIF
|
|
CALL PPIDE_OUT
|
|
.DB PPIDE_REG_LBA1
|
|
;
|
|
LD A,(IY+PPIDE_LBA+0)
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PC_SPACE
|
|
CALL PRTHEXBYTE
|
|
#ENDIF
|
|
CALL PPIDE_OUT
|
|
.DB PPIDE_REG_LBA0
|
|
;
|
|
LD A,1
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PC_SPACE
|
|
CALL PRTHEXBYTE
|
|
#ENDIF
|
|
CALL PPIDE_OUT
|
|
.DB PPIDE_REG_COUNT
|
|
;
|
|
#IF (DSKYENABLE)
|
|
CALL PPIDE_DSKY
|
|
#ENDIF
|
|
;
|
|
RET
|
|
;
|
|
;=============================================================================
|
|
; COMMAND PROCESSING
|
|
;=============================================================================
|
|
;
|
|
PPIDE_RUNCMD:
|
|
CALL PPIDE_WAITRDY ; WAIT FOR DRIVE READY
|
|
RET NZ ; BAIL OUT ON TIMEOUT
|
|
;
|
|
LD A,(PPIDE_CMD) ; GET THE COMMAND
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PC_SPACE
|
|
CALL PRTHEXBYTE
|
|
#ENDIF
|
|
;OUT (PPIDE_REG_CMD),A ; SEND IT (STARTS EXECUTION)
|
|
CALL PPIDE_OUT
|
|
.DB PPIDE_REG_CMD
|
|
#IF (PPIDETRACE >= 3)
|
|
PRTS(" -->$")
|
|
#ENDIF
|
|
;
|
|
CALL PPIDE_WAITBSY ; WAIT FOR DRIVE READY (COMMAND DONE)
|
|
RET NZ ; BAIL OUT ON TIMEOUT
|
|
;
|
|
CALL PPIDE_GETRES
|
|
JP NZ,PPIDE_CMDERR
|
|
RET
|
|
;
|
|
;
|
|
;
|
|
PPIDE_GETBUF:
|
|
#IF (PPIDETRACE >= 3)
|
|
PRTS(" GETBUF$")
|
|
#ENDIF
|
|
;
|
|
; WAIT FOR BUFFER
|
|
CALL PPIDE_WAITDRQ ; WAIT FOR BUFFER READY
|
|
RET NZ ; BAIL OUT IF TIMEOUT
|
|
;
|
|
; SETUP PPI TO READ
|
|
LD A,PPIDE_DIR_READ ; SET DATA BUS DIRECTION TO READ
|
|
;OUT (PPIDE_IO_PPI),A ; DO IT
|
|
LD C,(IY+PPIDE_PPI) ; PPI CONTROL WORD
|
|
OUT (C),A ; WRITE IT
|
|
;
|
|
; SELECT READ/WRITE IDE REGISTER
|
|
LD A,PPIDE_REG_DATA ; DATA REGISTER
|
|
;OUT (PPIDE_IO_CTL),A ; DO IT
|
|
LD C,(IY+PPIDE_CTL) ; SET IDE ADDRESS
|
|
OUT (C),A ; DO IT
|
|
LD E,A ; E := READ UNASSERTED
|
|
XOR PPIDE_CTL_DIOR ; SWAP THE READ LINE BIT
|
|
LD D,A ; D := READ ASSERTED
|
|
;
|
|
; LOOP SETUP
|
|
XOR A ; IMPORTANT, NEEDED FOR LOOP END COMPARISON
|
|
LD B,0 ; 256 ITERATIONS
|
|
LD C,(IY+PPIDE_CTL) ; SET IDE ADDRESS
|
|
;
|
|
BIT 1,(IY+PPIDE_ACC) ; 8 BIT?
|
|
JR Z,PPIDE_GETBUF1 ; IF NOT, DO 16 BIT
|
|
CALL PPIDE_GETBUF8 ; FIRST PASS (FIRST 256 BYTES)
|
|
CALL PPIDE_GETBUF8 ; SECOND PASS (LAST 256 BYTES)
|
|
JR PPIDE_GETBUF2 ; CONTINUE
|
|
PPIDE_GETBUF1:
|
|
CALL PPIDE_GETBUF16 ; FIRST PASS (FIRST 256 BYTES)
|
|
CALL PPIDE_GETBUF16 ; SECOND PASS (LAST 256 BYTES)
|
|
PPIDE_GETBUF2:
|
|
CALL PPIDE_WAITRDY ; PROBLEMS IF THIS IS REMOVED!
|
|
RET NZ
|
|
CALL PPIDE_GETRES
|
|
JP NZ,PPIDE_IOERR
|
|
RET
|
|
;
|
|
PPIDE_GETBUF8: ; 8 BIT WIDE READ LOOP
|
|
; ENTER W/ C = PPIDE_IO_CTL
|
|
OUT (C),D ; ASSERT READ
|
|
DEC C ; CTL -> MSB
|
|
DEC C ; MSB -> LSB
|
|
INI ; READ FROM LSB
|
|
INC C ; LSB -> MSB
|
|
INC C ; MSB -> CTL
|
|
OUT (C),E ; DEASSERT READ
|
|
CP B ; B == A == 0?
|
|
JR NZ,PPIDE_GETBUF8 ; LOOP UNTIL DONE
|
|
RET
|
|
;
|
|
PPIDE_GETBUF16: ; 16 BIT WIDE READ LOOP
|
|
; ENTER W/ C = PPIDE_IO_CTL
|
|
OUT (C),D ; ASSERT READ
|
|
DEC C ; CTL -> MSB
|
|
DEC C ; MSB -> LSB
|
|
INI ; READ FROM LSB
|
|
INC C ; LSB -> MSB
|
|
INI ; READ MSB FOR 16 BIT
|
|
INC C ; MSB -> CTL
|
|
OUT (C),E ; DEASSERT READ
|
|
CP B ; B == A == 0?
|
|
JR NZ,PPIDE_GETBUF16 ; LOOP UNTIL DONE
|
|
RET
|
|
;
|
|
;
|
|
;
|
|
PPIDE_PUTBUF:
|
|
#IF (PPIDETRACE >= 3)
|
|
PRTS(" PUTBUF$")
|
|
#ENDIF
|
|
;
|
|
; WAIT FOR BUFFER
|
|
CALL PPIDE_WAITDRQ ; WAIT FOR BUFFER READY
|
|
RET NZ ; BAIL OUT IF TIMEOUT
|
|
;
|
|
; SETUP PPI TO WRITE
|
|
LD A,PPIDE_DIR_WRITE ; SET DATA BUS DIRECTION TO WRITE
|
|
;OUT (PPIDE_IO_PPI),A ; DO IT
|
|
LD C,(IY+PPIDE_PPI) ; PPI CONTROL WORD
|
|
OUT (C),A ; WRITE IT
|
|
;
|
|
; SELECT READ/WRITE IDE REGISTER
|
|
LD A,PPIDE_REG_DATA ; DATA REGISTER
|
|
;OUT (PPIDE_IO_CTL),A ; DO IT
|
|
LD C,(IY+PPIDE_CTL) ; SET IDE ADDRESS
|
|
OUT (C),A ; DO IT
|
|
LD E,A ; E := WRITE UNASSERTED
|
|
XOR PPIDE_CTL_DIOW ; SWAP THE READ LINE BIT
|
|
LD D,A ; D := WRITE ASSERTED
|
|
;
|
|
; LOOP SETUP
|
|
XOR A ; IMPORTANT, NEEDED FOR LOOP END COMPARISON
|
|
LD B,0 ; 256 ITERATIONS
|
|
LD C,(IY+PPIDE_CTL) ; SET IDE ADDRESS
|
|
;
|
|
BIT 1,(IY+PPIDE_ACC) ; 8 BIT?
|
|
JR Z,PPIDE_PUTBUF1 ; IF NOT, DO 16 BIT
|
|
CALL PPIDE_PUTBUF8 ; FIRST PASS (FIRST 256 BYTES)
|
|
CALL PPIDE_PUTBUF8 ; SECOND PASS (LAST 256 BYTES)
|
|
JR PPIDE_PUTBUF2 ; CONTINUE
|
|
PPIDE_PUTBUF1:
|
|
CALL PPIDE_PUTBUF16 ; FIRST PASS (FIRST 256 BYTES)
|
|
CALL PPIDE_PUTBUF16 ; SECOND PASS (LAST 256 BYTES)
|
|
PPIDE_PUTBUF2:
|
|
CALL PPIDE_WAITRDY ; PROBLEMS IF THIS IS REMOVED!
|
|
RET NZ
|
|
CALL PPIDE_GETRES
|
|
JP NZ,PPIDE_IOERR
|
|
RET
|
|
;
|
|
PPIDE_PUTBUF8: ; 8 BIT WIDE WRITE LOOP
|
|
DEC C ; CTL -> MSB
|
|
DEC C ; MSB -> LSB
|
|
OUTI ; WRITE NEXT BYTE (LSB)
|
|
INC C ; LSB -> MSB
|
|
INC C ; MSB -> CTL
|
|
OUT (C),D ; ASSERT WRITE
|
|
OUT (C),E ; DEASSERT WRITE
|
|
CP B ; B == A == 0?
|
|
JR NZ,PPIDE_PUTBUF8 ; LOOP UNTIL DONE
|
|
RET
|
|
;
|
|
PPIDE_PUTBUF16: ; 16 BIT WIDE WRITE LOOP
|
|
DEC C ; CTL -> MSB
|
|
DEC C ; MSB -> LSB
|
|
OUTI ; WRITE NEXT BYTE (LSB)
|
|
INC C ; LSB -> MSB
|
|
OUTI ; WRITE NEXT BYTE (MSB)
|
|
INC C ; MSB -> CTL
|
|
OUT (C),D ; ASSERT WRITE
|
|
OUT (C),E ; DEASSERT WRITE
|
|
CP B ; B == A == 0?
|
|
JR NZ,PPIDE_PUTBUF16 ; LOOP UNTIL DONE
|
|
RET
|
|
;
|
|
;
|
|
;
|
|
PPIDE_GETRES:
|
|
;IN A,(PPIDE_REG_STAT) ; READ STATUS
|
|
CALL PPIDE_IN
|
|
.DB PPIDE_REG_STAT
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PC_SPACE
|
|
CALL PRTHEXBYTE
|
|
#ENDIF
|
|
AND %00000001 ; ERROR BIT SET?
|
|
RET Z ; NOPE, RETURN WITH ZF
|
|
;
|
|
;IN A,(PPIDE_REG_ERR) ; READ ERROR REGISTER
|
|
CALL PPIDE_IN
|
|
.DB PPIDE_REG_ERR
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PC_SPACE
|
|
CALL PRTHEXBYTE
|
|
#ENDIF
|
|
OR $FF ; FORCE NZ TO SIGNAL ERROR
|
|
RET ; RETURN
|
|
;
|
|
;=============================================================================
|
|
; HARDWARE INTERFACE ROUTINES
|
|
;=============================================================================
|
|
;
|
|
; SOFT RESET OF ALL DEVICES ON BUS
|
|
;
|
|
PPIDE_RESET:
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PPIDE_PRTPREFIX
|
|
PRTS(" RESET$")
|
|
#ENDIF
|
|
;
|
|
; OLDER CF CARDS DO NOT SEEM TO SET THE
|
|
; REGISTERS ON RESET, SO HERE WE FAKE THINGS BY
|
|
; SETTING THEM AS A RESET WOULD
|
|
#IF (PPIDETRACE >= 3)
|
|
PRTS(" FAKE$")
|
|
#ENDIF
|
|
XOR A
|
|
;OUT (IDE_IO_CYLLO),A
|
|
CALL PPIDE_OUT
|
|
.DB PPIDE_REG_CYLLO
|
|
;OUT (IDE_IO_CYLHI),A
|
|
CALL PPIDE_OUT
|
|
.DB PPIDE_REG_CYLHI
|
|
INC A
|
|
;OUT (IDE_IO_COUNT),A
|
|
CALL PPIDE_OUT
|
|
.DB PPIDE_REG_COUNT
|
|
;OUT (IDE_IO_SECT),A
|
|
CALL PPIDE_OUT
|
|
.DB PPIDE_REG_SECT
|
|
;
|
|
; SETUP PPI TO READ
|
|
LD A,PPIDE_DIR_READ ; SET DATA BUS DIRECTION TO READ
|
|
;OUT (PPIDE_IO_PPI),A ; DO IT
|
|
LD C,(IY+PPIDE_PPI) ; PPI CONTROL WORD
|
|
OUT (C),A ; WRITE IT
|
|
;
|
|
; PULSE IDE RESET LINE
|
|
LD A,PPIDE_CTL_RESET
|
|
;OUT (PPIDE_IO_CTL),A
|
|
LD C,(IY+PPIDE_CTL) ; SET IDE ADDRESS
|
|
OUT (C),A
|
|
LD DE,20
|
|
CALL VDELAY
|
|
XOR A
|
|
;OUT (PPIDE_IO_CTL),A
|
|
OUT (C),A
|
|
LD DE,20
|
|
CALL VDELAY
|
|
;
|
|
LD A,%00001010 ; SET ~IEN, NO INTERRUPTS
|
|
;OUT (PPIDE_REG_CTRL),A
|
|
CALL PPIDE_OUT
|
|
.DB PPIDE_REG_CTRL
|
|
;
|
|
; SPEC ALLOWS UP TO 450MS FOR DEVICES TO ASSERT THEIR PRESENCE
|
|
; VIA -DASP. I ENCOUNTER PROBLEMS LATER ON IF I DON'T WAIT HERE
|
|
; FOR THAT TO OCCUR. THUS FAR, IT APPEARS THAT 150MS IS SUFFICIENT
|
|
; FOR ANY DEVICE ENCOUNTERED. MAY NEED TO EXTEND BACK TO 500MS
|
|
; IF A SLOWER DEVICE IS ENCOUNTERED.
|
|
;
|
|
;LD DE,500000/16 ; ~500MS
|
|
LD DE,150000/16 ; ~???MS
|
|
CALL VDELAY
|
|
;
|
|
; INITIALIZE THE INDIVIDUAL UNITS (MASTER AND SLAVE).
|
|
; BASED ON TESTING, IT APPEARS THAT THE MASTER UNIT MUST
|
|
; BE DONE FIRST OR THIS BEHAVES BADLY.
|
|
PUSH IY ; SAVE CFG PTR
|
|
BIT 0,(IY+PPIDE_ACC) ; MASTER?
|
|
CALL Z,PPIDE_GOPARTNER ; IF NOT, SWITCH TO MASTER
|
|
CALL PPIDE_INITUNIT ; INIT CURRENT UNIT
|
|
CALL PPIDE_GOPARTNER ; POINT TO SLAVE
|
|
CALL PPIDE_INITUNIT ; INIT PARTNER UNIT
|
|
POP IY ; RECOVER ORIG CFG PTR
|
|
;
|
|
XOR A ; SIGNAL SUCCESS
|
|
RET ; AND DONE
|
|
;
|
|
;
|
|
;
|
|
PPIDE_INITUNIT:
|
|
CALL PPIDE_SELUNIT ; SELECT UNIT
|
|
RET NZ ; ABORT IF ERROR
|
|
|
|
LD HL,PPIDE_TIMEOUT ; POINT TO TIMEOUT
|
|
LD (HL),PPIDE_TONORM ; SET NORMAL TIMEOUT
|
|
|
|
CALL PPIDE_PROBE ; DO PROBE
|
|
RET NZ ; JUST RETURN IF NOTHING THERE
|
|
|
|
CALL PPIDE_INITDEV ; IF FOUND, ATTEMPT TO INIT DEVICE
|
|
RET ; DONE
|
|
;
|
|
; TAKE ANY ACTIONS REQUIRED TO SELECT DESIRED PHYSICAL UNIT
|
|
;
|
|
PPIDE_SELUNIT:
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PPIDE_PRTPREFIX
|
|
PRTS(" SELUNIT$")
|
|
#ENDIF
|
|
BIT 0,(IY+PPIDE_ACC) ; MASTER?
|
|
JR Z,PPIDE_SELUNIT1 ; HANDLE SLAVE
|
|
LD A,PPIDE_DRVMASTER ; MASTER
|
|
JR PPIDE_SELUNIT2
|
|
PPIDE_SELUNIT1:
|
|
LD A,PPIDE_DRVSLAVE ; SLAVE
|
|
PPIDE_SELUNIT2:
|
|
LD (PPIDE_DRVHD),A ; SAVE IT
|
|
XOR A ; SUCCESS
|
|
RET
|
|
;
|
|
;
|
|
;
|
|
PPIDE_PROBE:
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PPIDE_PRTPREFIX
|
|
PRTS(" PROBE$") ; LABEL FOR IO ADDRESS
|
|
#ENDIF
|
|
;
|
|
LD A,(PPIDE_DRVHD)
|
|
;OUT (IDE_IO_DRVHD),A
|
|
CALL PPIDE_OUT
|
|
.DB PPIDE_REG_DRVHD
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PC_SPACE
|
|
CALL PRTHEXBYTE
|
|
#ENDIF
|
|
|
|
CALL DELAY ; DELAY ~16US
|
|
;
|
|
; BELOW TESTS FOR EXISTENCE OF AN IDE CONTROLLER ON THE
|
|
; PPIDE INTERFACE. WE WRITE A VALUE OF ZERO FIRST SO THAT
|
|
; THE PPI BUS HOLD WILL RETURN A VALUE OF ZERO IF THERE IS
|
|
; NOTHING CONNECTED TO PPI PORT A. THEN WE READ THE STATUS
|
|
; REGISTER. IF AN IDE CONTROLLER IS THERE, IT SHOULD ALWAYS
|
|
; RETURN SOMETHING OTHER THAN ZERO. IF AN IDE CONTROLLER IS
|
|
; THERE, THEN THE VALUE WRITTEN TO PPI PORT A IS IGNORED
|
|
; BECAUSE THE WRITE SIGNAL IS NEVER PULSED.
|
|
XOR A
|
|
;OUT (PPIDE_IO_DATALO),A
|
|
LD C,(IY+PPIDE_DATALO) ; PPI PORT A, DATALO
|
|
OUT (C),A
|
|
; IN A,(PPIDE_REG_STAT) ; GET STATUS
|
|
CALL PPIDE_IN
|
|
.DB PPIDE_REG_STAT
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PC_SPACE
|
|
CALL PRTHEXBYTE
|
|
#ENDIF
|
|
OR A
|
|
JP Z,PPIDE_NOMEDIA
|
|
;
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PPIDE_REGDUMP
|
|
#ENDIF
|
|
;
|
|
;JR PPIDE_PROBE1 ; *DEBUG*
|
|
;
|
|
PPIDE_PROBE0:
|
|
CALL PPIDE_WAITBSY ; WAIT FOR BUSY TO CLEAR
|
|
JP NZ,PPIDE_NOMEDIA ; CONVERT TIMEOUT TO NO MEDIA AND RETURN
|
|
;
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PPIDE_REGDUMP
|
|
#ENDIF
|
|
;
|
|
; CHECK STATUS
|
|
; IN A,(PPIDE_REG_STAT) ; GET STATUS
|
|
CALL PPIDE_IN
|
|
.DB PPIDE_REG_STAT
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PC_SPACE
|
|
CALL PRTHEXBYTE ; IF DEBUG, PRINT STATUS
|
|
#ENDIF
|
|
OR A ; SET FLAGS TO TEST FOR ZERO
|
|
JP Z,PPIDE_NOMEDIA ; CONTINUE IF NON-ZERO
|
|
;
|
|
; CHECK SIGNATURE
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PC_SPACE
|
|
#ENDIF
|
|
;IN A,(PPIDE_REG_COUNT)
|
|
CALL PPIDE_IN
|
|
.DB PPIDE_REG_COUNT
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PRTHEXBYTE
|
|
#ENDIF
|
|
CP $01
|
|
JP NZ,PPIDE_NOMEDIA
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PC_SPACE
|
|
#ENDIF
|
|
;IN A,(PPIDE_REG_SECT)
|
|
CALL PPIDE_IN
|
|
.DB PPIDE_REG_SECT
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PRTHEXBYTE
|
|
#ENDIF
|
|
CP $01
|
|
JP NZ,PPIDE_NOMEDIA
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PC_SPACE
|
|
#ENDIF
|
|
;IN A,(PPIDE_REG_CYLLO)
|
|
CALL PPIDE_IN
|
|
.DB PPIDE_REG_CYLLO
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PRTHEXBYTE
|
|
#ENDIF
|
|
CP $00
|
|
JP NZ,PPIDE_NOMEDIA
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PC_SPACE
|
|
#ENDIF
|
|
;IN A,(PPIDE_REG_CYLHI)
|
|
CALL PPIDE_IN
|
|
.DB PPIDE_REG_CYLHI
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL PRTHEXBYTE
|
|
#ENDIF
|
|
CP $00
|
|
JP NZ,PPIDE_NOMEDIA
|
|
;
|
|
PPIDE_PROBE1:
|
|
; SIGNATURE MATCHES ATA DEVICE, RECORD TYPE AND RETURN SUCCESS
|
|
LD A,PPIDE_TYPEATA ; TYPE = ATA
|
|
LD (IY+PPIDE_TYPE),A ; SET IT IN INSTANCE DATA
|
|
XOR A ; SIGNAL SUCCESS
|
|
RET ; DONE, NOTE THAT A=0 AND Z IS SET
|
|
;
|
|
; (RE)INITIALIZE DEVICE
|
|
;
|
|
PPIDE_INITDEV:
|
|
;
|
|
LD A,(IY+PPIDE_TYPE) ; GET THE DEVICE TYPE
|
|
OR A ; SET FLAGS
|
|
JP Z,PPIDE_NOMEDIA ; EXIT SETTING NO MEDIA STATUS
|
|
;
|
|
BIT 1,(IY+PPIDE_ACC) ; 8 BIT ACCESS?
|
|
JR Z,PPIDE_INITDEV0 ; NO, DO 16 BIT INIT
|
|
LD A,PPIDE_FEAT_ENABLE8BIT ; FEATURE VALUE = ENABLE 8-BIT PIO
|
|
CALL PPIDE_SETFEAT ; SET FEATURE
|
|
RET NZ ; BAIL OUT ON ERROR
|
|
JR PPIDE_INITDEV00 ; CONTINUE
|
|
;
|
|
PPIDE_INITDEV0:
|
|
; "REAL" IDE DRIVES MAY NOT ACCEPT THE DISABLE8BIT FEATURE COMMAND,
|
|
; SO IT IS ONLY AN ERROR IF WE ARE ATTEMPTING TO ENABLE8BIT.
|
|
; CREDIT TO ED BRINDLEY FOR THIS CORRECTION. SO ERROR RETURN IGNORED HERE.
|
|
LD A,PPIDE_FEAT_DISABLE8BIT ; FEATURE VALUE = ENABLE 8-BIT PIO
|
|
CALL PPIDE_SETFEAT ; SET FEATURE, IGNORE ERRORS
|
|
;
|
|
PPIDE_INITDEV00:
|
|
;
|
|
CALL PPIDE_IDENTIFY ; EXECUTE PPIDENTIFY COMMAND
|
|
RET NZ ; BAIL OUT ON ERROR
|
|
;
|
|
LD DE,HB_WRKBUF ; POINT TO BUFFER
|
|
#IF (PPIDETRACE >= 3)
|
|
CALL DUMP_BUFFER ; DUMP IT IF DEBUGGING
|
|
#ENDIF
|
|
;
|
|
LD (IY+PPIDE_MED),0 ; CLEAR MEDIA FLAGS
|
|
;
|
|
; DETERMINE IF CF DEVICE
|
|
LD HL,HB_WRKBUF ; FIRST WORD OF IDENTIFY DATA HAS CF FLAG
|
|
LD A,$8A ; FIRST BYTE OF MARKER IS $8A
|
|
CP (HL) ; COMPARE
|
|
JR NZ,PPIDE_INITDEV1 ; IF NO MATCH, NOT CF
|
|
INC HL
|
|
LD A,$84 ; SECOND BYTE OF MARKER IS $84
|
|
CP (HL) ; COMPARE
|
|
JR NZ,PPIDE_INITDEV1 ; IF NOT MATCH, NOT CF
|
|
SET 0,(IY+PPIDE_MED) ; SET FLAGS BIT FOR CF MEDIA
|
|
;
|
|
PPIDE_INITDEV1:
|
|
; DETERMINE IF LBA CAPABLE
|
|
LD A,(HB_WRKBUF+98+1) ; GET BYTE WITH LBA BIT FROM BUFFER
|
|
BIT 1,A ; CHECK THE LBA BIT
|
|
JR Z,PPIDE_INITDEV2 ; NOT SET, BYPASS
|
|
SET 1,(IY+PPIDE_MED) ; SET FLAGS BIT FOR LBA
|
|
;
|
|
PPIDE_INITDEV2:
|
|
; GET DEVICE CAPACITY AND SAVE IT
|
|
LD A,PPIDE_MEDCAP ; OFFSET TO CAPACITY FIELD
|
|
CALL LDHLIYA ; HL := IY + A, REG A TRASHED
|
|
PUSH HL ; SAVE POINTER
|
|
LD HL,HB_WRKBUF ; POINT TO BUFFER START
|
|
LD A,120 ; OFFSET OF SECTOR COUNT
|
|
CALL ADDHLA ; POINT TO ADDRESS OF SECTOR COUNT
|
|
CALL LD32 ; LOAD IT TO DE:HL
|
|
POP BC ; RECOVER POINTER TO CAPACITY ENTRY
|
|
CALL ST32 ; SAVE CAPACITY
|
|
;
|
|
; RESET CARD STATUS TO 0 (OK)
|
|
XOR A ; A := 0 (STATUS = OK)
|
|
LD (IY+PPIDE_STAT),A ; SAVE IT
|
|
;
|
|
RET ; RETURN, A=0, Z SET
|
|
;
|
|
; SWITCH IY POINTER FROM CURRENT UNIT CFG TO PARTNER UNIT CFG
|
|
;
|
|
PPIDE_GOPARTNER:
|
|
PUSH HL ; SAVE HL
|
|
LD L,(IY+PPIDE_PARTNER) ; GET PARTNER ENTRY
|
|
LD H,(IY+PPIDE_PARTNER+1) ; ...
|
|
PUSH HL ; MOVE HL
|
|
POP IY ; ... TO IY
|
|
POP HL ; RESTORE INCOMING HL
|
|
RET ; AND DONE
|
|
;
|
|
; CHECK CURRENT DEVICE FOR ERROR STATUS AND ATTEMPT TO RECOVER
|
|
; VIA RESET IF DEVICE IS IN ERROR.
|
|
;
|
|
PPIDE_CHKERR:
|
|
LD A,(IY+PPIDE_STAT) ; GET STATUS
|
|
OR A ; SET FLAGS
|
|
CALL NZ,PPIDE_RESET ; IF ERROR STATUS, RESET BUS
|
|
RET
|
|
;
|
|
;
|
|
;
|
|
PPIDE_WAITRDY:
|
|
LD A,(PPIDE_TIMEOUT) ; GET TIMEOUT IN 0.05 SECS
|
|
LD B,A ; PUT IN OUTER LOOP VAR
|
|
PPIDE_WAITRDY1:
|
|
LD DE,(PPIDE_TOSCALER) ; CPU SPEED SCALER TO INNER LOOP VAR
|
|
PPIDE_WAITRDY2:
|
|
;IN A,(PPIDE_REG_STAT) ; READ STATUS
|
|
CALL PPIDE_IN
|
|
.DB PPIDE_REG_STAT
|
|
LD C,A ; SAVE IT
|
|
AND %11000000 ; ISOLATE BUSY AND RDY BITS
|
|
XOR %01000000 ; WE WANT BUSY(7) TO BE 0 AND RDY(6) TO BE 1
|
|
RET Z ; ALL SET, RETURN WITH Z SET
|
|
DEC DE
|
|
LD A,D
|
|
OR E
|
|
JR NZ,PPIDE_WAITRDY2 ; INNER LOOP RETURN
|
|
DJNZ PPIDE_WAITRDY1 ; OUTER LOOP RETURN
|
|
JP PPIDE_RDYTO ; EXIT WITH RDYTO ERR
|
|
;
|
|
;
|
|
;
|
|
PPIDE_WAITDRQ:
|
|
LD A,(PPIDE_TIMEOUT) ; GET TIMEOUT IN 0.05 SECS
|
|
LD B,A ; PUT IN OUTER LOOP VAR
|
|
PPIDE_WAITDRQ1:
|
|
LD DE,(PPIDE_TOSCALER) ; CPU SPEED SCALER TO INNER LOOP VAR
|
|
PPIDE_WAITDRQ2:
|
|
;IN A,(PPIDE_REG_STAT) ; READ STATUS
|
|
CALL PPIDE_IN
|
|
.DB PPIDE_REG_STAT
|
|
LD C,A ; SAVE IT
|
|
AND %10001000 ; TO FILL (OR READY TO FILL)
|
|
XOR %00001000
|
|
RET Z
|
|
DEC DE
|
|
LD A,D
|
|
OR E
|
|
JR NZ,PPIDE_WAITDRQ2
|
|
DJNZ PPIDE_WAITDRQ1
|
|
JP PPIDE_DRQTO ; EXIT WITH BUFTO ERR
|
|
;
|
|
;
|
|
;
|
|
PPIDE_WAITBSY:
|
|
LD A,(PPIDE_TIMEOUT) ; GET TIMEOUT IN 0.05 SECS
|
|
LD B,A ; PUT IN OUTER LOOP VAR
|
|
PPIDE_WAITBSY1:
|
|
LD DE,(PPIDE_TOSCALER) ; CPU SPEED SCALER TO INNER LOOP VAR
|
|
PPIDE_WAITBSY2:
|
|
;IN A,(PPIDE_REG_STAT) ; READ STATUS
|
|
CALL PPIDE_IN ; 17TS + 170TS
|
|
.DB PPIDE_REG_STAT ; 0TS
|
|
LD C,A ; SAVE IT ; 4TS
|
|
AND %10000000 ; TO FILL (OR READY TO FILL) ; 7TS
|
|
RET Z ; 5TS
|
|
DEC DE ; 6TS
|
|
LD A,D ; 4TS
|
|
OR E ; 4TS
|
|
JR NZ,PPIDE_WAITBSY2 ; 12TS
|
|
DJNZ PPIDE_WAITBSY1 ; -----
|
|
JP PPIDE_BSYTO ; EXIT WITH BSYTO ERR ; 229TS
|
|
;
|
|
; READ A VALUE FROM THE DEVICE POINTED TO BY IY AND RETURN IT IN A
|
|
;
|
|
PPIDE_IN:
|
|
EX (SP),HL ; GET PARM POINTER ; 19TS
|
|
PUSH BC ; SAVE INCOMING BC ; 11TS
|
|
LD A,PPIDE_DIR_READ ; SET DATA BUS DIRECTION TO READ ; 7TS
|
|
;OUT (PPIDE_IO_PPI),A ; DO IT ; 11TS
|
|
LD C,(IY+PPIDE_PPI) ; PPI CONTROL WORD
|
|
OUT (C),A ; WRITE IT
|
|
;
|
|
LD B,(HL) ; GET CTL PORT VALUE ; 7TS
|
|
;LD C,PPIDE_IO_CTL ; SETUP PORT TO WRITE ; 7TS
|
|
;LD C,(IY+PPIDE_CTL) ; SET IDE ADDRESS
|
|
DEC C ; SET IDE ADDRESS
|
|
OUT (C),B ; SET ADDRESS LINES ; 12TS
|
|
SET 6,B ; TURN ON READ BIT ; 8TS
|
|
OUT (C),B ; ASSERT READ LINE ; 12TS
|
|
;
|
|
;IN A,(PPIDE_IO_DATALO) ; GET DATA VALUE FROM DEVICE ; 11TS
|
|
DEC C
|
|
DEC C
|
|
IN A,(C) ; GET DATA VALUE FROM DEVICE
|
|
INC C
|
|
INC C
|
|
;
|
|
RES 6,B ; CLEAR READ BIT ; 8TS
|
|
OUT (C),B ; DEASSERT READ LINE ; 12TS
|
|
POP BC ; RECOVER INCOMING BC ; 10TS
|
|
INC HL ; POINT PAST PARM ; 6TS
|
|
EX (SP),HL ; RESTORE STACK ; 19TS
|
|
RET ; 10TS
|
|
;
|
|
; OUTPUT VALUE IN A TO THE DEVICE POINTED TO BY IY
|
|
;
|
|
PPIDE_OUT:
|
|
; *** TODO *** FIX ORDER OF SET/CLEAR WRITE LINE
|
|
EX (SP),HL ; GET PARM POINTER
|
|
PUSH BC ; SAVE INCOMING BC
|
|
PUSH AF ; PRESERVE INCOMING VALUE
|
|
LD A,PPIDE_DIR_WRITE ; SET DATA BUS DIRECTION TO WRITE
|
|
;OUT (PPIDE_IO_PPI),A ; DO IT
|
|
LD C,(IY+PPIDE_PPI) ; PPI CONTROL WORD
|
|
OUT (C),A ; WRITE IT
|
|
POP AF ; RECOVER VALUE TO WRITE
|
|
;
|
|
LD B,(HL) ; GET IDE ADDRESS VALUE
|
|
;LD C,PPIDE_IO_CTL ; SETUP PORT TO WRITE
|
|
;LD C,(IY+PPIDE_CTL) ; SET IDE ADDRESS
|
|
DEC C ; SET IDE ADDRESS
|
|
OUT (C),B ; SET ADDRESS LINES
|
|
SET 5,B ; TURN ON WRITE BIT
|
|
OUT (C),B ; ASSERT WRITE LINE
|
|
;
|
|
DEC C
|
|
DEC C
|
|
;OUT (PPIDE_IO_DATALO),A ; SEND DATA VALUE TO DEVICE
|
|
OUT (C),A ; SEND DATA VALUE TO DEVICE
|
|
INC C
|
|
INC C
|
|
;
|
|
RES 5,B ; CLEAR WRITE BIT
|
|
OUT (C),B ; DEASSERT WRITE LINE
|
|
POP BC ; RECOVER INCOMING BC
|
|
INC HL ; POINT PAST PARM
|
|
EX (SP),HL ; RESTORE STACK
|
|
RET
|
|
;
|
|
;=============================================================================
|
|
; ERROR HANDLING AND DIAGNOSTICS
|
|
;=============================================================================
|
|
;
|
|
; ERROR HANDLERS
|
|
;
|
|
PPIDE_INVUNIT:
|
|
LD A,PPIDE_STINVUNIT
|
|
JR PPIDE_ERR2 ; SPECIAL CASE FOR INVALID UNIT
|
|
;
|
|
PPIDE_NOMEDIA:
|
|
LD A,PPIDE_STNOMEDIA
|
|
JR PPIDE_ERR
|
|
;
|
|
PPIDE_CMDERR:
|
|
LD A,PPIDE_STCMDERR
|
|
JR PPIDE_ERR
|
|
;
|
|
PPIDE_IOERR:
|
|
LD A,PPIDE_STIOERR
|
|
JR PPIDE_ERR
|
|
;
|
|
PPIDE_RDYTO:
|
|
LD A,PPIDE_STRDYTO
|
|
JR PPIDE_ERR
|
|
;
|
|
PPIDE_DRQTO:
|
|
LD A,PPIDE_STDRQTO
|
|
JR PPIDE_ERR
|
|
;
|
|
PPIDE_BSYTO:
|
|
LD A,PPIDE_STBSYTO
|
|
JR PPIDE_ERR
|
|
;
|
|
PPIDE_ERR:
|
|
LD (IY+PPIDE_STAT),A ; SAVE NEW STATUS
|
|
;
|
|
PPIDE_ERR2:
|
|
#IF (PPIDETRACE >= 2)
|
|
CALL PPIDE_PRTSTAT
|
|
CALL PPIDE_REGDUMP
|
|
#ENDIF
|
|
OR A ; SET FLAGS
|
|
RET
|
|
;
|
|
;
|
|
;
|
|
PPIDE_PRTERR:
|
|
RET Z ; DONE IF NO ERRORS
|
|
; FALL THRU TO PPIDE_PRTSTAT
|
|
;
|
|
; PRINT STATUS STRING (STATUS NUM IN A)
|
|
;
|
|
PPIDE_PRTSTAT:
|
|
PUSH AF
|
|
PUSH DE
|
|
PUSH HL
|
|
OR A
|
|
LD DE,PPIDE_STR_STOK
|
|
JR Z,PPIDE_PRTSTAT1
|
|
INC A
|
|
LD DE,PPIDE_STR_STINVUNIT
|
|
JR Z,PPIDE_PRTSTAT2 ; INVALID UNIT IS SPECIAL CASE
|
|
INC A
|
|
LD DE,PPIDE_STR_STNOMEDIA
|
|
JR Z,PPIDE_PRTSTAT1
|
|
INC A
|
|
LD DE,PPIDE_STR_STCMDERR
|
|
JR Z,PPIDE_PRTSTAT1
|
|
INC A
|
|
LD DE,PPIDE_STR_STIOERR
|
|
JR Z,PPIDE_PRTSTAT1
|
|
INC A
|
|
LD DE,PPIDE_STR_STRDYTO
|
|
JR Z,PPIDE_PRTSTAT1
|
|
INC A
|
|
LD DE,PPIDE_STR_STDRQTO
|
|
JR Z,PPIDE_PRTSTAT1
|
|
INC A
|
|
LD DE,PPIDE_STR_STBSYTO
|
|
JR Z,PPIDE_PRTSTAT1
|
|
LD DE,PPIDE_STR_STUNK
|
|
PPIDE_PRTSTAT1:
|
|
CALL PPIDE_PRTPREFIX ; PRINT UNIT PREFIX
|
|
JR PPIDE_PRTSTAT3
|
|
PPIDE_PRTSTAT2:
|
|
CALL NEWLINE
|
|
PRTS("PPIDE:$") ; NO UNIT NUM IN PREFIX FOR INVALID UNIT
|
|
PPIDE_PRTSTAT3:
|
|
CALL PC_SPACE ; FORMATTING
|
|
CALL WRITESTR
|
|
POP HL
|
|
POP DE
|
|
POP AF
|
|
RET
|
|
;
|
|
; PRINT ALL REGISTERS DIRECTLY FROM DEVICE
|
|
; DEVICE MUST BE SELECTED PRIOR TO CALL
|
|
;
|
|
PPIDE_REGDUMP:
|
|
PUSH AF
|
|
PUSH BC
|
|
push DE
|
|
CALL PC_SPACE
|
|
CALL PC_LBKT
|
|
LD A,PPIDE_DIR_READ ; SET DATA BUS DIRECTION TO READ
|
|
;OUT (PPIDE_IO_PPI),A ; DO IT
|
|
LD C,(IY+PPIDE_PPI) ; PPI CONTROL WORD
|
|
OUT (C),A ; WRITE IT
|
|
LD C,(IY+PPIDE_CTL) ; SET IDE ADDRESS
|
|
LD E,PPIDE_REG_CMD
|
|
LD B,7
|
|
PPIDE_REGDUMP1:
|
|
LD A,E ; REGISTER ADDRESS
|
|
;OUT (PPIDE_IO_CTL),A ; SET IT
|
|
OUT (C),A ; REGISTER ADDRESS
|
|
XOR PPIDE_CTL_DIOR ; SET BIT TO ASSERT READ LINE
|
|
;OUT (PPIDE_IO_CTL),A ; ASSERT READ
|
|
OUT (C),A ; ASSERT READ
|
|
;IN A,(PPIDE_IO_DATALO) ; GET VALUE
|
|
DEC C ; CTL -> MSB
|
|
DEC C ; MSB -> LSB
|
|
IN A,(C) ; GET VALUE
|
|
INC C ; LSB -> MSB
|
|
INC C ; MSB -> CTL
|
|
CALL PRTHEXBYTE ; DISPLAY IT
|
|
;LD A,C ; RELOAD ADDRESS W/ READ UNASSERTED
|
|
;OUT (PPIDE_IO_CTL),A ; AND SET IT
|
|
OUT (C),E ; RELOAD ADDRESS W/ READ UNASSERTED
|
|
;DEC C ; NEXT LOWER REGISTER
|
|
DEC E ; NEXT LOWER REGISTER
|
|
DEC B ; DEC LOOP COUNTER
|
|
CALL NZ,PC_SPACE ; FORMATTING
|
|
JR NZ,PPIDE_REGDUMP1 ; LOOP AS NEEDED
|
|
CALL PC_RBKT ; FORMATTING
|
|
POP DE
|
|
POP BC
|
|
POP AF
|
|
RET
|
|
;
|
|
; PRINT DIAGNONSTIC PREFIX
|
|
;
|
|
PPIDE_PRTPREFIX:
|
|
PUSH AF
|
|
CALL NEWLINE
|
|
PRTS("PPIDE$")
|
|
LD A,(IY+PPIDE_DEV) ; GET CURRENT DEVICE NUM
|
|
ADD A,'0'
|
|
CALL COUT
|
|
CALL PC_COLON
|
|
POP AF
|
|
RET
|
|
;
|
|
;
|
|
;
|
|
#IF (DSKYENABLE)
|
|
PPIDE_DSKY:
|
|
LD HL,DSKY_HEXBUF ; POINT TO DSKY BUFFER
|
|
CALL PPIDE_IN
|
|
.DB PPIDE_REG_DRVHD
|
|
LD (HL),A ; SAVE IN BUFFER
|
|
INC HL ; INCREMENT BUFFER POINTER
|
|
CALL PPIDE_IN
|
|
.DB PPIDE_REG_CYLHI
|
|
LD (HL),A ; SAVE IN BUFFER
|
|
INC HL ; INCREMENT BUFFER POINTER
|
|
CALL PPIDE_IN
|
|
.DB PPIDE_REG_CYLLO
|
|
LD (HL),A ; SAVE IN BUFFER
|
|
INC HL ; INCREMENT BUFFER POINTER
|
|
CALL PPIDE_IN
|
|
.DB PPIDE_REG_SECT
|
|
LD (HL),A ; SAVE IN BUFFER
|
|
CALL DSKY_HEXOUT ; SEND IT TO DSKY
|
|
RET
|
|
#ENDIF
|
|
;
|
|
;=============================================================================
|
|
; STRING DATA
|
|
;=============================================================================
|
|
;
|
|
PPIDE_STR_STOK .TEXT "OK$"
|
|
PPIDE_STR_STINVUNIT .TEXT "INVALID UNIT$"
|
|
PPIDE_STR_STNOMEDIA .TEXT "NO MEDIA$"
|
|
PPIDE_STR_STCMDERR .TEXT "COMMAND ERROR$"
|
|
PPIDE_STR_STIOERR .TEXT "IO ERROR$"
|
|
PPIDE_STR_STRDYTO .TEXT "READY TIMEOUT$"
|
|
PPIDE_STR_STDRQTO .TEXT "DRQ TIMEOUT$"
|
|
PPIDE_STR_STBSYTO .TEXT "BUSY TIMEOUT$"
|
|
PPIDE_STR_STUNK .TEXT "UNKNOWN ERROR$"
|
|
;
|
|
PPIDE_STR_NO .TEXT "NO$"
|
|
PPIDE_STR_NOPPI .TEXT "PPI NOT PRESENT$"
|
|
PPIDE_STR_8BIT .TEXT " 8-BIT$"
|
|
;
|
|
;=============================================================================
|
|
; DATA STORAGE
|
|
;=============================================================================
|
|
;
|
|
PPIDE_TIMEOUT .DB PPIDE_TONORM ; WAIT FUNCS TIMEOUT IN TENTHS OF SEC
|
|
PPIDE_TOSCALER .DW CPUMHZ * 218 ; WAIT FUNCS SCALER FOR CPU SPEED
|
|
;
|
|
PPIDE_CMD .DB 0 ; PENDING COMMAND TO PROCESS
|
|
PPIDE_IOFNADR .DW 0 ; PENDING IO FUNCTION ADDRESS
|
|
PPIDE_DRVHD .DB 0 ; CURRENT DRIVE/HEAD MASK
|
|
;
|
|
PPIDE_DSKBUF .DW 0 ; ACTIVE DISK BUFFER
|
|
;
|
|
PPIDE_DEVNUM .DB 0 ; TEMP DEVICE NUM USED DURING INIT
|
|
|