TITLE	DISK - MS-DOS 4.0 disk drivers for IBM
NAME	DISK

	PAGE	,132

;DEBUGFLG=1

.xlist
	INCLUDE DEFDBUG.INC
.list

; Constants

ErrLim=		5			; Number of retries on error

; Floppy delay constants

DelayLoad=	35			; 35 milliseconds to load head

; Constants for floppy disk controller

Rate99=		000H		; Step rate 96tpi disk in 96tpi drive
Rate49=		001H		; Step rate 48tpi disk in 96tpi drive
Rate44=		002H		; Step rate 48tpi disk in 48tpi drive

; Commands to floppy disk controller

FD_CRESET=	007H		; Recalibrate drive
FD_CSENSE=	008H		; Sense interrupt status
FD_CSEEK=	00FH		; Seek to another track
FD_CREAD=	046H		; MFM read, skip deleted data
FD_CWRITE=	045H		; MFM write, skip deleted data
FD_CSPEC=	003H		; Special - step rate, head load/unload

; Status codes

FD_SDIO=	01000000B	; Transfer direction (0 -> controller)
FD_SRQM=	10000000B	; Controller ready for next data

; Hard disk controller commands
HD_CSENS=	03H		; request sense block
HD_CREAD=	08H		; read
HD_CWRITE=	0AH		; write

HDcontrolbyte=	05H		; step rate = 70 us.

; I/O ports

FD_PSEL=	03F2H		; Controls drive select and motors
FD_PDAT=	03F5H		; Data transfer to/from controller
FD_PSTAT=	03F4H		; Controller status
FD_PCMD=	03F7H		; Controller command register

HD_PDAT=	0320H		; read/write data
HD_PSTAT=	0321H		; controller status
HD_PSEL=	0322H		; controller select
HD_PMSK=	0323H		; DMA and interrupt mask bits

PDMA=		0		; Base of ports for DMA control
PDMAX=		7FH		; Address extension regs for DMA
				;NOTE base address suitable for ch. 2 & 3 only
FD_DMA=		2		; floppy disk DMA channel
HD_DMA=		3		; hard disk DMA channel

DMA_READ=	44H		; DMA read command
DMA_WRITE=	48H		; DMA write command

; Misc

DORmask=	00CH		; Not reset, enable DMA & interrupt



SUBTTL	Data for performing requests
PAGE	+

;*	Dos Request Packet structure

DosPacket   STRUC
	RqCmdLen DB	0		; Length of this command
	RqUnit	DB	0		; Unit in this driver
	RqCmd	DB	0		; Command to do
	RqStatus DW	0		; Status of request
		DD	0
		DD	0		; Not used
	RqMedia DB	0		; Media descriptor
	RqAddr	DW	0		; Offset of data
		DW	0		; Segment of data
	RqCount DW	0		; Number of sectors
	RqFirst DW	0		; First sector to do
DosPacket	ENDS

;	The disk drivers work as a state machine performing the various actions
;  that make up disk I/O.

; Driver states
;	The following states are common to both drivers
Start=	0			; Starting I/O
Calc=	1			; Calculate position on disk
Done=	7			; I/O is done
Idle=	8			; Drive is inactive
Error=	9			; Have an error
;	The following states are used by the floppy driver only
Select= 2			; Select drive, start motor, seek
Recal=	3			; Drive was just recalibrated
Seek=	4			; Seek just finished
Settle= 5			; Head has settled
RdWri=	6			; Read/write is done
;	The following states are used by the fixed driver only
Verify= 6			; Start verify portion of write


DeviceStruc STRUC
	State	DW	Idle		; Current drive state
	Current DW	-1		; Current active drive
	ErrCnt	DB	0		; # of errors in doing request
	Flags	DB	0		; Various bit flags, see below
	DOR	DB	0		; Copy of select/motor reg
; Following values are set by Setup from the request packet and are
; updated after each transfer is completed.
	Unit	DB	0		; Unit
	First	DW	0		; 1st sector of request
	RealAddr DD	0		; Real addr of data when Addr is
					; scratch buffer.
	Count	DW	0		; Number of sectors to xfer
; Following values are set by MapSector.
	Cyl	DW	0		; Cylinder
	Sector	DB	0		; Sector - zero based
	Head	DB	0		; Head
	NumSectors DW	0		; Number of sectors to do
	NumBytes DW	0		; Number of bytes
	Addr	DD	0		; Pointer to data buffer
; Device dependent data
	ST0	DB	0		; floppy controller ST0
	ST1	DB	0		; floppy controller ST1
	ST2	DB	0		; floppy controller ST2
	CHRN	DB	0,0,0,0		; other floppy status returns
DeviceStruc	ENDS
	DCB	EQU	ST0		; Fixed disk Device Control Block

; Bits in Flags

    Factive=		1		; Actively working on something
    F2step=		2		; Must double step when seeking
    Fwrite=		4		; This is a write, not a read
    Fverify=		8		; This is a verify, not a rd/wr
    Fwrap1=		010H		; We are currently using ScratchBuffer
    Fwrap2=		020H		; We have used ScratchBuffer in this req

BiosSeg GROUP	Code,BiosInit

Code	SEGMENT BYTE PUBLIC	'CODE'
    ASSUME	CS:BiosSeg

IFDEF	DEBUGFLG
	EXTRN	BUGBITS:BYTE,DPRINTF:NEAR
ENDIF

SUBTTL	Device data
PAGE	+

Floppy	DeviceStruc	<>
Fixed	DeviceStruc	<>

;*	Per drive information, including BPBs

DriveStruc  STRUC
	BPBsecsiz	DW	512	; Physical sector size
	BPBsecpau	DB	1	; Sectors/Allocation unit
	BPBressec	DW	1	; Reserved sectors for DOS
	BPBnfat		DB	2	; # of allocation tables
	BPBndir		DW	64	; # of directory entries
	BPBnsec		DW	9*40	; Number of sectors
	BPBmediab	DB	0FCH	; Media descriptor
	BPBnfatsec	DW	2	; # of FAT sectors
	BPBtrksiz	DW	9	; # of sectors/track
	BPBnhead	DW	1	; # of heads
	BPBhidsec	DW	0	; Hidden sector count
	Timer		DB	0	; Countdown for motor off
	DrvFlag		DB	1	; Per-drive flags, see below
	TPI		DB	0	; Drive TPI= Not present, 48, 96
	CurCyl		DW	-1	; Current cylinder
DriveStruc	ENDS

;   DrvFlag values
Frestor=	1			; restore needed
Fmotoron=	2			; motor is on

DriveA	DriveStruc	<>		; floppy drive 0
DriveB	DriveStruc	<>		; floppy drive 1 or 0
DriveC	DriveStruc	<>		; hard drive 0 or floppy drive 2
DriveD	DriveStruc	<>		; hard drive 1 or floppy drive 3

FDinfo	DW	DriveA
	DW	DriveB
HDinfo	DW	DriveC
	DW	DriveD


; Structure of parameter block for floppy pointed to by 0:4*1E

FloppyParameter STRUC
	Spec1	DB	0		;  0  1st byte for specify cmd
	Spec2	DB	0		;  1  2nd byte for specify cmd
	DelayOff DB	0		;  2  # of Ticks(1/18.2) until
					;	motor shut off
	SectorSize DB	0		;  3  Sector size(128,256,512,1024)
					;	= (O,1,2,3 are put here)
	CylSize DB	0		;  4  Number of sectors/cylinder
	DataGap DB	0		;  5  Gap length of read/write
	ValueDTL DB	0		;  6  Data length (ignored)
	FormatGap DB	0		;  7  Gap for format operation
	FormatFill DB	0		;  8  Fill char for format
	DelaySettle DB	0		;  9  Head settle time in msec
	DelayMotor DB	0		; 10  Motor start time in 1/8 sec
FloppyParameter ENDS


ScratchBuffer	DB 512 DUP(?)	; Scratch buffer for when DMA fails
					; Hope we don't handle >512 sector
					; size

;*	Miscellaneous data

Single		DB	0		; non-zero if 1 floppy disk system
					;    in this case, NumFloppy will be 2

SUBTTL	Data for interface to 4.0
PAGE	+

	EXTRN	DosFunction:DWORD	; Addr of DOS function routine

; Dos helper functions used by disk driver

    PullRequest =	2		; Pull a request from the queue
    PushRequest =	4		; Add a request to the queue
    BlockProcess =	9		; Block process until I/O done
    ContinueProcess =  10		; I/O done, continue process

int_savregs=	32H			; interrupt routine which saves all regs


SwapSem1	DB	0		; non-zero if waiting to swap disks
SwapSem2	DB	0		; non-zero if waiting to prompt for swap
ScratchBufSem	DB	0		; semaphore controlling ScratchBuffer

SEM_WANT=	2
SEM_BUSY=	1

SemWait Macro	wchan
local	l1,l2
	pushf
l1:	cli
	test	wchan,SEM_BUSY		;;semaphore busy?
	jz	l2			;;no
	or	wchan,SEM_WANT		;;say we want it
	mov	ax,cs
	mov	bx,OFFSET wchan
	xor	cx,cx
	mov	dx,BlockProcess
	call	[DosFunction]		;;wait till semaphore released
	jmp	l1
l2:	or	wchan,SEM_BUSY		;;claim semaphore
	popf
	endm

SemSig	Macro	wchan
local	l
	test	wchan,SEM_WANT		;;anyone waiting on semaphore?
	jz	l
	mov	ax,cs
	mov	bx,OFFSET wchan
	mov	dx,ContinueProcess
	call	[DosFunction]
l:	and	wchan,NOT (SEM_WANT+SEM_BUSY)
	endm


FloppyQueue	DD  0			; List of requests for floppy
FixedQueue	DD  0			; List of requests for fixed disk

; Device driver headers

      PUBLIC	FloppyDevice
FloppyDevice	LABEL	WORD
	DD	FixedDevice		; Next device is hard disk
	DW	100000B			; This is 4.0 driver
	DW	JustReturn		; Strategy does nothing
	DW	FloppyRequest		; Interrupt does the work
NumFloppy	DB	4		; Handle 4 floppys maximum
	DB	0			; can be addressed as word also

	EXTRN	Com1Dev:NEAR

FixedDevice	LABEL	WORD
	DD	Com1Dev			; Next device is comm port 1
	DW	100000B			; This is 4.0 driver
	DW	JustReturn		; Strategy does nothing
	DW	FixedRequest		; Interrupt does work (misnomer)
NumFixed	DB	0		; Handle 2 hard disks maximum


; Utility routines which reside in the BIOS main module

	EXTRN	Interrupt:NEAR		; BIOS interrupt routine(misnomer)
	EXTRN	CmdErr:NEAR
	EXTRN	StatusDevReady:NEAR
	EXTRN	StatusComplete:NEAR
	EXTRN	StatusError:NEAR
	EXTRN	SetStatus:NEAR

JustReturn	PROC	FAR
	RET
JustReturn	ENDP

FloppyRequest	PROC	FAR
	debug	4,2,<FloppyRequest, es:bx $x:$x, cmd $d\n>,<es,bx,<word ptr es:[bx.RqCmd]>>
	PUSH	SI
	LEA	SI,FloppyFunction	; 4.0 function routines
	JMP	Interrupt		; Let BIOS figure out what to do
FloppyRequest	ENDP

