;
;	File:		SonySWIM3.a
;
;	Written by:	Gary Rensberger	1-Feb-93
;
;	Copyright:	© 1993-1994 by Apple Computer, Inc., all rights reserved.
;
;	Change History (most recent first):
;
;	  <SM22>	 1/31/94	LB		This file now builds a driver compatible with PDM and TNT.
;									Since the SWIM3 device registers are spaced differently on the
;									two machines, there is now a new vector table in the
;									negative-offset portion of SWIM3Vars (SonyVars) which is
;									filled-in with the addresses of the SWIM3 registers by
;									SWIM3DiskOpen, and every instruction in the SWIM3 code that
;									accesses a register has been changed to use an addressing mode
;									that goes through the table.  Also, routines which previously
;									required the SWIM3 base address in a2 now require a1 to point to
;									SonyVars (most did already) and routine header comments have
;									been changed to reflect that.
;	  <SM21>	 1/20/94	GMR		Rolled in another readTrack optomization from MissingLink.
;									Reversed the order of the vectors added in <SM20>, so the
;									offsets of the orginals won't change (to make patching simpler).
;	  <SM20>	  1/4/94	LB		Added support for Tsunami/TNT.  This consists of a temporary
;									build-time check on forTNTDebug for the SWIM3 register offsets,
;									and a runtime check for separate init code in the open routine.
;									Also, I have broken out the hardware-specific DMA functions into
;									separate subroutines, vectorized them in SWIM3Vars, and written
;									versions for TNT's Grand Central DMA controller.  These routines
;									have been moved to two new files, SonySWIM3AMIC.a and
;									SonySWIM3GC.a.
;	  <SM19>	12/22/93	GMR		Make sure SWIM3 error reg is cleared before starting the DMA in
;									RawTrackRead.
;	  <SM18>	12/22/93	GMR		Rolled in the last changes from mc900ftjesus, and missinglink.
;									(MC2-MC6).
;	  <SMG2>	  9/1/93	chp		Remove privately-defined AMIC constants and instead include
;									AMICEqu.a. (Some names changed.) _DMAIntInstall is no more. Use
;									equivalent, explicit inline code.
;	  <SM16>	 8/16/93	GMR		Fixed problem in identifying 720K mfm formats (vs GCR). SWIM3
;									gave no error reading the MFM header in GCR mode. The fix was to
;									change the order of format checking (try MFM first, then GCR).
;									Also added vectors to the low level routines (for patching).
;	  <SM15>	  8/9/93	GMR		Fixed a copy protect bug that crept back in.
;	  <SM14>	  8/4/93	GMR		Added support for MFM tags (though we can't support some of the
;									tag info on SWIM3).
;	  <SM13>	 7/20/93	GMR		Added 3 retries/track during MFM formats (GCR format changes to
;									come...) to make MFM formatting reliable with VM on.
;	  <SM12>	 7/19/93	GMR		Made reads more reliable under VM and sound playing, by
;									requesting for sectors in interleave order, rather then reading
;									'the next one that comes by'.
;	  <SM11>	 6/23/93	GMR		Two changes to copy protection- change how address headers are
;									found, and don't enable GCR conversion in RawTrackRead.
;	  <SM10>	 5/19/93	GMR		Modified the icon installation code to get the info from
;									universal tables instead of the driver.
;	   <SM9>	 5/10/93	GMR		Added back support for original SWIM3's (there are still many
;									out there).
;	   <SM8>	 4/26/93	GMR		Tweaked format to work with the new SWIM3's (ver 3.5). MFM
;									writes are now 1/1. Removed hack code for old SWIM3's. Update
;									drive status after ejecting.
;	   <SM7>	  4/2/93	GMR		Changed the parameters for the _DMAIntInstall call to match the
;									new pb.
;	   <SM6>	 3/16/93	GMR		Raw track read for GCR now reads 2 tracks of data, and parses
;									for the 'search' position before copying to user buffer.
;	   <SM5>	 3/10/93	GMR		Added remaining calls (raw track read, etc) to make driver
;									functionally complete. Added code to conditionally check 
;									SWIM version, and enable writes if new chip. Increased
;									read performance; GCR reads are now 1/1 when using new chip.
;									SeekTrack is now asynchronous.
;	   <SM4>	  3/4/93	GMR		Reset the floppy DMA register, so it's base offset will get
;									initialized properly in the Open code.
;	   <SM3>	 2/23/93	GMR		Install DMA interrupt handler using Sams new installation trap.
;									The AMIC DMA base is now setup, and no longer needs to be done
;									here.
;	   <SM2>	  2/9/93	GMR		Added a missing endwith to end of file.
;	   <SM1>	  2/5/93	GMR		Added for first time.
;_______________________________________________________________________
;
;	Sony SWIM3 driver
;
;	This file contains the SWIM3 (DMA based floppy) driver for PDM.
;
;	To do:
;_______________________________________________________________________

			TITLE	'SONY SWIM3 Driver - 3.5" '

			STRING	ASIS
			
			INCLUDE	'AMICEqu.a'
			INCLUDE 	'TrapsPrivate.a'	; for the new BlockMove OpWord
			
;	next INCLUDES for TNT, added 12/17/93 by Monte Benaresh
			INCLUDE		'DBDMA.a'
			INCLUDE		'GrandCentralPriv.a'


			PRINT	NOMDIR
			MACHINE	MC68020

_GetMicroSeconds	OpWord	$A193		; new time manager trap returns current time in microseconds

FAST_BMOVE			EQU		1			; 1 = use fast native blockMove which doesn't use the DCBZ instruction.



********************* NOTE:	The SWIM3 register offset equates are now obsolete because	*****************
*********************		the driver now uses an address table filled in at runtime.	*****************
;
;	Current Grand Central has SWIM3 registers offset by $10 instead of $200.
;
;	Added 12/22/93 by Monte Benaresh
;

;------------------------------
; SWIM3 offsets for Grand Central
;------------------------------
;Timer 			equ 	$010 			; Write the timer
;Error			equ		$020			; Error register
;ParamData   	equ 	$030 			; Set the 16 parameter registers
;Phase			equ 	$040 			; Set phase lines states and directions
;Setup			equ 	$050 			; Set the current configuration
;Zeroes   		equ 	$060 			; Write Mode reg: 1's clr bits, 0's=don't care
;Mode	   		equ 	$060 			; Read Mode (returns current mode reg value)
;Ones 			equ 	$070 			; Write Mode reg: 1's set bits, 0's=don't care
;Handshake		equ 	$070 			; Read Handshake register
;Interrupt		equ 	$080 			; Interrupt register
;Step			equ		$090			; Step register
;CurTrack		equ		$0A0			; Track register
;CurSect			equ		$0B0			; Sector register
;Gap				equ		$0C0			; Gap register (write)
;FormatByte		equ		$0C0			; Current format byte (read)
;FirstSector		equ		$0D0			; First sector to start xfer
;SectorsToXfer	equ		$0E0			; Number of sectors to xfer
;IntMask			equ		$0F0			; Interrupt mask register


;------------------------------
; SWIM3 offsets
;------------------------------
;Timer 			equ 	$0200 			; Write the timer
;Error			equ		$0400			; Error register
;ParamData   	equ 	$0600 			; Set the 16 parameter registers
;Phase			equ 	$0800 			; Set phase lines states and directions
;Setup			equ 	$0A00 			; Set the current configuration
;Zeroes   		equ 	$0C00 			; Write Mode reg: 1's clr bits, 0's=don't care
;Mode	   		equ 	$0C00 			; Read Mode (returns current mode reg value)
;Ones 			equ 	$0E00 			; Write Mode reg: 1's set bits, 0's=don't care
;Handshake		equ 	$0E00 			; Read Handshake register
;Interrupt		equ 	$1000 			; Interrupt register
;Step			equ		$1200			; Step register
;CurTrack		equ		$1400			; Track register
;CurSect			equ		$1600			; Sector register
;Gap				equ		$1800			; Gap register (write)
;FormatByte		equ		$1800			; Current format byte (read)
;FirstSector		equ		$1A00			; First sector to start xfer
;SectorsToXfer	equ		$1C00			; Number of sectors to xfer
;IntMask			equ		$1E00			; Interrupt mask register



;------------------------------
; Error register equates
;------------------------------
UnderrunFIFO	equ 	%00000001		; Underrun FIFO
;				equ 	%00000010		; ...
OverrunFIFO 	equ 	%00000100		; Overrun FIFO
;				equ 	%00001000		; ...
;				equ 	%00010000		; ...
;				equ 	%00100000		; ...
CRCAddrErr		equ 	%01000000		; CRC error in address header
CRCDataErr		equ 	%10000000		; CRC error in data field

CRCAddrErrBit	equ		6


;------------------------------
; Setup
;------------------------------
InvWrData		equ 	%00000001		; 1=invert write data
CopyProtMode	equ 	%00000010		; 1=copy protect mode
GCRMode 		equ 	%00000100		; select GCR mode
ClockDiv2		equ 	%00001000		; internal clock frequency / 2
DisGCRConv		equ 	%00010000		; 1=disable GCR conversion
IBMDrive		equ 	%00100000		; IBM type drive
GCRWrites		equ 	%01000000		; 1=GCR writes, 0=MFM writes
SoftReset		equ 	%10000000		; software reset

GCRModeBit		equ		2				; bit 2 is gcrmode


;------------------------------
; Handshake
;------------------------------
MarkInFIFO		equ 	%00000001		; next byte read from FIFO is a Mark
IntPending		equ 	%00000010		; an interrupt is pending
DriveRdData 	equ 	%00000100		; state of the RdData signal from the drive
DriveSense		equ 	%00001000		; state of the Sense signal from the drive
DriveEnabled	equ 	%00010000		; a drive is explicitly enabled, or timing out
rErrorValid 	equ 	%00100000		; error register is non-zero
Dat2Bytes		equ 	%01000000		; 2 bytes valid / available in the FIFO
Dat1Byte		equ 	%10000000		; 1 byte valid / available in the FIFO

IntPendBit		equ		1
DriveRdDataBit	equ		2



;------------------------------
; Zeroes / Ones / Mode
;------------------------------
EnableInts		equ 	%00000001		; enable interrupts
Drive1Enabled	equ 	%00000010		; select Drive 1
Drive2Enabled	equ 	%00000100		; select Drive 2
StartAction 	equ 	%00001000		; go active
WriteMode		equ 	%00010000		; set the chip into Write mode
HeadSelect		equ 	%00100000		; select head (side) 0 or 1
FormatMode		equ 	%01000000		; format mode
GoStep	 		equ 	%10000000		; start stepping to desired track

HeadSelectBit	equ 	5				; select head (side) 0 or 1 bit #



;------------------------------
; wIntMask
;------------------------------
timerIntNum		equ		0
stepIntNum		equ		1
idIntNum		equ		2
doneIntNum		equ		3
senseIntNum		equ		4


;------------------------------
; phase lines - floppy address equates
;------------------------------
ph0 			equ 	%00000001		; phase line 0 output data
ph1 			equ 	%00000010		; phase line 1 output data
ph2 			equ 	%00000100		; phase line 2 output data
ph3 			equ 	%00001000		; phase line 3 output data
ca0 			equ 	ph0
ca1 			equ 	ph1
ca2 			equ 	ph2
lstrb			equ 	ph3


;------------------------------
; disk drive pulse addresses / data
;------------------------------
wDirNextAdr 	equ 	0*HeadSelect+0*ca2+0*ca1+0*ca0
wDirPrevAdr 	equ 	0*HeadSelect+1*ca2+0*ca1+0*ca0
wStepOnAdr		equ 	0*HeadSelect+0*ca2+0*ca1+1*ca0
wStepOffAdr 	equ 	0*HeadSelect+1*ca2+0*ca1+1*ca0
wMotorOnAdr 	equ 	0*HeadSelect+0*ca2+1*ca1+0*ca0
wMotorOffAdr	equ 	0*HeadSelect+1*ca2+1*ca1+0*ca0
wEjectOffAdr	equ 	0*HeadSelect+0*ca2+1*ca1+1*ca0
wEjectOnAdr 	equ 	0*HeadSelect+1*ca2+1*ca1+1*ca0
;				equ 	1*HeadSelect+0*ca2+0*ca1+0*ca0	; undefined
;				equ 	1*HeadSelect+1*ca2+0*ca1+0*ca0	; undefined
wDiskInPlAdr	equ 	1*HeadSelect+0*ca2+0*ca1+0*ca0	; don't know for sure if you can
wNoDiskInPlAdr	equ 	1*HeadSelect+1*ca2+0*ca1+0*ca0	; really write to these addresses
wMFMModeOnAdr	equ 	1*HeadSelect+0*ca2+0*ca1+1*ca0
wGCRModeOffAdr	equ 	wMFMModeOnAdr
wMFMModeOffAdr	equ 	1*HeadSelect+1*ca2+0*ca1+1*ca0
wGCRModeOnAdr	equ 	wMFMModeOffAdr
;				equ 	1*HeadSelect+0*ca2+1*ca1+0*ca0	; undefined
;				equ 	1*HeadSelect+1*ca2+1*ca1+0*ca0	; undefined
;				equ 	1*HeadSelect+0*ca2+1*ca1+1*ca0	; undefined
;				equ 	1*HeadSelect+1*ca2+1*ca1+1*ca0	; undefined

; disk drive sense addresses

rDirPrevAdr 	equ 	0*HeadSelect+0*ca2+0*ca1+0*ca0
rStepOffAdr 	equ 	0*HeadSelect+0*ca2+0*ca1+1*ca0
rMotorOffAdr	equ 	0*HeadSelect+0*ca2+1*ca1+0*ca0
rEjectOnAdr 	equ 	0*HeadSelect+0*ca2+1*ca1+1*ca0
rRdData0Adr 	equ 	0*HeadSelect+1*ca2+0*ca1+0*ca0
rMFMDriveAdr	equ 	0*HeadSelect+1*ca2+0*ca1+1*ca0
rDoubleSidedAdr equ 	0*HeadSelect+1*ca2+1*ca1+0*ca0
rNoDriveAdr 	equ 	0*HeadSelect+1*ca2+1*ca1+1*ca0
rNoDiskInPlAdr	equ 	1*HeadSelect+0*ca2+0*ca1+0*ca0
rNoWrProtectAdr equ 	1*HeadSelect+0*ca2+0*ca1+1*ca0
rNotTrack0Adr	equ 	1*HeadSelect+0*ca2+1*ca1+0*ca0
rNoTachPulseAdr equ 	1*HeadSelect+0*ca2+1*ca1+1*ca0
rIndexPulseAdr	equ		rNoTachPulseAdr
rRdData1Adr 	equ 	1*HeadSelect+1*ca2+0*ca1+0*ca0
rMFMModeOnAdr	equ 	1*HeadSelect+1*ca2+0*ca1+1*ca0
rGCRModeOffAdr	equ 	rMFMModeOnAdr
rNotReadyAdr	equ 	1*HeadSelect+1*ca2+1*ca1+0*ca0
rNotRevisedAdr	equ 	1*HeadSelect+1*ca2+1*ca1+1*ca0
r1MegMediaAdr	equ 	rNotRevisedAdr




;----------------------------------------------------------------------------------------------

DDVersion			equ		$0410				; disk duplicator version 4.10 and earlier

; Drive number assignments

intDriveNumber		equ 	1					; drive number 1 is internal drive
extDriveNumber		equ 	2					; drive number 2 is external drive

NumberOfDrives		equ 	extDriveNumber+2	; drive 0 (ignored), drive 1 & 2, and drive 3 (spare)
MaxDriveNum			equ 	extDriveNumber


;		Disk Drive Kinds

;noDriveKind 		equ 	0					; no drive connected
;unknownDriveKind	equ 	1					; unspecified drive kind
;SSGCRDriveKind		equ 	2					; single sided 400K GCR disk drive
;DSGCRDriveKind		equ 	3					; double sided 400K/800K GCR disk drive
;DSMFMGCRDriveKind	equ 	4					; double sided 400K/800K GCR, 720K, 1440K MFM disk drive
;HD20DriveKind		equ		7					; HD20

;		Disk Media Kinds

NoMediaKind 		equ 	0					; no disk media in drive
unknownMediaKind 	equ		1					; unknown disk media
HD20MediaKind		equ 	2					; HD20 20MB hard disk media
LoDenMediaKind		equ 	3					; 400K, 800K, 720K Media (Low density)
HiDenMediaKind		equ 	4					; 1440K Media (High density)

;		Disk Format Kinds

uncheckedFormat 	equ 	0					; disk format has not been checked
unknownFormat		equ 	1					; disk format could not be determined
HD20Format			equ 	2					; HD20 20MB hard disk
GCR400Kformat		equ 	3					; single sided	400K GCR disk
GCR800Kformat		equ 	4					; double sided	800K GCR disk
MFM720Kformat		equ 	5					; double sided	720K MFM disk
MFM1440Kformat		equ 	6					; double sided 1440K MFM disk HD media
GCRonHDformat		equ 	7					; 400K or 800K GCR format on HD media (user error)


; 		Error codes

cantReadHdr			equ		-401				; couldn't read a sector header


; ———————————————————————————————————————————————————————————————————————————————————————
;	driver Control codes
; ———————————————————————————————————————————————————————————————————————————————————————

;killCode			equ		1					; KillIO code
;verifyCC			equ		5					; 'verify' control code
;formatCC			equ		6					; 'format' control code
;tagBufCC			equ		8					; 'set tag buffer' control code
;tCacheCC			equ		9					; 'track cache' control 
;iconIDCC			equ		20					; 'get icon id' control code
;iconCC				equ		21					; 'get icon' control code
;iconLogCC			equ		22					; 'get logical icon' code
;infoCC				equ		23					; 'get drive info' code
;GetRawDataCC		equ		18244				; 'get raw track data' code
;FmtCopyCC			equ		21315				; one-pass format/copy/verify for disk duplicator

;TotalControlCalls 	equ		11					; 11 currently defined
;MaxControlCalls	equ		TotalControlCalls+4	; allow 4 extra for expansion

TotalVectors		equ		14					; 14 patch vectors

; ———————————————————————————————————————————————————————————————————————————————————————
;	driver Status codes
; ———————————————————————————————————————————————————————————————————————————————————————

;fmtLstCode			equ		6					; returns a list of disk formats
;drvStsCode			equ		8					; status code for drive status	(in SysEqu.a)
;mfmStsCode			equ		10					; 'Get MFM status'
;DupVerSts			equ		17494				; disk duplicator version supported (to match features)
;FmtByteSts			equ		21315				; return address header format byte for disk duplicator

;TotalStatusCalls 	equ		5					; 5 currently defined
;MaxStatusCalls		equ		TotalStatusCalls+4	; allow 4 extra for expansion

;	Flags used in decode tables

ChkDriveNum			equ		7
ChkDriveExists		equ		6






;	Disk Format constants

LastCylinder		equ 	80-1				; cylinders are numbered 0..79
MinSectors			equ 	9					; minimum 9 sectors supported per head	(720K)
MaxSectors			equ 	18					; maximum 18 sectors supported per head	(1440K)

TagSize 			equ 	12					; Tags are 12 bytes long
BlockSize			equ 	512 				; Disk blocks contain 512 data bytes

gcrDMASize			equ		704+11+9			; 704 bytes for GCR, + header + trailer
gcrDataSize			equ		703					; number of nibbles in a GCR sector
mfmDMASize			equ		34+512+10			; # bytes reserved/MFM sector in DMA buffer
mfmDataSize			equ		512					; 512 bytes/block for MFM
gcrRawTrackCnt		equ		12*800*2			; # of bytes for 2 tracks of data (max)

GCRInitialSyncCount equ 	200 				; start track with 200 sync groups before first sector
GCRMinSyncCount 	equ 	4					; no less than 4 sync groups between GCR sectors
GCRDefaultSyncCount equ 	8					; start with 8 sync groups between GCR sectors
MFMInitialGapSize	equ 	80					; size of MFM Gap between index and index mark
MFMSyncSize 		equ 	12					; size of MFM sync field before Index/Addr/Data marks
MFMIndexMarkGapSize equ 	50					; size of MFM Gap between index mark and sector 1
MFMAddrMarkGapSize	equ 	22					; size of MFM Gap between address and data
MFM720KDataGapSize	equ 	80					; size of MFM Gap following 720K sectors
MFM1440KDataGapSize equ 	101 				; size of MFM Gap following 1440K sectors
MFMFinalGapSize 	equ 	102					; size of MFM Gap between last sector to index (act)

MFMFmtRetryCnt	 	equ 	3					; # retries allowed during MFM format.


;	Delay Timing / Timeout constants

PollRate			equ 	500					; wake up and look around every 500 ms
MotorTimeoutCount	equ		5					; motor timeout is 2.0 .. 2.5 seconds (5 polls)

ReadyPollRate		equ 	-750		 		; check ready every 750 uSeconds
ReadyTimeoutCount	equ		1000000/750			; max poll time is 1 second
ReadyDelay			equ		10					; 10ms extra delay after /Ready, for WolfPack drives

MotorOnDelay		equ 	50					; Delay 50ms after motor on before checking ready
ChuckingDelay		equ 	500					; Delay 500ms for proper disk chucking
MotorOnSettle		equ 	300					; Motor speed within 1.5 % 300ms after drive ready
MotorStopDelay		equ 	200					; Delay 200ms after MotorOff to spin down
SeekDelay			equ 	-500				; wait 500usec after seek before checking ready

SectorDataTime		equ		8					; 8ms is approx time for the data (MFM, GCR slightly longer)

SectorTimeout		equ		50					; 50 ms timeout to find a sector header
TrackTimeout		equ		300					; 300 ms timeout for track operations
FmtTrackTime		equ		600					; 600 ms timeout to find index, then write the track
StepTimeout			equ		72*160				; ≈ 11 ms timeout to send 160 step pulses (double the max of 80 tracks)

EjectDelay			equ		1500				; 1.5 seconds for eject to complete

GCRWriteToRead		equ 	620 				; 620µs max time from write to read data valid again


;	Sector Buffer / Track Cache constants

TotalBuffers		equ		36+4				; buffer storage for 36 sectors (+ 4 temporary buffers)
DMABufLength		equ		1024*44				; length of our floppy DMA buffer
DBDMABufSize		equ		1024*44 + 2*DBDMADescriptor.size



;	Error handling / recovery constants

RecalsMax			equ		1					; Max Recals allowed before hard error
IOErrorsMax			equ		2					; Max I/O errors allowed before Recal


IntBlock			record	0,INCREMENT
intCompletion		ds.l	1					; our specific completion address
intRegSave			ds.l	4					; space to save registers a3,d1-d3
IntBlockSize		equ		*					; size of our block				
					endr


TimerBlock			record	{TMPBStart},INCREMENT
myCompletion		ds.l	1					; our specific completion address
regSave				ds.l	4					; space to save registers a3,d1-d3
TMPBStart			ds.b	tmXQSize			; allocate a time manager block
TimerBlockSize		equ		*-myCompletion		; size of our block				
					endr
TimeMgrOffset		equ		TimerBlock.TMPBStart-TimerBlock.myCompletion



MyDriveInfo			record	0,increment			; drive specific variables
WriteProtected		ds.b	1					; bit7=1=write protected
DiskInPlace			ds.b	1					; 0 = no disk place, 1 or 2 = disk in place
Installed			ds.b	1					; 0 = don't know, 1=installed, $FF=not installed
Sides				ds.b	1					; bit7=0=single sided, bit7=1=double sided
DriveQElement		ds.b	dQDrvSz2+2
MyDriveInfoSize	equ	*							; size of drive specific variables
					endr

DriveStatusRec		record	0,increment			; disk status results
StatWriteProt		ds.b	1					; bit7=1=write protected
StatDiskInPlace		ds.b	1					; 0 = no disk place, 1 or 2 = disk in place
StatInstalled		ds.b	1					; 0 = don't know, 1=installed, $FF=not installed
StatSides			ds.b	1					; bit7=0=single sided, bit7=1=double sided
StatTwoSidedFmt		ds.b	1					; FF=2 sided format
StatNewInterface	ds.b	1					; FF=new interface, 00 = old				
StatDiskErrors		ds.w	1					; errors for this drive
StatCurrentFmt		ds.b	1					; current format of disk
StatFmtAllowed		ds.b	1					; allowed formats for disk
StatDriveInfoB3 	ds.b	1 					; start of data for drive info control call
StatDriveInfoB2 	ds.b	1 					; high 2 bytes unused for now
StatDriveAttr		ds.b	1					; disk drive attributes
StatDriveType		ds.b	1 					; type of disk drive
StatDiskSize		ds.w	1					; # of blocks on disk
DriveStatusRecSize	equ		*	
					endr
					


;------------------------------------------------------------------------------------
SWIM3Vars			record	{PhysDriveNumber},INCREMENT
				
SWIMVarsStart		equ 	*

;	SWIM3 device register vector table, filled-in by SWIM3DiskOpen.
;	This is necessary to allow this driver to be used on machines with varying
;	SWIM3 device register spacings, e.g., PDM and TNT.
;
;	Added 1/25/94 by Monte Benaresh

SWIM3RegVects
vTimer				ds.l	1
vError				ds.l	1
vParamData			ds.l	1
vPhase				ds.l	1
vSetup				ds.l	1
vZeroes											; shared with Mode
vMode				ds.l	1
vOnes											; shared with Handshake
vHandshake			ds.l	1
vInterrupt			ds.l	1
vStep				ds.l	1
vCurTrack			ds.l	1
vCurSect			ds.l	1
vGap											; shared with FormatByte
vFormatByte			ds.l	1
vFirstSector		ds.l	1
vSectorsToXfer		ds.l	1
vIntMask			ds.l	1


;	Next vectors added 12/15/93 by Monte Benaresh

vClearDMAInt		ds.l	1					; clear floppy DMA interrupt
vStartDMAAction		ds.l	1					; enable floppy DMA interrupt, start SWIM3 action with timeout
vSetUpDMAXfer		ds.l	1					; set up address, count, and direction for DMA transfer
vStopDMA			ds.l	1					; stop the DMA controller

vSelectDrive		ds.l	1					; Low level routine vectors
vAddrAndStrb		ds.l	1					; (negative offset from globals ptr)
vAddrAndSense		ds.l	1					;
vSeekTrack			ds.l	1					;
vReCalibrate		ds.l	1					;
vStartReadyTimer	ds.l	1					;
vWaitDriveReady		ds.l	1					;
vTurnOnDrive		ds.l	1					;
vTurnOffDrive		ds.l	1					;
vFmtTrack			ds.l	1					;
vWriteTrack			ds.l	1					;
vReadTrack			ds.l	1					;
vRawTrackRead		ds.l	1					;
vReadSectorHdr		ds.l	1					;


; ••• drive dependent variables (start of positive offset globals)

PhysDriveNumber 	ds.b	NumberOfDrives		; physical drive number
DriveKind			ds.b	NumberOfDrives		; kind of drive attached
MediaKind			ds.b	NumberOfDrives		; kind of disk media in drive
DiskFormat			ds.b	NumberOfDrives		; format of disk in drive
CylinderValid		ds.b	NumberOfDrives		; current Cylinder (high byte)
CurrentCylinder 	ds.b	NumberOfDrives		; current Cylinder (low byte)
ErrorCount 			ds.w	NumberOfDrives		; Number of errors 

DriveInfoPtrs		ds.l	NumberOfDrives	 	; 0 based list of pointers to MyDriveInfo
FirstDriveInfo		ds.b	NumberOfDrives*MyDriveInfo.MyDriveInfoSize

CurrentStatus		ds.b	DriveStatusRec.DriveStatusRecSize	; our current drives status

ControlCallInfo		ds.l	1					; pointer to control call dispatching table
					ds.w	1					; number of Control Calls defined - 1
					ds.w	1					; default error if not found (ControlErr)
					ds.b	MaxControlCalls*8	; 2 byte csCode, 2 bytes flags, 4 bytes routine ptr 
				
StatusCallInfo		ds.l	1					; pointer to status call dispatching table
					ds.w	1					; number of Status Calls defined - 1
					ds.w	1					; default error if not found (StatusErr)
					ds.b	MaxStatusCalls*8
				
; drive independent variables

DCEpointer			ds.l	1					; ptr to DCE
DriverActive		ds.b	1					; idle = 0, active <> 0
CacheEnabled		ds.b	1					; $FF=enabled, $00=disabled
ReqDriveNumber		ds.w	1					; requested drive for current operation
CurrentDrive		ds.w	1					; drive currently selected or powered up
LastActiveDrive 	ds.w	1					; drive number of last successfully accessed drive


SWIM3IntVectors											; vectors for the 5 SWIM3 interrupts
TimeIntPB			ds.b	IntBlock.IntBlockSize		; 	timer interrupt
StepIntPB			ds.b	IntBlock.IntBlockSize		; 	step complete interrupt
IdIntPB				ds.b	IntBlock.IntBlockSize		; 	id read interrupt
DoneIntPB			ds.b	IntBlock.IntBlockSize		; 	sector data read interrupt
SenseIntPBr			ds.b	IntBlock.IntBlockSize		; 	sense line interrupt

PollingTMPB 		ds.b	TimerBlock.TimerBlockSize	; timer used for drive polling task
SettledTMPB 		ds.b	TimerBlock.TimerBlockSize	; timer used for Motor speed settled ≈1.5% timing
ReadyTMPB			ds.b	TimerBlock.TimerBlockSize	; timer used for Drive Ready / Sleep delay processing
ReadWriteTMPB		ds.b	TimerBlock.TimerBlockSize	; timer used for DMA/SWIM transfer timeouts


MediaIconPtr		ds.l	1					; ptr to our media icon
Drive1PhysIcon		ds.l	1					; ptr to our primary drive icon
Drive2PhysIcon		ds.l	1					; ptr to our secondary drive icon

AsyncPc				ds.l	1					; saved PC when waiting asynchronously
ReCalPc				ds.l	1					; PC when waiting in ReCalibrate
SeekPc				ds.l	1					; PC when waiting for Seek to send pulses to drive
ReadHdrPc			ds.l	1					; PC when waiting for a header to read
SettleTime 			ds.l	1					; settle time after drive ready
WaitReadyCount		ds.w	1					; timeout counter for WaitDriveReady

					ALIGN	4


DMARegSave			ds.l	4					; space to save registers a3,d1-d3 during DMA xfer
DMACompletionPtr	ds.l	1					; completion routine for DMA

DMABaseAddr			ds.l	1					; ptr to DMA controller in I/O space
FloppyDMAStart		ds.l	1					; offset to start of floppy DMA buffer
TrackCacheStart		ds.l	1					; ptr to start of floppy DMA buffer (logical address)

; next vars added 12/17/93 for TNT by Monte Benaresh
DBDMABufPtr			ds.l	1					; ptr to buffer for channel command descriptors
												; and track cache
DBDMADescPtr		ds.l	1					; ptr to our channel command descriptors


; Track Cache variables

SectorsToRead		ds.b	2					; # sectors needed for each head on current track 	(ReadTrack)
SectorsToWrite		equ		SectorsToRead		; sectors/side to write								(SWIM3Write)
FmtCopyVerify		equ		SectorsToRead		; $FF = verify after format/copy operation			(Format/Copy)
NumSectors			ds.w	1					; sector counter 									(WriteTrack)

WriteDMAPtr			ds.l	1					; temporary DMA buffer physical ptr (for writes)
WritePtr			ds.l	1					; temporary DMA buffer logical ptr (for writes and verifies)
VerifyPtr			ds.l	1					; ptr to our verify buffer (logical)
NibbilizeDMAPtr		ds.l	1					; ptr into DMA buffer for Nibbilize routine

TrackCacheDMAPtr	ds.l	TotalBuffers		; offsets to each DMA sector buffer for a track
TrackCachePtr		ds.l	TotalBuffers		; logical address of each DMA sector buffer for a track
SectorBufPtr		ds.w	TotalBuffers		; buffer numbers for each sector, 
SectorValid			equ		15-8				; bit 15=1 if valid
SectorNeeded		equ		14-8				; bit 14=1 if needed for this read/write

TCTrackNum			ds.w	1					; track # in track cache

SearchMode			ds.w	1					; search mode					(for RawTrackRead)
ByteCount			ds.l	1					; # of bytes to read			(for RawTrackRead)
TagBufPtr			ds.l	1					; pointer to users tag buffer	(for read/write)
CurTagPtr			ds.l	1					; pointer into users tag buffer	(for read/write)

UserTagsPtr			ds.l	1					; pointer to tag buffer 		(for format)
UserBufPtr			ds.l	1					; pointer to data buffer 		(for format)

ClockBuffer			equ		UserTagsPtr			; pointer to clock buffer		(for RawTrackRead)
DataBuffer			equ		UserBufPtr			; pointer to data buffer		(for RawTrackRead)
					
SectHdrCylinder		ds.b	1					; Cylinder number from sector header
SectHdrHead 		ds.b	1					; Head number from sector header
SectHdrSector		ds.b	1					; Sector number from sector header
SectHdrFmtKind		ds.b	1					; Format Kind or Block Size from sector header
SectHdrHandshake	ds.b	1					; Handshake register after reading last byte
SectHdrError		ds.b	1					; Error register after reading last byte

SeekingCylinder		ds.b	1					; cylinder number that we are seeking
StateFlags			ds.b	1					; driver state flags
TrackTimer			equ		0					; bit 0 = track timeout installed
					
LogicalBlock		ds.l	1					; Logical Block number input to BlockToPhysAddr
BlockCount			ds.l	1					; # of blocks to read/write
BlockAddress		ds.l	1					; address of user buffer for read/write

PhysCylinder		ds.b	1					; Physical Cylinder returned by BlockToPhysAddr
PhysHead			ds.b	1					; Physical Head returned by BlockToPhysAddr
PhysSector			ds.b	1					; Physical Sector (head relative) returned by BlockToPhysAddr
PhysCylSector		ds.b	1					; Physical Sector (cylinder relative) returned by BlockToPhysAddr
PhysSectsPerCyl		ds.b	1					; Number of Sectors per cylinder returned by BlockToPhysAddr
PhysSectsPerHead	ds.b	1					; Number of Sectors per head returned by BlockToPhysAddr
PhysCylBias 		ds.b	1					; Starting Cylinder number of speed group