; Dispatch table for actions of the floppy requested by 4.0

FloppyFunction	LABEL	WORD
	DW	FloppyInit		;  0  Initialize
	DW	FloppyCheck		;  1  Check media
	DW	FloppyBuild		;  2  Build BPB
	DW	CmdErr			;  3  IOCTL input
	DW	FloppyRead		;  4  Read
	DW	StatusDevReady		;  5  Non-destructive read
	DW	StatusComplete		;  6  Input status
	DW	StatusComplete		;  7  Input flush
	DW	FloppyWrite		;  8  Write
	DW	FloppyWriteV		;  9  Write with verify
	DW	CmdErr			; 10  Output status
	DW	CmdErr			; 11  Output flush
	DW	CmdErr			; 12  IOCTL output
	DW	CmdErr			; 13  Device open
	DW	CmdErr			; 14  Device close
	DW	CmdErr			; 15  Removable media
	DW	CmdErr			; 16  Generic IOCTL request

FixedRequest	PROC	FAR
	debug	8,2,<FixedRequest, es:bx $x:$x, cmd $d\n>,<es,bx,<word ptr es:[bx.RqCmd]>>
	PUSH	SI
	LEA	SI,FixedFunction	; 4.0 function routines
	JMP	Interrupt		; Let BIOS figure out what to do
FixedRequest	ENDP

; Dispatch table for actions of the hard disk requested by 4.0

FixedFunction	LABEL	WORD
	DW	FixedInit		;  0  Initialize
	DW	FixedCheck		;  1  Check media
	DW	FixedBuild		;  2  Build BPB
	DW	CmdErr			;  3  IOCTL input
	DW	FixedRead		;  4  Read
	DW	StatusDevReady		;  5  Non-destructive read
	DW	StatusComplete		;  6  Input status
	DW	StatusComplete		;  7  Input flush
	DW	FixedWrite		;  8  Write
	DW	FixedWriteV		;  9  Write with verify
	DW	CmdErr			; 10  Output status
	DW	CmdErr			; 11  Output flush
	DW	CmdErr			; 12  IOCTL output
	DW	CmdErr			; 13  Device open
	DW	CmdErr			; 14  Device close
	DW	CmdErr			; 15  Removable media
	DW	CmdErr			; 16  Generic IOCTL request


SUBTTL	Data for routines that make direct Int 13 requests
PAGE	+


RealInt13Vec	dw	0		; Used to make Int 13 requests
		dw	0
OldIntDVec	dw	0		; Must be reset when Int 13's on hard
		dw	0		;  disk.
OldIntEVec	dw	0		; Must be reset when Int 13's on floppy
		dw	0		;  disk.
SemDiskIO	db	0		; Semaphore controlling disk io
SemInt13	db	0		; Semaphore controlling Int 13's


SUBTTL	4.0 device driver routines (system entry points)
PAGE	+

BiosInit	SEGMENT PARA PUBLIC	'CODE'
    ASSUME	CS:BiosSeg

	PUBLIC	Disk_Init
Disk_Init	PROC
;**************************************************************
;	This routine performs device dependent initialization
;	during the BIOS initialization.	 Not to be confused
;	with the device initialization entry points which are
;	called later on and perform different functions.
;
;	AFTER THE EQUIPMENT CALL (INT 11H) BITS 6&7 WILL TELL
;	THE NUMBER OF FLOPPY DISKS IN THE SYSTEM.
;	THE INDICATIONS ARE AS FOLLOWS:
;
;	BITS	7	6	DRIVES
;		0	0	1
;		0	1	2
;		1	0	3
;		1	1	4
;**************************************************************

	debug	12,1,<Performing disk driver pre-DOS initialization\n>,<>
	PUSH	CS
	POP	DS

    ASSUME	DS:BiosSeg
	INT	11H			;GET EQUIPMENT STATUS
	rol	al,1			; rotate around to low order bits
	rol	al,1
	AND	AL,11B			;MASK DRIVE BITS
	JNZ	NOTSNGL		;Zero means single drive system
	INC	[SINGLE]	;REMEMBER THIS
	inc	al		; make it look like two-drive system
NOTSNGL:
	inc	al
	MOV	[NumFloppy],AL		;Remember how many drives
	MOV	AH,8
	MOV	DL,80H
	INT	13H		;Request number of hardfiles attached
	JC	ENDDRV		;Carry indicates old rom, so no hardfile
	MOV	[NumFixed],DL
	test	dl,dl			; any specified?
	jz	ENDDRV			; no
	cmp	NumFloppy,2		; too many floppies?
	jbe	ENDDRV
	mov	NumFloppy,2		; limit to two floppies max.
ENDDRV:

;*	Initialize the hard disk BPBs

	MOV	DL,80H
	MOV	DI,OFFSET DriveC
	CMP	[NumFixed],0
	JLE	ITSOK
	CALL	SETHRD		;SET UP FIRST HARDFILE

	MOV	DL,81H		;SET UP FOR NEXT CALL
	MOV	DI,OFFSET DriveD
	JC	NOTOK
	CMP	[NumFixed],2
	JZ	SETIT
	JMP	SHORT ITSOK
NOTOK:
	MOV	DI,OFFSET DriveC
	DEC	[NumFixed]
	CMP	[NumFixed],0
	JZ	ITSOK
SETIT:	CALL	SETHRD		;SET UP SECOND HARDFILE
	JNC	ITSOK
	DEC	[NumFixed]
ITSOK:
	cmp	[NumFixed],0	; any hard disks found?
	jnz	itsok2		; yes
	mov	ax,[FixedDevice]  ; no, patch device chain to skip fixed disk
	mov	[FloppyDevice],ax
itsok2:
	push	es			; Install Int 13 handler and save the
	xor	ax,ax			;  old value of the interrupt vector.
	mov	es,ax
	mov	ax,es:[4*13h]
	mov	[RealInt13Vec],ax
	mov	ax,OFFSET Int13Handler
	mov	es:[4*13H],ax
	mov	ax,es:[4*13h+2]
	mov	[RealInt13Vec+2],ax
	mov	es:[4*13H+2],cs
	mov	ax,es:[4*0dh]		; Save original Int D vector
	mov	[OldIntDVec],ax
	mov	ax,es:[4*0dh+2]
	mov	[OldIntDVec+2],ax
	mov	ax,es:[4*0eh]		; Save original Int E vector
	mov	[OldIntEVec],ax
	mov	ax,es:[4*0eh+2]
	mov	[OldIntEVec+2],ax
	pop	es
	ret
Disk_Init	ENDP

;
;	READ A BOOT RECORD INTO Scratch buffer
;
GETBOOT:
	MOV	CX,1
	MOV	AX,0201H
	push	CS
	pop	es
	mov	BX,OFFSET ScratchBuffer
	xor	DH,DH
	INT	13H
	JC	SETRET
	CMP	WORD PTR ES:[BX+1FEH],0AA55H
	JNZ	SETRET
	RET
;
;	SETUP VARIABLE SIZED HARDFILE
;	ON ENTRY DL=DRIVE NUMBER (80 OR 81)
;		DI=PTR TO B.P.B
;
SETHRD: PUSH	DX
	MOV	AH,8		;GET DRIVE PARAMETERS
	INT	13H
	INC	DH
	MOV	BYTE PTR [DI].BPBnhead,DH
	POP	DX
	JC	SETRET
	AND	CL,3FH
	MOV	BYTE PTR [DI].BPBtrksiz,CL
	CALL	GETBOOT		;GET THE BOOT RECORD
	JC	SETRET
	add	BX,1C2H
	mov	cx,4
SET1:	CMP	BYTE PTR ES:[BX],1
	JZ	SET2
	ADD	BX,16
	loop	SET1
SETRET: STC			;NOT FOUND SO USE DEFAULTS
	debug	8,3,<Sethrd err rtn: drive $x stat $x\n>,<dx,ax>
	RET

SET2:	MOV	AX,ES:[BX+4]
	MOV	DS:[DI].BPBhidsec,AX	;SET HIDDEN SECTOR COUNT
	MOV	AX,ES:[BX+8]
	CMP	AX,64			;HAS TO BE AT LEAST 32K
	JB	SETRET
	MOV	DS:[DI].BPBnsec,AX	;SAVE LOGICAL SECTOR COUNT
	MOV	CX,0100H		;SET CLUS SIZE AND SHIFT COUNT
	MOV	DX,64			;SET NUMBER OF DIR ENTRIES
	CMP	AX,512
	JBE	SET3

	ADD	CH,CH
	INC	CL
	MOV	DX,112
	CMP	AX,2048
	JBE	SET3

	ADD	CH,CH
	INC	CL
	MOV	DX,256
	CMP	AX,8192
	JBE	SET3

	ADD	CH,CH
	INC	CL
	ADD	DX,DX
	CMP	AX,32680	;NOT 32768! MAX NUMBER OF CLUSTERS=4085
	JBE	SET3

	ADD	CH,CH
	INC	CL
	ADD	DX,DX
SET3:
;
;	DX=NUMBER OF DIR ENTRIES, CH=NUMBER OF SECTORS PER CLUSTER
;				  CL=LOG BASE 2 OF CH
;
;	NOW CALCULATE SIZE OF FAT TABLE
;
	MOV	[DI].BPBndir,DX		;SAVE NUMBER OF DIR ENTRIES
	MOV	[DI].BPBsecpau,CH	;SAVE SECTORS PER CLUSTER
	XOR	BX,BX
	MOV	BL,CH
	DEC	BX
	ADD	BX,AX
	SHR	BX,CL			;DIVIDE BY SECTORS/CLUSTER
	INC	BX
	AND	BL,11111110B		;MAKE SURE COUNT IS EVEN
	MOV	SI,BX
	SHR	BX,1
	ADD	BX,SI			;MULTIPY BY 1.5
	ADD	BX,511
	SHR	BH,1
	MOV	BYTE PTR [DI].BPBnfatsec,BH	;SAVE NUMBER OF FAT SECTORS
	MOV	[DI].BPBmediab,0F8H	; set media byte
	CLC
	RET
BiosInit	ENDS

    ASSUME	CS:BiosSeg,DS:NOTHING,ES:NOTHING

FloppyInit	PROC
	debug	4,3,<Diskette initialization>,<>
	push	ds			; install floppy interrupt routine
	xor	ax,ax
	mov	ds,ax
	mov	ax,OFFSET FloppyInterrupt
	mov	ds:[4*0eH],ax
	mov	ds:[4*0eH+2],cs
	pop	ds
	call	Rst765
	mov	ah,[NumFloppy]
	mov	di,OFFSET FDinfo
DBBEG	4,3
	jmp	SHORT iniret
DBEND
	jmp	bpbret
ELSE
	jmp	SHORT bpbret
ENDIF
FloppyInit	ENDP

FixedInit	PROC
	debug	8,3,<Hard disk initialization>,<>
	push	ds			; install fixed disk interrupt routine
	xor	ax,ax
	mov	ds,ax
	mov	ax,OFFSET FixedInterrupt
	mov	ds:[4*0dH],ax
	mov	ds:[4*0dH+2],cs
	pop	ds
	in	al,21H			; unmask fixed disk interrupts
	and	al,0DFH
	out	21H,al
	mov	dx,HD_PMSK		; set interrupt and DMA mask bits
	mov	al,3
	out	dx,al
	mov	ah,[NumFixed]
	mov	di,OFFSET HDinfo
DBBEG	8,3
iniret: debug	12,3,< - Num=$x BPB table=$x:$x\n>,<ax,cs,di>
DBEND
ENDIF
	jmp	SHORT bpbret
FixedInit	ENDP

FloppyBuild	PROC
	mov	ah,byte ptr es:[di]
	call	FDGetBPB
bpbret: mov	[bx.RqMedia],ah
	mov	[bx.RqCount],di
	mov	[bx.RqCount+2],CS
	jmp	StatusComplete
FloppyBuild	ENDP

FixedBuild	PROC
	mov	ah,byte ptr es:[di]
	call	HDGetBPB
	jmp	SHORT bpbret
FixedBuild	ENDP

;***	FloppyCheck - check to see if the disk may have been changed.
;
;	ENTRY	AL = unit #
;		AH = media byte
;	EXIT	Return value in request header set to one of:
;			1	Media may have been changed
;			0	Media not changed
;			-1	Media was probably changed
;

FloppyCheck	PROC
	MOV	DL,1			; Assume not changed
	cmp	AH,0f8H			; Is disk removable?
	JE	FloppyCheckDone		; No, can't be changed then
	cmp	Single,0		; single drive system?
	je	flchk1			; no, check drive state
	cmp	Floppy.Unit,al		; unit = current drive?
	je	flchk1			; yes, check drive state
	mov	DL,-1			; say media changed for sure
	jmp	FloppyCheckDone
flchk1: MOV	CX,AX
	XOR	CH,CH
	MOV	SI,CX
	ADD	SI,SI
	MOV	SI,FDinfo[SI]		; Get pointer to drive info
	TEST	CS:[SI].DrvFlag,Fmotoron	; Is motor on?
	JNZ	FloppyCheckDone		; Yes, media not changed then
	XOR	DL,DL			; No, might have been changed
FloppyCheckDone:
	MOV	BYTE PTR DS:[BX].RqAddr,DL
	JMP	StatusComplete		; Return whether media changed
FloppyCheck	ENDP


FixedCheck	PROC
	MOV	DL,1
	JMP	FloppyCheckDone
FixedCheck	ENDP
;***	FloppyRead, FloppyWrite, FloppyWriteV - Basic I/O entry points
;
;	FloppyRead, FloppyWrite and FloppyWriteV are the basic I/O
;	routines used by the DOS.  They really do not do much except
;	queue the request and start the device if it is idle.
;	For single drive floppy systems, they also handle the
;	switching of disks when I/O changes from A to B or vice-versa.
;
;	ENTRY	DS:BX	Packet address
;		ES:DI	Transfer address
;		AL	Unit #
;		AH	Media Byte
;		CX	# of sectors
;		DX	Starting sector
;
;	EXIT	DS:BX	Packet Addr
;		CX	# of sectors left to do
;
;	USES	SI

FloppyRead	LABEL	NEAR
FloppyWrite	LABEL	NEAR
FloppyWriteV	PROC
	debug	4,2,<Fl rd/wt/ver  Req $x:$x  unit $b  sec $d  nsec $d\n>,<ds,bx,ax,dx,cx>
	call	BlockIfLocked
	push	di
	call	FDGetBPB		; cs:di => BPB
	mov	si,dx
	add	si,cx			; compute last sector + 1
	cmp	si,cs:[di.BPBnsec]
	mov	si,di
	pop	di
	jbe	flrw1
	mov	al,8			; ERROR - Sector not found
	jmp	StatusError

flrw1:	OR	CX,CX			; Anything to do?
	JNZ	flrw2			; Yes
	JMP	StatusComplete		; No, all done now
flrw2:
	CMP	Single,0		; Is this a single drive system?
	JE	flrw3			; No, don't check for drive change
	CALL	FloppyChange		; See if should change disks
flrw3:
	call	CheckWrap
	push	ds
	pop	es			; ES:BX = Request addr
	push	cs
	pop	ds
	LEA	SI,FloppyQueue		; DS:SI = ptr to head of queue
	MOV	DX,PushRequest
	CALL	DosFunction		; Add request to list
	push	es
	pop	ds			; Back to DS:BX is request
	pushf
	cli				; interrupts off while testing state
	TEST	Floppy.Flags,Factive	; Is driver active?
	JNE	FloppyActive		; Yes, driver will get to it
	PUSH	DS
	PUSH	BX			; Save some regs
	OR	Floppy.Flags,Factive
	MOV	Floppy.State,Start	; Want to start I/O
	CALL	FloppyExecute		; Start up the driver
	POP	BX
	POP	DS			; Restore regs
flrw4:	test	DS:[BX].RqStatus,0100H	; IO completed?
	JNZ	FloppyIOdone		; yes

FloppyActive:
	MOV	AX,DS			; AX:BX = request
	xor	cx,cx
	push	bx
	MOV	DX,BlockProcess
	CALL	DosFunction		; Block until I/O is done
	pop	bx
	jmp	flrw4			; test completion status again
FloppyIOdone:
	popf
	MOV	AX,DS:[BX].RqStatus	; Need AX = status
	MOV	CX,DS:[BX].RqCount	; Need CX = count left to do
	debug	4,2,<Fl rd/wt/ver DONE	Req $x:$x  stat $x  resid $d\n>,<ds,bx,ax,cx>
	JMP	SetStatus		; Return to DOS with results
FloppyWriteV	ENDP


FixedRead	LABEL	NEAR
FixedWrite	LABEL	NEAR
FixedWriteV	PROC
	debug	8,2,<Fix rd/wt/ver  Req $x:$x  unit $b	sec $d	nsec $d\n>,<ds,bx,ax,dx,cx>
	call	BlockIfLocked
	push	di
	call	HDGetBPB		; cs:di => BPB
	mov	si,dx
	add	si,cx			; compute last sector + 1
	cmp	si,cs:[di.BPBnsec]
	mov	si,di
	pop	di
	jbe	fxrw1
	mov	al,8			; ERROR - Sector not found
	jmp	StatusError

fxrw1:	OR	CX,CX			; Anything to do?
	JNZ	fxrw2			; Yes
	JMP	StatusComplete		; No, all done now
fxrw2:
	call	CheckWrap
	push	ds
	pop	es			; ES:BX = Request addr
	push	cs
	pop	ds
	LEA	SI,FixedQueue		; DS:SI = ptr to head of queue
	MOV	DX,PushRequest
	CALL	DosFunction		; Add request to list
	push	es
	pop	ds			; Back to DS:BX is request
	pushf
	cli				; interrupts off while testing state
	TEST	Fixed.Flags,Factive	; Is driver active?
	JNE	FixedActive		; Yes, driver will get to it
	PUSH	DS
	PUSH	BX			; Save some regs
	OR	Fixed.Flags,Factive
	MOV	Fixed.State,Start	; Want to start I/O
	CALL	FixedExecute		; Start up the driver
	POP	BX
	POP	DS			; Restore regs
fxrw4:	test	DS:[BX].RqStatus,0100H	; IO completed?
	JNZ	FixedIOdone		; yes

FixedActive:
	MOV	AX,DS			; AX:BX = request
	xor	cx,cx
	push	bx
	MOV	DX,BlockProcess
	CALL	DosFunction		; Block until I/O is done
	pop	bx
	jmp	fxrw4			; test completion status again
FixedIOdone:
	popf
	MOV	AX,DS:[BX].RqStatus	; Need AX = status
	MOV	CX,DS:[BX].RqCount	; Need CX = count left to do
	debug	8,2,<Fx rd/wt/ver DONE	Req $x:$x  stat $x  resid $d\n>,<ds,bx,ax,cx>
	JMP	SetStatus		; Return to DOS with results
FixedWriteV	ENDP

;***	CheckWrap - check whether a request crosses a 64Kb boundary
;
;	CheckWrap will check whether the request given in DS:BX
;	crosses a 64Kb boundary.  A portion of such requests must
;	be done using ScratchBuffer for a single sector transfer.
;	This routine ensures that only one such request is put into
;	either of the request queues at any time.
;
;	ENTRY	DS:BX	Request header
;		ES:DI	Transfer address
;		CS:SI	Pointer to BPB
;		CX	Sector count
;	EXIT	When it's safe to proceed.
;	USES	AX,BP

CheckWrap	PROC
	push	dx
	push	cx
	mov	ax,cx
	mul	cs:[si.BPBsecsiz]
	mov	dx,es			; compute offset
	mov	cl,4
	shl	dx,cl
	add	dx,di
	clc				; now see if offset+nbytes overflows
	add	dx,ax
	jnc	chkw8
	debug	12,10h,<CheckWrap $x $x:$x	>,<ax,es,di>
	push	bx
	SemWait ScratchBufSem		; wait for ScratchBuffer to be available
	pop	bx

chkw8:	pop	cx
	pop	dx
	ret
CheckWrap	ENDP


;***	FloppyChange - check whether floppy disk must be changed
;
;	FloppyChange is called on a single drive system to simulate a
;	two drive system.  The current request for I/O is checked against
;	what the driver considers to be the current drive.  If they are
;	the same, FloppyChange just returns.  Otherwise, SwapSem2 is set
;	and the current process is blocked on SwapSem2.	 Any process that
;	attempts I/O while SwapSem2 is set is blocked on SwapSem1.  When
;	SwapSem2 is cleared, these processes are continued.  When the
;	driver becomes idle and SwapSem2 is set, the Idle state continues
;	the blocked process.  This process then puts out the message about
;	switching disks and waits for a user reply.  When it is given,
;	FloppyChange clears SwapSem1 and causes the I/O to be started.
;
;	ENTRY	DS:BX	Pointer to I/O request
;
;	USES	AX,DX
;


FloppyChange	PROC
	push	cx
	pushf
	push	bx
	SemWait SwapSem1		; Currently waiting to switch disk?
	pop	bx

flcha1: and	SwapSem1,NOT SEM_BUSY	; reset BUSY for now
	MOV	AL,DS:[BX].RqUnit	; Get desired unit
	CMP	AL,Floppy.Unit		; Switching A and B drive?
	JE	flcha7			; No, keep using this drive
	CLI				; ** Disable interrupts
	OR	SwapSem1,SEM_BUSY	; Flag waiting to switch
	test	Floppy.Flags,Factive	; Is driver idle?
	JE	flcha2			; Yes, don't need to wait
	push	bx
	SemWait SwapSem2
	pop	bx
	jmp	flcha1
flcha2:
	popf				; restore interrupt state
	pushf
	ADD	AL,"A"			; Convert to drive letter
	MOV	CS:DriveLetter,AL	; Set the letter
	PUSH	DS
	PUSH	SI
	push	bx
	push	cs
	pop	ds
	LEA	SI,SwitchMsg
flcha4:
	LODSB
	OR	AL,AL			; End of message?
	JZ	flcha5			; Yes
	INT	29H			; No, output char
	JMP	flcha4			; Put out whole msg

flcha5:
	mov	ah,1			; Flush keyboard input
	int	16H
	jz	flcha5
	XOR	AH,AH
	INT	16H			; Wait for a char
	pop	bx
	POP	SI
	POP	DS
flcha7:
	push	bx
	SemSig	SwapSem1		; Allow blocked processes to continue
	pop	bx
flcha8:
	popf
	pop	cx
	RET