CurSectsPerHead		ds.b	1					; number of sectors per head for current cylinder
Interleave			ds.b	1					; sector interleave factor
					ds.b	1					; align
					
RecalsLeft			ds.w	1					; number of Recals remaining before hard error
IOErrorsLeft		ds.w	1					; number of I/O errors remaining before Recal

SectorGapSize		ds.b	1					; number of gap bytes or sync groups to fmt between sectors
FmtByteBlkSize		ds.b	1					; GCR Format byte / MFM block size for formatting
SectorMap			ds.b	MaxSectors			; sector interleave buffer for formatting

MotorTimingOut		ds.b	1					; number of polls to left before turning drive off

SWIMVarsSize		equ 	*-SWIMVarsStart 	; number of bytes of SWIMVars
					endr



;==================================================================================================



;----------------------------------------------------------------------
;	Decode table for Status Calls (gets copied into RAM for patching)
;----------------------------------------------------------------------

SWIM3StatusDecode	
				dc.w	FmtLstCode						; Get Format List status call
				dc.b	0
				dc.b	(1<<ChkDriveNum)+\
						(1<<ChkDriveExists)
				dc.w	SWIM3GetFormatList-SonyHeader

				dc.w	drvStsCode						; Drive Status call
				dc.b	0
				dc.b	(1<<ChkDriveNum)+\
						(1<<ChkDriveExists)
				dc.w	SWIM3DriveStatus-SonyHeader

				dc.w	MFMStsCode						; MFM Status call
				dc.b	0
				dc.b	(1<<ChkDriveNum)+\
						(1<<ChkDriveExists)
				dc.w	SWIM3MFMStatus-SonyHeader

				dc.w	DupVerSts						; duplicator version status call
				dc.b	0
				dc.b	(0<<ChkDriveNum)+\
						(0<<ChkDriveExists)
				dc.w	SWIM3DupVersion-SonyHeader

				dc.w	FmtByteSts						; get format byte status call
				dc.b	0
				dc.b	(0<<ChkDriveNum)+\
						(0<<ChkDriveExists)
				dc.w	SWIM3GetFmtByte-SonyHeader

				assert	(*-SWIM3StatusDecode)=(TotalStatusCalls*6)

;----------------------------------------------------------------------
;	Decode table for Control Calls (gets copied into RAM for patching)
;----------------------------------------------------------------------

SWIM3ControlDecode	
				dc.w	killCode						; KillIO control call
				dc.b	0
				dc.b	(0<<ChkDriveNum)+\
						(0<<ChkDriveExists)
				dc.w	SWIM3CtlKillIO-SonyHeader

				dc.w	VerifyCC						; Verify control call
				dc.b	0
				dc.b	(1<<ChkDriveNum)+\
						(1<<ChkDriveExists)
				dc.w	SWIM3CtlVerify-SonyHeader

				dc.w	FormatCC						; Format control call
				dc.b	0
				dc.b	(1<<ChkDriveNum)+\
						(1<<ChkDriveExists)
				dc.w	SWIM3CtlFormat-SonyHeader

				dc.w	EjectCode						; Eject control call
				dc.b	0
				dc.b	(1<<ChkDriveNum)+\
						(1<<ChkDriveExists)
				dc.w	SWIM3CtlEject-SonyHeader

				dc.w	tgBuffCode						; Set Tag Buffer control call
				dc.b	0
				dc.b	(0<<ChkDriveNum)+\
						(0<<ChkDriveExists)
				dc.w	SWIM3CtlTagBuf-SonyHeader

				dc.w	TCacheCC						; Track Cache control call
				dc.b	0
				dc.b	(0<<ChkDriveNum)+\
						(0<<ChkDriveExists)
				dc.w	SWIM3CtlTrkCache-SonyHeader

				dc.w	IconCC							; Physical Drive Icon control call
				dc.b	0
				dc.b	(1<<ChkDriveNum)+\
						(1<<ChkDriveExists)
				dc.w	SWIM3CtlPhysIcon-SonyHeader

				dc.w	IconLogCC						; Disk Media Icon control call
				dc.b	0
				dc.b	(1<<ChkDriveNum)+\
						(1<<ChkDriveExists)
				dc.w	SWIM3CtlLogIcon-SonyHeader

				dc.w	InfoCC							; Get Drive Info control call
				dc.b	0
				dc.b	(1<<ChkDriveNum)+\
						(1<<ChkDriveExists)
				dc.w	SWIM3CtlDrvInfo-SonyHeader

				dc.w	FmtCopyCC						; Format and copy control call
				dc.b	0
				dc.b	(1<<ChkDriveNum)+\
						(1<<ChkDriveExists)
				dc.w	SWIM3CtlFmtCopy-SonyHeader

				dc.w	GetRawDataCC					; Read raw data control call
				dc.b	0
				dc.b	(1<<ChkDriveNum)+\
						(1<<ChkDriveExists)
				dc.w	SWIM3CtlGetRawData-SonyHeader

				assert	(*-SWIM3ControlDecode)=(TotalControlCalls*6)


;----------------------------------------------------------------------
;	Patch vector table for low level routines
;----------------------------------------------------------------------

ptchVectTable	dc.w	jSelectDrive-SonyHeader			; routine offset 0
				dc.w	jAddrAndStrb-SonyHeader			; routine offset 1
				dc.w	jAddrAndSense-SonyHeader		; routine offset 2
				dc.w	jSeekTrack-SonyHeader			; routine offset 3
				dc.w	jRecalibrate-SonyHeader			; routine offset 4
				dc.w	jStartReadyTimer-SonyHeader		; routine offset 5
				dc.w	jWaitDriveReady-SonyHeader		; routine offset 6
				dc.w	jTurnOnDrive-SonyHeader			; routine offset 7
				dc.w	jTurnOffDrive-SonyHeader		; routine offset 8
				dc.w	jFmtTrack-SonyHeader			; routine offset 9
				dc.w	jWriteTrack-SonyHeader			; routine offset 10
				dc.w	jReadTrack-SonyHeader			; routine offset 11
				dc.w	jRawTrackRead-SonyHeader		; routine offset 12
				dc.w	jReadSectorHdr-SonyHeader		; routine offset 13

				assert	(*-ptchVectTable)=(TotalVectors*2)


			with	SWIM3Vars

;_______________________________________________________________________
;
;  Routine:		SWIM3DiskOpen
;  Inputs:		a0 - pointer to I/O ParamBlock
;				a1 - pointer to Device Control Entry (DCE)
;  Outputs:		d0 - Result Code (noErr/openErr)
;  Destroys:	a0-a4,d0-d2
;  Calls:		none
;  Called by:	Device Manager
;
;  Function:	Driver initialization routine
;
;_______________________________________________________________________

SWIM3DiskOpen										; all regs saved by Device Manager
				move.l	#SWIM3Vars.SWIMVarsSize,d0
				_NewPtr	,Sys,CLEAR
				adda.l	#PhysDriveNumber-\
							SWIMVarsStart,a0		; point to the start offset 0 of globals
				move.l	a0,SonyVars					; save in lowmem
				move.l	a1,DCEpointer(a0)			; save a copy of the DCE pointer
				move.b	#Version,DCtlQueue+1(a1) 	; put our version number in
				movea.l	a0,a1						; a1 = sonyvars ptr
			
				clr.l	DBDMABufPtr(a1)				; init to nil

				TestFor	AMICExists					; do we have AMIC DMA?
				bne		@AMICInit					; if so, go do it

@GrandCentralInit									; init for Grand Central DMA, added
													; 12/17/93 by Monte Benaresh

;	Fill the SWIM3 device register address table
				move.l	IWM,a0						; base address of SWIM3
				move.l	#$00000010,d0				; register spacing
				bsr		@FillSWIM3RegTable			; fill in the table

;	Allocate memory for track cache and 2 DB-DMA channel command descriptors.
;	The command descriptors must be aligned on an even $10 boundary, so we add
;	$F in case we have to round down.

				move.l	#DBDMABufSize+$F,D0			; allocate a track buffer

				_NewPtr ,SYS,CLEAR
				bne		@openErr					; br if we couldn't get it
				move.l	a0,DBDMABufPtr(a1)			; save it un-aligned
				movea.l	#DBDMABufSize+$F,a1			; get size again
				_LockMemoryContiguous
				move.l	SonyVars,a1					; restore globals ptr
				tst.l	d0							; did it fail?
				bne		@openErr

				move.l	DBDMABufPtr(a1),d0
				add.l	#$F,d0						; align to next $10-byte boundary
				andi	#$FFFFFFF0,d0
				move.l	d0,DBDMADescPtr(a1)			; save our descriptor ptr
				add		#2*DBDMADescriptor.size,d0
				move.l	d0,TrackCacheStart(a1)		; save logical address of floppy DMA buffer

;		translate to physical address

				subq.l	#8, sp						; make room for physical result
				move.l	#DMABufLength,-(sp)			; parm: length
				move.l	d0, -(sp)					; parm: logical address
				move.l	sp, A0						; pass in addr of log to phys table
				move.l	#1, A1						; setup the count
				_GetPhysical						; do the translation
				addq.l	#8, sp						; forget about logical addr/count
				move.l	(sp)+,d0					; get physical address (result)
				addq.l	#4, sp						; pop physical count
				move.l	SonyVars,a1					; restore globals ptr
				move.l	d0,FloppyDMAStart(a1)		; save starting offset to floppy DMA buffer

				_GCBaseAddr							; get base addr of Grand Central DMA Chip
				move.l	a0,DMABaseAddr(a1)			; save in our globals

;		our second channel command descriptor must be a STOP command, so
;		set that up now

				move.l	DBDMADescPtr(a1),d0			; get ptr to our descriptors
				add		#DBDMADescriptor.size,d0	; point to 2nd one
				move.l	d0,a0
				move.l	#(STOP<<16) | $0000,d0		; stop command / count field is reserved
				lea		0,a1						; address field is reserved
				_MakeCCDescriptor
				move.l	SonyVars,a1					; restore globals ptr

;		install our SWIM3 and floppy DMA interrupt handlers

				move.l	#gcifDevSwim3,d0			; specify int source
				lea		SWIM3IntDispatch,a0			; get ptr to our handler
													; a1 = refcon = SonyVars
				_GCRegisterHandler

				move.l	#gcifDmaFloppy,d0
				lea		DMAInterruptHandler,a0		; get ptr to our handler
				_GCRegisterHandler

;		enable SWIM3 device interrupts in Grand Central

				_GCEnableInterruptSource	gcifDevSwim3

;		init vectors to DMA-specific routines

				lea		jSetUpGCDMAXfer,a0			; get the routine address
				move.l	a0,vSetUpDMAXfer(a1)		; install the vector
				lea		jClearGCDMAInt,a0			; get the routine address
				move.l	a0,vClearDMAInt(a1)			; install the vector
				lea		jStartGCDMAAction,a0		; get the routine address
				move.l	a0,vStartDMAAction(a1)		; install the vector
				lea		jStopGCDMA,a0				; get the routine address
				move.l	a0,vStopDMA(a1)				; install the vector

				bra		@genericInit				; join common init code

@AMICInit
;	Fill the SWIM3 device register address table
				move.l	IWM,a0						; base address of SWIM3
				move.l	#$00000200,d0				; register spacing
				bsr		@FillSWIM3RegTable			; fill in the table

				lea		AMIC_DMA_BASE_REG,a0		; get ptr to DMA Base Register
				move.l	a0,DMABaseAddr(a1)			; save in our globals (for now)
				
				bset.b	#DMARST,DMAFloppyCS(a0)		; reset floppy DMA reg, to init base address
				
				move.b	DMAFloppyBase+0(a0),d0		; get the physical address of the floppy DMA buffer
				asl.l	#8,d0
				move.b	DMAFloppyBase+1(a0),d0
				asl.l	#8,d0
				move.b	DMAFloppyBase+2(a0),d0
				asl.l	#8,d0
				move.b	DMAFloppyBase+3(a0),d0
				move.l	d0,FloppyDMAStart(a1)		; save starting offset to floppy DMA buffer
		
				move.b	AMIC_DMA_BASE_ADDR3(a0),d1	; get the physical address of the floppy DMA buffer
				asl.l	#8,d1
				move.b	AMIC_DMA_BASE_ADDR2(a0),d1
				asl.l	#8,d1
				move.b	AMIC_DMA_BASE_ADDR1(a0),d1
				asl.l	#8,d1
				move.b	AMIC_DMA_BASE_ADDR0(a0),d1
				sub.l	d1,d0						; calc floppy DMA buffer offset from start of DMA buffer
				
				addi.l	#$61000000,d0				; add in logical start of DMA buffer
				move.l	d0,TrackCacheStart(a1)		; save logical address of Floppy DMA buffer
		
				with	ExpandMemRec, DMADispGlobals
				
				movea.l	([ExpandMem],emDMADispatchGlobals),a0
				moveq	#hwAmicFDC,d0
				move.l	a1,ddRefCon0(a0,d0.l*8)		; refcon = globals ptr
				lea		DMAInterruptHandler,a1
				move.l	a1,ddVector0(a0,d0.l*8)		; handler = our DMA handler

				endwith

				lea		SWIM3IntDispatch,a0			; get ptr to our handler
				move.l	a0,VIA2DT+(4*5)				; SWIM3 is VIA 2 interrupt, bit 5
				movea.l	VIA2RBV,a0					; get ptr to VIA2/RBV base
				move.b	#%10100000,RvIER(a0)		; enable the floppy interrupt at the VIA
				move.l	SonyVars,a1					; restore globals ptr

				lea		jSetUpAMICDMAXfer,a0		; get the routine address
				move.l	a0,vSetUpDMAXfer(a1)		; install the vector
				lea		jClearAMICDMAInt,a0			; get the routine address
				move.l	a0,vClearDMAInt(a1)			; install the vector
				lea		jStartAMICDMAAction,a0		; get the routine address
				move.l	a0,vStartDMAAction(a1)		; install the vector
				lea		jStopAMICDMA,a0				; get the routine address
				move.l	a0,vStopDMA(a1)				; install the vector

@genericInit

;	Initialize the ICON pointers

				movea.l	SonyVars,a1
				
				movea.l	UnivInfoPtr,a2					;											<SM10>
				adda.l	ProductInfo.IconInfoPtr(a2),a2	; point to icon info table for this machine	<SM10>
				move.l	0(a2),d0					; offset to media icon
				bsr		@getIconPtr					; get the icon pointer
				move.l	a3,MediaIconPtr(a1)			; save it
				move.l	4(a2),d0					; offset to primary drive icon
				bsr		@getIconPtr					; get the icon pointer
				move.l	a3,Drive1PhysIcon(a1)		; save it
				move.l	14(a2),d0					; offset to secondary drive icon
				bsr		@getIconPtr					; get the icon pointer
				move.l	a3,Drive2PhysIcon(a1)		; save it
	
				
				;movea.l	IWM,a2						; SWIM3 base address in a2	
				
				clr.b	([vIntMask,a1])				; make sure the enable mask is 0
				move.b	#EnableInts,([vOnes,a1])	; enable SWIM3 interrupts at the chip


;	next code moved to machine-specific section above 12/17/93 by Monte Benaresh
				;lea		SWIM3IntDispatch,a0			; get ptr to our handler
				;move.l	a0,VIA2DT+(4*5)				; SWIM3 is VIA 2 interrupt, bit 5
				;movea.l	VIA2RBV,a0					; get ptr to VIA2/RBV base
				;move.b	#%10100000,RvIER(a0)		; enable the floppy interrupt at the VIA
	
				
;	Install the vectors for Prime and Control

				lea		jtSWIM3DiskPrime,a0			; get the routine address
				move.l	a0,JDiskPrime				; install the vector
				lea		jtSWIM3DiskControl,a0		; get the routine address
				move.l	a0,JControl					; install the vector

;	Install the vectors for low level driver routines

				lea		vSelectDrive(a1),a0			; point to start of vector globals
				lea		ptchVectTable,a3			; point to start of vector table
				moveq	#TotalVectors-1,d1						
@vectLoop		lea		SonyHeader,a4				; get driver base address
				adda.w	(a3)+,a4					; convert offset to absolute address
				move.l	a4,(a0)+
				dbra	d1,@vectLoop				; process the whole table

;	initialize the Control and Status Call Info tables

				lea		ControlCallInfo(a1),a0		; a0 <- address of table in globals
				lea		SWIM3ControlDecode,a3		; a3 <- address of table in ROM
				moveq	#controlErr,d0				; d0 <- default error code
				moveq	#TotalControlCalls-1,d1		; d1 <- loop counter
				bsr.w	@InstallCallInfo			; install the ControlCallInfo
	
				lea		StatusCallInfo(a1),a0		; a0 <- address of table in globals
				lea		SWIM3StatusDecode,a3		; a3 <- address of table in ROM
				moveq	#statusErr,d0				; d0 <- default error code
				moveq	#TotalStatusCalls-1,d1		; d1 <- loop counter
				bsr		@InstallCallInfo			; install the StatusCallInfo

;	initialize the SWIM

*				;clr.w 	CurrentDrive(a1)			; initialize CurrentDrive to default invalid drive
				bsr 	InitSWIMChip				; initialize the chip
				bne.s	@openErr					; couldn't init, error
				
			
;	assign drive numbers, and add drive queue elements to the drive queue

			with	MyDriveInfo
				lea		FirstDriveInfo(a1),a4		; a4 <- pointer to MyDriveInfo for drive
				lea		DriveInfoPtrs(a1),a3		; a3 <- pointer to DriveInfoPtrs list entry

				moveq	#0,d1						; init logical drive #
				moveq	#0,d2						; init physical drive #
@floppyLoop		move.w	d2,d0						; get drive # for SelectDrive
				bsr		SelectDrive					; attempt to select the drive
				beq.s	@NextFloppy					; if drive couldn't be selected
				bsr 	FindDriveKind				; see what kind of drive we found
				cmpi.b 	#SSGCRDriveKind+1,d0		; see if it's a floppy drive we support
				blt.s	@NextFloppy					; ignore noDrive, unknown, and 400K drives
				cmpi.b 	#DSMFMGCRDriveKind,d0		; 
				bgt.s	@nextFloppy					; ignore HD20's also

				addq.w 	#1,d1		 				; found a live one, count the logical drive
				move.b 	d0,DriveKind(a1,d1.w)		; record the drive kind
				move.b	d2,PhysDriveNumber(a1,d1.w)	; record physical drive number

				move.l	a4,(a3)						; install pointer to per drive info
				move.b	#1,Installed(a4)			; indicate that drive is installed
	
				move.w	d1,d0						; prepare to insert logical drive number
				swap	d0
				move.w	#SonyRefNum,d0				; d0 <- driver RefNum in low 16 bits
				lea		DriveQElement(a4),a0		; a0 <- pointer to Drive Queue Element
				_AddDrive							; add the drive to the drive queue
				adda.w	#MyDriveInfoSize,a4			; point to next MyDriveInfo

@nextFloppy		addq.l	#4,a3						; point to next DriveInfoPtr
				addq.w	#1,d2						; go onto next physical drive
				cmpi.w 	#MaxDriveNum,d2				; see if past the range of floppies
				ble.s	@floppyLoop					; loop through all floppy drive numbers
			endwith
				
				bsr 	TurnOffDrive				; de-select all drives
				
				st.b	CacheEnabled(a1)			; enable our track cache
				
				bsr		PollingTask					; start up our disk insert/eject polling task

				moveq	#0,d0						; no error
@openExit		rts
				
@openErr
				move.l	DBDMABufPtr(a1),a0			; get command descriptor & track buffer ptr
				beq		@noDescPtr					; never allocated, don't dispose

				movea.l	#DBDMABufSize+$F,a1			; get size
				_UnlockMemory
				move.l	SonyVars,a1					; restore globals ptr

				move.l	DBDMABufPtr(a1),a0
				_DisposPtr
@noDescPtr
				movea.l	SonyVars,a0
				_DisposPtr							; release our globals
				moveq	#-1,d0
				move.l	d0,SonyVars					; clear the lowmem ptr
				moveq	#OpenErr,d0				
				bra.s	@openExit

;---------------------
@getIconPtr		lea		(a2,d0.l),a3				; assume relative to table
				bclr.l	#0,d0						; test & clear 'use ROM table' bit
				beq.s	@IconPtrOK					; branch if should use current table
				movea.l	UnivInfoPtr,a3				;												<SM10>
				adda.l	ProductInfo.IconInfoPtr(a3),a3	; point to icon info table for this machine	<SM10>
				adda.w	d0,a3						; add in relative offset
@IconPtrOK		rts									; ptr to icon is in a3 now


;---------------------
@InstallCallInfo
				move.l	a0,(a0)						; save the pointer to the table (for patching)
				addq.l	#4,(a0)+					; point to loop counter
				move.w	d1,(a0)+					; install the loop counter
				move.w	d0,(a0)+					; install the default error code
@CallInfoLoop
				move.l	(a3)+,(a0)+					; install csCode, IOProutine, Flags
				lea		SonyHeader,a4				; get driver base address
				adda.w	(a3)+,a4					; convert relative addr to absolute
				move.l	a4,(a0)+					; install routine address
				dbra	d1,@CallInfoLoop			; process the whole table
				rts									; all done

@FillSWIM3RegTable									; init vectors to regularly-spaced SWIM3 registers
;				on entry:
;					A0 = ptr to SWIM3 register base
;					A1 = ptr to SonyVars
;					D0 = register spacing

				move.l	#15-1,d1					; do for 15 vectors
				lea		SWIM3RegVects(a1),a2
@SWIM3RegLoop
				add.l	d0,a0						; start with 2nd physical register
				move.l	a0,(a2)+
				dbra	d1,@SWIM3RegLoop
				rts



;_______________________________________________________________________
;
;  Routine:		SWIM3DiskClose
;  Inputs:		a0 - pointer to I/O ParamBlock
;				a1 - pointer to Device Control Entry (DCE)
;  Outputs:		d0 - Result Code (noErr/openErr)
;  Destroys:	
;  Calls:		none
;  Called by:	Device Manager
;
;  Function:	Driver close routine
;_______________________________________________________________________

SWIM3DiskClose	moveq	#ClosErr,d0 				; report error: can not close at present
				rts




;_______________________________________________________________________
;
;  Routine:		SWIM3Control/SWIM3Status
;  Inputs:		a0 - pointer to I/O ParamBlock
;				a1 - pointer to Device Control Entry (DCE)
;  Outputs:		d0 - Result Code (noErr/openErr)
;  Destroys:	
;  Calls:		none
;  Called by:	Device Manager
;
;  Function:	Driver close routine
;_______________________________________________________________________

SWIM3DiskStatus	movea.w	#StatusCallInfo,a2			; offset of decode table
				bra.s	SWIM3ControlStatus			; join common code (fall into it)

SWIM3DiskControl
				move.l	JControl,-(sp)				; all regs saved by Device Manager
				rts

jtSWIM3DiskControl
				movea.w	#ControlCallInfo,a2			; offset of decode table
*				bra.s	SWIM3ControlStatus			; join common code


SWIM3ControlStatus
				movea.l	SonyVars,a1					; get pointer to globals
				st.b	DriverActive(a1)			; driver is busy
				movea.l	(a1,a2.l),a2				; get pointer to table
				move.w	(a2)+,d1					; d1 <- loop counter
				move.w	(a2)+,d0					; d0 <- default error code
				move.w	csCode(a0),d2				; d2 <- csCode to search for

@SearchLoop		cmp.w	(a2),d2						; check for a match
				addq.l	#8,a2						; point to next table entry
				dbeq	d1,@SearchLoop				; search through all table entries
				bne.s	Swim3DiskDone				; illegal csCode, return with error
				moveq	#NoErr,d0					; default to no error
				movea.l	-(a2),a3					; get address of routine
				move.w	IODrvNum(a0),d1				; get the drive number
				move.b	-(a2),d2					; get flags
			assert	ChkDriveNum=7					; flag is in sign bit
				bpl.s	@DriveNumInRange			; if flag to check drive num is not set
				tst.w	d1							; is drive num <= 0?
				ble.s	@badDrvNum					; yes, exit
				cmpi.w	#MaxDriveNum,d1				; <= max drive num?
				bls.s	@DriveNumInRange			; yes, it's valid
@badDrvNum		moveq	#NSDrvErr,d0				; else, bad drive number
				bra.s	Swim3DiskDone				; drive num out of range, return with error
@DriveNumInRange
			assert	ChkDriveExists=ChkDriveNum-1 	; next flag is ChkDriveExists
				add.b	d2,d2						; test next flag
				bpl.s	@DriveExists				; if flag to check drive exists is not set
				tst.l	DriveInfoPtrs(a1,d1.w*4)	; test to see if it exists
				bne.s	@DriveExists				; if valid drive
				moveq	#NoDriveErr,d0				; non-existent drive error
				bra.s	Swim3DiskDone				; drive doesn't exists, return with error
@DriveExists
				lea		csParam(a0),a0				; a0 points to csParam
				move.w	d1,ReqDriveNumber(a1)		; save Drive Number in globals
				;movea.l	IWM,a2						; a1=globals, a2=SWIM ptr
				jmp		(a3)						; jump into the routine


;--------------------------------------------

Swim3DiskDone	clr.b	DriverActive(a1)			; driver is free now
				move.l	JIODone,-(sp)				; prepare to return to IODone
				movea.l	DCEPointer(a1),a1			; a1 <- DCE (param to IODone)
				ext.l	d0							; check for errors
				beq.s	@noError					; if no error
				move.w	d0,DskErr					; save error in low memory global DskErr
@noError		rts									; return to IODone






;_______________________________________________________________________
;
;  Routine:		DiskPrime
;  Inputs:		a0 - pointer to I/O ParamBlock
;				a1 - pointer to Device Control Entry (DCE)
;  Outputs:		d0 - Result Code (noErr/openErr)
;  Destroys:	
;  Calls:		none
;  Called by:	Device Manager
;
;  Function:	Driver read/write routine
;_______________________________________________________________________

SWIM3DiskPrime	move.l	JDiskPrime,-(sp)			;
				rts									;

jtSWIM3DiskPrime									;
				movea.l	a1,a2						; DCE ptr in a2
				movea.l	SonyVars,a1					; get ptr to our globals
				
				st.b	DriverActive(a1)			; driver is active
				
				moveq	#NSDrvErr,d0				; assume Bad drive number
				move.w	IODrvNum(a0),d1				; get the logical drive number
				cmpi.w	#MaxDriveNum,d1				; see if way out of range
				bgt.s	@PrimeErr					; if invalid drive number
				move.w	d1,ReqDriveNumber(a1)		; save it
				
				moveq	#ParamErr,d0				; assume parameter error
				moveq	#9,d1						; shift amount for divide by 512
	
				move.l	dCtlPosition(a2),d2			; get byte position
				ror.l	d1,d2						; convert to block number
				move.l	d2,LogicalBlock(a1)			; setup block number
				rol.l	d1,d2						; convert back to byte position
				andi.w	#$01FF,d2					; test for mod 512
				bne.s	@PrimeErr					; if error in dCtlPosition parameter
	
				move.l	ioBuffer(a0),BlockAddress(a1)	; save user buffer address
				
				move.l	ioByteCount(a0),d2			; get byte count
				ror.l	d1,d2						; convert to block count
				move.l	d2,BlockCount(a1)			; setup block count
				rol.l	d1,d2						; convert back to byte count
				andi.w	#$01FF,d2					; test for mod 512
				bne.s	@PrimeErr					; if error in byte count parameter
				
				;movea.l	IWM,a2						; get ptr to SWIM chip

				cmpi.b	#aRdCmd,ioTrap+1(a0)		; check for read
				bne		SWIM3Write					; if not read, must be a write
				jmp		SWIM3Read					; else, call our read routine

@PrimeErr		bra.s	Swim3DiskDone				; complete the call with error