FloppyChange	ENDP


SwitchMsg	LABEL	WORD
	DB	13,10,"Insert diskette for drive "
DriveLetter	LABEL	BYTE
	DB	"A: and strike",13,10,"any key when ready",13,10,10,0


Int13Handler	Proc	Far
	push	dx			; Save regs used in local processing
	push	cx
	push	bx
	push	ax
	pushf
LockCheck:
	cli				; If any Int 13 request is already
	cmp	SemInt13,0		;  pending, block this process until
	jz	NotLocked		;  the previous one finishes.
	mov	ax,cs
	mov	bx,offset SemInt13
	xor	cx,cx
	mov	dx,BlockProcess
	call	DosFunction
	jmp	LockCheck
NotLocked:
	mov	SemInt13,1		; Lock out other disk requests
	popf
	pushf
BusyCheck:
	cli
	cmp	SemDiskIO,0		; If the disks are busy, block this
	jz	DiskFree		;  process till they free up.
	mov	ax,cs
	mov	bx,offset SemDiskIO
	xor	cx,cx
	mov	dx,BlockProcess
	call	DosFunction
	jmp	BusyCheck
DiskFree:
	popf
	sti
	pop	ax			; Restore regs for call
	pop	bx
	pop	cx
	pop	dx
	push	dx
	push	cx
	push	bx
	pushf
	call	dword ptr [RealInt13Vec]
	mov	SemInt13,0
	push	ax
	pushf
	mov	ax,cs			; Unblock anything that is waiting
	mov	bx,offset SemInt13
	mov	dx,ContinueProcess
	call	DosFunction
	popf				; Restore user regs
	pop	ax
	pop	bx
	pop	cx
	pop	dx
	ret	2
Int13Handler	endp


SUBTTL	Fixed disk startup routine
PAGE	+

;	FixedExecute processes a disk request after it has been set up.	 When the
;  disk is inactive (State = Idle), it is called to start the device.  For all
;  subsequent events, it is called on the disk interrupt which signaled the
;  completion of that subfunction.  Some states do not involve waiting for an
;  interrupt to occur.	This routine runs entirely off the 'Fixed' data structure

FixedDispatch	LABEL	WORD
	DW	FxExStart
	DW	FxExCalc
	DW	FxExError		;; BUGBUG really error in state machine
	DW	FxExError		;; BUGBUG really error in state machine
	DW	FxExError		;; BUGBUG really error in state machine
	DW	FxExError		;; BUGBUG really error in state machine
	DW	FxExVerify
	DW	FxExDone
	DW	FxExIdle
	DW	FxExError

FixedExecute	PROC
	push	cs			; CS -> DS
	pop	ds
    ASSUME	DS:BiosSeg
	MOV	BX,Fixed.State		; Get current state
	debug	8,4,<FxEx state $d	>,<bx>
	ADD	BX,BX
	JMP	FixedDispatch[BX]	; Dispatch to correct routine


;*	Fixed state Start
;
;	Do setup calculations to figure out sector, start
;  up motor, advance to Calc state.
;
;  Entered on initially picking up a new request to do and on error retries.
;  If error retries start here, then multiple sector requests will always start
;  at the beginning rather than at the point of the error! Why?

FxExStart:
	mov	si,OFFSET Fixed		; SI = pointer to per-device info.
	les	bx,FixedQueue		; ES:BX = pointer to current request
	mov	al,es:[bx].RqUnit
	call	HDGetBPB		; DI = drive parameters
	CALL	Setup			; Do setup calculations
	MOV	Fixed.State,Calc	; Advance to next state
	JMP	FixedExecute		; Now return to do Calc code



;*	Fixed state Calc
;
;	Calculate cylinder, head and sector, wait for motor
;  start or head load, advance to Select state.
;
;  Entered after Start state and also on further sectors of a multiple sector
;  request.

FxExCalc:
	mov	si,OFFSET Fixed		; SI = pointer to per-device info.
	les	bx,FixedQueue		; ES:BX = pointer to current request
	mov	al,es:[bx].RqUnit
	call	HDGetBPB		; DI = drive parameters
	CALL	MapSector		; Get head, cylinder and sector
	test	Fixed.Flags,Fwrite
	jnz	fxxc1
	mov	al,DMA_read
	mov	Fixed.DCB,HD_CREAD
	jmp	SHORT fxxc2
fxxc1:	mov	al,DMA_write
	mov	Fixed.DCB,HD_CWRITE
fxxc2:	mov	ah,HD_DMA
	call	DMAsetup		; set up DMA transfer
	mov	al,Fixed.Unit
	mov	cl,5
	shl	ax,cl
	or	al,Fixed.Head
	mov	Fixed.DCB+1,al		; set head/unit
	mov	ax,Fixed.cyl
	mov	Fixed.DCB+3,al		; set low cylinder
	shr	ax,1
	shr	ax,1
	and	al,0C0H
	or	al,Fixed.Sector
	mov	Fixed.DCB+2,al		; set high cylinder/sector
	mov	al,BYTE PTR Fixed.Numsectors
	mov	Fixed.DCB+4,al		; set sector count
	mov	Fixed.DCB+5,HDcontrolbyte	;BUGBUG - what do we want here?
	mov	al,3
	call	HDCommand
	mov	al,Done			; assume next state is Done
	test	Fixed.Flags,Fverify
	jz	fxxc3
	mov	al,Verify
fxxc3:	mov	BYTE PTR Fixed.State,al		; set next state
	ret


;*	Fixed state Verify
;
;	Have executed a write function, must now verify.
; BUGBUG	For now just go to done state.

FxExVerify:
	mov	Fixed.State,Done
	jmp	FixedExecute



;*	Fixed state Done
;
;	If whole request is now complete, mark the request
;  as done and then start the next one if there is one.	 If the request is not
;  yet done, adjust values to show the amount of the request done and then go
;  back to the Calc state to do next part.

FxExDone:
	MOV	AL,Fixed.Flags
	AND	AL,Fwrite+Fwrap1	; Only interested in these bits
	CMP	AL,Fwrap1		; Just read into scratch?
	JNE	fxxd1			; No
	PUSH	DS
	PUSH	ES
	MOV	CX,Fixed.NumBytes	; CS = # bytes to write from scr
	LES	DI,Fixed.RealAddr	; ES:DI = real buffer
	LDS	SI,Fixed.Addr		; DS:SI = scratch buffer
	CLD
  REP	MOVSB				; Copy into real buffer
	POP	ES
	POP	DS
fxxd1:
	MOV	AX,Fixed.NumSectors	; AX = # of sectors we did
	SUB	Fixed.Count,AX		; Adjust count to number left
	JZ	fxxd3		; Request is done, tell DOS
	ADD	Fixed.First,AX		; Advance sector number
	MOV	AX,Fixed.NumBytes	; Number of bytes handled
	ADD	WORD PTR Fixed.RealAddr,AX ; Advance data address
	MOV	Fixed.State,Calc	; Go to Calc state
fxexj4: JMP	FixedExecute

fxxd3:
	mov	DI,OFFSET Fixed
	mov	SI,OFFSET FixedQueue	; DS:SI = head of queue
	call	DoneRequest
	JMP	fxexj4


;*	Fixed state Idle
;
;	Nothing hapenning, become inactive.

FxExIdle:
	and	Fixed.Flags,NOT Factive
	RET


;*	Fixed state Error
;
;	Entered when a non-recoverable error is detected.
;	A sense block has been requested and put into the
;	DCB.

FxExError:
	MOV	Fixed.State,Done	; Request is done
; Set error bits in request packet
	MOV	AL,Fixed.DCB		; Get status byte
	mov	bl,al			; isolate error type as word address
	and	bx,0030h
	mov	cl,3
	shr	bx,cl
	mov	bx,HDErrType[BX]	; index into error table by type
	and	ax,0Fh			; get error code
	cmp	al,ds:[bx]		; outside range of table?
	jae	fxxe1
	add	bx,ax
	mov	ah,ds:[bx+1]		; translate error code
	jmp	SHORT fxxe2
fxxe1:
	mov	ah,12
fxxe2:	dbbeg	8,4
	mov	di,OFFSET Fixed.DCB
	debug	8,4,<HD error: sense $b$b$b$b code $x\n>,<<[di]>,<[di+1]>,<[di+2]>,<[di+3]>,ax>
	dbend
	endif
	PUSH	ES
	LES	DI,FixedQueue		; Get ptr to request
	MOV	AL,ah
	MOV	AH,10000001B
	MOV	ES:[DI].RqStatus,AX	; Set error and code
	POP	ES
	JMP	fxxd3		; Advance to Done state
FixedExecute	ENDP

;*	Traslation of controller error codes to DOS error codes

HDErrType	DW	HDErrTyp0
		DW	HDErrTyp1
		DW	HDErrTyp2
		DW	HDErrTyp3

HDErrTyp0	DB	9, 12, 2, 6,10, 2,12, 6,12, 6
HDErrTyp1	DB	10, 4, 4, 8,12, 8, 6,12,12, 4, 6
HDErrTyp2	DB	2,  3, 8
HDErrTyp3	DB	3,  4, 4, 4

    ASSUME	CS:BiosSeg,DS:NOTHING,ES:NOTHING

FixedInterrupt	PROC	FAR
	debug	8,8,<FxIntr\n>,<>
	cmp	word [SemDiskIO],0001h
	jnz	fxinot13
	cmp	SemInt13,0		; If a direct Int13 request is being
	jz	fxinot13		;  made call the ROM floppy interrupt
	cmp	SemDiskIO,0		;  routine to handle it.
	jnz	fxinot13
	int	int_savregs
;;	in	al,21H			; Mask fixed disk interrupts
;;	or	al,20h
;;	out	21H,al
	pushf
	call	dword ptr [OldIntDVec]
	in	al,21H			; Unmask fixed disk interrupts
	and	al,0DFH
	out	21H,al
	mov	dx,HD_PMSK		; set interrupt and DMA mask bits
	mov	al,3
	out	dx,al
	iret
fxinot13:
	TEST	Fixed.Flags,Factive	; device active?
	JZ	fxinret			; no, go away
	INT	int_savregs		; save registers
	mov	dx,HD_PDAT
	in	al,dx			; get status reg.
;;	mov	ah,al
;;	mov	dx,HD_PMSK
;;	xor	al,al
;;	out	dx,al			; turn off intr. and DMA.
;;	test	ah,02h			; error bit set?
	test	al,02h			; error bit set?
	jz	fxin4			; no
;* error occurred.  see if retry, else get error code.
	push	cs
	pop	ds
    ASSUME	ds:BiosSeg
	CMP	Fixed.ErrCnt,ErrLim	; Reach error limit?
	JAE	fxin0			; Yes, request fails
	INC	Fixed.ErrCnt		; We are doing another try
	MOV	Fixed.State,Start	; Restart the request
	JMP	fxin4
fxin0:	mov	Fixed.DCB,HD_CSENS	; send sense command
	xor	al,al			; reset intr. & DMA masks
	call	HDCommand
	push	cs
	pop	es
	mov	di,OFFSET Fixed.DCB
	mov	cx,5
fxin1:	call	HDWaitReq		; get the sense block back
	mov	dx,HD_PDAT
	in	al,dx
	stosb
	loop	fxin1
	mov	Fixed.State,Error

    ASSUME	ds:NOTHING