;_______________________________________________________________________
;
;  Routine: 	jmp 	SWIM3GetFormatList
;  Inputs:		a0 	- 	csParam ptr
;				a1 	- 	SonyVars ptr
;				d1	-	logical drive #
;  Outputs: 	none
;  Destroys:	a0,a2,d0
;  Calls:		none
;  Called by:	Driver control dispatcher
;
;  Function:	Returns a list of possible drive formats.  The information for each 
;				possible disk format is an 8-byte record:
;					Byte 0-3:	disk capacity in blocks
;								(is [#tracks][#heads][#sectors][#bytes/sector])
;					       4:	bit 7=1: number of tracks, sides, sectors is valid
;							    6=1: current disk has this format
;							    5=0: reserved for future expansion, should be zero
;							    4=0: single density, =1: double density
;							    0-3: number of heads (or zero if don't care)
;					       5:	number of sectors (or zero if don't care)
;					     6-7:	number of tracks (or zero if don't care)
;_______________________________________________________________________

SWIM3GetFormatList
				with 	MyDriveInfo,DriveStatusRec

				bsr		GetDriveStatus				; update our status record
				
				moveq	#offLinErr,d0				; default error in case no disk in place.
				movea.l	DriveInfoPtrs(a1,d1.w*4),a2	; a2 = ptr to drive info for this drive
				cmpi.b	#2,DiskInPlace(a2)			; see if disk is online and clamped
				blt		Swim3DiskDone				; if no disk, or format unknown, offLinErr
			
				lea		CurrentStatus(a1),a2		; get ptr to our status record
				moveq	#0,d3
				moveq	#0,d4
				move.b	StatFmtAllowed(a2),d3		; get allowable formats bitmask
				move.b	StatCurrentFmt(a2),d4		; get current format bitmask
			
@doList			move.w	(a0)+,d2					; d2 <- max list size
				ble		Swim3DiskDone				; no room to return anything
				movea.l	(a0),a2						; get ptr to format list buffer

				lea		@FmtTbl,a3					; a3 <- pointer to list template
				clr.w	-(a0)						; returned list size := 0
				moveq	#0,d0						; d0 <- bit index into lists
@loop			bclr.l	d0,d3						; test and clear allowable format bit
				beq.s	@next						; bit wasn't set, try next
				move.l	(a3,d0.w*8),(a2)+			; copy disk size
				move.l	4(a3,d0.w*8),(a2)+			; copy attributes
				bclr.l	d0,d4						; test and clear current format bit
				beq.s	@currentDone				; if not the current format
				bset.b	#6,-4(a2)					; set the 'is current format' bit

@currentDone	addq.w	#1,(a0)						; increment result list count
				subq.w	#1,d2						; decrement space left
				ble.s	@done						; if result list is now full
@next			addq.w	#1,d0						; increment template list / bit index
				tst.l	d3							; see if all formats found
				bne.s	@loop						; loop through remaining list
@done			moveq	#noErr,d0					; return good status
				bra		Swim3DiskDone				; return	

				endwith





;----------------------------------------------------------------------
;  The information for each possible disk format is an 8-byte record:
;	Byte 0-3:	disk capacity in blocks
;				(is [#tracks][#heads][#sectors][#bytes/sector])
;	       4:	bit 7=1: number of tracks, sides, sectors is valid
;			    6=1: current disk has this format
;			    5=0: reserved for future expansion, should be zero
;			    4=0: single density, =1: double density
;			    0-3: number of heads (or zero if don't care)
;	       5:	number of sectors (or zero if don't care)
;	     6-7:	number of tracks (or zero if don't care)

@FmtTbl
				dc.l	38965						; HD-20
				dc.b	(%0100<<4)+0,0,0,0			;  THS invalid, current disk has this format

				dc.l	400*2						; 400K GCR
				dc.b	(%1000<<4)+1				;  THS valid, SD, 1 head
				dc.b	10							;  10 sectors (average)
				dc.w	80							;  80 tracks
	
				dc.l	800*2						; 800K GCR
				dc.b	(%1000<<4)+2				;  THS valid, SD, 2 heads
				dc.b	10							;  10 sectors (average)
				dc.w	80							;  80 tracks
	
				dc.l	720*2						; 720K (1M) MFM
				dc.b	(%1000<<4)+2				;  THS valid, SD, 2 heads
				dc.b	9							;  9 sectors
				dc.w	80							;  80 tracks
	
				dc.l	1440*2						; 1440K (2M) MFM
				dc.b	(%1001<<4)+2				;  THS valid, DD, 2 heads
				dc.b	18							;  9 sectors
				dc.w	80							;  80 tracks
	


;_______________________________________________________________________
;
;  Routine: 	jmp 	SWIM3DriveStatus
;  Inputs:		a0 	- 	csParam ptr
;				a1 	- 	SonyVars ptr
;				d1	-	logical drive #
;  Outputs: 	none
;  Destroys:	a0,a2,d0
;  Calls:		none
;  Called by:	Driver control dispatcher
;
;  Function:	Returns the drive status
;_______________________________________________________________________

SWIM3DriveStatus
				with	DriveStatusRec

				bsr		GetDriveStatus
				
				movea.l	DriveInfoPtrs(a1,d1.w*4),a2	; a2 = ptr to drive info for this drive
				clr.b	(a0)+						; clear high byte of track
				move.b	CylinderValid(a1,d1.w),(a0)+; copy current track
				move.l	(a2)+,(a0)+					; copy writeProt, DIP, driveInst, numSides
				move.l	(a2)+,(a0)+					; copy qLink
				move.l	(a2)+,(a0)+					; copy qType, dQDrive
				move.l	(a2)+,(a0)+					; copy dQRefNum, dQFSID

			assert	StatNewInterface=StatTwoSidedFmt+1
			assert	StatDiskErrors=StatNewInterface+1

				lea		CurrentStatus(a1),a2
				move.l	StatTwoSidedFmt(a2),(a0)+	; copy 2-sided format/ new interface bytes, and disk errors			
	
				moveq	#noErr,d0					; return good status
				bra		Swim3DiskDone

				endwith
				
				
				

;_______________________________________________________________________
;
;  Routine: 	jmp 	SWIM3MFMStatus
;  Inputs:		a0 	- 	csParam ptr
;				a1 	- 	SonyVars ptr
;				d1	-	logical drive #
;  Outputs: 	none
;  Destroys:	a0,a2,d0
;  Calls:		none
;  Called by:	Driver control dispatcher
;
;  Function:	Returns the MFM status:
;					[0]	-	$FF = superdrive, 0 = 400K/800K drive
;					[1]	-	$FF = MFM, 		  0 = GCR (valid only when installed)
;					[2]	-	$FF = 1440K disk, 0 = 720K disk
;					[3]	-	$FF = SWIM, 	  0 = IWM
;_______________________________________________________________________

SWIM3MFMStatus
				clr.l	(a0)						; set defaults
				st.b	3(a0)						; we always have a SWIM
				moveq	#DSMFMGCRDriveKind,d0		; see if superdrive attached
				cmp.b	DriveKind(a1,d1.w),d0		;
				bne.s	@done
				
				st.b	(a0)+						; superdrive, mark it and continue
				move.b	DiskFormat(a1,d1.w),d0
				cmpi.b	#MFM720Kformat,d0			; see if the disk is MFM
				beq.s	@mfm						; yes, mark it
				moveq	#MFM1440Kformat,d0			; 
				cmp.b	DiskFormat(a1,d1.w),d0		;
				beq.s	@mfm						; yes, mark it
				addq.w	#1,a0
				bra.s	@chkMedia

@mfm			st.b	(a0)+						; MFM, mark it and continue
@chkMedia		moveq	#HiDenMediaKind,d0			; MFM, see if high density
				cmp.b	MediaKind(a1,d1.w),d0		;
				bne.s	@done						; no, we're done
				
				st.b	(a0)+						; else, indicate 1440K disk

@done			moveq	#noErr,d0					; return good status
				bra	Swim3DiskDone




;_______________________________________________________________________
;
;  Routine: 	jmp 	SWIM3DupVersion
;  Inputs:		a0 	- 	csParam ptr
;				a1 	- 	SonyVars ptr
;				d1	-	logical drive #
;  Outputs: 	none
;  Destroys:	a0,a2,d0
;  Calls:		none
;  Called by:	Driver control dispatcher
;
;  Function:	Returns the version of the disk duplicator program we support
;_______________________________________________________________________

SWIM3DupVersion
				move.w	#DDVersion,(a0)				; return the version that we support
				bra		Swim3DiskDone



;_______________________________________________________________________
;
;  Routine: 	jmp 	SWIM3GetFmtByte
;  Inputs:		a0 	- 	csParam ptr
;				a1 	- 	SonyVars ptr
;				d1	-	logical drive #
;  Outputs: 	none
;  Destroys:	a0,a2,d0
;  Calls:		none
;  Called by:	Driver control dispatcher
;
;  Function:	Returns the format byte for the current disk.
;_______________________________________________________________________

SWIM3GetFmtByte
				move.b	SectHdrFmtKind(a1),(a0)		; return the format byte
				bra		Swim3DiskDone



;_______________________________________________________________________
;
;  Routine: 	jmp 	SWIM3CtlKillIO
;  Inputs:		a0 	- 	csParam ptr
;				a1 	- 	SonyVars ptr
;				d1	-	logical drive #
;  Outputs: 	none
;  Destroys:	a0,a2,d0
;  Calls:		none
;  Called by:	Driver control dispatcher
;
;  Function:	Returns error.
;_______________________________________________________________________

SWIM3CtlKillIO	moveq	#controlErr,d0
				bra		Swim3DiskDone



;_______________________________________________________________________
;
;  Routine: 	jmp 	SWIM3CtlTagBuf
;  Inputs:		a0 	- 	csParam ptr
;				a1 	- 	SonyVars ptr
;				d1	-	logical drive #
;  Outputs: 	none
;  Destroys:	a0,a2,d0
;  Calls:		none
;  Called by:	Driver control dispatcher
;
;  Function:	Sets up a user tag buffer, where tags will be read from/written to.
;_______________________________________________________________________

SWIM3CtlTagBuf	move.l	(a0),TagBufPtr(a1) 			; set or clear ptr to separate buffer
				bra		Swim3DiskDone



;_______________________________________________________________________
;
;  Routine: 	jmp 	SWIM3CtlTrkCache
;  Inputs:		a0 	- 	csParam ptr
;				a1 	- 	SonyVars ptr
;				d1	-	logical drive #
;  Outputs: 	none
;  Destroys:	a0,a2,d0
;  Calls:		none
;  Called by:	Driver control dispatcher
;
;  Function:	Disables/enables the track cache. 
;_______________________________________________________________________
SWIM3CtlTrkCache
				movea.l	a0,a3						; save csParam ptr
				bsr		FlushIfDisabled				; need to flush if going from disabled to enabled
				clr.b	CacheEnabled(a1)			; assume disabled
				tst.b	1(a3)						; get installed flag
				bmi.s	@exit						; disable cache if remove request
				move.b	(a3),CacheEnabled(a1)		; update enable flag
@exit			moveq	#noErr,d0					; no errors possible
				bra		Swim3DiskDone



;_______________________________________________________________________
;
;  Routine: 	jmp 	SWIM3CtlPhysIcon
;  Inputs:		a0 	- 	csParam ptr
;				a1 	- 	SonyVars ptr
;				d1	-	logical drive #
;  Outputs: 	none
;  Destroys:	a0,a2,d0
;  Calls:		none
;  Called by:	Driver control dispatcher
;
;  Function:	Returns the drives physical icon.
;_______________________________________________________________________
SWIM3CtlPhysIcon
				movea.l	Drive1PhysIcon(a1),a3		; return primary drive Icon
				cmpi.w	#intDriveNumber,d1			; test for primary
				beq.s	@gotDefault					; if it was primary
				movea.l	Drive2PhysIcon(a1),a3		; else, return secondary drive Icon
@gotDefault		move.l	a3,(a0)						; return pointer to Icon
				bra		Swim3DiskDone				; return



;_______________________________________________________________________
;
;  Routine: 	jmp 	SWIM3CtlLogIcon
;  Inputs:		a0 	- 	csParam ptr
;				a1 	- 	SonyVars ptr
;				d1	-	logical drive #
;  Outputs: 	none
;  Destroys:	a0,a2,d0
;  Calls:		none
;  Called by:	Driver control dispatcher
;
;  Function:	Returns the drives logical icon (media icon).
;_______________________________________________________________________
SWIM3CtlLogIcon
				movea.l	MediaIconPtr(a1),a3			; return media Icon
				move.l	a3,(a0)						; return pointer to Icon
				bra		Swim3DiskDone				; return



;_______________________________________________________________________
;
;  Routine: 	jmp 	SWIM3CtlDrvInfo
;  Inputs:		a0 	- 	csParam ptr
;				a1 	- 	SonyVars ptr
;				d1	-	logical drive #
;  Outputs: 	none
;  Destroys:	a0,a2,d0
;  Calls:		none
;  Called by:	Driver control dispatcher
;
;  Function:	Returns the drive info struct for the specified drive.
;_______________________________________________________________________
SWIM3CtlDrvInfo
			with	DriveStatusRec
				bsr		GetDriveStatus
				lea		CurrentStatus(a1),a2		; get ptr to status record
				move.l	StatDriveInfoB3(a2),(a0)	; return drive status
				moveq	#noErr,d0					; return good status
				bra		Swim3DiskDone
			endwith
				


;__________________________________________________________________________________________________
;
;  Routine:		jmp		SWIM3CtlGetRawData
;  Inputs:		a0 	- 	csParam ptr
;				a1 	- 	SonyVars ptr
;				d1	-	logical drive #
;  Outputs:		d0 -- result code
;  Destroys:	d0,d2-d3,a0,a3
;  Calls:		SetUpDrive, SeekTrack, WaitDriveReady, RawTrackRead
;  Called by:	Driver control dispatcher
;
;  Function:	The call reads all or part of a track and returns the raw, unmassaged data it
;				finds there so that applications can access a floppy disk at a very low level
;				without having to directly access the hardware.  The following parameters are
;				passed starting at csParam:
;
;				 0:	clockBuffer		pointer to packed bit array (MFM disks only), or nil
;				 4:	dataBuffer		pointer to raw track data, or nil
;				 8:	byteCount		number of bytes requested
;										(dataBuffer must be able to hold this many bytes)
;				12:	numDone			number of bytes actually read (≤ byteCount)
;				16:	searchMode		when to start collecting bytes:
;										0 = as soon as spindle motor is up to speed
;										1 = after reading an address field
;										2 = after reading a data field
;										3 = at the index mark (MFM disks only)
;				18:	track			which track to read (0-79)
;				20:	side			which side to read (0-1)
;				21: sector			which sector to synchronize on (0-255)
;
;				If clockBitsBuffer is non-nil, it must point to a buffer that's at least 1/8th
;				the size of dataBuffer.  It consists of a packed array of bits signifying whether
;				or not the corresponding byte in dataBuffer is a mark or data byte.  If a bit
;				is equal to "1", the byte is an MFM mark byte; if it's a "0", the byte is an
;				MFM data byte.  Bits for ASCENDING data bytes are arranged in DESCENDING order
;				within a byte, i.e., bit 7 represents byte 0, bit 6 represents byte 1, etc.
;
;		NOTE: 	If both clockBitsBuffer and dataBuffer are nil, the call will do nothing.
;				This provides a way for applications to determine if the call exists
;				without first having to allocate large buffers.
;__________________________________________________________________________________________________

SWIM3CtlGetRawData			
				move.l	(a0)+,d0
				move.l	d0,ClockBuffer(a1)			; save ptr to clock buffer
				or.l	(a0),d0
				beq.s	@exit						; exit if both buffers are nil
				move.l	(a0)+,DataBuffer(a1)		; save ptr to data buffer
				move.l	(a0)+,ByteCount(a1)			; save byte count
				
				movea.l	a0,a3						; save ptr to reply count
				clr.l	(a3)						; init the reply count to 0
				addq.l	#4,a0						; skip over it
				moveq	#paramErr,d0				; assume search mode out of range
				move.w	(a0)+,d2					; get search mode
				cmpi.b	#3,d2						; compare to our limit
				bhi.s	@exit						; exit if out of range
				move.w	d2,SearchMode(a1)			; save the search mode
				
				move.w	(a0)+,d0					; get track #
				move.b	d0,PhysCylinder(a1)			; save it
				move.b	(a0)+,PhysHead(a1)			; save head #
				move.b	(a0)+,PhysSector(a1)		; save sector #

				bsr 	SetUpDrive					; select and power up the disk drive
				bne.s 	@exit						; if no error in SetUp

				move.b 	PhysCylinder(a1),d0			; get the desired cylinder number
				bsr		SeekTrack					; seek to it
				bne.s	@exit						; die on errors

				moveq	#paramErr,d0				; assume invalid search mode
				moveq	#3,d2						; get our last mode
				cmp.w	SearchMode(a1),d2			; in range?
				blo.s	@exit						; no, exit
				bne.s	@startRead					; not 'at index', go ahead
				
				btst.b	#GCRModeBit,([vSetup,a1])	; read from index, are we in GCR mode?
				beq.s	@startRead					; no, read as specified
				clr.w	SearchMode(a1)				; else, read immediatly
				
@startRead		bsr 	WaitDriveReady				; wait for the seek to complete
				bne.s	@exit						; exit if error seeking
				bsr		RawTrackRead				; all setup, get the data (reply cnt ptr in a3)

@exit			jmp		Swim3DiskDone




;_______________________________________________________________________
;
;  Routine: 	jmp 	SWIM3CtlEject
;  Inputs:		a0 	- 	csParam ptr
;				a1 	- 	SonyVars ptr
;				d1	-	logical drive #
;  Outputs: 	d0	-	result code
;  Destroys:	d0,d2-d3,a0
;  Calls:		SetUpDrive, SeekTrack, ReCalibrate, WaitDriveReady, SelectDrive. AddrAndStrb,
;				Sleep, AddrAndSense, TurnOffDrive
;  Called by:	Driver control dispatcher
;
;  Function:	Ejects the disk in the specified drive
;_______________________________________________________________________

SWIM3CtlEject	bsr 	SetUpDrive					; select and power up the disk drive
				beq.s 	@EjectSeek					; if no error in SetUp

				cmpi.w 	#OffLinErr,d0				; see if there is a disk to eject
				beq.s 	@EjectOut					; if disk is already out

;		Ignore some of the errors returned by SetUpDrive, since we are just going to
;		eject the disk.  Only errors related to drive number will be flagged

				cmpi.w	#nsDrvErr,d0				; return no such drive error if out of range
				beq.s 	@EjectDone					; report drive number errors
				cmpi.w	#noDriveErr,d0				; return no drive error if drive not installed
				beq.s	@EjectDone					;
				bra.s 	@EjectDiskette				; if any other error, skip seek, just eject
				

@EjectSeek		move.b 	#LastCylinder/2,d0			; position head to middle of disk before eject
				bsr 	SeekTrack					; to prevent major data loss if heads damage media
				beq.s 	@EjectDiskette				; if seek was ok, eject the disk

				bsr 	ReCalibrate 				; try to recalibrate if seek failed
				bne.s 	@EjectDiskette				; if couldn't recalibrate, forget about seeking

				move.b 	#LastCylinder/2,d0			; position head again
				bsr 	SeekTrack					; one last attempt at seeking


@EjectDiskette	bsr 	WaitDriveReady				; wait for motor speed and heads to settle
				
;		Re-Enable the drive, in case it was disabled by an error.

				move.w 	ReqDriveNumber(a1),d0		; see what drive is requested
				move.b 	PhysDriveNumber(a1,d0.w),d0	; get the new physical drive number
				bsr 	SelectDrive					; select and enable the new drive

				moveq 	#wMotorOffAdr,d0			; motor off drive command
				bsr 	AddrAndStrb					; turn off the drive motor

				move.l 	#MotorStopDelay,d0			; delay time
				bsr 	Sleep						; sleep until disk stops spinning

				moveq 	#wEjectOnAdr,d0				; eject disk drive command
				bsr 	AddrAndStrb					; start the eject process

				move.l 	#EjectDelay,d0				; wait 1.5 seconds for eject to complete
				bsr 	Sleep						; wait the specified amount of time

@EjectOut		clr.b 	MediaKind(a1,d1.w)			; indicate NoMediaKind
				clr.b 	DiskFormat(a1,d1.w)			; indicate uncheckedFormat
				clr.w	LastActiveDrive(a1)			; indicate drive state is unknown

				bsr		GetDriveStatus				; update drive status
				
				bsr 	TurnOffDrive				; disable the drive
				moveq	#noErr,d0					; indicate success
@EjectDone		jmp 	Swim3DiskDone				; done with the call
				




;_______________________________________________________________________
;
;  Routine: 	jmp 	SWIM3Read
;  Inputs:		a0	-	iopb
;				a1	-	SonyVars
;				ReqDriveNumber	-	logical drive #
;				LogicalBlock	-	block # for request
;				BlockAddress	-	user buffer address
;				BlockCount		-	# of blocks to xfer
;  Outputs: 	
;  Destroys:	a0,a3,d0-d3
;  Calls:		BlocktoPhysAddr, ClearNeededTrackCache, InvalidateTrackCache
;				SeekTrack, WaitDriveReady, ReadTrack, DeNibbleize, ReCalibrate
;  Called by:	SWIM3DiskPrime
;
;  Function:	Reads the requested blocks into the user buffer / track cache.
;_______________________________________________________________________

SWIM3Read		move.l	TagBufPtr(a1),CurTagPtr(a1)	; init our index into user tag buffer

				clr.l	VerifyPtr(a1)				; assume we're not verifying
				btst.b	#6,IOPosMode+1(a0)			; test for verify mode
				beq.s	@setup						; no, we're set
				move.l	WritePtr(a1),VerifyPtr(a1)	; yes, setup a temporary buffer for verify
				
@setup			bsr 	SetUpDrive					; select and power up the disk drive
				bne	 	@readExit					; exit if error

				moveq	#noAdrMkErr,d0				; assume invalid disk format
				cmpi.b	#unknownFormat,DiskFormat(a1,d1.w)	; does this disk have a valid format?
				beq		@readExit					; no, exit with error

;-------------------------------------------------
; 	Here we want to calculate all the needed sectors for this cylinder
;-------------------------------------------------

@nextCylinder	move.l	LogicalBlock(a1),d0			; init our block#
				bsr		BlocktoPhysAddr				; compute starting sector/track for this format
				moveq	#0,d2
				move.b	PhysCylSector(a1),d2		; get cylinder sector # in d2
				
				move.l	BlockCount(a1),d3			; init our blocks remaining count
				bsr		ClearNeededTrackCache		; assume no sectors are needed yet
				clr.w	SectorsToRead(a1)			; assume no sectors needed
				
				moveq	#0,d0
				move.b	PhysCylinder(a1),d0			; get desired cylinder
				cmp.w	TCTrackNum(a1),d0			; does our track cache hold this one?
				beq.s	@sectLoop					; yes, already set
				move.w	d0,TCTrackNum(a1)			; no, set track cache to this track
				bsr		InvalidateTrackCache		; invalidate the cache

@sectLoop		bset.b	#SectorNeeded,\
							(SectorBufPtr,a1,d2.w*2); mark this sector as needed
				tst.l	VerifyPtr(a1)				; are we verifying?
				beq.s	@cntSect					; no, see if already there
				bclr.b	#SectorValid,\
							(SectorBufPtr,a1,d2.w*2); yes, mark this sector as not there (so we read it)

@cntSect		btst.b	#SectorValid,\
							(SectorBufPtr,a1,d2.w*2); is this sector already in cache?
				bne.s	@nextSect					; yes, don't count it as needed
				cmp.b	PhysSectsPerHead(a1),d2		; on head 1?
				blt.s	@cntHead0					; no, flag we need side 0
				addq.b	#1,SectorsToRead+1(a1)		; count needed on side 1
				bra.s	@nextSect
@cntHead0		addq.b	#1,SectorsToRead(a1)		; count needed on side 0
@nextSect		addq.l	#1,d2						; next block #
				subq.l	#1,d3						; count the block
				ble.s	@startRead					; none left, this is the last cylinder
				
				cmp.b	PhysSectsPerCyl(a1),d2		; is this the last one?
				blt.s	@sectLoop					; no, get another

;-------------------------------------------------
;	Now we know what sectors are needed, seek to the cylinder and read them
;-------------------------------------------------
@startRead		move.b	#1,Interleave(a1)			; assume 1-1 (mfm) interleave
				btst.b	#GCRModeBit,([vSetup,a1])	; are we in MFM mode
				beq.s	@createMap					; yes, interleave correct
				moveq	#$1F,d0						; mask only the interleave bits
				and.b	SectHdrFmtKind(a1),d0		; get format byte from header
				move.b	d0,Interleave(a1)			; setup the GCR interleave factor

@createMap		bsr		BuildInterleaveMap			; build the interleave map

				move.w	#RecalsMax,RecalsLeft(a1)	; Max Recals allowed before hard error

@seektoCyl		tst.w	SectorsToRead(a1)			; and sectors to get (or are they all in the cache)?
				beq.s	@copyTrack					; no, skip the read
				
				move.b 	PhysCylinder(a1),d0			; get the desired cylinder number
				bsr		SeekTrack					; seek to it

				move.w	#IOErrorsMax,IOErrorsLeft(a1)	; Max I/O errors allowed before Recal

				bsr 	WaitDriveReady				; wait for the seek to complete
				bne		@recalAndRetry				; if error seeking, try to recal
		
@retry			clr.b	PhysHead(a1)
				bsr 	ReadTrack 					; read the track
				bne		@readErr					; branch on errors
			
				addq.b	#1,PhysHead(a1)				; bump to head 1
				bsr 	ReadTrack 					; read the track
				bne		@readErr					; branch on errors

;-------------------------------------------------
;	All needed sectors for this cylinder are in the DMA buffer, now denibblize/copy/verify into user buffer
;-------------------------------------------------

@copyTrack		moveq	#0,d3						; start with sector 0

@nextBlock		btst.b	#SectorNeeded,\
							(SectorBufPtr,a1,d3.w*2); do we need this sector?
				bne.s	@translate					; yes, translate into user buffer
				addq.b	#1,d3						; no, try next one
				cmp.b	PhysSectsPerCyl(a1),d3		; is this the last one?
				blt.s	@nextBlock					; no, repeat
				bra		@nextCylinder				; yes, handle next cylinder

@translate		lea		TagData+2,a3				; a3 = ptr to tag buffer (lowmem)
				movea.l	BlockAddress(a1),a0			; a0 = ptr to user buffer, (assume not verifying)
				move.l	VerifyPtr(a1),d2			; are we verifying?
				beq.s	@denib						; yes, we're all set
				movea.l	d2,a0 						; a0 = ptr to denibbleizing buffer

@denib			move.l	d3,d0						; d0 = sector#
				bsr		DeNibbleize					; de-nibblize it into user buffer
				beq.s	@chkTags					; no errors, continue
				bclr.b	#SectorValid,\				;
						(SectorBufPtr,a1,d3.w*2)	; error, mark this sector as not valid
				bra.s	@readErr
				
@chkTags		move.l	CurTagPtr(a1),d0			; does the user have a tag buffer? (d0=0)
				beq.s	@chkVerify					; no, then leave tags in lowmem		
			
				movea.l	d0,a0
				lea		TagData+2,a3				; a3 = ptr to tag lowmem
				move.l	(a3)+,(a0)+					; copy tags into user buffer
				move.l	(a3)+,(a0)+
				move.l	(a3)+,(a0)+
				
@chkVerify		tst.l	d2							; are we verifying?
				beq.s	@bumpTag					; no, handle next block, if any more
				movea.l	d2,a0						; a0=ptr to read data
				movea.l	BlockAddress(a1),a3			; a3=ptr to expected data
				moveq	#(BlockSize/4)-1,d2			; loop counter
@verifyLoop		move.l	(a0)+,d0					; get next longword
				cmp.l	(a3)+,d0					; compare to expected
				dbne	d2,@verifyLoop				; repeat for 512 bytes, or error
				beq.s	@bumpTag					; no error, continue
				bsr		InvalidateTrackCache		; invalidate the cache
				moveq	#dataVerErr,d0				; verify error,
				bra.s	@readExit					; exit

@bumpTag		bclr.b	#SectorNeeded,\				;
						(SectorBufPtr,a1,d3.w*2)	; sector's ok, mark as not needed
				moveq	#0,d0
				tst.l	CurTagPtr(a1)
				beq.s	@bumpBuf
				moveq	#TagSize,d2
				add.l	d2,CurTagPtr(a1)			; bump tag ptr
				
@bumpBuf		add.l	#BlockSize,BlockAddress(a1)	; update buffer address
				addq.l	#1,LogicalBlock(a1)			; next block
				subq.l	#1,BlockCount(a1)			; count the block
				bne		@nextBlock
	
@done			movea.l	DCEPointer(a1),a3			; get DCE pointer
				movea.l	DCtlQHead(a3),a0			; get IO param block pointer
				move.l	ioByteCount(a0),d1			; get byte count
				move.l	d1,ioNumDone(a0)			; all byte done
				add.l	d1,dCtlPosition(a3)			; update position pointer
				bra.s	@readExit					; return	
	
@readErr		addq.w	#1,ErrorCount(a1,d1.w*2)	; count the error for this drive
				subq.w	#1,IOErrorsLeft(a1)			; count the error
				bge		@retry						; more retrys left, continue

@recalAndRetry	subq.w	#1,RecalsLeft(a1)			; see if RecalsMax exceeded
				blt.s	@readExit					; if too many retrys, die with hard error
				bsr 	ReCalibrate 				; move heads to track zero, init the drive
				beq	 	@seektoCyl					; if Recal OK, retry seek

@readExit		bra		Swim3DiskDone




;_______________________________________________________________________
;
;  Routine: 	jmp 	SWIM3Write
;  Inputs:		a0	-	iopb
;				a1	-	SonyVars
;				ReqDriveNumber	-	logical drive #
;				LogicalBlock	-	block # for request
;				BlockAddress	-	user buffer address
;				BlockCount		-	# of blocks to xfer
;  Outputs: 	
;  Destroys:	a0,a3,d0-d2
;  Calls:		ReCalibrate
;  Called by:	DiskPrime
;
;  Function:	Writes the requested blocks into the user buffer / track cache.
;_______________________________________________________________________

SWIM3Write		move.l	TagBufPtr(a1),CurTagPtr(a1)		; init our index into user tag buffer

				bsr 	SetUpDrive						; select and power up the disk drive
				bne	 	@writeExit						; exit if error
				
				moveq 	#wPrErr,d0 						; assume write protected
				movea.l	DriveInfoPtrs(a1,d1.w*4),a3		; get ptr to drive info for this drive
				tst.b	MyDriveInfo.WriteProtected(a3)	; see if write protected
				bmi		@writeExit						; yes, exit

				moveq	#noAdrMkErr,d0					; assume invalid disk format
				cmpi.b	#unknownFormat,DiskFormat(a1,d1.w)	; does this disk have a valid format?
				beq		@writeExit						; no, exit with error

;-------------------------------------------------
; 	Here we want to calculate all the needed sectors for this cylinder, and copy
;	into the DMA buffer.
;-------------------------------------------------

@nextCylinder	move.l	LogicalBlock(a1),d0			; init our block#
				bsr		BlocktoPhysAddr				; compute starting sector/track for this format
				moveq	#0,d2
				move.b	PhysCylSector(a1),d2		; get cylinder sector # in d2
				
				bsr		ClearNeededTrackCache		; assume no sectors are needed yet
				clr.w	SectorsToWrite(a1)
				
				moveq	#0,d0
				move.b	PhysCylinder(a1),d0			; get desired cylinder
				cmp.w	TCTrackNum(a1),d0			; does our track cache hold this one?
				beq.s	@sectLoop					; yes, already set
				move.w	d0,TCTrackNum(a1)			; no, set track cache to this track
				bsr		InvalidateTrackCache		; invalidate the cache

@sectLoop		bset.b	#SectorNeeded,\
							(SectorBufPtr,a1,d2.w*2); mark this sector as needed
				bclr.b	#SectorValid,\
							(SectorBufPtr,a1,d2.w*2); mark this sector as not valid
				
				move.l	CurTagPtr(a1),d0			; does user have his own tag buffer?
				beq.s	@nib						; no, all set
				movea.l	d0,a0						; yes, use it
				lea		TagData+2,a3				; 
				move.l	(a0)+,(a3)+					; copy from user tag buffer into lowmem
				move.l	(a0)+,(a3)+
				move.l	(a0)+,(a3)+

@nib			lea		TagData+2,a3				; a3 = ptr to tag buffer (assume no user buffer)
				movea.l	BlockAddress(a1),a0			; a0 = ptr to user buffer,
				
				moveq	#0,d0
				move.b	(SectorBufPtr+1,a1,d2.w*2),d0 ; get buffer# for this sector
				move.l	(TrackCachePtr,a1,d0.w*4),\
							NibbilizeDMAPtr(a1)		; set the DMA ptr for Nibbleize
				move.b	d2,d3						; get cylinder sector #
				cmp.b	PhysSectsPerHead(a1),d3		; on head 1?
				blt.s	@setHead0					; no, flag we need side 0
				addq.b	#1,SectorsToWrite+1(a1)		; count needed on side 1
				sub.b	PhysSectsPerHead(a1),d3		; and adjust for head 1
				bra.s	@setSect
@setHead0		addq.b	#1,SectorsToWrite(a1)		; count needed on side 0
@setSect		move.b	d3,PhysSector(a1)			; setup the track sector #
				bsr		Nibbleize					; nibblize it into our DMA buffer

				tst.l	CurTagPtr(a1)				; does user have tag buffer?
				beq.s	@cntBlock					; no, don't bump it
				moveq	#TagSize,d0
				add.l	d0,CurTagPtr(a1)			; bump tag ptr

@cntBlock		addi.l	#BlockSize,BlockAddress(a1)	; update buffer address
				addq.l	#1,LogicalBlock(a1)			; next block
			
				addq.l	#1,d2						; next sector #
				subq.l	#1,BlockCount(a1)			; count the block
				ble.s	@startTransfer				; none left, this is the last cylinder
				
				cmp.b	PhysSectsPerCyl(a1),d2		; is this the last one?
				blt.s	@sectLoop					; no, get another

;-------------------------------------------------
; 	The sectors are marked and loaded into the cache, now
;	write them to the cylinder
;-------------------------------------------------
				
@startTransfer	move.b	#1,Interleave(a1)			; assume 1-1 (mfm) interleave
				btst.b	#GCRModeBit,([vSetup,a1])	; are we in MFM mode
				beq.s	@createMap					; yes, interleave correct
				moveq	#$1F,d0						; mask only the interleave bits
				and.b	SectHdrFmtKind(a1),d0		; get format byte from header
				move.b	d0,Interleave(a1)			; setup the GCR interleave factor

@createMap		bsr		BuildInterleaveMap			; build the interleave map

				move.w	#RecalsMax,RecalsLeft(a1)	; Max Recals allowed before hard error

@seektoCyl		bsr 	WaitMotorSettled			; wait for motor speed to be in 1.5% tolerance

				move.b 	PhysCylinder(a1),d0			; get the desired cylinder number
				bsr		SeekTrack					; seek to it

				move.w	#IOErrorsMax,IOErrorsLeft(a1)	; Max I/O errors allowed before Recal
				
				bsr 	WaitDriveReady				; wait for the seek to complete
				bne.s	@recalAndRetry				; if error seeking, try to recal
		
@retry			clr.b	PhysHead(a1)
				move.b	SectorsToWrite(a1),d0		; need any from side 0?
				beq.s	@chkSide1					; no, see if side 1
				cmpi.b	#1,d0						; yes, see if more then 1 sector needed
				bgt.s	@write0						; more than 1, leave sign bit clear (d0, bit 7)
				st.b	d0							; else, set sign bit						
@write0			bsr 	WriteTrack 					; write the track
				bne.s	@writeErr					; branch on errors
			
@chkSide1		move.b	SectorsToWrite+1(a1),d0		; need any from side 0?
				beq.s	@anyLeft					; no, see if any more blocks remain in request
				cmpi.b	#1,d0						; yes, see if more then 1 sector needed
				bgt.s	@write1						; more then 1, leave sign bit clear (d0, bit 7)
				st.b	d0							; else, set sign bit						
@write1			addq.b	#1,PhysHead(a1)				; bump to head 1
				bsr 	WriteTrack 					; write the track
				bne.s	@writeErr					; branch on errors

@anyLeft		tst.l	BlockCount(a1)				; any blocks remaining?
				bne		@nextCylinder				; yes, copy them
				
				movea.l	DCEPointer(a1),a3			; get DCE pointer
				movea.l	DCtlQHead(a3),a0			; get IO param block pointer
				move.l	ioByteCount(a0),d1			; get byte count
				move.l	d1,ioNumDone(a0)			; all bytes done
				add.l	d1,dCtlPosition(a3)			; update position pointer
				bra.s	@writeExit
				
@writeErr		addq.w	#1,ErrorCount(a1,d1.w*2)	; count the error for this drive
				subq.w	#1,IOErrorsLeft(a1)			; count the error
				bne.s	@retry						; retry if possible

@recalAndRetry	subq.w	#1,RecalsLeft(a1)			; see if RecalsMax exceeded
				blt.s	@writeExit					; if too many retrys, die with hard error
				bsr 	ReCalibrate 				; move heads to track zero, init the drive
				beq.s 	@seektoCyl					; if Recal OK, retry seek

@writeExit		bra		Swim3DiskDone




;_______________________________________________________________________
;
;  Routine: 	jmp 	SWIM3CtlFormat
;				jmp		SWIM3CtlFmtCopy
;  Inputs:		a0		Globals
;				d1.w	driveNum
;  Outputs: 	none
;  Destroys:	d0,d2-d3,a0
;  Calls:		SetUpDrive, GetDriveStatus, WaitDriveReady, CreateTrackCache, 
;				ReCalibrate, WaitMotorSettled, SeekTrack, UpdateTagInfo, 
;				UpdateDataInfo, FmtTrack, BlockToPhysAddr,GetDriveStatus
;  Called by:	Driver control dispatcher
;
;  Function:	Disk formatting routine.  Used to Format/Copy as well.
;_______________________________________________________________________

SWIM3CtlFormat	moveq	#0,d3						; default format
				clr.l	UserBufPtr(a1)				; no sector buffer ptr
				clr.l	UserTagsPtr(a1)				; no sector tags ptr
				clr.b 	FmtByteBlkSize(a1)			; default Fmt byte / Block Size
				clr.b	FmtCopyVerify(a1)			; don't verify after format (separate call)
				bra.s	StartFormat

SWIM3CtlFmtCopy	
				move.l	2(a0),UserBufPtr(a1)		; setup sector buffer ptr
				move.l	6(a0),UserTagsPtr(a1)		; setup sector tags ptr
				move.b 	10(a0),FmtByteBlkSize(a1)	; setup Fmt byte / Block Size
				move.b	11(a0),FmtCopyVerify(a1)	; setup flag for verify
StartFormat	
		with	DriveStatusRec, MyDriveInfo
				clr.b	Interleave(a1) 				; setup sector interleave factor (use default)
				move.w	(a0),d3						; get format kind
				
				bsr 	SetUpDrive					; select and power up the disk drive
				bne 	@exit						; if error powering up

				cmpi.w	#08,d3						; see if format kind reasonable (allow a few extras for expansion)
				bhi	 	@ParamErr					; if not, it's an error

				bsr 	GetDriveStatus				; get the status for disk size
				moveq 	#1,d0						; defaults are first index into current format
				tst.w	d3 							; check format kind
				beq.s	@CopyFmtList				; if zero, use defaults (d3=0) format
				move.w	d3,d0 						; set desired format index
				moveq	#StatFmtAllowed-StatCurrentFmt,d3 ; else use the allowed bitmask
@CopyFmtList	lea		CurrentStatus(a1),a0		; get ptr to our status record
				move.b	StatCurrentFmt(a0,d3.w),d2 	; get format byte bitmask from list

				moveq	#0,d4
				moveq 	#0,d3						; initialize table index
@FmtSearchLoop	move.b 	(FmtIndexTable,d3.w),d4		; get the format for this index
				bmi 	@ParamErr					; return ParamErr if formatKind too big
				addq.w	#1,d3 						; update index
				ror.b 	#1,d2			 			; shift the formats allowed bitmask
				bcc.s	@FmtSearchLoop				; loop if this format not available
				subq.w	#1,d0 						; decrement format kind
				bne.s	@FmtSearchLoop				; loop if not the desired format kind

				move.w	d4,d0						; get format in d0
				movea.l	DriveInfoPtrs(a1,d1.w*4),a0	; get ptr to drive info for this drive
				tst.b	WriteProtected(a0)			; see if write enabled
				bpl.s	@writeEnabled				; yes, continue
		endwith
				moveq 	#wPrErr,d0 					; indicate write protected disk
				bra		@exit						; return the error
	
				
@writeEnabled	move.b 	d0,DiskFormat(a1,d1.w)		; change to new disk format
				move.b	(DefaultGapSize,d0.w),SectorGapSize(a1)	; setup sector gap info

				move.b 	FmtByteBlkSize(a1),d2		; get Fmt byte / Block Size from request
				bne.s	@gotFmtByte					; if non-default, use it
				move.b 	(DefaultFmtByte,d0.w),d2	; get default format byte / block size byte value
@gotFmtByte		move.b	d2,FmtByteBlkSize(a1)		; setup Fmt byte / Block Size

				move.b 	Interleave(a1),d2			; get sector interleave factor from request
				bne.s	@gotInterleave				; if non-default, use it
				move.b 	(DefaultInterleave,d0),d2	; get the default interleave for this format
				bpl.s	@gotInterleave				; if positive, use it
				move.b	FmtByteBlkSize(a1),d2		; else, get the interleave from the format byte
				andi.b	#$1F,d2						; 
				bne.s	@gotInterleave				; if non-zero, use it
				addq.b	#1,d2						; if zero, change it to one
@gotInterleave	move.b	d2,Interleave(a1) 			; setup sector interleave factor

				bsr 	ReCalibrate 				; move heads to track zero, init the drive
				bne.s	@exit						; if error powering up

				clr.l 	LogicalBlock(a1)			; start with block number zero

				bsr 	WaitMotorSettled			; wait for motor speed to be in 1.5% tolerance
				bra.s	@Start						; start formatting

;-------------------------------------------------

@CylinderLoop	move.b 	PhysCylinder(a1),d0			; get the desired cylinder number
				bsr		SeekTrack					; seek to it
				bne.s	@exit						; die on errors

				moveq	#0,d0
				move.b	PhysSectsPerCyl(a1),d0		; 
				add.l	d0,LogicalBlock(a1)			; get first block of next cylinder

;-------------------------------------------------
;		build the sector interleave map
;-------------------------------------------------

				bsr.s	BuildInterleaveMap			; build the interleave map
				
				bsr 	WaitDriveReady				; wait for the seek to complete
				beq.s	@HeadLoop					; continue with next head if successful
				bra.s	@exit						; die on errors

@HeadLoop		bsr 	FmtTrack 					; format the track
				bne.s	@exit						; exit if formatting error
				addq.b 	#1,PhysHead(a1)				; go on to the next head
				move.b	PhysSectsPerHead(a1),d0		; decrement by blocks on this head
				sub.b 	d0,PhysSectsPerCyl(a1)		; update remaining blocks on this cylinder
				bne.s	@HeadLoop					; loop through all of the heads

@Start			move.l	LogicalBlock(a1),d0
				bsr 	BlockToPhysAddr				; convert highest block on this cylinder
				beq.s	@CylinderLoop				; process next cylinder if end not reached
				
				tst.b	FmtCopyVerify(a1)			; are we verifying?
				bne.s	SWIM3CtlVerify				; yes, call our verify routine
				
				bsr		CreateTrackCache			; create a cache using the new Format
				moveq 	#noErr,d0					; indicate format succeeded

@exit			bra 	SWIM3DiskDone				; finish up by returning the drive status

@ParamErr		moveq 	#paramErr,d0				; format kind out of range
				bra.s	@exit						; return the error
	


DefaultInterleave
;		table of interleave factors indexed by DiskFormat
				dc.b	1					;  0 - uncheckedFormat
				dc.b	1					;  1 - unknownFormat
				dc.b	1					;  2 - HD20Format
				dc.b	-1					;  3 - GCR400Kformat (get interleave from FmtByte)
				dc.b	-1					;  4 - GCR800Kformat (get interleave from FmtByte)
				dc.b	1					;  5 - MFM720Kformat
				dc.b	1					;  6 - MFM1440Kformat
				dc.b	1					;  7 - GCRonHDformat
				dc.b	1					;  8 - reserved for future use
				dc.b	1					;  9 - reserved for future use
				dc.b	1					; 10 - reserved for future use

				ALIGN	2
DefaultGapSize
;		table of inter sector gap/sync group sizes indexed by DiskFormat
				dc.b	0					;  0 - uncheckedFormat
				dc.b	0					;  1 - unknownFormat
				dc.b	0					;  2 - HD20Format
				dc.b	GCRDefaultSyncCount ;  3 - GCR400Kformat
				dc.b	GCRDefaultSyncCount ;  4 - GCR800Kformat
				dc.b	MFM720KDataGapSize	;  5 - MFM720Kformat
				dc.b	MFM1440KDataGapSize ;  6 - MFM1440Kformat
				dc.b	MFM1440KDataGapSize ;  7 - GCRonHDformat
				dc.b	0					;  8 - reserved for future use
				dc.b	0					;  9 - reserved for future use
				dc.b	0					; 10 - reserved for future use

				ALIGN	2
DefaultFmtByte
;		table of format byte / block size indexed by DiskFormat
				dc.b	0					;  0 - uncheckedFormat
				dc.b	0					;  1 - unknownFormat
				dc.b	0					;  2 - HD20Format
				dc.b	$02 				;  3 - GCR400Kformat 2-1 interleave
				dc.b	$22 				;  4 - GCR800Kformat 2-1 interleave
				dc.b	BlockSize/256		;  5 - MFM720Kformat
				dc.b	BlockSize/256		;  6 - MFM1440Kformat
				dc.b	BlockSize/256		;  7 - GCRonHDformat
				dc.b	0					;  8 - reserved for future use
				dc.b	0					;  9 - reserved for future use
				dc.b	0					; 10 - reserved for future use


				ALIGN	2
FmtIndexTable	
; 		table of formats indexed by offset into StatCurrentFmt/StatFmtAllowed
				dc.b	HD20Format			;  0 - HD20Format
				dc.b	GCR400Kformat		;  1 - GCR400Kformat
				dc.b	GCR800Kformat		;  2 - GCR800Kformat
				dc.b	MFM720Kformat		;  3 - MFM720Kformat
				dc.b	MFM1440Kformat		;  4 - MFM1440Kformat
				dc.b	-1					;  5 - end of list



;_______________________________________________________________________
;
;  Routine: 	jmp 	BuildInterleaveMap
;  Inputs:		a0		Globals
;				Interleave	-	interleave factor
;  Outputs: 	none
;  Destroys:	d0,d2
;  Calls:		...
;  Called by:	SWIM3CtlFormat, SWIM3Write
;
;  Function:	Builds the sector interleave map for current track.
;_______________________________________________________________________

BuildInterleaveMap
				moveq	#0,d0
				move.b 	PhysSectsPerHead(a1),d0		; number of sectors to interleave
				subq.w	#1,d0						; adjust for dbra
@MapInit		st.b 	(SectorMap,a1,d0.w)			; mark sector as available
				dbra 	d0,@MapInit					; initialize all of the sectors

				moveq	#0,d2						; sector#
@Occupied		addq.w	#1,d0 						; try the next sector
@MapNext		cmp.b 	PhysSectsPerHead(a1),d0		; see if still in range
				blt.s	@NoWrap 					; if it didn't wrap around
				sub.b 	PhysSectsPerHead(a1),d0		; if wrap around, back up
@NoWrap			tst 	(SectorMap,a1,d0.w)			; see if it is already occupied
				bpl.s	@Occupied					; if so, try another one
				move.b 	d2,(SectorMap,a1,d0.w)		; if not, update the map
				add.b 	Interleave(a1),d0 			; bump index by interleave
				addq.b	#1,d2 						; update sector number
				cmp.b 	PhysSectsPerHead(a1),d2		; see if end reached
				blt.s	@MapNext					; if not, keep on mapping

				rts
				
				
				
;_______________________________________________________________________
;
;  Routine: 	jmp 	SWIM3CtlVerify
;  Inputs:		a0		Globals
;				d1.w	driveNum
;  Outputs: 	none
;  Destroys:	d0,d2-d3,a0
;  Calls:		SetUpDrive, GetDriveStatus, WaitDriveReady, InvalidateTrackCache
;				SeekTrack, BlockToPhysAddr, GetDriveStatus, DeNibbleize
;  Called by:	Driver control dispatcher, SWIM3CtlFmtCopy
;
;  Function:	Disk verify routine.  Called after formatting to verify
;				each sector on the disk.
;_______________________________________________________________________

SWIM3CtlVerify	bsr 	SetUpDrive					; select and power up the disk drive
				bne	 	@verifyExit					; exit if error

				bsr 	GetDriveStatus				; get the status for disk size

				bsr 	WaitDriveReady				; wait for motor speed and heads to settle
				bne 	@verifyExit					; if error powering up

				bsr		InvalidateTrackCache		; invalidate the cache
				
				moveq	#0,d0
				move.w	CurrentStatus+DriveStatusRec.\
								StatDiskSize(a1),d0
				move.l	d0,LogicalBlock(a1)			; setup highest block #

				moveq 	#1,d0						; setup to dec (last block is disk size - 1)
				bra 	@Start						; start verifying

@CylinderLoop	move.l	LogicalBlock(a1),d0
				bsr 	BlockToPhysAddr				; convert highest block on this cylinder
				bne		@verifyExit					; die on errors

;-------------------------------------------------
;	mark all sectors as needed...
;-------------------------------------------------
				clr.w	SectorsToRead(a1)			; assume no sectors needed

				moveq	#0,d0
				move.b	PhysSectsPerCyl(a1),d0		; init our counter
				bra.s	@cntSect
@sectLoop		bset.b	#SectorNeeded,\
							(SectorBufPtr,a1,d0.w*2); mark this sector as needed
				bclr.b	#SectorValid,\
							(SectorBufPtr,a1,d0.w*2); and as not there (force the read)

				cmp.b	PhysSectsPerHead(a1),d0		; on head 1?
				blt.s	@cntHead0					; no, flag we need side 0
				addq.b	#1,SectorsToRead+1(a1)		; count needed on side 1
				bra.s	@cntSect
@cntHead0		addq.b	#1,SectorsToRead(a1)		; count needed on side 0

@cntSect		dbra	d0,@sectLoop				; repeat for entire cylinder

;-------------------------------------------------
;	Now we have all sectors marked, seek to the cylinder and read them
;-------------------------------------------------

				move.b	#1,Interleave(a1)			; assume 1-1 (mfm) interleave
				btst.b	#GCRModeBit,([vSetup,a1])	; are we in MFM mode
				beq.s	@createMap					; yes, interleave correct
				moveq	#$1F,d0						; mask only the interleave bits
				and.b	SectHdrFmtKind(a1),d0		; get format byte from header
				move.b	d0,Interleave(a1)			; setup the GCR interleave factor

@createMap		bsr		BuildInterleaveMap			; build the interleave map

				move.b 	PhysCylinder(a1),d0			; get the desired cylinder number
				bsr		SeekTrack					; seek to it
				bne.s	@verifyExit					; die on errors

				move.w	#IOErrorsMax,IOErrorsLeft(a1)	; max I/O errors allowed before failing

				bsr 	WaitDriveReady				; wait for the seek to complete
				bne.s	@verifyExit					; die on errors

@retry			clr.b	PhysHead(a1)
				bsr 	ReadTrack 					; read the track
				bne		@cntErr						; branch on errors
			
				addq.b	#1,PhysHead(a1)				; bump to head 1
				bsr 	ReadTrack 					; read the track
				bne.s	@cntErr						; continue if no errors

;-------------------------------------------------
;	All sectors have read ok, now denibbleize them 
;	to check for CRC errors (GCR only)
;-------------------------------------------------

@checkCRC		btst.b	#GCRModeBit,([vSetup,a1])	; are we in MFM mode
				beq.s	@readOK						; yes, SWIM3 already did the CRC

				moveq	#0,d2
				move.b	PhysSectsPerCyl(a1),d2		; init our counter
				subq.w	#1,d2						; adjust for dbra

@crcLoop		lea		TagData+2,a3				; a3 = ptr to tag buffer (lowmem)
				movea.l	WritePtr(a1),a0				; a0 = ptr to denib buffer,
				move.l	d2,d0						; d0 = sector#
				bsr		DeNibbleize					; de-nibblize it into temporary buffer
				dbne	d2,@crcLoop					; repeat for all sectors, or error
				beq.s	@readOK						; continue if no errors

				bclr.b	#SectorValid,\
							(SectorBufPtr,a1,d2.w*2); else, force it to read again

@cntErr			addq.w	#1,ErrorCount(a1,d1.w*2)	; count the error for this drive
				subq.w	#1,IOErrorsLeft(a1)			; count the retry
				bge.s	@retry						; more retrys left, continue
				bra.s	@verifyExit
				
;-------------------------------------------------
;	All sectors are good, continue with next cylinder
;-------------------------------------------------

@readOK			moveq	#0,d0
				move.b	PhysSectsPerCyl(a1),d0	
@Start			sub.l 	d0,LogicalBlock(a1)			; subtract out the cylinder size, update block #
				bge 	@CylinderLoop				; continue verify if more cylinders

				moveq 	#noErr,d0					; verify succeeded
@verifyExit		bra		Swim3DiskDone




;_______________________________________________________________________
;
;  Routine: 	jsr 	PollingTask
;  Inputs:		a1	-	SonyVars
;  Outputs: 	
;  Destroys:	a0,d0-d2
;  Calls:		StartTMPBTimer, WaitTMPBdone, PrefetchIntoCache, TurnOffDrive,
;				SelectDrive, AddrAndSense, AddrAndStrb, CheckStaticAttr,
;				GetDriveStatus
;  Called by:	DiskOpen
;
;  Function:	Timer task that polls all of the installed drives,
;				turning off the drive motor if the timeout period has expired,
;				and looks for disk inserted, or eject button events, and
;				notifies the HOST processor if they are found.
;_______________________________________________________________________

PollingTask		lea		PollingTMPB+TimeMgrOffset(a1),a0	; get the polling timer
				move.l	#PollRate,d0
				bsr 	StartTMPBTimer				; start the timer
				bsr 	WaitTMPBdone				; wait for it to time out

;		when the timer runs out, we will wake up and snoop around

				move.w	sr,-(sp)					; •• save old int mask
				ori.w	#$0700,sr					; •• mask all interrupts (to keep others who
													;    might make a driver call at int time out).
				
				tst.b	DriverActive(a1)			; see if driver is active
				bne.s	@PollExit	 				; skip poll if active
				move.b	MotorTimingOut(a1),d0		; see if timing out a drive motor
				beq.s	@PollDrives					; not timing out, do the poll
				subq.b 	#1,MotorTimingOut(a1)		; decrement the timeout counter
				bne.s	@PollExit	 				; exit if count not expired

				bsr 	TurnOffDrive				; it is time to turn off the drive motor

@PollDrives		moveq 	#0,d1						; initial drive number
@PollDriveLoop	move.b 	DriveKind(a1,d1.w),d0		; get the drive kind
				beq.s	@PollNextDrive				; skip it if not installed
				tst.b 	MediaKind(a1,d1.w)			; see if any media in drive
				beq.s	@PollDiskInPlace			; no media, check for disk inserted
				bra.s	@PollEjectSwitch			; there is a disk, see if eject pressed

@PollDiskInPlace 
				cmpi.b 	#HD20DriveKind,d0			; check for HD-20 (special case)
				beq.s 	@PollNextDrive			 	; if HD-20, skip (for now)
				move.b 	PhysDriveNumber(a1,d1.w),d0	; get the physical drive number
				bsr 	SelectDrive					; select the drive
				moveq 	#rNoDiskInPlAdr,d0			; prepare to test for disk in place
				bsr 	AddrAndSense				; read the status bit
				bne.s 	@PollNextDrive				; if still no disk in place
				moveq 	#wNoDiskInPlAdr,d0			; make it look like the disk ejected
				bsr 	AddrAndStrb					; to reset the eject latch

				bsr 	CheckStaticAttr				; check the media kind and write protect
				
@PostDiskInPlace 
				moveq	#0,d0						; upper d0 <- 0, disk inserted
				bsr.s	@PostEvent					; send it to the system
				beq.s	@PollNextDrive 				; all done if not error
				clr.b 	MediaKind(a1,d1.w)			; indicate NoMediaKind if couldn't mount
	
@PollNextDrive	addq.w	#1,d1 						; point to next logical drive
				cmpi.w 	#NumberOfDrives,d1			; compare to limit
				blt.s	@PollDriveLoop				; loop through all drives
			 	bsr.s	@DeselectDrives				; deselect both drives

@PollExit		move.w	(sp)+,sr					; •• restore interrupts
				bra.s	PollingTask					; and start another poll

				
@PollEjectSwitch 
				cmpi.b 	#HD20DriveKind,d0			; check for HD-20 (special case)
				beq.s	@PollNextDrive				; if HD-20, can't eject, so don't check
				cmpi.b 	#SSGCRDriveKind,d0		 	; check for 400K drive (special case)
				beq.s	@PollNextDrive				; if 400K drive, can't eject, so don't check

				move.b 	PhysDriveNumber(a1,d1.w),d0	; get the physical drive number
				bsr 	SelectDrive					; select the drive
				moveq 	#rEjectOnAdr,d0				; prepare to test for eject latch set
				bsr 	AddrAndSense 				; read the status bit
				beq.s	@PollNextDrive				; if latch not set (eject button hadn't been pushed)
				moveq 	#wNoDiskInPlAdr,d0			; make it look like the disk ejected
				bsr 	AddrAndStrb					; to reset the eject latch
				moveq	#-1,d0						; upper d0 <- -1, disk ejected
				bsr.s	@PostEvent					; send it to the host (ignore errors)
				bra.s	@PollNextDrive		 		; keep on polling


@PostEvent		movea.w	#DiskInsertEvt,a0			; a0 <- event type
				clr.w	d0							; zero extend drive number
				move.b	d1,d0						; insert drive number into message
				_PostEvent							; post the insert/eject
				bsr		GetDriveStatus				; update status for this drive

@DeselectDrives	move.b 	#StartAction+WriteMode,\
									([vZeroes,a1])	; clear action and write mode (prepare for motoroff)
				nop
				move.b	#Drive1Enabled\
						 +Drive2Enabled,([vZeroes,a1])	; reset MotorOn and Enables, disabling all drives
				tst.w	d0							; check error
				rts 								; return to caller




;_______________________________________________________________________
;
;  Routine: 	jsr 	SetUpDrive
;  Inputs:		a1		-	driver globals
;  Outputs: 	d0.w	- 	error status code
;  Destroys:	d0,d2-d3,a0
;  Calls:		
;  Called by:	SWIM3CtlEject, SWIM3Read, SWIM3Write, SWIM3CtlFormat,
;				SWIM3CtlVerify, SWIM3CtlGetRawData
;
;  Function:	Selects and Powers up the specified drive.	If the disk in
;				this drive had not been powered up before, it will also
;				perform a re-calibrate, and determine the format kind of
;				the disk.  The drive will be turned off by the polling
;				task when it resumes and the timeout counter expires, or
;				when TurnOffDrive is explicitly called to turn it off.
;_______________________________________________________________________

SetUpDrive		move.w	#nsDrvErr,d0				; assume invalid drive #
				move.w	ReqDriveNumber(a1),d1		; see what drive is requested
				beq.s	@setupDone					; 0 is not valid
				cmpi.w	#MaxDriveNum,d1				; check high limit
				bgt.s	@setupDone					; exit if out of range
				
				cmp.w	CurrentDrive(a1),d1			; see if already powered up
				bne.s	@notCurrentDrive			; no, then set it up
				
				move.b	#motorTimeoutCount,MotorTimingOut(a1) 	; restart our motor timeout oneshot

@setupGood		moveq	#0,d0						; good result
		
@setupDone		move.w	d0,-(sp)					; save result
				bsr		FlushIfDisabled				; flush cache if disabled
				move.w	(sp)+,d0					; restore result
				
				rts
			
				
@notCurrentDrive
				move.w	#noDriveErr,d0				; assume no drive installed
				move.b	DriveKind(a1,d1.w),d2		; get drive kind
				beq.s	@setupDone					; exit if no drive present
				
				bsr 	TurnOffDrive				; turn off the old drive (whatever was selected)
				bsr 	TurnOnDrive 				; turn on the new drive
				bne.s 	@setUpDone					; return error if couldn't turn on drive

				
				cmp.w	LastActiveDrive(a1),d1		; see if same drive as last successful access
				beq.s	@setupGood					; yes, return with success, no drive change

				move.w	d1,LastActiveDrive(a1)		; mark this drive as last active, assuming success
				
				move.b	DiskFormat(a1,d1.w),d0		; see if format has been determined
				beq.s	@firstTime					; unchecked format, first time disk is accessed.
				
			
				bsr		LoadSWIMparams				; load params if format is known
				bra.s	@fmtChangeDone				; drive changed, so create a new track cache

			
@firstTime		move.l	(sp)+,AsyncPc(a1)			; •• save callers pc
				bsr 	CheckStaticAttr				; update media kind and write enable
				
				lea 	ReadyTMPB+TimeMgrOffset(a1),a0	; get the ready timer block
				bsr 	WaitTMPBdone				; wait for it to time out
				move.l	#ChuckingDelay,d0			; get Disk Chucking wait time
				bsr 	StartTMPBTimer				; start the timer

				moveq	#0,d3						; init our format search index
@SearchLoop		move.b	(FmtSearchOrder,d3.w),d0	; get format to try
				addq.w	#1,d3						; bump the index
				move.b	d0,DiskFormat(a1,d1.w)		; setup the disk format to try
				eori.b	#unknownFormat,d0			; are we done?
				beq.s	@SearchDone					; unknown format found, exit
				
				bsr		ReCalibrate					; establish head position
				bne.s	@SearchError				; return with error if couldn't recal
				
				clr.b	PhysHead(a1)				; always read from side zero
				st.b	PhysSectsPerHead(a1)		; allow any sector number
				bsr		ReadSectorHdr				; try to read a sector address
@chkFmt			beq.s	@readOk						; no errors, check format
				cmpi.w	#seekErr,d0					; did it read, but invalid cylinder?
				bne.s	@SearchLoop					; no, try next format, else, we got the correct format
				
@readOk			move.b	(FmtByteValues-1,d3.w),d0	; get expected value
				move.b	SectHdrFmtKind(a1),d2		; compare to updated index
				eor.b	d2,d0
				and.b	(FmtByteMasks-1,d3.w),d0	; get only the valid bits
				beq.s	@SearchDone					; if format is correct, exit with success
				bra.s	@searchLoop					; otherwise, try next format
				
@SearchError	clr.b	DiskFormat(a1,d1.w)			; indicate unchecked format, couldn't recal

@SearchDone		ext.w	d0
				move.l	AsyncPc(a1),-(sp)			; •• restore callers pc
				
@FmtChangeDone	move.w	d0,-(sp)					; save result code
				bsr.s	CreateTrackCache			; create a cache based on the new format
				move.w	(sp)+,d0					; restore result code
				rts
				
				

;_______________________________________________________________________
;
;  Routine: 	jsr 	CreateTrackCache
;  Inputs:		d1 	- 	Drive Number
;				a1	-	driver globals
;  Outputs: 	none
;  Destroys:	d0,d2-d3
;  Calls:		none
;  Called by:	SetupDrive
;
;  Function:	This routine sets up our track cache ptrs, based on this
;				disk's format.
;_______________________________________________________________________

CreateTrackCache
				move.l	#gcrDMASize,d2				; assume GCR bytes/DMA sector
				move.b	DiskFormat(a1,d1.w),d0		; get the disk format
				subq.b	#GCR400Kformat,d0			; 400K?
				beq.s	@initPtrs					; yes, guessed correctly
				subq.b	#1,d0						; 800K?
				beq.s	@initPtrs					; yes, guessed correctly
				move.l	#mfmDMASize,d2				; no, setup for MFM sectors

@initPtrs		move.l	FloppyDMAStart(a1),d0		; physical starting offset to floppy DMA buffer
				movea.l	TrackCacheStart(a1),a0		; logical start of buffer
				moveq	#0,d3
				bra.s	@setit
				
@loop			add.l	d2,d0							; compute next offset
				adda.l	d2,a0							; 	"
@setit			move.l	d0,(TrackCacheDMAPtr,a1,d3.w*4)	; stuff the ptr
				move.l	a0,(TrackCachePtr,a1,d3.w*4)	; stuff the ptr
				move.w	d3,(SectorBufPtr,a1,d3.w*2)		; init sector buffer #, mark as invalid
				addq.w	#1,d3							; count the sector buffer
				cmpi.w	#TotalBuffers,d3				; done?
				blt.s	@loop							; no, keep going...

				add.l	d2,d0
				adda.w	d2,a0
				move.l	d0,WriteDMAPtr(a1)				; temporary sector offset (for writes)
				move.l	a0,WritePtr(a1)					; temporary sector ptr (for writes)
				rts



;_______________________________________________________________________
;
;  Routine: 	bsr 	InvalidateTrackCache
;  Inputs:		a1	-	driver globals
;  Outputs: 	none
;  Destroys:	d0
;  Calls:		none
;  Called by:	SetupDrive,SWIM3Read
;
;  Function:	This routine marks the track cache as invalid.
;_______________________________________________________________________

InvalidateTrackCache
				moveq	#TotalBuffers-1,d0			; clear all buffers
@loop			clr.b	(SectorBufPtr,a1,d0.w*2)	; mark as invalid
				dbra	d0,@loop
				rts



;_______________________________________________________________________
;
;  Routine: 	bsr 	FlushIfDisabled
;  Inputs:		a1	-	driver globals
;  Outputs: 	none
;  Destroys:	d0
;  Calls:		none
;  Called by:	SetupDrive, SWIM3CtlTrkCache
;
;  Function:	This routine marks the track cache as empty.
;_______________________________________________________________________

FlushIfDisabled
				tst.b	CacheEnabled(a1)			; are we disabled?
				beq.s	InvalidateTrackCache		; yes, invalidate it
				rts



;_______________________________________________________________________
;
;  Routine: 	bsr 	ClearNeededTrackCache
;  Inputs:		a1	-	driver globals
;  Outputs: 	none
;  Destroys:	d0
;  Calls:		none
;  Called by:	SWIM3Read
;
;  Function:	This routine inits all sectors to 'not needed'.
;_______________________________________________________________________

ClearNeededTrackCache
				moveq	#TotalBuffers-1,d0			; all buffers
@loop			bclr.b	#sectorNeeded,\
						(SectorBufPtr,a1,d0.w*2)	; mark as not needed
				dbra	d0,@loop
				rts

		
		
;_______________________________________________________________________
;
;  Routine: 	jsr 	GetDriveStatus
;  Inputs:		d1 - Drive Number
;  Outputs: 	none
;  Destroys:	d0
;  Calls:		none
;  Called by:	SWIM3GetFormatList, SWIM3DriveStatus, SWIM3CtlDrvInfo,
;				SWIM3CtlFormat, SWIM3CtlVerify, PollingTask
;
;  Function:	Gets the status of the current drive/disk into our CurrentStatus
;				record.
;_______________________________________________________________________

GetDriveStatus 
			with	DriveStatusRec,MyDriveInfo

				movem.l	a0/a2,-(sp)					; save this reg
				
				moveq	#0,d0
				lea		CurrentStatus(a1),a2		; get ptr to our status rec
				
				move.w	ErrorCount(a1,d1.w*2),\
						StatDiskErrors(a2)			; get # of errors for this drive
			
				move.b 	PhysDriveNumber(a1,d1.w),d0	; get the physical drive number
				move.b 	(DriveAttributes,d0.w),\
							StatDriveAttr(a2)		; get the drive attributes
			
				lea 	DefaultStatus,a0			; get ptr to defaults table
				bsr.s	TranslateStatus 			; translate the Default
				

				move.b	DriveKind(a1,d1.w),d0		; get the drive kind for the drive
				lea		StatusTables,a0
				adda.w	(DriveStatusPtrs,d0.w*2),a0	; offset to our table
				bsr.s	TranslateStatus				; translate the Drive status

				move.b	MediaKind(a1,d1.w),d0		; get the media kind for the drive
				lea		StatusTables,a0
				adda.w	(MediaStatusPtrs,d0.w*2),a0	; offset to our table
				bsr.s	TranslateStatus				; translate the Drive status

				move.b	DiskFormat(a1,d1.w),d0		; get the current disk format
				lea		StatusTables,a0
				adda.w	(FmtStatusPtrs,d0.w*2),a0	; offset to our table
				bsr.s	TranslateStatus				; translate the Drive status

				movea.l	DriveInfoPtrs(a1,d1.w*4),a0	; get ptr to drive info for this drive
				
				move.b	WriteProtected(a0),\
							StatWriteProt(a2)		; copy writeProt into our status record
				
				move.b	StatDiskInPlace(a2),\		; copy disk in place
							DiskInPlace(a0)
				move.b	StatInstalled(a2),\
							Installed(a0)			; copy installed
				move.b	StatSides(a2),\
							Sides(a0)				; copy # sides
		
				move.w	StatTwoSidedFmt(a2),\		; copy 2-sided format/ new interface bytes	
						DriveQElement+dQDrvSz(a0)	; into our drive queue element		

				movem.l	(sp)+,a0/a2
				rts 								; all done

;--------------
XlateLoop		move.b 	(a0)+,(a2,d0.w)				; move the data byte
TranslateStatus move.b 	(a0)+,d0					; get the status rec index byte
				bne.s	XlateLoop					; loop through all bytes
				rts 								; all done
		


StatusTables

;---------------------------
DefaultStatus	dc.b	StatDiskInPlace,$01			; Default status values returned
				dc.b	StatInstalled,$01
				dc.b	StatTwoSidedFmt,$FF
				dc.b	StatDriveInfoB3,0
				dc.b	StatDriveInfoB2,0
				dc.b	$00
				
;---------------------------
; Tables based on Drive Kind

NoDrive 		dc.b	StatInstalled,$FF			; unknown drive kind info
				dc.b	StatSides,$00
				dc.b	StatNewInterface,$00
				dc.b	StatDriveType,noDriveKind
				dc.b	$00


HD20Drive		dc.b	StatSides,$00				; HD-20 drive kind info
				dc.b	StatNewInterface,$00
				dc.b	StatFmtAllowed,$01
				dc.b	StatCurrentFmt,$01
				dc.b	StatDriveType,HD20DriveKind
				dc.b	$00


SSGCRDrive		dc.b	StatSides,$00				; 400K GCR drive kind info
				dc.b	StatNewInterface,$00
				dc.b	StatFmtAllowed,$02
				dc.b	StatDriveType,SSGCRDriveKind
				dc.b	$00


DSGCRDrive		dc.b	StatSides,$FF				; 400K / 800K GCR drive kind info
				dc.b	StatNewInterface,$FF
				dc.b	StatFmtAllowed,$06
				dc.b	StatDriveType,SSGCRDriveKind
				dc.b	$00


DSMFMGCRDrive	dc.b	StatSides,$FF				; 400K / 800K GCR, 720K / 1440K MFM drive kind info
				dc.b	StatNewInterface,$FF
				dc.b	StatFmtAllowed,$0E
				dc.b	StatDriveType,DSMFMGCRDriveKind
				dc.b	$00

;---------------------------
; Tables based on Media Kind

NoMedia 		dc.b	StatDiskInPlace,$00			; no media kind info
				dc.b	StatFmtAllowed,$00
				dc.b	StatCurrentFmt,$00
				dc.b	$00

LoDenMedia		dc.b	StatCurrentFmt,$02
				dc.b	$00

HiDenMedia		dc.b	StatFmtAllowed,$10
				dc.b	StatCurrentFmt,$10
HD20Media		dc.b	$00

;---------------------------
; Tables based on Disk Format Kind

NoFmt			dc.b	StatDiskInPlace,$02			; unknown format kind info

UnCheckedFmt	dc.b	StatTwoSidedFmt,$00			; unchecked format kind info
				dc.b	StatDiskSize,$00
				dc.b	StatDiskSize+1,$00
				dc.b	$00

HD20Fmt 		dc.b	StatDiskInPlace,$08			; HD-20 format kind info
				dc.b	StatTwoSidedFmt,$00
				dc.b	StatDiskSize,$98			; $9835 = 38965
				dc.b	StatDiskSize+1,$35
				dc.b	$00

GCR400KFmt		dc.b	StatDiskInPlace,$02			; 400K GCR format kind info
				dc.b	StatDiskSize,$03			; $0320 = 800
				dc.b	StatDiskSize+1,$20
				dc.b	$00

GCR800KFmt		dc.b	StatDiskInPlace,$02			; 800K GCR format kind info
				dc.b	StatCurrentFmt,$04
				dc.b	StatDiskSize,$06			; $0640 = 1600
				dc.b	StatDiskSize+1,$40
				dc.b	$00

MFM720KFmt		dc.b	StatDiskInPlace,$02			; 720K MFM format kind info
				dc.b	StatCurrentFmt,$08
				dc.b	StatDiskSize,$05			; $05A0 = 1440
				dc.b	StatDiskSize+1,$A0
				dc.b	$00

MFM1440KFmt 	dc.b	StatDiskInPlace,$02			; 1440K MFM format kind info
				dc.b	StatDiskSize,$0B			; $0B40 = 2880
				dc.b	StatDiskSize+1,$40
				dc.b	$00

GCRonHDFmt		dc.b	StatDiskInPlace,$03			; 400K/800K GCR on HD media format kind info
				dc.b	StatFmtAllowed,$10
				dc.b	StatCurrentFmt,$10
				dc.b	StatDiskSize,$0B			; $0B40 = 2880
				dc.b	StatDiskSize+1,$40
				dc.b	$00


;---------------------------
DriveStatusPtrs dc.w	NoDrive-StatusTables		; 0 - no drive
				dc.w	NoDrive-StatusTables		; 1 - unspecified drive
				dc.w	SSGCRDrive-StatusTables		; 2 - Single Sided 400K GCR Drive
				dc.w	DSGCRDrive-StatusTables		; 3 - Double Sided 400K/800K GCR Drive
				dc.w	DSMFMGCRDrive-StatusTables	; 4 - Double Sided GCR / MFM Drive
				dc.w	NoDrive-StatusTables		; 5 - unspecified drive
				dc.w	NoDrive-StatusTables		; 6 - unspecified drive
				dc.w	HD20Drive-StatusTables		; 7 - HD-20 drive
				dc.w	NoDrive-StatusTables		; 8 - unspecified drive

MediaStatusPtrs dc.w	NoMedia-StatusTables		; 0 - No Media kind
				dc.w	LoDenMedia-StatusTables		; 1 - unknown media kind
				dc.w	HD20Media-StatusTables		; 2 - HD-20 media
				dc.w	LoDenMedia-StatusTables		; 3 - Low Density media
				dc.w	HiDenMedia-StatusTables		; 4 - High Density media

FmtStatusPtrs	dc.w	UnCheckedFmt-StatusTables	;  0 - uncheckedFormat
				dc.w	NoFmt-StatusTables			;  1 - unknownFormat
				dc.w	HD20Fmt-StatusTables		;  2 - HD20Format
				dc.w	GCR400KFmt-StatusTables 	;  3 - GCR400Kformat
				dc.w	GCR800KFmt-StatusTables 	;  4 - GCR800Kformat
				dc.w	MFM720KFmt-StatusTables 	;  5 - MFM720Kformat
				dc.w	MFM1440KFmt-StatusTables	;  6 - MFM1440Kformat
				dc.w	GCRonHDFmt-StatusTables 	;  7 - GCRonHDformat


DriveAttributes 		; table of drive attributes, indexed by PhysDriveNumber
				dc.b	%00000000					; drive 0, non-existent
				dc.b	%00000000					; drive 1, primary int removable
				dc.b	%00001000					; drive 2, secondary int removable
				dc.b	%00000000					; drive 3, non-existent
				dc.b	%00000000					; drive 4, non-existent
				dc.b	%00000101					; drive 5, primary ext fixed HD-20
				dc.b	%00001101					; drive 6, secondary ext fixed HD-20
				dc.b	%00001101					; drive 7, secondary ext fixed HD-20
				dc.b	%00001101					; drive 8, secondary ext fixed HD-20
				dc.b	0							; word align

			endwith			



;_______________________________________________________________________
;
;  Routine: 	jsr 	CheckStaticAttr
;  Inputs:		d1 - Drive Number
;  Outputs: 	none
;  Destroys:	d0
;  Calls:		AddrAndSense
;  Called by:	PollingTask, SetUpDrive
;
;  Function:	Checks the static attributes of the currently selected
;				drive, and updates the per-drive data structures to
;				reflect the current state of the attributes.  Currently
;				tested attributes are MediaKind, and WriteEnabled.
;_______________________________________________________________________

CheckStaticAttr 
			with	MyDriveInfo
				
				move.l	a3,-(sp)
				move.b 	#LoDenMediaKind,MediaKind(a1,d1.w) 	; assume low density media
				move.b 	DriveKind(a1,d1.w),d0				; check for multi-density drive
				cmpi.b 	#DSMFMGCRDriveKind,d0				; see if SuperDrive
				bne.s 	@CheckWrEnable						; if not superdrive, media density is correct
				moveq 	#r1MegMediaAdr,d0					; check for 1 or 2 megabyte media
				bsr 	AddrAndSense 						; test the media kind
				bne.s 	@CheckWrEnable						; if low density media
				move.b 	#HiDenMediaKind,MediaKind(a1,d1.w)	; indicate High Density media in drive

@CheckWrEnable	movea.l	DriveInfoPtrs(a1,d1.w*4),a3			; get ptr to drive info for this drive
				st.b	WriteProtected(a3)					; assume write protected
				moveq 	#rNoWrProtectAdr,d0					; check write enabled/protected
				bsr 	AddrAndSense 						; test the write protect
				beq.s 	@Done								; if write protected
				clr.b	WriteProtected(a3)					; not write protected
@Done			movea.l	(sp)+,a3
				rts 										; all done
				
			endwith			
		
		
		
;_______________________________________________________________________
;
;  Routine: 	bsr 	BlockToPhysAddr
;  Inputs:		d0.l	- Logical Block Number
;				d1.w	- active drive number
;  Outputs: 	d0		- 	error status code
;				ccr		-	based on error code
;				PhysCylinder	- Physical Cylinder number
;				PhysHead		- Physical Head number
;				PhysSector		- Physical Sector number
;				PhysCylSector	- Physical Sector number relative to beginning of cylinder
;				PhysSectsPerHead- Physical Number of Sectors per head on this Cylinder
;				PhysSectsPerCyl - Physical Number of Sectors on this Cylinder
;  Destroys:	d0,a0
;  Calls:		none
;  Called by:	ReadWriteSetUp, SetupTrackInfo, SWIM3CtlFormat, SWIM3CtlVerify
;
;  Function:	Converts a logical block number into a physical disk address,
;				and returns the Physical Cylinder, Head, and Sector numbers,
;				along with the total count of sectors on this head.  Range
;				checking is also performed to assure that the Block Number is
;				not beyond the end of the disk.
;
;				NOTE: The sector number returned will always be adjusted
;				so that it is zero based, even though it may not be
;				zero based on the disk (MFM is 1 based, GCR is 0 based)
;_______________________________________________________________________
				
BlockXlateHeadsPerCyl	equ		-1			; heads per cylinder
BlockXlateSectsPerHead	equ		0			; sectors per head
BlockXlateSectsPerCyl	equ		1			; sectors per cylinder (1 head)
BlockXlateCylBias		equ		2			; starting at cylinder zero (first group of 16)
BlockXlateSpare			equ		3			; ...
BlockXlateBlockLimit	equ		4			; sectors * heads * cylinders
		
		
BlockToPhysAddr 
				move.l	d2,-(sp)					; save d2
				moveq	#0,d2
				move.b	DiskFormat(a1,d1.w),d2		; get format to read
				lea		BlockXlateTable,a0
				adda.w	(a0,d2*2),a0				; a0 points to desired table
				bra.s 	@SearchStart				; start searching for the cylinder group

@SearchLoop 	sub.w	BlockXlateBlockLimit(a0),d0
				blt.s	@SearchDone 				; exit if block number below limit
				addq.w	#6,a0						; point to next record
@SearchStart	tst.b 	BlockXlateSectsPerHead(a0)	; see if end if list
				bne.s	@SearchLoop 				; not the end, keep on searching

				moveq 	#paramErr,d0				; indicate block number too big for this format
				bra.s	@exit 						; return with error status

@SearchDone 	move.b 	(a0)+,PhysSectsPerHead(a1)	; update sectors per head
				moveq	#0,d2
				move.b 	(a0)+,d2
				move.b	d2,PhysSectsPerCyl(a1) 		; update sectors per cylinder
				move.b 	(a0)+,PhysCylBias(a1)		; save starting cylinder number
				addq.w	#1,a0						; skip past dummy field
				add.w	(a0)+,d0					; undo subtract from loop

				divu.w	d2,d0						; sector offset / sectors per cylinder
				move.b	d0,PhysCylinder(a1)			; save physical cylinder #
				swap	d0
				move.b	d0,PhysCylSector(a1)		; save physical sector # within cylinder

				moveq	#-1,d2						; start with head 0
@HeadLoop		move.b	d0,PhysSector(a1)			; save sector number in case we're on head
				addq.b	#1,d2						; bump head
				sub.b	PhysSectsPerHead(a1),d0		; is sector < PhysSectsPerHead?
				bge.s	@HeadLoop					; yes, found correct head
				
				move.b 	d2,PhysHead(a1)				; update head number
				move.b	PhysCylBias(a1),d0
				add.b	d0,PhysCylinder(a1)			; update cylinder number
				moveq 	#noErr,d0					; indicate success
@exit			move.l	(sp)+,d2
				tst.w	d0
				rts 								; all done

				
		
BlockXlateTable dc.w	UnknownTable-BlockXlateTable	;  0 - uncheckedFormat
				dc.w	UnknownTable-BlockXlateTable	;  1 - unknownFormat
				dc.w	UnknownTable-BlockXlateTable	;  2 - HD20Format
				dc.w	GCR400KTable-BlockXlateTable	;  3 - GCR400Kformat
				dc.w	GCR800KTable-BlockXlateTable	;  4 - GCR800Kformat
				dc.w	MFM720KTable-BlockXlateTable	;  5 - MFM720Kformat
				dc.w	MFM1440KTable-BlockXlateTable 	;  6 - MFM1440Kformat
				dc.w	GCRonHDTable-BlockXlateTable	;  7 - GCRonHDformat
				dc.w	UnknownTable-BlockXlateTable	;  8 - reserved for future use
				dc.w	UnknownTable-BlockXlateTable	;  9 - reserved for future use
				dc.w	UnknownTable-BlockXlateTable	; 10 - reserved for future use
	
				dc.b	0							; word align

				dc.b	1							; 1 head per cylinder
GCR400KTable	dc.b	12							; 12 sectors per head
				dc.b	12*1						; 12 sectors per cylinder (1 head)
				dc.b	0*16						; starting at cylinder zero (first group of 16)
				dc.b	0							; align
				dc.w	12*1*16 					; 12 sectors, 1 head, 16 cylinders

				dc.b	11,11*1,1*16,0
				dc.w	11*1*16

				dc.b	10,10*1,2*16,0
				dc.w	10*1*16

				dc.b	9,9*1,3*16,0
				dc.w	9*1*16

				dc.b	8,8*1,4*16,0
				dc.w	8*1*16

				dc.b	0


				dc.b	2							; 2 head per cylinder
GCRonHDTable
GCR800KTable	dc.b	12,12*2,0*16,0
				dc.w	12*2*16

				dc.b	11,11*2,1*16,0
				dc.w	11*2*16

				dc.b	10,10*2,2*16,0
				dc.w	10*2*16

				dc.b	9,9*2,3*16,0
				dc.w	9*2*16

				dc.b	8,8*2,4*16,0
				dc.w	8*2*16

				dc.b	0


				dc.b	2							; 2 head per cylinder
MFM720KTable	dc.b	9,9*2,0*80,0
				dc.w	9*2*80

				dc.b	0


				dc.b	2							; 2 head per cylinder
MFM1440KTable	dc.b	18,18*2,0*80,0
				dc.w	18*2*80

				dc.b	0


				dc.b	1							; 1 head per cylinder
UnknownTable	dc.b	8,8*1,0*1,0					; 1 cylinder, 1 head, 8 sectors
				dc.w	8*1*1						; let blocks 0..7 translate, and die in
				dc.b	0							; read sector header with no address mark
				
				



RequiredMedia	dc.b	unknownMediaKind			;  0 - uncheckedFormat
				dc.b	unknownMediaKind			;  1 - unknownFormat
				dc.b	HD20MediaKind				;  2 - HD20Format
				dc.b	LoDenMediaKind				;  3 - GCR400Kformat
				dc.b	LoDenMediaKind				;  4 - GCR800Kformat
				dc.b	LoDenMediaKind				;  5 - MFM720Kformat
				dc.b	HiDenMediaKind				;  6 - MFM1440Kformat
				dc.b	HiDenMediaKind				;  7 - GCRonHDformat
				dc.b	unknownMediaKind			;  8 - reserved for future use
				dc.b	unknownMediaKind			;  9 - reserved for future use
				dc.b	unknownMediaKind			; 10 - reserved for future use

HeadSelectDecode
				dc.b	rRdData0Adr 				; select head 0
				dc.b	rRdData1Adr 				; select head 1

GCRFmtSelDecode
				dc.b	rStepOffAdr		 			; select head 0
				dc.b	r1MegMediaAdr		 		; select head 1



;_______________________________________________________________________
;
;  Routine: 	jsr 	ReadSectorHdr
;  Inputs:		d1		- active drive number
;				SeekingCylinder	- Desired cylinder number
;				PhysHead		- Desired head number
;				PhysSectsPerHead- Upper limit for sector numbers
;  Outputs: 	d0		- error status code
;				ccr.z 	- true if an error occured
;				SectHdrCylinder - Cylinder number from sector header
;				SectHdrHead 	- Head number from sector header
;				SectHdrSector	- Sector number from sector header
;				SectHdrFmtKind	- Format Kind / Block Size from sector header
;				SectHdrHandshake- Handshake register after last byte
;				SectHdrError	- Error register after last byte
;				AdrSearchCount	- number of bytes found before header
;				CurSectsPerHead	- copy of PhysSectsPerHead
;  Destroys:	d0,d2,a0
;  Calls:		AddrAndSense, WaitForInterrupt
;  Called by:	SWIM3CtlVerify, RawTrackRead, WriteCylinder, FmtTrack
;				PrefetchIntoCache, SetUpDrive
;
;  Function:	Reads the sector header information for the next sector
;				found on the specified head, on the current cylinder.
;
;				NOTE: This routine returns to it's caller while waiting for the
;				read to complete.
;
;				NOTE: The sector number returned will always be adjusted
;				so that it is zero based, even though it may not have been
;				zero based on the disk (MFM is 1 based, GCR is 0 based)
;
;				NOTE: If a sector is found that is greater than or equal to
;				PhysSectsPerHead, it should be skipped.  The error reported
;				will be SeekErr, since the header was read correctly, but there 
;				is no buffer for the data.
;_______________________________________________________________________

ReadSectorHdr	move.l	vReadSectorHdr(a1),-(sp)	; push vector
				rts									; call routine
				
jReadSectorHdr	moveq	#0,d2
				move.b 	DiskFormat(a1,d1.w),d2		; see what format to read
				move.b 	RequiredMedia(d2.w),d0		; see what media is required
				cmp.b 	MediaKind(a1,d1.w),d0 		; see if we have correct media
				bne.s 	@ReadUnknownHdr				; if wrong kind of media
	
				lea		@ReadHdrDecode,a0
				adda.w	(a0,d2.w*2),a0
				jmp 	(a0)						; dispatch to the routine

@ReadHdrDecode	dc.w	@ReadUnknownHdr	-	@ReadHdrDecode	;  0 - uncheckedFormat
				dc.w	@ReadUnknownHdr	-	@ReadHdrDecode	;  1 - unknownFormat
				dc.w	@ReadUnknownHdr	-	@ReadHdrDecode	;  2 - HD20Format
				dc.w	@ReadGCRHdr		-	@ReadHdrDecode	;  3 - GCR400Kformat
				dc.w	@ReadGCRHdr		-	@ReadHdrDecode	;  4 - GCR800Kformat
				dc.w	@ReadLoDenMFMHdr-	@ReadHdrDecode	;  5 - MFM720Kformat
				dc.w	@ReadHiDenMFMHdr-	@ReadHdrDecode	;  6 - MFM1440Kformat
				dc.w	@ReadGCRHdr		-	@ReadHdrDecode	;  7 - GCRonHDformat
				dc.w	@ReadUnknownHdr	-	@ReadHdrDecode	;  8 - reserved for future use
				dc.w	@ReadUnknownHdr	-	@ReadHdrDecode	;  9 - reserved for future use
				dc.w	@ReadUnknownHdr	-	@ReadHdrDecode	; 10 - reserved for future use


@ReadUnknownHdr	moveq 	#noAdrMkErr,d0 				; unsupported format, return with error
				rts 								; all done


;-------------------
@ReadLoDenMFMHdr 
				moveq	#DSMFMGCRDriveKind,d0 		; check if drive supports MFM formats
				cmp.b 	DriveKind(a1,d1.w),d0		; 
				beq.s	@ReadHdr					; if correct drive, join common code
				moveq 	#noAdrMkErr,d0				; can't read MFM address marks with this drive
				rts 								; return with error
				

;-------------------
@ReadGCRHdr
@ReadHiDenMFMHdr
@ReadHdr		move.l	(sp)+,ReadHdrPc(a1)			; •• save callers pc
				
				moveq	#0,d0
				move.b 	PhysHead(a1),d0				; get the desired head number
				move.b 	HeadSelectDecode(d0.w),d0	; get the head select command
				bsr 	AddrAndSense 				; select the disk head
			 	
				tst.b 	([vError,a1])				; read and clear any pending errors
				
				move.b 	#StartAction+WriteMode,\
								([vZeroes,a1])		; clear action and write mode
				nop
				
				move.l	#TrackTimeout,d2			; 500ms second timeout
				move.l	#(StartAction<<16)+\
							idIntNum,d0				; we want the 'ID' interrupt
				bsr		WaitForInterrupt			; and wait for it...
				bne.s	@exit						; exit if error
				
@readHdrDone	move.b 	#StartAction,([vZeroes,a1])	; stop reading

				move.b	([vError,a1]),SectHdrError(a1)	; save the final error register
				
				move.b	([vFormatByte,a1]),\
							SectHdrFmtKind(a1) 		; get the format byte	

				move.b 	([vCurTrack,a1]),d0			; keep track info in d0
				move.b	d0,SectHdrCylinder(a1)		; update cylinder number
				andi.b	#$7F,SectHdrCylinder(a1)	; mask off head#
				lsr.b	#7,d0						; head is in bit 7
				move.b	d0,SectHdrHead(a1)			; update the head #
				
				moveq	#$7F,d2
				and.b 	([vCurSect,a1]),d2			; mask off the ID_valid bit
				move.b	d2,SectHdrSector(a1)		; update sector number
				btst.b	#GCRModeBit,([vSetup,a1])	; are we in gcr mode
				bne.s	@chkCRCErr					; yes, don't adjust sector #
				subq.b	#1,SectHdrSector(a1)		; else, MFM, dec the sector #

@chkCRCErr		btst.b	#CRCAddrErrBit,\
							SectHdrError(a1)		; was there a CRC error?
				bne.s	@CRCError					; yes, flag it
				
				cmp.b 	PhysHead(a1),d0				; see if we found the correct head
				bne.s	@SeekError					; if wrong head
				move.b	SectHdrCylinder(a1),d0		; get the cylinder number we found
				cmp.b 	SeekingCylinder(a1),d0		; see if we found the correct cylinder
				bne.s	@SeekError					; if wrong cylinder
				
@chkRangeErr	move.b	SectHdrSector(a1),d0		; get sector #
				cmp.b	PhysSectsPerHead(a1),d0		; is it in range?
				bhs.s	@SeekError					; no, error exit
				moveq	#0,d0						; else, no error

@exit			move.l	ReadHdrPc(a1),-(sp)			; •• restore callers pc
				tst.w	d0
				rts 								; all done

@SeekError		moveq	#seekErr,d0					; report the seek error
				bra.s	@exit
				
@CRCError		moveq	#badCksmErr,d0				; report the crc error
				bra.s	@exit
		



;_______________________________________________________________________
;
;  Routine: 	jsr 	RawTrackRead
;  Inputs:		a1	-	SonyVars
;				a3	-	ptr to reply count
;				d1	-	drive#	
;				ClockBuffer		- ptr to clock buffer
;				DataBuffer(a1)	- ptr to data buffer
;				ByteCount(a1)	- # of bytes to read
;				PhysHead		- desired head #
;				PhysSector(a1)	- desired sector #
;
;  Outputs: 	d0	-	error code	
;  Destroys:	a0,a3,d1-d3
;  Calls:		AddrAndSense, ReadSectorHdr, CancelTMPBTimer, StartTMPBTimer
;				WaitTMPBdone, StartDMAAction
;  Called by:	SWIM3CtlGetRawData
;
;  Function:	Reads raw data, starting from a postion specified by the
;				search mode value (0-3).
;_______________________________________________________________________

RawTrackRead	move.l	vRawTrackRead(a1),-(sp)		; push vector
				rts									; call routine
				
jRawTrackRead	moveq	#0,d0
				move.b 	PhysHead(a1),d0				; get the desired head number
				lea		HeadSelectDecode,a0
				move.b 	(a0,d0.w),d0				; get the head select command
				bsr 	AddrAndSense 				; select the disk head

				move.w	SearchMode(a1),d0			; get search mode to use
				beq.s	@ReadImmediate				; 0 = read now
				cmpi.b	#3,d0
				blo.s	@readAtMark					; 1,2 = read at mark
													; else, 3 = read at index...
;----------------------------
@ReadAtIndex	moveq	#rIndexPulseAdr,d0			; MFM only, wait for index pulse first
				bsr		AddrAndSense
				beq.s	@ReadAtIndex

				move.b 	PhysHead(a1),d0				; get the desired head number
				lea		HeadSelectDecode,a0
				move.b 	(a0,d0.w),d0				; get the head select command
				bsr 	AddrAndSense 				; select the disk head
				bra.s	@ReadImmediate				; start reading from index

;----------------------------
@ReadAtMark		move.l	#gcrRawTrackCnt,d0			; prepare to DMA at least 2 revolutions worth of data
				btst.b	#GCRModeBit,([vSetup,a1])	; are we in gcr mode
				bne.s	@ReadCountBytes				; yes, just load the whole track, process later

				moveq	#36,d3						; init our counter
@tryAnother		move.l	(sp)+,AsyncPc(a1)			; •• save callers pc
				bsr		ReadSectorHdr				; find the address header
				move.l	AsyncPc(a1),-(sp)			; •• restore callers pc
				tst.w	d0							; exit if not found
				bne		@exit						; 
				move.b	([vCurSect,a1]),d0			; get sector #
				cmp.b	PhysSector(a1),d0			; does it match the one we want?
				dbeq	d3,@tryAnother				; no, read next header
				beq.s	@chkDataAddr				; if we found it, continue to read the track
				moveq	#sectNFErr,d0				; indicate sector not found (timeout)
				bra		@exit						; exit if not found

@chkDataAddr	cmpi.w	#1,SearchMode(a1)			; are we reading after address field?
				beq.s	@ReadImmediate				; yes, then we're set
				
				lea 	ReadyTMPB+TimeMgrOffset(a1),a0 ; use the Ready timer to delay into the sector
				bsr 	CancelTMPBTimer				; cancel any old timeout
				moveq	#SectorDataTime,d0			; get time for 1 sector of data (about 8 ms)
				bsr 	StartTMPBTimer				; start the timer
				move.l	(sp)+,d2					; •• pop pc
				bsr 	WaitTMPBdone				; wait for it to time out
				move.l	d2,-(sp)					; •• restore pc
				
;----------------------------
;	we're positioned correctly, start the DMA now
;----------------------------

@ReadImmediate	move.l	ByteCount(a1),d0
				andi.l	#$7FFF,d0					; max of 32K
@ReadCountBytes
				add.w	d0,d0						; double count, to include flag bytes (for marks)
													; bit 31 = 0 for read
				move.l	FloppyDMAStart(a1),a0		; get 16-bit address
				bsr		SetUpDMAXFer				; get DMA controller ready to go



				move.b 	#StartAction+WriteMode,\
							([vZeroes,a1])			; clear action and write mode
				nop
				ori.b	#CopyProtMode+DisGCRConv,\
								([vSetup,a1])		; set to copy protect mode
				nop

				tst.b 	([vError,a1])				; read and clear any pending errors

				move.l	(sp)+,AsyncPc(a1)			; •• save callers pc
				move.l	#TrackTimeout*2,d0			; 500ms second timeout
				bsr		StartDMAAction				; set action, wait for DMA to complete
				move.l	AsyncPc(a1),-(sp)			; •• restore callers pc
				
				andi.b	#~(CopyProtMode+DisGCRConv),\
							([vSetup,a1])			; clear copy protect
				move.b 	#StartAction,([vZeroes,a1])	; clear action 
				
				tst.w	d0
				bne.s	@exit						; if we timed out, return error
	
@convertData	movea.l	TrackCacheStart(a1),a0		; get ptr to data
				btst.b	#GCRModeBit,([vSetup,a1])	; are we in gcr mode
				bne.s	@CopyGCR					; yes, process GCR data


;----------------------------
;	MFM mode: data is read, now just transfer to user buffer, 
;	packing the mark flags into the clock buffer
;----------------------------

@CopyMFM		move.l	a4,-(sp)					; • save this reg
				movea.l	DataBuffer(a1),a4			; init ptr to data buffer
				movea.l	ClockBuffer(a1),a2			; init ptr to clock buffer
				move.l	a0,d2
				addi.l	#DMABufLength,d2			; d2 = end+1 of floppy DMA buffer, for compare
				
@mfmLoop		moveq	#$01,d3						; init our mark bit byte
@nextMark		cmp.l	a0,d2						; are we at end of buffer?
				ble.s	@done						; yes, exit
				move.b	(a0)+,d0					; get next mark flag byte
				beq.s	@stuffMFM					; if 0, then it's a valid mark byte
				cmpi.b	#$80,d0						; or if $80,
				bne.s	@nextMark					; otherwise, get another (SWIM3 bug)

@stuffMFM		move.b	(a0)+,(a4)+					; stuff the data byte
				add.b	d0,d0
				roxl.b	#1,d3						; shift in next mark bit
				bcc.s	@nextMark					; repeat for 8 bytes
				
@nextByte		tst.l	a2							; do we have a mark buffer?
				beq.s	@cntByte					; no, just count
				move.b	d3,(a2)+					; stuff the 8 mark bits
@cntByte		addq.l	#8,(a3)						; count the 8 bytes
				subq.l	#8,ByteCount(a1)			; any left
				cmpi.l	#8,ByteCount(a1)			; more then 8 left?
				bhi.s	@mfmLoop					; yes, get them (don't bother with the remainder)

@done			movea.l	(sp)+,a4					; • restore reg
@exit			rts


;----------------------------
;	GCR mode: data is read, find the start based on SearchMode,
;	and copy the data into the users buffer (ignore the clock buffer).
;----------------------------

@CopyGCR		tst.w	SearchMode(a1)				; get search mode to use
				beq.s	@copyData					; 0 = read now
				
				moveq	#12*2,d2					; init our sector counter
@nextGCRMark	bsr.s	@findAddrMark				; get the next address mark (in d0)
				beq.s	@noAddrError				; not found, exit
				cmp.b	PhysSector(a1),d0			; does it match?
				dbeq	d2,@nextGCRMark				; no, try next
				bne.s	@noAddrError				; not found, exit with error
				
				adda.w	#7*2,a0						; skip over address header
				moveq	#1,d0
				cmp.w	SearchMode(a1),d0			; are we reading after address field?
				beq.s	@copyData					; yes, copy data from here
				
				bsr.s	@findBitSlip				; no, find next bit slip bytes (after data field)
				beq.s	@noDataError
				bra.s	@copyData					; and copy the data
				
@nextAddrMark	bsr.s	@findAddrMark				; find next address mark
				beq.s	@noAddrError				; exit if not found
			
@copyData		moveq	#0,d0
				movea.l	DataBuffer(a1),a2			; init ptr to user data buffer
				move.l	TrackCacheStart(a1),d2		; get start of buffer
				add.l	#DMABufLength,d2			; calc end+1 of buffer

@gcrLoop		cmp.l	a0,d2						; are we at end of buffer?
				ble.s	@gcrExit					; yes, exit
				move.b	(a0)+,d0					; get next flag byte
				bne.s	@gcrLoop					; if not zero, then it's not a flag byte

				move.b	(a0)+,(a2)+					; stuff the next byte
				addq.l	#1,(a3)						; count the byte
				subq.l	#1,ByteCount(a1)			; any left
				bhi.s	@gcrLoop					; yes, get them (don't bother with the remainder)
@gcrExit		moveq	#0,d0
				rts 								; all done


@noAddrError	moveq 	#noAdrMkErr,d0 				; > 3 = unsupported format, return with error
				rts 								; all done

@noDataError	moveq	#noDtaMkErr,d0
				rts 								; all done




;------------------
@findAddrMark	move.w	#1024*2,d3					; init our byte counter
@aLoop			move.b	#$D5,d0						; next byte = 1st mark byte?
				cmp.b	(a0),d0
				bne.s	@aNextByte					; no, try next
				move.b	#$AA,d0						; 2nd byte = 2nd mark byte?
				cmp.b	2(a0),d0
				bne.s	@aNextByte					; no, try next
				move.b	#$96,d0						; 
				cmp.b	4(a0),d0					; 3rd byte = 'Addr mark'?
				beq.s	@foundAMark					; yes, we found it

@aNextByte		addq.l	#1,a0						; move to next byte
				dbra	d3,@aLoop					; count it

@foundAMark		addq.w	#5,a0						; skip over mark (if found)
				moveq	#0,d0
				move.b	3(a0),d0					; get the sector # (if found)
				move.b	(@GCRDecode-$96,d0.w),d0	; decode it
				addq.w	#1,d3						; ccr.z=1 if not found, 0 if found
				rts


;------------------
@findBitSlip	move.w	#740*2,d3					; init our byte counter
@bLoop			move.b	#$DE,d0						; next byte = 1st bit slip byte?
				cmp.b	(a0),d0
				bne.s	@bNextByte					; no, try next
				move.b	#$AA,d0						; 2nd byte = 2nd bit slip byte?
				cmp.b	2(a0),d0
				beq.s	@foundBMark					; yes, we found it

@bNextByte		addq.l	#1,a0						; move to next byte
				dbra	d3,@bLoop					; count it

@foundBMark		addq.w	#3,a0						; skip over mark (if found)
				addq.w	#1,d3						; ccr.z=1 if not found, 0 if found
				rts


;------------------
@GCRDecode
				dc.b	$00,$01,$FF,$FF,$02,$03 	; $96,$97,	 ,	 ,$9A,$9B
				dc.b	$FF,$04,$05,$06,$FF,$FF 	;	 ,$9D,$9E,$9F,	 ,
				dc.b	$FF,$FF,$FF,$FF,$07,$08 	;	 ,	 ,	 ,	 ,$A6,$A7
				dc.b	$FF,$FF,$FF,$09,$0A,$0B 	;	 ,	 ,	 ,$AB,$AC,$AD
				dc.b	$0C,$0D,$FF,$FF,$0E,$0F 	; $AE,$AF,	 ,	 ,$B2,$B3
				dc.b	$10,$11,$12,$13,$FF,$14 	; $B4,$B5,$B6,$B7,	 ,$B9
				dc.b	$15,$16,$17,$18,$19,$1A 	; $BA,$BB,$BC,$BD,$BE,$BF
				dc.b	$FF,$FF,$FF,$FF,$FF,$FF	 	;	 ,	 ,	 ,	 ,	 ,
				dc.b	$FF,$FF,$FF,$FF,$FF,$1B 	;	 ,	 ,	 ,	 ,	 ,$CB
				dc.b	$FF,$1C,$1D,$1E,$FF,$FF 	;	 ,$CD,$CE,$CF,
				dc.b	$FF,$1F,$FF,$FF,$20,$21 	;	 ,$D3,	 ,	 ,$D6,$D7
				dc.b	$FF,$22,$23,$24,$25,$26 	;	 ,$D9,$DA,$DB,$DC,$DD
				dc.b	$27,$28,$FF,$FF,$FF,$FF 	; $DE,$DF,
				dc.b	$FF,$29,$2A,$2B,$FF,$2C 	;	 ,$E5,$E6,$E7,	 ,$E9
				dc.b	$2D,$2E,$2F,$30,$31,$32 	; $EA,$EB,$EC,$ED,$EE,$EF
				dc.b	$FF,$FF,$33,$34,$35,$36 	;	 ,	 ,$F2,$F3,$F4,$F5
				dc.b	$37,$38,$FF,$39,$3A,$3B 	; $F6,$F7,	 ,$F9,$FA,$FB
				dc.b	$3C,$3D,$3E,$3F 			; $FC,$FD,$FE,$FF
	



;_______________________________________________________________________
;
;  Routine: 	jsr 	ReadTrack
;  Inputs:		a1		-	SonyVars
;				PhysCylinder		- Physical Cylinder number
;				PhysSectsPerHead	- Physical Number of Sectors per head on this Cylinder
;				PhysSectsPerCyl 	- Physical Number of Sectors on this Cylinder
;				SectorBufPtr		- sector indexed based list of flags/buffer index's
;
;  Outputs: 	d0		-	error code (sector not found)
;				ccr.z	-	set based on d0
;				a0		-	ptr to this sectors DMA buffer entry
;  Destroys:	a0,d0-d3
;  Calls:		AddrAndSense, WaitForInterrupt
;  Called by:	SWIM3Read
;
;  Function:	Reads desired sectors from the current cylinder.
;_______________________________________________________________________

ReadTrack		move.l	vReadTrack(a1),-(sp)		; push vector
				rts									; call routine
				
jReadTrack		move.l	(sp)+,AsyncPc(a1)			; •• save callers pc
				clr.b	([vGap,a1])					; don't need gap bytes
				move.b	PhysSectsPerHead(a1),\
							NumSectors(a1)			; init our counter
				lea		sectorBufPtr(a1),a3			; get ptr to sector buffer table

				move.w	SectorsToRead(a1),d3		; get needed counts (both sides)
				ror.w	#8,d3
				tst.b	PhysHead(a1)				; which head?
				beq.s	@findHeader					; 0, we're set to find our position on the disk
				lsr.w	#8,d3						; else, get needed count for head 1
				moveq	#0,d2
				move.b	PhysSectsPerHead(a1),d2		; adjust for head 1
				add.l	d2,d2						; * 2 for table of words
				adda.l	d2,a3						; bump to 2nd side in table

;------------------------------
;	find current head positon
;------------------------------
@findHeader		moveq	#0,d0
				tst.b	d3							; any blocks to read?
				beq		@exit						; no, exit
				swap	d3							; yes, keep count in upper word

				jsr		ReadSectorHdr				; find the address header
				bne		@exit						; exit on errors
				move.b	SectHdrSector(a1),d0		; get sector # (0 based)
		
				clr.w	d3							; init map index
				move.b	PhysSectsPerHead(a1),d3
				subq.w	#1,d3
@findSectMap	cmp.b	(SectorMap,a1,d3.w),d0		; does this sector match the one head is over?
				dbeq	d3,@findSectMap
				beq.s	@nextSector
				_debugger							; ••somethings screwed...

;------------------------------
;	grab the next sector (in order of interleave)
;	and see if needed.
;------------------------------
@nextSector		moveq	#0,d0						; no error
				subq.b	#1,NumSectors(a1)			; count the sector
				blo		@exit						; no more to check, we're done
				addq.w	#1,d3						; bump to next entry
				cmp.b	PhysSectsPerHead(a1),d3		; are we at end of list?
				blo.s	@searchLoop					; no, repeat
				clr.w	d3							; yes, go back to start of list

@searchLoop		moveq	#0,d2
				move.b	(SectorMap,a1,d3.w),d2		; get next sector #

;-------------------------------
;	we found a sector to read, DMA it into memory
;-------------------------------
@found			move.b	d2,PhysSector(a1)			; save sector#
				move.b	d2,([vFirstSector,a1])		; set the sector # to read
				btst.b	#GCRModeBit,([vSetup,a1])	; are we in GCR mode
				bne.s	@setDMA						; yes, guessed correctly
				addq.b	#1,([vFirstSector,a1])		; adjust sector numbering for MFM

@setDMA			moveq	#0,d0
				move.b	1(a3,d2.w*2),d0					; get index into list of buffer ptrs for this sector buffer
				move.l	(TrackCacheDMAPtr,a1,d0.w*4),a0	; reset starting offset to floppy DMA buffer
				move.l	#$00008000,d0					; setup to some big count
														; bit 31 = 0 for read
				bsr		SetUpDMAXFer					; get DMA controller ready to go

@setNumSects	move.b	#1,([vSectorsToXfer,a1])		; xfer 1 sector

				tst.b 	([vError,a1])					; clear any pending errors
				move.b 	#StartAction+WriteMode,([vZeroes,a1])	; clear action and write mode

				moveq	#0,d2
				move.b	PhysHead(a1),d2					; check the head#
				move.b	(SectorsToRead,a1,d2.w),d2		; get # sectors to read for this side
				move.w	#TrackTimeout,d0				; approx track time
				mulu.w	d0,d2							; calculate max delay for this request (1 rev per sector)
				move.l	#1000,d0
				cmp.l	d0,d2							; make sure we give at least 1sec minimum
				bgt.s	@ok
				move.l	d0,d2					
@ok
				move.l	#(StartAction<<16)+\
							doneIntNum,d0				; we want the 'done' interrupt
				bset.b	#TrackTimer,StateFlags(a1) 		; we have a timeout for the whole track
				bsr		WaitForInterrupt				; wait for it...
	
				bsr		StopDMA							; stop the floppy DMA channel
				move.b 	#StartAction,([vZeroes,a1])		; clear action 
				nop
				
				moveq	#0,d2							; zero for later
				tst.w	d0								; any errors (like timeout)?
				bne.s	@hwError						; yes, see if sector was needed
				move.b	([vError,a1]),d2				; any SWIM3 errors (chksum,DMA, etc)
				beq.s	@chkTrack						; no, verify track/sector
				moveq	#BadDCkSum,d0					; yes, use this error code
					
@hwError		move.b	PhysSector(a1),d2				; yes, get the sector # we read
				btst.b	#sectorNeeded,(a3,d2.w*2)		; was this sector needed?
				bne		@exit							; yes, exit with error
				bra		@nextSector						; no, get next sector
	
@chkTrack		move.b	([vCurTrack,a1]),d2				; make sure track matches one we're after
				andi.b	#$7F,d2
				cmp.b	PhysCylinder(a1),d2
				beq.s	@checkSect
				moveq	#noAdrMkErr,d0					; no, return error
				bra.s	@exit
									
@checkSect		move.b	PhysSector(a1),d2				; get the sector # we read
				bset.b	#sectorValid,(a3,d2.w*2)		; mark as valid
				bne.s	@nextSector						; if already valid, don't count again
				btst.b	#sectorNeeded,(a3,d2.w*2)		; was this sector needed?
				beq.s	@nextSector						; no, get another
				
				swap	d3
				subq.b	#1,d3							; count the sector
				beq.s	@exit							; no more requested, exit
				swap	d3								; else, save count in upper word
				bra		@nextSector						; and get anther
				
				
@exit			move.l	d0,-(sp)						; • save error code
				lea		ReadWriteTMPB+\
							TimeMgrOffset(a1),a0		; get ptr to our timeout timer block
				_RmvTime								; remove the timer
				clr.l	tmAddr(a0)						; it's free now
				bclr.b	#TrackTimer,StateFlags(a1) 		; track timeout is removed
				move.l	(sp)+,d0						; • restore error code
				
				move.l	AsyncPc(a1),-(sp)				; •• restore callers pc
				tst.w	d0
				rts





;_______________________________________________________________________
;
;  Routine: 	jsr 	WriteTrack
;  Inputs:		d0			- 	!=0 = start with 1st sector of request (MFM only, ignore head pos)
;							      0 = write next sector under head
;				a1			- SonyVars
;				PhysHead	- Desired head number
;  Outputs: 	
;  Destroys:	a0,d0-d3
;  Calls:		ReadSectorHdr, WaitForInterrupt
;  Called by:	SWIM3Write
;
;  Function:	Writes the current track/side DMA buffer to the disk.  We are
;				assumed to be on track.  Writes all sectors for PhysHead to
;				the disk.
;_______________________________________________________________________

WriteTrack		move.l	vWriteTrack(a1),-(sp)		; push vector
				rts									; call routine
				
jWriteTrack		move.l	(sp)+,AsyncPc(a1)			; •• save callers pc
				clr.b	([vGap,a1])

				move.b	PhysSectsPerHead(a1),\
							NumSectors(a1)			; init our counter
				
				lea		sectorBufPtr(a1),a3			; get ptr to sector buffer table
				
				tst.b	PhysHead(a1)				; check the head#
				beq.s	@findNextHeader				; head 0, we're pointing to correct table
				moveq	#0,d2
				move.b	PhysSectsPerHead(a1),d2		; else, adjust for head 1
				add.l	d2,d2						; * 2 for table of words
				adda.l	d2,a3						; bump to 2nd side in table

;------------------------------
;	find next sector header that goes by (if more then 1 sector in request)
;------------------------------

@findNextHeader	tst.b	d0							; check user request; more then 1 block?
				bpl.s	@curHeadPos					; yes, get current head position

				moveq	#0,d0						; else
				move.b 	PhysHead(a1),d0				; get the desired head number
				lea		HeadSelectDecode,a0
				move.b 	(a0,d0.w),d0				; get the head select command
				bsr 	AddrAndSense 				; select the disk head
				moveq	#0,d0						; start with 1st (only) block of request
				bra.s	@findNext

@curHeadPos		bsr		ReadSectorHdr				; find the address header
				bne		@exit						; exit on errors
				move.b	SectHdrSector(a1),d0		; get sector # (0 based)
		
@findNext		moveq	#0,d3						; init map index
				move.b	PhysSectsPerHead(a1),d3
				subq.w	#1,d3
@findSectMap	cmp.b	(SectorMap,a1,d3.w),d0		; does this sector match the one head is over?
				dbeq	d3,@findSectMap
				beq.s	@nextSector
				_debugger							; ••somethings screwed...

;------------------------------
;	we know the current head position,
;	find the next sector to follow that is needed
;------------------------------

@searchLoop		moveq	#0,d2
				move.b	(SectorMap,a1,d3.w),d2		; get next sector #
				btst.b	#sectorNeeded,(a3,d2.w*2)	; is this sector needed?
				bne.s	@found						; yes, write it

@nextSector		moveq	#0,d0						; no error
				subq.b	#1,NumSectors(a1)			; count the sector
				blo		@exit						; no more to check, we're done
				addq.w	#1,d3						; bump to next entry
				cmp.b	PhysSectsPerHead(a1),d3		; are we at end of list?
				blo.s	@searchLoop					; no, repeat
				moveq	#0,d3						; yes, go back to start of list
				bra.s	@searchLoop					; and repeat
				
;-------------------------------
;	we found a sector that needs writing, DMA it out to the disk
;-------------------------------

@found			move.b	d2,PhysSector(a1)			; save sector#
				
				move.b	d2,([vFirstSector,a1])		; set the sector #
				btst.b	#GCRModeBit,([vSetup,a1])	; are we in GCR mode
				bne.s	@setCnt						; yes, guessed correctly
				addq.b	#1,([vFirstSector,a1])		; adjust sector numbering for MFM

@setCnt
				moveq	#0,d0
				move.b	1(a3,d2.w*2),d0				; get index into list of buffer ptrs for this sector buffer
				move.l	(TrackCacheDMAPtr,a1,d0.w*4),a0	; reset starting offset to floppy DMA buffer

				move.l	#$80008000,d0				; setup to some big count
													; bit 31 = 1 for write
				bsr		SetUpDMAXFer				; get DMA controller ready to go

				move.b	#1,([vSectorsToXfer,a1])	; transfer 1 sector
			
				tst.b 	([vError,a1])				; read and clear any pending errors
				move.b 	#StartAction,([vZeroes,a1])	; clear action and write mode
				nop
				move.b 	#WriteMode,([vOnes,a1])		; set write mode

				moveq	#0,d2
				move.b	PhysHead(a1),d2					; check the head#
				move.b	(SectorsToWrite,a1,d2.w),d2		; get # sectors to write for this side
				move.w	#TrackTimeout,d0				; approx track time
				mulu.w	d0,d2							; calculate max delay for this request (1 rev per sector)
				move.l	#800,d0
				cmpi.l	#800,d2							; make sure we give at least 800ms minimum
				bgt.s	@ok
				move.l	d0,d2					
@ok
				move.l	#(StartAction<<16)+\
							doneIntNum,d0			; we want the 'done' interrupt
				bset.b	#TrackTimer,StateFlags(a1) 	; we have a timeout for the whole track?
				bsr		WaitForInterrupt			; and wait for it...

				bsr		StopDMA							; stop the floppy DMA channel
				move.b 	#StartAction+WriteMode,\
							([vZeroes,a1])			; clear action and write mode
		
				tst.w	d0							; any errors?
				bne.s	@exit						; yes, exit
				
				moveq	#0,d2
				move.b	PhysSector(a1),d2			; get sector#
				bclr.b	#sectorNeeded,(a3,d2.w*2)	; mark this sector not needed
				bra		@nextSector					; and write next sector
		
@exit			move.l	d0,-(sp)					; • save error code
				lea		ReadWriteTMPB+TimeMgrOffset(a1),a0	; get ptr to our timeout timer block
				_RmvTime							; remove the timer
				clr.l	tmAddr(a0)					; it's free now
				bclr.b	#TrackTimer,StateFlags(a1) 	; track timeout is removed
				move.l	(sp)+,d0					; • restore error code

				move.l	AsyncPc(a1),-(sp)			; •• restore callers pc
				tst.w	d0							; check for timeout error
				rts




;_______________________________________________________________________
;
;  Routine: 	jsr 	DeNibbleize
;  Inputs:		d0.w-	sector# in track cache to denibbleize
;				a0	-	destination buffer
;				a1	-	SonyVars
;				a3	-	tag buffer
;  Outputs: 	
;  Destroys:	a0,d0
;  Calls:		
;  Called by:	DiskPrime
;
;  Function:	For GCR, denibblizes our DMA buffer into the tag buffer and destination
;				buffer.  There are 699 nibbles followed by 3 checksum nibbles.  We use 
;				a four nibble loop for the data nibbles . . . the first 12 bytes go 
;				into a separate buffer, then 512 bytes are placed in the user's buffer.
;
;				For MFM, this routine simply fakes out the tag data and BlockMoves
;				the data into the destination buffer.
;
;	Uses (GCR):
;		D7 = CkSumC 		
;		D6 = CkSumB 		
;		D5 = CkSumA 		
;		D4 = loop counters		A4 = ptr nibblized data
;		D3 = buffer 		
;		D2 = buffer 		
;		D1 = buffer bit pairs	A1 = ptr to 12 byte tag buffer
;		D0 = $C0 mask			A0 = ptr to 512 byte user buffer
;_______________________________________________________________________

DeNibbleize		movem.l	a1/a3/a4/d1-d7,-(sp)		; •• save registers
		
				moveq	#0,d2
				move.b	(SectorBufPtr+1,a1,d0.w*2),d2	; get buffer# for this sector
				movea.l	(TrackCachePtr,a1,d2.w*4),a4	; get logical address of sector buffer

				btst.b	#GCRModeBit,([vSetup,a1])	; are we in GCR mode
				bne.s	@gcr						; yes, guessed correctly
			
													; for MFM, fill out the tag data
				move.b	CurrentCylinder(a1),(a3)+	; stuff track#
				clr.b	(a3)						; assume side 0
				cmp.b	PhysSectsPerHead(a1),d0		; is it?
				blt.s	@0
				addq.b	#1,(a3)						; no, bump to side 1
@0				addq.w	#1,a3
				addq.b	#1,d0
				move.b	d0,(a3)+					; stuff sector#
				move.b	SectHdrFmtKind(a1),(a3)		; stuff format byte			
				ori.b	#$20,(a3)					; make it look double sided
				
				movea.l	a0,a1						; destination in a1
				movea.l	a4,a0						; source in a0
				move.l	#mfmDataSize,d0				; 512 bytes for mfm
				_BlockMove
				bra		@done						; and we're done

@gcr			addq.w	#1,a4						; skip over sector#
				movea.l	a3,a1						; A1 = tag buffer
				
				move.b	#%11000000,d0				; mask for upper 2 bits
				moveq	#0,d5						; init the checksum
				moveq	#0,d6
				moveq	#0,d7

				moveq	#10,d4						; loop counter for tag bytes
				
; first the tag bytes (12)

@RdData2		move.b	(a4)+,d1					; D1 = [00][00][A7][A6][B7][B6][C7][C6]
				rol.b	#2,d1						; D1 = [A7][A6][B7][B6][C7][C6][00][00]
				move.b	d1,d2						;
				and.b	d0,d2						; D2 = [A7][A6][00][00][00][00][00][00]

				or.b	(a4)+,d2					; D2 = ByteA'

				move.b	d7,d3						;
				add.b	d7,d3						; ex <- CkSumC[7]
				rol.b	#1,d7						; CkSumC' <- ROL (CkSumC)

				eor.b	d7,d2						; ByteA <- ByteA' XOR CkSumC'
				move.b	d2,(a1)+					; store first byte
				addx.b	d2,d5						; CkSumA',ex <- CkSumA + ByteA + ex
				rol.b	#2,d1						; D1 = [B7][B6][C7][C6][00][00][A7][A6]
				move.b	d1,d2						;
				and.b	d0,d2						; D2 = [B7][B6][00][00][00][00][00][00]

				or.b	(a4)+,d2					; D2 = ByteB' (no time for bad nibs)
				eor.b	d5,d2						; D2 = ByteB
				move.b	d2,(a1)+					; store second byte
				addx.b	d2,d6						; CkSumB',ex <- CkSumB + ByteB + ex

				rol.b	#2,d1						; D1 = [C7][C6][0][0][A7][A6][B7][B6]
				and.b	d0,d1						; D1 = [C7][C6][0][0][0][0][0][0]

				or.b	(a4)+,d1					; D1 = ByteC'
				eor.b	d6,d1						; D1 = ByteC
				move.b	d1,(a1)+					; store third byte
				addx.b	d1,d7						; CkSumC'' <- CkSumC' + ByteC + ex
				subq.w	#3,d4						; decrement counter by 3 bytes
				bpl.s	@RdData2 					; loop	(careful->subq changes ex bit)

; then the data portion...

				move.l	#510,d4						; loop counter for data field
				
@RdData3		move.b	(a4)+,d1					; D1 = [00][00][A7][A6][B7][B6][C7][C6]
				rol.b	#2,d1						; D1 = [A7][A6][B7][B6][C7][C6][00][00]
				move.b	d1,d2						;
				and.b	d0,d2						; D2 = [A7][A6][00][00][00][00][00][00]

				or.b	(a4)+,d2					; D2 = ByteA'

				move.b	d7,d3						;
				add.b	d7,d3						; ex <- CkSumC[7]
				rol.b	#1,d7						; CkSumC' <- ROL (CkSumC)

				eor.b	d7,d2						; ByteA <- ByteA' XOR CkSumC'
				move.b	d2,(a0)+					; store first byte
				addx.b	d2,d5						; CkSumA',ex <- CkSumA + ByteA + ex
				rol.b	#2,d1						; D1 = [B7][B6][C7][C6][00][00][A7][A6]
				move.b	d1,d2						;
				and.b	d0,d2						; D2 = [B7][B6][00][00][00][00][00][00]

				or.b	(a4)+,d2					; D2 = ByteB' (no time for bad nibs)
				eor.b	d5,d2						; D2 = ByteB
				move.b	d2,(a0)+					; store second byte
				addx.b	d2,d6						; CkSumB',ex <- CkSumB + ByteB + ex
				tst.w	d4							; check counter
				beq.s	@RdCkSum 					; we are done when counter is 0

				rol.b	#2,d1						; D1 = [C7][C6][0][0][A7][A6][B7][B6]
				and.b	d0,d1						; D1 = [C7][C6][0][0][0][0][0][0]

				or.b	(a4)+,d1					; D1 = ByteC' (no time for bad nibs)
				eor.b	d6,d1						; D1 = ByteC
				move.b	d1,(a0)+					; store third byte
				addx.b	d1,d7						; CkSumC'' <- CkSumC' + ByteC + ex
				subq.w	#3,d4						; decrement counter by 3 bytes
				bra.s	@RdData3 					; loop	(careful->subq changes ex bit)


; now read the four checksum nibbles and compare . . .

@RdCkSum 		move.b	(a4)+,d1					; D1 = [00][00][A7][A6][B7][B6][C7][C6]
				rol.b	#2,d1						; D1 = [A7][A6][B7][B6][C7][C6][00][00]
				move.b	d1,d2						;
				and.b	d0,d2						; D2 = [A7][A6][00][00][00][00][00][00]

				move.b	(a4)+,d3					; D3 = [0][0][A5][A4][A3][A2][A1][A0]
				or.b	d3,d2						; D2 = CkSumA
				cmp.b	d2,d5						; check against calculated value
				bne.s	@CkSumBad					; br if bad
				rol.b	#2,d1						; D1 = [B7][B6][C7][C6][00][00][A7][A6]
				move.b	d1,d2						;
				and.b	d0,d2						; D2 = [B7][B6][00][00][00][00][00][00]

				move.b	(a4)+,d3					; D3 = [0][0][B5][B4][B3][B2][B1][B0]
				or.b	d3,d2						; D2 = CkSumB
				cmp.b	d2,d6						; check against calculated value
				bne.s	@CkSumBad					; br if bad
				rol.b	#2,d1						; D1 = [C7][C6][00][00][A7][A6][B7][B6]
				and.b	d0,d1						; D1 = [C7][C6][00][00][00][00][00][00]

				move.b	(a4),d3						; D3 = [00][00][C5][C4][C3][C2][C1][C0]
				bmi.s	@CkSumBad					; branch if bad nibble
				or.b	d3,d1						; D1 = CkSumC
				cmp.b	d1,d7						; check against calculated value
				beq.s	@done						;

@CkSumBad		moveq	#BadDCkSum,D0				; bad checksum
				bra.s	@exit

@RdVerErr		moveq	#DataVerErr,D0
				bra.s	@exit

@done			moveq	#NoErr,d0
@exit			movem.l	(sp)+,a1/a3/a4/d1-d7		; •• restore registers
				rts





SelfSyncCount	equ		6
MarkCount		equ		9							; 9 mark bytes
SelfSyncTbl
MarkTable		dc.b	$3F,$BF,$1E,$34,$3C,$3F 	; self-sync pattern for SWIM3's converter
				dc.b	$D5,$AA,$0B	 				; data mark for SWIM3's converter

TrailMkCount	equ		8							; 4 trail bytes + 2 end bytes + 2 extras
TrailMarks		dc.b	$27,$AA,$3F,$3F				; bit slip and gap bytes for SWIM3's converter
				dc.b	$3F,$3F
				dc.b	$99,$08						; end of transfer for SWIM3


				ALIGN	4
MFMGapValue 	dc.l	$4E4E4E4E 						; MFM gap is string of 4E's
MFMSyncValue	dc.l	$00000000	 					; MFM sync is string of 00's

MFMMarkSize		equ		8								; # bytes in an MFM mark pattern for SWIM3
MFMIndexMark	dc.b	$99,$C2,$99,$C2,$99,$C2,$99,$FC	; MFM index mark pattern for SWIM3
MFMAddrMark		dc.b	$99,$A1,$99,$A1,$99,$A1,$99,$FE	; MFM address mark pattern for SWIM3
MFMDataMark		dc.b	$99,$A1,$99,$A1,$99,$A1,$99,$FB	; MFM data mark pattern for SWIM3


;_______________________________________________________________________
;
;  Routine: 	jsr 	Nibbleize
;  Inputs:		a0	-	user buffer
;				a1	-	SonyVars
;				a3	-	tag buffer (sector #)
;				NibbilizeDMAPtr	- Ptr into DMA buffer for this sector
;				PhysSector		- sector #
;  Outputs: 	
;  Destroys:	a0,d0
;  Calls:		
;  Called by:	SWIM3Write
;
;  Function:	Nibblizes the tag buffer and destination buffer into the  
;				DMA buffer pointed to by NibbilizeDMAPtr.  
;
;	Uses:
;	D7 = CkSumC 				
;	D6 = CkSumB 				
;	D5 = CkSumA 				
;	D4 = loop counts			A4 = ptr to DMA buffer
;	D3 = A7A6B7B6C7C6 nibble	
;	D2 = C5C4C3C2C1C0 nibble	
;	D1 = B5B4B3B2B1B0 nibble	A1 = ptr to data buffer
;	D0 = A5A4A3A2A1A0 nibble	A0 = ptr to user buffer (to A1 after 12 bytes)
;_______________________________________________________________________

Nibbleize		movem.l	a1/a4/d1-d7,-(sp)			; •• save registers

				movea.l	NibbilizeDMAPtr(a1),a4		; get ptr into DMA buffer
				btst.b	#GCRModeBit,([vSetup,a1])	; are we in GCR mode
				bne.s	@gcr						; yes, guessed correctly
			
		
				move.l	MFMGapValue,d0
				move.l	d0,(a4)+					; copy remaining 10 gap bytes
				move.l	d0,(a4)+
				move.w	d0,(a4)+
				
				move.l	MFMSyncValue,d0
				move.l	d0,(a4)+					; copy 12 sync bytes
				move.l	d0,(a4)+
				move.l	d0,(a4)+
				
			assert	MFMMarkSize=8
				lea		MFMDataMark,a1
				move.l	(a1)+,(a4)+					; copy an MFM data mark
				move.l	(a1)+,(a4)+
				
				move.w	#$990F,(a4)+				; turn off escaping for next 512 bytes
			
				movea.l	a4,a1						; destination in a1
				move.l	#mfmDataSize,d0				; 512 bytes for mfm
			IF FAST_BMOVE THEN
				_MoveBytesNoDCBZ					; •••• move the data, without using the DCBZ instr.
													; •••• which gives us a big win into non-cacheable io space
			ELSE
				_BlockMove
			ENDIF
				adda.w	#mfmDataSize,a4
				
				move.w	#$9904,(a4)+				; write CRC
				
				move.l	MFMGapValue,d1
				move.w	d1,(a4)+					; make sure we flush the CRC
				move.w	d1,(a4)+					; before turning off writing

				move.w	#$9908,(a4)+				; done with transfer
				bra		@done						; and we're done


;------------------------------------
; first we write some self-sync bytes, data marks, and sector number
;------------------------------------

@gcr			moveq	#0,d2						; clear high byte for indexing
				move.b	PhysSector(a1),d2			; get the sector number
				
				lea		MarkTable,a1				; get ptr to our mark buffer
				moveq	#MarkCount-1-1,d0			; # mark bytes (-1 for the last one, which we write separately)
@markLp			move.b	(a1)+,(a4)+					; stuff the mark bytes
				dbra	d0,@markLp

				movea.l	a3,a1						; a1 = tag buffer
				move.l	#$02010009,d4				; adjusted byte write counts for 2 buffers
				moveq	#0,d3						; D3 also: note D0,D1 cleared later

				moveq	#0,d5						; clear the checksum bytes
				moveq	#0,d6						; 
				moveq	#0,d7						; 

				moveq	#$0B,d1 					; last data mark byte not yet encoded ($AD)
				sub.w	d0,d0						; leave D0=0, ex = 0
				bra.s	@WrData2					; and d2 = sector#


@WrDataSw		movea.l	a0,a1						; switch to user buffer

@WrData1 		addx.b	d2,d7						; CSumC'' <- ByteC + CSumC' + ex
				eor.b	d6,d2						; ByteC' <- ByteC XOR CSumB'
				move.b	d2,d3						; D3 = [00][00][00][00][A7][A6][B7][B6]
													;	   [C7][C7][C5][C4][C3][C2][C1][C0]
				lsr.w	#6,d3						; D3 = [00][00][A7][A6][B7][B6][C7][C6]
				move.b	d3,(a4)+ 					; nibblize and write hi-bits out

				subq.w	#3,d4						; got 3 more bytes (wipes out ex bit!)
				move.b	d7,d3						; D3 <- CSumC
				add.b	d7,d3						; ex <- CSumC[7]
				rol.b	#1,d7						; CSumC' <- ROL (CSumC)
				andi.b	#$3F,d0 					; D0 = [00][00][A5][A4][A3][A2][A1][A0]
				move.b	d0,(a4)+ 					; nibblize and write low ByteA out

@WrData2 		move.b	(a1)+,d0					; read next ByteA
				addx.b	d0,d5						; CSumA' <- ByteA + CSumA + ex
				eor.b	d7,d0						; ByteA' <- ByteA XOR CSumC'
				move.b	d0,d3						; D3 = [A7][A6][A5][A4][A3][A2][A1][A0]
				rol.w	#2,d3						;
				andi.b	#$3F,d1 					; D1 = [00][00][B5][B4][B3][B2][B1][B0]
				move.b	d1,(a4)+			 		; nibblize and write low ByteB out

				move.b	(a1)+,d1					; read next ByteB
				addx.b	d1,d6						; CSumB' <- ByteB + CSumB + ex
				eor.b	d5,d1						; ByteB' <- ByteB XOR CSumA'
				move.b	d1,d3						;
				rol.w	#2,d3						;
				andi.b	#$3F,d2 					; D2 = [00][00][C5][C4][C3][C2][C1][C0]
				move.b	d2,(a4)+			 		; nibblize and write low ByteC out
	
				move.b	(a1)+,d2					; read next ByteC
				tst.w	d4							; reached end of buffer?
				bne.s	@WrData1 					;
				swap	d4
				bne.s	@WrDataSw					; br if we are switching to user buffer
	
; the last 2 data bytes are written out separately since they are odd . . .
; the missing third byte is just zero . . .

@WrLast2 		clr.b	d3							; D3 = [00][00][00][00][A7][A6][B7][B6]
													;	   [00][00][00][00][00][00][00][00]
				lsr.w	#6,d3						; D3 = [00][00][A7][A6][B7][B6][00][00]
				move.b	d3,(a4)+ 					; nibblize and write hi-bits out

				move.b	d5,d3						; start preparing 1st cksum byte
				rol.w	#2,d3						;
				move.b	d6,d3						;
				rol.w	#2,d3						;
				andi.b	#$3F,d0 					; D0 = [00][00][A5][A4][A3][A2][A1][A0]
				move.b	d0,(a4)+			 		; write low ByteA out

				andi.b	#$3F,d1 					; D1 = [00][00][B5][B4][B3][B2][B1][B0]
				move.b	d1,(a4)+					; nibblize and write low ByteB out

; now we write out the three checksum bytes as 4 nibbles

@WrCkSum 		move.b	d7,d3						; D3 = [0][0][0][0][A7][A6][B7][B6]
													;	   [C7][C7][C5][C4][C3][C2][C1][C0]
				lsr.w	#6,d3						; D3 = [0][0][A7][A6][B7][B6][C7][C6]
				move.b	d3,(a4)+					; nibblize and write hi-bits out

				andi.b	#$3F,d5 					; zero high 2 bits
				move.b	d5,(a4)+			 		; write CkSumA out

				andi.b	#$3F,d6 					; zero high 2 bits
				move.b	d6,(a4)+			 		; write CkSumB out

				andi.b	#$3F,d7 					; zero high 2 bits
				move.b	d7,(a4)+			 		; write CkSumC out

; now, finally, write the two bit slip marks and FF bytes

				lea		TrailMarks,a0				; get ptr to our bit slip/gap bytes
				moveq	#TrailMkCount-1,d2			;
@WrSlip			move.b	(a0)+,(a4)+
				dbra	d2,@WrSlip
	
@done			move.l	a4,d0						; save DMA ptr
				movem.l	(sp)+,a1/a4/d1-d7			; •• restore regs
				move.l	d0,NibbilizeDMAPtr(a1)		; save updated DMA ptr
				moveq	#0,d0						; no errors possible
				rts
				
				
				


;_______________________________________________________________________
;
;  Routine: 	jsr 	FmtTrack
;  Inputs:		
;  Outputs: 	d0.w 	- error status code
;				ccr.z	- based on result
;  Destroys:	a0,a3,d0,d2-d3
;  Calls:		FmtUnknownTrack, FmtGCRTrack, FmtMFMTrack
;  Called by:	SWIM3CtlFormat
;
;  Function:	Formats a track on the current drive.
;_______________________________________________________________________

FmtTrack		move.l	vFmtTrack(a1),-(sp)			; push vector
				rts									; call routine
				
jFmtTrack 		move.l	(sp)+,AsyncPc(a1)			; •• save Pc

				moveq	#0,d2
				move.b 	DiskFormat(a1,d1.w),d2		; see what format to write
				move.b 	(RequiredMedia,d2.w),d0		; see what media is required
				cmp.b 	MediaKind(a1,d1.w),d0 		; see if we have correct media
				bne.s 	@FmtUnknownTrack			; if wrong kind of media
				
				lea		@FmtTrackDecode,a0
				adda.w	(a0,d2.w*2),a0
				jmp 	(a0)						; dispatch to the routine


@FmtUnknownTrack 
				moveq 	#paramErr,d0				; unsupported format, return with error
@FmtTrackDone	move.l 	AsyncPc(a1),-(sp)			; •• restore Pc
				tst.w	d0
				rts 								; all done


@FmtTrackDecode	dc.w	@FmtUnknownTrack-@FmtTrackDecode 	;  0 - uncheckedFormat
				dc.w	@FmtUnknownTrack-@FmtTrackDecode	;  1 - unknownFormat
				dc.w	@FmtUnknownTrack-@FmtTrackDecode	;  2 - HD20Format
				dc.w	@FmtGCRTrack 	-@FmtTrackDecode	;  3 - GCR400Kformat
				dc.w	@FmtGCRTrack 	-@FmtTrackDecode	;  4 - GCR800Kformat
				dc.w	@FmtMFMTrack 	-@FmtTrackDecode	;  5 - MFM720Kformat
				dc.w	@FmtMFMTrack 	-@FmtTrackDecode	;  6 - MFM1440Kformat
				dc.w	@FmtUnknownTrack-@FmtTrackDecode 	;  7 - GCRonHDformat
				dc.w	@FmtUnknownTrack-@FmtTrackDecode 	;  8 - reserved for future use
				dc.w	@FmtUnknownTrack-@FmtTrackDecode 	;  9 - reserved for future use
				dc.w	@FmtUnknownTrack-@FmtTrackDecode 	; 10 - reserved for future use



				
;============================================================
@FmtGCRTrack	move.l	a4,-(sp)					; • save a4
				movea.l	TrackCachePtr(a1),a4		; get ptr to start of DMA buffer
				move.w	#GCRInitialSyncCount,d0
				bsr		@CopySyncGroups				; first copy 200 sync groups at start of track
				
@GCRsectorLoop	moveq	#0,d0
				move.b	SectorGapSize(a1),d0		; get our current # of intersector sync groups
				bsr		@CopySyncGroups				; copy inter-sector sync groups
				
				bsr		@CopyAddrHeader				; copy an address mark+header
				
				movea.l	UserTagsPtr(a1),a3			; get sector tags ptr
				move.l	UserBufPtr(a1),d0			; get sector buffer ptr
				bne.s	@copyGCRSector				; copying, branch
				
;------------------------------------
;	Clear a GCR sector...
;------------------------------------

				move.w	#1,d0						; 
				bsr		@CopySyncGroups				; copy 1 sync group before data mark
				move.w	#$D5AA,(a4)+				; copy 1st 2 bytes of data mark
				move.b	#$0B,(a4)+					; and the 3rd byte
				moveq	#0,d0
				move.b	PhysSector(a1),d0	 		; get sector index
				move.b	(SectorMap,a1,d0.w),(a4)+	; stuff sector number before data block
				move.w	#gcrDataSize-1,d0			; we're formatting, # of nibbles in a GCR sector
@fillGCRLoop	clr.b	(a4)+						; clear next byte of sector
				dbra	d0,@fillGCRLoop
				move.w	#$27AA,(a4)+				; stuff 2 bit-slip bytes
				move.b	#$3F,(a4)+					; and a gap byte
				bra.s	@nextGCRSect

;------------------------------------
;	Copy a GCR sector (disk duplicator)			
;------------------------------------

@copyGCRSector	move.l	a4,NibbilizeDMAPtr(a1)		; set the DMA ptr for Nibbleize
				movea.l	d0,a0						; a0 = ptr to user buffer,
				moveq	#0,d0
				move.b	PhysSector(a1),d0	 		; get sector index
				move.b	(SectorMap,a1,d0.w),d0		; get logical sector
				move.w	d0,d2						; keep a copy
				add.w	d0,d0
				lsl.w	#8,d0						; * 512 to get offset
				adda.w	d0,a0						; calc offset into user buffer
				mulu.w	#TagSize,d2					; * 12 to get tag offset
				adda.w	d2,a3						; calc offset into tag buffer
				bsr		Nibbleize					; copy data mark+data (d0=0)
				movea.l	NibbilizeDMAPtr(a1),a4		; update our DMA ptr reg
				subq.l	#3,a4						; back up before the 99 08 and one of the gaps that Nibbilize added		
				
@nextGCRSect	addq.b	#1,PhysSector(a1)			; bump sector #
				move.b	PhysSector(a1),d0
				cmp.b	PhysSectsPerHead(a1),d0		; done with track?
				blt.s	@GCRsectorLoop				; yes, done
	
				clr.b	PhysSector(a1)				; reset sector # for next head (if any)
				move.l	#$3F3F3F3F,(a4)+			; move some gap bytes at the end of the track
				move.w	#$9908,(a4)+				; add our 'end of data' chars for SWIM3
				movea.l	(sp)+,a4					; • restore a4
			
			
;------------------------------------
; now setup the DMA transfer
;------------------------------------

				moveq	#0,d0
				move.b 	PhysHead(a1),d0				; get the desired head number
				lea		GCRFmtSelDecode,a0
				move.b 	(a0,d0.w),d0				; get the head select command
				bsr 	AddrAndSense 				; select the disk head (and address that reads back a '1')
				
				move.l	TrackCacheDMAPtr(a1),a0		; reset to start of DMA buffer
				move.l	#$80008000,d0				; setup to some big count
													; bit 31 = 1 for write
				bsr		SetUpDMAXFer				; get DMA controller ready to go
			
				tst.b 	([vError,a1])				; read and clear any pending errors
				move.b 	#StartAction,([vZeroes,a1])	; clear action
				nop
				move.b 	#FormatMode,([vOnes,a1])	; set format mode
				nop

				move.l	#TrackTimeout,d2			; 500 ms timeout looking for index and writing track
				move.l	#(StartAction<<16)+\
							doneIntNum,d0			; we want the 'done' interrupt
				bsr		WaitForInterrupt			; and wait for it
				
				bsr		StopDMA							; stop the floppy DMA channel
				
				move.b 	#StartAction,([vZeroes,a1])	; clear GO first,
				nop
				move.b 	#FormatMode,([vZeroes,a1])	; then Format (SWIM3 requirement)
				nop

;------------------------------------
;	Now measure the gap from the end 
;	of last sector to sector header 0
;------------------------------------

				_GetMicroSeconds					; get time at end of last sector we wrote
				move.l	d0,d3						; save it
				
				bsr		ReadSectorHdr				; read next sector address
				bne.s	@fmtGCRDone					; error, exit immediately				

				tst.b	SectHdrSector(a1)			; was next sector# found 0? (should be)
				beq.s	@chkMoreSync				; yes, see if we have room for more sync between sectors

;------------------------------------
;	Gap was too short... overwrote sector 0 header
;------------------------------------
				moveq	#fmt1err,d0					; assume "can't find sector 0 after format"
@decSync		move.b	SectorGapSize(a1),d2
				subq.b	#1,d2						; use 1 less sync pattern between sectors
				cmpi.b	#GCRMinSyncCount,d2			; are we at minimum # of sync patterns?
				blt.s	@fmtGCRDone					; yes, exit with error
				move.b	d2,SectorGapSize(a1)		; no, update gap size
				bra		@FmtGCRTrack				; and try again
	
@chkMoreSync	_GetMicroSeconds					; get time at end of sector 0 header
				sub.l	d3,d0						; compute delta from end of track to start of track
				lsr.l	#4,d0						; / 16 to compute delta in terms of # of GCR nibbles
				subi.l	#10,d0						; subtract off header bytes
				divu.w	#5,d0						; compute # of sync groups at end	
				sub.b 	SectorGapSize(a1),d0		; subtract num of syncs we were using
				bgt.s 	@useMore					; branch if gap a little long
				moveq	#fmt2Err,d0					; gap too short, assume "can't get enough sync"
				bra.s	@decSync					; and try again with less sync

;------------------------------------
;	Gap was a little long...
;------------------------------------

@useMore		move.w	d0,d3
				moveq 	#noErr,d0					; enough sync, format will succeed
				lsr.l 	#1,d3						; divide excess sync groups by 2
				cmp.b 	PhysSectsPerHead(a1),d3		; see if SectorGapSize could inc by 1
				blt.s 	@fmtGCRDone					; exit if gap sync still reasonable
				addq.b	#1,SectorGapSize(a1)		; use more sync next time

@fmtGCRDone		tst.l	UserBufPtr(a1)				; are we doing a fmt/copy?
				beq		@FmtTrackDone				; no, we're done

				moveq	#0,d2						; yes, need to update user ptrs
				move.b	PhysSectsPerHead(a1),d2		; get # sectors we stuffed
				move.l	d2,d3						; keep a copy
				add.w	d2,d2
				lsl.w	#8,d2						; * 512 to get offset
				add.l	d2,UserBufPtr(a1)			; update our buffer ptr
				mulu.w	#TagSize,d3
				add.l	d3,UserTagsPtr(a1)			; update user tags ptr
				bra		@FmtTrackDone				; done with track, exit


;------------------------------------------------------------------------
;	This subroutine copies D0 self sync groups to the DMA buffer.
;------------------------------------------------------------------------

@CopySyncStart	lea		SelfSyncTbl,a0				; get ptr to our self-sync buffer
				move.l	(a0)+,(a4)+					; copy first 4 bytes
				move.w	(a0)+,(a4)+					; copy next 2 bytes
@CopySyncGroups	dbra	d0,@CopySyncStart			; write requested number of sync groups
				rts
	
	
;------------------------------------------------------------------------
;	This subroutine copies an address header to the DMA buffer.
;------------------------------------------------------------------------

@CopyAddrHeader	move.w	#$D5AA,(a4)+				; copy 1st 2 bytes of address mark
				clr.b	(a4)+						; and the 3rd byte
				moveq	#0,d2						; init the checksum

				moveq	#0,d0
				move.b	PhysCylinder(a1),d3			; get track
				move.b	d3,d0
				andi.b	#%00111111,d0				; keep low 6 bits
				eor.b	d0,d2						; add into checksum
				move.b	d0,(a4)+					; stuff the track[0..5]
	
				move.b	PhysSector(a1),d0	 		; get sector index
				move.b	(SectorMap,a1,d0.w),d0		; get the sector number
				eor.b	d0,d2						; add into checksum
				move.b	d0,(a4)+					; stuff sector #
				
				lsr.b	#6,d3						; get bits 6,7 of track (8-10 are 0)
				tst.b	PhysHead(a1)				; which head?
				beq.s	@setHead					; 0, we're set
				bset.l	#5,d3
@setHead		eor.b	d3,d2
				move.b	d3,(a4)+					; stuff head/track
				
				move.b	FmtByteBlkSize(a1),d0		; get format byte
				andi.b	#$20,d0						; keep just the sides bit
				or.b	Interleave(a1),d0			; or in the interleave
				eor.b	d0,d2
				move.b	d0,(a4)+					; stuff the format byte
				move.b	d2,(a4)+					; stuff the checksum
				
				move.w	#$27AA,(a4)+				; stuff the 2 bit-slip bytes
				move.b	#$3F,(a4)+					; and a gap byte
				rts
	


;============================================================

@FmtMFMTrack	move.l	a4,-(sp)					; •• save a4
				movea.l	TrackCachePtr(a1),a4		; get ptr to start of DMA buffer
				
				move.w	#MFMInitialGapSize,d0
				move.l	MFMGapValue,d2				; get our gap value
				bsr		@CopyMFMBytes				; first copy 80 gap bytes before index
				
				moveq	#MFMSyncSize,d0
				move.l	MFMSyncValue,d2				; get our sync value
				bsr		@CopyMFMBytes				; copy 12 sync bytes after gap
				
			assert	MFMMarkSize=8
				lea		MFMIndexMark,a0				; copy an MFM index mark
				move.l	(a0)+,(a4)+
				move.l	(a0)+,(a4)+
				
				moveq	#MFMIndexMarkGapSize,d0
				move.l	MFMGapValue,d2				; get our gap value
				bsr		@CopyMFMBytes				; copy 50 gap bytes at after index pulse
				
@MFMsectorLoop	moveq	#MFMSyncSize,d0
				move.l	MFMSyncValue,d2				; get our sync value
				bsr		@CopyMFMBytes				; copy 12 sync bytes after gap

			assert	MFMMarkSize=8
				lea		MFMAddrMark,a0				; copy an MFM address mark
				move.l	(a0)+,(a4)+
				move.l	(a0)+,(a4)+
				
				bsr		@CopyMFMHeader				; copy address header
				
				move.l	UserBufPtr(a1),d0			; get sector buffer ptr
				bne.s	@copyMFMSector				; copying, branch
				
;------------------------------------
;	Clear an MFM sector...
;------------------------------------

				moveq	#MFMAddrMarkGapSize,d0
				move.l	MFMGapValue,d2				; get our gap value
				bsr		@CopyMFMBytes				; copy 22 gap bytes at after address mark
				
				moveq	#MFMSyncSize,d0
				move.l	MFMSyncValue,d2				; get our sync value
				bsr		@CopyMFMBytes				; copy 12 sync bytes after gap
				
			assert	MFMMarkSize=8
				lea		MFMDataMark,a0				; copy an MFM data mark
				move.l	(a0)+,(a4)+
				move.l	(a0)+,(a4)+
				move.w	#$990F,(a4)+				; turn off escaping for next 512 bytes
				
				moveq	#(mfmDataSize/4)-1,d0		; # of bytes / MFM sector
@fillMFMData	move.l	#$F6F6F6F6,(a4)+			; fill the sector with this pattern
				dbra	d0,@fillMFMData
			
				move.w	#$9904,(a4)+				; write the CRC bytes

				bra.s	@nextMFMSect

;------------------------------------
;	Copy an MFM sector (disk duplicator)			
;------------------------------------

@copyMFMSector	moveq	#12,d0
				move.l	MFMGapValue,d2				; get our pre-gap value of 12 bytes
				bsr		@CopyMFMBytes				; copy 12 of 22 gap bytes after address mark
				
				move.l	a4,NibbilizeDMAPtr(a1)		; set the DMA ptr for Nibbleize
				movea.l	UserBufPtr(a1),a0			; a0 = ptr to user buffer
				moveq	#0,d0
				move.b	PhysSector(a1),d0	 		; get sector index
				move.b	(SectorMap,a1,d0.w),d0		; get logical sector
				add.w	d0,d0
				lsl.w	#8,d0						; * 512 to get offset
				adda.w	d0,a0						; calc offset into user buffer
				bsr		Nibbleize					; copy data mark+data (d0=0)
				movea.l	NibbilizeDMAPtr(a1),a4		; update our DMA ptr reg
				subq.l	#2,a4						; back up before the 99 08 that Nibbilize added		

;------------------------------------
;	Now fill in the gap between sectors, and repeat if more remaining
;------------------------------------

@nextMFMSect	moveq	#0,d0
				move.b	SectorGapSize(a1),d0		; get intra-sector gap size for MFM
				move.l	MFMGapValue,d2				; get our gap value
				bsr		@CopyMFMBytes				; copy 80/101 gap bytes at after each sector
				
				addq.b	#1,PhysSector(a1)			; bump sector #
				move.b	PhysSector(a1),d0
				cmp.b	PhysSectsPerHead(a1),d0		; done with track?
				blt		@MFMsectorLoop				; yes, done
	

				moveq	#MFMFinalGapSize,d0			; get final gap size for MFM
				tst.b	PhysHead(a1)
				beq.s	@1							; use small gap if head 0 (so we'll overlap on head 1)
				add.l	d0,d0						; use more on head 1
@1				move.l	MFMGapValue,d2				; get our gap value
				bsr		@CopyMFMBytes				; copy 102/204 gap bytes at end of track
				
				move.w	#$9908,(a4)+				; add our 'end of data' chars for SWIM3

				movea.l	(sp)+,a4					; •• restore a4
				clr.b	PhysSector(a1)				; reset sector # for next head (if any)

;------------------------------------
;	Setup and start the DMA
;------------------------------------
				moveq	#MFMFmtRetryCnt-1,d3		; allow 3 retries/track-side

@mfmRetry		moveq	#0,d0
				move.b 	PhysHead(a1),d0				; get the desired head number
				lea		HeadSelectDecode,a0
				move.b 	(a0,d0.w),d0				; get the head select command
				bsr 	AddrAndSense 				; select the disk head
				
				move.l	TrackCacheDMAPtr(a1),a0		; reset to start of DMA buffer
				move.l	#$80008000,d0				; setup to some big count
													; bit 31 = 1 for write
				bsr		SetUpDMAXFer				; get DMA controller ready to go
			
				tst.b 	([vError,a1])				; read and clear any pending errors
				move.b 	#StartAction,([vZeroes,a1])	; clear action
				nop
				move.b 	#FormatMode,([vOnes,a1])	; set format mode
				nop

				move.l	#FmtTrackTime,d2			; 600 ms timeout looking for index and writing track
				move.l	#(StartAction<<16)+\
							doneIntNum,d0			; we want the 'done' interrupt
				bsr		WaitForInterrupt			; and wait for it...
				
				bsr		StopDMA						; stop the floppy DMA channel
				move.b 	#StartAction,([vZeroes,a1])	; clear action first,
				nop
				move.b 	#FormatMode,([vZeroes,a1])	; then format mode
		
				tst.w	d0							; any errors?
				dbeq	d3,@mfmRetry				; yes, count, then retry the track
				bne.s	@FmtTrackDone				; too many errors, exit
		
				tst.l	UserBufPtr(a1)				; are we doing a fmt/copy?
				beq		@FmtTrackDone				; no, we're done

				moveq	#0,d2						; yes, need to update user ptrs
				move.b	PhysSectsPerHead(a1),d2		; get # sectors we stuffed
				add.w	d2,d2
				lsl.w	#8,d2						; * 512 to get offset
				add.l	d2,UserBufPtr(a1)			; update our buffer ptr
				bra		@FmtTrackDone				; done with track, exit
				
			
				
;------------------------------------------------------------------------
;	This subroutine copies D0.L gap or sync bytes to the DMA buffer.
;------------------------------------------------------------------------
@CopyMFMBytes	ror.l	#2,d0						; / 4, remainder in high byte
				bra.s	@Cnt4
@copyLongLp		move.l	d2,(a4)+					; copy 4 bytes at a time
@Cnt4			dbra	d0,@copyLongLp

				addq.w	#1,d0						; d0.w = 0
				rol.l	#2,d0						; d0.w = bytes remaining (0-3)
				bra.s	@Cnt1

@copyByteLp		move.b	d2,(a4)+					; copy a byte at a time
@Cnt1			dbra	d0,@copyByteLp
				rts

;------------------------------------------------------------------------
;	This subroutine copies the address header to the DMA buffer.
;------------------------------------------------------------------------
@CopyMFMHeader	move.b	PhysCylinder(a1),(a4)+		; copy track

				moveq	#0,d0						; assume side 0
				tst.b	PhysHead(a1)				; which head?
				beq.s	@setMFMHead					; 0, we're set
				addq.b	#1,d0
@setMFMHead		move.b	d0,(a4)+					; copy head

				move.b	PhysSector(a1),d0 			; get physical sector
				move.b	(SectorMap,a1,d0.w),d0
				addq.b	#1,d0						; adjust for MFM numbering
				move.b	d0,(a4)+					; copy the logical sector number
				
				move.b	FmtByteBlkSize(a1),d0		; get format byte
				andi.b	#$1F,d0						; keep just the block size
				move.b	d0,(a4)+					; stuff the block size byte
				
				move.w	#$9904,(a4)+				; write the CRC bytes
				rts
	



;_______________________________________________________________________
;
;  Routine: 	jsr 	TurnOnDrive
;  Inputs:		a1				-	driver globals
;				ReqDriveNumber	-	Drive Number
;  Outputs: 	d0				-	error status code
;				d1,CurrentDrive - Drive number, (only when noErr)
;  Destroys:	none
;  Calls:		SelectDrive, AddrAndSense, TurnOffDrive, CheckDriveMode, AddrAndStrb
;				CancelTMPBtimer, StartReadyTimer
;  Called by:	SetUpDrive, ReCalibrate 
;
;  Function:	Selects and Powers up the specified drive, returns error
;				status if no disk in drive.
;				The caller must call WaitDriveReady to wait for the drive
;				to attain proper motor speed.
;_______________________________________________________________________

TurnOnDrive		move.l	vTurnOnDrive(a1),-(sp)		; push vector
				rts									; call routine
				
jTurnOnDrive 	move.w	ReqDriveNumber(a1),d0		; see what drive is requested
				move.b 	PhysDriveNumber(a1,d0.w),d0	; get the new physical drive number
				bsr 	SelectDrive					; select and enable the new drive
				move.b 	#rNoDiskInPlAdr,d0			; prepare to see if there is a disk
				bsr 	AddrAndSense 				; read the drive status bit
				beq.s 	@HasMedia					; turn drive on, if there is a disk in the drive
				bsr.s	TurnOffDrive				; turn off and disable the drive if no diskette
				moveq 	#OffLinErr,d0				; indicate that the disk was off line
				rts 								; all done

@HasMedia		move.w 	ReqDriveNumber(a1),\
							CurrentDrive(a1)		; mark new drive as powered
				move.b 	#MotorTimeoutCount,\
							MotorTimingOut(a1)		; start timing out motor when polling resumes

				move.b 	#rMotorOffAdr,d0			; prepare to test the drive motor status
				bsr 	AddrAndSense 				; see if it is off
				beq.s 	@AlreadyOn					; if already on

;------------------------------------
;	we must setup the drive mode every time the drive is turned on, because
;	it forgets what mode it was in when it gets turned off.
;------------------------------------
	
				bsr 	CheckDriveMode				; see if mode needs to change
				beq.s 	@TurnItOn					; no change needed, just turn on motor
				bsr 	AddrAndStrb					; otherwise, set the drive mode first

@TurnItOn		moveq 	#wMotorOnAdr,d0				; prepare to turn the drive motor on
				bsr 	AddrAndStrb					; turn it on

				lea 	ReadyTMPB+TimeMgrOffset(a1),a0	; get the ready timer block
				bsr 	CancelTMPBtimer 			; cancel the timer in case it was running
				moveq	#MotorOnDelay,d0			; get Disk Motor On wait time
				bsr 	StartTMPBTimer	 			; start the timer

				move.l	#MotorOnSettle,SettleTime(a1)	; set Motor speed settle time
	
@AlreadyOn		move.w 	CurrentDrive(a1),d1			; return current drive number
				moveq 	#noErr,d0					; return successful status
				rts 								; all done


		
;_______________________________________________________________________
;
;  Routine: 	jsr 	TurnOffDrive
;  Inputs:		a1	- 	ptr to globals
;  Outputs: 	none
;  Destroys:	??
;  Calls:		AddrAndStrb, CancelTMPBtimer
;  Called by:	SWIMInitialize, PollingTask, SWIMEject, SetUpDrive, TurnOnDrive,
;				WaitDriveReady, ReCalibrate
;
;  Function:	Immediatly turns off the motor and disables the drive
;				that was currently enabled.
;_______________________________________________________________________

TurnOffDrive	move.l	vTurnOffDrive(a1),-(sp)		; push vector
				rts									; call routine
				
jTurnOffDrive	clr.w 	CurrentDrive(a1)			; indicate that no drive is powered
				clr.b 	MotorTimingOut(a1)			; indicate timeout expired
				move.b 	#wMotorOffAdr,d0			; motor off drive command
				bsr 	AddrAndStrb					; send the command to the drive
				move.b 	#StartAction\
						+WriteMode,([vZeroes,a1])	; clear action and write mode (prepare for motoroff)
				nop
				move.b 	#Drive1Enabled+Drive2Enabled\
						,([vZeroes,a1])				; disable the drive
				clr.l 	SettleTime(a1) 				; ignore any pending settle time
				lea 	ReadyTMPB+TimeMgrOffset(a1),a0	; get the ready timer block
				jmp 	CancelTMPBtimer				; cancel the timer and return
				


;_______________________________________________________________________
;
;  Routine: 	jsr 	WaitDriveReady
;  Inputs:		a1			- ptr to globals
;  Outputs: 	d0,ccr.z	 - error status code
;  Destroys:	a0,d2
;  Calls:		WaitTMPBdone, AddrAndSense, CancelTMPBTimer, StartTMPBTimer,
;				StartReadyTimer, WaitTMPBdone,TurnOffDrive
;  Called by:	SWIM3CtlEject, SWIM3Read, SWIM3Write, SWIM3CtlFormat,
;				SWIM3CtlVerify, SWIM3CtlGetRawData, PrefetchIntoCache, ReCalibrate,
;				SeekTrack
;
;  Function:	Polls the currently selected drive, waiting for it to become
;				ready. If it doesn't happen within 1 second, it will be turned
;				off, and an error status will be returned.
;_______________________________________________________________________

WaitDriveReady	move.l	vWaitDriveReady(a1),-(sp)	; push vector
				rts									; call routine
				
jWaitDriveReady	move.l	(sp)+,d2					; •• pop pc
				lea 	ReadyTMPB+TimeMgrOffset(a1),a0	; get the ready timer block
				bsr 	WaitTMPBdone				; wait for initial delay to time out

				move.w	#ReadyTimeoutCount,\
							WaitReadyCount(a1)		; initialize max polls counter

@WaitReadyLoop	moveq 	#rNotReadyAdr,d0			; prepare to test ready
				bsr 	AddrAndSense 				; test drive ready
				bne.s 	@NotReady					; if not ready, sleep and try again

				tst.l	SettleTime(a1)				; get Motor speed settle time
				bne.s 	@StartSettleTimer			; start timer if needed
			
				move.w	WaitReadyCount(a1),d0
				eori.w	#ReadyTimeoutCount,d0		; were we already ready?
				beq.s	@readyExit					; yes, don't need the extra 10ms delay
				
				lea 	SettledTMPB+TimeMgrOffset(a1),a0 ; get the settled timer
				bsr 	CancelTMPBTimer				; cancel any old timeout
				moveq	#ReadyDelay,d0				; get extra ready delay needed for WolfPack drives
				bsr 	StartTMPBTimer				; start the timer
				bsr 	WaitTMPBdone				; wait for it to time out
				moveq 	#noErr,d0					; return No Error status if drive is ready
				bra.s	@readyExit					; return with sucess

@StartSettleTimer
				lea 	SettledTMPB+TimeMgrOffset(a1),a0 ; get the settled timer
				bsr 	CancelTMPBTimer				; cancel any old timeout
				move.l	SettleTime(a1),d0			; get Motor speed settle time
@strtTimer		bsr 	StartTMPBTimer				; start the timer
				moveq	#0,d0 						; return No Error status if drive is ready
				move.l	d0,SettleTime(a1)			; remember that timer was started
				bra.s	@readyExit 					; return with success

@NotReady		move.l	#ReadyPollRate,d0			; get poll rate
				bsr.s	StartReadyTimer				; start the timer
				lea 	ReadyTMPB+TimeMgrOffset(a1),a0	; get the ready timer block
				bsr 	WaitTMPBdone				; wait for it to time out

				subq.w	#1,WaitReadyCount(a1)		; count the poll
				bne.s	@WaitReadyLoop				; count not exhausted, check drive ready

				bsr 	TurnOffDrive				; timed out, turn off the drive
				move.w 	#spdAdjErr,d0				; timed out, indicate error

@readyExit		move.l	d2,-(sp)					; •• restore pc
				tst.w	d0
				rts 								; return with error code
				

;_______________________________________________________________________
;
;  Routine: 	jsr 	WaitMotorSettled
;  Inputs:		none
;  Outputs: 	none
;  Destroys:	a0
;  Calls:		WaitTMPBdone
;  Called by:	SWIMWrite, SWIM3CtlFormat
;
;  Function:	Waits for the MotorSettled timer to expire indicating that
;				the drive motor speed is within 1.5% of tolerance.
;				WaitDriveReady should have already been called to ensure that
;				the motor was up to speed, and this extra wait is only needed
;				during Format and Writes where it is desireable to keep motor
;				speed variation to a minimum to improve data reliability.
;_______________________________________________________________________

WaitMotorSettled  
				lea 	SettledTMPB+TimeMgrOffset(a1),a0 	; get the settled timer
				jmp 	WaitTMPBdone						; wait for settle time to expire
				


;_______________________________________________________________________
;
;  Routine: 	jsr 	StartReadyTimer
;  Inputs:		d0.l	- timer count (+ for ms, - for µs)
;				a1		- ptr to globals
;  Outputs: 	none
;  Destroys:	d0
;  Calls:		StartTMPBTimer
;  Called by:	SetUpDrive, TurnOnDrive, WaitDriveReady, Sleep,
;				ReCalibrate, SeekTrack, ReadMFMData, WriteDataBuffer
;
;  Function:	Starts the Ready wait timer using the supplied values.
;_______________________________________________________________________

StartReadyTimer	move.l	vStartReadyTimer(a1),-(sp)		; push vector
				rts										; call routine
				
jStartReadyTimer 
				lea 	ReadyTMPB+TimeMgrOffset(a1),a0	; get the ready timer block
				jmp 	StartTMPBTimer					; start the timer, and return



;_______________________________________________________________________
;
;  Routine: 	jsr 	Sleep
;  Inputs:		d0.l - sleep count, (+ for ms, - for µs)
;  Outputs: 	none
;  Destroys:	d0
;  Calls:		StartReadyTimer, WaitTMPBdone
;  Called by:	SWIM3CtlEject
;
;  Function:	Sleeps for the specified amount of time.
;_______________________________________________________________________

Sleep			jsr 	StartReadyTimer				; start the timer
				jmp 	WaitTMPBdone				; return after it times out
				


;_______________________________________________________________________
;
;  Routine: 	jsr 	ReCalibrate
;  Inputs:		CurrentDrive - active drive number
;				a1		- ptr to globals
;  Outputs: 	d0	 - error status code
;				ccr.n,z - based on value returned in d0
;				SeekingCylinder - 0 (cylinder number that we are seeking)
;  Destroys:	d0-d2,a0
;  Calls:		InitSWIMChip, TurnOnDrive, CheckDriveMode, AddrAndStrb, WaitTMPBdone,
;				StartReadyTimer, WaitDriveReady, SeekTrack, AddrAndSense, TurnOffDrive
;  Called by:	SWIM3CtlEject, SWIM3Read, SWIM3Write, SWIM3CtlFormat, SetUpDrive
;
;  Function:	Re-initializes the disk controller chip, and moves the disk
;				heads back to cylinder zero, reporting any errors that may
;				occur.	This will attempt to get all of the hardware into a
;				known state, when first powering up, or when recovering from
;				an error.
;_______________________________________________________________________

ReCalibrate		move.l	vReCalibrate(a1),-(sp)		; push vector
				rts									; call routine
				
jReCalibrate 	move.l 	(sp)+,ReCalPc(a1)			; •• save pc
				
				move.w 	CurrentDrive(a1),d1			; get current drive number
				clr.b 	CurrentCylinder(a1,d1.w)	; indicate current Cylinder is zero
				clr.b 	SeekingCylinder(a1)			; indicate which cylinder we are seeking
				bsr 	InitSWIMChip				; Re-Initialize the disk controller chip
				bne.s 	@ReCalErrA					; return with error status if couldn't init
				bsr 	TurnOnDrive 				; re-select and power the drive
				bne.s 	@ReCalErrA					; return with error status if couldn't turn on

				bsr 	CheckDriveMode				; see if mode needs to change
				beq.s 	@ReCalStart					; if mode is OK, don't change is
				bsr 	AddrAndStrb					; change the drive mode

				lea 	ReadyTMPB+TimeMgrOffset(a1),a0	; get the ready timer block
				bsr 	WaitTMPBdone				; wait for any initial delay to time out

;------------------------------------
;		when switching modes with the motor running, (which will cause a motor speed
;		change), Ready is not immediatly correct, so we must delay before checking ready,
;		otherwise it will appear that the drive is Ready, even though the motor is not
;		up to speed.  We will delay as if the motor was just turned on.
;------------------------------------
			
				moveq 	#MotorOnDelay,d0			; get low byte of Disk Motor On wait time
				bsr.s	StartReadyTimer				; start the timer

				move.l 	#MotorOnSettle,SettleTime(a1)	; set the settle time
				
@ReCalStart		bsr 	WaitDriveReady				; wait for the motor to be ready
				bne.s 	@ReCalErrA					; return error if motor not ready

				clr.b 	CylinderValid(a1,d1.w)		; indicate current Cylinder is valid
				move.b 	#LastCylinder,CurrentCylinder(a1,d1.w)	; make beleive that we are at end of disk
				moveq 	#0,d0						; we want to go to cylinder zero
				bsr.s	SeekTrack					; seek to zero
				bsr 	WaitDriveReady				; wait for the heads to move
				bne.s 	@ReCalErrA					; return error if couldn't seek

				moveq 	#rNotTrack0Adr,d0			; see if we found cylinder zero
				bsr 	AddrAndSense 				; test the flag
				beq.s 	@ReCalNoErr					; return success if cylinder zero was found

				moveq 	#tk0BadErr,d0				; setup error code, just in case
				bra.s	@ReCalErrA
				
@ReCalNoErr		moveq	#0,d0 						; indicate no error
@ReCalErrA		move.b 	d0,CylinderValid(a1,d1.w)	; indicate current Cylinder is zero (if no err)
				move.b 	d0,CurrentCylinder(a1,d1.w)	; indicate current Cylinder is zero (if no err)
				beq.s	@ReCalDone					; no error, restore pc and return
				clr.b 	DiskFormat(a1,d1.w)			; indicate un-checked format kind
				move.l	d0,-(sp)	 				; preserve error code
				bsr 	TurnOffDrive				; couldn't re-cal, turn off the drive
				move.l	(sp)+,d0					; restore error code

@ReCalDone		move.l 	ReCalPc(a1),-(sp)			; •• restore pc
				tst.w	d0			 				; test error code, set flags
				rts 								; all done
				



;_______________________________________________________________________
;
;  Routine: 	jsr 	SeekTrack
;  Inputs:		CurrentDrive - active drive number
;				d0 	- Desired cylinder number
;				a1	- ptr to globals
;  Outputs: 	d0 	- error status code
;				ccr	- based on error code in d0
;				SeekingCylinder - cylinder number that we are seeking
;				CurSectsPerHead	- Zero, to indicate unknown
;  Destroys:	d0-d2
;  Calls:		AddrAndStrb, AddrAndSense, WaitTMPBdone, StartReadyTimer, LoadSWIMparams
;  Called by:	SWIM3CtlEject, SWIM3Read, SWIM3Write, SWIM3CtlFormat,
;				SWIM3FmtVerify, SWIM3CtlGetRawData, ReCalibrate
;
;  Function:	Sends the Steps Pulses to position the disk heads to the
;				desired cylinder.  WaitDriveReady must be called to wait
;				for the heads to actually move, and settle.
;_______________________________________________________________________

SeekTrack		move.l	vSeekTrack(a1),-(sp)		; push vector
				rts									; call routine
				
jSeekTrack		move.l	(sp)+,SeekPc(a1)			; •• pop pc
				clr.b	CurSectsPerHead(a1)			; new track, don't prefetch unless ReadSectorHdr called
				move.b 	d0,SeekingCylinder(a1)		; indicate which cylinder we are seeking
				move.b	d0,d2						; cylinder in d2
				moveq 	#ParamErr,d0				; assume cylinder too high
				cmpi.b 	#LastCylinder+1,d2			; check for out of range
				bge.s 	@SeekDone					; if out of range, return with error

				move.w 	CurrentDrive(a1),d1			; get the active drive number
				move.b 	CylinderValid(a1,d1.w),d0	; see if cylinder is valid
				bne.s 	@SeekDone					; if invalid, return with error


				move.b	CurrentCylinder(a1,d1.w),d0	; get current cylinder
				move.b	d2,CurrentCylinder(a1,d1.w)	; update current cylinder (to desired)
				sub.b	d2,d0						; compare to desired track
				beq.s	@SeekDone					; exit if no seek needed
				move.b	d0,d2						; # steps in d2
				bmi.s	@stepIn						; step in
	
				moveq 	#wDirPrevAdr,d0				; step out (towards 0)
				bsr 	AddrAndStrb	 				; 
				bra.s	@seek
				
@stepIn			neg.b	d2							; step in
				moveq 	#wDirNextAdr,d0				; step in (away from 0)
				bsr 	AddrAndStrb	 				; 
				
@seek			moveq 	#wStepOnAdr,d0				; put step command on phase lines
				bsr 	AddrAndSense	 			; 
				
				move.b	d2,([vStep,a1])				; setup the step count		
				tst.b 	([vError,a1])				; read and clear any pending errors

				move.l	#StepTimeout,d2				; 11 ms timeout waiting for step pulses to be sent
				move.l	#(GoStep<<16)+stepIntNum,d0	; we want the 'step complete' interrupt
				bsr		WaitForInterrupt			; and wait for it...
				bne.s	@SeekError
				
				move.b	#GoStep,([vZeroes,a1])		; turn off seeking
				lea 	ReadyTMPB+TimeMgrOffset(a1),a0	; get the ready timer block
				bsr 	WaitTMPBdone				; wait for prior waits to time out
			
				move.l	#SeekDelay,d0		 		; Seek initial wait time
				bsr 	StartReadyTimer				; start the timer
				bsr 	LoadSWIMparams				; setup params based upon new cylinder
				bne.s 	@SeekError					; branch on error
				moveq	#0,d0						; else, return no error
				
@SeekDone		move.l	SeekPc(a1),-(sp)			; •• restore pc
				ext.w	d0 							; test error code, set flags
				rts 								; all done
				
@SeekError		move.b 	d0,CylinderValid(a1,d1.w)	; invalidate the cylinder
				move.b 	d0,CurrentCylinder(a1,d1.w)	; setup cylinder number too
				bra.s	@SeekDone



;_______________________________________________________________________
;
;  Routine: 	jsr 	CheckDriveMode
;  Inputs:		d1 - Drive Number
;  Outputs: 	ccr.z - 0 (bne) if drive mode change needed
;				ccr.z - 1 (beq) if no drive mode change needed
;				d0 - command for AddrAndStrb to change drive mode,
;					only valid when z indicates change is needed
;  Destroys:	d0,d2
;  Calls:		AddrAndSense
;  Called by:	TurnOnDrive, ReCalibrate
;
;  Function:	Checks to see if the drive mode (GCR/MFM) needs to be changed
;				for the currently selected drive, and returns the command
;				to change the drive mode, or an indication that no change
;				is needed.
;_______________________________________________________________________

CheckDriveMode	move.b 	DriveKind(a1,d1.w),d0 		; check the drive kind
				cmpi.b 	#DSMFMGCRDriveKind,d0		; see if SuperDrive
				bne.s 	@ModeIsCorrect				; only superdrive supports GCR and MFM

				moveq	#wMFMModeOnAdr,d2			; assume MFM format
				move.b	DiskFormat(a1,d1.w),d0		; get the format
				cmpi.b	#MFM720Kformat,d0			; is it MFM 720k?
				beq.s	@CheckMode					; yes, branch
				
				cmpi.b	#GCRonHDformat,d0			; GCR data on HD media needs GCR mode
				beq.s 	@NeedGCRMode 				; if GCR data on hi-density disk

				move.b	MediaKind(a1,d1.w),d0		; check the media
				cmpi.b 	#HiDenMediaKind,d0			; High density media is almost always MFM
				beq.s 	@CheckMode					; if High Density Media

@NeedGCRMode 	moveq 	#wGCRModeOnAdr,d2			; otherwise set to GCR format

@CheckMode		moveq 	#rMFMModeOnAdr,d0			; prepare to see what mode the drive is in
				bsr 	AddrAndSense 				; read the status
				bne.s 	@InMFMMode					; if in MFM mode

@InGCRMode		move.b	d2,d0
				cmpi.b 	#wGCRModeOnAdr,d0			; we're in GCR mode, see if we want to be
				rts 								; return with d0 = desired mode, z = mode is correct

@InMFMMode		move.b	d2,d0
				cmpi.b 	#wMFMModeOnAdr,d0			; we're in MFM mode, see if we want to be
				rts 								; return with A = desired mode, z = mode is correct

@ModeIsCorrect	moveq 	#0,d0						; set z, indicate mode is correct
				rts 								; return
				
		
		
		
;_______________________________________________________________________
;
;  Routine: 	jsr 	InitSWIMChip
;  Inputs:		a1	-	ptr to globals
;  Outputs: 	d0	- 	error status code
;  Destroys:	d0,a0
;  Calls:		LoadSWIMparams
;  Called by:	SWIM3Open, ReCalibrate
;
;  Function:	Initializes the SWIM3 chip.  Returns an error indication 
;				if initialization failed.
;_______________________________________________________________________

InitSWIMChip	movea.l	VIA,a0
				move.b	#startAction+WriteMode,([vZeroes,a1])	; turn off ACTION/WRITE
				
				move.b 	#ph0+ph2,d0
				move.b	d0,([vPhase,a1])
				tst.b	(a0)
				cmp.b	([vPhase,a1]),d0			; see if we can write/read phase lines
				bne.s	@error						; couldn't, must be bad SWIM3
				move.b 	#ph1+ph2,d0
				move.b	d0,([vPhase,a1])
				tst.b	(a0)
				cmp.b	([vPhase,a1]),d0			; see if we can write/read phase lines
				bne.s	@error						; couldn't, must be bad SWIM3
				move.b 	#ph0+ph1+ph2,d0
				move.b	d0,([vPhase,a1])
				tst.b	(a0)
				cmp.b	([vPhase,a1]),d0			; see if we can write/read phase lines
				bne.s	@error						; couldn't, must be bad SWIM
				
@loadParams		bsr		LoadSWIMparams				; setup the SWIM for current format/cylinder
				bne.s	@error						; didn't write, return error
				moveq	#0,d0						; else, no error
				bra.s	@exit
				
@error			move.w	#initIWMErr,d0				; else, indicate SWIM chip error
@exit			rts
				
				
				
;_______________________________________________________________________
;
;  Routine: 	jsr 	LoadSWIMparams
;  Inputs:		d1	-	drive #
;  				a1	-	ptr to globals
;  Outputs: 	ccr.z	-	1 if it wrote correctly
;  Destroys:	d0
;  Calls:		...
;  Called by:	SetUpDrive, SeekTrack, InitSWIMChip
;
;  Function:	Loads the SWIM parameter RAM with the correct parameters
;				for the current disk format, checks to see if they were
;				loaded correctly, and reports any errors
;_______________________________________________________________________

LoadSWIMparams	moveq	#0,d0
				move.b	#$95,([vParamData,a1])		; set to nominal pre-comp				
				move.b	DiskFormat(a1,d1.w),d0		; get format type
				move.b	SWIMwSetupTbl(d0.w),d0
				move.b	d0,([vSetup,a1])			; setup chip for this format
				nop
				cmp.b	([vSetup,a1]),d0			; did it write?
				rts
		
		
SWIMwSetupTbl	dc.b	GCRWrites*1+IBMDrive*0+ClockDiv2*1+GCRMode*1	;  0 - uncheckedFormat (use GCR)
				dc.b	GCRWrites*1+IBMDrive*0+ClockDiv2*1+GCRMode*1	;  1 - unknownFormat (use GCR)
				dc.b	GCRWrites*1+IBMDrive*0+ClockDiv2*1+GCRMode*1	;  2 - HD20Format (use GCR)
				dc.b	GCRWrites*1+IBMDrive*0+ClockDiv2*1+GCRMode*1	;  3 - GCR400Kformat
				dc.b	GCRWrites*1+IBMDrive*0+ClockDiv2*1+GCRMode*1	;  4 - GCR800Kformat
				dc.b	GCRWrites*0+IBMDrive*1+ClockDiv2*1+GCRMode*0	;  5 - MFM720Kformat
				dc.b	GCRWrites*0+IBMDrive*1+ClockDiv2*1+GCRMode*0	;  6 - MFM1440Kformat
				dc.b	GCRWrites*1+IBMDrive*0+ClockDiv2*1+GCRMode*1	;  7 - GCRonHDformat

		
		
;_______________________________________________________________________
;
;  Routine: 	jsr 	AddrAndSense
;  				jsr 	Sense
;  Inputs:		d0	-	drive address [0,0, HeadSelect, 0,0, ca2,ca1,ca0]
;				a1	-	ptr to globals
;  Outputs: 	ccr.z - 1 (BEQ) if DriveRdData line was zero
;				ccr.z - 0 (BNE) if DriveRdData line was one
;  Destroys:	a0,d0
;  Calls:		...
;  Called by:	CheckDriveMode, SeekTrack, Recalibrate, WaitDriveReady,
;				TurnOffDrive, TurnOnDrive, ReadTrack, RawTrackRead, ReadSectorHdr,
;				CheckStaticAttr, PollingTask, SWIM3CtlEject
;
;  Function:	Reads the DriveRdData line for selected register.
;_______________________________________________________________________

AddrAndSense	move.l	vAddrAndSense(a1),-(sp)		; push the vector
				rts									; call routine
				
jAddrAndSense	move.b 	#ca1+ca0,([vPhase,a1])		; set ca1 and ca0 high before changing HeadSelect
				nop
				btst	#HeadSelectBit,d0			; test new head select value
				beq.s 	@ResetHeadSelect 			; if new value is zero
				
				move.b	#HeadSelect,([vOnes,a1])	; set head select
				nop
				bra.s 	@HeadSelectDone				; join common code
@ResetHeadSelect 
				move.b	#HeadSelect,([vZeroes,a1])	; set head select
				nop
@HeadSelectDone	move.b 	d0,([vPhase,a1])			; write the phase lines

@Sense			movea.l	VIA,a0						
				tst.b	(a0)						; access the VIA to ensure a long pulse
				tst.b	(a0)						; "
				nop
				move.b 	#DriveRdData,d0				; prepare to test bit
				and.b 	([vHandshake,a1]),d0		; test the DriveRdData bit
				rts 								; all done
				



;_______________________________________________________________________
;
;  Routine: 	jsr 	AddrAndStrb
;  Inputs:		d0	-	drive address [0,0, HeadSelect, 0,0, ca2,ca1,ca0]
;				a1	-	ptr to globals
;  Outputs: 	...
;  Destroys:	d0
;  Calls:		...
;  Called by:	PollingTask, SWIMCtl3Eject, TurnOnDrive, TurnOffDrive,
;				ReCalibrate, SeekTrack
;
;  Function:	Sets up the disk register address for the currently enabled
;				disk and pulses the ph3 line, causing the data from ca2 to
;				be written to the addressed register.
;_______________________________________________________________________

AddrAndStrb		move.l	vAddrAndStrb(a1),-(sp)		; push the vector
				rts									; call routine
				
jAddrAndStrb	move.b 	#ca1+ca0,([vPhase,a1])		; set ca1 and ca0 high before changing HeadSelect
				btst	#HeadSelectBit,d0			; test new head select value
				beq.s 	@ResetHeadSelect 			; if new value is zero
				
				move.b	#HeadSelect,([vOnes,a1])	; set head select
				bra.s 	@HeadSelectDone				; join common code
@ResetHeadSelect 
				move.b	#HeadSelect,([vZeroes,a1])	; set head select

@HeadSelectDone	nop
				move.b 	d0,([vPhase,a1])			; write the phase lines
		 		ori.b 	#ph3,d0						; prepare to set ph3 bit
				nop
				move.b 	d0,([vPhase,a1])			; turn ph3 on
				movea.l	VIA,a0						
				tst.b	(a0)						; access the VIA to ensure a long pulse
				tst.b	(a0)						; "
				nop
				eori.b 	#ph3,d0						; prepare to reset ph3 bit
				move.b 	d0,([vPhase,a1])			; turn ph3 off
				nop
				rts 								; all done

				


;_______________________________________________________________________
;
;  Routine: 	jsr 	SelectDrive
;  Inputs:		d0.b	- physical drive number (1 or 2)
;				a1		- ptr to globals
;  Outputs: 	ccr.z 	- 1 (BEQ) if illegal drive number
;				ccr.z 	- 0 (BNE) if legal drive number
;  Destroys:	d0
;  Calls:		...
;  Called by:	SWIMInitialize, PollingTask, SWIM3CtlEject, SWIM3Open, TurnOnDrive
;
;  Function:	Asserts the ENABLE line for the specified drive.
;_______________________________________________________________________

SelectDrive		move.l	vSelectDrive(a1),-(sp)
				rts

jSelectDrive	cmpi.b 	#intDriveNumber,d0			; check for internal drive
				bne.s 	@chkExternal 				; if not internal drive
				move.b 	#Drive2Enabled,([vZeroes,a1])	; disable external drive
				nop
				move.b 	#Drive1Enabled,([vOnes,a1])	; enable the internal drive
				rts 								; all done, return z <- false

@chkExternal 	move.b 	#rNoDriveAdr,([vPhase,a1])	; address the drive exists reg
				move.b 	#HeadSelect,([vZeroes,a1]) 	; HeadSelect is 0 for rNoDriveAdr
				move.b 	#Drive1Enabled,([vZeroes,a1]) 	; disable internal drive
				nop
				move.b 	#Drive2Enabled,([vOnes,a1]) ; enable the external drive
				cmpi.b 	#extDriveNumber,d0			; check for external drive
				bne.s 	@unknownDrive 				; if not external, exit
				moveq	#1,d0						; return z <- false
				rts 								; all done

@unknownDrive	moveq	#0,d0						; return z <- true
				rts 								; all done




;_______________________________________________________________________
;
;  Routine: 	jsr 	FindDriveKind
;  Inputs:		a1		- ptr to globals
;  Outputs: 	d0	- 	Disk Drive Kind
;  Destroys:	...
;  Calls:		...
;  Called by:	SWIM3Open
;
;  Function:	Determines what kind of drive is currently selected, by
;				examining 4 of the disk status values returned by the drive.
;
;
; Name			HeadSel ca2 	ca1 	ca0 |	400K	800K	HD20	SuperDr Typhoon	NoDrive
;											|
; Revised		1		1		1		1	|	0		1		1		x		0		1
; /DrvIn		0		1		1		1	|	0		0		1		0		0		1
; /SingleSide	0		1		1		0	|	0		1		1		1		0		1
; SuperDrive	0		1		0		1	|	0		0		0		1		1		1
;_______________________________________________________________________

FindDriveKind	movem.l	a0/d1-d2,-(sp)				; save regs
				movea.l	VIA,a0
				move.b 	#ca2+ca1+ca0,d2				; init our ca2-0 bits
				move.b	d2,([vPhase,a1])			; prepare to test REVISED status
				move.b 	#HeadSelect,([vOnes,a1]) 	; set HeadSelect
				nop
				move.b 	([vHandshake,a1]),d0		; prepare to test bit
				nop
				move.b 	#HeadSelect,([vZeroes,a1]) 	; Clear HeadSelect
				nop
				moveq 	#%00010000,d1				; init drive kind index / loop counter
				bra.s 	@start

@loop			move.b	d2,([vPhase,a1])			; set the phase lines
				tst.b	(a0)						; access VIA to let sense line settle
				nop
				subq.b	#1,d2 						; decrement ca2..ca0 phase values
				move.b 	([vHandshake,a1]),d0		; prepare to test bit
				nop
@start			btst 	#DriveRdDataBit,d0			; isolate the DriveRdData bit
				beq.s	@shift						; if 0, just shift in 0
				bset	#0,d1						; else, shift in a 1
@shift			add.b	d1,d1						; shift in next bit
				bcc.s 	@loop						; loop until last bit shifted in

				lsr.b	#1,d1
				move.b 	DriveKindXlate(d1.w),d0 	; translate status's to drive kind
				
				movem.l	(sp)+,a0/d1-d2				; restore regs
				rts 								; all done


DriveKindXlate	dc.b	SSGCRDriveKind				; 0 0 0 0 - 400K GCR drive
				dc.b	unknownDriveKind			; 0 0 0 1 - 4MB Typhoon drive
				dc.b	unknownDriveKind			; 0 0 1 0 - unknown
				dc.b	DSMFMGCRDriveKind			; x 0 1 1 - SuperDrive
				dc.b	unknownDriveKind			; 0 1 0 0 - unknown
				dc.b	unknownDriveKind			; 0 1 0 1 - unknown
				dc.b	unknownDriveKind			; 0 1 1 0 - unknown
				dc.b	unknownDriveKind			; 0 1 1 1 - unknown
				dc.b	unknownDriveKind			; 1 0 0 0 - unknown
				dc.b	unknownDriveKind			; 1 0 0 1 - unknown
				dc.b	DSGCRDriveKind				; 1 0 1 0 - 800K GCR drive
				dc.b	DSMFMGCRDriveKind			; x 0 1 1 - SuperDrive
				dc.b	unknownDriveKind			; 1 1 0 0 - unknown
				dc.b	unknownDriveKind			; 1 1 0 1 - unknown
				dc.b	HD20DriveKind				; 1 1 1 0 - HD-20 drive
				dc.b	noDriveKind 				; 1 1 1 1 - No drive installed
				




FmtSearchOrder	dc.b	MFM1440Kformat				; try 1440K first
				dc.b	MFM720Kformat				; then 720K
				dc.b	GCR800Kformat				; then 800K
				dc.b	GCR400Kformat				; then 400K
				dc.b	GCRonHDformat				; and finally 400K/800K on HD media
				dc.b	unknownFormat				; list terminator

FmtByteValues	dc.b	$02 						; 1440K (block size = 2*256)
				dc.b	$02 						; 720K (block size = 2*256)
				dc.b	$22 						; 800K GCR (2 sided)
				dc.b	$02 						; 400K GCR (1 sided)
				dc.b	$00 						; 400K/800K GCR on HD media (ignore)

FmtByteMasks	dc.b	$FF 						; 1440K, use whole byte
				dc.b	$FF 						; 720K, use whole byte
				dc.b	$20 						; 800K GCR, ignore interleave info
				dc.b	$20 						; 400K GCR, ignore interleave info
				dc.b	$00 						; 400K/800K GCR on HD media, ignore byte


				ALIGN	2




;_______________________________________________________________________
;
;  Routine: 	jsr 	StartTMPBtimer
;  Inputs:		a0	 - Timer parameter block
;  				d0	 - duration (>0 = ms, <0 = microseconds)
;  Outputs: 	none
;  Destroys:	d0
;  Calls:		_InstallTime, _PrimeTime
;  Called by:	StartReadyTimer, WaitDriveReady, TurnOnDrive, RawTrackRead,
;				PollingTask
;
;  Function:	Starts running the timer pointed to by a0.
;				The tmCount field of the TMPB must be filled in prior
;				to this call.
;_______________________________________________________________________

StartTMPBTimer	
			with 	TimerBlock
		
				movem.l	d0/a1,-(sp)					; save d0,a1
				lea		GenericTimerCompletion,a1
				move.l	a1,tmAddr(a0)				; set our completion routine (indicate active also)
				_InsTime							; install the timer
				movem.l	(sp)+,d0/a1					; restore d0,a1
				_PrimeTime							; prime it
				rts
				
GenericTimerCompletion
				movea.l	a1,a0						; get the pb
				_RmvTime							; remove the timer
				clr.l	tmAddr(a0)					; indicate we're complete
				move.l	myCompletion(a0),d0			; is there a user completion to run?
				beq.s	@exit						; no, exit

				clr.l	myCompletion(a0)			; 
				movea.l	SonyVars,a1					; yes, setup a1
				;movea.l	IWM,a2						; and a2
				movem.l	regSave(a0),a3/d1-d3		; and restore others
				
				move.l	d0,-(sp)					; call users completion
@exit			rts
			
			endwith
			
			
				
;_______________________________________________________________________
;
;  Routine: 	jsr 	WaitTMPBdone
;  Inputs:		a0	-	Timer parameter block
;  Outputs: 	d0	-	noErr
;  Destroys:	...
;  Calls:		...
;  Called by:	SeekTrack, Recalibrate, Sleep, WaitMotorSettled, WaitDriveReady,
;				RawTrackRead, PollingTask
;
;  Function:	If the TMPB is complete, this routine simply returns to
;				its caller.  If it is not complete, then it returns to
;				its callers caller, and will return to its caller when
;				the TMPB request has completed.
;_______________________________________________________________________

WaitTMPBdone	
			with 	TimerBlock
			
				movem.l	a3/d1-d3,regSave(a0)		; save state in the user area of pb
				
				tst.l	tmAddr(a0)					; are we complete already?
				beq.s 	@exit						; if already done
				
				tst.l	myCompletion(a0)			; see if already waiting
				bne.s 	@MultipleWaits				; crash if already waiting
				move.l	(sp)+,myCompletion(a0)

@exit			moveq	#noErr,d0					; return to caller's caller with no error
				rts 								; all done

@MultipleWaits	_debugger 							; multiple waits on TMPB

			endwith





;_______________________________________________________________________
;
;  Routine: 	jsr 	CancelTMPBtimer
;  Inputs:		a0	 - Timer parameter block
;  Outputs: 	...
;  Destroys:	d0
;  Calls:		_RmvTime
;  Called by:	WaitDriveReady, TurnOffDrive, TurnOnDrive, RawTrackRead
;
;  Function:	Cancels the timer pointed to by a0, and removes it
;				from the timer queue.
;_______________________________________________________________________

CancelTMPBtimer	
			with 	TimerBlock

				move.w	sr,-(sp)
				ori.w	#$0700,sr
				clr.l	myCompletion(a0)			; 
				clr.l	tmAddr(a0)					; indicate we're complete
				_RmvTime							; remove the timer
				move.w	(sp)+,sr
				rts
				
			endwith
	
	
	
	
	
	
;_______________________________________________________________________
;
;  Routine: 	jsr 	StartIntTimeout
;  Inputs:		d2	- 	duration (>0 = ms, <0 = microseconds)
;				a1	-	ptr to globals
;  Outputs: 	none
;  Destroys:	a0
;  Calls:		_InstallTime, _PrimeTime
;  Called by:	WaitForInterrupt
;
;  Function:	Starts a timeout timer for the floppy operation about to begin.
;				If and when it expires, it disables the floppy interrupt
;				and calls the completion routine with an error code.
;_______________________________________________________________________

StartIntTimeout	
			with 	TimerBlock,IntBlock
				
				move.l	a1,-(sp)
				move.l	d0,-(sp)
				
				lea		ReadWriteTMPB+TimeMgrOffset(a1),a0	; get ptr to our timeout timer block
				lea		@InterruptTimeout,a1
				tst.l	tmAddr(a0)					; is the timer already installed?
				bne.s	@doneInst					; yes, let it continue to run
				move.l	a1,tmAddr(a0)				; set our completion routine (indicate active also)
				move.l	#'eada',qLink(a0)			; this is a VM safe task
				_InsTime							; install the timer
				move.l	d2,d0						; get our wait time
				_PrimeTime							; prime it
@doneInst		move.l	(sp)+,d0
				movea.l	(sp)+,a1
				rts
				
@InterruptTimeout
				move.w	sr,-(sp)
				ori.w	#$0200,sr					; •• mask out Floppy interrupts
				movea.l	a1,a0						; get the pb
				_RmvTime							; remove the timer
				clr.l	tmAddr(a0)					; it's free now
				
				movea.l	SonyVars,a1					; yes, setup a1
				;movea.l	IWM,a2						; and a2

				moveq	#0,d0
				move.b	([vIntMask,a1]),d0			; get the floppy int we were waiting for
				beq.s	@noWaits					; exit if no bits set (why are we here?)

				move.b	(SWIM3IntPriority,d0.w),d0	; convert to bit#
				bclr.b	d0,([vIntMask,a1])			; disable this interrupt
				bclr.b	#idIntNum,([vIntMask,a1])	; disable ID int as well (in case of read)
				mulu.w	#IntBlockSize,d0			; calc offset to proper pb
				
				lea		(SWIM3IntVectors,a1,d0.w),a0; get ptr to param block
				move.l	intCompletion(a0),d0		; get completion routine
				clr.l	intCompletion(a0)			; it's free now
				move.w	(sp)+,sr					; •• restore ints
				tst.l	d0							; did the floppy interrupt already complete the call?
				beq.s	@exit
				
				movem.l	intRegSave(a0),a3/d1-d3		; restore state
				movea.l	d0,a0						; completion in a0
				
				moveq	#sectNFErr,d0				; indicate sector not found (timeout)
				jsr		(a0)						; and call the users completion rtn

@exit			rts

@noWaits		_debugger

			endwith
	
	
	
	
;_______________________________________________________________________
;
;  Routine: 	jsr 	WaitForInterrupt
;  Inputs:		d0	 	- (15..0)  SWIM3 interrupt # (0-4)
;				d0	 	- (23..16) value to write into Ones(a2), to start SWIM3
;				d2.l	- duration (>0 = ms, <0 = microseconds)
;				a1		- ptr to globals
;  Outputs: 	none
;  Destroys:	a0
;  Calls:		StartIntTimeout
;  Called by:	Seek, FmtTrack, WriteTrack, ReadTrack, ReadSectorHdr
;
;  Function:	This routine sets up the interrupt param block, enables the SWIM3
;				interrupt, writes the specified value to Ones(a2) to startup SWIM3,
;				and returns to the callers caller.  When the interrupt completes, 
;				the caller gets called (with it's state restored).
;_______________________________________________________________________

WaitForInterrupt	
			with	IntBlock

				tst.b	([vInterrupt,a1])			; clear any pending flags

				move.l	d2,-(sp)					; save d2
				move.w	SWIM3IntPBOffset(d0.w*2),d2	; get param block offset
				lea		(SWIM3IntVectors,a1,d2.w),a0; get ptr to actual param block
				move.l	(sp)+,d2
				
				tst.l	intCompletion(a0)			; see if already waiting
				bne.s 	@multipleWaits				; crash if already waiting
				movem.l	a3/d1-d3,intRegSave(a0)		; save state in the user area of pb
				move.l	(sp)+,intCompletion(a0)
				
				bsr		StartIntTimeout				; start a time-out for the SWIM3 interrupt
				tst.b	([vIntMask,a1])				; are there any currently enabled ints?
				bne.s	@multipleWaits				; yes, break
	
				bset.b	d0,([vIntMask,a1])			; enable the SWIM3 interrupt
				nop
				swap	d0
				move.b	d0,([vOnes,a1])				; startup the chip
				
				moveq	#noErr,d0					; return to caller's caller with no error
				rts 								; all done

@multipleWaits	_debugger
		

SWIM3IntPBOffset
				dc.w	IntBlockSize*0				; timer 	pb offset
				dc.w	IntBlockSize*1				; step 		pb offset
				dc.w	IntBlockSize*2				; ID Read 	pb offset
				dc.w	IntBlockSize*3				; Done		pb offset
				dc.w	IntBlockSize*4				; Sense		pb offset
	
			endwith


	
;_______________________________________________________________________
;
;  Routine: 	jsr 	SWIM3IntDispatch
;  Inputs:		none
;  Outputs: 	none
;  Destroys:	none
;  Calls:		a SWIM3 interrupt handler
;  Called by:	Level 2 interrupt dispatcher
;
;  Function:	Dispatches to the correct floppy interrupt vector, based on
;				SWIM3 interrupt flags.
;_______________________________________________________________________

SWIM3IntDispatch
			with	IntBlock

				;movea.l	IWM,a2						; get ptr to SWIM base
				movea.l	SonyVars,a1					; get ptr to our globals

				moveq	#0,d0
				move.b	([vInterrupt,a1]),d0		; get (and clear) the interrupt
				and.b	([vIntMask,a1]),d0			; look only at enabled ints
				beq		DefIntHandler				; exit if no bits set (why are we here?)
				
				move.b	SWIM3IntPriority(d0.w),d0	; prioritize them
				bclr.b	d0,([vIntMask,a1])			; disable this interrupt
				bclr.b	#idIntNum,([vIntMask,a1])	; disable ID int in case enabled

				mulu.w	#IntBlockSize,d0			; calc offset to proper pb
				lea		(SWIM3IntVectors,a1,d0.w),a0; get ptr to param block
				movem.l	intRegSave(a0),a3/d1-d3		; restore state
				move.l	intCompletion(a0),-(sp)		; get completion routine
				clr.l	intCompletion(a0)			; it's free now

				btst	#TrackTimer,StateFlags(a1) 	; do we have a timeout for the whole track?
				bne.s	@exit						; yes, don't remove the task here (let it run)
				
				lea		ReadWriteTMPB+TimeMgrOffset(a1),a0	; get ptr to our timeout timer block
				_RmvTime									; remove the timer
				clr.l	tmAddr(a0)							; it's free now

@exit			moveq	#0,d0						; no timeout error
				rts									; call it

@error		_debugger

SWIM3IntPriority
				dc.b	0							; dummy
				dc.b	0							; 0 0 0 0 0 0 1  bit 0 is highest priority
				dc.b	1							; 0 0 0 0 0 1 0  bit 1 is highest priority
				dc.b	1							; 0 0 0 0 0 1 1  bit 1 is highest priority
				dc.b	2							; 0 0 0 0 1 0 0  bit 2 is highest priority
				dc.b	2							; 0 0 0 0 1 0 1  bit 2 is highest priority
				dc.b	2							; 0 0 0 0 1 1 0  bit 2 is highest priority
				dc.b	2							; 0 0 0 0 1 1 1  bit 2 is highest priority
				dc.b	3							; 0 0 0 1 0 0 0  bit 3 is highest priority
				dc.b	3							; 0 0 0 1 0 0 1  bit 3 is highest priority
				dc.b	3							; 0 0 0 1 0 1 0  bit 3 is highest priority
				dc.b	3							; 0 0 0 1 0 1 1  bit 3 is highest priority
				dc.b	3							; 0 0 0 1 1 0 0  bit 3 is highest priority
				dc.b	3							; 0 0 0 1 1 0 1  bit 3 is highest priority
				dc.b	3							; 0 0 0 1 1 1 0  bit 3 is highest priority
				dc.b	3							; 0 0 0 1 1 1 1  bit 3 is highest priority
				dc.b	4							; 0 0 1 0 0 0 0  bit 4 is highest priority
				dc.b	4							; 0 0 1 0 0 0 1  bit 4 is highest priority
				dc.b	4							; 0 0 1 0 0 1 0  bit 4 is highest priority
				dc.b	4							; 0 0 1 0 0 1 1  bit 4 is highest priority
				dc.b	4							; 0 0 1 0 1 0 0  bit 4 is highest priority
				dc.b	4							; 0 0 1 0 1 0 1  bit 4 is highest priority
				dc.b	4							; 0 0 1 0 1 1 0  bit 4 is highest priority
				dc.b	4							; 0 0 1 0 1 1 1  bit 4 is highest priority
				dc.b	4							; 0 0 1 1 0 0 0  bit 4 is highest priority
				dc.b	4							; 0 0 1 1 0 0 1  bit 4 is highest priority
				dc.b	4							; 0 0 1 1 0 1 0  bit 4 is highest priority
				dc.b	4							; 0 0 1 1 0 1 1  bit 4 is highest priority
				dc.b	4							; 0 0 1 1 1 0 0  bit 4 is highest priority
				dc.b	4							; 0 0 1 1 1 0 1  bit 4 is highest priority
				dc.b	4							; 0 0 1 1 1 1 0  bit 4 is highest priority
				dc.b	4							; 0 0 1 1 1 1 1  bit 4 is highest priority

	
DefIntHandler	_debugger
				rts									; just rts	
	
			endwith
		
		
;_______________________________________________________________________
;
;  Routine: 	jsr 	StartDMATimeout
;  Inputs:		d0	- 	duration (>0 = ms, <0 = microseconds)
;				a1	-	ptr to globals
;  Outputs: 	none
;  Destroys:	d0,a0
;  Calls:		_InstallTime, _PrimeTime
;  Called by:	StartDMAAction
;
;  Function:	Starts a timeout timer for the DMA operation about to begin.
;				If and when it completes, it turns off the DMA operation
;				and calls the user completion with an error code.
;_______________________________________________________________________

StartDMATimeout	
			with 	TimerBlock
				movem.l	d0/a1,-(sp)					; save d0,a1
				lea		ReadWriteTMPB+TimeMgrOffset(a1),a0	; get ptr to our timeout timer block
				lea		@DMATimeout,a1
				tst.l	tmAddr(a0)					; is someone using this timer?
				bne.s	@inUse
				move.l	a1,tmAddr(a0)				; set our completion routine (indicate active also)
				_InsTime							; install the timer
				movem.l	(sp)+,d0/a1					; restore d0,a1
				_PrimeTime							; prime it
				rts
				
				
@DMATimeout		move.w	sr,-(sp)
				ori.w	#$0500,sr					; mask out level 5 interrupts (DMA)
				movea.l	a1,a0						; get the pb
				_RmvTime							; remove the timer
				clr.l	tmAddr(a0)					; it's free now

				movea.l	SonyVars,a1					; yes, setup a1
				;movea.l	IWM,a2						; and a2

				move.l	DMACompletionPtr(a1),d0		; is there a user completion to run?
				clr.l	DMACompletionPtr(a1)		; clear the completion so DMA ints can't screw us
				move.w	(sp)+,sr					; restore interrupts
			
				tst.l	d0							; did the DMA already complete?
				beq.s	@exit						; yes, exit
				
				bsr	ClearDMAInt						; clear floppy DMA interrupt
								
				movem.l	DMARegSave(a1),a3/d1-d3		; restore driver state
				movea.l	d0,a0
			
				moveq	#sectNFErr,d0				; indicate sector not found (timeout)
				jsr		(a0)						; and call the users completion rtn

@exit			rts

@inUse			_debugger

			endwith
			

;_______________________________________________________________________
;
;  Routine: 	jsr 	StartDMAAction
;  Inputs:		d0.l-	DMA timeout value
;				d1	-	drive#
;				a1	- 	Globals
;  Outputs: 	none
;  Destroys:	d0,a0
;  Calls:		none
;  Called by:	RawTrackRead, ReadRawHeader
;
;  Function:	This routine saves state in the DMARegSave area, and starts
;				the DMA, returning to the caller's caller.
;_______________________________________________________________________

StartDMAAction		
				move.l	vStartDMAAction(a1),-(sp)	; push vector
				rts									; call routine


;_______________________________________________________________________
;
;  Routine: 	jsr 	DMAInterruptHandler
;  Inputs:		none
;  Outputs: 	none
;  Destroys:	none
;  Calls:		DMACompletionHandler
;  Called by:	68020 level 5 interrupt
;
;  Function:	This routine removes the time-out timer, clears the floppy 
;				interrupt, then calls the floppy handler.
;_______________________________________________________________________

DMAInterruptHandler
				movea.l	SonyVars,a1
				;movea.l	IWM,a2
				
				lea		ReadWriteTMPB+TimeMgrOffset(a1),a0	; get ptr to our timeout timer block
				_RmvTime									; remove the timer
				clr.l	tmAddr(a0)							; it's free now
				
				bsr	ClearDMAInt						; clear floppy DMA interrupt
								
				movem.l	DMARegSave(a1),a3/d1-d3		; restore driver state
				move.l	DMACompletionPtr(a1),d0		; get completion routine
				beq.s	@exit						; exit if none
				clr.l	DMACompletionPtr(a1)		; clear it
				movea.l	d0,a0
				moveq	#0,d0						; no errors
				jsr		(a0)						; call the user completion
				
@exit			rts
				

;_______________________________________________________________________
;
;  Routine: 	jsr 	SetUpDMAXFer
;  Inputs:		a0	-	DMA transfer address
;				a1 	- 	SonyVars ptr
;				d0	-	bit 31 = 0	-> read
;						       = 1	-> write
;						bits 0-30	-> transfer count
;  Outputs:		none
;  Destroys:	d0
;  Calls:
;  Called by:
;
;  Function:	Sets up address, count, and direction for a DMA
;				transfer.
;_______________________________________________________________________

SetUpDMAXFer	move.l	vSetUpDMAXfer(a1),-(sp)		; push vector
				rts									; call routine


;_______________________________________________________________________
;
;  Routine: 	jsr 	ClearDMAInt
;  Inputs:		a1 	- 	SonyVars ptr
;  Outputs:		none
;  Destroys:	none
;  Calls:
;  Called by:
;
;  Function:	Clears floppy DMA controller interrupt.
;_______________________________________________________________________

ClearDMAInt
				move.l	vClearDMAInt(a1),-(sp)		; push vector
				rts									; call routine


;_______________________________________________________________________
;
;  Routine: 	jsr 	StopDMA
;  Inputs:		a1 	- 	SonyVars ptr
;  Outputs:		none
;  Destroys:	none
;  Calls:
;  Called by:
;
;  Function:	Stops the floppy DMA channel.
;_______________________________________________________________________

StopDMA
				move.l	vStopDMA(a1),-(sp)				; push vector
				rts										; call routine


			endwith		; SWIM3Vars