fxin4:	CALL	FixedExecute
fxinret: push	ax
	MOV	AL,20H			; send EOI to 8259
	OUT	20H,AL
	pop	ax
	IRET
FixedInterrupt	ENDP

SUBTTL	Floppy disk startup routine
PAGE	+

;	FloppyExecute processes a disk request after it has been set up.
;	When the disk is inactive (State = Idle), it is called to start
;	the device.  For all subsequent events, it is called on the disk
;	interrupt which signaled the completion of that subfunction.
;	Some states do not involve waiting for an interrupt to occur.
;	This routine runs entirely off the 'Floppy' data structure

FloppyDispatch	LABEL	WORD
	DW	FlExStart
	DW	FlExCalc
	DW	FlExSelect
	DW	FlExRecal
	DW	FlExSeek
	DW	FlExSettle
	DW	FlExRdWri
	DW	FlExDone
	DW	FlExIdle
	DW	FlExError

FloppyExecute	PROC
	push	cs			; CS -> DS
	pop	ds
    ASSUME	DS:BiosSeg
	MOV	BX,Floppy.State		; Get current state
	debug	4,4,<FlEx state $d	>,<bx>
	ADD	BX,BX
	JMP	FloppyDispatch[BX]	; Dispatch to correct routine


;*	Floppy state Start
;
;	Do setup calculations to figure out sector, start
;  up motor, advance to Calc state.
;
;  Entered on initially picking up a new request to do and on error retries.
;  If error retries start here, then multiple sector requests will always start
;  at the beginning rather than at the point of the error! Why?

FlExStart:
	mov	si,OFFSET Floppy	; SI = pointer to per-device info.
	les	bx,FloppyQueue		; ES:BX = pointer to current request
	mov	al,es:[bx].RqUnit
	mov	ah,es:[bx].RqMedia
	call	FDGetBPB		; DI = drive parameters
	CALL	Setup			; Do setup calculations
	MOV	DX,FD_PCMD
	MOV	AL,Rate44
	OUT	DX,AL			; Set step rate
	MOV	Floppy.State,Calc	; Advance to next state
flexj1: JMP	FloppyExecute		; Now return to do Calc code



;*	Floppy state Calc
;
;	Calculate cylinder, head and sector, wait for motor
;  start or head load, advance to Select state.
;
;  Entered after Start state and also on further sectors of a multiple sector
;  request.

FlExCalc:
	mov	si,OFFSET Floppy	; SI = pointer to per-device info.
	les	bx,FloppyQueue		; ES:BX = pointer to current request
	mov	al,es:[bx].RqUnit
	mov	ah,es:[bx].RqMedia
	call	FDGetBPB			; DI = drive parameters
	CALL	MapSector		; Get head, cylinder and sector
	MOV	Floppy.State,Select	; Will advance to Select state
	CALL	Sel765			; Select the drive and maybe wait
	JNC	FloppyExecute		; Did select with no waiting
	RET				; Have set a timer, get out



;*	Floppy state Select
;
;	Recalibrate the drive if needed.  If Seek is
;  needed, start it and advance to Seek state.	Otherwise advance to Settle
;  state.

FlExSelect:
	call	GetDrivePtr
	OR	[BX].DrvFlag,Fmotoron	; we've been selected, so motor is on
	TEST	[BX].DrvFlag,Frestor	; Is a restore needed?
	JE	NoRestore		; No
	call	SetTimer2		; set a sanity/motor stop timer
	MOV	Floppy.State,Recal	; Next state will be recalibrate
	CALL	Rcl765			; Start the recalibrate
	RET				; Done until floppy interrupt arrives

NoRestore:				; Start the seek if any
	CALL	Seek765			; Start the seek to cylinder
	JNC	SeekOK			; Already on correct cylinder
	MOV	Floppy.State,Seek	; Next state is Seek
	call	GetDrivePtr
	call	SetTimer2		; set sanity timer
	RET				; Done until interrupt on seek done



;*	Floppy state Recal
;
;	If error, set state is Error.  Else, load drive
;  specs into controller and advance to Select state.

FlExRecal:
	CALL	Sense765
	OR	AX,AX			; Error in recal?
	JNZ	SeekErr			; Yes
RecalOK:
	CALL	Spec765			; Load drive specs
	MOV	Floppy.State,Select	; Back to select state now
flexj2: JMP	flexj1



;*	Floppy state Seek
;
;	If error, advance to Error state.  Otherwise, wait
;  for head to settle and advance to Settle state.

FlExSeek:
	CALL	Sense765		; Get status of seek
	OR	AX,AX			; Any error?
	JZ	SeekOK			; No
SeekErr:
	CALL	GetDrivePtr
	OR	[BX].DrvFlag,Frestor	; flag restore needed
	MOV	Floppy.State,Error	; Yes, next state is Error
	or	Floppy.ST1,8		; indicate seek error in an unused bit
	JMP	flexj2

SeekOK:
	MOV	Floppy.State,Settle	; Next state is Settle
	MOV	AL,DelaySettle
	CALL	GetFloppyParam		; Get the settle time in Msecs
	xor	ah,ah
	CALL	SetTimer1		; Set the timer
	JNC	flexj2
	RET



;*	Floppy state Settle
;
;	Start the read/write request and advance to the RdWri state.

FlExSettle:
	MOV	Floppy.State,RdWri	; Advance to read/write state
	CALL	RdWr765			; Start the I/O
	call	GetDrivePtr
	call	SetTimer2		; set sanity timer
	RET				; Done until floppy interrupt



;*	Floppy state RdWri
;
;	If error, next state is Error.	Otherwise next state is Done.

FlExRdWri:
	CALL	Fini765			; Get status of I/O
	OR	AX,AX			; Any error?
	JZ	RdWriOK			; No
	MOV	Floppy.State,Error	; Yes, go to error state
	JMP	flexj2

RdWriOK:
	MOV	Floppy.State,Done	; I/O is done
flexj3: JMP	flexj2



;*	Floppy state Done
;
;	If whole request is now complete, mark the request
;  as done and then start the next one if there is one.	 If the request is not
;  yet done, adjust values to show the amount of the request done and then go
;  back to the Calc state to do next part.

FlExDone:
	MOV	AL,Floppy.Flags
	AND	AL,Fwrite+Fverify+Fwrap1	; Only interested in these bits
	CMP	AL,Fwrap1		; Just read into scratch?
	JNE	DoneNotWrap		; No
	PUSH	DS
	PUSH	ES
	MOV	CX,Floppy.NumBytes	; CS = # bytes to write from scr
	LES	DI,Floppy.RealAddr	; ES:DI = real buffer
	LDS	SI,Floppy.Addr		; DS:SI = scratch buffer
	CLD
  REP	MOVSB				; Copy into real buffer
	POP	ES
	POP	DS
DoneNotWrap:
	AND	AL,Fwrite+Fverify	; Just want to see these bits
	CMP	AL,Fwrite+Fverify	; Just do write part of write+verify?
	JNE	DoneNotWritePart	; No
	AND	Floppy.Flags,NOT Fwrite ; Yes, do verify next
	mov	Floppy.State,Settle	;   don't need to calc or seek
	jmp	flexj3

DoneNotWritePart:
	CMP	AL,Fverify		; Just do verify part of write+verify?
	JNE	DoneNotVerify		; No
	OR	Floppy.Flags,Fwrite	; Yes, flip write back up for next
DoneNotVerify:
	MOV	AX,Floppy.NumSectors	; AX = # of sectors we did
	SUB	Floppy.Count,AX		; Adjust count to number left
	JZ	flxd3		; Request is done, tell DOS
	ADD	Floppy.First,AX		; Advance sector number
	MOV	AX,Floppy.NumBytes	; Number of bytes handled
	ADD	WORD PTR Floppy.RealAddr,AX ; Advance data address
	MOV	Floppy.State,Calc	; Go to Calc state
flexj4: JMP	flexj3

flxd3:
	mov	di,OFFSET Floppy
	mov	SI,OFFSET FloppyQueue	; DS:SI = head of floppy queue
	call	DoneRequest
	JMP	flexj4


;*	Floppy state Idle
;
;	Nothing hapenning except possible motor off timeout.

FlExIdle:
	call	GetDrivePtr
	CALL	SetTimer2		; Set the motor timer
	and	Floppy.Flags,NOT Factive
	SemSig	SwapSem2		; someone waiting to switch drive?
	RET


;*	Floppy state Error
;
;	If error count not exceeded, restore the drive and start
;  the request over again.  Otherwise set error in the packet and
;  advance to the Done state.

FlExError:
	CALL	Rst765			; Reset the controller
	CMP	Floppy.ErrCnt,ErrLim	; Reach error limit?
	JAE	FloppyFails		; Yes, request fails
	INC	Floppy.ErrCnt		; We are doing another try
	MOV	Floppy.State,Start	; Restart the request
	JMP	flexj4		; Back to state machine loop

FloppyFails:
	call	GetDrivePtr
	OR	CS:[BX].DrvFlag,Frestor ; Set drive needs a restore
	MOV	Floppy.State,Done	; Request is done
; Set error bits in request packet
	MOV	AX, WORD PTR Floppy.ST0 ; Get ST0, ST1
	mov	BL,2			; Drive not ready?
	test	AL,0cH
	jne	ErrorFound
	MOV	BL,6			; Bad seek?
	TEST	AH,8
	JNE	ErrorFound
	MOV	BL,4			; CRC error?
	TEST	AH,30H
	JNE	ErrorFound
	MOV	BL,8			; Sector not found?
	TEST	AH,85H
	JNE	ErrorFound
	MOV	BL,0			; Write protect?
	TEST	AH,2
	JNE	ErrorFound
	MOV	BL,12			; Catch-all error
ErrorFound:
	debug	4,4,<FD error: status $x code $b\n>,<ax,bx>
	PUSH	ES
	LES	DI,FloppyQueue		; Get ptr to request
	MOV	AL,BL
	MOV	AH,10000001B
	MOV	ES:[DI].RqStatus,AX	; Set error and code
	POP	ES
	JMP	flxd3			; Advance to Done state (via shortcut)

FloppyExecute	ENDP


    ASSUME	CS:BiosSeg,DS:NOTHING,ES:NOTHING

FloppyInterrupt PROC	FAR
	debug	4,8,<FlIntr\n>,<>
	cmp	SemInt13,0		; If a direct Int13 request is being
	jz	flinot13		;  made call the ROM floppy interrupt
	cmp	SemDiskIO,0		;  routine to handle it.
	jnz	flinot13
	int	int_savregs
	pushf
	call	dword ptr [OldIntEVec]
	iret
flinot13:
	TEST	Floppy.Flags,Factive	; device active?
	JZ	flinret			; no, go away
	INT	int_savregs		; save registers
	CALL	FloppyExecute
flinret: push	ax
	MOV	AL,20H			; send EOI to 8259
	OUT	20H,AL
	pop	ax
	IRET
FloppyInterrupt ENDP

SUBTTL	Timing routines for floppy disk
PAGE	+

;*  Data for timers
TimerActive	DB	0		; bit flags for active timers
TimerConv	DB	50		; conversion factor for ms => ticks
Timer1	DB	0			; One-shot time till restart intr. rtn.
Timer2	DB	0			; Repetitive 1 Hz timer
Timer2count	=	20		; Reload value for timer2

MOFFDELAY=	2			; turn off motor after 2 sec. inactivity

;***	SetTimer1 - Arm timer 1
;
;	SetTimer1 will arm the Timer1.	Input parameter
;	values in milliseconds will be converted to timer
;	ticks.
;
;	ENTRY	AX = delay value in milliseconds
;	EXIT	AL = timer ticks
;		CF set if timer armed
;		CF clear if zero count passed
;	USES	AX

SetTimer1	PROC
	TEST	AX,AX			; zero count?
	JNZ	sett10			; no
	CLC
	RET

sett10: DIV	TimerConv
	TEST	AH,AH			; remainder?
	JZ	sett11
	INC	AL			; yes, round up
sett11: MOV	Timer1,AL
	OR	TimerActive,1
	debug	4,8,<SetTimer1 $b\n>,<ax>
	STC
	RET
SetTimer1	ENDP

;***	SetTimer2 - Arm timer 2
;
;	SetTimer2 will set a motor off timeout for the
;	drive whose parameter block is pointed to by
;	CS:BX
;
;	ENTRY	CS:BX = pointer to per drive info.
;	EXIT
;	USES	NONE

SetTimer2	PROC
	TEST	TimerActive,2
	JNZ	sett21
	MOV	Timer2,Timer2Count
	OR	TimerActive,2
sett21: MOV	CS:[BX].Timer,MOFFDELAY
	debug	4,8,<SetTimer2\n>,<>
	RET
SetTimer2	ENDP



;	FloppyTimer is called every scheduler tick to perform
;  time related services for the floppy driver.	 There are
;  two services performed; rescheduling of interrupt time
;  service after a head load or motor startup delay, and
;  a motor turn off service when a drive is not active.
;
;  It's assumed that all registers have been saved by the
;  caller.

	ASSUME	CS:BiosSeg,DS:NOTHING,ES:NOTHING

	PUBLIC	FloppyTimer
FloppyTimer	PROC	FAR
	TEST	TimerActive,0ffH	; any timers active?
	JNZ	fltim1			; yes
	RET				; no, return quickly
fltim1: TEST	TimerActive,1		; Timer1 active?
	JZ	fltim3			; no
	DEC	Timer1			; Timer1 expired?
	JNZ	fltim3			; no
;*  Perform Timer1 service
	debug	4,8,<Timer 1 expired\n>,<>
	AND	TimerActive,NOT 1
	CALL	FloppyExecute		; push the states around a while
	RET				; don't do Timer2 service this time.

fltim3: TEST	TimerActive,2		; Timer2 active?
	JZ	fltim4			; no
	DEC	Timer2			; 1 Hz clock time?
	JZ	fltim5			; no
fltim4: JMP	fltim9
fltim5:
	debug	4,8,<Timer 2 expired\n>,<>
	MOV	BL,Timer2count		; reload the counter
	MOV	Timer2,BL

;*  Perform Timer2 service
	XOR	CH,CH			; No active timeouts seen
	XOR	DI,DI			; Start with drive A
TimeOutLoop:
	MOV	BX,DI
	ADD	BX,BX
	MOV	BX,FDinfo[BX]		; Get ptr to drive info
	TEST	CS:[BX].DrvFlag,Fmotoron	; motor on?
	JZ	fltim8			; no
	CMP	CS:[BX].Timer,0		; Is timer active for drive?
	JZ	fltim8			; No
	DEC	CS:[BX].Timer		; Yes, another tick has passed
	JNZ	fltim7
	cmp	di,Floppy.Current	; Current drive?
	jnz	fltim6			; no
	test	Floppy.Flags,Factive	; device active?
	jz	fltim6			; no, go ahead
	mov	Floppy.State,Error
	mov	Floppy.ErrCnt,ErrLim	; don't retry this one
	mov	Floppy.ST0,048H		; set not ready error
	call	FloppyExecute		; oops, sanity timeout
	jmp	fltim9
fltim6:
	AND	CS:[BX].DrvFlag,NOT Fmotoron	; stop drive motor
	MOV	AX,DI
	MOV	CL,AL
	ADD	CL,4
	MOV	AL,1
	SHL	AL,CL			; Get bit mask for motor on
	TEST	Floppy.DOR,AL		; Is motor already off?
	JE	fltim8			; Yes, go on to next drive
	NOT	AL			; Get all bits except this motor
	AND	Floppy.DOR,AL		; Clear this motor on
	MOV	DX,FD_PSEL
	MOV	AL,Floppy.DOR
	OUT	DX,AL			; Turn off motor
;;	cmp	di,Floppy.Current	; Current drive?
;;	jnz	fltim8			; no
;;	test	Floppy.Flags,Factive	; device active
;;	jz	fltim8			; no, go on to next drive
;;	call	DumpRegs		; oops, sanity timeout

fltim7: INC	CH			; Flag still active
fltim8: INC	DI			; Advance to next drive
	CMP	DI,WORD PTR NumFloppy	; Any more to check?
	JNE	TimeOutLoop		; Yes, do them
	OR	CH,CH			; Need to keep timer active?
	JNZ	fltim9			; Yes
	AND	TimerActive,NOT 2	; No, clear timeout is active
fltim9: RET

FloppyTimer	ENDP


IFDEF	DEBUGFLG
DumpRegs	PROC
	push	cs
	pop	ds
	debug	4,0fh,<Sanity Timeout!!\n>,<>
	mov	di,OFFSET Floppy
	debug	4,0fh,<Floppy struct\n	$x $x $x $x  $x $x $x $x\n>,<[di],[di.2],[di.4],[di.6],[di.8],[di.10],[di.12],[di.14]>
	debug	4,0fh,<	 $x $x $x $x  $x $x $x $x\n>,<[di.10h],[di.12h],[di.14h],[di.16h],[di.18h],[di.1ah],[di.1ch],[di.1eh]>
	call	GetDrivePtr
	debug	4,0fh,<Drive struct\n  $x $x $x $x  $x $x $x $x\n>,<[bx],[bx.2],[bx.4],[bx.6],[bx.8],[bx.10],[bx.12],[bx.14]>
	debug	4,0fh,<	 $x $x $x $x\n>,<[bx.16],[bx.18],[bx.20],[bx.22]>
	debug	4,0fh,<	 IMR IRR ISR	8259 status\n>,<>
	mov	al,0ah
	out	20h,al
	in	al,20h
	mov	bl,al

	mov	al,0bh
	out	20h,al
	in	al,20h
	mov	cl,al
	in	al,21h
	debug	4,0fh,<	 $b  $b	 $b\n>,<ax,bx,cx>
	debug	4,0fh,<765 status, data\n>,<>
	mov	dx,FD_PSTAT
	in	al,dx
	mov	bl,al
	mov	dx,FD_PDAT
	in	al,dx
	debug	4,0fh,<	    $b	    $b\n>,<bx,ax>
	sti
dmpr0:	jmp	dmpr0
DumpRegs	ENDP
ENDIF	;DEUBGFLAG

SUBTTL	Routines shared between Floppy and Hard disk drivers
PAGE	+

;***	Setup - Set request parameters into local structure.
;
;	Setup sets the Unit, First, Addr, Count and Flags fields in the
;	device structure which are used to drive the I/O.  The following
;	flags are affected:
;		Fwrite	This is a write request, not a read
;		Fverify This is a write with verify (verify when write
;			is cleared).
;	Other fields are copied from the DOS request packet.
;
;	ENTRY	SI	Pointer to device variables
;		ES:BX	Current request
;		AL	Unit number
;		DI	BPB for drive
;		DS	CS
;
;	EXIT	The following variables are set
;			[SI].Unit
;			[SI].First	The hidden sectors are added
;			[SI].RealAddr
;			[SI].Count
;			[SI].Flags

    ASSUME	CS:BiosSeg,DS:BiosSeg

Setup	PROC
	MOV	AX,ES:[BX].RqCount
	MOV	[SI].Count,AX		; Set number of sectors to do
	MOV	AX,ES:[BX].RqAddr
	MOV	WORD PTR [SI].RealAddr,AX
	MOV	AX,ES:[BX].RqAddr+2
	MOV	WORD PTR [SI].RealAddr+2,AX  ; Copy data address
	MOV	AL,ES:[BX].RqUnit	; Get unit number
	MOV	[SI].Unit,AL		; Set drive needed
	MOV	AX,ES:[BX].RqFirst	; Get the starting sector number
	ADD	AX,[DI].BPBhidsec	; Add # of hidden sectors
	MOV	[SI].First,AX		; Set 1st sector of I/O
	and	[SI].Flags,Factive+F2step	; mask excess flags
	CMP	ES:[BX].RqCmd,4		; Is this a read?
	JE	SetupDone		; Yes, all done
	OR	[SI].Flags,Fwrite	; No, flag this is a read
	CMP	ES:[BX].RqCmd,9		; Write with verify?
	JNE	SetupDone		; No, just write
	OR	[SI].Flags,Fverify	; Yes, set to verify too
SetupDone:
	RET
Setup	ENDP


;***	MapSector - compute head, sector, cylinder
;
;	MapSector takes the fields set up by Setup and figures out the
;	head, cylinder and sector involved.  If the request involves
;	multiple sectors, it figures out how many can be done at once
;	based on the number of sectors left on the track and that the
;	target address' offset does not wrap around 64k (the DMA on the
;	PC uses a 20 bit address, but the high 4 bits do not change when
;	the low 16 cycle back to 0).  If the request wraps around 64k, it
;	is split into 2 or 3 pieces which are all data before wrap, after
;	wrap and the wrap itself.  The wrap itself is transferred via a temp
;	buffer (ScratchBuffer).
;
;	ENTRY	SI	Pointer to device variables
;		ES:BX	Current request
;		AL	Unit number
;		DI	BPB for drive
;		DS	CS
;	EXIT	The following variables are set
;			[SI].Flags
;			[SI].Head
;			[SI].Cyl
;			[SI].Sector
;			[SI].NumSectors
;			[SI].NumBytes
;			[SI].Addr
;	USES	AX,CX,DX,DI
;

MapSector	PROC
	PUSH	ES
	les	CX,[SI].RealAddr
	MOV	WORD PTR [SI].Addr,CX		; copy RealAddr to Addr
	MOV	WORD PTR [SI].Addr+2,ES
	AND	[SI].Flags,NOT Fwrap1		; Clear buffer wrap flag

; Calculate the head, cylinder and sector of the start of the request
; from [SI].First
	POP	ES
	MOV	AX,[SI].First
	XOR	DX,DX
	DIV	[DI].BPBtrksiz		; Divide by sectors/track
;;	INC	DL
	MOV	[SI].Sector,DL		; Set sector to start at
	XOR	DX,DX
	DIV	[DI].BPBnhead		; Divide by number of heads
	MOV	[SI].Head,DL		; Set head number
	MOV	[SI].Cyl,AX		; Set cylinder number
	debug	8,4,<Cyl $d  Hd $b  Sec $b	>,<ax,dx,<word ptr [SI].Sector>>
;
; Now see how many sectors of request can be done.  The floppy
; controller will not advance tracks, but will allow reading or
; writing the remaining sectors on the track.
;
	MOV	AX,[DI].BPBtrksiz
	SUB	AL,[SI].Sector		; AL = # of sectors left on
					; track after desired.
	XOR	AH,AH
;;	inc	ax
	CMP	AX,[SI].Count		; Is whole request on this cyl?
	JB	maps2		; No, can only do what is left
	MOV	AX,[SI].Count		; Yes, use the actual # wanted
maps2:
	MOV	[SI].Numsectors,AX	; Set number to do this time
;
; Now have to normalize offset (add in paragraph) and then see if adding
; [SI].Numsectors causes overflow.  If it does, DMA will trash memory, so
; decrement Numsectors and loop.
;
	MOV	AX,WORD PTR([SI].Addr+2)
	MOV	CL,4
	SHL	AX,CL			; Convert para to offset
	ADD	AX,WORD PTR [SI].Addr	; Add in offset
	MOV	CX,AX			; Save offset of buffer
maps4:
	MOV	AX,[DI].BPBsecsiz
	MUL	[SI].NumSectors		; Get # bytes in transfer
	MOV	[SI].NumBytes,AX	; Set # bytes involved
	ADD	AX,CX			; Get final offset
	JAE	maps6			; No overflow, DMA will be ok
	OR	[SI].Flags,Fwrap2	; Flag we will be using scratch
	DEC	[SI].NumSectors		; Overflow, try using one less
	JNZ	maps4
;
; If we got here, no sectors can be transferred before the 64K
; boundary.  One sector must be transferred through a scratch buffer.
;
	debug	12,10h,<MapSector $x $x >,<ax,cx>
	INC	[SI].NumSectors		; Doing 1 sector of I/O
	OR	[SI].Flags,Fwrap1	; Flag we are using scratch
	MOV	AX,CS
	MOV	DI,OFFSET ScratchBuffer
	MOV	WORD PTR([SI].Addr),DI
	MOV	WORD PTR([SI].Addr+2),AX  ; Change buffer to scratch
	TEST	[SI].Flags,Fwrite	; Doing a write?
	JE	maps6			; No, All done
	PUSH	ES
	PUSH	DS
	PUSH	SI
	MOV	ES,AX			; ES:DI = scratch buffer
	mov	cx,[SI].NumBytes
	LDS	SI,[SI].RealAddr	; DS:SI = Data buffer
	CLD
REP	MOVSB				; Copy the write buffer
	POP	SI
	POP	DS
	POP	ES
maps6:
	RET
MapSector	ENDP




;***	DMAsetup - Set the DMA channel up to do the I/O
;
;	ENTRY	AL = DMA mode
;		AH = DMA channel number (2 or 3 only)
;		SI = pointer to device parameters
;	USES	AX,CX,DX
;

DMAsetup	PROC
	PUSH	AX
	XCHG	AH,AL
	OR	AL,4
	OUT	PDMA+10,AL		; set channel's mask bit
	OUT	PDMA+12,AL		; clear byte pointer F/F
	pop	ax
	push	ax			; restore AH, AL
	OR	AL,AH			; add channel number to command
	OUT	PDMA+11,AL		; Set DMA mode
	MOV	DX,PDMA
	ROL	AH,1
	ADD	DL,AH
	MOV	AX,WORD PTR [SI].Addr+2 ; Get segment of addr
	MOV	CL,4
	ROL	AX,CL			; Convert para to bytes
	MOV	CH,AL			; CH = 4 bits ROLed around
	AND	AL,0F0H			; Lose high bits rotated around
	ADD	AX,WORD PTR [SI].Addr	; Add in offset value
	ADC	CH,0			; Add in any carry
	OUT	DX,AL			; Output low byte of address
	MOV	AL,AH
	OUT	DX,AL			; Output high byte of address
	inc	dx			; address `word' count register
	MOV	AX,[SI].NumBytes	; # bytes in request
	dec	ax
	OUT	DX,AL
	MOV	AL,AH
	OUT	DX,AL			; Tell DMA how many bytes
	pop	ax			; get back channel number
	mov	dl,PDMAX
	add	dl,ah
	MOV	AL,CH
	AND	AL,0FH			; Only 4 bits are good
	OUT	DX,AL			; Output highest 4 bits of address
	MOV	AL,AH			; Channel to start
	OUT	PDMA+10,AL		; Clear channel's mask bit
	RET
DMAsetup	ENDP

;***	DoneRequest - Mark a request complete, setup to start next one
;
;	DoneRequest does common processing needed when a request
;	has been completed.  It will reset the device state,
;	dequeue the request, mark it complete, restart the
;	process and restart any process waiting on ScratchBuffer
;	if this request had reserved it.
;
;	ENTRY	SI	Pointer to head of queue
;		DI	Pointer to device information
;	EXIT	ES:BX	Next request
;	USES	AX,BX,DX,BP,ES


DoneRequest	PROC
	push	cs
	pop	ds
    ASSUME	ds:BiosSeg
	MOV	[DI].ErrCnt,0		; Reset error count
	MOV	[DI].State,Idle		; Assume will be idle
	MOV	DX,PullRequest
	CALL	DosFunction		; Pull the current request out
	JZ	dnrq2			; Nothing really completed
	MOV	AX,[DI].Count		; Get I/O left to do
	SUB	ES:[BX].RqCount,AX	; Adjust requested count by residual
	OR	ES:[BX].RqStatus,0100h	; set done bit
	MOV	AX,ES			; AX:BX = Request completed
	MOV	DX,ContinueProcess
	CALL	DosFunction		; Make process run again
	CMP	WORD PTR [SI]+2,0	; Is there another request to do?
	JZ	dnrq2			; No, let device shut down
	MOV	[DI].State,Start	; Yes, start up next request
dnrq2:
	test	[DI].Flags,Fwrap2	; had this request used ScratchBuffer?
	jz	dnrq4			; no
	SemSig	ScratchBufSem		; let anyone waiting proceed
	and	[DI].Flags,NOT Fwrap2
dnrq4:					; If both the fixed and floppy drivers
	push	bx			;  are idle, reset the busy flag and
	cmp	Floppy.State,Idle	;  continue any processes that were
	jne	dnrq5			;  waiting for it.
	cmp	Fixed.State,Idle
	jne	dnrq5
	mov	SemDiskIO,0
	mov	ax,ds
	mov	bx,offset SemDiskIO
	mov	dx,ContinueProcess
	call	DosFunction
dnrq5:
	pop	bx
	ret
DoneRequest	ENDP


;	FDGetBPB returns a pointer to the floppy disk BPB for the
;  selected media byte.	 The BPB contains various drive parameters
;  such as physical disk dimensions and the size of FATs and the
;  root directory.
;
;  Input:	AH =	Media byte
;		AL =	Drive number
;  Destroys:	None
;  Output:	CS:DI = Pointer to BPB

	ASSUME	DS:NOTHING,ES:NOTHING

FDGetBPB	PROC

	PUSH	AX
	PUSH	BX
	PUSH	CX
	PUSH	DX			; Save regs
	MOV	CL,AH			; Copy media value
	AND	CL,0F8H			; Look at just top 5 bits
	CMP	CL,0F8H			; Valid media byte?
	JE	BPBGood			; Yes
	MOV	AH,0FEH			; No, make it 8 sector 1 sided
BPBgood:
	MOV	BL,AL			; Get pointer to per drive info.
	XOR	BH,BH
	ADD	BX,BX
	MOV	DI,CS:FDinfo[BX]
	CMP	AH,CS:[DI].BPBmediab	; already set?
	JE	BPBdone			; yes, don't bother rebuilding
	MOV	AL,1			; Assume will have 1 FAT sector
	MOV	BX,64*256+8		; Assume # dir = 64,  8 sector
	MOV	CX,40*8			; Assume 320 sectors/disk
	MOV	DX,1*256+1		; Assume 1 head, 1 sector/allocate
	TEST	AH,2			; Is drive 8 or 9 sector?
	JNZ	BPBKnowSectors		; It's 8, we assumed right
	INC	AL			; 9 sector, incr # of FAT sectors
	INC	BL			; Set we have 9 sectors/cylinder
	ADD	CX,40			; Increase size to 360 sectors
BPBKnowSectors:
	TEST	AH,1			; Is disk double sided?
	JE	BPBKnowHeads		; No, we guessed right
	ADD	CX,CX			; Double size of disk
	MOV	BH,112			; Increase # of directory entries
	INC	DH			; Set 2 sectors/allocation unit
	INC	DL			; Set 2 heads
BPBKnowHeads:
	MOV	CS:[DI].BPBsecpau,DH		; Set sectors/allocation unit
	MOV	BYTE PTR CS:[DI].BPBndir,BH	; Set # of directory entries
	MOV	CS:[DI].BPBnsec,CX		; Set size of disk in sectors
	MOV	CS:[DI].BPBmediab,AH		; Set media byte
	MOV	BYTE PTR CS:[DI].BPBnfatsec,AL	; Set number of FAT sectors
	MOV	BYTE PTR CS:[DI].BPBtrksiz,BL	; Set sectors/track
	MOV	BYTE PTR CS:[DI].BPBnhead,DL	; Set # of heads
BPBdone:
	POP	DX
	POP	CX
	POP	BX
	POP	AX
	RET
FDGetBPB	ENDP


;	HDGetBPB returns a pointer to the hard disk BPB for the
;  selected unit.  The BPB contains various drive parameters
;  such as physical disk dimensions and the size of FATs and the
;  root directory.
;
;  Input:	AL =	Drive number
;  Destroys:	None
;  Output:	CS:DI = Pointer to BPB

	ASSUME	DS:NOTHING,ES:NOTHING

HDGetBPB	PROC
	PUSH	BX
	MOV	BL,AL			; Get pointer to per drive info.
	XOR	BH,BH
	ADD	BX,BX
	MOV	DI,CS:HDinfo[BX]
	POP	BX
	RET
HDGetBPB	ENDP


	ASSUME	DS:NOTHING,ES:NOTHING

BlockIfLocked	Proc	Near		; Block the current process if it has
	pushf				;  been locked out by an Int 13 request.
bifl1:	cli				;  Otherwise, set the busy flag to block
	cmp	SemInt13,0		;  out Int 13 requests.
	jz	bifl2
	push	dx
	push	cx
	push	bx
	push	ax
	mov	ax,cs
	mov	bx,offset SemInt13
	xor	cx,cx
	mov	dx,BlockProcess
	call	DosFunction
	pop	ax
	pop	bx
	pop	cx
	pop	dx
	jmp	bifl1
bifl2:
	mov	SemDiskIO,1
	popf
	ret
BlockIfLocked	endp

SUBTTL	Routines that interface to hard disk controller
PAGE	+

;***	HDCommand - send a command to the hard disk controller
;
;	HDCommand will send the previously set up command block
;	to the hard disk controller.
;
;	ENTRY	AL = value to be put in interrupt/DMA mask
;	EXIT	AL = status port value
;	USES	AX,CX,DX,SI

HDCommand	PROC
	mov	dx,HD_PSEL		; point to select port
	out	dx,al
;;	mov	cx,10			;BUGBUG - timing prob. w/ expansion box?
;;hdcom0: loop	hdcom0			;BUGBUG - timing prob. w/ expansion box?
	inc	dx			; point to mask port
	out	dx,al
	mov	dx,HD_PSTAT
hdcom1: in	al,dx			; get status
	and	al,0FH
	cmp	al,0DH			; test for busy, command/data, request
	jnz	hdcom1
	mov	si,OFFSET Fixed.DCB
	mov	cx,6
	cld
	dec	dx			; point to data port
hdcom2: lodsb
	out	dx,al
	loop	hdcom2
	inc	dx
;;	mov	cx,10			;BUGBUG - timing prob. w/ expansion box?
;;hdcom3: loop	hdcom3			;BUGBUG - timing prob. w/ expansion box?
	in	al,dx
	ret
HDCommand	ENDP

;***	HDWaitReq - wait for request bit in status register
;
;	HDWaitReq will pause until the request bit in the hard disk
;	status register is set.
;
;	ENTRY
;	EXIT	AL = status byte
;	USES	AX,DX

HDWaitReq	PROC
	mov	dx,HD_PSTAT
	in	al,dx
	test	al,01h			; request bit?
	jz	HDWaitReq
	ret
HDWaitReq	ENDP
SUBTTL	Routines that interface to floppy disk controller
PAGE	+

;***	GetDrivePtr - compute ptr to per drive info.
;
;	GetDrivePtr returns a pointer to the per-drive information
;	for the current drive.	Should not be called before the
;	current drive is set up by Sel765 in state CALC.
;
;	EXIT	BX = pointer to per drive table
;	USES	BX

GetDrivePtr	PROC
	mov	bx,cs:Floppy.Current
	add	bx,bx
	mov	bx,cs:FDinfo[bx]
	ret
GetDrivePtr	ENDP


;	GetFloppyParam is called to get a disk parameter from the parameter
;  block set up by the BIOS.  This block allows disk parameters to be changed
;  from the standard.
;
;  Input:	AL = parameter desired (see FloppyParam structure)
;  Destroys:	AX
;  Output:	AL = parameter byte desired

GetFloppyParam	PROC
	PUSH	DS
	PUSH	BX
	XOR	AH,AH
	MOV	BX,AX
	XOR	AX,AX
	MOV	DS,AX			; Point to INT area
	LDS	AX,DWORD PTR DS:(4*1EH) ; Get pointer to param block
	ADD	BX,AX			; Add in block offset
	MOV	AL,[BX]
	POP	BX
	POP	DS
	RET
GetFloppyParam	ENDP



;	Recalibrate the current drive.	Clear Restore flag, set cylinder to
;  unknown and issue command to controller.
;
;  Destroys:	AX,BX,DX
;

Rcl765	PROC
	AND	CS:[BX].DrvFlag,NOT Frestor	; Have restored drive
	MOV	CS:[BX].CurCyl,-1	; Flag don't know where we are
	MOV	AL,FD_CRESET
	CALL	Put765			; Put out reset command
	MOV	AX,Floppy.Current	; Get current drive
	CALL	Put765			; Tell controller which drive
	RET
Rcl765	ENDP


;	Reset the controller.
;
;  Destroys:	AX,CX,DX
;

Rst765	PROC
	MOV	AL,CS:Floppy.DOR
	AND	AL,NOT(DORmask)
	MOV	DX,FD_PSEL
	OUT	DX,AL
	MOV	CX,10000
RstDelayLoop:
	loop	RstDelayLoop
	OR	AL,DORmask
	MOV	CS:Floppy.DOR,AL		; Update value
	OUT	DX,AL
	RET
Rst765	ENDP


;	Load the drive specs into the controller.
;
;  Destroys:	AX,DX
;

Spec765 PROC
	MOV	AL,FD_CSPEC
	CALL	Put765
	MOV	AL,Spec1
	CALL	GetFloppyParam
	CALL	Put765
	MOV	AL,Spec2
	CALL	GetFloppyParam
	CALL	Put765
	RET
Spec765 ENDP


;	Get the interrupt status from the controller and into AX
;
;  Destroys:	AX,CX,DX
;

Sense765	PROC
	MOV	AL,FD_CSENSE		; Get status
	CALL	Put765
	CALL	Get765			; Read ST0
	PUSH	AX			; Save status
	CALL	Get765			; Read PCN (present cylinder number)
	POP	AX			; Restore status
	MOV	CL,6
	SHR	AL,CL			; Shift bits down
	AND	AX,3			; Leave only error bits
	RET
Sense765	ENDP


;	Select the current drive.  Return carry set if must wait until drive is
;  ready. FloppyExecute will be called again when the drive is ready.  The
;  code must wait either for a motor start or head load delay, otherwise it
;  returns with carry clear.
;
;  Destroys:	AX,BX,CX,DX
;

Sel765	PROC
	MOV	DX,FD_PSEL		; set DX = Digital Output Register
	MOV	CL,Floppy.Unit		; Get unit we want to use
	XOR	CH,CH			; CX = wanted unit
	CMP	Single,0		; Single drive system?
	JE	Sel765Double		; No, Unit is accurate
	MOV	CL,CH			; Yes, there is only drive 0
Sel765Double:
	CMP	CX,Floppy.Current	; Wanted same as current?
	MOV	Floppy.Current,CX	; Set new current unit
	JNE	SelectUnit		; No, must select new drive
	ADD	CL,4
	MOV	AL,1
	SHL	AL,CL			; AL = Bit for drive's motor on
	TEST	AL,Floppy.DOR		; Is the drive's motor still on?
	JE	SelectUnit		; No, must turn it back on
	MOV	AL,Floppy.DOR
	OUT	DX,AL			; ? For some reason output value again
	CLC				; Clear carry, don't have to wait
	RET

SelectUnit:
	MOV	AL,NOT(3)		; Drive select is low 2 bits
	AND	AL,Floppy.DOR		; Lose old select bits
	OR	AL,DORmask
	MOV	CL,BYTE PTR Floppy.Current ; get unit number
	OR	AL,CL			; Put in new select bits
	MOV	Floppy.DOR,AL		; Save new bits
	ADD	CL,4
	MOV	AL,1
	SHL	AL,CL			; Get bit for motor is on
	TEST	AL,Floppy.DOR		; Is drive's motor on?
	JE	SelectStartMotor	; No, must start motor
	MOV	AL,Floppy.DOR
	OUT	DX,AL			; Load the head
	MOV	AX,DelayLoad		; Load head delay
	CALL	SetTimer1
	RET

SelectStartMotor:
	OR	Floppy.DOR,AL		; Add in motor start bit
	MOV	AL,Floppy.DOR
	OUT	DX,AL			; Start the motor
	MOV	AL,DelayMotor
	CALL	GetFloppyParam		; Get the proper delay time in 1/8 sec
	mov	cl,125
	mul	cl			; convert to milliseconds
	CALL	SetTimer1		; Set timer for motor startup
	RET
Sel765	ENDP


;	Seek to the correct cylinder.  Set carry if have to wait for operation
;  to complete (we are not on right cylinder).
;
;  Destroys:	AX,BX,DX
;

Seek765 PROC
	MOV	AX,Floppy.Cyl		; Get cylinder wanted
	CMP	AX,CS:[BX].CurCyl	; Already on cylinder?
	JE	SeekDone		; Yes, return with carry clear
	MOV	CS:[BX].CurCyl,AX	; Set the new current cylinder
	MOV	AL,FD_CSEEK
	CALL	Put765			; Seek command
	MOV	AL,Floppy.Head		; Get head desired
	SHL	AL,1
	SHL	AL,1			; Move head # 2 bits left
	ADD	AL,BYTE PTR Floppy.Current	; Low 2 bits are unit (hhuu)
	CALL	Put765			; Put out drive and head select
	MOV	AX,Floppy.Cyl
	TEST	Floppy.Flags,F2step	; Need to double step?
	JE	SeekNoDouble		; No
	ADD	AX,AX			; Yes, double cylinder number
SeekNoDouble:
	CALL	Put765			; Give controller the cylinder
	STC				; Set carry, must wait for seek intr.
SeekDone:
	RET
Seek765 ENDP



;	Start the Read/write.  Set up the DMA channel and give a read or write
;  command to the controller depending on flag.
;
;  Destroys:	AX,CX,DX
;

RdWr765 PROC
	mov	ah,FD_DMA
	mov	si,OFFSET Floppy
	TEST	Floppy.Flags,Fwrite	; Is this a write?
	JNE	WriteSetup		; Yes
	MOV	AL,DMA_READ		; No, read
	CALL	DMAsetup		; Set up the DMA
	MOV	AL,FD_CREAD		; Want to read
	JMP	SHORT RdWrLoc		; Now put out rest of command

WriteSetup:
	MOV	AL,DMA_WRITE
	CALL	DMAsetup		; Set DMA up for write
	MOV	AL,FD_CWRITE		; Want to write
RdWrLoc:
	CALL	Put765			; Put out command
	MOV	AL,Floppy.Head
	ADD	AL,AL
	ADD	AL,AL			; Form HHxx Binary
	ADD	AL,BYTE PTR Floppy.Current	; Form HHUU
	CALL	Put765			; Output unit and head
	MOV	AX,Floppy.Cyl
	CALL	Put765			; Output cylinder
	MOV	AL,Floppy.Head
	CALL	Put765			; Output head again?
	MOV	AL,Floppy.Sector
	inc	al
	CALL	Put765			; Output sector
	MOV	AL,SectorSize
	CALL	GetFloppyParam		; Get sector size code
	CALL	Put765			; Tell controller sector size
	MOV	AL,CylSize
	CALL	GetFloppyParam		; Get number of sectors/cylinder
	CALL	Put765			; Tell controller
	MOV	AL,DataGap		; Gap length for read/write
	CALL	GetFloppyParam
	CALL	Put765			; Tell controller gap length
	MOV	AL,ValueDTL
	CALL	GetFloppyParam		; Get value for DTL
	CALL	Put765			; Since bytes/sector#0, this is a
					; meaningless value, but controller
					; wants to see something
	RET
RdWr765 ENDP



;	Fini765 gets the completion status.
;
;  Destroys:	AX,CX,DX
;  Returns:	AL
;

Fini765 PROC
	push	es
	push	di
	push	cs
	pop	es
	mov	di,OFFSET Floppy.ST0
	MOV	CX,7
fini1:	CALL	Get765
	stosb
	loop	fini1
	mov	al,Floppy.ST0
	mov	cl,6
	SHR	AL,CL
	AND	AX,3			; Mask down to value to return
	pop	di
	pop	es
	RET
Fini765 ENDP



;	Put765 writes a command to the controller.
;
;  Input:	AL = value
;  Destroys:	AX,DX
;

Put765	PROC
	PUSH	AX			; Save the value to write
PutWaitLoop:
	MOV	DX,FD_PSTAT
	IN	AL,DX			; Get status
	AND	AL,FD_SDIO+FD_SRQM
	CMP	AL,FD_SRQM			; Controller ready for data?
	JNE	PutWaitLoop		; No, keep waiting
	POP	AX			; Get value back
	MOV	DX,FD_PDAT
	OUT	DX,AL			; Put out value
	RET
Put765	ENDP


;	Get765 gets a value back from the controller into AL.
;
;  Destroys:	AX,DX
;  Returns:	AL
;

Get765	PROC
	MOV	DX,FD_PSTAT
	IN	AL,DX			; Get status
	AND	AL,FD_SDIO+FD_SRQM
	CMP	AL,FD_SDIO+FD_SRQM		; Controller data available?
	JNE	Get765			; No, wait for it
	MOV	DX,FD_PDAT
	IN	AL,DX			; Get value from controller
	ret
Get765	ENDP

Code	ENDS
	END