Macintosh-SW/sys7.1-doc-wip
1
0
Fork 0
mirror of https://github.com/elliotnunn/sys7.1-doc-wip.git synced 2024-12-13 11:29:15 +00:00
Code Issues Projects Releases Wiki Activity
cf5093687a
sys7.1-doc-wip/Drivers/IOP/SWIMDriver.aii
Horst Beepmanh 33cd9271f4 SuperMarioProj.1994-02-09
2019-07-27 22:37:48 +08:00

7719 lines
303 KiB
Plaintext
Raw Blame History

;
; File: SWIMDriver.aii
;
; Contains: IOP Based SWIM/SuperDrive Floppy Disk Driver.
;
; Written by: Gary G. Davidian Created: 01-Aug-87
;
; Copyright: © 1987-1990 by Apple Computer, Inc., all rights reserved.
;
; Change History (most recent first):
;
; <3> 1/14/90 GGD NEEDED FOR ZONE-5: Fixing occasional problem with Raw Track Read
; getting an overrun when doing an immediate GCR track dump.
; Adjusted MFMreWriteDelay timing to give proper write splices.
; Changed Polling Task to disable the drive before calling the
; 68030 to post disk inserted events, to prevent clicking noises
; during the early booting stages.
; <2> 1/2/90 GGD NEEDED FOR ZONE-5:Adding support for Raw Track I/O to better
; support copy protection. Fixed bug in GCR formatting that wrote
; 199 bad sync patterns at the beginning of the track, but since
; it gets mostly overwritten by the last sector on the track, and
; was followed by 8 good ones, it was pretty harmless. This was
; introduced by change <1.8>. Re-organized and optimized code to
; regain some additional RAM space. Improved the performance of
; reporting GCRonMFMErr, eliminated the retries (which took a long
; time), since it is not a recoverable error.
; <2.0> 12/11/89 GGD NEEDED FOR ZONE-5 Added support for the Disk Duplicator.
; Implemented a dummy routine for the Get Raw Data track dump
; command which just returns ControlErr for now. Added some extra
; entries to the request dispatch table to allow easier patching.
; <1.9> 11/19/89 GGD NEEDED FOR ZONE-5 Changed StartPolling and implemented
; StopPolling, to more closely match how they are documented in
; the ERS. Added a prefetcher task to fill the cache with data
; that is under the heads during the last second before turning
; off the drive motor. Added TimeOut checks in DMA transfer loops
; to prevent infinate loops if DMA hangs.
; <1.8> 11/2/89 GGD NEEDED FOR ZONE-5 Added DMA support to GCR Format, MFM
; Read/Write/Format so that ADB can get more processor time while
; the floppy is in use. This feature will result in a smoother
; mouse/cursor if the user moves the mouse while the floppy is
; being used, which will boost the sales of ZONE-5's and will have
; a direct impact on profit sharing.
; <1.7> 10/10/89 GGD Reorganized some code to allow more sharing between routines and
; save space. I/O routines now look for recent ADB activity, and
; try to give ADB some more time to make the mouse smoother. Added
; seek optimization for large I/O requests to start at the end of
; the request that is closest to the current head position.
; <1.6> 9/22/89 GGD Implemented first pass at Track Cacheing and Error Recovery.
; <1.5> 7/8/89 CCH Added EASE comments to file.
; <•1.4> 6/15/89 GGD Updated to use equates for the latest rev of the IOP chip,
; re-formated tab stops in source.
; <1.3> 2/9/89 GGD Added temporary version of track buffer support to greatly
; improve Floppy performance. Also coded around SWIM problem with
; MFM writes not always getting 12 bytes of zeros for a sync
; field.
; <1.2> 2/5/89 GGD Implemented Format/Verify support. Rolled in changes to
; SWIM/SuperDrive support that were uncovered during Mac IIx
; development (new SWIM params, GCR on HD media, etc).
; <1.1> 11/16/88 GGD Fixed bug with incorrect sensing of eject button in some cases.
; <1.0> 11/9/88 CCH Adding to EASE.
;
; To Do:
;
eject
title 'IOP SWIM Driver'
; File: SWIMDriver.aii - IOP code for IOP Based SWIM driver.
;
;______________________________________________________________________________
;
; IOP Based SWIM/SuperDrive Floppy Disk Driver.
;
; written by Gary G. Davidian Created: 01-Aug-87
;
; Copyright © Apple Computer, Inc. 1987-1989
;
;______________________________________________________________________________
machine m65C02
codechk off
datachk off
longa off
longi off
print nomdir
include 'IOPDefs.aii'
include 'SWIMDefs.aii'
import ADBActivity
import GetTMPB
import StartTMPBTimer
import WaitTMPBdone
import CancelTMPBtimer
import TMPBtimeH
import TMPBtimeL
import GetBCPB
import MakeBCPBreq
import WaitBCPBdone
import BCPBcmd
import BCPBiopAddrH
import BCPBiopAddrL
import BCPBbyteCountH
import BCPBbyteCountL
import BCPBhostAddrB0
import BCPBhostAddrB1
import BCPBhostAddrB2
import BCPBhostAddrB3
import BCPBcompRel
entry InitSWIMChip
entry AdrAndSense
entry AdrAndStrb
entry GetDriveStatus
entry DiskSelect
entry FindDriveKind
entry TurnOffDrive
entry CheckStaticAttr
entry SetUpDrive
entry ReadSectorHdr
entry ReadHdrSetup
entry ReadSectorData
entry WriteSectorData
entry SkipSectorData
entry BlockToPhysAddr
entry Seek
entry ReCalibrate
entry WaitDriveReady
entry WaitMotorSettled
entry SleepLong
entry SleepShort
entry TurnOnDrive
entry LoadSwimParams
entry StartReadyTimer
entry Sense
entry Pulse
entry CreateTrackCache
entry FlushTrackCache
entry FlushIfDisabled
entry FindCacheEntry
title 'IOP SWIM Driver - Global Variables'
; Conditional assembly switches
CheckEncodings equ 0 ; don't check gcr nibbles for legal encodings in loops
UseDmaHardware equ 1 ; use the DMA Hardware where appropriate
; 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
GCRAddrMarkSize equ 3 ; size of GCR Address Mark (D5 AA 96)
GCRAddrSlipMarkSize equ 3 ; size of GCR Address Slip Mark (DE AA FF)
GCRGapSyncSize equ 6 ; size of GCR Gap Sync (FF 3F CF F3 FC FF)
GCRDataMarkSize equ 3 ; size of GCR Data Mark (D5 AA AD)
GCRDataSlipMarkSize equ 4 ; size of GCR Data Slip Mark (DE AA FF FF)
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
MFMIndexMarkSize equ 4 ; size of MFM Index Mark (C2 C2 C2 FC)
MFMIndexMarkGapSize equ 50 ; size of MFM Gap between index mark and sector 1
MFMAddrMarkSize equ 4 ; size of MFM Address Mark (A1 A1 A1 FE)
MFMAddrMarkGapSize equ 22 ; size of MFM Gap between address and data
MFMDataMarkSize equ 4 ; size of MFM Data Mark (A1 A1 A1 FB)
MFM720KDataGapSize equ 80 ; size of MFM Gap following 720K sectors
MFM1440KDataGapSize equ 101 ; size of MFM Gap following 1440K sectors
MFMFinalGapSize equ 1000 ; size of MFM Gap between last sector to index (max)
; Delay Timing / Timeout constants
PollRate equ TMPB1second/2 ; wake up and look around every 1/2 second
MotorTimeoutCount equ 5 ; motor timeout is 2.0 .. 2.5 seconds (5 polls)
ReadyPollRate equ TMPB1ms*3/4 ; check ready every 750 uSeconds
ReadyTimeoutCount equ TMPB1second\
/ReadyPollRate ; max poll time is 1 second
MotorOnDelay equ TMPB1second/20 ; Delay 50ms after motor on before checking ready
ChuckingDelay equ TMPB1second/2\
-MotorOnDelay ; Delay 500ms for proper disk chucking
MotorOnSettle equ TMPB100ms*3 ; Motor speed within 1.5 % 300ms after drive ready
MotorStopDelay equ TMPB1second/5 ; Delay 200ms after MotorOff to spin down
SeekDelay equ TMPB1ms/2 ; wait 500usec after seek before checking ready
DMAxferDelay equ 2000*TMPB1second/1000000 ; go idle for 2.0 ms during DMA xfer
GCRSectorDataDelay equ 12124*TMPB1second/1000000 ; 12.124 ms is time of data & gap portion of GCR sector
MFMSectorDataDelay equ 9472*TMPB1second/1000000 ; 9.472 ms is time of data & gap portion of MFM sector
TypicalADBDelay equ 3800*TMPB1second/1000000 ; 3.800 ms is typical time of ADB poll with 2 data bytes
SectorDelay equ TMPB10ms+TMPB1ms; 11ms is approx time of 1 sector
EjectPollRate equ TMPB100ms ; check eject done every 100 ms
EjectTimeoutCount equ TMPB100ms*15\
/EjectPollRate ; give up after 1.5 seconds
EjectSettleDelay equ TMPB1ms*15/100 ; leave drive enabled 150usec after eject
GCRWriteToRead equ 620 ; 620µs max time from write to read data valid again
AddrSearchMax equ 1500 ; search 1500 bytes looking for an address mark
BytePollMax equ 8 ; give up on a byte after 8 polls
DataSearchMax equ 48 ; search 48 bytes looking for data mark
; MFM bytes are 16µsec, which is 31.3344 clocks @1.9584MHz.
; About 204 clocks of overhead is already consumed by the routine.
; Delay loop is 5 clocks per iteration.
MFMreWriteDelay equ (((MFMAddrMarkGapSize*313344)/10000)-204)/5
GiveADBTimeMask equ %11111111 ; Consider the last 8 ADB polls for activity
; Sector Buffer / Track Cache constants
TotalBuffers equ 36 ; buffer storage for 36 sectors
MaxCacheEntries equ TotalBuffers\
/MinSectors ; Max number of tracks that fit into cache
MinCacheEntries equ TotalBuffers\
/MaxSectors ; Min number of tracks that fit into cache
; Raw I/O Buffer constants
RawTempBufferNum equ 0 ; 1 temp buffer needed to read sector data
RawDataBufferNum equ 1 ; large buffer space for raw track data
RawClockBufferNum equ (TotalBuffers-1)*8/9+RawDataBufferNum
RawByteCountMax equ (RawClockBufferNum-RawDataBufferNum)\
*BlockSize ; max number of bytes for Raw I/O
; Error handling / recovery constants
RecalsMax equ 1 ; Max Recals allowed before hard error
IOErrorsMax equ 9 ; Max I/O errors allowed before Recal
WrongSectsMax equ 64 ; Max wrong sectors allowed before Recal
seg 'PageData'
SectorBuffers record ; Sector Buffer Storage (must be Page Aligned)
MFMGapBuffer equ * ; MFM format gap buffer for DMA
TagBufStart equ * ; start of tag buffer
ds.b 4 ; padding so that a tag doesn't cross a page
TagBuffers ds.b TotalBuffers\
*TagSize ; sector tag storage
ds.b 4 ; get back to a page boundary
TagBufEnd equ * ; end of tag buffer
BufferStatus ds.b TotalBuffers ; status flags for each buffer
ReadDataValid equ %10000000 ; Valid disk data has been read into the buffer
IORequested equ %01000000 ; Buffer needs to be Read/Written for current request.
TagPtrs ds.b TotalBuffers ; offsets divided by 2 to tag buffers
DataBuffers ds.b TotalBuffers\
*BlockSize ; sector data storage
DataBufSize equ *-DataBuffers ; number of bytes in data buffers
GCRGapBuffer equ *-$500 ; GCR format gap sync buffer for DMA
endr
seg 'zdata'
SWIMVarsZ record
SWIMVarsZStart equ *
DriverActive ds.b 1 ; idle = 0, active <> 0
CurrentDrive ds.b 1 ; drive currently selected or powered up
LastActiveDrive ds.b 1 ; drive number of last successfully accessed drive
StatusMsgPtr ds.w 1 ; Pointer to message that gets drive status
TagBufPtr ds.w 1 ; pointer to 12 byte tag buffer
DataBufPtr ds.w 1 ; pointer to 512 byte data buffer
GCRCkSumA ds.b 1 ; byte A of GCR data checksum
GCRCkSumB ds.b 1 ; byte B of GCR data checksum
GCRCkSumC ds.b 1 ; byte C of GCR data checksum
WrTagBytesA ds.b 4 ; bytes 10, 7, 4, 1 of processed tag bytes
WrTagBytesB ds.b 4 ; bytes 11, 8, 5, 2 of processed tag bytes
WrTagBytesC ds.b 4 ; bytes 12, 9, 6, 3 of processed tag bytes
SectHdrFmtIndex ds.b 1 ; DiskFormat*2 (jump table index)
AdrSearchCountH ds.b 1 ; high byte of address mark search timeout
AdrSearchCountL ds.b 1 ; low byte of address mark search timeout
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
SectHdrChkSumH ds.b 1 ; high byte of Check Sum from sector header
SectHdrChkSumL ds.b 1 ; low byte of Check Sum from sector header
SectHdrHandshake ds.b 1 ; Handshake register after reading last byte
SectHdrError ds.b 1 ; Error register after reading last byte
StepCount ds.b 1 ; Head Step counter for Seek/ReCalibrate
SeekingCylinder ds.b 1 ; cylinder number that we are seeking
SeekingHead ds.b 1 ; head number that we are seeking
SeekDirection ds.b 1 ; seek direction for request, > 0 is forward, < 0 is reverse
SkipBlockToPhys ds.b 1 ; Skip first call to BlockToPhys when <> 0
LogicalBlockH ds.b 1 ; Logical Block number input to BlockToPhysAddr
LogicalBlockL ds.b 1 ; Logical Block number input to BlockToPhysAddr
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
Interleave ds.b 1 ; sector interleave factor
WritingForFmt ds.b 1 ; flag to indicate that write sector data code called from Format
SectorsNeeded ds.b 1 ; number of sectors needed on this track
BaseBufferNum ds.b 1 ; Buffer number for sector 0 of this track
SectBufferNum ds.b 1 ; Buffer number for current sector of this track
TagBlockNumL ds.b 1 ; low byte of running block number for tag writes
TagBlockNumH ds.b 1 ; high byte of running block number for tag writes
BlocksToDoH ds.b 1 ; remaining blocks to read/write (high)
BlocksToDoL ds.b 1 ; remaining blocks to read/write (low)
RecalsLeft ds.b 1 ; number of Recals remaining before hard error
IOErrorsLeft ds.b 1 ; number of I/O errors remaining before Recal
WrongSectsLeft ds.b 1 ; number of wrong sectors remaining before Recal
DMARetryStatus ds.b 1 ; > 0 if ints during DMA took more than xfer time
RawIOFmtMFM ds.b 1 ; $FF if MFM, $00 if GCR, disk format for raw I/O
SwimWriteReg ds.b 2 ; pointer to SWIM reg (usually wData)
LoopCountL ds.b 1 ; low byte of general purpose loop counter
LoopCountH ds.b 1 ; high byte of general purpose loop counter
AsyncPcH ds.b 1 ; saved high byte of PC when waiting asynchronously
AsyncPcL ds.b 1 ; saved low byte of PC when waiting asynchronously
ReadyTMPB ds.b 1 ; timer used for Drive Ready / Sleep delay processing
CacheMRUPtr ds.b 1 ; index of the Most Recently Used Cache Entry
DataBCPB ds.b 1 ; Block Copy Paramater Block for data transfers
DataBCPB2 ds.b 1 ; Block Copy Paramater Block for data transfers
PrevDataBCPB ds.b 1 ; Previous Block Copy Paramater Block for data transfers
CurDataBCPB ds.b 1 ; Current Block Copy Paramater Block for data transfers
TagBCPB ds.b 1 ; Block Copy Paramater Block for tag transfers
TagBCPB2 ds.b 1 ; Block Copy Paramater Block for tag transfers
PrevTagBCPB ds.b 1 ; Previous Block Copy Paramater Block for tag transfers
CurTagBCPB ds.b 1 ; Current Block Copy Paramater Block for tag transfers
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
PollingDriveNum ds.b 1 ; drive currently being polled
MotorTimingOut ds.b 1 ; number of polls to left before turning drive off
ADBActivityMask ds.b 1 ; mask to use to see if ADB deserves time
SectHdrInfo ds.b 5 ; buffer used in formatting, for sector header info
SWIMVarsZSize equ *-SWIMVarsZStart; number of bytes of SWIMVarsZ
endr
seg 'data'
SWIMVars record
SWIMVarsStart equ *
; drive independent variables
OpenStatus ds.b 1 ; Flag indicating Initialization status
PassThruBroken ds.b 1 ; HD20 pass through connector not working
DrivesFound ds.b 1 ; Number of valid disk drives found
CacheEnabled ds.b 1 ; disabled = 0, enabled <> 0
TagBuffHostAddr ds.b 4 ; host address of separate tag buffer
TagBuffEnabled ds.b 1 ; disabled = 0, enabled <> 0
HFSTagAddr ds.b 4 ; host address of HFS tag buffer
HFSTagAddrValid ds.b 1 ; invalid = 0, valid <> 0
PollingEnabled ds.b 1 ; disabled = 0, enabled <> 0
PollingTMPB ds.b 1 ; TMPB index of drive polling task
PollingPcH ds.b 1 ; high byte of PC when waiting for host to post event
PollingPcL ds.b 1 ; low byte of PC when waiting for host to post event
SettledTMPB ds.b 1 ; timer used for Motor speed settled ≈1.5% timing
SettleTimeL ds.b 1 ; low byte of settle time after drive ready
SettleTimeH ds.b 1 ; high byte of settle time after drive ready
ReCalPcH ds.b 1 ; high byte of PC when waiting in ReCalibrate
ReCalPcL ds.b 1 ; low byte of PC when waiting in ReCalibrate
WaitReadyCount ds.b 2 ; timeout counter for WaitDriveReady
EjectPollCount ds.b 1 ; timeout counter for SWIMEject
LastParamSet ds.b 1 ; index if last set of parameters loaded
FmtSearchIndex ds.b 1 ; index into table of formats to search
Sect0CkSum ds.b 1 ; GCR header Checksum for sector zero when formatting
PrefetchActive ds.b 1 ; Cache Prefetching Active when <> 0
RequestPending ds.b 1 ; <> 0 if request received while DriverActive <> 0
CurHeadsPerCyl ds.b 1 ; number of heads per cylinder for current disk
CurSectsPerHead ds.b 1 ; number of sectors per head for current cylinder
PrefetchCachePtr ds.b 1 ; cache index for entry being prefetched
; drive dependent variables
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)
ErrorCountH ds.b NumberOfDrives ; Number of errors (high byte)
ErrorCountL ds.b NumberOfDrives ; Number of errors (low byte)
WriteEnabledFlag equ %10000000 ; disk is not write protected
DriveFlags ds.b NumberOfDrives ; flag bits
; Track Cache variables
CacheNextMRU ds.b MaxCacheEntries ; offset to next Most Recently Used entry
CacheCylinder ds.b MaxCacheEntries ; Cylinder number of cached track
CacheHead ds.b MaxCacheEntries ; Head number of cached track
CacheBufferNum ds.b MaxCacheEntries ; First Buffer number for cached track
CacheInvalidCount ds.b MaxCacheEntries ; Number of entries that need to be read (-1=all)
SWIMVarsSize equ *-SWIMVarsStart ; number of bytes of SWIMVars
endr
title 'IOP SWIM Driver - Request Decode / Dispatching'
seg 'code'
SWIMDriver proc ; SWIM driver requests use MSG 2
entry UnKnownSWIMReq
export HandleRCVMsg2
export SWIMReqDone
entry SWIMReqDecode
entry SWIMReqStart
entry SWIMReqEnd
with SWIMVarsZ
with SWIMVars
HandleRCVMsg2 lda #MessageReceived ; indicate that the message
sta RCVState ; was received
lda #$FF ; indicate driver active
tsb <DriverActive ; mark driver as running, check prior state
bne BusyReturn ; if was active (prefetching), wait until it is done.
trb PrefetchActive ; clear prefetching, see if it was active
beq @PrefetchIdle ; if idle, don't touch the timer
ldy <ReadyTMPB ; get the Ready timer TMPB index
jsr CancelTMPBtimer ; cancel prefetch sleep timer, preventing future prefetches
@PrefetchIdle stz <ADBActivityMask ; give disk priority next time
lda ReqKind ; get the request Kind
cpa #(SWIMReqEnd-SWIMReqStart)/2 ; range check it
bge UnKnownSWIMReq ; if request kind out of range
asl a ; compute the table index
tax ; load the index register
lda OpenStatus ; see if driver has been opened
jmp (SWIMReqDecode,x) ; dispatch to the routine
BusyReturn sta RequestPending ; remember to re-run the request
rts
UnKnownSWIMReq lda #paramErr ; parameter error
SWIMReqDone sta ReqErrorCode+1 ; lower byte of error code
beq ErrHDone ; if noErr
stz <LastActiveDrive ; abnormal completion, force drive change path
bmi ErrNeg ; all errors are negative, and most fit in 1 byte
lda #>gcrOnMfmErr ; except this one, which needs 2 bytes
bra ErrHDone ; store the upper byte
ErrNeg lda #-1 ; sign extend error code
ErrHDone sta ReqErrorCode ; upper byte of error code
lda #MessageCompleted ; message completed state
sta RCVState ; indicate that it is done
stz <DriverActive ; indicate that driver is no longer running
lda #MsgCompletedINT ; get the interrupt bit
sta HostControl ; interrupt the main CPU
rts ; all done
endwith
endwith
endproc
seg 'WordConsts'
SWIMReqDecode proc
entry SWIMReqStart
entry SWIMReqEnd
entry SWIMInitialize
entry SWIMShutDown
entry SWIMStartPolling
entry SWIMStopPolling
entry SWIMSetHFSTagAddr
entry SWIMDriveStatus
entry SWIMEject
entry SWIMFormat
entry SWIMFormatVerify
entry SWIMWrite
entry SWIMRead
entry SWIMReadVerify
entry SWIMCacheControl
entry SWIMTagBufferControl
entry SWIMGetIcon
entry SWIMDiskDupInfo
entry SWIMGetRawData
SWIMReqStart dc.w UnKnownSWIMReq ; $00 - reserved
dc.w SWIMInitialize ; $01 - Initialize
dc.w SWIMShutDown ; $02 - ShutDown
dc.w SWIMStartPolling ; $03 - StartPolling
dc.w SWIMStopPolling ; $04 - StopPolling
dc.w SWIMSetHFSTagAddr ; $05 - SetHFSTagAddr
dc.w SWIMDriveStatus ; $06 - DriveStatus
dc.w SWIMEject ; $07 - Eject
dc.w SWIMFormat ; $08 - Format
dc.w SWIMFormatVerify ; $09 - FormatVerify
dc.w SWIMWrite ; $0A - Write
dc.w SWIMRead ; $0B - Read
dc.w SWIMReadVerify ; $0C - ReadVerify
dc.w SWIMCacheControl ; $0D - CacheControl
dc.w SWIMTagBufferControl; $0E - TagBufferControl
dc.w SWIMGetIcon ; $0F - GetIcon
dc.w SWIMDiskDupInfo ; $10 - DiskDupInfo
dc.w SWIMGetRawData ; $11 - GetRawData
dc.w UnKnownSWIMReq ; $12 - unknown
dc.w UnKnownSWIMReq ; $13 - unknown
dc.w UnKnownSWIMReq ; $14 - unknown
dc.w UnKnownSWIMReq ; $15 - unknown
dc.w UnKnownSWIMReq ; $16 - unknown
dc.w UnKnownSWIMReq ; $17 - unknown
dc.w UnKnownSWIMReq ; $18 - unknown
SWIMReqEnd
endproc
seg 'code'
Unimplemented proc
export HandleDMA2Int
HandleDMA2Int
brk
bra Unimplemented
entry SWIMShutDown
entry SWIMGetIcon
SWIMShutDown ; unimplemented
SWIMGetIcon ; unimplemented
bra UnKnownSWIMReq
endproc
title 'IOP SWIM Driver - SWIM Initialize'
;_______________________________________________________________________
;
; Routine: jmp SWIMInitialize
; Inputs: A - OpenStatus error code
; n, z - status of the OpenStatus flag
; Outputs: none
; Destroys: A, X, Y, n, v, z, c
; Calls: InitSWIMChip, DiskSelect, FindDriveKind, TurnOffDrive
; PollingTask, GetTMPB, GetBCPB
; Called by: SWIM Request Dispatcher
;
; Function: Initializes the IOP based SWIM Driver variables, and
; returns a list of installed drives to the Host processor.
;
;_______________________________________________________________________
seg 'code'
SWIMInitialize proc
entry PollingTask
with SWIMVarsZ
with SWIMVars
eor #openErr ; check for already open
bne InitErr ; return error if already initialized
lda #BYPASS ; prepare to turn off bypass mode
trb SCCControlReg ; let IOP control the SWIM chip now
ldx #SWIMVarsZSize ; size of page zero globals space
InitVarsZloop dex ; dec loop counter / index
stz <SWIMVarsZStart,x ; zero a byte
bne InitVarsZloop ; initialize all of the bytes
ldx #SWIMVarsSize ; size of globals space
InitVarsloop dex ; dec loop counter / index
stz SWIMVarsStart,x ; zero a byte
bne InitVarsloop ; initialize all of the bytes
; Initialize the TagPtrs array to point to the corresponding TagBuffers entry
with SectorBuffers
lda #((TagBuffers-SectorBuffers)+TotalBuffers*TagSize)/2
ldx #TotalBuffers-1 ; loop count/index
@tagPtrLoop sec ; setup for subtract
sbc #TagSize/2 ; point to previous buffer
sta TagPtrs,x ; initialize the pointer
dex ; update index
bpl @tagPtrLoop ; loop for each buffer
endwith
ldx #<RCVData ; get low byte of RCV / XMT Data address
stx <StatusMsgPtr ; initialize low byte of status message pointer
ldx #<wData ; get low byte of SWIM wData reg
stx <SwimWriteReg ; initialize low byte of SWIM Write Reg pointer
ldx #>wData ; get high byte of SWIM wData reg
stx <SwimWriteReg+1 ; initialize high byte of SWIM Write Reg pointer
* stz <CurrentDrive ; initialize CurrentDrive to default invalid drive
jsr InitSWIMChip ; initialize the chip
beq InitCheckConfig ; check configuration if chip initialized
ldx #openErr ; not opened status value
stx OpenStatus ; indicate not opened yet (in case of error)
InitErr jmp SWIMReqDone ; return with error status
InitCheckConfig jsr GetTMPB ; get a TiMer Parameter Block
sty <ReadyTMPB ; timer used for Drive Ready / Sleep delay processing
jsr GetTMPB ; get a TiMer Parameter Block
sty SettledTMPB ; timer used for Motor speed settled ≈1.5% timing
jsr GetTMPB ; get a TiMer Parameter Block
sty PollingTMPB ; timer used for Motor timeout/Insert/Eject polling
jsr GetBCPB ; get a Block Copy Parameter Block
sty <DataBCPB ; Block Copy Paramater Block for data transfers
jsr GetBCPB ; get a Block Copy Parameter Block
sty <DataBCPB2 ; Block Copy Paramater Block for data transfers
jsr GetBCPB ; get a Block Copy Parameter Block
sty <TagBCPB ; Block Copy Paramater Block for tag transfers
jsr GetBCPB ; get a Block Copy Parameter Block
sty <TagBCPB2 ; Block Copy Paramater Block for tag transfers
; if the HD-20 pass through connector is not working, then there will appear
; to be an infinate number of HD-20s connected (really, the first one that
; doesn't pass-through will be continually addressed)
; stz PassThruBroken ; initialize PassThru flag, assume it works
ldx #MaxDriveNumber+5 ; a large drive number
jsr DiskSelect ; try to select it
jsr FindDriveKind ; see what kind of drive we find
cpa #HD20DriveKind ; see if it's an HD-20
bne PassThruWorks ; if its not an HD-20, then the pass thru works
dec PassThruBroken ; it was an HD-20, pass thru must be broke.
PassThruWorks
* stz DrivesFound ; no drives found yet
FloppyLoop ldx <CurrentDrive ; get the drive number
jsr DiskSelect ; attempt to select the drive
beq NextFloppy ; if drive couldn't be selected
jsr FindDriveKind ; see what kind of drive we found
cpa #SSGCRDriveKind+1 ; see if it's a floppy drive we support
blt NextFloppy ; ignore noDrive, unknown, and 400K drives
cpa #HD20DriveKind ; ignore HD20s too
beq NextFloppy ; if HD20
inc DrivesFound ; found a live one, count it
ldx DrivesFound ; get the count
sta DriveKind,x ; record the drive kind
lda <CurrentDrive ; get the physical drive number
sta PhysDriveNumber,x ; record it
NextFloppy inc <CurrentDrive ; go onto next drive
lda <CurrentDrive ; prepare to test for end
cpa #FirstHD20DriveNumber ; see if past the range of floppies
blt FloppyLoop ; loop through all floppy drive numbers
HD20Loop ldx <CurrentDrive ; get the drive number
jsr DiskSelect ; attempt to select the drive
beq NextHD20 ; if drive couldn't be selected
jsr FindDriveKind ; see what kind of drive we found
cpa #HD20DriveKind ; look for HD20s
bne NextHD20 ; if HD20
inc DrivesFound ; found a live one, count it
ldx <CurrentDrive ; get the drive number
sta DriveKind,x ; record the drive kind
txa ; get the physical drive number
sta PhysDriveNumber,x ; record it
NextHD20 inc <CurrentDrive ; go onto next drive
lda <CurrentDrive ; prepare to test for end
cpa #MaxDriveNumber+1 ; see if past the range of HD20s
blt HD20Loop ; loop through all HD20 drive numbers
jsr TurnOffDrive ; de-select all drives
ldx #28-1 ; return 28 bytes of drive kinds
DriveKindsLoop lda #noDriveKind ; assume no drive
cpx #NumberOfDrives ; see if in range of drives supported
bge ReturnDriveKind ; use default if out of range
lda DriveKind,x ; get the drive kind
ReturnDriveKind sta ReqDriveKinds,x ; return the drive kind
dex ; dec count / index
bpl DriveKindsLoop ; loop through all possible drives
lda #noErr ; return no error
* sta OpenStatus ; indicate successful Initialization (noErr)
jsr SWIMReqDone ; let the HOST know we're done
jmp PollingTask ; start the polling task
export InitSWIMDrvr
InitSWIMDrvr lda #openErr ; not opened status value
sta OpenStatus ; indicate not opened yet
rts
endwith
endwith
endproc
title 'IOP SWIM Driver - SWIM Drive Status'
;_______________________________________________________________________
;
; Routine: jmp SWIMDriveStatus
; Inputs: A - OpenStatus error code
; n, z - status of the OpenStatus flag
; Outputs: none
; Destroys: A, X, Y, n, z, c
; Calls: GetDriveStatus
; Called by: SWIM Request Dispatcher, SWIMEject, SWIMFormat
;
; Function: Returns the drive / media status information for the
; drive specified in the Drive Status request message
; returns a list of installed drives to the Host processor.
;
;_______________________________________________________________________
seg 'code'
SWIMDriveStatus proc
bne StatusDone ; return openErr if SWIM Driver not initialized
lda #nsDrvErr ; return no such drive error if out of range
ldx ReqDriveNumber ; see what drive is requested
cpx #MaxDriveNumber+1 ; see if in range
bge StatusDone ; return nsDrvErr if out of range
lda #>ReqDriveStatus ; get page number of status message buffer
jsr GetDriveStatus ; get the status
lda #noErr ; indicate successful completion
StatusDone jmp SWIMReqDone ; let the HOST know we're done
endproc
title 'IOP SWIM Driver - SWIM Disk Duplicator Info'
;_______________________________________________________________________
;
; Routine: jmp SWIMDiskDupInfo
; Inputs: A - OpenStatus error code
; n, z - status of the OpenStatus flag
; Outputs: none
; Destroys: A, n, z
; Calls: none
; Called by: SWIM Request Dispatcher
;
; Function: Returns the Disk Duplicator Version number, and the format byte
; for the last sector that was read.
;
;_______________________________________________________________________
seg 'code'
SWIMDiskDupInfo proc
with SWIMVarsZ
bne DupInfoDone ; return openErr if SWIM Driver not initialized
lda #>$0410 ; Current Version is 4.1
sta ReqDupVersion+0 ; upper byte of version
lda #<$0410 ; get low byte
sta ReqDupVersion+1 ; lower byte of version
lda <SectHdrFmtKind ; get the Format Kind / Block Size from sector header
sta ReqHdrFmtKind ; return the Format Kind from the last sector hdr
lda #noErr ; indicate successful completion
DupInfoDone jmp SWIMReqDone ; let the HOST know we're done
endwith
endproc
title 'IOP SWIM Driver - SWIM Cache Control'
;_______________________________________________________________________
;
; Routine: jmp SWIMCacheControl
; Inputs: A - OpenStatus error code
; n, z - status of the OpenStatus flag
; Outputs: none
; Destroys: A, X, Y, n, v, z, c
; Calls: FlushIfDisabled
; Called by: SWIM Request Dispatcher
;
; Function: Enables / Disables the track cache.
;
;_______________________________________________________________________
seg 'code'
SWIMCacheControl proc
with SWIMVars
bne CacheError ; return openErr if SWIM Driver not initialized
jsr FlushIfDisabled ; Need to flush if going from disabled to enabled
stz CacheEnabled ; assume disabled
ldx ReqAdditionalParams+1 ; get install flag
bmi CacheDone ; disable cache if remove request
ldx ReqAdditionalParams+0 ; get enable flag
stx CacheEnabled ; update enable flag
CacheDone lda #noErr ; indicate successful completion
CacheError jmp SWIMReqDone ; let the HOST know we're done
endwith
endproc
title 'IOP SWIM Driver - SWIM Set HFS Tag Addr'
;_______________________________________________________________________
;
; Routine: jmp SWIMSetHFSTagAddr
; Inputs: A - OpenStatus error code
; n, z - status of the OpenStatus flag
; Outputs: none
; Destroys: A, X, n, z
; Calls: none
; Called by: SWIM Request Dispatcher
;
; Function: Sets the HOST address of the HFS tag buffer area.
;
;_______________________________________________________________________
seg 'code'
SWIMSetHFSTagAddr proc
with SWIMVars
bne HFStagDone ; return openErr if SWIM Driver not initialized
stz HFSTagAddrValid ; initialize enable flag
ldx #3 ; loop counter / index
loop lda ReqRAMAddress,x ; get buffer address
sta HFSTagAddr,x ; update buffer address
tsb HFSTagAddrValid ; update enable flag
dex ; point to previous byte
bpl loop ; loop through all bytes
lda #noErr ; indicate successful completion
HFStagDone jmp SWIMReqDone ; let the HOST know we're done
endwith
endproc
title 'IOP SWIM Driver - SWIM Tag Buffer Control'
;_______________________________________________________________________
;
; Routine: jmp SWIMTagBufferControl
; Inputs: A - OpenStatus error code
; n, z - status of the OpenStatus flag
; Outputs: none
; Destroys: A, X, n, z
; Calls: none
; Called by: SWIM Request Dispatcher
;
; Function: Enables / Disables a separate tag buffer.
;
;_______________________________________________________________________
seg 'code'
SWIMTagBufferControl proc
with SWIMVars
bne TagBufferDone ; return openErr if SWIM Driver not initialized
stz TagBuffEnabled ; initialize enable flag
ldx #3 ; loop counter / index
loop lda ReqAdditionalParams,x ; get buffer address
sta TagBuffHostAddr,x ; update buffer address
tsb TagBuffEnabled ; update enable flag
dex ; point to previous byte
bpl loop ; loop through all bytes
lda #noErr ; indicate successful completion
TagBufferDone jmp SWIMReqDone ; let the HOST know we're done
endwith
endproc
title 'IOP SWIM Driver - SWIM Start Polling'
;_______________________________________________________________________
;
; Routine: jmp SWIMStartPolling
; Inputs: A - OpenStatus error code
; n, z - status of the OpenStatus flag
; Outputs: none
; Destroys: A, n, z
; Calls: None
; Called by: SWIM Request Dispatcher
;
; Function: Indicates that Disk Insert/Eject polling should be enabled.
;
;_______________________________________________________________________
seg 'code'
SWIMStartPolling proc
with SWIMVars
bne StartPollDone ; return openErr if SWIM Driver not initialized
dea ; indicate that Insert/Eject polling is enabled
sta PollingEnabled ; set enable to $FF
lda #noErr ; indicate successful completion
StartPollDone jmp SWIMReqDone ; let the HOST know we're done
endwith
endproc
title 'IOP SWIM Driver - SWIM Start Polling'
;_______________________________________________________________________
;
; Routine: jmp SWIMStopPolling
; Inputs: A - OpenStatus error code
; n, z - status of the OpenStatus flag
; Outputs: none
; Destroys: A, n, z
; Calls: None
; Called by: SWIM Request Dispatcher
;
; Function: Indicates that Disk Insert/Eject polling should be disabled.
;
;_______________________________________________________________________
seg 'code'
SWIMStopPolling proc
with SWIMVars
bne StopPollDone ; return openErr if SWIM Driver not initialized
stz PollingEnabled ; indicate that Insert/Eject polling is disabled
* lda #noErr ; indicate successful completion
StopPollDone jmp SWIMReqDone ; let the HOST know we're done
endwith
endproc
title 'IOP SWIM Driver - SWIM Polling Task'
;_______________________________________________________________________
;
; Routine: jmp PollingTask
; Inputs: A - OpenStatus error code
; n, z - status of the OpenStatus flag
; Outputs: none
; Destroys: A, X, Y, n, v, z, c
; Calls: StartTMPBTimer, WaitTMPBdone, PrefetchIntoCache, TurnOffDrive,
; DiskSelect, AdrAndSense, AdrAndStrb, CheckStaticAttr,
; GetDriveStatus
; Called by: SWIMInitialize
;
; 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.
; Starts prefetching data when the motor timeout is half expired.
;
;_______________________________________________________________________
seg 'code'
PollingTask proc
entry PrefetchIntoCache
with SWIMVarsZ
with SWIMVars
ldy PollingTMPB ; get the TMPB index
lda #>PollRate ; get high byte of poll rate
sta TMPBtimeH,y ; store it into the TMPB
lda #<PollRate ; get low byte of poll rate
sta TMPBtimeL,y ; store it into the TMPB
jsr StartTMPBTimer ; start the timer
ldy PollingTMPB ; get the TMPB index
jsr WaitTMPBdone ; wait for it to time out
; when the timer runs out, we will wake up and snoop around
lda <DriverActive ; see if driver is active
bne PollingTask ; skip poll if active
lda <MotorTimingOut ; see if timing out a drive motor
beq PollDrives ; not timing out, do the poll
cpa #((MotorTimeoutCount+1)/2)+1 ; see if half left
bne @noPrefetch ; start prefetching at half way point
jsr PrefetchIntoCache ; prefetch into the cache while idle
@noPrefetch dec <MotorTimingOut ; decrement the timeout counter
bne PollingTask ; exit if count not expired
jsr TurnOffDrive ; it is time to turn off the drive motor
PollDrives ldx #0 ; initial drive number
PollDriveLoop ldy DriveKind,x ; get the drive kind
beq PollNextDrive ; skip it if not installed
stx <PollingDriveNum ; save drive number
lda MediaKind,x ; see if any media in drive
beq PollDiskInPlace ; no media, check for disk inserted
jmp PollEjectSwitch ; there is a disk, see if eject pressed
PollDiskInPlace lda PhysDriveNumber,x ; get the physical drive number
tax ; setup drive number for DiskSelect
cpy #HD20DriveKind ; check for HD-20 (special case)
beq PollHD20InPlace ; if HD-20
jsr DiskSelect ; select the drive
ldx <PollingDriveNum ; restore drive number
lda #rNoDiskInPlAdr ; prepare to test for disk in place
jsr AdrAndSense ; read the status bit
bne ThisPollDone ; if still no disk in place
lda #wNoDiskInPlAdr ; make it look like the disk ejected
jsr AdrAndStrb ; to reset the eject latch
jsr CheckStaticAttr ; check the media kind and write protect
PostDiskInPlace lda #DiskInsertedXmtReq ; post the inserted event
jsr PostEvent ; send it to the host
beq EventPosted ; all done if not error
ldx <PollingDriveNum ; restore drive number
stz MediaKind,x ; indicate NoMediaKind if couldn't mount
EventPosted lda <DriverActive ; see if driver is active
bne PollingExit ; exit poll if active
ThisPollDone ldx <PollingDriveNum ; restore drive number
PollNextDrive inx ; point to next
cpx #NumberOfDrives ; compare to limit
blt PollDriveLoop ; loop through all drives
PollingExit jsr DeselectDrives ; deselect both drives
jmp PollingTask ; keep on polling
PollHD20InPlace jsr DiskSelect ; select the drive
ldx <PollingDriveNum ; restore drive number
lda #rMotorOffAdr ; prepare to test /busy
jsr AdrAndSense ; read the status bit
beq ThisPollDone ; if /busy = 0, don't post event
lda #HD20MediaKind ; indicate HD-20 media in drive
sta MediaKind,x ; update media kind
lda #HD20Format ; indicate HD-20 format
sta DiskFormat,x ; update format kind
lda DriveFlags,x ; get the flags
ora #WriteEnabledFlag ; force write enabled
sta DriveFlags,x ; update flags
bra PostDiskInPlace ; post the event
PollEjectSwitch lda DriveKind,x ; see what kind of drive we have
cpa #HD20DriveKind ; check for HD-20 (special case)
beq ThisPollDone ; if HD-20, can't eject, so don't check
cpa #SSGCRDriveKind ; check for 400K drive (special case)
beq ThisPollDone ; if 400K drive, can't eject, so don't check
lda PhysDriveNumber,x ; get the physical drive number
tax ; setup drive number for DiskSelect
jsr DiskSelect ; select the drive
lda #rEjectOnAdr ; prepare to test for eject latch set
jsr AdrAndSense ; read the status bit
beq ThisPollDone ; if latch not set (eject button hadn't been pushed)
lda #wNoDiskInPlAdr ; make it look like the disk ejected
jsr AdrAndStrb ; to reset the eject latch
lda #DiskEjectedXmtReq ; post the dismount event
jsr PostEvent ; send it to the host (ignore errors)
bra EventPosted ; keep on polling
PostEvent ldy PollingEnabled ; see if polling is enabled
beq DeselectDrives ; if not, don't post any events, return noErr
ply ; pop pcL
sty PollingPcL ; save pcL
ply ; pop pcH
sty PollingPcH ; save pcH
sta XmtKind ; store the command kind
stx XmtDriveNumber ; store the drive number
lda #>XmtDriveStatus ; get page number of status message buffer
jsr GetDriveStatus ; return the drive status
lda #NewMessageSent ; get the new message state
sta XMTState ; set the new message state
lda #NewMsgSentINT ; prepare to interrupt the host
sta HostControl ; interrupt the host
DeselectDrives lda #StartAction+WriteMode ; prepare to clear action and write mode
sta wZeroes ; clear action and write mode (prepare for motoroff)
lda #MotorOn+Drive1Enabled+Drive2Enabled ; prepare to disable the drive
sta wZeroes ; reset MotorOn and Enables, disabling all drives
rts ; return to callers caller
export HandleXmtMsg2 ; resume when Host is done
HandleXmtMsg2 lda #Idle ; Indicate that response was received
sta XMTState ; set the new message state
lda PollingPcH ; get pcH
pha ; push pcH
lda PollingPcL ; get pcL
pha ; push pcL
lda XmtErrorCode ; get the high byte of the error code
ora XmtErrorCode+1 ; or with low byte (to test for non-zero)
rts ; return to polling loop
endwith
endwith
endproc
title 'IOP SWIM Driver - SWIM Eject'
;_______________________________________________________________________
;
; Routine: jmp SWIMEject
; Inputs: A - OpenStatus error code
; n, z - status of the OpenStatus flag
; Outputs: none
; Destroys: A, X, Y, n, v, z, c
; Calls: SetUpDrive, Seek, ReCalibrate, WaitDriveReady, DiskSelect. AdrAndStrb,
; SleepLong, AdrAndSense, SleepShort, TurnOffDrive, SWIMDriveStatus
; Called by: SWIM Request Dispatcher
;
; Function: Ejects the disk in the specified drive
;
;_______________________________________________________________________
seg 'code'
SWIMEject proc
with SWIMVarsZ
with SWIMVars
bne EjectError ; return if errors found
jsr SetUpDrive ; select and power up the disk drive
beq EjectSeek ; if no error in SetUp
cpa #OffLinErr ; see if there is a disk to eject
beq 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
cpa #nsDrvErr ; return no such drive error if out of range
beq EjectError ; report drive number errors
cpa #noDriveErr ; return no drive error if drive not installed
bne EjectDiskette ; if any other error, skip seek, just eject
EjectError tax ; set flags based upon error code
jmp SWIMReqDone ; let the HOST know we're done
EjectSeek ldy #LastCylinder ; position head to last cylinder before eject
jsr Seek ; to prevent major data loss if heads damage media
beq EjectDiskette ; if seek was ok, eject the disk
jsr ReCalibrate ; try to recalibrate if seek failed
bne EjectDiskette ; if couldn't recalibrate, forget about seeking
ldy #LastCylinder ; position head to last cylinder before eject
jsr Seek ; one last attempt at seeking
EjectDiskette jsr WaitDriveReady ; wait for motor speed and heads to settle
; Re-Enable the drive, in case it was disabled by an error.
ldy ReqDriveNumber ; see what drive is requested
ldx PhysDriveNumber,y ; get the new physical drive number
jsr DiskSelect ; select and enable the new drive
lda #wMotorOffAdr ; motor off drive command
jsr AdrAndStrb ; turn off the drive motor
lda #<MotorStopDelay ; low byte of delay time
ldx #>MotorStopDelay ; high byte of delay time
jsr SleepLong ; sleep until disk stops spinning
lda #wEjectOnAdr ; eject disk drive command
jsr AdrAndStrb ; start the eject process
lda #EjectTimeoutCount ; max number of polls
sta EjectPollCount ; setup polling counter
EjectPollLoop lda #<EjectPollRate ; low byte of delay time
ldx #>EjectPollRate ; high byte of delay time
jsr SleepLong ; sleep waiting for disk to eject
lda #rNoDiskInPlAdr ; prepare to see if disk is out
jsr AdrAndSense ; read the drive status bit
bne EjectOut ; disk is out, wait for things to settle
dec EjectPollCount ; decrement poll timeout counter
bne EjectPollLoop ; loop if more polls left
EjectOut lda #<EjectSettleDelay ; delay before killing enable
jsr SleepShort ; wait the specified amount of time
ldx <CurrentDrive ; get the drive number
stz MediaKind,x ; indicate NoMediaKind
stz DiskFormat,x ; indicate uncheckedFormat
stz DriveFlags,x ; clear all flags
stz <LastActiveDrive ; indicate drive state is unknown
jsr TurnOffDrive ; disable the drive
lda #noErr ; indicate success
jmp SWIMDriveStatus ; finish up by returning the drive status
endwith
endwith
endproc
title 'IOP SWIM Driver - SWIM Read / ReadVerify'
;_______________________________________________________________________
;
; Routine: jmp SWIMRead / SWIMReadVerify
; Inputs: A - OpenStatus error code
; n, z - status of the OpenStatus flag
; Outputs: none
; Destroys: A, X, Y, n, v, z, c
; Calls: SetUpDrive, ReadWriteSetUp, WaitBCPBdone, SetupTrackInfo,
; UpdateTagInfo, UpdateDataInfo, UpdateBlockInfo, WaitDriveReady,
; Seek, ReadSectorHdr, ReadSectorData, MakeBCPBreq, ReCalibrate,
; SkipSectorData
; Called by: SWIM Request Dispatcher
;
; Function: Reads data from the specified drive, at the specified
; block number, and transfers or compares the data to the host.
;
;_______________________________________________________________________
seg 'code'
SWIMRead proc
entry SWIMReadVerify
entry ReadWriteSetUp
entry SetupTrackInfo
entry UpdateTagInfo
entry UpdateDataInfo
entry UpdateBlockInfo
with SWIMVarsZ
with SWIMVars
with SectorBuffers
SWIMReadVerify jsr SetUpDrive ; select and power up the disk drive
bne ReadError ; if error powering up
ldx <CacheMRUPtr ; get index of MRU entry
lda CacheNextMRU,x ; get index of next (if any)
asl a ; single buffer if next entry is nil
jsr ReadWriteSetUp ; get the paramaters, and setup data structures
beq ReadTrackLoop ; if no errors, start reading
ReadDone ldy <PrevTagBCPB ; get the prior tag copy request
bmi @TagXferDone ; skip it if not enabled
jsr WaitBCPBdone ; wait for buffer to be free before returning
ldy <CurTagBCPB ; get the current tag copy request
jsr WaitBCPBdone ; wait for buffer to be free before returning
@TagXferDone
ldy <PrevDataBCPB ; get the prior data copy request
jsr WaitBCPBdone ; wait for buffer to be free before returning
ldx BCPBcompRel,y ; see if it compared ok
beq @prevOK ; of so, leave error code alone
lda #dataVerErr ; indicate compare failed
@prevOK ldy <CurDataBCPB ; get the current data copy request
jsr WaitBCPBdone ; wait for buffer to be free before returning
ldx BCPBcompRel,y ; see if it compared ok
beq @curOK ; of so, leave error code alone
lda #dataVerErr ; indicate compare failed
@curOK tax ; set flags based on error code
ReadError jmp SWIMReqDone ; return the error
; Read the data looping through each track of the request
ReadTrackLoop jsr SetupTrackInfo ; find the track address and cache buffers
bcs ReadDone ; if none left, or error, request is complete
; Update the TAG data transfer addresses and counts
ldy <PrevTagBCPB ; get the prior tag copy request
bmi @skipTagXfer ; if not enabled, skip it to save time
jsr WaitBCPBdone ; wait for buffer to be free before re-using it
jsr UpdateTagInfo ; update the TAG data transfer addresses and counts
@skipTagXfer
; Update the DATA data transfer addresses and counts
ldy <PrevDataBCPB ; get the prior data copy request
jsr WaitBCPBdone ; wait for buffer to be free before re-using it
ldx BCPBcompRel,y ; get the compare relation (0 means equal)
bne ReadDone ; return with error if compared not equal
jsr UpdateDataInfo ; update the DATA data transfer addresses and counts
; Update the DISK block addresses and counts
jsr UpdateBlockInfo ; update the DISK block addresses and counts
; Update the Buffer Status for each sector and check for cache hits
ldy <SectorsNeeded ; setup loop counter
ldx <SectBufferNum ; starting buffer number
@sectorLoop lda BufferStatus,x ; get the status for this sector buffer
assert ReadDataValid=$80 ; sign bit is valid bit
bmi @cacheHit ; if cache hit, no need to read it in
@NeedsRead ora #IORequested ; indicate the Read Request
sta BufferStatus,x ; update the buffer status
bra @nextSector ; go on to the next sector
@cacheHit ; x = last buffer number for tag copy at ReadXfer
dec <SectorsNeeded ; since it is a hit, we don't need to read it
beq ReadXfer ; if all sectors hit in the cache, skip the read
@nextSector inx ; update buffer number
dey ; decrement loop count
bne @sectorLoop ; loop through all sectors of the request
; Seek to the requested cylinder
lda #RecalsMax ; Max Recals allowed before hard error
sta <RecalsLeft ; number of Recals remaining before hard error
SeekToCyl jsr WaitDriveReady ; wait for motor speed and heads to settle
bne RecalAndRetry ; if error powering up
lda <PhysHead ; get the head we want
sta <SeekingHead ; pass it to ReadSectorHdr
ldy <PhysCylinder ; get the cylinder number
jsr Seek ; Seek to the requested cylinder
lda #IOErrorsMax ; Max I/O errors allowed before Recal
sta <IOErrorsLeft ; number of I/O errors remaining before Recal
jsr WaitDriveReady ; wait for the seek to complete
bne RecalAndRetry ; if error seeking, try to recal
; Read the sectors requested for this track
ReadHeader lda #WrongSectsMax ; successful read, re-init Wrong Sector Count
sta <WrongSectsLeft ; number of wrong sectors remaining before Recal
ReadAfterSkip jsr ReadSectorHdr ; read the next sector header that comes along
bcs ReadAddrError ; handle sector address errors
assert ReadDataValid=$80 ; sign bit is valid bit
assert IORequested=$40 ; overflow bit is requested bit
bvc ReadIntoCache ; if not requested, just fill the cache
jsr ReadSectorData ; read the data into IOP memory
bne ReadDataError ; if I/O error, handle sector data errors
ldx <CacheMRUPtr ; get index to current cache entry
dec CacheInvalidCount,x ; decrement the invalid entry count
ldx <SectBufferNum ; get the buffer number for this sector
assert (IORequested<<1)=ReadDataValid
asl BufferStatus,x ; set ReadDataValid, clear IORequested
dec <SectorsNeeded ; account for this sector
bne ReadHeader ; if more to go, keep reading
; Transfer the data for this track to the Host buffer
ReadXfer ; x = the last buffer number transferred
lda TagPtrs,x ; get the tag buffer pointer for this sector
asl a ; unpack 9th bit into carry
sta <TagBufPtr ; setup low byte of tag pointer
lda #0 ; setup to add in tag addr carry
adc #>TagBuffers ; add in starting page of tag buffers
sta <TagBufPtr+1 ; setup page number
ldy #TagSize-1 ; index / loop counter
@TagCopyLoop lda (<TagBufPtr),y ; get tag byte from tag buffer
sta ReqMfsTagData,y ; return the last tag read in the message
dey ; update index / count
bpl @TagCopyLoop ; loop through all of the bytes
ldy <CurDataBCPB ; the the BCPB index
jsr MakeBCPBreq ; issue the copy request
ldy <CurTagBCPB ; the the BCPB index
bmi @TagXferDone ; skip it if not enabled
jsr MakeBCPBreq ; issue the copy request
@TagXferDone jmp ReadTrackLoop ; transfer the data, continue with the next track
; Load the cache with sectors that were not part of the request
ReadIntoCache bmi SkipSector ; if already in cache, skip it
jsr ReadSectorData ; read the data into the cache buffer
bne IgnoreData ; if error, don't validate it, just skip it
ldx <CacheMRUPtr ; get index to current cache entry
dec CacheInvalidCount,x ; decrement the invalid entry count
ldx <SectBufferNum ; get the buffer number for this sector
lda #ReadDataValid ; mark the cache entry valid
sta BufferStatus,x ; set ReadDataValid, clear IORequested
IgnoreData dec <WrongSectsLeft ; adjust count of sectors searched
bpl ReadAfterSkip ; if count not exhausted, keep on reading
lda #sectNFErr ; assume sector not found
RecalAndRetry dec <RecalsLeft ; see if RecalsMax exceeded
bmi ToReadDone ; if too many retrys, die with hard error
jsr ReCalibrate ; move heads to track zero, init the drive
beq SeekToCyl ; if Recal OK, retry seek
ToReadDone jmp ReadDone ; if Recal failed, die with hard error
; Error handling and recovery
ReadAddrError beq SkipSector ; if sect num out of range, just ignore it
cpa #SeekErr ; see if it was a seek error
beq RecalAndRetry ; if so, recal, and then retry
DataError ldx <CurrentDrive ; get current drive number
inc ErrorCountL,x ; update the soft error count for this drive
bne @ErrorCountDone ; if no carry, skip high byte
inc ErrorCountH,x ; update the high byte of the error count
@ErrorCountDone dec <IOErrorsLeft ; number of I/O errors remaining before Recal
bmi RecalAndRetry ; if too many I/O errors, recal and try again
bra ReadHeader ; if more to go, keep reading
ReadDataError cpa <DMARetryStatus ; see if it was a DMA timeout error
beq IgnoreData ; if so, just re-try it without ints during DMA
cpa #<gcrOnMfmErr ; see if GCR data on High Density Disk
bne DataError ; if real I/O error, handle sector data errors
bra ToReadDone ; if GCR on MFM, don't waste time retrying
SkipSector jsr SkipSectorData ; give ADB some time
bra IgnoreData ; ignore this sector
endwith
endwith
endwith
endproc
title 'IOP SWIM Driver - SWIM Write'
;_______________________________________________________________________
;
; Routine: jmp SWIMWrite
; Inputs: A - OpenStatus error code
; n, z - status of the OpenStatus flag
; Outputs: none
; Destroys: A, X, Y, n, v, z, c
; Calls: SetUpDrive, ReadWriteSetUp, SetupTrackInfo,
; UpdateTagInfo, UpdateDataInfo, UpdateBlockInfo, MakeBCPBreq,
; WaitDriveReady, WaitMotorSettled, Seek, WaitBCPBdone, ReadSectorHdr,
; WriteSectorData, ReadSectorData, ReCalibrate, SkipSectorData
; Called by: SWIM Request Dispatcher
;
; Function: Write data to the specified drive, at the specified
; block number, and transfers data from the host.
;
;_______________________________________________________________________
seg 'code'
SWIMWrite proc
entry ReadWriteSetUp
entry SetupTrackInfo
entry UpdateTagInfo
entry UpdateDataInfo
entry UpdateBlockInfo
with SWIMVarsZ
with SWIMVars
with SectorBuffers
stz <WritingForFmt ; we are not writing for format
jsr SetUpDrive ; select and power up the disk drive
bne WriteError ; if error powering up
ldx <CurrentDrive ; get drive number
lda #WriteEnabledFlag ; prepare to test write enable
bit DriveFlags,x ; test the enable bit
beq WriteProtected ; if write protected, return the error
sec ; single buffer only
jsr ReadWriteSetUp ; get the paramaters, and setup data structures
beq WriteTrackLoop ; if no errors, start the write request
WriteDone tax ; set flags based on error code
WriteError jmp SWIMReqDone ; return the error
WriteProtected lda #wPrErr ; indicate write protected disk
bra WriteError ; return the error
; Write the data looping through each track of the request
WriteTrackLoop jsr SetupTrackInfo ; find the track address and cache buffers
bcs WriteDone ; if none left, or error, request is complete
; Update the DATA data transfer addresses and counts
ldy <PrevDataBCPB ; get the prior data copy request
jsr UpdateDataInfo ; update the DATA data transfer addresses and counts
jsr MakeBCPBreq ; issue the copy request
; Update the DISK block addresses and counts
jsr UpdateBlockInfo ; update the DISK block addresses and counts
; Update the Buffer Status for each sector
lda <SectorsNeeded ; setup loop counter
sta <LoopCountL ; initialize loop counter
ldx <SectBufferNum ; starting buffer number
bra @loopStart ; skip the tag block increment the first time
@sectorLoop inc ReqMfsTagData+7 ; increment tag block number (low byte)
bne @loopStart ; if no carry out
inc ReqMfsTagData+6 ; increment tag block number (high byte)
@loopStart lda BufferStatus,x ; get the status for this sector buffer
assert ReadDataValid=$80 ; sign bit is valid bit
bpl @setupTag ; if already invalid, don't need to invalidate
txa ; preserve x
ldx <CacheMRUPtr ; get index to current cache entry
inc CacheInvalidCount,x ; increment the invalid entry count
tax ; restore x
@setupTag lda TagPtrs,x ; get the tag buffer pointer for this sector
asl a ; unpack 9th bit into carry
sta <TagBufPtr ; remember it for the tag copy
lda #0 ; setup to add in tag addr carry
adc #>TagBuffers ; add in starting page of tag buffers
sta <TagBufPtr+1 ; setup page number
ldy #TagSize-1 ; index / loop counter
@TagCopyLoop lda ReqMfsTagData,y ; setup the tag from the message request
sta (<TagBufPtr),y ; store the tags into the tag buffer
dey ; update index / count
bpl @TagCopyLoop ; loop through all of the bytes
lda #IORequested ; indicate the Write Request, clear valid flag
sta BufferStatus,x ; update the buffer status
@nextSector inx ; update buffer number
dec <LoopCountL ; decrement loop count
bne @sectorLoop ; loop through all sectors of the request
; Update the TAG data transfer addresses and counts
ldy <PrevTagBCPB ; get the prior tag copy request
bmi @skipTagXfer ; if not enabled, skip it to save time
jsr UpdateTagInfo ; update the TAG data transfer addresses and counts
jsr MakeBCPBreq ; issue the copy request
@skipTagXfer
; Seek to the requested cylinder
lda #RecalsMax ; Max Recals allowed before hard error
sta <RecalsLeft ; number of Recals remaining before hard error
SeekToCyl jsr WaitDriveReady ; wait for motor speed and heads to settle
bne RecalAndRetry ; if error powering up
jsr WaitMotorSettled ; wait for motor speed to be in 1.5% tolerance
lda <PhysHead ; get the head we want
sta <SeekingHead ; pass it to WriteSectorHdr
ldy <PhysCylinder ; get the cylinder number
jsr Seek ; Seek to the requested cylinder
; Transfer the data for this track from the Host buffer
ldy <CurDataBCPB ; get the DATA BCPB index
jsr WaitBCPBdone ; wait for the data to arrive
ldy <CurTagBCPB ; get the TAG BCPB index
bmi @TagXferDone ; skip it if not enabled
jsr WaitBCPBdone ; wait for the data to arrive
@TagXferDone
lda #IOErrorsMax ; Max I/O errors allowed before Recal
sta <IOErrorsLeft ; number of I/O errors remaining before Recal
jsr WaitDriveReady ; wait for the seek to complete
bne RecalAndRetry ; if error seeking, try to recal
; Write the sectors requested for this track
ReadHeader lda #WrongSectsMax ; successful write, re-init Wrong Sector Count
sta <WrongSectsLeft ; number of wrong sectors remaining before Recal
ReadAfterSkip jsr ReadSectorHdr ; read the next sector header that comes along
bcs ReadAddrError ; handle sector address errors
assert ReadDataValid=$80 ; sign bit is valid bit
assert IORequested=$40 ; overflow bit is requested bit
bvc ReadIntoCache ; if not requested, just fill the cache
jsr WriteSectorData ; write the data from IOP memory
beq @writeOK ; if successfull write, update sector info
cpa <DMARetryStatus ; see if it was a DMA timeout error
beq IgnoreData ; if so, just re-try it without ints during DMA
bra WriteDataError ; if real I/O error, handle sector data errors
@writeOK ldx <SectBufferNum ; get the buffer number for this sector
stz BufferStatus,x ; clear ReadDataValid, clear IORequested
dec <SectorsNeeded ; account for this sector
bne ReadHeader ; if more to go, keep writing
; If there are no valid entries left on this track, we will invalidate the entire
; track so that it will be reused soonest even though it is MRU.
ldx <CacheMRUPtr ; get index to current cache entry
lda CacheInvalidCount,x ; get the invalid entry count
cpa <PhysSectsPerHead ; see if all sectors are invalid
blt @validDone ; if some sectors valid, leave the track valid
lda #-1 ; if all invalid, invalidate the entire track
sta CacheInvalidCount,x ; decrement the invalid entry count
@validDone jmp WriteTrackLoop ; transfer the data, continue with the next track
; Load the cache with sectors that were not part of the request
ReadIntoCache bmi SkipSector ; if already in cache, skip it
ldy #GiveADBTimeMask ; see if ADB has been active recently
and <ADBActivity ; check against the ADB activity history
bne SkipSector ; if so, don't fill the cache, give ADB some time instead
jsr ReadSectorData ; read the data into the cache buffer
bne IgnoreData ; if error, don't validate it, just skip it
ldx <CacheMRUPtr ; get index to current cache entry
dec CacheInvalidCount,x ; decrement the invalid entry count
ldx <SectBufferNum ; get the buffer number for this sector
lda #ReadDataValid ; mark the cache entry valid
sta BufferStatus,x ; set ReadDataValid, clear IORequested
IgnoreData dec <WrongSectsLeft ; adjust count of sectors searched
bpl ReadAfterSkip ; if count not exhausted, keep on reading
lda #sectNFErr ; assume sector not found
RecalAndRetry dec <RecalsLeft ; see if RecalsMax exceeded
bmi ToWriteDone ; if too many retrys, die with hard error
jsr ReCalibrate ; move heads to track zero, init the drive
beq SeekToCyl ; if Recal OK, retry seek
ToWriteDone jmp WriteDone ; if Recal failed, die with hard error
; Error handling and recovery
ReadAddrError beq SkipSector ; if sect num out of range, just ignore it
cpa #SeekErr ; see if it was a seek error
beq RecalAndRetry ; if so, recal, and then retry
WriteDataError ldx <CurrentDrive ; get current drive number
inc ErrorCountL,x ; update the soft error count for this drive
bne @ErrorCountDone ; if no carry, skip high byte
inc ErrorCountH,x ; update the high byte of the error count
@ErrorCountDone
; if there was a problem reading a header, or writing data, recalibrate and retry
; first, to reduce the amount of data that will be written if the head is slightly
; off track. If all of the recals have been used, then we will stay on track and
; use the remaining retries on this track.
ldx <RecalsLeft ; see if RecalsMax reached
bne RecalAndRetry ; if not, recal, and then retry
dec <IOErrorsLeft ; number of I/O errors remaining before Recal
bmi RecalAndRetry ; if too many I/O errors, recal and try again
bra ReadHeader ; if more to go, keep reading
SkipSector jsr SkipSectorData ; give ADB some time
bra IgnoreData ; ignore this sector
endwith
endwith
endwith
endproc
title 'IOP SWIM Driver - Read / Write Setup'
;_______________________________________________________________________
;
; Routine: jsr ReadWriteSetUp
; Inputs: c - Cleared if double buffering allowed
; ReqKind - (WriteReq,ReadReq,ReadVerifyReq)
; Outputs: A, n, z - error status code
; Destroys: A, X, Y, n, v, z, c
; Calls: SetupBCPB, BlockToPhysAddr
; Called by: SWIMRead, SWIMReadVerify, SWIMWrite
;
; Function: Utility routines used by Read, ReadVerify, and Write
;
;_______________________________________________________________________
seg 'code'
ReadWriteSetUp proc
entry TagCopyCmd
entry DataCopyCmd
with SWIMVarsZ
with SWIMVars
with SectorBuffers
; setup the fields in the TagBCPB
ldx #-1 ; assume no tag buffer
ldy #-1 ; assume no tag buffer
lda TagBuffEnabled ; see if we need tag buffer copying
beq @skipTagSetup ; if not, skip it to save time
ldx ReqKind ; get the I/O command
lda TagCopyCmd-WriteReq,x ; get the copy command
ldy <TagBCPB ; get the BCPB index
sta BCPBcmd,y ; setup the block copy operation
tya ; assume single buffer
tax ; both prev and current are the same
bcs @singleTagBuff ; if only 1 cache entry, don't double buffer reads
ldx <TagBCPB2 ; use second buffer if enough cache entries
@singleTagBuff
lda TagBuffHostAddr+0 ; setup the initial HOST RAM Address
sta BCPBhostAddrB0,y
lda TagBuffHostAddr+1
sta BCPBhostAddrB1,y
lda TagBuffHostAddr+2
sta BCPBhostAddrB2,y
lda TagBuffHostAddr+3
sta BCPBhostAddrB3,y
lda #0 ; initialize count to zero
sta BCPBbyteCountH,y
sta BCPBbyteCountL,y
@skipTagSetup
sty <CurTagBCPB ; setup current
stx <PrevTagBCPB ; setup previous
; setup the fields in the DataBCPB
ldy <DataBCPB ; get the BCPB index
sty <CurDataBCPB ; setup current
tya ; assume single buffer
bcs @singleDataBuff ; if only 1 entry, don't double buffer reads
lda <DataBCPB2 ; get the second BCPB index
@singleDataBuff sta <PrevDataBCPB ; setup previous
tax ; get prev buffer
stz BCPBcompRel,x ; assume verify good for previous buffer
ldx ReqKind ; get the request kind
lda DataCopyCmd-WriteReq,x ; get the copy command
ldx #ReqRAMAddress-RCVData
jsr SetupBCPB ; setup the BCPB fields, use ReqRAMAddress
; get remaining parameters from the request message
lda ReqBlockNumber+2 ; use low word of long block number
sta <LogicalBlockH
lda ReqBlockNumber+3
sta <LogicalBlockL
lda ReqBlockCount+2 ; use low word of long block count
sta <BlocksToDoH
lda ReqBlockCount+3
sta <BlocksToDoL
lda ReqMfsTagData+6 ; get high byte of tag block number
sta <TagBlockNumH ; initialize the count
lda ReqMfsTagData+7 ; get low byte of tag block number
sta <TagBlockNumL ; initialize the count
; check high word of block number and block count
lda ReqBlockNumber+0
ora ReqBlockNumber+1
ora ReqBlockCount+0
ora ReqBlockCount+1
beq SetupDirection ; if block number / block count in range
lda #paramErr ; Parameter Error if out of range
SetupError rts ; return with result
; Determine the Seek Direction, and adjust addresses if needed
SetupDirection
lda #1 ; indicate incrementing track order
sta <SeekDirection ; setup the default direction
sta <SkipBlockToPhys ; skip first call to BlockToPhys
jsr BlockToPhysAddr ; translate the starting block number
bne SetupError ; die on errors
; See if requested data does not cross cylinders (no seeks within the request)
lda <PhysSectsPerCyl ; Number of Sectors per cylinder
sec ; setup for subtraction
sbc <PhysCylSector ; compute sectors remaining before seek needed
cpa <BlocksToDoL ; compare to number of sectors requested
lda #0 ; setup to compare high byte too
sbc <BlocksToDoH ; see if sectors till end of cyl >= BlocksToDo
bge @setupDone ; if request fits on 1 cylinder, seek direction doesn't matter
; See if we would need to seek ahead to reach the first cylinder of the request
ldx <CurrentDrive ; get the active drive number
lda <PhysCylinder ; get desired cylinder
sec ; setup for subtraction
sbc CurrentCylinder,x ; step count := desired - current
bge @setupDone ; if seeking ahead, use incrementing track order
ldy CylinderValid,x ; see if cylinder is valid
bne @setupDone ; if invalid, just use default
; See which end of the request the head is closest to
asl a ; negative step count * 2 (also set carry for subtract)
sbc <PhysCylinder ; compute negative end cyl where seek ahead is a win
sta <LoopCountL ; save the negative cylinder number
ldx <BlocksToDoH ; get high byte
lda <BlocksToDoL ; get low byte
bne @noBlockBorrow ; if non-zero, decrement won't borrow
dex ; if borrow, decrement upper byte
@noBlockBorrow dea ; compute BlocksToDo - 1
clc ; clear carry for addition
adc <LogicalBlockL ; LogicalBlock := LogicalBlock + BlocksToDo - 1
sta <LogicalBlockL
txa ; get BlocksToDoH
adc <LogicalBlockH
sta <LogicalBlockH
jsr BlockToPhysAddr ; translate the ending block number
bne SetupError ; die on errors
lda <LoopCountL ; get the negative cylinder number
clc ; setup carry for addition
adc <PhysCylinder ; see if ending cylinder is closer to head
blt @seekReverse ; if so, start at end, use decrementing track order
; Head is closer to beginning of request
stz <SkipBlockToPhys ; Don't skip first call to BlockToPhys
lda ReqBlockNumber+2 ; restore starting logical block number
sta <LogicalBlockH
lda ReqBlockNumber+3
sta <LogicalBlockL
@setupDone lda #noErr ; indicate success
rts ; return with result
; Head is closer to end of request
@seekReverse lda #-1 ; indicate decrementing track order
sta <SeekDirection ; setup the reverse direction
; correct the address in the TagBCPB
ldx <CurTagBCPB ; get current tag BCPB, see if tags enabled
bmi @skipTagSetup ; if not enabled, skip it to save time
ldy #TagSize ; multiplier/loop counter
@tagMultLoop clc ; clear carry for addition
lda BCPBhostAddrB3,x ; get low byte
adc <BlocksToDoL ; add in count
sta BCPBhostAddrB3,x ; update low byte
lda BCPBhostAddrB2,x ; get next byte
adc <BlocksToDoH ; add in count
sta BCPBhostAddrB2,x ; update next byte
bcc @noTagCarry ; see if carry out
inc BCPBhostAddrB1,x ; propagate the carry
bne @noTagCarry ; see if carry out
inc BCPBhostAddrB0,x ; propagate the carry
@noTagCarry dey ; update loop counter
bne @tagMultLoop ; loop until multiply is done
@skipTagSetup
; correct the address in the DataBCPB
ldx <CurDataBCPB ; get current data BCPB
ldy #BlockSize/256 ; multiplier/loop counter
@dataMultLoop clc ; clear carry for addition
lda BCPBhostAddrB2,x ; get low byte
adc <BlocksToDoL ; add in count
sta BCPBhostAddrB2,x ; update low byte
lda BCPBhostAddrB1,x ; get next byte
adc <BlocksToDoH ; add in count
sta BCPBhostAddrB1,x ; update next byte
bcc @noDataCarry ; see if carry out
inc BCPBhostAddrB0,x ; propagate the carry
@noDataCarry dey ; update loop counter
bne @dataMultLoop ; loop until multiply is done
; correct the Tag Block Numbers
clc ; clear carry for addition
lda <BlocksToDoL ; get low byte
adc <TagBlockNumL ; TagBlockNum := TagBlockNum + BlocksToDo
sta <TagBlockNumL
lda <BlocksToDoH ; get high byte
adc <TagBlockNumH
sta <TagBlockNumH
bra @setupDone ; indicate success and return
title 'IOP SWIM Driver - Copy Host Address'
;_______________________________________________________________________
;
; Routine: jsr SetupBCPB
; Inputs: A - BCPB command value
; X - Offset into RVCData of address to copy
; Y - BCPB index of destination BCPB
; Outputs: Y - set to $FF if HostAddr was zero, otherwise remains unchanged
; Destroys: A, Y, n, v, z, c, LoopCountL
; Calls: none
; Called by: ReadWriteSetUp, SWIMFormat, SWIMGetRawData
;
; Function: BCPBcmd[y] := A
; BCPBbyteCount[y] := $0000
; BCPBcompRel[y] := $00
; BCPBhostAddr[y] := RVCData[x]
; if RVCData[x] = 0 then y := $FF
;
;_______________________________________________________________________
entry SetupBCPB
SetupBCPB sta BCPBcmd,y ; setup the block copy operation
lda #0 ; initialize count to zero
sta BCPBbyteCountH,y
sta BCPBbyteCountL,y
sta BCPBcompRel,y ; assume verify good for current buffer
lda RCVData+0,x ; setup the Sector Data HOST RAM Address
sta BCPBhostAddrB0,y
sta <LoopCountL ; or the bytes to check for nil
lda RCVData+1,x
sta BCPBhostAddrB1,y
tsb <LoopCountL ; or the bytes to check for nil
lda RCVData+2,x
sta BCPBhostAddrB2,y
tsb <LoopCountL ; or the bytes to check for nil
lda RCVData+3,x
sta BCPBhostAddrB3,y
ora <LoopCountL ; or the bytes to check for nil
bne @notNil ; if valid address, use it
ldy #-1 ; otherwise, remember that it is disabled
@notNil rts ; all done
title 'IOP SWIM Driver - Inc/Dec Host Address'
;_______________________________________________________________________
;
; Routine: jsr IncHostAddr/DecHostAddr
; Inputs: x - Previous BCPB index
; y - Current BCPB index
; Outputs: none
; Destroys: A, n, v, z, c
; Calls: none
; Called by: UpdateTagInfo, UpdateDataInfo
;
; Function: BCPBhostAddr[y] := BCPBhostAddr[x] + BCPBbyteCount[x]
; BCPBcmd[y] := BCPBcmd[x]
;
; BCPBhostAddr[y] := BCPBhostAddr[x] - BCPBbyteCount[y]
; BCPBcmd[y] := BCPBcmd[x]
;
;_______________________________________________________________________
entry IncHostAddr
IncHostAddr clc ; setup carry for addition
lda BCPBhostAddrB3,x ; update the RAM Address
adc BCPBbyteCountL,x ; by the prior byte count
sta BCPBhostAddrB3,y
lda BCPBhostAddrB2,x
adc BCPBbyteCountH,x
sta BCPBhostAddrB2,y
lda BCPBhostAddrB1,x
adc #0
sta BCPBhostAddrB1,y
lda BCPBhostAddrB0,x
adc #0
sta BCPBhostAddrB0,y
lda BCPBcmd,x ; setup the block copy operation
sta BCPBcmd,y
rts ; all done
entry DecHostAddr
DecHostAddr sec ; setup carry for subtraction
lda BCPBhostAddrB3,x ; update the RAM Address
sbc BCPBbyteCountL,y ; by the prior byte count
sta BCPBhostAddrB3,y
lda BCPBhostAddrB2,x
sbc BCPBbyteCountH,y
sta BCPBhostAddrB2,y
lda BCPBhostAddrB1,x
sbc #0
sta BCPBhostAddrB1,y
lda BCPBhostAddrB0,x
sbc #0
sta BCPBhostAddrB0,y
lda BCPBcmd,x ; setup the block copy operation
sta BCPBcmd,y
rts ; all done
title 'IOP SWIM Driver - Setup Track Info'
;_______________________________________________________________________
;
; Routine: jsr SetupTrackInfo
; Inputs: BlocksToDoH/L - remaining blocks to read/write
; CurrentDrive - active drive number
; LogicalBlockH/L - Logical Block Number
; Outputs: c - true if error returned, or no more blocks
; A - error status code
; n,z - based on value returned in A
; PhysCylinder - Physical Cylinder number
; PhysHead - Physical Head number
; PhysSector - Physical Sector number
; PhysSectsPerHead- Physical Number of Sectors per head on this Cylinder
; PhysSectsPerCyl - Physical Number of Sectors on this Cylinder
; CacheMRUPtr - Index of cache entry for this Cylinder/Head
; BaseBufferNum - Buffer number for sector 0 of this track
; SectBufferNum - Buffer number for current sector of this track
; SectorsNeeded - number of sectors needed on this track
; Destroys: X, Y, n, v, z, c
; Calls: BlockToPhysAddr, FindCacheEntry
; Called by: SWIMRead, SWIMReadVerify, and SWIMWrite
;
; Function: Sets up the variables that describe this track of the request.
;
;_______________________________________________________________________
entry SetupTrackInfo
SetupTrackInfo lda <BlocksToDoH ; lots of blocks left?
ora <BlocksToDoL ; how many left in the request
beq @Done ; if none left, request is complete
lda <SkipBlockToPhys ; see if we should skip the BlockToPhys call
stz <SkipBlockToPhys ; Don't skip it next time
bne @skipped ; if already called, save time by not calling again
jsr BlockToPhysAddr ; translate the starting block number
bne @Done ; die on errors
@skipped jsr FindCacheEntry ; search the cache for this track
lda CacheBufferNum,x ; get starting buffer number for this track
sta <BaseBufferNum ; remember the starting buffer for this track
bit <SeekDirection ; see which way we are going
bmi @decrementing ; if decrementing, handle it specially
clc ; setup for addition
adc <PhysSector ; get starting sector number of request
sta <SectBufferNum ; save the starting buffer number
sec ; setup for subtract
lda <PhysSectsPerHead ; max sectors needed
sbc <PhysSector ; compute sectors till end of track
sta <SectorsNeeded ; remember how many sectors are needed
lda <BlocksToDoH ; lots of blocks left?
bne @GotNeeded ; if so, Sectors needed is correct
lda <BlocksToDoL ; how many left in the request
cpa <SectorsNeeded ; does track have more than we need
bge @GotNeeded ; if not, use remainder of track
sta <SectorsNeeded ; otherwise, use just what was requested
@GotNeeded clc ; indicate track exists
rts ; all done
@Done sec ; indicate error, or no more blocks
rts ; all done
@decrementing sta <SectBufferNum ; save the starting buffer number
lda <PhysSector ; get ending sector number of request
ina ; + 1 to get sector count
sta <SectorsNeeded ; remember how many sectors are needed
ldx <BlocksToDoH ; lots of blocks left?
bne @GotNeeded ; if so, Sectors needed is correct
sec ; setup for subtract
sbc <BlocksToDoL ; see if SectorsNeeded < BlocksToDo
blt @GotNeeded ; if so, Sectors Needed is correct
clc ; setup for addition
adc <BaseBufferNum ; get starting buffer number of track
sta <SectBufferNum ; save the starting buffer number
lda <BlocksToDoL ; how many left in the request
sta <SectorsNeeded ; remember how many sectors are needed
* clc ; indicate track exists
rts ; all done
title 'IOP SWIM Driver - Update Tag Info'
;_______________________________________________________________________
;
; Routine: jsr UpdateTagInfo
; Inputs: CurTagBCPB - Current BCPB index
; y, PrevTagBCPB - Previous BCPB index
; SectBufferNum - Buffer number for current sector of this track
; SectorsNeeded - number of sectors needed on this track
; Outputs: y, CurTagBCPB - former PrevTagBCPB
; PrevTagBCPB - former CurTagBCPB
; BCPBiopAddrH/L - IOP address of first tag to transfer for this track
; BCPBhostAddr - Updated to point to corresponding Host address of tag buffer
; BCPBbyteCountH/L- Number of bytes of tag data for this track
; Destroys: A, X, n, v, z, c
; Calls: IncHostAddr, DecHostAddr
; Called by: SWIMRead, SWIMReadVerify, SWIMWrite, SWIMFormat
;
; Function: Updates the variables associated with the tag data transfer for this track.
;
;_______________________________________________________________________
entry UpdateTagInfo ; update the TAG data transfer addresses and counts
UpdateTagInfo ldx <CurTagBCPB ; get the current tag copy request
bit <SeekDirection ; see which way we are going
bmi @decrementing ; if decrementing, handle it specially
jsr IncHostAddr ; point to new host address
@common stx <PrevTagBCPB ; swap buffers cur -> prev
sty <CurTagBCPB ; swap buffers prev -> cur
ldx <SectBufferNum ; get the starting buffer number
lda TagPtrs,x ; get the tag buffer offset
asl a ; unpack 9th bit into carry
sta BCPBiopAddrL,y ; remember the tag offset
lda #0 ; setup to add in tag addr carry
sta BCPBbyteCountH,y ; high byte of byte count always zero
adc #>TagBuffers ; add in starting page of tag buffers
sta BCPBiopAddrH,y ; remember the tag page
assert TagSize=12 ; multiply by 12 is hard coded
lda <SectorsNeeded ; sector count for this track
asl a ; SectorsNeeded*2
adc <SectorsNeeded ; SectorsNeeded*3
ldx <CurTagBCPB ; x := y := CurTagBCPB
asl a ; SectorsNeeded*6
rol BCPBbyteCountH,x ; shift into high byte of byte count
asl a ; SectorsNeeded*12
rol BCPBbyteCountH,x ; shift into high byte of byte count
sta BCPBbyteCountL,y ; setup low byte of byte count
rts ; all done
@decrementing jsr @common ; do everything but increment
ldx <PrevTagBCPB ; get the previous tag copy request
jmp DecHostAddr ; exit through DecHostAddr
title 'IOP SWIM Driver - Update Data Info'
;_______________________________________________________________________
;
; Routine: jsr UpdateDataInfo
; Inputs: CurDataBCPB - Current BCPB index
; y, PrevTagBCPB - Previous BCPB index
; SectBufferNum - Buffer number for current sector of this track
; SectorsNeeded - number of sectors needed on this track
; Outputs: y, CurDataBCPB - former PrevTagBCPB
; PrevTagBCPB - former CurTagBCPB
; BCPBiopAddrH/L - IOP address of first sector to transfer for this track
; BCPBhostAddr - Updated to point to corresponding Host address of sector buffer
; BCPBbyteCountH/L- Number of bytes of sector data for this track
; Destroys: A, X, n, v, z, c
; Calls: IncHostAddr, DecHostAddr
; Called by: SWIMRead, SWIMReadVerify, SWIMWrite, SWIMFormat
;
; Function: Updates the variables associated with the sector data transfer for this track.
;
;_______________________________________________________________________
entry UpdateDataInfo ; update the DATA data transfer addresses and counts
UpdateDataInfo ldx <CurDataBCPB ; get the current data copy request
bit <SeekDirection ; see which way we are going
bmi @decrementing ; if decrementing, handle it specially
jsr IncHostAddr ; point to new host address
@common stx <PrevDataBCPB ; swap buffers cur -> prev
sty <CurDataBCPB ; swap buffers prev -> cur
lda <SectBufferNum ; get the starting buffer number
assert BlockSize=(2*256) ; multiply by 2 is hard coded
asl a ; buffer number * 2 for 2*256 byte blocks
adc #>DataBuffers ; add in starting page of data buffers
sta BCPBiopAddrH,y ; remember the data page
lda <SectorsNeeded ; sector count for this track
asl a ; SectorsNeeded*2 for 2*256 byte blocks
sta BCPBbyteCountH,y ; setup high byte of byte count
lda #0 ; setup data buffer offset
sta BCPBiopAddrL,y ; data is page aligned in the buffer
sta BCPBbyteCountL,y ; setup low byte of byte count
rts ; all done
@decrementing jsr @common ; do everything but increment
ldx <PrevDataBCPB ; get the previous data copy request
jmp DecHostAddr ; exit through DecHostAddr
title 'IOP SWIM Driver - Update Block Info'
;_______________________________________________________________________
;
; Routine: jsr UpdateBlockInfo
; Inputs: LogicalBlockH/L - Logical Block Number
; SectorsNeeded - number of sectors needed on this track
; BlocksToDoH/L - remaining blocks to read/write
; TagBlockNumH/L - tag buffer
; Outputs: LogicalBlockH/L - Logical Block Number
; BlocksToDoH/L - remaining blocks to read/write
; Destroys: A, n, v, z, c
; Calls: none
; Called by: SWIMRead, SWIMReadVerify, SWIMWrite
;
; Function: Updates the variables associated with the block addressing for this track.
;
;_______________________________________________________________________
entry UpdateBlockInfo ; update the DISK block addresses and counts
UpdateBlockInfo lda <BlocksToDoL ; get low byte of block count
sec ; setup for subtraction
sbc <SectorsNeeded ; account for blocks on this track
sta <BlocksToDoL ; update block count
bcs @BlockCountDone ; if no borrow
dec <BlocksToDoH ; update high byte
@BlockCountDone
bit <SeekDirection ; see which way we are going
bmi @decrementing ; if decrementing, handle it specially
lda <LogicalBlockL ; get block number
clc ; setup for addition
adc <SectorsNeeded ; account for blocks on this track
sta <LogicalBlockL ; update block number
bcc @BlockNumIncDone ; if no carry
inc <LogicalBlockH
@BlockNumIncDone
lda <TagBlockNumL ; get low byte of tag block number
sta ReqMfsTagData+7 ; initialize the count
clc ; setup for addition
adc <SectorsNeeded ; account for blocks on this track
sta <TagBlockNumL ; update tag block number
lda <TagBlockNumH ; get high byte of tag block number
sta ReqMfsTagData+6 ; initialize the count
adc #0 ; add in carry
sta <TagBlockNumH ; update tag block number
rts ; all done
@decrementing lda <LogicalBlockL ; get block number
sec ; setup for subtraction
sbc <SectorsNeeded ; account for blocks on this track
sta <LogicalBlockL ; update block number
bcs @BlockNumDecDone ; if no borrow
dec <LogicalBlockH
@BlockNumDecDone
lda <TagBlockNumL ; get low byte of tag block number
sec ; setup for subtraction
sbc <SectorsNeeded ; account for blocks on this track
sta ReqMfsTagData+7 ; initialize the count
sta <TagBlockNumL ; update tag block number
lda <TagBlockNumH ; get high byte of tag block number
sbc #0 ; subtract borrow
sta ReqMfsTagData+6 ; initialize the count
sta <TagBlockNumH ; update tag block number
rts ; all done
endwith
endwith
endwith
endproc
seg 'constants'
TagCopyCmd proc
; table of Tag Copy BCPBcmd bytes indexed by (ReqKind)-WriteReq
dc.b bcHOSTtoIOP ; 0 - WriteReq
dc.b bcIOPtoHOST ; 1 - ReadReq
dc.b bcIOPtoHOST ; 2 - ReadVerifyReq
entry DataCopyCmd
DataCopyCmd
; table of Data Copy BCPBcmd bytes indexed by (ReqKind)-WriteReq
dc.b bcHOSTtoIOP ; 0 - WriteReq
dc.b bcIOPtoHOST ; 1 - ReadReq
dc.b bcCompare ; 2 - ReadVerifyReq
endproc
title 'IOP SWIM Driver - SWIM Format'
;_______________________________________________________________________
;
; Routine: jmp SWIMFormat
; Inputs: A - OpenStatus error code
; n, z - status of the OpenStatus flag
; Outputs: none
; Destroys: A, X, Y, n, v, z, c
; Calls: SetUpDrive, SetupBCPB, GetDriveStatus, WaitDriveReady,
; CreateTrackCache, ReCalibrate, WaitMotorSettled, Seek,
; UpdateTagInfo, MakeBCPBreq, WaitBCPBdone, UpdateDataInfo,
; FormatTrack, BlockToPhysAddr, SWIMDriveStatus
; Called by: SWIM Request Dispatcher
;
; Function: Disk formatting routine
;
;_______________________________________________________________________
seg 'code'
SWIMFormat proc
entry FmtIndexTable
entry DefaultInterleave
entry DefaultGapSize
entry DefaultFmtByte
entry FormatTrack
with SWIMVarsZ
with SWIMVars
jsr SetUpDrive ; select and power up the disk drive
bne @Done ; if error powering up
ldy <DataBCPB ; get the BCPB index
lda #bcHOSTtoIOP ; setup the command
ldx #ReqFmtDataAddress\
-RCVData ; offset of start of address field
jsr SetupBCPB ; copy the FmtDataAddress
sty <CurDataBCPB ; setup current
ldy <TagBCPB ; get the BCPB index
lda #bcHOSTtoIOP ; setup the command
ldx #ReqFmtTagAddress\
-RCVData ; offset of start of address field
jsr SetupBCPB ; copy the ReqFmtTagAddress
sty <CurTagBCPB ; setup current
lda ReqHdrFmtKind ; get the desired HdrFmtKind byte
sta <FmtByteBlkSize ; setup Fmt byte / Block Size
lda ReqFmtInterleave ; get the desired Interleave factor
sta <Interleave ; setup sector interleave factor
lda ReqFormatKind ; get high byte of format kind
bne @ParamErr ; if non-zero, it's an error
lda ReqFormatKind+1 ; get low byte of format kind
pha ; save for later
lda #>ReqDriveStatus ; get page number of status message buffer
ldx <CurrentDrive ; get the drive number
jsr GetDriveStatus ; get the status for disk size
lda #1 ; defaults are first index into current format
plx ; restore low byte of format kind
beq @CopyFmtList ; if zero, use defaults (x=0)
txa ; set desired format index
ldx #StatFmtAllowedH\
-StatCurrentFmtH ; use formats allowed list
@CopyFmtList ldy RCVData\
+StatCurrentFmtH,x ; get high byte of list
sty <LoopCountH ; save it in a temp
ldy RCVData\
+StatCurrentFmtL,x ; get low byte of list
sty <LoopCountL ; save it in a temp
ldx #0 ; initialize table index
@FmtSearchLoop ldy FmtIndexTable,x ; get the format for this index
bmi @ParamErr ; return ParamErr if formatKind too big
inx ; update index
ror <LoopCountH ; shift high byte
ror <LoopCountL ; shift low byte
bcc @FmtSearchLoop ; loop if this format not available
dea ; decrement format kind
bne @FmtSearchLoop ; loop if not the desired format kind
ldx <CurrentDrive ; get drive number
lda #WriteEnabledFlag ; prepare to test write enable
bit DriveFlags,x ; test the enable bit
bne @WriteEnabled ; if ok to write
lda #wPrErr ; indicate write protected disk
bra @Done ; return the error
@ParamErr lda #paramErr ; format kind out of range
@Done stz <WritingForFmt ; formatting complete, not writing for format now
jmp SWIMReqDone ; return the error
@WriteEnabled tya ; get new format
sta DiskFormat,x ; change to new disk format
lda DefaultGapSize,y ; get the default inter sector gap size/sync count
sta <SectorGapSize ; setup sector gap info
lda <FmtByteBlkSize ; get Fmt byte / Block Size from request
bne @gotFmtByte ; if non-default, use it
lda DefaultFmtByte,y ; get default format byte / block size byte value
@gotFmtByte sta <FmtByteBlkSize ; setup Fmt byte / Block Size
ldx <Interleave ; get sector interleave factor from request
bne @gotInterleave ; if non-default, use it
ldx DefaultInterleave,y ; get the default interleave for this format
bpl @gotInterleave ; if positive, use it
and #$1F ; get the interleave from the format byte
tax ; setup to store it
bne @gotInterleave ; if non-zero, use it
inx ; if zero, change it to one
@gotInterleave stx <Interleave ; setup sector interleave factor
jsr CreateTrackCache ; create a cache using the new Format
jsr ReCalibrate ; move heads to track zero, init the drive
bne @Done ; if error powering up
lda #1 ; indicate incrementing track order
sta <SeekDirection ; setup the default direction
stz <LogicalBlockL ; start with block number zero
stz <LogicalBlockH ; setup high byte
jsr WaitMotorSettled ; wait for motor speed to be in 1.5% tolerance
dec <WritingForFmt ; we be formatting now, tell with world
bra @Start ; start formatting
@CylinderLoop ldy <PhysCylinder ; get the cylinder number
jsr Seek ; start the seek to the cylinder
bne @Done ; die on errors
lda <LogicalBlockL ; get first block of this cylinder
clc ; setup for addition
adc <PhysSectsPerCyl ; add in the cylinder size
sta <LogicalBlockL ; update low byte
bcc @BlockNumOK ; if no carry into high byte
inc <LogicalBlockH ; update high byte
@BlockNumOK
; build the sector interleave map
ldy <PhysSectsPerHead ; number of sectors to interleave
lda #$FF ; flag for available sector
@MapInit dey ; decrement sector count
sta SectorMap,y ; mark sector as available
bne @MapInit ; initialize all of the sectors
@Occupied ina ; try the next sector
@MapNext cpa <PhysSectsPerHead ; see if still in range
blt @NoWrap ; if it didn't wrap around
; sec ; carry set for subtract from CPA above
sbc <PhysSectsPerHead ; if wrap around, back up
clc ; clear carry for future addition
@NoWrap tax ; setup map index
bit <SectorMap,x ; see if it is already occupied
bpl @Occupied ; if so, try another one
sty <SectorMap,x ; if not, update the map
adc <Interleave ; bump index by interleave
iny ; update sector number
cpy <PhysSectsPerHead ; see if end reached
blt @MapNext ; if not, keep on mapping
stz <SectBufferNum ; starting buffer number is always zero
lda <PhysSectsPerCyl ; get number of blocks on this cylinder
sta <SectorsNeeded ; sector count for this track
; get the tag data
ldy <CurTagBCPB ; get the current tag copy info
bmi @tagXferDone ; if not enabled, skip it
jsr UpdateTagInfo ; update the data xfer info
jsr MakeBCPBreq ; issue the copy request
ldy <CurTagBCPB ; get the current tag copy info
jsr WaitBCPBdone ; wait for it to complete
@tagXferDone
; get the sector data
ldy <CurDataBCPB ; get the current data copy info
bmi @dataXferDone ; if not enabled, skip it
jsr UpdateDataInfo ; update the data xfer info
jsr MakeBCPBreq ; issue the copy request
ldy <CurDataBCPB ; get the current data copy info
jsr WaitBCPBdone ; wait for it to complete
@dataXferDone
jsr WaitDriveReady ; wait for the seek to complete
beq @HeadLoop ; continue with next head if successful
@toDone jmp @Done ; die on errors
@HeadLoop
jsr FormatTrack ; format the track
bne @toDone ; exit if formatting error
inc <PhysHead ; go on to the next head
lda <PhysSectsPerCyl ; get remaining blocks on this cylinder
sec ; setup for subtract
sbc <PhysSectsPerHead ; decrement by blocks on this head
sta <PhysSectsPerCyl ; update remaining blocks on this cylinder
bne @HeadLoop ; loop through all of the heads
@Start jsr BlockToPhysAddr ; convert highest block on this cylinder
beq @CylinderLoop ; process next cylinder if end not reached
jsr CreateTrackCache ; create a cache using the new Format
stz <WritingForFmt ; formatting complete, not writing for format now
lda #noErr ; indicate format succeeded
jmp SWIMDriveStatus ; finish up by returning the drive status
endwith
endwith
endproc
seg 'constants'
DefaultInterleave proc
; 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
entry DefaultGapSize
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
entry DefaultFmtByte
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
endproc
title 'IOP SWIM Driver - SWIM Format Verify'
;_______________________________________________________________________
;
; Routine: jmp SWIMFormatVerify
; Inputs: A - OpenStatus error code
; n, z - status of the OpenStatus flag
; Outputs: none
; Destroys: A, X, Y, n, v, z, c
; Calls: SetUpDrive, GetDriveStatus, WaitDriveReady, FlushTrackCache,
; BlockToPhysAddr, Seek, FindCacheEntry, SkipSectorData, ReadSectorHdr,
; ReadSectorData
; Called by: SWIM Request Dispatcher
;
; Function: Verify that the disk is correctly formatted and all blocks
; can be read without errors.
;
;_______________________________________________________________________
seg 'code'
SWIMFormatVerify proc
with SWIMVarsZ
with SWIMVars
with SectorBuffers
jsr SetUpDrive ; select and power up the disk drive
bne @Done ; if error powering up
lda #>ReqDriveStatus ; get page number of status message buffer
ldx <CurrentDrive ; get the drive number
jsr GetDriveStatus ; get the status for disk size
jsr WaitDriveReady ; wait for motor speed and heads to settle
bne @Done ; if error powering up
jsr FlushTrackCache ; Flush the cache to force reads without retries
lda #1 ; setup to dec (last block is disk size - 1)
sta <PhysSectsPerCyl ; setup decrement value
lda RCVData\
+StatDiskSizeB1 ; get high byte of disk size
sta <LogicalBlockH ; setup highest logical block number
lda RCVData\
+StatDiskSizeB0 ; get low byte of disk size
bra @Start ; start verifying
@HdrErr bne @Done ; if sector out of range, die with verErr
@VerErr lda #verErr ; verify failed, sector not found
@Done jmp SWIMReqDone ; return the error
@CylinderLoop jsr BlockToPhysAddr ; convert highest block on this cylinder
bne @Done ; die on errors
ldy <PhysCylinder ; get the cylinder number
jsr Seek ; start the seek to the cylinder
bne @Done ; die on errors
jsr WaitDriveReady ; wait for the seek to complete
bne @Done ; die on errors
@HeadLoop lda <PhysHead ; get the head we want
sta <SeekingHead ; pass it to ReadSectorHdr
jsr FindCacheEntry ; search the cache for this track
lda CacheBufferNum,x ; get starting buffer number for this track
sta <BaseBufferNum ; remember the starting buffer for this track
lda <PhysSectsPerHead ; max sectors needed
sta <SectorsNeeded ; remember how many sectors are needed
lda #WrongSectsMax ; number of wrong sectors allowed before error
sta <WrongSectsLeft ; number of wrong sectors remaining before error
bra @VerifyLoop ; start reading the track
@SkipSector jsr SkipSectorData ; give ADB some time
@VerifyLoop dec <WrongSectsLeft ; count the block
beq @VerErr ; if count exhausted, die with verErr
jsr ReadSectorHdr ; look for a sector
bcs @HdrErr ; die on all errors
assert ReadDataValid=$80 ; sign bit is valid bit
bmi @SkipSector ; if already in cache, just ignore it
jsr ReadSectorData ; read the data into the cache
beq @readOK ; if successfull read, update sector info
cpa <DMARetryStatus ; see if it was a DMA timeout error
beq @VerifyLoop ; if so, just re-try it without ints during DMA
bra @Done ; if real I/O error, handle sector data errors
@readOK ldx <CacheMRUPtr ; get index to current cache entry
dec CacheInvalidCount,x ; decrement the invalid entry count
ldx <SectBufferNum ; get the buffer number for this sector
lda #ReadDataValid ; mark the buffer data valid
sta BufferStatus,x ; set ReadDataValid, clear IORequested
dec <SectorsNeeded ; decrement blocks to find
bne @VerifyLoop ; if more needed, continue searching
dec <PhysHead ; go on to the next head
bpl @HeadLoop ; loop through all of the heads
lda <LogicalBlockL ; get last block of this cylinder
@Start sec ; setup for subtract
sbc <PhysSectsPerCyl ; subtract out the cylinder size
sta <LogicalBlockL ; update low byte
lda <LogicalBlockH ; get high byte
sbc #0 ; subtract high byte
sta <LogicalBlockH ; update high byte
bge @CylinderLoop ; continue verify if more cylinders
lda #noErr ; verify succeeded
bra @Done ; return the error
endwith
endwith
endwith
endproc
title 'IOP SWIM Driver - SWIM Get Raw Track Data'
;_______________________________________________________________________
;
; Routine: jmp SWIMGetRawData
; Inputs: A - OpenStatus error code
; n, z - status of the OpenStatus flag
; Outputs: none
; Destroys: A, X, Y, n, v, z, c
; Calls: SetUpDrive, Seek, WaitDriveReady, CreateTrackCache, AdrAndSense,
; Sense, ReadSectorData, ReadHdrSetup, MakeBCPBreq, WaitBCPBdone,
; ReadSectorHdr, SetupBCPB
; Called by: SWIM Request Dispatcher
;
; Function: Reads Raw data from the disk, starting at a user selectable point.
;
;_______________________________________________________________________
seg 'code'
SWIMGetRawData proc
with SWIMVarsZ
with SWIMVars
with SectorBuffers
; The read loop would average about 30.643 clocks per byte (15.647µsec) which doesn't
; allow 5% speed variation in MFM mode (16µsec - 5% = 15.2µsec).
; To allow better margin for speed variation, self modifying code is used in the loop
; to get the average byte time down to 29.647 clocks (15.138µsec)
FasterReads equ 1 ; enable faster (and self modifying) read loop
jsr SetUpDrive ; select and power up the disk drive
bne RawIOError ; if error powering up
jsr SetupByteCount ; get the byte count, make sure it is in range
clc ; indicate data buffer
ldy <DataBCPB ; get the BCPB index
ldx #ReqRawDataAddress\
-RCVData ; offset of start of address field
lda #>(DataBuffers+(RawDataBufferNum*BlockSize)+RawByteCountMax+$FF)
jsr SetupRawBCPB ; copy the ReqRawDataAddress
sty <CurDataBCPB ; setup data buffer copy request
sec ; indicate clock buffer
ldy <TagBCPB ; get the BCPB index
ldx #ReqRawClockAddress\
-RCVData ; offset of start of address field
lda #>(DataBuffers+(RawClockBufferNum*BlockSize)+RawByteCountMax/8+$FF)
jsr SetupRawBCPB ; copy the ReqRawClockAddress
sty <CurTagBCPB ; setup clock buffer copy request
lda #paramErr ; default to Parameter Error if out of range
ldx ReqRawSearchMode+0 ; check high byte of search mode
bne RawIOError ; must be zero
ldx ReqRawSearchMode+1 ; check low byte of search mode
cpx #4 ; must be 0…3
bge RawIOError ; param error if out of range
ldx ReqRawHead ; get the requested head number
stx <SeekingHead ; remember which head we want
cpx CurHeadsPerCyl ; check against max heads
bge RawIOError ; param error if out of range
ldy <CurrentDrive ; get the active drive number
ldx DiskFormat,y ; see what format we have
stz <RawIOFmtMFM ; $00 if GCR
cpx #MFM1440Kformat ; check for MFM (1440K)
beq @mfmDisk ; if MFM, adjust sector number
cpx #MFM720Kformat ; check for MFM (720K)
bne @formatFound ; if not MFM, use GCR numbering
@mfmDisk dec ReqRawSector ; MFM sectors are 1 based, we need zero based
dec <RawIOFmtMFM ; $FF if MFM
@formatFound
ldx ReqRawCylinder ; get high byte of cylinder
bne RawIOError ; param error if out of range
ldy ReqRawCylinder+1 ; get low byte of cylinder
jsr Seek ; move the heads
bne RawIOError ; die on errors
jsr WaitDriveReady ; wait for the seek to complete
beq StartSearching ; if successful, search for the starting point
RawIOError ldx #4-1 ; loop count/index
@errLoop stz ReqRawByteCount,x ; indicate that no bytes were transferred
dex ; update loop count/index
bpl @errLoop ; clear all 4 bytes of the byte count
RawIODone ldx #StartAction\
+WriteMode ; prepare to clear action and write mode
stx wZeroes ; clear action and write mode (read done)
stz CurSectsPerHead ; disable prefetching, sects per head unknown
pha ; save error code
jsr CreateTrackCache ; cache is trash, re-create it
pla ; restore error code, set conditions
jmp SWIMReqDone ; return the error
StartSearching ldx ReqRawSearchMode+1 ; check low byte of search mode
assert SearchImmediate=0
beq ReadImmediate ; if SearchImmediate, select the head and start reading
assert SearchForAddress=1
dex
beq FindAddress ; if SearchForAddress, starting reading after sect hdr
assert SearchForData=2
dex
beq FindData ; if SearchForData, starting reading after sect data
assert SearchForIndex=3
FindIndex lda <RawIOFmtMFM ; see if MFM
beq ReadImmediate ; if GCR, no index pulse, searchImmediate
stz <LoopCountH ; init outer loop counter 65K times ± 256
lda #rIndexPulseAdr ; sense the index signal
jsr AdrAndSense ; sense it
@indexLoop tax ; remember index signal from last sample
jsr Sense ; test the index signal
beq @noIndex ; if index not active then keep waiting
txa ; index is active, see if inactive last time
beq ReadImmediate ; if inactive to active transition, start reading
@noIndex iny ; update low byte of timeout counter
bne @indexLoop ; if time remaining, keep checking
inc <LoopCountH ; update high byte of timeout counter
bne @indexLoop ; if time ramaining, keep checking
lda #noIndexErr ; timed out searching for index
ToRawIOError bra RawIOError ; return the error
FindAddress jsr FindSector ; search for the sector
bcs RawIOError ; if not found, report the error
lda <RawIOFmtMFM ; see if MFM or GCR
beq ContinueReading ; if GCR, continue reading, without re-syncing
bra ReadImmediate ; if MFM, re-sync, and start reading
FindData jsr FindSector ; search for the sector
bcs RawIOError ; if not found, report the error
lda #>(DataBuffers+\
(RawTempBufferNum*BlockSize)) ; page number of temp buffer
sta <DataBufPtr+1 ; setup page number for data to be ignored
sta <TagBufPtr+1 ; dump the tags there too.
jsr ReadSectorData ; read the data, ignore errors
ReadImmediate jsr ReadHdrSetup ; select the head, start shifting in data
ContinueReading ldx <TagBCPB ; get the BCPB index
lda BCPBiopAddrH,x ; get high byte of clock buffer start address
sta <TagBufPtr+1 ; setup high byte of buffer pointer
lda BCPBiopAddrL,x ; get low byte of clock buffer start address
sta <TagBufPtr ; setup low byte of buffer pointer
ldx <DataBCPB ; get the BCPB index
lda BCPBiopAddrH,x ; get high byte of data buffer start address
ldy BCPBiopAddrL,x ; get low byte of data buffer start address
if FasterReads then
sta StoreDataInst+2 ; setup high byte of buffer pointer
else
sta <DataBufPtr+1 ; setup high byte of buffer pointer
stz <DataBufPtr ; setup low byte of buffer pointer
endif
ldx #$01 ; constant to cause carry out after 8 shifts
stx <LoopCountH ; initialize shift temporary to $01
txa ; outer loop counter
bit rData ; empty a garbage byte out of the FIFO,
bit rError ; read and clear errors
@findByte bit rHandshake ; see if byte is available
assert Dat1Byte=$80
bmi ReadLoopStart ; if so, go ahead and start reading
inc <LoopCountL ; update inner loop counter
bne @findByte ; loop until a byte is found
ina ; update outer loop counter
bne @findByte ; loop until a byte is found, or timeout
lda #noNybErr ; indicate that no bytes were found
bra ToRawIOError ; return the error
WaitNextByte lda rHandshake ; see if byte is available
assert Dat1Byte=$80
bpl WaitNextByte ; loop until byte is ready
assert MarkInFIFO=$01
lsr a ; carry := mark/data indicator
lda rMark ; read the mark/data byte
if FasterReads then
StoreDataInst sta $FF00,y ; store the raw data (page number gets modified)
else
sta (<DataBufPtr),y ; store the raw data
endif
rol <LoopCountH ; shift in the mark/data indicator
iny ; update the buffer offset
bcc WaitNextByte ; loop until a group of 8 bytes completes
bne @DataPageOK ; if page boundary not reached
if FasterReads then
inc StoreDataInst+2 ; if page crossing, update the page number
else
inc <DataBufPtr+1 ; if page crossing, update the page number
endif
@DataPageOK
lda <LoopCountH ; get the mark/data indicators for 8 bytes
stx <LoopCountH ; re-initialize to $01 for next pass
sta (<TagBufPtr) ; store the indicators
inc <TagBufPtr ; update the buffer offset
bne WaitNextByte ; loop until page crossing
inc <TagBufPtr+1 ; if page crossing, update the page number
ReadLoopStart lda <TagBufPtr+1 ; get the updated page number
cpa #>(DataBuffers+\
(RawClockBufferNum*BlockSize)+\
RawByteCountMax/8+$FF) ; see if end has been reached
bne WaitNextByte ; keep looping until end of buffer
ldy <CurDataBCPB ; setup data buffer copy request
jsr SendData ; copy the buffer
ldy <CurTagBCPB ; setup clock buffer copy request
jsr SendData ; copy the buffer
lda #noErr ; indicate success
jmp RawIODone ; if all done, return success
SendData bmi @noData ; if no buffer, skip it
phy ; save the BCPB index
jsr MakeBCPBreq ; issue the copy request
ply ; restore the BCPB index
jmp WaitBCPBdone ; wait for it to complete and return
@noData rts ; all done
FindSector inc <DMARetryStatus ; force 1 re-try to prevent ints during DMA
lda #WrongSectsMax+1 ; successful read, re-init Wrong Sector Count
sta <WrongSectsLeft ; number of wrong sectors remaining before Recal
lda #$FF ; allow any sector number
sta <PhysSectsPerHead ; setup for sector number range checking
@tryAgain lda #sectNFErr ; assume it isn't found
sec ; return carry := 1, to indicate error
dec <WrongSectsLeft ; update the retry count
bmi @done ; if no retries left, report the error
jsr ReadSectorHdr ; read the next sector header that comes along
bcs @tryAgain ; if any error, try again
lda <SectHdrSector ; get the sector number that was found
eor ReqRawSector ; see if it is the one that we want
bne @tryAgain ; if not, try the next one
@done rts ; all done
SetupByteCount lda ReqRawByteCount+0 ; get high byte of longword byte count
ora ReqRawByteCount+1 ; get next byte of longword byte count
bne @ReduceByteCount ; if too big, reduce it
ldy ReqRawByteCount+3 ; get low byte of longword byte count
cpy #<RawByteCountMax ; compare to max
ldx ReqRawByteCount+2 ; get middle byte of longword byte count
txa ; setup for compare
sbc #>RawByteCountMax ; compare to max
blt @ByteCountOK ; if less than max then use it, else use max
@ReduceByteCount
stz ReqRawByteCount+0 ; clear high byte of longword byte count
stz ReqRawByteCount+1 ; clear next byte of longword byte count
ldx #>RawByteCountMax ; get high byte of max byte count
ldy #<RawByteCountMax ; get low byte of max byte count
@ByteCountOK stx ReqRawByteCount+2 ; setup middle byte of longword byte count
sty ReqRawByteCount+3 ; setup low byte of longword byte count
tya ; get the low byte
clc ; setup for addition
adc #$07 ; round up to mod 8 boundary
and #$F8 ; clear low bits
bcc @rounded ; if no carry to propagate, store the count
inx ; propagate the carry
@rounded stx <BlocksToDoH ; setup high byte of loop counter
sta <BlocksToDoL ; setup low byte of loop counter
rts ; all done
SetupRawBCPB php ; save the flags
pha ; save the ending page number
lda #0 ; ending page offset is always zero
sec ; setup for subtraction
sbc <BlocksToDoL ; subtract the byte count
sta BCPBiopAddrL,y ; remember the page offset (page aligned)
pla ; get the page number again
sbc <BlocksToDoH ; subtract the byte count
sta BCPBiopAddrH,y ; remember the page number
lda #bcIOPtoHOST ; setup the command
jsr SetupBCPB ; copy the ReqRawClockAddress
ldx <BlocksToDoH ; high byte of byte count
lda <BlocksToDoL ; low byte of byte count
lsr <BlocksToDoH ; shift byte count right by 3 bits (div by 8)
ror <BlocksToDoL ; shift low byte
lsr <BlocksToDoH
ror <BlocksToDoL
lsr <BlocksToDoH
ror <BlocksToDoL
plp ; restore the carry flag
phy ; see if buffer valid
ply
bmi @done ; if not, don't need to setup byte count
bcs @storeCount ; if clock buffer, store rounded count div 8
ldx ReqRawByteCount+2 ; for data buffer, use the actual byte count
lda ReqRawByteCount+3
@storeCount sta BCPBbyteCountL,y ; setup low byte of byte count
txa ; get high byte
sta BCPBbyteCountH,y ; setup high byte of byte count
@done rts ; all set up
endwith
endwith
endwith
endproc
title 'IOP SWIM Driver - Create Track Cache'
;_______________________________________________________________________
;
; Routine: jsr CreateTrackCache
; Inputs: CurrentDrive - active drive number
; Outputs: CurHeadsPerCyl - Number of heads per cylinder for this disk
; Destroys: A, X, Y, n, v, z, c
; Calls: FlushTrackCache
; Called by: SWIMFormat, SWIMGetRawData, SetUpDrive
;
; Function: Creates a track cache for the current drive, allocating buffer
; space according to the format of the disk in the drive.
;
;_______________________________________________________________________
seg 'code'
CreateTrackCache proc
entry BlockXlateTable
entry BlockXlateHeadsPerCyl
entry BlockXlateSectsPerHead
with SWIMVarsZ
with SWIMVars
ldy <CurrentDrive ; get the active drive number
ldx DiskFormat,y ; see what format to read
ldy BlockXlateTable,x ; Get the translate table index
lda BlockXlateHeadsPerCyl,y ; get number of heads per cylinder for this format
sta CurHeadsPerCyl ; remember it for prefetching
ldx #-1 ; cache index
lda #TotalBuffers ; index of last buffer + 1
sec ; setup for subtract (remains set within loop)
bra @BufferStart ; enter the loop
@BufferLoop pha ; save the buffer number
txa ; get current element index
inx ; point to the next cache entry
sta CacheNextMRU,x ; initialize the link
pla ; restore the buffer number
sta CacheBufferNum,x ; initialize the starting buffer number
@BufferStart sbc BlockXlateSectsPerHead,y ; allocate a track buffer
bge @BufferLoop ; loop until all buffer space used
stx <CacheMRUPtr ; make this the new first element
* (fall into) bra FlushTrackCache ; now invalidate all of the elements
title 'IOP SWIM Driver - Flush Track Cache / Flush If Disabled'
;_______________________________________________________________________
;
; Routine: jsr FlushTrackCache
; Inputs: none
; Outputs: none
; Destroys: A, X, n, z
; Calls: none
; Called by: SWIMFormatVerify, CreateTrackCache, FlushIfDisabled
;
; Function: Flushes the existing track cache for the current drive by
; invalidating all of the cache entries.
;
;_______________________________________________________________________
entry FlushTrackCache
FlushTrackCache ldx #MaxCacheEntries-1 ; index of last entry / loop counter
lda #-1 ; invalid count
@invalidLoop sta CacheInvalidCount,x ; mark all entries invalid
dex ; index through each element
bpl @invalidLoop ; loop until all done
rts ; all done
;_______________________________________________________________________
;
; Routine: jsr FlushIfDisabled
; Inputs: none
; Outputs: none
; Destroys: A, X, n, z
; Calls: FlushTrackCache
; Called by: SWIMCacheControl, SetUpDrive
;
; Function: Checks to see if Track Cacheing is enabled, and if not, calls
; FlushTrackCache to invalidate it.
;
;_______________________________________________________________________
entry FlushIfDisabled
FlushIfDisabled lda CacheEnabled ; see if cache is enabled
beq FlushTrackCache ; if disabled, flush it
rts ; if enabled, leave it alone
endwith
endwith
endproc
title 'IOP SWIM Driver - Find Cache Entry'
;_______________________________________________________________________
;
; Routine: jsr FindCacheEntry
; Inputs: PhysCylinder - Physical Cylinder number
; PhysHead - Physical Head number
; PhysSectsPerHead- Physical Number of Sectors per head on this Cylinder
; Outputs: CacheMRUPtr - Index of cache entry for this Cylinder/Head
; X - loaded with CacheMRUPtr
; Destroys: A, X, Y, n, v, z, c
; Calls: none
; Called by: SetupTrackInfo, SWIMFormatVerify
;
; Function: Searches the track cache for an entry matching this cyl/head.
; If it is not found in the cache, an entry will be created in the
; cache (replacing an invalid entry, or the least recently used
; entry if all entries were valid). The cache entry for this
; track will be updated to be the most recently used entry.
;
;_______________________________________________________________________
seg 'code'
FindCacheEntry proc
with SWIMVarsZ
with SWIMVars
with SectorBuffers
ldy #-1 ; indicate that no invalid entries found
lda <CacheMRUPtr ; search the cache in MRU order
bra @searchStart ; enter the search loop
@invalid tay ; remember the last invalid entry found
@searchNext lda CacheNextMRU,x ; get index of next entry to search
bmi @searchEnd ; if end of list, exit
@searchStart tax ; setup index to current entry to check
bit CacheInvalidCount,x ; see if entry is valid
bmi @invalid ; if invalid, don't bother with compare
lda CacheCylinder,x ; get the cylinder number of the cache entry
cpa <PhysCylinder ; see if it matches
bne @searchNext ; if not, go on to next entry
lda CacheHead,x ; get the head number of the cache entry
cpa <PhysHead ; see if it matches
bne @searchNext ; if not, go on to next entry
bra @match ; if both match, we found the entry
; No match was found, so we need to create an entry, and reclaim an existing entry.
; We will first try to reclaim an invalid entry, but if all entries were valid,
; we will reclaim the least recently used valid entry.
@searchEnd tya ; see if any invalids found
bmi @createEntry ; if not, then just use the last entry
tax ; if invalid found, use it
@createEntry lda <PhysCylinder ; get the Cylinder for the entry
sta CacheCylinder,x ; update the cache entry
lda <PhysHead ; get the Head for the entry
sta CacheHead,x ; update the cache entry
lda <PhysSectsPerHead ; get the sector count
sta CacheInvalidCount,x ; all of the sectors are invalid
; invalidate the buffer status of each sector on this track
tay ; setup loop counter
clc ; setup for addition
adc CacheBufferNum,x ; point past end of buffer list
phx ; preserve cache index
tax ; setup status index
@statusLoop dex ; point to previous entry
stz BufferStatus,x ; clear the status
dey ; decrement the buffer count
bne @statusLoop ; loop for all buffers
plx ; restore cache index
; We now have a valid entry in the cache, and we must promote it to be the head
; of the Most Recently Used (MRU) list.
@match cpx <CacheMRUPtr ; see if already MRU
beq @done ; of so, we're all done
txa ; setup index to search for
ldy #-1 ; loop counter/index
@MRUloop iny ; inc counter/index
cpa CacheNextMRU,y ; look for entry that points to new MRU
bne @MRUloop ; loop until it is found
lda CacheNextMRU,x ; get successor of new MRU
sta CacheNextMRU,y ; remove new MRU entry from chain
lda <CacheMRUPtr ; get pointer to old MRU entry
sta CacheNextMRU,x ; new MRU entry points to old MRU entry
stx <CacheMRUPtr ; mark new entry as MRU
@done rts ; return with valid MRU entry
endwith
endwith
endwith
endproc
title 'IOP SWIM Driver - Prefetch Into Cache'
;_______________________________________________________________________
;
; Routine: jsr PrefetchIntoCache
; Inputs: CacheEnabled - Track cache enabled flag
; CurrentDrive - Drive that is currently spinning (zero if none)
; LastActiveDrive - Drive that was most recently spinning (zero if none)
; PrefetchActive - Flag indicating that prefetcher is active
; DriverActive - Flag indicating that driver is active
; RequestPending - Flag indicating that a request is pending
; CurSectsPerHead - Sectors per head for current track (zero if unknown)
; CurHeadsPerCyl - Number of heads per cylinder for this disk
; CacheMRUPtr - Index of cache entry for this Cylinder/Head
; Outputs: Prefetch data is read into the cache (validating the entries)
; Destroys: A, X, Y, n, v, z, c
; Calls: WaitDriveReady, SkipSectorData, ReadSectorHdr, ReadSectorData
; Called by: PollingTask
;
; Function: Reads sectors from all of the heads on the current cylinder
; of the spinning disk drive, into the track cache.
;
; The heads are read in Cache MRU order. Invalid tracks in
; the cache will be validated with any remaining track that
; were not already in the cache (without moving the head).
;
;_______________________________________________________________________
seg 'code'
PrefetchIntoCache proc
with SWIMVarsZ
with SWIMVars
with SectorBuffers
entry SkipSectorData
lda CacheEnabled ; see if cache is enabled
beq PrefetchDone ; if disabled, don't prefetch
lda <CurrentDrive ; see which drive is spining
beq PrefetchDone ; if none, quit
cpa <LastActiveDrive ; see if it matches last active drive
beq PrefetchTrack ; if so, find a track to prefetch
PrefetchDone stz PrefetchActive ; indicate that prefetcher is idle
stz <DriverActive ; let driver run
lda #$FF ; mask to check all bits
trb RequestPending ; see if a request is pending
beq @exit ; if not, just return
jmp HandleRCVMsg2 ; if pending, go run it
@exit rts
PrefetchTrack lda CurSectsPerHead ; get sectors per head for this track
beq PrefetchDone ; if invalid, don't prefetch
sta <PhysSectsPerHead ; remember it for ReadSectorHdr
lda #-1 ; starting head - 1
@nextHead ina ; try next higher head
cpa CurHeadsPerCyl ; see if still in range
bge PrefetchDone ; exit if all heads searched
sta <SeekingHead ; remember head to read from
ldy #-1 ; indicate that no invalid entries found
lda <CacheMRUPtr ; search the cache in MRU order
bra @searchStart ; enter the search loop
@invalid tay ; remember the last invalid entry found
@searchNext lda CacheNextMRU,x ; get index of next entry to search
bmi @searchEnd ; if end of list, exit
@searchStart tax ; setup index to current entry to check
bit CacheInvalidCount,x ; see if entry is valid
bmi @invalid ; if invalid, don't bother with compare
lda <SeekingCylinder ; get the current cylinder number
cpa CacheCylinder,x ; see if it matches
bne @searchNext ; if not, go on to next entry
lda CacheInvalidCount,x ; see if any invalid entries need to be filled
bne @searchFound ; if so, fill this cache entry
lda CacheHead,x ; get the head number of the cache entry
cpa <SeekingHead ; see if it matches
beq @nextHead ; if so, go on to next head
bra @searchNext ; otherwise, go on to next entry
@searchEnd tya ; see if any invalids found
bmi PrefetchDone ; if not, then just use the last entry
tax ; if invalid found, use it
lda <SeekingCylinder ; get the current cylinder number
sta CacheCylinder,x ; update the cylinder in case we use this entry
lda <SeekingHead ; get the head number to fill
sta CacheHead,x ; validate the head
lda <PhysSectsPerHead ; get number of sectors for this head
sta CacheInvalidCount,x ; mark all of the sectors invalid
tay ; setup loop counter
clc ; setup for addition
adc CacheBufferNum,x ; point past end of buffer list
phx ; preserve cache index
tax ; setup status index
@invalidateLoop dex ; point to previous entry
stz BufferStatus,x ; clear the status
dey ; decrement the buffer count
bne @invalidateLoop ; loop for all buffers
plx ; restore cache index
@searchFound lda CacheHead,x ; get the head of the matching entry
sta <SeekingHead ; mark it as the head to read
lda CacheBufferNum,x ; get starting buffer number for this track
sta <BaseBufferNum ; remember the starting buffer for this track
stx PrefetchCachePtr ; remember the cache entry pointer
lda #$FF ; give lots of sectors left
sta <WrongSectsLeft ; to force sleep
sta PrefetchActive ; indicate that we are sleeping during prefetch
sta <DriverActive ; driver is active while waiting ready
jsr WaitDriveReady ; make sure the drive is ready
bne @toPrefetchDone ; if not, don't bother prefetching
stz <DriverActive ; let driver run during sleep
jsr SkipSectorData ; sleep to give time to other tasks
lda <CurrentDrive ; see which drive is spining
beq @toPrefetchDone ; if none, quit
cpa <LastActiveDrive ; see if it matches last active drive
bne @toPrefetchDone ; if not, quit
lda #$FF ; awake again, driver active
sta <DriverActive ; mark active in case of ints during DMA
jsr ReadSectorHdr ; look for a sector
bcs @nextSect ; ignore all errors
assert ReadDataValid=$80 ; sign bit is valid bit
bmi @nextSect ; if already in cache, just ignore it
jsr ReadSectorData ; read the data into the cache
bne @nextSect ; ignore all errors
ldx PrefetchCachePtr ; get index to current cache entry
dec CacheInvalidCount,x ; decrement the invalid entry count
ldx <SectBufferNum ; get the buffer number for this sector
lda #ReadDataValid ; mark the buffer data valid
sta BufferStatus,x ; set ReadDataValid, clear IORequested
@nextSect jmp PrefetchIntoCache ; loop until timeout
@toPrefetchDone jmp PrefetchDone
endwith
endwith
endwith
endproc
title 'IOP SWIM Driver - Get Drive Status'
;_______________________________________________________________________
;
; Routine: jsr GetDriveStatus
; Inputs: A - High byte of StatusMsg address
; X - DriveNumber
; Outputs: none
; Destroys: A, X, Y, n, z, c
; Cycles: 693..757
; Calls: TranslateStatus (internal routine)
; Called by: SWIMDriveStatus, PollingTask, SWIMFormat, SWIMFormatVerify
;
; Function: Given a drive number and a pointer to a Message Buffer,
; this routine returns the status information for that drive
; and the disk that may be inserted in that drive.
;
;_______________________________________________________________________
seg 'code'
GetDriveStatus proc
entry StatusTables
entry DefaultStatus
entry DriveStatusPtrs
entry MediaStatusPtrs
entry FmtStatusPtrs
entry DriveAttributes
with SWIMVarsZ
with SWIMVars
ldy <StatusMsgPtr+1 ; save old status message pointer
phy ; push it onto the stack
sta <StatusMsgPtr+1 ; create new status message pointer
lda DiskFormat,x ; get the disk format for the disk
pha ; save it for later
lda MediaKind,x ; get the media kind for the disk
pha ; save it for later
lda DriveKind,x ; get the drive kind for the drive
pha ; save it for later
lda CylinderValid,x ; get the current Cylinder (high byte)
ldy #StatTrackH ; setup the index into the status message
sta (<StatusMsgPtr),y ; move it to the status message
lda CurrentCylinder,x ; get the current Cylinder (low byte)
ldy #StatTrackL ; setup the index into the status message
sta (<StatusMsgPtr),y ; move it to the status message
lda ErrorCountH,x ; get the error count (high byte)
ldy #StatDiskErrorsH ; setup the index into the status message
sta (<StatusMsgPtr),y ; move it to the status message
lda ErrorCountL,x ; get the error count (low byte)
ldy #StatDiskErrorsL ; setup the index into the status message
sta (<StatusMsgPtr),y ; move it to the status message
ldy PhysDriveNumber,x ; get the Physical Drive number
lda DriveAttributes,y ; get the drive attributes
ldy #StatDriveAttr ; setup the index into the status message
sta (<StatusMsgPtr),y ; move it to the status message
lda DriveFlags,x ; get the Drive Flags
and #WriteEnabledFlag ; see if write enabled
beq UpdateWrProt ; branch if write protected (a = 0)
lda #$01 ; return $00 if write enabled
UpdateWrProt dea ; return $FF if write protected
ldy #StatWrProtected ; setup the index into the status message
sta (<StatusMsgPtr),y ; move it to the status message
ldx #DefaultStatus-StatusTables ; get ptr to defaults table
jsr TranslateStatus ; translate the Default
ply ; get the drive kind for the drive
ldx DriveStatusPtrs,y ; find start of table for this drive kind
jsr TranslateStatus ; translate the Drive status
ply ; get the media kind for the disk
ldx MediaStatusPtrs,y ; find start of table for this media kind
jsr TranslateStatus ; translate the Format status
ply ; get the disk format for the drive
ldx FmtStatusPtrs,y ; find start of table for this disk format
jsr TranslateStatus ; translate the Format status
ply ; pop old status message pointer
sty <StatusMsgPtr+1 ; restore it
rts ; all done
XlateLoop inx ; point to data byte
lda StatusTables,x ; get the data byte
sta (<StatusMsgPtr),y ; move it to the status message
inx ; point to next index byte
TranslateStatus ldy StatusTables,x ; get the message index byte
bne XlateLoop ; loop through all bytes
rts ; all done
endwith
endwith
endproc
seg 'constants'
StatusConstants proc
entry StatusTables
entry DefaultStatus
entry DriveStatusPtrs
entry MediaStatusPtrs
entry FmtStatusPtrs
entry DriveAttributes
entry FmtIndexTable
StatusTables
; Default status values returned
DefaultStatus dc.b StatDiskInPlace,$01
dc.b StatInstalled,$01
dc.b StatTwoSidedFmt,$FF
dc.b StatDriveInfoB3,$00
dc.b StatDriveInfoB2,$00
dc.b StatMfmDrive,$00
dc.b StatMfmDisk,$00
dc.b StatMfmFormat,$00
dc.b StatDiskCtlr,$FF
dc.b StatCurrentFmtH,$00
dc.b StatFmtAllowedH,$00
dc.b StatDiskSizeB3,$00
dc.b StatDiskSizeB2,$00
dc.b StatIconFlags,$00
dc.b StatSpare,$00
dc.b $00
; Tables based on Drive Kind
; unknown drive kind info
NoDrive dc.b StatInstalled,$FF
dc.b StatSides,$00
dc.b StatNewIntFace,$00
dc.b StatDriveType,noDriveKind
dc.b $00
; HD-20 drive kind info
HD20Drive dc.b StatSides,$00
dc.b StatNewIntFace,$00
dc.b StatDriveType,HD20DriveKind
dc.b StatFmtAllowedL,$01
dc.b StatCurrentFmtL,$01
dc.b StatIconFlags,$03
dc.b $00
; 400K GCR drive kind info
SSGCRDrive dc.b StatSides,$00
dc.b StatNewIntFace,$00
dc.b StatDriveType,SSGCRDriveKind
dc.b StatFmtAllowedL,$02
dc.b $00
; 400K / 800K GCR drive kind info
DSGCRDrive dc.b StatSides,$FF
dc.b StatNewIntFace,$FF
dc.b StatDriveType,DSGCRDriveKind
dc.b StatFmtAllowedL,$06
dc.b $00
; 400K / 800K GCR, 720K / 1440K MFM drive kind info
DSMFMGCRDrive dc.b StatSides,$FF
dc.b StatNewIntFace,$FF
dc.b StatDriveType,DSMFMGCRDriveKind
dc.b StatMfmDrive,$FF
dc.b StatFmtAllowedL,$0E
dc.b $00
; Tables based on Media Kind
; no media kind info
NoMedia dc.b StatDiskInPlace,$00
dc.b StatFmtAllowedL,$00
dc.b StatCurrentFmtL,$00
dc.b $00
LoDenMedia dc.b StatCurrentFmtL,$02
dc.b $00
HiDenMedia dc.b StatFmtAllowedL,$10
dc.b StatCurrentFmtL,$10
HD20Media dc.b $00
; Tables based on Disk Format Kind
; unknown format kind info
NoFmt dc.b StatDiskInPlace,$02
; unchecked format kind info
UnCheckedFmt dc.b StatTwoSidedFmt,$00
dc.b StatDiskSizeB1,$00
dc.b StatDiskSizeB0,$00
dc.b $00
; HD-20 format kind info
HD20Fmt dc.b StatDiskInPlace,$08
dc.b StatTwoSidedFmt,$00
dc.b StatDiskSizeB1,$98 ; $9835 = 38965
dc.b StatDiskSizeB0,$35
dc.b $00
; 400K GCR format kind info
GCR400KFmt dc.b StatDiskInPlace,$02
dc.b StatTwoSidedFmt,$00
dc.b StatDiskSizeB1,$03 ; $0320 = 800
dc.b StatDiskSizeB0,$20
dc.b $00
; 800K GCR format kind info
GCR800KFmt dc.b StatDiskInPlace,$02
dc.b StatCurrentFmtL,$04
dc.b StatDiskSizeB1,$06 ; $0640 = 1600
dc.b StatDiskSizeB0,$40
dc.b $00
; 720K MFM format kind info
MFM720KFmt dc.b StatDiskInPlace,$02
dc.b StatMfmDisk,$FF
dc.b StatCurrentFmtL,$08
dc.b StatDiskSizeB1,$05 ; $05A0 = 1440
dc.b StatDiskSizeB0,$A0
dc.b $00
; 1440K MFM format kind info
MFM1440KFmt dc.b StatDiskInPlace,$02
dc.b StatMfmDisk,$FF
dc.b StatMfmFormat,$FF
dc.b StatDiskSizeB1,$0B ; $0B40 = 2880
dc.b StatDiskSizeB0,$40
dc.b $00
; 400K/800K GCR on HD media format kind info
GCRonHDFmt dc.b StatDiskInPlace,$03
dc.b StatMfmDisk,$FF
dc.b StatMfmFormat,$FF
dc.b StatFmtAllowedL,$10
dc.b StatCurrentFmtL,$10
dc.b StatDiskSizeB1,$0B ; $0B40 = 2880
dc.b StatDiskSizeB0,$40
dc.b $00
DriveStatusPtrs dc.b NoDrive-StatusTables ; 0 - no drive
dc.b NoDrive-StatusTables ; 1 - unspecified drive
dc.b SSGCRDrive-StatusTables ; 2 - Single Sided 400K GCR Drive
dc.b DSGCRDrive-StatusTables ; 3 - Double Sided 400K/800K GCR Drive
dc.b DSMFMGCRDrive-StatusTables ; 4 - Double Sided GCR / MFM Drive
dc.b NoDrive-StatusTables ; 5 - unspecified drive
dc.b NoDrive-StatusTables ; 6 - unspecified drive
dc.b HD20Drive-StatusTables ; 7 - HD-20 drive
dc.b NoDrive-StatusTables ; 8 - unspecified drive
MediaStatusPtrs dc.b NoMedia-StatusTables ; 0 - No Media kind
dc.b LoDenMedia-StatusTables ; 1 - unknown media kind
dc.b HD20Media-StatusTables ; 2 - HD-20 media
dc.b LoDenMedia-StatusTables ; 3 - Low Density media
dc.b HiDenMedia-StatusTables ; 4 - High Density media
FmtStatusPtrs dc.b UnCheckedFmt-StatusTables ; 0 - uncheckedFormat
dc.b NoFmt-StatusTables ; 1 - unknownFormat
dc.b HD20Fmt-StatusTables ; 2 - HD20Format
dc.b GCR400KFmt-StatusTables ; 3 - GCR400Kformat
dc.b GCR800KFmt-StatusTables ; 4 - GCR800Kformat
dc.b MFM720KFmt-StatusTables ; 5 - MFM720Kformat
dc.b MFM1440KFmt-StatusTables ; 6 - MFM1440Kformat
dc.b 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
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
endproc
title 'IOP SWIM Driver - Check Static Attributes'
;_______________________________________________________________________
;
; Routine: jsr CheckStaticAttr
; Inputs: X - Drive Number
; Outputs: none
; Destroys: A, Y, n, z, c
; Calls: AdrAndSense
; 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.
;
;_______________________________________________________________________
seg 'code'
CheckStaticAttr proc
with SWIMVars
lda #LoDenMediaKind ; assume low density media
sta MediaKind,x ; indicate disk is in place
lda DriveKind,x ; check for multi-density drive
cpa #DSMFMGCRDriveKind ; see if SuperDrive
bne CheckWrEnable ; if not superdrive, media density is correct
lda #r1MegMediaAdr ; check for 1 or 2 megabyte media
jsr AdrAndSense ; test the media kind
bne CheckWrEnable ; if low density media
lda #HiDenMediaKind ; indicate High Density media in drive
sta MediaKind,x ; update media kind
CheckWrEnable lda DriveFlags,x ; get the flags
ora #WriteEnabledFlag ; assume write enabled
sta DriveFlags,x ; update flags
lda #rNoWrProtectAdr ; check write enabled/protected
jsr AdrAndSense ; test the write protect
bne Done ; if write enabled
lda DriveFlags,x ; get the flags
and #$FF-WriteEnabledFlag ; reset write enabled
sta DriveFlags,x ; update flags
Done rts ; all done
endwith
endproc
title 'IOP SWIM Driver - Set Up Drive'
;_______________________________________________________________________
;
; Routine: jsr SetUpDrive
; Inputs: A - OpenStatus error code
; n, z - status of the OpenStatus flag
; Outputs: A, n, z - error status code
; Destroys: A, X, Y, n, z
; Calls: FlushIfDisabled, TurnOffDrive, TurnOnDrive, LoadSWIMparams,
; CheckStaticAttr, WaitTMPBdone, StartReadyTimer, ReCalibrate,
; ReadSectorHdr, CreateTrackCache
; Called by: SWIMEject, SWIMRead, SWIMReadVerify, SWIMWrite, SWIMFormat,
; SWIMFormatVerify, SWIMGetRawData
;
; 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.
;
;_______________________________________________________________________
seg 'code'
SetUpDrive proc
entry FmtSearchOrder
entry FmtByteValues
entry FmtByteMasks
with SWIMVarsZ
with SWIMVars
bne SetUpDone ; return openErr if SWIM Driver not initialized
ldy ReqDriveNumber ; see what drive is requested
beq NotCurrentDrive ; zero is not a valid drive number
cpy <CurrentDrive ; see if already powered up
bne NotCurrentDrive ; if not currently powered drive
ldy #MotorTimeoutCount ; setup count of polls to wait
sty <MotorTimingOut ; start timing out motor when polling resumes
SetUpDone tay ; preserve error code
jsr FlushIfDisabled ; flush the cache if it is disabled
tya ; restore error code, set flags
rts ; drive already set up, just return
NotCurrentDrive lda #nsDrvErr ; return no such drive error if out of range
cpy #MaxDriveNumber+1 ; see if in range
bge SetUpDone ; return nsDrvErr if out of range
lda #noDriveErr ; return no drive error if drive not installed
ldx DriveKind,y ; get the drive kind
beq SetUpDone ; return noDriveErr if not installed
jsr TurnOffDrive ; turn off the old drive (whatever was selected)
jsr TurnOnDrive ; turn on the new drive
bne SetUpDone ; return error if couldn't turn on drive
txa ; get drive number
eor <LastActiveDrive ; see if same drive as last successful access
beq SetUpDone ; return with success, no drive change
stx <LastActiveDrive ; mark this drive as last active, assuming success
ldy DiskFormat,x ; see if format has been determined
beq @FirstTime ; unchecked format, first time disk is accessed
jsr LoadSWIMparams ; Load params if format is known
bra @FmtChangeDone ; drive changed, so create a new cache
@FirstTime ply ; pop pcL
sty <AsyncPcL ; save PcL
ply ; pop pcH
sty <AsyncPcH ; save PcH
jsr CheckStaticAttr ; update media kind and write enable
ldy <ReadyTMPB ; get the TMPB index
jsr WaitTMPBdone ; wait for it to time out
ldx #>ChuckingDelay ; get high byte of Disk Chucking wait time
lda #<ChuckingDelay ; get low byte of Disk Chucking wait time
jsr StartReadyTimer ; start the timer
stz FmtSearchIndex ; initialize the index
@SearchLoop ldy FmtSearchIndex ; get the index
inc FmtSearchIndex ; update the index
lda FmtSearchOrder,y ; get the format to try
ldx <CurrentDrive ; get the drive number
sta DiskFormat,x ; setup the disk format
eor #unknownFormat ; are we done
beq @SearchDone ; unknown format found, exit
jsr ReCalibrate ; establish head position
bne @SearchError ; return with error if couldn't recalibrate
stz <SeekingHead ; always read from size zero
lda #$FF ; allow any sector number
sta <PhysSectsPerHead ; setup for sector number range checking
jsr ReadSectorHdr ; try to read a sector address
bcs @SearchLoop ; if couldn't read, try next format
ldy FmtSearchIndex ; get the updated index
lda <SectHdrFmtKind ; get the disk format found
eor FmtByteValues-1,y ; compare to expected value
and FmtByteMasks-1,y ; get only the valid bits
beq @SearchDone ; if format correct, exit with success
bra @SearchLoop ; otherwise, try next format
@SearchError ldx <CurrentDrive ; get the drive number
stz DiskFormat,x ; indicate unchecked format, couldn't re-cal
@SearchDone ldy <AsyncPcH ; get PcH
phy ; restore PcH
ldy <AsyncPcL ; get PcL
phy ; restore PcL
@FmtChangeDone pha ; preserve the error code
jsr CreateTrackCache ; create a cache based on the new format
pla ; restore error code, set flags
rts ; all done
endwith
endwith
endproc
title 'IOP SWIM Driver - Check Drive Mode'
;_______________________________________________________________________
;
; Routine: jsr CheckDriveMode
; Inputs: X - Drive Number
; Outputs: z - 0 (bne) if drive mode change needed
; z - 1 (beq) if no drive mode change needed
; A - command for AdrAndStrb to change drive mode,
; only valid when z indicates change is needed
; Destroys: Y, v, c, n, z
; Calls: AdrAndSense
; 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.
;
;_______________________________________________________________________
seg 'code'
CheckDriveMode proc
with SWIMVars
lda DriveKind,x ; check the drive kind
cpa #DSMFMGCRDriveKind ; see if SuperDrive
bne ModeIsCorrect ; only superdrive supports GCR and MFM
lda #wMFMModeOnAdr ; assume MFM format
ldy DiskFormat,x ; check the format
cpy #MFM720Kformat ; 720K is only lo-den MFM format
beq CheckMode ; if 720K MFM disk
cpy #GCRonHDformat ; GCR data on HD media needs GCR mode
beq NeedGCRMode ; if GCR data on hi-density disk
ldy MediaKind,x ; check the media
cpy #HiDenMediaKind ; High density media is almost always MFM
beq CheckMode ; if High Density Media
NeedGCRMode lda #wGCRModeOnAdr ; otherwise set to GCR format
CheckMode pha ; save desired mode
lda #rMFMModeOnAdr ; prepare to see what mode the drive is in
jsr AdrAndSense ; read the status
bne InMFMMode ; if in MFM mode
InGCRMode pla ; restore desired mode
cpa #wGCRModeOnAdr ; we're in GCR mode, see if we want to be
rts ; return with A = desired mode, z = mode is correct
InMFMMode pla ; restore desired mode
cpa #wMFMModeOnAdr ; we're in MFM mode, see if we want to be
rts ; return with A = desired mode, z = mode is correct
ModeIsCorrect lda #0 ; set z, indicate mode is correct
rts ; return
endwith
endproc
title 'IOP SWIM Driver - Turn On Drive'
;_______________________________________________________________________
;
; Routine: jsr TurnOnDrive
; Inputs: ReqDriveNumber - Drive Number
; Outputs: A, n, z - error status code
; X, CurrentDrive - Drive number, (only when noErr)
; Destroys: Y, v, c
; Calls: DiskSelect, AdrAndSense, TurnOffDrive, CheckDriveMode, AdrAndStrb
; 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.
;
;_______________________________________________________________________
seg 'code'
TurnOnDrive proc
with SWIMVarsZ
with SWIMVars
ldy ReqDriveNumber ; see what drive is requested
ldx PhysDriveNumber,y ; get the new physical drive number
jsr DiskSelect ; select and enable the new drive
lda #rNoDiskInPlAdr ; prepare to see if there is a disk
jsr AdrAndSense ; read the drive status bit
beq HasMedia ; turn drive on, if there is a disk in the drive
jsr TurnOffDrive ; turn off and disable the drive if no diskette
lda #OffLinErr ; indicate that the disk was off line
rts ; all done
HasMedia ldx ReqDriveNumber ; see what drive is requested
stx <CurrentDrive ; mark new drive as powered
lda #MotorTimeoutCount ; setup count of polls to wait
sta <MotorTimingOut ; start timing out motor when polling resumes
lda #rMotorOffAdr ; prepare to test the drive motor status
jsr AdrAndSense ; see if it is off
beq 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.
jsr CheckDriveMode ; see if mode needs to change
beq TurnItOn ; no change needed, just turn on motor
jsr AdrAndStrb ; otherwise, set the drive mode first
TurnItOn lda #wMotorOnAdr ; prepare to turn the drive motor on
jsr AdrAndStrb ; turn it on
ldy <ReadyTMPB ; get the TMPB index
jsr CancelTMPBtimer ; cancel the timer in case it was running
ldx #>MotorOnDelay ; get high byte of Disk Motor On wait time
lda #<MotorOnDelay ; get low byte of Disk Motor On wait time
jsr StartReadyTimer ; start the timer
lda #>MotorOnSettle ; get high byte of settle time
sta SettleTimeH ; set high byte of Motor speed settle time
lda #<MotorOnSettle ; get low byte of settle time
sta SettleTimeL ; set low byte of Motor speed settle time
AlreadyOn ldx <CurrentDrive ; return current drive number
lda #noErr ; return successful status
rts ; all done
endwith
endwith
endproc
title 'IOP SWIM Driver - Turn Off Drive'
;_______________________________________________________________________
;
; Routine: jsr TurnOffDrive
; Inputs: none
; Outputs: none
; Destroys: A, Y, n, z
; Calls: AdrAndStrb, CancelTMPBtimer
; Called by: SWIMInitialize, PollingTask, SWIMEject, SetUpDrive, TurnOnDrive,
; WaitDriveReady, ReCalibrate
;
; Function: Immediatly turns off the motor and disables the drive
; that was currently enabled.
;
;_______________________________________________________________________
seg 'code'
TurnOffDrive proc
with SWIMVarsZ
with SWIMVars
stz <CurrentDrive ; indicate that no drive is powered
stz <MotorTimingOut ; indicate timeout expired
lda #wMotorOffAdr ; motor off drive command
jsr AdrAndStrb ; send the command to the drive
lda #StartAction\
+WriteMode ; prepare to clear action and write mode
sta wZeroes ; clear action and write mode (prepare for motoroff)
lda #MotorOn+Drive1Enabled\
+Drive2Enabled ; prepare to disable the drive
sta wZeroes ; clear the enables
stz SettleTimeH ; ignore any pending settle time
stz SettleTimeL ; ignore any pending settle time
ldy <ReadyTMPB ; get the TMPB index
jmp CancelTMPBtimer ; cancel the timer and return
endwith
endwith
endproc
title 'IOP SWIM Driver - Wait Drive Ready'
;_______________________________________________________________________
;
; Routine: jsr WaitDriveReady
; Inputs: none
; Outputs: A, n, z - error status code
; Destroys: A, X, Y, n, z
; Calls: WaitTMPBdone, AdrAndSense, CancelTMPBTimer, StartTMPBTimer,
; StartReadyTimer, WaitTMPBdone,TurnOffDrive
; Called by: SWIMEject, SWIMRead, SWIMReadVerify, SWIMWrite, SWIMFormat,
; SWIMFormatVerify, SWIMGetRawData, PrefetchIntoCache, ReCalibrate,
; Seek
;
; 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.
;
;_______________________________________________________________________
seg 'code'
WaitDriveReady proc
with SWIMVarsZ
with SWIMVars
pla ; pop pcL
plx ; pop pcH
ldy <ReadyTMPB ; get the TMPB index
jsr WaitTMPBdone ; wait for initial delay to time out
phx ; push pcH
pha ; push pcL
lda #<0-ReadyTimeoutCount ; low byte of max polls counter
sta WaitReadyCount ; initialize low byte of counter
lda #>0-ReadyTimeoutCount ; high byte of max polls counter
sta WaitReadyCount+1 ; initialize high byte of counter
WaitReadyLoop lda #rNotReadyAdr ; prepare to test ready
jsr AdrAndSense ; test drive ready
bne NotReady ; if not ready, sleep and try again
lda SettleTimeH ; get high byte of Motor speed settle time
ora SettleTimeL ; get low byte of Motor speed settle time
bne StartSettleTimer ; start timer if needed
* lda #noErr ; return No Error status if drive is ready
rts ; return with success
StartSettleTimer
ldy SettledTMPB ; get the TMPB index
jsr CancelTMPBTimer ; cancel any old timeout
ldy SettledTMPB ; get the TMPB index
ldx SettleTimeH ; get high byte of Motor speed settle time
lda SettleTimeL ; get low byte of Motor speed settle time
jsr StartTMPBTimer ; start the timer
stz SettleTimeH ; remember that timer was started
stz SettleTimeL ; remember that timer was started
lda #noErr ; return No Error status if drive is ready
rts ; return with success
NotReady ldx #>ReadyPollRate ; get high byte of poll rate
lda #<ReadyPollRate ; get low byte of poll rate
jsr StartReadyTimer ; start the timer
pla ; pop pcL
plx ; pop pcH
ldy <ReadyTMPB ; get the TMPB index
jsr WaitTMPBdone ; wait for it to time out
phx ; push pcH
pha ; push pcL
inc WaitReadyCount ; increment the timeout counter
bne WaitReadyLoop ; no carry out, check drive ready
inc WaitReadyCount+1 ; increment high byte of counter
bne WaitReadyLoop ; count not exhausted, check drive ready
jsr TurnOffDrive ; timed out, turn off the drive
lda #spdAdjErr ; timed out, indicate error
rts ; return with error
endwith
endwith
endproc
title 'IOP SWIM Driver - Wait Motor Settled'
;_______________________________________________________________________
;
; Routine: jsr WaitMotorSettled
; Inputs: none
; Outputs: none
; Destroys: Y, n, z
; Calls: WaitTMPBdone
; Called by: SWIMWrite, SWIMFormat
;
; 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.
;
;_______________________________________________________________________
seg 'code'
WaitMotorSettled proc
with SWIMVars
ldy SettledTMPB ; get the TMPB index
jmp WaitTMPBdone ; wait for settle time to expire
endwith
endproc
title 'IOP SWIM Driver - Start Ready Timer'
;_______________________________________________________________________
;
; Routine: jsr StartReadyTimer
; Inputs: A - low byte of sleep count
; X - high byte of sleep count
; Outputs: none
; Destroys: A, X, Y, n, v, z, c
; Calls: StartTMPBTimer
; Called by: SetUpDrive, TurnOnDrive, WaitDriveReady, SleepShort, SleepLong,
; ReCalibrate, Seek, ReadMFMData, WriteDataBuffer
;
; Function: Starts the Ready wait timer using the supplied values.
;
;_______________________________________________________________________
seg 'code'
StartReadyTimer proc
with SWIMVarsZ
with SWIMVars
stz <ADBActivityMask ; give disk priority next time
ldy <ReadyTMPB ; get the TMPB index
sta TMPBtimeL,y ; store low byte into the TMPB
txa ; get high byte of poll rate
sta TMPBtimeH,y ; store it into the TMPB
jmp StartTMPBTimer ; start the timer, and return
endwith
endwith
endproc
title 'IOP SWIM Driver - SleepShort / SleepLong'
;_______________________________________________________________________
;
; Routine: jsr SleepShort, SleepLong
; Inputs: A - low byte of sleep count
; X - high byte of sleep count (SleepLong only, > 33.333333 ms)
; Outputs: none
; Destroys: A, X, Y, n, v, z, c
; Calls: StartReadyTimer, WaitTMPBdone
; Called by: SWIMEject, SkipSectorData, FmtMFMTrack
;
; Function: Sleeps for the specified amount of time.
;
;_______________________________________________________________________
seg 'code'
SleepShort proc
entry SleepLong
with SWIMVarsZ
with SWIMVars
ldx #0 ; high byte is zero (0 .. 33.333333 ms)
SleepLong jsr StartReadyTimer ; start the timer
ldy <ReadyTMPB ; get the TMPB index
jmp WaitTMPBdone ; return after it times out
endwith
endwith
endproc
title 'IOP SWIM Driver - Re-Calibrate heads to cylinder 0'
;_______________________________________________________________________
;
; Routine: jsr ReCalibrate
; Inputs: CurrentDrive - active drive number
; Outputs: A - error status code
; n,z - based on value returned in A
; SeekingCylinder - 0 (cylinder number that we are seeking)
; Destroys: A, X, Y, n, z, c
; Calls: InitSWIMChip, TurnOnDrive, CheckDriveMode, AdrAndStrb, WaitTMPBdone,
; StartReadyTimer, WaitDriveReady, Seek, AdrAndSense, TurnOffDrive
; Called by: SWIMEject, SWIMRead, SWIMReadVerify, SWIMWrite, SWIMFormat, 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.
;
;_______________________________________________________________________
seg 'code'
ReCalibrate proc
with SWIMVarsZ
with SWIMVars
pla ; pop pcL
sta ReCalPcL ; save pcL
pla ; pop pcH
sta ReCalPcH ; save pcH
ldx <CurrentDrive ; get current drive number
stz CurrentCylinder,x ; indicate current Cylinder is zero
stz <SeekingCylinder ; indicate which cylinder we are seeking
jsr InitSWIMChip ; Re-Initialize the disk controller chip
bne ReCalErrA ; return with error status if couldn't init
jsr TurnOnDrive ; re-select and power the drive
bne ReCalErrA ; return with error status if couldn't turn on
jsr CheckDriveMode ; see if mode needs to change
beq ReCalStart ; if mode is OK, don't change is
jsr AdrAndStrb ; change the drive mode
ldy <ReadyTMPB ; get the TMPB index
jsr WaitTMPBdone ; wait for 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.
ldx #>MotorOnDelay ; get high byte of Disk Motor On wait time
lda #<MotorOnDelay ; get low byte of Disk Motor On wait time
jsr StartReadyTimer ; start the timer
lda #>MotorOnSettle ; get high byte of settle time
sta SettleTimeH ; set high byte of Motor speed settle time
lda #<MotorOnSettle ; get low byte of settle time
sta SettleTimeL ; set low byte of Motor speed settle time
ReCalStart jsr WaitDriveReady ; wait for the motor to be ready
bne ReCalErrA ; return error if motor not ready
ldx <CurrentDrive ; get current drive number
stz CylinderValid,x ; indicate current Cylinder is valid
lda #LastCylinder ; worst case is that we are at the end
sta CurrentCylinder,x ; make beleive that we are there
ldy #0 ; we want to go to cylinder zero
jsr Seek ; seek to zero
jsr WaitDriveReady ; wait for the heads to move
bne ReCalErrA ; return error if couldn't seek
ldx #noErr ; setup success code, just in case
lda #rNotTrack0Adr ; see if we found cylinder zero
jsr AdrAndSense ; test the flag
beq ReCalErrX ; return success if cylinder zero was found
ldx #tk0BadErr ; setup error code, just in case
ReCalErrX txa ; get error code
ReCalErrA ldx <CurrentDrive ; get current drive number
sta CylinderValid,x ; indicate current Cylinder is zero (if no err)
sta CurrentCylinder,x ; indicate current Cylinder is zero (if no err)
tay ; test error code
beq ReCalDone ; no error, restore pc and return
stz DiskFormat,x ; indicate un-checked format kind
pha ; preserve error code
jsr TurnOffDrive ; couldn't re-cal, turn off the drive
pla ; restore error code
ReCalDone ldx ReCalPcH ; get pcH
phx ; restore pcH
ldx ReCalPcL ; get pcL
phx ; restore pcL
tax ; test error code, set flags
rts ; all done
endwith
endwith
endproc
title 'IOP SWIM Driver - Seek heads to cylinder'
;_______________________________________________________________________
;
; Routine: jsr Seek
; Inputs: CurrentDrive - active drive number
; Y - Desired cylinder number
; Outputs: A - error status code
; n,z - based on value returned in A
; SeekingCylinder - cylinder number that we are seeking
; CurSectsPerHead - Zero, to indicate unknown
; Destroys: X, Y, n, z, c
; Calls: AdrAndStrb, AdrAndSense, Sense, Pulse, WaitTMPBdone,
; StartReadyTimer, LoadSWIMparams
; Called by: SWIMEject, SWIMRead, SWIMReadVerify, SWIMWrite, SWIMFormat,
; SWIMFormatVerify, SWIMGetRawData, 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.
;
;_______________________________________________________________________
seg 'code'
Seek proc
with SWIMVarsZ
with SWIMVars
stz <DMARetryStatus ; new track, allow ints during DMA requests
stz CurSectsPerHead ; new track, don't prefetch unless ReadSectorHdr called
sty <SeekingCylinder ; indicate which cylinder we are seeking
lda #ParamErr ; return paramater error if cylinder too high
cpy #LastCylinder+1 ; check for out of range
bge SeekDone ; if out of range, return with error
ldx <CurrentDrive ; get the active drive number
lda CylinderValid,x ; see if cylinder is valid
bne SeekDone ; if invalid, return with error
lda CurrentCylinder,x ; get current cylinder
sta <StepCount ; setup current cylinder for subtraction
tya ; get desired cylinder
sta CurrentCylinder,x ; update current cylinder (to desired)
sec ; setup carry for subtract
sbc <StepCount ; step count := desired - current
beq SeekDone ; no seek needed if on cylinder (A=0, noErr)
ldy #wDirNextAdr ; set direction away from cylinder zero
bge SeekStart ; start seeking ahead if positive
eor #$FF ; prepare to negate
ina ; step count := current - desired
ldy #wDirPrevAdr ; set direction towards cylinder zero
SeekStart sta <StepCount ; save step count
tya ; get the step direction
jsr AdrAndStrb ; set the step direction
lda #rStepOffAdr ; see if last step pulse accepted
jsr AdrAndSense ; test the flag
ldx #1 ; 1 poll, must be right the first time
; The drive can accept step pulses spaced at 72µsec max. We turn step on, and the drive
; will turn it off when it is ready to accept the next step pulse. There appears to be
; an undocumented drive spec which causes the drive to ignore step pulses if they are sent
; less than 18µsec after the drive indicated that it was OK to sent the next step. To avoid
; this problem, we add an additional short (but not > 72µs) delay before sending each step.
SeekLoop jsr Sense ; see if OK to send a step pulse
beq SeekPoll ; wait until OK to send a step pulse
dec <StepCount ; decrement the loop counter
bmi SeekWait ; start waiting when no more left to do
ldx #4 ; ≈10µsec additional delay (to wait at least 18µsec)
StepDelay dex ; decrement delay count
bne StepDelay ; wait a short time before sending step pulse
assert rStepOffAdr=wStepOnAdr
jsr Pulse ; send a step pulse
ldx #10+1 ; allow 10 polls before timeout
SeekPoll dex ; decrement poll count
bne SeekLoop ; try again until count runs out
lda #cantStepErr ; couldn't send a step pulse
SeekError ldx <CurrentDrive ; get the active drive number
sta CylinderValid,x ; invalidate the cylinder
sta CurrentCylinder,x ; setup cylinder number too
SeekDone tax ; test error code, set flags
rts ; all done
SeekWait pla ; pop pcL
plx ; pop pcH
ldy <ReadyTMPB ; get the TMPB index
jsr WaitTMPBdone ; wait for prior waits to time out
phx ; push pcH
pha ; push pcL
ldx #>SeekDelay ; get high byte of Seek initial wait time
lda #<SeekDelay ; get low byte of Seek initial wait time
jsr StartReadyTimer ; start the timer
jsr LoadSWIMparams ; setup params based upon new cylinder
bne SeekError ; if couldn't load params
rts ; return with success
endwith
endwith
endproc
title 'IOP SWIM Driver - Block To Physical Address'
;_______________________________________________________________________
;
; Routine: jsr BlockToPhysAddr
; Inputs: CurrentDrive - active drive number
; LogicalBlockH/L - Logical Block Number
; Outputs: A - error status code
; n,z - based on value returned in A
; 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: X, Y, n, z, c
; Calls: none
; Called by: ReadWriteSetUp, SetupTrackInfo, SWIMFormat, SWIMFormatVerify
;
; 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)
;
;_______________________________________________________________________
seg 'code'
BlockToPhysAddr proc
entry BlockXlateTable
entry BlockXlateHeadsPerCyl
entry BlockXlateSectsPerHead
entry BlockXlateSectsPerCyl
entry BlockXlateCylBias
entry BlockXlateBlockLimit
with SWIMVarsZ
with SWIMVars
ldy <CurrentDrive ; get the active drive number
ldx DiskFormat,y ; see what format to read
ldy BlockXlateTable,x ; Get the translate table index
ldx <LogicalBlockL ; get low byte of block number
lda <LogicalBlockH ; get high byte of block number
sta <PhysSector ; update high byte of block number
bra @SearchStart ; start searching for the cylinder group
@SearchLoop txa ; get low byte of block number
sec ; setup carry for subtraction
sbc BlockXlateBlockLimit+0,y ; compare to / subtract limit
tax ; save updated block number
lda <PhysSector ; get high byte of block number
sbc BlockXlateBlockLimit+1,y ; compare to / subtract limit
bcc @SearchDone ; exit if block number below limit
sta <PhysSector ; update high byte of block number
tya ; point to next record (y := y + 5)
adc #5-1 ; (carry set from above)
tay ; y := y + 5
@SearchStart lda BlockXlateSectsPerHead,y ; see if end if list
bne @SearchLoop ; not the end, keep on searching
lda #paramErr ; indicate block number too big for this format
rts ; return with error status
@SearchDone lda BlockXlateSectsPerCyl,y ; get sectors per cylinder
sta <PhysSectsPerCyl ; save sectors per cylinder
lda BlockXlateSectsPerHead,y; get sectors per head
sta <PhysSectsPerHead ; save sectors per head
lda BlockXlateCylBias,y ; get starting cylinder number
sta <PhysCylBias ; save starting cylinder number
txa ; get low byte of block offset
adc BlockXlateBlockLimit+0,y ; undo subtract from loop
asl a ; shift to setup loop
sta <PhysCylinder ; Low byte of numerator, quotient
lda <PhysSector ; get high byte of block number
ldy #8-1 ; divide loop counter
@CylinderLoop rol a ; shift high byte of numerator
cpa <PhysSectsPerCyl ; compare to denominator
bcc @CylinderShift ; if N < D, don't subtract, just shift
sbc <PhysSectsPerCyl ; if N >= D, subtract denominator
@CylinderShift rol <PhysCylinder ; shift in quotient bit
dey ; decrement loop counter
bpl @CylinderLoop ; loop through all 8 bits
sta <PhysCylSector ; sector number relative to beginning of cylinder
sec ; setup carry for subtraction
@HeadLoop iny ; move on to next head
tax ; save sector number for exit
sbc <PhysSectsPerHead ; adjust sector number
bcs @HeadLoop ; if sector >= PhysSectsPerHead, loop
sty <PhysHead ; update head number
stx <PhysSector ; update sector number
lda <PhysCylinder ; get cylinder offset
adc <PhysCylBias ; bias by starting cylinder number
sta <PhysCylinder ; update cylinder number
lda #noErr ; indicate success
rts ; all done
endwith
endwith
endproc
seg 'constants'
BlockXlateTable proc
entry BlockXlateHeadsPerCyl
entry BlockXlateSectsPerHead
entry BlockXlateSectsPerCyl
entry BlockXlateCylBias
entry BlockXlateBlockLimit
dc.b UnknownTable-TableBase ; 0 - uncheckedFormat
dc.b UnknownTable-TableBase ; 1 - unknownFormat
dc.b UnknownTable-TableBase ; 2 - HD20Format
dc.b GCR400KTable-TableBase ; 3 - GCR400Kformat
dc.b GCR800KTable-TableBase ; 4 - GCR800Kformat
dc.b MFM720KTable-TableBase ; 5 - MFM720Kformat
dc.b MFM1440KTable-TableBase ; 6 - MFM1440Kformat
dc.b GCRonHDTable-TableBase ; 7 - GCRonHDformat
dc.b UnknownTable-TableBase ; 8 - reserved for future use
dc.b UnknownTable-TableBase ; 9 - reserved for future use
dc.b UnknownTable-TableBase ; 10 - reserved for future use
BlockXlateHeadsPerCyl
dc.b 1 ; 1 head per cylinder
TableBase
GCR400KTable
BlockXlateSectsPerHead
dc.b 12 ; 12 sectors per head
BlockXlateSectsPerCyl
dc.b 12*1 ; 12 sectors per cylinder (1 head)
BlockXlateCylBias
dc.b 0*16 ; starting at cylinder zero (first group of 16)
BlockXlateBlockLimit
dc.w 12*1*16 ; 12 sectors, 1 head, 16 cylinders
dc.b 11,11*1,1*16
dc.w 11*1*16
dc.b 10,10*1,2*16
dc.w 10*1*16
dc.b 9,9*1,3*16
dc.w 9*1*16
dc.b 8,8*1,4*16
dc.w 8*1*16
dc.b 0
dc.b 2 ; 2 head per cylinder
GCRonHDTable
GCR800KTable dc.b 12,12*2,0*16
dc.w 12*2*16
dc.b 11,11*2,1*16
dc.w 11*2*16
dc.b 10,10*2,2*16
dc.w 10*2*16
dc.b 9,9*2,3*16
dc.w 9*2*16
dc.b 8,8*2,4*16
dc.w 8*2*16
dc.b 0
dc.b 2 ; 2 head per cylinder
MFM720KTable dc.b 9,9*2,0*80
dc.w 9*2*80
dc.b 0
dc.b 2 ; 2 head per cylinder
MFM1440KTable dc.b 18,18*2,0*80
dc.w 18*2*80
dc.b 0
dc.b 1 ; 1 head per cylinder
UnknownTable dc.b 8,8*1,0*1 ; 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
endproc
title 'IOP SWIM Driver - Encoding / Decoding Tables'
seg 'PageConsts'
DiskDataXlate proc
; Nibblizing Table ($00 thru $3F converted to nibbles $96 thru $FF)
; table is repeated 4 times, since upper 2 bits are not masked to zero
entry EncodeGCRnibble
EncodeGCRnibble dc.b $96,$97,$9A,$9B ; x x 0 0 0 0 x x
dc.b $9D,$9E,$9F,$A6 ; x x 0 0 0 1 x x
dc.b $A7,$AB,$AC,$AD ; x x 0 0 1 0 x x
dc.b $AE,$AF,$B2,$B3 ; x x 0 0 1 1 x x
dc.b $B4,$B5,$B6,$B7 ; x x 0 1 0 0 x x
dc.b $B9,$BA,$BB,$BC ; x x 0 1 0 1 x x
dc.b $BD,$BE,$BF,$CB ; x x 0 1 1 0 x x
dc.b $CD,$CE,$CF,$D3 ; x x 0 1 1 1 x x
dc.b $D6,$D7,$D9,$DA ; x x 1 0 0 0 x x
dc.b $DB,$DC,$DD,$DE ; x x 1 0 0 1 x x
dc.b $DF,$E5,$E6,$E7 ; x x 1 0 1 0 x x
dc.b $E9,$EA,$EB,$EC ; x x 1 0 1 1 x x
dc.b $ED,$EE,$EF,$F2 ; x x 1 1 0 0 x x
dc.b $F3,$F4,$F5,$F6 ; x x 1 1 0 1 x x
dc.b $F7,$F9,$FA,$FB ; x x 1 1 1 0 x x
dc.b $FC,$FD,$FE,$FF ; x x 1 1 1 1 x x
dc.b $96,$97,$9A,$9B ; x x 0 0 0 0 x x
dc.b $9D,$9E,$9F,$A6 ; x x 0 0 0 1 x x
dc.b $A7,$AB,$AC,$AD ; x x 0 0 1 0 x x
dc.b $AE,$AF,$B2,$B3 ; x x 0 0 1 1 x x
dc.b $B4,$B5,$B6,$B7 ; x x 0 1 0 0 x x
dc.b $B9,$BA,$BB,$BC ; x x 0 1 0 1 x x
dc.b $BD,$BE,$BF,$CB ; x x 0 1 1 0 x x
dc.b $CD,$CE,$CF,$D3 ; x x 0 1 1 1 x x
dc.b $D6,$D7,$D9,$DA ; x x 1 0 0 0 x x
dc.b $DB,$DC,$DD,$DE ; x x 1 0 0 1 x x
dc.b $DF,$E5,$E6,$E7 ; x x 1 0 1 0 x x
dc.b $E9,$EA,$EB,$EC ; x x 1 0 1 1 x x
dc.b $ED,$EE,$EF,$F2 ; x x 1 1 0 0 x x
dc.b $F3,$F4,$F5,$F6 ; x x 1 1 0 1 x x
dc.b $F7,$F9,$FA,$FB ; x x 1 1 1 0 x x
dc.b $FC,$FD,$FE,$FF ; x x 1 1 1 1 x x
dc.b $96,$97,$9A,$9B ; x x 0 0 0 0 x x
dc.b $9D,$9E,$9F,$A6 ; x x 0 0 0 1 x x
dc.b $A7,$AB,$AC,$AD ; x x 0 0 1 0 x x
dc.b $AE,$AF,$B2,$B3 ; x x 0 0 1 1 x x
dc.b $B4,$B5,$B6,$B7 ; x x 0 1 0 0 x x
dc.b $B9,$BA,$BB,$BC ; x x 0 1 0 1 x x
dc.b $BD,$BE,$BF,$CB ; x x 0 1 1 0 x x
dc.b $CD,$CE,$CF,$D3 ; x x 0 1 1 1 x x
dc.b $D6,$D7,$D9,$DA ; x x 1 0 0 0 x x
dc.b $DB,$DC,$DD,$DE ; x x 1 0 0 1 x x
dc.b $DF,$E5,$E6,$E7 ; x x 1 0 1 0 x x
dc.b $E9,$EA,$EB,$EC ; x x 1 0 1 1 x x
dc.b $ED,$EE,$EF,$F2 ; x x 1 1 0 0 x x
dc.b $F3,$F4,$F5,$F6 ; x x 1 1 0 1 x x
dc.b $F7,$F9,$FA,$FB ; x x 1 1 1 0 x x
dc.b $FC,$FD,$FE,$FF ; x x 1 1 1 1 x x
dc.b $96,$97,$9A,$9B ; x x 0 0 0 0 x x
dc.b $9D,$9E,$9F,$A6 ; x x 0 0 0 1 x x
dc.b $A7,$AB,$AC,$AD ; x x 0 0 1 0 x x
dc.b $AE,$AF,$B2,$B3 ; x x 0 0 1 1 x x
dc.b $B4,$B5,$B6,$B7 ; x x 0 1 0 0 x x
dc.b $B9,$BA,$BB,$BC ; x x 0 1 0 1 x x
dc.b $BD,$BE,$BF,$CB ; x x 0 1 1 0 x x
dc.b $CD,$CE,$CF,$D3 ; x x 0 1 1 1 x x
dc.b $D6,$D7,$D9,$DA ; x x 1 0 0 0 x x
dc.b $DB,$DC,$DD,$DE ; x x 1 0 0 1 x x
dc.b $DF,$E5,$E6,$E7 ; x x 1 0 1 0 x x
dc.b $E9,$EA,$EB,$EC ; x x 1 0 1 1 x x
dc.b $ED,$EE,$EF,$F2 ; x x 1 1 0 0 x x
dc.b $F3,$F4,$F5,$F6 ; x x 1 1 0 1 x x
dc.b $F7,$F9,$FA,$FB ; x x 1 1 1 0 x x
dc.b $FC,$FD,$FE,$FF ; x x 1 1 1 1 x x
; transform [A7] [A6] [A5] [A4] [A3] [A2] [A1] [A0]
; to [00] [00] [A7] [A6] [00] [00] [00] [00]
entry EncodeGCRHighA
EncodeGCRHighA dcb.b 64,%00000000 ; 0 0 X X X X X X
dcb.b 64,%00010000 ; 0 1 X X X X X X
dcb.b 64,%00100000 ; 1 0 X X X X X X
dcb.b 64,%00110000 ; 1 1 X X X X X X
; transform [B7] [B6] [B5] [B4] [B3] [B2] [B1] [B0]
; to [00] [00] [00] [00] [B7] [B6] [00] [00]
entry EncodeGCRHighB
EncodeGCRHighB dcb.b 64,%00000000 ; 0 0 X X X X X X
dcb.b 64,%00000100 ; 0 1 X X X X X X
dcb.b 64,%00001000 ; 1 0 X X X X X X
dcb.b 64,%00001100 ; 1 1 X X X X X X
; transform [C7] [C6] [C5] [C4] [C3] [C2] [C1] [C0]
; to [00] [00] [00] [00] [00] [00] [C7] [C6]
entry EncodeGCRHighC
EncodeGCRHighC dcb.b 64,%00000000 ; 0 0 X X X X X X
dcb.b 64,%00000001 ; 0 1 X X X X X X
dcb.b 64,%00000010 ; 1 0 X X X X X X
dcb.b 64,%00000011 ; 1 1 X X X X X X
; Denibblizing Table (nibbles $96 thru $FF converted to $00 thru $3F)
; $FF means illegal nibble:
entry DecodeGCRnibble
DecodeGCRnibble dcb.b $94,$FF ; $00..$93 are illegal
dc.b $FF,$FF,$00,$01 ; , ,$96,$97
dc.b $FF,$FF,$02,$03 ; , ,$9A,$9B
dc.b $FF,$04,$05,$06 ; ,$9D,$9E,$9F
dc.b $FF,$FF,$FF,$FF ; , , ,
dc.b $FF,$FF,$07,$08 ; , ,$A6,$A7
dc.b $FF,$FF,$FF,$09 ; , , ,$AB
dc.b $0A,$0B,$0C,$0D ; $AC,$AD,$AE,$AF
dc.b $FF,$FF,$0E,$0F ; , ,$B2,$B3
dc.b $10,$11,$12,$13 ; $B4,$B5,$B6,$B7
dc.b $FF,$14,$15,$16 ; ,$B9,$BA,$BB
dc.b $17,$18,$19,$1A ; $BC,$BD,$BE,$BF
dc.b $FF,$FF,$FF,$FF ; , , ,
dc.b $FF,$FF,$FF,$FF ; , , ,
dc.b $FF,$FF,$FF,$1B ; , , ,$CB
dc.b $FF,$1C,$1D,$1E ; ,$CD,$CE,$CF
dc.b $FF,$FF,$FF,$1F ; , , ,$D3
dc.b $FF,$FF,$20,$21 ; , ,$D6,$D7
dc.b $FF,$22,$23,$24 ; ,$D9,$DA,$DB
dc.b $25,$26,$27,$28 ; $DC,$DD,$DE,$DF
dc.b $FF,$FF,$FF,$FF ; , , ,
dc.b $FF,$29,$2A,$2B ; ,$E5,$E6,$E7
dc.b $FF,$2C,$2D,$2E ; ,$E9,$EA,$EB
dc.b $2F,$30,$31,$32 ; $EC,$ED,$EE,$EF
dc.b $FF,$FF,$33,$34 ; , ,$F2,$F3
dc.b $35,$36,$37,$38 ; $F4,$F5,$F6,$F7
dc.b $FF,$39,$3A,$3B ; ,$F9,$FA,$FB
dc.b $3C,$3D,$3E,$3F ; $FC,$FD,$FE,$FF
; transform [00] [00] [A7] [A6] [B7] [B6] [C7] [C6]
; to [A7] [A6] [00] [00] [00] [00] [00] [00]
entry DecodeGCRHighA
DecodeGCRHighA dcb.b 16,%00000000 ; 0 0 0 0 X X X X
dcb.b 16,%01000000 ; 0 0 0 1 X X X X
dcb.b 16,%10000000 ; 0 0 1 0 X X X X
dcb.b 16,%11000000 ; 0 0 1 1 X X X X
; transform [00] [00] [A7] [A6] [B7] [B6] [C7] [C6]
; to [B7] [B6] [00] [00] [00] [00] [00] [00]
entry DecodeGCRHighB
DecodeGCRHighB dcb.b 4,%00000000 ; 0 0 0 0 0 0 X X
dcb.b 4,%01000000 ; 0 0 0 0 0 1 X X
dcb.b 4,%10000000 ; 0 0 0 0 1 0 X X
dcb.b 4,%11000000 ; 0 0 0 0 1 1 X X
dcb.b 4,%00000000 ; 0 0 0 1 0 0 X X
dcb.b 4,%01000000 ; 0 0 0 1 0 1 X X
dcb.b 4,%10000000 ; 0 0 0 1 1 0 X X
dcb.b 4,%11000000 ; 0 0 0 1 1 1 X X
dcb.b 4,%00000000 ; 0 0 1 0 0 0 X X
dcb.b 4,%01000000 ; 0 0 1 0 0 1 X X
dcb.b 4,%10000000 ; 0 0 1 0 1 0 X X
dcb.b 4,%11000000 ; 0 0 1 0 1 1 X X
dcb.b 4,%00000000 ; 0 0 1 1 0 0 X X
dcb.b 4,%01000000 ; 0 0 1 1 0 1 X X
dcb.b 4,%10000000 ; 0 0 1 1 1 0 X X
dcb.b 4,%11000000 ; 0 0 1 1 1 1 X X
; transform [00] [00] [A7] [A6] [B7] [B6] [C7] [C6]
; to [C7] [C6] [00] [00] [00] [00] [00] [00]
entry DecodeGCRHighC
DecodeGCRHighC dc.b %00000000,%01000000,%10000000,%11000000 ; 0 0 0 0 0 0 X X
dc.b %00000000,%01000000,%10000000,%11000000 ; 0 0 0 0 0 1 X X
dc.b %00000000,%01000000,%10000000,%11000000 ; 0 0 0 0 1 0 X X
dc.b %00000000,%01000000,%10000000,%11000000 ; 0 0 0 0 1 1 X X
dc.b %00000000,%01000000,%10000000,%11000000 ; 0 0 0 1 0 0 X X
dc.b %00000000,%01000000,%10000000,%11000000 ; 0 0 0 1 0 1 X X
dc.b %00000000,%01000000,%10000000,%11000000 ; 0 0 0 1 1 0 X X
dc.b %00000000,%01000000,%10000000,%11000000 ; 0 0 0 1 1 1 X X
dc.b %00000000,%01000000,%10000000,%11000000 ; 0 0 1 0 0 0 X X
dc.b %00000000,%01000000,%10000000,%11000000 ; 0 0 1 0 0 1 X X
dc.b %00000000,%01000000,%10000000,%11000000 ; 0 0 1 0 1 0 X X
dc.b %00000000,%01000000,%10000000,%11000000 ; 0 0 1 0 1 1 X X
dc.b %00000000,%01000000,%10000000,%11000000 ; 0 0 1 1 0 0 X X
dc.b %00000000,%01000000,%10000000,%11000000 ; 0 0 1 1 0 1 X X
dc.b %00000000,%01000000,%10000000,%11000000 ; 0 0 1 1 1 0 X X
dc.b %00000000,%01000000,%10000000,%11000000 ; 0 0 1 1 1 1 X X
entry SectorTemplates
SectorTemplates
entry GCRAddrMark
GCRAddrMark dc.b $D5,$AA,$96 ; GCR address mark byte sequence
assert GCRAddrMarkSize=(*-GCRAddrMark)
entry GCRAddrSlipMark
GCRAddrSlipMark dc.b $DE,$AA,$FF ; GCR address bit slip mark byte sequence
assert GCRAddrSlipMarkSize=(*-GCRAddrSlipMark)
entry GCRGapSync
GCRGapSync dc.b $FF,$3F,$CF,$F3,$FC,$FF ; GCR gap sync byte sequence
assert GCRGapSyncSize=(*-GCRGapSync)
entry GCRDataMark
GCRDataMark dc.b $D5,$AA,$AD ; GCR data mark byte sequence
assert GCRDataMarkSize=(*-GCRDataMark)
entry GCRDataSlipMark
GCRDataSlipMark dc.b $DE,$AA ; GCR data bit slip mark byte sequence
entry GCRGapValue
GCRGapValue dc.b $FF,$FF ; GCR gap is string of FF's
assert GCRDataSlipMarkSize=(*-GCRDataSlipMark)
entry GCRFmtFillValue
GCRFmtFillValue dc.b $96 ; GCR format data is string of 96's (00's)
entry MFMIndexMark
MFMIndexMark dc.b $C2,$C2,$C2,$FC ; MFM index mark byte sequence
assert MFMIndexMarkSize=(*-MFMIndexMark)
entry MFMAddrMark
MFMAddrMark dc.b $A1,$A1,$A1,$FE ; MFM address mark byte sequence
assert MFMAddrMarkSize=(*-MFMAddrMark)
entry MFMDataMark
MFMDataMark dc.b $A1,$A1,$A1,$FB ; MFM data mark byte sequence
assert MFMDataMarkSize=(*-MFMDataMark)
entry MFMGapValue
MFMGapValue dc.b $4E ; MFM gap is string of 4E's
entry MFMSyncValue
MFMSyncValue dc.b $00 ; MFM sync is string of 00's
entry MFMFmtFillValue
MFMFmtFillValue dc.b $F6 ; MFM format data is string of F6's
entry FmtSearchOrder
FmtSearchOrder dc.b GCR800Kformat ; try 800K first
dc.b MFM1440Kformat ; then 1440K
dc.b GCR400Kformat ; then 400K
dc.b MFM720Kformat ; then 720K
dc.b GCRonHDformat ; and finally 400K/800K on HD media
dc.b unknownFormat ; list terminator
entry FmtByteValues
FmtByteValues dc.b $22 ; 800K GCR (2 sided)
dc.b $02 ; 1440K (block size = 2*256)
dc.b $02 ; 400K GCR (1 sided)
dc.b $02 ; 720K (block size = 2*256)
dc.b $00 ; 400K/800K GCR on HD media (ignore)
entry FmtByteMasks
FmtByteMasks dc.b $20 ; 800K GCR, ignore interleave info
dc.b $FF ; 1440K, use whole byte
dc.b $20 ; 400K GCR, ignore interleave info
dc.b $FF ; 720K, use whole byte
dc.b $00 ; 400K/800K GCR on HD media, ignore byte
entry RequiredMedia
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
entry HeadSelectDecode
HeadSelectDecode
dc.b rRdData0Adr ; select head 0
dc.b rRdData1Adr ; select head 1
if (*-SectorTemplates) > 64 then
aerror 'DiskDataXlate constants overflowed page boundary'
elseif (*-SectorTemplates) < 64 then
dcb.b 64-(*-SectorTemplates),0 ; pad out rest of page
endif
endproc
title 'IOP SWIM Driver - Read Sector Header'
;_______________________________________________________________________
;
; Routine: jsr ReadSectorHdr
; Inputs: CurrentDrive - active drive number
; SeekingCylinder - Desired cylinder number
; SeekingHead - Desired head number
; PhysSectsPerHead- Upper limit for sector numbers
; BaseBufferNum - Starting buffer number for this track
; Outputs: c - true if an error occured
; A - error status code (if carry set)
; n,z - based on value returned in A (if carry set)
; n,v - buffer status for this sector (if carry clear)
; 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
; SectHdrChkSumH/L- Checksum from sector header
; SectHdrHandshake- Handshake register after last byte
; SectHdrError - Error register after last byte
; AdrSearchCountH/L - number of bytes found before header
; SectBufferNum - Buffer number for the sector that was found
; DataBufPtr - Address of DATA buffer for this sector
; TagBufPtr - Address of TAG buffer for this sector
; CurSectsPerHead - copy of PhysSectsPerHead
; Destroys: X, Y, n, z, c
; Calls: ReadUnknownHdr, ReadGCRHdr, ReadLoDenMFMHdr, ReadHiDenMFMHdr
; Called by: SWIMRead, SWIMReadVerify, SWIMWrite, SWIMFormatVerify, SWIMGetRawData,
; PrefetchIntoCache, SetUpDrive, FmtGCRTrack
;
; Function: Reads the sector header information for the next sector
; found on the specified head, on the current cylinder.
;
; 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. Carry will be set,
; but the error status returned will be noErr, since the header
; was read correctly, but there is no buffer for the data.
;
;_______________________________________________________________________
seg 'code'
ReadSectorHdr proc
entry ReadHdrDecode
entry ReadHdrSetup
entry ReadUnknownHdr
entry ReadGCRHdr
entry ReadLoDenMFMHdr
entry ReadHiDenMFMHdr
entry SetupBufferPtrs
with SWIMVarsZ
with SWIMVars
with SectorBuffers
stz <DataBufPtr+0 ; setup data buffer offset
ldy <CurrentDrive ; get the active drive number
ldx DiskFormat,y ; see what format to read
lda RequiredMedia,x ; see what media is required
cpa MediaKind,y ; see if we have correct media
bne ReadUnknownHdr ; if wrong kind of media
lda <PhysSectsPerHead ; get number of sectors per head
sta CurSectsPerHead ; remember PhysSectsPerHead for prefetching
txa ; get the DiskFormat
asl a ; compute the table index
tax ; load the index register
stx <SectHdrFmtIndex ; save for Read / Write SectorData
lda <WrongSectsLeft ; see how many sectors we can skip
cpa #WrongSectsMax/2 ; see if more than half used
blt @ReadHdr ; if so, don't consider skipping sectors
lda <ADBActivityMask ; see if ADB deserves priority
ldy #GiveADBTimeMask ; assume that it doesn't,
sty <ADBActivityMask ; give ADB priority next time
and <ADBActivity ; check against the ADB activity history
beq @ReadHdr ; if not, just read it
; ADB should be given some time, so read the header, and return a buffer status that
; indicates that the buffer has valid data and no I/O is requested for this sector.
jsr @ReadHdr ; read the sector header
bcs @exit ; if error, return the error status
assert ReadDataValid=$80 ; sign bit is valid bit
assert IORequested=$40 ; overflow bit is requested bit
clv ; indicate that no I/O is requested
lda #ReadDataValid ; indicate that the buffer is valid
@exit rts ; all done
@ReadHdr jmp (ReadHdrDecode,x) ; dispatch to the routine
ReadUnknownHdr stz <AdrSearchCountH ; indicate that no bytes were searched
stz <AdrSearchCountL ; indicate that no bytes were searched
lda #noAdrMkErr ; unsupported format, return with error
sec ; set carry to indicate error
rts ; all done
ReadHdrSetup ldy <SeekingHead ; get the desired head number
lda HeadSelectDecode,y ; get the head select command
jsr AdrAndSense ; select the disk head
ReStartRead lda rError ; read and clear any pending errors
lda #StartAction+WriteMode ; prepare to clear action and write mode
sta wZeroes ; clear action and write mode (prepare for read)
lda #ClearFIFO ; prepare to clear the FIFO
sta wOnes ; toggle it to one
sta wZeroes ; and back to zero to clear it
lda rError ; read and clear errors again
lda #StartAction ; prepare to start reading
sta wOnes ; start shifting in the read data
rts
title 'IOP SWIM Driver - Read Sector Header GCR'
ReadGCRHdr jsr ReadHdrSetup ; select the head and start the data transfer
stz <SectHdrChkSumH ; high byte of checksum is always 0 in GCR
; see if we can read any data, by trying to read 3 bytes
; When reading immediatly after a write, the drive may suppress read data for
; up to 620µsec, so we will wait at least that long for the first byte to be valid.
; We look for 3 bytes @16.34µsec per byte brings the total wait to 669µsec.
; The polling loop takes 11 clocks per iteration @1.9584MHz, which is 5.617µsec.
; So we compute the timeout as 669/5.617 = 119 iterations, and add in another 10%
; for good measure to get 131. It doesn't hurt for it to be too big, it would just
; take longer to get noNybErr which should never occur unless there is a hardware error.
ldx #131 ; timeout counter
ldy #3 ; bytes to find counter
@pollAnyBytes lda rHandshake ; see if byte is available
assert Dat1Byte=$80
bmi @gotAnyByte ; if byte is ready
dex ; dec timeout
bne @pollAnyBytes ; poll for the byte
stz <AdrSearchCountL ; update lower byte of the search counter
stz <AdrSearchCountH ; update upper byte of the search counter
lda #noNybErr ; if timed out searching for a nibble
bra @ErrorReturn ; no bytes found, return with error
@gotAnyByte lda rData ; get the data byte, to empty the FIFO
dey ; update count of bytes left to find
bne @pollAnyBytes ; wait for more bytes
; now search for the address mark byte sequence
lda #>-AddrSearchMax ; high byte of search byte count
sta <AdrSearchCountH ; initialize the timeout counter
lda #<-AddrSearchMax ; low byte of search byte count
@markSearch ldx #0 ; index into address mark sequence
@nextMark ldy GCRAddrMark,x ; get expected byte value
ina ; update lower byte of the timeout counter
bne @pollAddrMark ; check the address byte
inc <AdrSearchCountH ; update upper byte of the timeout counter
bne @pollAddrMark ; if address mark not found on disk
@AdrMarkTimeOut lda #<AddrSearchMax+3 ; count of bytes searched before error
sta <AdrSearchCountL ; update lower byte of the search counter
lda #>AddrSearchMax+3 ; count of bytes searched before error
sta <AdrSearchCountH ; update upper byte of the search counter
lda #noAdrMkErr ; address mark not found within timeout period
@ErrorReturn ldx rError ; read error reg for logic analyzer
ldy #StartAction\
+WriteMode ; prepare to clear action and write mode
tax ; set flags based upon error code
sty wZeroes ; clear action and write mode (read done)
sec ; set carry to indicate error
rts ; return with error
@pollAddrMark bit rHandshake ; see if byte is available
assert Dat1Byte=$80
bpl @pollAddrMark ; loop until byte is ready
cpy rData ; see if correct byte found
bne @markSearch ; if not, point back to start of search string
inx ; point to next search byte
cpx #GCRAddrMarkSize ; see if all bytes searched
blt @nextMark ; keep searching if not the final byte
* sec ; carry is left set by CPX above
adc #<AddrSearchMax-1 ; update count of bytes preceeding header
sta <AdrSearchCountL ; update lower byte of the search counter
lda <AdrSearchCountH ; get upper byte of the search counter
adc #>AddrSearchMax-1 ; update count of bytes preceeding header
sta <AdrSearchCountH ; update upper byte of the search counter
; get the fields of the sector header
@pollCylByte bit rHandshake ; see if byte is available
assert Dat1Byte=$80
bpl @pollCylByte ; loop until byte is ready
ldx rData ; get the low cylinder number byte
lda DecodeGCRnibble,x ; denibblize it
bmi @ChkSumError ; return checksum error if illegal encoding
asl a ; [0] [C5] [C4] [C3] [C2] [C1] [C0] [0]
asl a ; [C5] [C4] [C3] [C2] [C1] [C0] [0] [0]
sta <SectHdrCylinder ; update low byte of cylinder number
lda DecodeGCRnibble,x ; denibblize it again, initialize the checksum
@pollSectByte bit rHandshake ; see if byte is available
assert Dat1Byte=$80
bpl @pollSectByte ; loop until byte is ready
ldx rData ; get the sector number byte
ldy DecodeGCRnibble,x ; denibblize it
sty <SectHdrSector ; update sector number
eor DecodeGCRnibble,x ; add it to checksum
bmi @ChkSumError ; return checksum error if illegal encoding
cpy <PhysSectsPerHead ; see if it is in range
blt @pollHeadByte ; keep going if in range
jsr @pollHeadByte ; read rest of header
bcs @TooBigDone ; if any other error, return it instead
lda #noErr ; header read OK, but sect num too big
sec ; set carry to indicate error
@TooBigDone rts ; all done
@ChkSumError lda #badCksmErr ; sector header checksum error
bra @ErrorReturn ; return with checksum error
@pollHeadByte bit rHandshake ; see if byte is available
assert Dat1Byte=$80
bpl @pollHeadByte ; loop until byte is ready
ldx rData ; get the Head number (and high bits of cyl)
ldy DecodeGCRnibble,x ; denibblize it
bmi @ChkSumError ; return checksum error if illegal encoding
sty <SectHdrHead ; [0] [0] [H] [C10] [C9] [C8] [C7] [C6]
eor DecodeGCRnibble,x ; add it to checksum
lsr <SectHdrHead ; [0] [0] [0] [H] [C10] [C9] [C8] [C7]
ror <SectHdrCylinder ; [C6] [C5] [C4] [C3] [C2] [C1] [C0] [0]
@pollFmtByte bit rHandshake ; see if byte is available
assert Dat1Byte=$80
bpl @pollFmtByte ; loop until byte is ready
ldx rData ; get the Format Kind
ldy DecodeGCRnibble,x ; denibblize it
bmi @ChkSumError ; return checksum error if illegal encoding
sty <SectHdrFmtKind ; update Format Kind
eor DecodeGCRnibble,x ; add it to checksum
lsr <SectHdrHead ; [0] [0] [0] [0] [H] [C10] [C9] [C8]
ror <SectHdrCylinder ; [C7] [C6] [C5] [C4] [C3] [C2] [C1] [C0]
@pollChkSumByte bit rHandshake ; see if byte is available
assert Dat1Byte=$80
bpl @pollChkSumByte ; loop until byte is ready
ldx rData ; get the checksum
ldy DecodeGCRnibble,x ; denibblize it
sty <SectHdrChkSumL ; update the checksum
eor DecodeGCRnibble,x ; add it to checksum
bne @ChkSumError ; if checksum is bad
lda <SectHdrHead ; [0] [0] [0] [0] [H] [C10] [C9] [C8]
cpa #%00001000 ; carry := head
and #%00000111 ; [0] [0] [0] [0] [0] [C10] [C9] [C8]
rol a ; [0] [0] [0] [0] [C10] [C9] [C8] [H]
sta <SectHdrHead ; [0] [0] [0] [0] [C10] [C9] [C8] [H]
; we assume that cylinder numbers use at most 8 bits, and that the upper
; 3 bits will be zero for correct cylinders, so when we compare with the
; head, we will also be checking the upper 3 bits of cylinder for zero.
eor <SeekingHead ; see if we found the correct head
bne @SeekError ; if wrong head or cylinder
lda <SectHdrCylinder ; get the cylinder number we found
eor <SeekingCylinder ; see if we found the correct cylinder
bne @SeekError ; if wrong cylinder
@checkSlipMarks
lda <SectHdrSector ; get the sector we found
* clc ; setup for addition (cleared by ROL above)
adc <BaseBufferNum ; compute the buffer number for this sector
sta <SectBufferNum ; save the buffer number for this sector
asl a ; data buffers take 2 pages
* clc ; setup for addition (cleared by ASL above)
adc #>DataBuffers ; compute the data buffer page number
sta <DataBufPtr+1 ; setup data buffer page number
; Blindly read the first slip mark byte (58 clocks after previous byte read)
lda rData ; get the first slip mark byte
cpa GCRAddrSlipMark+0 ; check expected first slip mark byte
bne @SlipMarkError ; return with error if bad slip mark
lda GCRAddrSlipMark+1 ; get expected second slip mark byte
@pollSlipMark2 ldx rHandshake ; get final handshake register
assert Dat1Byte=$80
bpl @pollSlipMark2 ; loop until second slip byte is ready
cpa rData ; check the second slip mark byte
bne @SlipMarkError ; return with error if bad slip mark
stx <SectHdrHandshake ; save the handshake reg
ldx rError ; get the final error register
stx <SectHdrError ; save the Error reg
ldx <SectBufferNum ; get the buffer number for this sector
lda TagPtrs,x ; get the tag buffer pointer for this sector
asl a ; unpack 9th bit into carry
sta <TagBufPtr ; setup low byte of tag pointer
lda #0 ; setup to add in tag addr carry
adc #>TagBuffers ; add in starting page of tag buffers
sta <TagBufPtr+1 ; setup page number
* clc ; clear carry to indicate success
assert ReadDataValid=$80 ; sign bit is valid bit
assert IORequested=$40 ; overflow bit is requested bit
bit BufferStatus,x ; see if the buffer is needed
rts ; all done
@SlipMarkError ldx rError ; read error reg for logic analyzer
ldy #StartAction+WriteMode ; prepare to clear action and write mode
sty wZeroes ; clear action and write mode (read done)
lda #badBtSlpErr ; sector header slip mark error
sec ; set carry to indicate error
rts ; return with error
@SeekError jsr @checkSlipMarks ; make sure the header is valid first
bcs @SeekErrorDone ; other errors have priority over seek error
lda #seekErr ; if valid sector header, report the seek error
sec ; set carry to indicate error
@SeekErrorDone rts ; return with error
title 'IOP SWIM Driver - Read Sector Header MFM'
ReadLoDenMFMHdr ldx <CurrentDrive ; get the active drive number
lda DriveKind,x ; check drive kind
cpa #DSMFMGCRDriveKind ; see if drive supports MFM formats
beq ReadMFMHdr ; if correct drive, join common code
lda #noAdrMkErr ; can't read MFM address marks with this drive
sec ; set carry to indicate error
rts ; return with error
ReadHiDenMFMHdr
ReadMFMHdr jsr ReadHdrSetup ; select the head and start the data transfer
; search for the address mark byte sequence, with timeout.
lda #>-AddrSearchMax ; high byte of search byte count
sta <AdrSearchCountH ; initialize the timeout counter
ldy #<-AddrSearchMax ; low byte of search byte count
ldx #0 ; index into address marks table
lda #noNybErr ; no data found on disk
sta <SectHdrError ; default error if no bytes found
@pollAnyBytes lda #MarkInFIFO ; test for mark byte also
bit rHandshake ; see if byte is available
assert Dat1Byte=$80
bmi @gotAnyByte ; if byte is ready
bit rHandshake ; see if byte is available
assert Dat1Byte=$80
bmi @gotAnyByte ; if byte is ready
bit rHandshake ; see if byte is available
assert Dat1Byte=$80
bmi @gotAnyByte ; if byte is ready
nop ; extra 2 clocks to make loop 32 clocks (16µsec)
txa ; see if any bytes of mark found
beq @updateTimeout ; if not, just keep on polling
@ReStartSearch jsr ReStartRead ; flush the FIFO, and restart search for mark
ldx #0 ; index into address marks table
lda #noAdrMkErr ; address mark not found within timeout period
sta <SectHdrError ; error code if bytes were found
bra @updateTimeout ; start counting again
@gotAnyByte beq @gotDataByte ; if not a mark byte
lda rMark ; get the mark byte
eor MFMAddrMark,x ; check against expected value
bne @ReStartSearch ; if not a match, start over
inx ; point to next search byte
cpx #MFMAddrMarkSize ; see if this was the final byte
beq @ReStartSearch ; final byte should not be a mark byte
@updateTimeout iny ; update lower byte of the timeout counter
bne @pollAnyBytes ; check for next byte
inc <AdrSearchCountH ; update upper byte of the timeout counter
bne @pollAnyBytes ; check for next byte
@AdrMarkTimeOut lda #<AddrSearchMax ; count of bytes searched before error
sta <AdrSearchCountL ; update lower byte of the search counter
lda #>AddrSearchMax ; count of bytes searched before error
sta <AdrSearchCountH ; update upper byte of the search counter
lda <SectHdrError ; get proper error code
@ErrorReturn ldx rError ; read error reg for logic analyzer
ldy #StartAction+WriteMode ; prepare to clear action and write mode
tax ; set flags based upon error code
sty wZeroes ; clear action and write mode (read done)
sec ; set carry to indicate error
rts ; return with error
@gotDataByte lda rData ; get the data byte
cpa MFMAddrMark,x ; check against expected value
bne @ReStartSearch ; if not a match, start over
cpx #MFMAddrMarkSize-1 ; see if this was the final byte
blt @ReStartSearch ; only final byte should be a data byte
tya ; get lower byte of the search counter
* sec ; carry is left set by CPX above
adc #<AddrSearchMax-1-4 ; update count of bytes preceeding header
sta <AdrSearchCountL ; update lower byte of the search counter
lda <AdrSearchCountH ; get upper byte of the search counter
adc #>AddrSearchMax-1-4 ; update count of bytes preceeding header
sta <AdrSearchCountH ; update upper byte of the search counter
; get the fields of the sector header
ldx #0 ; timeout counter
lda #MarkInFIFO ; test for mark byte also
@pollCylByte dex ; decrement timeout counter
beq @HdrByteTimeOut ; if timed out waiting for a byte
bit rHandshake ; see if byte is available
assert Dat1Byte=$80
bpl @pollCylByte ; loop until byte is ready
bne @ChkSumError ; if mark byte, report as checksum error
ldy rData ; get the low cylinder number byte
sty <SectHdrCylinder ; update low byte of cylinder number
@pollHeadByte dex ; decrement timeout counter
beq @HdrByteTimeOut ; if timed out waiting for a byte
bit rHandshake ; see if byte is available
assert Dat1Byte=$80
bpl @pollHeadByte ; loop until byte is ready
bne @ChkSumError ; if mark byte, report as checksum error
ldy rData ; get the Head number
sty <SectHdrHead ; update the Head number
cpy <SeekingHead ; see if we found the correct head
bne @SeekError ; if wrong head or cylinder
ldy <SectHdrCylinder ; get the cylinder number we found
cpy <SeekingCylinder ; see if we found the correct cylinder
beq @pollSectByte ; if correct cylinder
@SeekError jsr @pollSectByte ; make sure the header is valid first
bcs @SeekErrorDone ; other errors have priority over seek error
lda #seekErr ; if valid sector header, report the seek error
sec ; set carry to indicate error
@SeekErrorDone rts ; return with error
@HdrByteTimeOut lda #noNybErr ; timeout while polling for a byte
bra @ErrorReturn ; return with timeout error
@ChkSumError lda #badCksmErr ; sector header checksum error
bra @ErrorReturn ; return with checksum error
@pollSectByte dex ; decrement timeout counter
beq @HdrByteTimeOut ; if timed out waiting for a byte
bit rHandshake ; see if byte is available
assert Dat1Byte=$80
bpl @pollSectByte ; loop until byte is ready
bne @ChkSumError ; if mark byte, report as checksum error
ldy rData ; get the sector number
dey ; adjust to zero based numbering
sty <SectHdrSector ; update sector number
cpy <PhysSectsPerHead ; see if it is in range
blt @pollFmtByte ; keep going if in range
jsr @pollFmtByte ; read rest of header
bcs @TooBigDone ; if any other error, return it instead
lda #noErr ; header read OK, but sect num too big
sec ; set carry to indicate error
@TooBigDone rts ; all done
@pollFmtByte dex ; decrement timeout counter
beq @HdrByteTimeOut ; if timed out waiting for a byte
bit rHandshake ; see if byte is available
assert Dat1Byte=$80
bpl @pollFmtByte ; loop until byte is ready
bne @ChkSumError ; if mark byte, report as checksum error
ldy rData ; get the (block size) Format Kind
sty <SectHdrFmtKind ; update Format Kind
@pollChkSumH dex ; decrement timeout counter
beq @HdrByteTimeOut ; if timed out waiting for a byte
bit rHandshake ; see if byte is available
assert Dat1Byte=$80
bpl @pollChkSumH ; loop until byte is ready
bne @ChkSumError ; if mark byte, report as checksum error
ldy rData ; get the first checksum byte
sty <SectHdrChkSumH ; update the first checksum byte
ldy #StartAction\
+WriteMode ; prepare to clear action and write mode
@pollChkSumL dex ; decrement timeout counter
beq @HdrByteTimeOut ; if timed out waiting for a byte
lda rHandshake ; see if byte is available
assert Dat1Byte=$80
bpl @pollChkSumL ; loop until byte is ready
ldx rData ; get the second checksum byte
sty wZeroes ; clear action and write mode (read done)
bit #MarkInFIFO ; test for mark byte
bne @ChkSumError ; if mark byte, report as checksum error
stx <SectHdrChkSumL ; update the second checksum byte
ldx rError ; get the final error register
stx <SectHdrError ; save the Error reg
sta <SectHdrHandshake ; save the handshake reg
and #rErrorValid+CRCNotZero ; check for errors
bne @ChkSumError ; if bad CRC, return with header checksum error
SetupBufferPtrs lda <SectHdrSector ; get the sector we found
clc ; setup for addition
adc <BaseBufferNum ; compute the buffer number for this sector
sta <SectBufferNum ; save the buffer number for this sector
tax ; setup for indexing by buffer number
asl a ; data buffers take 2 pages
* clc ; setup for addition (cleared by ASL above)
adc #>DataBuffers ; compute the data buffer page number
sta <DataBufPtr+1 ; setup data buffer page number
lda TagPtrs,x ; get the tag buffer pointer for this sector
asl a ; unpack 9th bit into carry
sta <TagBufPtr ; setup low byte of tag pointer
lda #0 ; setup to add in tag addr carry
adc #>TagBuffers ; add in starting page of tag buffers
sta <TagBufPtr+1 ; setup page number
* clc ; clear carry to indicate success
assert ReadDataValid=$80 ; sign bit is valid bit
assert IORequested=$40 ; overflow bit is requested bit
bit BufferStatus,x ; see if the buffer is needed
rts ; all done
endwith
endwith
endwith
endproc
seg 'WordConsts'
ReadHdrDecode proc
dc.w ReadUnknownHdr ; 0 - uncheckedFormat
dc.w ReadUnknownHdr ; 1 - unknownFormat
dc.w ReadUnknownHdr ; 2 - HD20Format
dc.w ReadGCRHdr ; 3 - GCR400Kformat
dc.w ReadGCRHdr ; 4 - GCR800Kformat
dc.w ReadLoDenMFMHdr ; 5 - MFM720Kformat
dc.w ReadHiDenMFMHdr ; 6 - MFM1440Kformat
dc.w ReadGCRHdr ; 7 - GCRonHDformat
dc.w ReadUnknownHdr ; 8 - reserved for future use
dc.w ReadUnknownHdr ; 9 - reserved for future use
dc.w ReadUnknownHdr ; 10 - reserved for future use
endproc
title 'IOP SWIM Driver - Read Sector Data'
;_______________________________________________________________________
;
; Routine: jsr ReadSectorData
; Inputs: CurrentDrive - active drive number
; TagBufPtr - pointer to 12 byte tag buffer
; DataBufPtr - pointer to 512 byte data buffer
; Expects to be called after ReadSectorHdr
; Outputs: A - error status code
; n,z - based on value returned in A
; Destroys: X, Y, n, z, c
; Calls: ReadUnknownData, ReadGCRData, ReadMFMData, RdWrGCRonHDData
; Called by: SWIMRead, SWIMReadVerify, SWIMWrite, SWIMFormatVerify,
; SWIMGetRawData, PrefetchIntoCache
;
; Function: Reads the sector Tag and Data information for the current
; sector on the selected head, on the current cylinder.
;
; NOTE: The data buffer must be page aligned, and the tag
; buffer must not span across pages.
;_______________________________________________________________________
seg 'code'
ReadSectorData proc
entry ReadDataDecode
entry ReadUnknownData
entry ReadGCRData
entry RdWrGCRonHDData
entry ReadMFMData
with SWIMVarsZ
with SWIMVars
ldx <SectHdrFmtIndex ; get index from ReadSectorHdr
jmp (ReadDataDecode,x) ; dispatch to the routine
ReadUnknownData lda #noDtaMkErr ; unsupported format, return with error
rts ; all done
title 'IOP SWIM Driver - Read Sector Data - GCR'
; we enter with action still set, and read mode, from ReadGCRHdr, but
; the FIFO has probably overrun, and errors may have been set.
; The shift register must be left running, in order to properly sync
; on the GCR sync pattern that preceeds the data mark sequence.
RdWrGCRonHDData ldx rError ; read error reg for logic analyzer
ldy #StartAction\
+WriteMode ; prepare to clear action and write mode
sty wZeroes ; clear action and write mode (read done)
lda #<gcrOnMfmErr ; indicate improperly formatted disk
rts ; return with error
ReadGCRData lda rData ; empty garbage byte out of the FIFO,
lda rError ; read and clear errors
; now search for the data mark byte sequence
assert DataSearchMax<128 ; it fits in 1 byte
lda #-DataSearchMax ; search byte count
@markSearch ldx #0 ; index into address marks table
@nextMark ldy GCRDataMark,x ; get expected byte value
ina ; update the timeout counter
beq @DataMarkTimeOut ; error if count expired
@pollDataMark bit rHandshake ; see if byte is available
assert Dat1Byte=$80
bpl @pollDataMark ; loop until byte is ready
cpy rData ; see if correct byte found
bne @markSearch ; if not, point back to start of search string
inx ; point to next search byte
cpx #GCRDataMarkSize ; see if all bytes searched
blt @nextMark ; keep searching if not the final byte
; get the fields of the data mark
lda #TagSize/3 ; 12 tag bytes, read 3 per loop
sta <LoopCountL ; initialize tag loop counter
stz <GCRCkSumA ; initialize checksum A
stz <GCRCkSumB ; initialize checksum B
lda #0 ; initialize checksum C
@pollSectByte bit rHandshake ; see if byte is available
assert Dat1Byte=$80
bpl @pollSectByte ; loop until byte is ready
ldx rData ; get the sector number byte
ldy DecodeGCRnibble,x ; denibblize it
bmi @ChkSumError ; checksum error if illegal encoding
@CheckSectNum cpy <SectHdrSector ; check sector number
beq @ReadTagStart ; if match read tag, else didn't find mark
@DataMarkTimeOut
lda #noDtaMkErr ; data mark not found within timeout period
bra @ErrorReturn ; return with error status
title 'IOP SWIM Driver - Read Sector Data - GCR Tags'
; read the tag data bytes
@ReadTagLoop ldx rData ; get the upper bits nibble
ldy DecodeGCRnibble,x ; denibblize it
bmi @ChkSumError ; checksum error if illegal encoding
; rotate high bit of CkSumC into carry and low bit of CkSumC
cpa #$80 ; carry := CheckSumC [7]
rol a ; [6] [5] [4] [3] [2] [1] [0] [7]
sta <GCRCkSumC ; update CheckSum C
ldx rData ; get ByteA'
lda DecodeGCRnibble,x ; denibblize it
if CheckEncodings then
bmi @ChkSumError ; checksum error if illegal encoding
else
* bmi @ChkSumError ; no time to check for illegal encoding
endif
eor DecodeGCRHighA,y ; insert upper 2 bits of ByteA'
eor <GCRCkSumC ; ByteA := ByteA' xor CkSumC
sta (<TagBufPtr) ; store the first byte
adc <GCRCkSumA ; CkSumA := CkSumA + ByteA + carry
sta <GCRCkSumA ; update CheckSum A
inc <TagBufPtr ; update buffer pointer
ldx rData ; get ByteB'
lda DecodeGCRnibble,x ; denibblize it
if CheckEncodings then
bmi @ChkSumError ; checksum error if illegal encoding
else
* bmi @ChkSumError ; no time to check for illegal encoding
endif
eor DecodeGCRHighB,y ; insert upper 2 bits of ByteB'
eor <GCRCkSumA ; ByteB := ByteB' xor CkSumA
sta (<TagBufPtr) ; store the second byte
adc <GCRCkSumB ; CkSumB := CkSumB + ByteB + carry
sta <GCRCkSumB ; update CheckSum B
inc <TagBufPtr ; update buffer pointer
ldx rData ; get ByteC'
lda DecodeGCRnibble,x ; denibblize it
if CheckEncodings then
bmi @ChkSumError ; checksum error if illegal encoding
else
* bmi @ChkSumError ; no time to check for illegal encoding
endif
eor DecodeGCRHighC,y ; insert upper 2 bits of ByteC'
eor <GCRCkSumB ; ByteC := ByteC' xor CkSumB
sta (<TagBufPtr) ; store the third byte
adc <GCRCkSumC ; CkSumC := CkSumC + ByteC + carry
dec <LoopCountL ; update loop counter
beq @ReadDataStart ; if done with tag, read data field
inc <TagBufPtr ; update buffer pointer
@ReadTagStart bit rHandshake ; see if 2 bytes are available
assert Dat2Bytes=$40
bvs @ReadTagLoop ; read the bytes if they are available
ldx #BytePollMax ; setup timeout counter
@PollTagLoop bit rHandshake ; check again
assert Dat2Bytes=$40
bvs @ReadTagLoop ; read the bytes if they are available
dex ; decrement timeout
bne @PollTagLoop ; poll until full, or timeout
@NoNybError lda #noNybErr ; bytes not coming in fast enough
@ErrorReturn ldx rError ; read error reg for logic analyzer
ldy #StartAction+WriteMode ; prepare to clear action and write mode
sty wZeroes ; clear action and write mode (read done)
tax ; set flags based upon error code
rts ; return with error
@ChkSumError lda #badDCksum ; sector data checksum error
bra @ErrorReturn ; return with checksum error
title 'IOP SWIM Driver - Read Sector Data - GCR Data'
; read the sector data bytes
@ReadDataLoop ldx rData ; get the upper bits nibble
ldy DecodeGCRnibble,x ; denibblize it
bmi @ChkSumError ; checksum error if illegal encoding
; rotate high bit of CkSumC into carry and low bit of CkSumC
cpa #$80 ; carry := CheckSumC [7]
rol a ; [6] [5] [4] [3] [2] [1] [0] [7]
sta <GCRCkSumC ; update CheckSum C
ldx rData ; get ByteA'
lda DecodeGCRnibble,x ; denibblize it
if CheckEncodings then
bmi @ChkSumError ; checksum error if illegal encoding
else
* bmi @ChkSumError ; no time to check for illegal encoding
endif
eor DecodeGCRHighA,y ; insert upper 2 bits of ByteA'
eor <GCRCkSumC ; ByteA := ByteA' xor CkSumC
sta (<DataBufPtr) ; store the byte
adc <GCRCkSumA ; CkSumA := CkSumA + ByteA + carry
sta <GCRCkSumA ; update CheckSum A
ldx rData ; get ByteB' (empty FIFO before page cross delay)
inc <DataBufPtr ; update buffer pointer
beq @DataCrossPage ; if last byte of first page
@CrossPageDone
lda DecodeGCRnibble,x ; denibblize it
if CheckEncodings then
bmi @ChkSumError ; checksum error if illegal encoding
else
* bmi @ChkSumError ; no time to check for illegal encoding
endif
eor DecodeGCRHighB,y ; insert upper 2 bits of ByteB'
eor <GCRCkSumA ; ByteB := ByteB' xor CkSumA
sta (<DataBufPtr) ; store the byte
adc <GCRCkSumB ; CkSumB := CkSumB + ByteB + carry
sta <GCRCkSumB ; update CheckSum B
inc <DataBufPtr ; update buffer pointer
beq @ReadDataExit ; if last data byte transferred
ldx rData ; get ByteC'
lda DecodeGCRnibble,x ; denibblize it
if CheckEncodings then
bmi @ChkSumError ; checksum error if illegal encoding
else
* bmi @ChkSumError ; no time to check for illegal encoding
endif
eor DecodeGCRHighC,y ; insert upper 2 bits of ByteC'
eor <GCRCkSumB ; ByteC := ByteC' xor CkSumB
sta (<DataBufPtr) ; store the byte
adc <GCRCkSumC ; CkSumC := CkSumC + ByteC + carry
inc <DataBufPtr ; update buffer pointer
@ReadDataStart bit rHandshake ; see if 2 bytes are available
assert Dat2Bytes=$40
bvs @ReadDataLoop ; read the bytes if they are available
ldx #BytePollMax ; setup timeout counter
@PollDataLoop bit rHandshake ; check again
assert Dat2Bytes=$40
bvs @ReadDataLoop ; read the bytes if they are available
dex ; decrement timeout
bne @PollDataLoop ; poll until full, or timeout
bra @NoNybError ; return error if no bytes found
@DataCrossPage inc <DataBufPtr+1 ; update upper byte of buffer pointer
bra @CrossPageDone ; re-join loop
title 'IOP SWIM Driver - Read Sector Data - GCR Tail'
@ToChkSumError bra @ChkSumError ; jump through here for short displacements
@ReadDataExit ldx rData ; get the upper bits of checksum nibbles
ldy DecodeGCRnibble,x ; denibblize it
bmi @ToChkSumError ; checksum error if illegal encoding
inc <DataBufPtr+1 ; update upper byte of data buffer pointer
inc <TagBufPtr ; update tag buffer pointer
@pollCkSumBytes bit rHandshake ; see if 2 bytes are available
assert Dat2Bytes=$40
bvc @pollCkSumBytes ; loop until 2 bytes are ready
ldx rData ; get checksum byte A
lda DecodeGCRnibble,x ; denibblize it
bmi @ToChkSumError ; checksum error if illegal encoding
eor DecodeGCRHighA,y ; insert upper 2 bits
eor <GCRCkSumA ; compare it to computed value
bne @ToChkSumError ; checksum error if doesn't match
ldx rData ; get checksum byte B
lda DecodeGCRnibble,x ; denibblize it
bmi @ToChkSumError ; checksum error if illegal encoding
eor DecodeGCRHighB,y ; insert upper 2 bits
eor <GCRCkSumB ; compare it to computed value
bne @ToChkSumError ; checksum error if doesn't match
ldx rData ; get checksum byte C
lda DecodeGCRnibble,x ; denibblize it
bmi @ToChkSumError ; checksum error if illegal encoding
eor DecodeGCRHighC,y ; insert upper 2 bits
eor <GCRCkSumC ; compare it to computed value
bne @ToChkSumError ; checksum error if doesn't match
ldy #StartAction\
+WriteMode ; prepare to clear action and write mode
@pollSlipMarks bit rHandshake ; see if 2 bytes are available
assert Dat2Bytes=$40
bvc @pollSlipMarks ; loop until bytes are ready
lda rData ; get the first slip mark byte
eor GCRDataSlipMark+0 ; compare to expected value
bne @SlipMarkError ; return with error if bad slip mark
lda rData ; get the second slip mark byte
eor GCRDataSlipMark+1 ; compare to expected value
beq @SlipMarksDone ; return with success if good slip mark
@SlipMarkError lda #badDBtSlp ; sector data slip mark error
@SlipMarksDone ldx rError ; read error reg for logic analyzer
sty wZeroes ; clear action and write mode (read done)
tax ; set flags based upon error code
rts ; all done
title 'IOP SWIM Driver - Read Sector Data - MFM'
entry PollDMADone
ReadMFMData lda rError ; read and clear any pending errors
lda #StartAction\
+WriteMode ; prepare to clear action and write mode
sta wZeroes ; clear action and write mode (prepare for read)
lda #ClearFIFO ; prepare to clear the FIFO
sta wOnes ; toggle it to one
sta wZeroes ; and back to zero to clear it
lda rError ; read and clear errors again
lda #StartAction ; prepare to start reading
sta wOnes ; start shifting in the read data
; fill in the tag info (while SWIM is looking for "bytes of zeros" sync field)
lda <SectHdrCylinder ; get cylinder number from sector header
ldy #0 ; index to first tag byte
sta (<TagBufPtr),y ; save it in the tag bytes
lda <SectHdrHead ; get head number from sector header
iny ; point to next tag byte
sta (<TagBufPtr),y ; save it in the tag bytes
lda <SectHdrSector ; get head number from sector header
ina ; convert back to one based numbering
iny ; point to next tag byte
sta (<TagBufPtr),y ; save it in the tag bytes
lda <SectHdrFmtKind ; get block size from sector header
ora #$20 ; modified to look double sided
iny ; point to next tag byte
sta (<TagBufPtr),y ; save it in the tag bytes
lda <SectHdrChkSumH ; get first checksum byte from sector header
iny ; point to next tag byte
sta (<TagBufPtr),y ; save it in the tag bytes
lda <SectHdrChkSumL ; get second checksum byte from sector header
iny ; point to next tag byte
sta (<TagBufPtr),y ; save it in the tag bytes
lda <SectHdrError ; get rError value from sector header read
iny ; point to next tag byte
sta (<TagBufPtr),y ; save it in the tag bytes
lda <SectHdrHandshake ; get rHandshake value from sector header read
iny ; point to next tag byte
sta (<TagBufPtr),y ; save it in the tag bytes
if UseDmaHardware then
lda #>(BlockSize-1) ; high byte of DMA count
sta DMA1XferCountH ; setup high byte of transfer count
lda #<(BlockSize-1) ; low byte of DMA count
sta DMA1XferCountL ; setup low byte of transfer count
lda #1 ; first byte of buffer is polled, rest is DMA
sta DMA1RAMAddressL ; setup low byte of buffer address
lda <DataBufPtr+1 ; get high byte of buffer address
sta DMA1RAMAddressH ; setup high byte of buffer address
endif
; now search for the data mark byte sequence
assert DataSearchMax<128 ; it fits in 1 byte
lda #DataSearchMax-1 ; search byte count
sta <LoopCountL ; initialize the byte search count
ldx #0 ; index into data marks table
@GetNextByte ldy #BytePollMax ; approximate loop count for 1 byte time
lda #MarkInFIFO ; test for mark byte also
@PollByteLoop bit rHandshake ; see if byte is available
assert Dat1Byte=$80
bmi @GotNextByte ; process the byte if one was found
dey ; decrement byte timeout counter
bne @PollByteLoop ; keep polling if count not expired
dec <LoopCountL ; update the search count
bpl @GetNextByte ; loop if still more bytes to search
@ByteTimeOut lda #noNybErr ; timeout while polling for a byte
@ErrorReturn ldx rError ; read error reg for logic analyzer
ldy #StartAction\
+WriteMode ; prepare to clear action and write mode
sty wZeroes ; clear action and write mode (read done)
tax ; set flags based upon error code
rts ; return with error
@ChkSumError lda #badDCkSum ; sector data checksum error
bra @ErrorReturn ; return with checksum error
@GotNextByte stz <LoopCountL ; force any new timeouts to cause errors
beq @GotDataByte ; if not a mark byte
lda rMark ; get the mark byte
eor MFMDataMark,x ; check against expected value
bne @NoDataMark ; if not a match, report error
inx ; point to next search byte
cpx #MFMDataMarkSize ; see if this was the final byte
blt @GetNextByte ; get next byte if not final byte
; ; final byte should not be a mark byte
@NoDataMark lda #noDtaMkErr ; data mark not found within timeout period
bra @ErrorReturn ; return with error status
@GotDataByte lda rData ; get the data byte
eor MFMDataMark,x ; check against expected value
bne @NoDataMark ; if not a match, report error
cpx #MFMDataMarkSize-1 ; see if this was the final byte
blt @NoDataMark ; only final byte should be a data byte
; get the sector data
if UseDmaHardware then
ldx #<(rData*IOA1+DMADIR1+DMAEN1)
@WaitSectorByte bit rHandshake ; see if byte is available
assert Dat1Byte=$80
bpl @WaitSectorByte ; loop until byte is ready
lda rData ; get the data byte
stx DMA1Control ; start the DMA transfer
sta (<DataBufPtr) ; store the first byte
lda <DMARetryStatus ; see if any DMA timeouts on this track
bne @pollDMA ; if so, don't allow interrupts
lda #<DMAxferDelay ; delay to give ADB some time during DMA xfer
ldx #>DMAxferDelay ; high byte
jsr StartReadyTimer ; start the timer
pla ; pop pcL
plx ; pop pcH
ldy <ReadyTMPB ; get the TMPB index
jsr WaitTMPBdone ; give ADB some time while DMA xfer in progress
phx ; push pcH
pha ; push pcL
lda #0 ; allow interrupts during poll
@pollDMA jsr PollDMADone ; wait for transfer to complete
bne @ErrorReturn ; return retry status if DMA timeout
else
ldx #BlockSize/256 ; page counter 2 pages = 512 bytes
@GetSectorByte lda #MarkInFIFO ; test for mark byte also
bit rHandshake ; see if byte is available
assert Dat1Byte=$80
bmi @GotSectorByte ; if byte is ready
ldy #BytePollMax ; approximate loop count for 1 byte time
@SectorByteLoop dey ; decrement byte timeout counter
beq @ByteTimeOut ; return with timeout error if count expired
bit rHandshake ; see if byte is available
assert Dat1Byte=$80
bpl @SectorByteLoop ; keep polling if byte not ready
@GotSectorByte bne @ChkSumError ; if mark byte, report as checksum error
lda rData ; get the data byte
sta (<DataBufPtr) ; store the byte
inc <DataBufPtr ; update buffer pointer
bne @GetSectorByte ; keep going if not page crossing
inc <DataBufPtr+1 ; update buffer pointer page number
dex ; update page counter
bne @GetSectorByte ; keep going if not the last page
endif
; get the sector checksum
ldx #BytePollMax*2 ; poll timeout counter for 2 bytes
@pollChkSumH dex ; decrement timeout counter
beq @ByteTimeOut ; if timed out waiting for a byte
lda rHandshake ; see if byte is available
assert Dat1Byte=$80
bpl @pollChkSumH ; loop until byte is ready
bit #MarkInFIFO ; test for mark byte
bne @ChkSumError ; if mark byte, report as checksum error
lda rData ; get the first checksum byte
ldy #8 ; point to next tag byte
sta (<TagBufPtr),y ; save it in the tag bytes
@pollChkSumL dex ; decrement timeout counter
beq @ByteTimeOut ; if timed out waiting for a byte
lda rHandshake ; see if byte is available
assert Dat1Byte=$80
bpl @pollChkSumL ; loop until byte is ready
bit #MarkInFIFO ; test for mark byte
bne @ChkSumError ; if mark byte, report as checksum error
tax ; save the handshake register value
lda rData ; get the second checksum byte
iny ; point to next tag byte
sta (<TagBufPtr),y ; save it in the tag bytes
lda rError ; get the final error register
iny ; point to next tag byte
sta (<TagBufPtr),y ; save it in the tag bytes
txa ; get the final handshake register
iny ; point to next tag byte
sta (<TagBufPtr),y ; save it in the tag bytes
ldy #StartAction\
+WriteMode ; prepare to clear action and write mode
and #rErrorValid\
+CRCNotZero ; check for errors
beq @ChkSumDone ; if checksum is good
lda #badDCkSum ; sector data checksum error
@ChkSumDone sty wZeroes ; clear action and write mode (read done)
rts ; all done
endwith
endwith
endproc
seg 'WordConsts'
ReadDataDecode proc
dc.w ReadUnknownData ; 0 - uncheckedFormat
dc.w ReadUnknownData ; 1 - unknownFormat
dc.w ReadUnknownData ; 2 - HD20Format
dc.w ReadGCRData ; 3 - GCR400Kformat
dc.w ReadGCRData ; 4 - GCR800Kformat
dc.w ReadMFMData ; 5 - MFM720Kformat
dc.w ReadMFMData ; 6 - MFM1440Kformat
dc.w RdWrGCRonHDData ; 7 - GCRonHDformat
dc.w ReadUnknownData ; 8 - reserved for future use
dc.w ReadUnknownData ; 9 - reserved for future use
dc.w ReadUnknownData ; 10 - reserved for future use
endproc
title 'IOP SWIM Driver - Write Utilities'
;_______________________________________________________________________
;
; Routine: jsr WriteByte
; Inputs: A - byte to be written
; SwimWriteReg - pointer SWIM register to use
; Outputs: none
; Destroys: n, v, z
; Calls: ??
; Called by: ??
;
; Function: Waits for room for a byte to be available in the FIFO, and
; then writes the byte to the FIFO, using the SWIM register
; specified by SwimWriteReg.
;_______________________________________________________________________
;_______________________________________________________________________
;
; Routine: jsr WriteRepeated
; Inputs: A - byte to be written
; X - number of times to be repeated
; SwimWriteReg - pointer SWIM register to use
; Outputs: X - zero
; Destroys: n, v, z
; Calls: ??
; Called by: ??
;
; Function: Waits for room for a byte to be available in the FIFO, and
; repeatedly writes the byte to the FIFO, using the SWIM register
; specified by SwimWriteReg.
;_______________________________________________________________________
;_______________________________________________________________________
;
; Routine: jsr WriteTemplate
; Inputs: A - byte to be written
; X - number of bytes to write
; Y - starting offset from SectorTemplates
; SwimWriteReg - pointer SWIM register to use
; Outputs: X - zero
; Y - incremented to point past last byte written
; Destroys: A, n, v, z
; Calls: ??
; Called by: ??
;
; Function: Waits for room for a byte to be available in the FIFO, and
; repeatedly writes the byte string template to the FIFO, using
; the SWIM register specified by SwimWriteReg.
;_______________________________________________________________________
;_______________________________________________________________________
;
; Routine: jsr WriteMFMCRC
; Inputs: none
; Outputs: none
; Destroys: n, v, z
; Calls: ??
; Called by: ??
;
; Function: Waits for room for a byte to be available in the FIFO, and
; then writes to the wCRC register causing 2 CRC bytes to be
; written in MFM mode.
;_______________________________________________________________________
;_______________________________________________________________________
;
; Routine: jsr WriteDataBuffer
; Inputs: A - byte to be written before buffer
; X - low byte of byte count
; Y - high byte of byte count
; DataBufPtr - starting PAGE address of data buffer
; SwimWriteReg - pointer SWIM register to use
; Outputs: A - error status code
; n,z - based on value returned in A
; Destroys: n, v, z
; Calls: ??
; Called by: ??
;
; Function: Writes the contents of the data buffer, whose address and
; length are passed in as parameters, to the disk.
;_______________________________________________________________________
seg 'code'
WriteUtilities proc
entry WriteByte
entry WriteRepeated
entry WriteTemplate
entry WriteMFMCRC
entry WriteDataExit
entry WriteDataBuffer
entry PollDMADone
with SWIMVarsZ
with SWIMVars
WrRepeatedPoll bit rHandshake ; see if we have room in the FIFO
assert Dat1Byte=$80
bpl WrRepeatedPoll ; wait until there is room for one byte
sta (<SwimWriteReg) ; write the byte
WriteRepeated dex ; decrement the byte count
bne WrRepeatedPoll ; loop if not the last byte
; otherwise fall into WriteByte for last byte
WriteByte bit rHandshake ; see if we have room in the FIFO
assert Dat1Byte=$80
bpl WriteByte ; wait until there is room for one byte
sta (<SwimWriteReg) ; write the byte
rts ; all done
WriteTemplate lda SectorTemplates,y ; get the byte
iny ; point to next byte of the template
dex ; decrement the byte count
beq WriteByte ; exit through WriteByte for last byte
WrTemplatePoll bit rHandshake ; see if we have room in the FIFO
assert Dat1Byte=$80
bpl WrTemplatePoll ; wait until there is room for one byte
sta (<SwimWriteReg) ; write the byte
bra WriteTemplate ; loop through all of the bytes
WriteMFMCRC bit rHandshake ; see if room is available in the FIFO
assert Dat1Byte=$80
bpl WriteMFMCRC ; wait until there is room
stz wCRC ; writing any value causes 2 CRC bytes to write
rts ; all done
WriteDataExit ldx #4 ; 4 bytes to flush shiftreg and 2 FIFOs
jsr WriteRepeated ; write the gap bytes (only 1 will get to disk)
lda rHandshake ; prepare to check rErrorValid bit
ldy #StartAction+WriteMode ; prepare to clear action and write mode
sty wZeroes ; clear action and write mode (write done)
ldx rError ; read and clear the final error register
and #rErrorValid ; check handshake register for any errors
beq @Done ; if no errors during write
lda #wrUnderrun ; report any write error as an underrun error
@Done rts ; all done
if UseDmaHardware then
WriteDataBuffer stx DMA1XferCountL ; setup low byte of transfer count
sty DMA1XferCountH ; setup high byte of transfer count
stz DMA1RAMAddressL ; setup low byte of buffer address (page aligned)
ldx <DataBufPtr+1 ; get high byte of buffer address
stx DMA1RAMAddressH ; setup high byte of buffer address
ldx #<(wData*IOA1+DMAEN1)
@pollLoop bit rHandshake ; see if room is available in the FIFO
assert Dat1Byte=$80
bpl @pollLoop ; wait until there is room
sta (<SwimWriteReg) ; write it to the disk
stx DMA1Control ; start the DMA transfer
lda <DMARetryStatus ; see if any DMA timeouts on this track
bne @pollDMA ; if so, don't allow interrupts
lda #<DMAxferDelay ; delay to give ADB some time during DMA xfer
ldx #>DMAxferDelay ; high byte
jsr StartReadyTimer ; start the timer
pla ; pop pcL
plx ; pop pcH
ldy <ReadyTMPB ; get the TMPB index
jsr WaitTMPBdone ; give ADB some time while DMA xfer in progress
phx ; push pcH
pha ; push pcL
lda #0 ; allow interrupts during poll
@pollDMA bra PollDMADone ; wait for transfer to complete (and return status)
else
WriteDataBuffer bit rHandshake ; see if room is available in the FIFO
assert Dat1Byte=$80
bpl WriteDataBuffer ; wait until there is room
sta (<SwimWriteReg) ; write it to the disk
txa ; test the low byte of the count
beq @decCountH ; if zero, decrement the high byte
@nextByte lda (<DataBufPtr) ; get the byte
inc <DataBufPtr ; update buffer pointer
bne @pollLoop ; keep going if not page crossing
inc <DataBufPtr+1 ; update buffer pointer page number
@pollLoop bit rHandshake ; see if room is available in the FIFO
assert Dat1Byte=$80
bpl @pollLoop ; wait until there is room
sta (<SwimWriteReg) ; write it to the disk
dex ; decrement low byte of count
bne @nextByte ; loop through all of the bytes
@decCountH dey ; decrement high byte of count
bpl @nextByte ; loop until entire count exhausted
lda #noErr ; indicate success
rts ; all done
endif
endwith
endwith
endproc
if UseDmaHardware then
title 'IOP SWIM Driver - Poll DMA Done'
;_______________________________________________________________________
;
; Routine: jsr PollDMADone
; Inputs: A - if non-zero don't enable interrupts
; - if zero enable interrupts for all but last page
; Outputs: A - DMARetryStatus (non-zero if timeout during DMA)
; Destroys: A, X, Y, n, v, c, z
; Calls: HandleDMA1Int
; Called by: ReadMFMData, WriteDataBuffer
;
; Function: Waits for a DMA transfer to complete, enabling interrupts
; if desired. Checks to make sure that bytes to transfer
; periodicaly, returning an error if DMA appears hung.
;_______________________________________________________________________
seg 'code'
PollDMADone proc
with SWIMVarsZ
with SWIMVars
tax ; test ints disable flag
bne @noInts ; if so, don't allow interrupts
bra @checkDMA ; see how the DMA is doing (no ints first time)
@addrChanged ldx #0 ; reset timeout counter
ldy DMA1XferCountL ; get the low byte of the DMA address counter
@intsLoop cli ; let interrupts have a chance
sei ; lock out interrupts
@checkDMA lda <DMARetryStatus ; see if DMA timeout while waiting
bne @done ; if so, return the DMA Retry Status
lda DMA1XferCountH ; see if more than a page left
beq @noInts ; if not, shut down interrupts, loop for end of xfer
cpy DMA1XferCountL ; see if address counter changed
bne @addrChanged ; if so, reset the timeout
inx ; update timeout
bne @intsLoop ; if no timeout, allow ints and keep polling
bra HandleDMA1Int ; if timed out, kill the xfer and return the error
@noInts lda #DMA1INT
bit InterruptReg ; see if xfer complete
bne HandleDMA1Int ; if so, it's too soon, no ints next time
ldx #$00 ; reset timeout
@waitNext ldy DMA1XferCountL ; get low byte of count
@waitLoop bit InterruptReg ; see if xfer complete
bne @waitDone ; if so, the wait is over
dex ; update timeout count
bne @waitLoop ; if no timeout, update keep waiting
cpy DMA1XferCountL ; see if count changed
bne @waitNext ; if count change, restart timeout
bra HandleDMA1Int ; DMA timed out, kill it
@waitDone stz DMA1Control ; stop the DMA transfer
sta InterruptReg ; clear the interrupt
lda #noErr ; indicate success
@done rts ; all done
export HandleDMA1Int
HandleDMA1Int stz DMA1Control ; stop the DMA transfer
lda #DMA1INT
sta InterruptReg ; clear the interrupt
lda #StartAction\
+WriteMode ; prepare to clear action and write mode
sta wZeroes ; clear action and write mode (write done)
lda rError ; read and clear the final error register
inc <DMARetryStatus ; indicate that DMA request needs to be retried
lda <DMARetryStatus ; return the retry count as the status
cpa #2 ; see if second offense
blt @done ; if not, return count as error code
lda #noNybErr ; otherwise indicate timeout while polling for a byte
@done rts ; return from the interrupt
endwith
endwith
endproc
endif
title 'IOP SWIM Driver - Write GCR Data Loop'
;_______________________________________________________________________
;
; Routine: jmp WrGCRdataStart
;
; Function: This is the internal data transfer loop used by
; WriteGCRData. In order for this loop to execute in the
; correct number of cycles, it must reside within page zero,
; and it contains some self modifing code (no opcodes are
; modified, just immediate operands, and the low byte of
; an absolute address operand.) This code is designed to
; run in lock step with the swim chip, and does not contain
; any code to check the handshake register, because if we
; are in sync when we enter, we will stay in sync throughout
; the loop.
;_______________________________________________________________________
seg 'zcode'
WrGCRdataLoop proc
entry WrGCRdataStart ; entry label
entry WriteGCRtail ; exit label
entry GCRWrByteC ; modified low byte of an abs address
entry GCRWrCkSumA ; modified immediate field
entry GCRWrCkSumB ; modified immediate field
entry GCRWrCkSumC ; modified immediate field
with SWIMVarsZ
with SWIMVars
eor (<DataBufPtr) ; ByteC' := ByteC xor CkSumB
sta <GCRWrByteC+1 ; save ByteC'
lda EncodeGCRHighA,x ; get high bits of ByteA'
ora EncodeGCRHighB,y ; insert high bits of ByteB'
GCRWrByteC ora EncodeGCRHighC ; insert high bits of ByteC'
; T=+65 FIFO1 = empty, FIFO2 = empty, ShiftReg = ByteC'
sta <HighNibble+1 ; save high bits nibble
HighNibble lda EncodeGCRnibble ; encode the high bits nibble
sta wData ; write out the high bits nibble
; T=+76 FIFO1 = empty, FIFO2 = HiBits, ShiftReg = ByteC'
lda EncodeGCRnibble,x ; encode the ByteA' nibble
sta wData ; write out the ByteA' nibble
; T=+84 FIFO1 = ByteA', FIFO2 = HiBits, ShiftReg = ByteC'
lda <GCRWrByteC+1 ; restore ByteC'
eor <GCRWrCkSumB+1 ; remove CkSumB to get ByteC
GCRWrCkSumC adc #<GCRWrCkSumC+1 ; CkSumC := CkSumC + ByteC + carry
cpa #$80 ; carry := CheckSumC [7]
rol a ; [6] [5] [4] [3] [2] [1] [0] [7]
; T=+96 FIFO1 = empty, FIFO2 = ByteA', ShiftReg = HiBits
sta <GCRWrCkSumC+1 ; update checksum C
inc <DataBufPtr ; point to next data byte
; T=+8 FIFO1 = empty, FIFO2 = ByteA', ShiftReg = HiBits
WrGCRdataStart eor (<DataBufPtr) ; ByteA' := ByteA xor CkSumC
tax ; save ByteA'
eor <GCRWrCkSumC+1 ; remove CkSumC to get ByteA
GCRWrCkSumA adc #GCRWrCkSumA+1 ; CkSumA := CkSumA + ByteA + carry
sta <GCRWrCkSumA+1 ; update checksum A
inc DataBufPtr ; point to next data byte
bne @CrossPageDone ; if not cross page
inc <DataBufPtr+1 ; update high byte on page crossing
@CrossPageDone
;T=+127 FIFO1 = empty, FIFO2 = empty, ShiftReg = ByteA'
; on the bread board, accesses to the swim chip cause the cycle to be
; stretched by 0.25 clocks, and since we make 4 accesses in this loop,
; the total stretch time is 1.0 clocks, which makes this loop exactly
; 128 clocks. (except for the one iteration which crosses a page boundary,
; which is 132 clocks)
; T=0…7 FIFO1 = empty, FIFO2 = empty, ShiftReg = ByteA'
lda EncodeGCRnibble,y ; encode the ByteB' nibble
sta wData ; write out the ByteB' nibble
; T=+8 FIFO1 = empty, FIFO2 = ByteB', ShiftReg = ByteA'
ldy <GCRWrByteC+1 ; get ByteC'
lda EncodeGCRnibble,y ; encode the ByteC' nibble
sta wData ; write out the ByteC' nibble
; T=+19 FIFO1 = ByteC', FIFO2 = ByteB', ShiftReg = ByteA'
lda <GCRWrCkSumA+1 ; restore checksum A
eor (<DataBufPtr) ; ByteB' := ByteB xor CkSumA
tay ; save ByteB'
eor <GCRWrCkSumA+1 ; remove CkSumA to get ByteB
; T=+32 FIFO1 = empty, FIFO2 = ByteC', ShiftReg = ByteB'
GCRWrCkSumB adc #GCRWrCkSumB+1 ; CkSumB := CkSumB + ByteB + carry
sta <GCRWrCkSumB+1 ; update checksum B
inc <DataBufPtr ; point to next data byte
bne WrGCRdataLoop ; loop until end of page 2 (512 bytes)
jmp WriteGCRtail ; write out last 2 bytes and checksum
; T=+51 FIFO1 = empty, FIFO2 = ByteC', ShiftReg = ByteB'
endwith
endwith
endproc
title 'IOP SWIM Driver - Write Sector Data'
;_______________________________________________________________________
;
; Routine: jsr WriteSectorData
; Inputs: CurrentDrive - active drive number
; TagBufPtr - pointer to 12 byte tag buffer
; DataBufPtr - pointer to 512 byte data buffer
; SectHdrSector - sector number that we are about to write
; Expects to be called after ReadSectorHdr
; Outputs: A - error status code
; n,z - based on value returned in A
; Destroys: X, Y, n, z, c
; Calls: WriteUnknownData, WriteGCRData, WriteMFMData, RdWrGCRonHDData
; Called by: SWIMWrite
;
; Function: Writes the sector Tag and Data information for the current
; sector on the selected head, on the current cylinder.
;
; NOTE: The data buffer must be page aligned, and the tag
; buffer must not span across pages.
;_______________________________________________________________________
seg 'code'
WriteSectorData proc
entry WriteDataDecode
entry WriteUnknownData
entry WriteGCRData
entry WriteGCRFmtData
entry WriteGCRtail
entry WriteMFMData
with SWIMVarsZ
with SWIMVars
ldx <SectHdrFmtIndex ; get index from ReadSectorHdr
jmp (WriteDataDecode,x) ; dispatch to the routine
WriteUnknownData
lda #noDtaMkErr ; unsupported format, return with error
rts ; all done
title 'IOP SWIM Driver - Write Sector Data - GCR'
WriteGCRData
* lda rData ; empty garbage byte out of the FIFO,
* lda rError ; read and clear any pending errors
lda #StartAction\
+WriteMode ; prepare to clear action and write mode
sta wZeroes ; clear action and write mode
lda #WriteMode ; prepare to enter write mode
sta wOnes ; change to write mode
ldy #ClearFIFO ; prepare to clear the FIFO
sty wOnes ; toggle it to one
sty wZeroes ; and back to zero to clear it
; FIFO1 = empty, FIFO2 = empty, ShiftReg = empty
lda rError ; read and clear errors again
ldx #StartAction ; prepare to start writing
lda #$FF ; byte 1 of 6 byte sync field
sta wData ; write it to the FIFO
; FIFO1 = empty, FIFO2 = $FF, ShiftReg = empty
WriteGCRFmtData
lda #$3F ; byte 2 of 6 byte sync field
sta wData ; write it to the FIFO
; FIFO1 = $3F, FIFO2 = $FF, ShiftReg = empty
lda (<TagBufPtr) ; get byte 1 of 12 byte tag field
sta <WrTagBytesA+3 ; save ByteA' (byte 1)
sta <GCRWrCkSumA+1 ; CkSumA := ByteA
assert ClearFIFO=1 ; y = 1 from "ldy #ClearFIFO" above
* ldy #1 ; point to next tag byte
eor (<TagBufPtr),y ; ByteB' := ByteB xor CkSumA (byte 2 of 12)
stx wOnes ; turn on Action to start shifting out the write data
; T=0 FIFO1 = empty, FIFO2 = $3F, ShiftReg = $FF
sta <WrTagBytesB+3 ; save ByteB' (byte 2)
eor <GCRWrCkSumA+1 ; remove CkSumA to get ByteB
sta <GCRWrCkSumB+1 ; CkSumB := ByteB
iny ; point to next tag byte
eor (<TagBufPtr),y ; ByteC' := ByteC xor CkSumB (byte 3 of 12)
sta <WrTagBytesC+3 ; save ByteC' (byte 3)
eor <GCRWrCkSumB+1 ; remove CkSumB to get ByteC
cpa #$80 ; carry := CheckSumC [7]
rol a ; [6] [5] [4] [3] [2] [1] [0] [7]
sta <GCRWrCkSumC+1 ; initialize checksum C
iny ; point to next tag byte
ldx #$CF ; byte 3 of 6 byte sync field
; T=32 FIFO1 = empty, FIFO2 = empty, ShiftReg = $3F
stx wData ; write it to the FIFO
; T=36 FIFO1 = empty, FIFO2 = $CF, ShiftReg = $3F
ldx #$F3 ; byte 4 of 6 byte sync field
@bugPoll bit rHandshake ; wait for 1 byte available in the FIFO
; T=0…7 FIFO1 = empty, FIFO2 = $CF, ShiftReg = $3F
assert Dat1Byte=$80
bpl @bugPoll ; wait until there is room for 1
stx wData ; write it to the FIFO
; T=48 FIFO1 = $F3, FIFO2 = $CF, ShiftReg = $3F
eor (<TagBufPtr),y ; ByteA' := ByteA xor CkSumC (byte 4 of 12)
sta <WrTagBytesA+2 ; save ByteA' (byte 4)
eor <GCRWrCkSumC+1 ; remove CkSumC to get ByteA
adc <GCRWrCkSumA+1 ; CkSumA := CkSumA + ByteA + carry
; T=64 FIFO1 = empty, FIFO2 = $F3, ShiftReg = $CF
sta <GCRWrCkSumA+1 ; update checksum A
iny ; point to next tag byte
eor (<TagBufPtr),y ; ByteB' := ByteB xor CkSumA (byte 5 of 12)
sta <WrTagBytesB+2 ; save ByteB' (byte 5)
eor <GCRWrCkSumA+1 ; remove CkSumA to get ByteB
adc <GCRWrCkSumB+1 ; CkSumB := CkSumB + ByteB + carry
sta <GCRWrCkSumB+1 ; update checksum B
iny ; point to next tag byte
eor (<TagBufPtr),y ; ByteC' := ByteC xor CkSumB (byte 6 of 12)
sta <WrTagBytesC+2 ; save ByteC' (byte 6)
; T=96 FIFO1 = empty, FIFO2 = empty, ShiftReg = $F3
eor <GCRWrCkSumB+1 ; remove CkSumB to get ByteC
adc <GCRWrCkSumC+1 ; CkSumC := CkSumC + ByteC + carry
cpa #$80 ; carry := CheckSumC [7]
rol a ; [6] [5] [4] [3] [2] [1] [0] [7]
sta <GCRWrCkSumC+1 ; update checksum C
iny ; point to next tag byte
ldx #$FC ; byte 5 of 6 byte sync field
stx wData ; write it to the FIFO
; T=115 FIFO1 = empty, FIFO2 = $FC, ShiftReg = $F3
ldx #$FF ; byte 6 of 6 byte sync field
stx wData ; write it to the FIFO
; T=121 FIFO1 = $FF, FIFO2 = $FC, ShiftReg = $F3
eor (<TagBufPtr),y ; ByteA' := ByteA xor CkSumC (byte 7 of 12)
; T=128 FIFO1 = empty, FIFO2 = $FF, ShiftReg = $FC
sta <WrTagBytesA+1 ; save ByteA' (byte 7)
eor <GCRWrCkSumC+1 ; remove CkSumC to get ByteA
adc <GCRWrCkSumA+1 ; CkSumA := CkSumA + ByteA + carry
sta <GCRWrCkSumA+1 ; update checksum A
iny ; point to next tag byte
eor (<TagBufPtr),y ; ByteB' := ByteB xor CkSumA (byte 8 of 12)
sta <WrTagBytesB+1 ; save ByteB' (byte 8)
eor <GCRWrCkSumA+1 ; remove CkSumA to get ByteB
adc <GCRWrCkSumB+1 ; CkSumB := CkSumB + ByteB + carry
sta <GCRWrCkSumB+1 ; update checksum B
iny ; point to next tag byte
; T=160 FIFO1 = empty, FIFO2 = empty, ShiftReg = $FF
ldx GCRDataMark+0 ; byte 1 of 3 byte data mark sequence
stx wData ; write it to the FIFO
; T=167 FIFO1 = empty, FIFO2 = $D5, ShiftReg = $FF
ldx GCRDataMark+1 ; byte 2 of 3 byte data mark sequence
stx wData ; write it to the FIFO
; T=175 FIFO1 = $AA, FIFO2 = $D5, ShiftReg = $FF
eor (<TagBufPtr),y ; ByteC' := ByteC xor CkSumB (byte 9 of 12)
sta <WrTagBytesC+1 ; save ByteC' (byte 9)
eor <GCRWrCkSumB+1 ; remove CkSumB to get ByteC
adc <GCRWrCkSumC+1 ; CkSumC := CkSumC + ByteC + carry
; T=192 FIFO1 = empty, FIFO2 = $AA, ShiftReg = $D5
cpa #$80 ; carry := CheckSumC [7]
rol a ; [6] [5] [4] [3] [2] [1] [0] [7]
sta <GCRWrCkSumC+1 ; update checksum C
iny ; point to next tag byte
eor (<TagBufPtr),y ; ByteA' := ByteA xor CkSumC (byte 10 of 12)
sta <WrTagBytesA+0 ; save ByteA' (byte 10)
eor <GCRWrCkSumC+1 ; remove CkSumC to get ByteA
adc <GCRWrCkSumA+1 ; CkSumA := CkSumA + ByteA + carry
sta <GCRWrCkSumA+1 ; update checksum A
iny ; point to next tag byte
eor (<TagBufPtr),y ; ByteB' := ByteB xor CkSumA (byte 11 of 12)
; T=224 FIFO1 = empty, FIFO2 = empty, ShiftReg = $AA
sta <WrTagBytesB+0 ; save ByteB' (byte 11)
eor <GCRWrCkSumA+1 ; remove CkSumA to get ByteB
adc <GCRWrCkSumB+1 ; CkSumB := CkSumB + ByteB + carry
sta <GCRWrCkSumB+1 ; update checksum B
iny ; point to next tag byte
ldx GCRDataMark+2 ; byte 3 of 3 byte data mark sequence
stx wData ; write it to the FIFO
; T=244 FIFO1 = empty, FIFO2 = $AD, ShiftReg = $AA
eor (<TagBufPtr),y ; ByteC' := ByteC xor CkSumB (byte 12 of 12)
sta <WrTagBytesC+0 ; save ByteC' (byte 12)
ldy <SectHdrSector ; sector number that we are about to write
; T=256 FIFO1 = empty, FIFO2 = empty, ShiftReg = $AD
ldx EncodeGCRnibble,y ; encode the ByteC' nibble
stx wData ; write out the ByteC' nibble
; T=263 FIFO1 = empty, FIFO2 = Sector, ShiftReg = $AD
eor <GCRWrCkSumB+1 ; remove CkSumB to get ByteC
adc <GCRWrCkSumC+1 ; CkSumC := CkSumC + ByteC + carry
cpa #$80 ; carry := CheckSumC [7]
rol a ; [6] [5] [4] [3] [2] [1] [0] [7]
sta <GCRWrCkSumC+1 ; update checksum C
ldx #4-1 ; get loop counter and index
@WriteTagsLoop ldy <WrTagBytesA,x ; get ByteA'
lda EncodeGCRHighA,y ; get high bits of ByteA'
; T=288 FIFO1 = empty, FIFO2 = empty, ShiftReg = Sector
; T=+32 FIFO1 = empty, FIFO2 = ByteC', ShiftReg = ByteB'
ldy <WrTagBytesB,x ; get ByteB'
ora EncodeGCRHighB,y ; insert high bits of ByteB'
ldy <WrTagBytesC,x ; get ByteC'
ora EncodeGCRHighC,y ; insert high bits of ByteC'
tay ; get high bits nibble
lda EncodeGCRnibble,y ; encode the high bits nibble
sta wData ; write out the high bits nibble
; T=312 FIFO1 = empty, FIFO2 = HiBits, ShiftReg = Sector
; T=+58 FIFO1 = HiBits, FIFO2 = ByteC', ShiftReg = ByteB'
ldy <WrTagBytesA,x ; get ByteA'
lda EncodeGCRnibble,y ; encode the ByteA' nibble
; T=320 FIFO1 = empty, FIFO2 = empty, ShiftReg = HiBits
; T=+66 FIFO1 = empty, FIFO2 = HiBits, ShiftReg = ByteC'
sta wData ; write out the ByteA' nibble
; T=324 FIFO1 = empty, FIFO2 = ByteA', ShiftReg = HiBits
; T=+70 FIFO1 = ByteA', FIFO2 = HiBits, ShiftReg = ByteC'
ldy <WrTagBytesB,x ; get ByteB'
lda <WrTagBytesC,x ; get ByteC'
sta <GCRWrByteC+1 ; save ByteC'
dex ; decrement the index / loop count
bmi @WriteTagsDone ; if no more tags to do
@WriteTagsPoll bit rHandshake ; wait for 2 bytes available in the FIFO
; T=0…7 FIFO1 = empty, FIFO2 = empty, ShiftReg = ByteA'
assert Dat2Bytes=$40
bvc @WriteTagsPoll ; wait until there is room for 2
lda EncodeGCRnibble,y ; encode the ByteB' nibble
sta wData ; write out the ByteB' nibble
; T=+10 FIFO1 = empty, FIFO2 = ByteB', ShiftReg = ByteA'
ldy <GCRWrByteC+1 ; get ByteC'
lda EncodeGCRnibble,y ; encode the ByteC' nibble
sta wData ; write out the ByteC' nibble
; T=+24 FIFO1 = ByteC', FIFO2 = ByteB', ShiftReg = ByteA'
bra @WriteTagsLoop ; loop through all tag bytes
@WriteTagsDone bit rHandshake ; wait for 1 bytes available in the FIFO
; T=0…7 FIFO1 = empty, FIFO2 = ByteA', ShiftReg = HiBits
assert Dat1Byte=$80
bpl @WriteTagsDone ; wait until there is room for 1
lda <GCRWrCkSumC+1 ; setup checksum C
jmp WrGCRdataStart ; done with tags, start writing the data
; T=+51 FIFO1 = empty, FIFO2 = ByteC', ShiftReg = ByteB'
WriteGCRtail lda EncodeGCRHighA,x ; get high bits of ByteA'
ora EncodeGCRHighB,y ; insert high bits of ByteB'
phx ; save ByteA'
tax ; load index with high bits nibble
; T=+64 FIFO1 = empty, FIFO2 = empty, ShiftReg = ByteC'
lda EncodeGCRnibble,x ; encode the high bits nibble
sta wData ; write out the high bits nibble
; T=+72 FIFO1 = empty, FIFO2 = HiBits, ShiftReg = ByteC'
plx ; restore ByteA'
lda EncodeGCRnibble,x ; encode the ByteA' nibble
sta wData ; write out the ByteA' nibble
; T=+84 FIFO1 = ByteA', FIFO2 = HiBits, ShiftReg = ByteC'
lda GCRDataSlipMark+1 ; byte 2 of 2 byte slip mark
pha ; stack it for later
lda GCRDataSlipMark+0 ; byte 1 of 2 byte slip mark
; T=+95 FIFO1 = empty, FIFO2 = ByteA', ShiftReg = HiBits
pha ; stack it for later
ldx <GCRWrCkSumC+1 ; get checksum byte C
lda EncodeGCRnibble,x ; encode the byte C nibble
pha ; stack it for later
lda EncodeGCRnibble,y ; encode the ByteB' nibble
sta wData ; write out the ByteB' nibble
; T+116 FIFO1 = ByteB', FIFO2 = ByteA', ShiftReg = HiBits
ldy <GCRWrCkSumB+1 ; get checksum byte B
lda EncodeGCRnibble,y ; encode the byte B nibble
pha ; stack it for later
; T+126 FIFO1 = empty, FIFO2 = ByteB', ShiftReg = ByteA'
lda EncodeGCRHighC,x ; get high bits of byte C
ora EncodeGCRHighB,y ; insert high bits of byte B
ldx <GCRWrCkSumA+1 ; get checksum byte A
ldy EncodeGCRnibble,x ; encode the byte A nibble
phy ; stack it for later
ora EncodeGCRHighA,x ; insert high bits of byte A
tay ; get high bits nibble
lda EncodeGCRnibble,y ; encode the high bits nibble
sta wData ; write out the high bits nibble
; T+155 FIFO1 = ChkHi, FIFO2 = ByteB', ShiftReg = ByteA'
ldx #5 ; number of stacked bytes
@TailLoop pla ; get the byte from the stack
jsr WriteByte ; write it out
dex ; update byte count
bne @TailLoop ; loop until all bytes written
; Then finally add a few gap bytes so that the SlipMark
; will be fully written before writing is disabled...
lda GCRGapValue ; get the gap value
bit <WritingForFmt ; see if we are formatting
bmi @FmtExit ; if so, exit differently
jmp WriteDataExit ; flush the FIFO to disk
@FmtExit jsr WriteByte ; write out 2 GCR gap bytes
jmp WriteByte ; and return
title 'IOP SWIM Driver - Write Sector Data - MFM'
WriteMFMData
; De-select RdData0/1 to de-select index pulse during write to prevent noise/crosstalk
; on the RdData line from interfering with WrData and causing a bad write. This is a
; workaround for a noisy external drive cable. Instead we select somthing that will be
; a constant high.
assert (rMFMDriveAdr+HeadSelect)=rMFMModeOnAdr
lda #rMFMDriveAdr\
++ph0123en ; select rMFMDriveAdr/rMFMModeOnAdr
sta wPhase ; change the phase lines, but not HeadSelect.
lda rError ; read and clear any pending errors
lda #StartAction\
+WriteMode ; prepare to clear action and write mode
sta wZeroes ; clear action and write mode
lda #WriteMode ; prepare to enter write mode
sta wOnes ; change to write mode
lda #ClearFIFO ; prepare to clear the FIFO
sta wOnes ; toggle it to one
sta wZeroes ; and back to zero to clear it
lda rError ; read and clear errors again
; Save the return PC for the Async call to WriteDataBuffer
pla ; pop pcL
sta <AsyncPcL ; save PcL
pla ; pop pcH
sta <AsyncPcH ; save PcH
; Delay until we are close to 22 bytes past the end of the address field before
; starting the write.
ldx #MFMreWriteDelay ; get the delay loop counter
@reWriteWait dex ; decrement the counter
bne @reWriteWait ; loop until count exhausted
; write out the "bytes of zeroes" sync field
assert MFMSyncSize>2 ; assume that Sync will more than fill the FIFO
lda MFMSyncValue ; get the sync value
sta (<SwimWriteReg) ; fill the first FIFO byte
sta (<SwimWriteReg) ; fill the second FIFO byte before setting action
ldx #StartAction ; prepare to start writing
stx wOnes ; turn on Action to start shifting out the write data
ldx #MFMSyncSize-2 ; number of remaining sync bytes to write
jsr WriteRepeated ; write out the remaining sync bytes
; write out the data mark byte sequence
ldx #MFMDataMarkSize-1 ; number of MARK bytes to write
ldy #MFMDataMark-SectorTemplates
assert (wData+1)=wMark
inc <SwimWriteReg ; point to wMark
jsr WriteTemplate ; write the data mark mark bytes
assert (wMark-1)=wData
dec <SwimWriteReg ; point back to wData
lda SectorTemplates,y ; get final byte
; write the sector data
* ldx #<BlockSize ; x := zero from WriteTemplate
ldy #>BlockSize ; page counter 2 pages = 512 bytes
jsr WriteDataBuffer ; write out the data buffer
bne @DMAerror ; if timeout during DMA, report the error
; End the sector data with 2 CRC bytes...
jsr WriteMFMCRC ; write the 2 CRC bytes
; Restore the return PC
lda <AsyncPcH ; get PcH
pha ; restore PcH
lda <AsyncPcL ; get PcL
pha ; restore PcL
; Then finally add a few gap bytes so that the CRC
; will be fully written before writing is disabled...
lda MFMGapValue ; get the gap value
jmp WriteDataExit ; flush the FIFO to disk
@DMAerror ldx <AsyncPcH ; get PcH
phx ; restore PcH
ldx <AsyncPcL ; get PcL
phx ; restore PcL
tax ; set conditions to indicate DMA retry
rts ; return DMA retry count in reg-A
endwith
endwith
endproc
seg 'WordConsts'
WriteDataDecode proc
dc.w WriteUnknownData ; 0 - uncheckedFormat
dc.w WriteUnknownData ; 1 - unknownFormat
dc.w WriteUnknownData ; 2 - HD20Format
dc.w WriteGCRData ; 3 - GCR400Kformat
dc.w WriteGCRData ; 4 - GCR800Kformat
dc.w WriteMFMData ; 5 - MFM720Kformat
dc.w WriteMFMData ; 6 - MFM1440Kformat
dc.w RdWrGCRonHDData ; 7 - GCRonHDformat
dc.w WriteUnknownData ; 8 - reserved for future use
dc.w WriteUnknownData ; 9 - reserved for future use
dc.w WriteUnknownData ; 10 - reserved for future use
endproc
title 'IOP SWIM Driver - Skip Sector Data'
;_______________________________________________________________________
;
; Routine: jsr SkipSectorData
; Inputs: none
; Expects to be called after ReadSectorHdr
; Outputs: none
; Destroys: A, X, Y, n, v, z, c
; Calls: SkipUnknownData, SkipGCRData, SkipMFMData, SleepShort
; Called by: SWIMRead, SWIMReadVerify, SWIMWrite, SWIMFormatVerify,
; PrefetchIntoCache
;
; Function: Skips the sector Tag and Data information for the current
; sector whose header has just been read.
;
;_______________________________________________________________________
seg 'code'
SkipSectorData proc
entry SkipDataDecode
entry SkipUnknownData
entry SkipGCRData
entry SkipMFMData
with SWIMVarsZ
with SWIMVars
lda <WrongSectsLeft ; see how many sectors we can skip
cpa #WrongSectsMax/2 ; see if more than half used
blt DontSkip ; if so, don't give up the CPU
ldx <SectHdrFmtIndex ; get index from ReadSectorHdr
jmp (SkipDataDecode,x) ; dispatch to the routine
SkipGCRData lda #GCRSectorDataDelay-TypicalADBDelay-TMPB1ms
jmp SleepShort ; give ADB some time
SkipUnknownData ; unsupported format, use MFM timing
SkipMFMData lda #MFMSectorDataDelay-TypicalADBDelay-TMPB1ms
jmp SleepShort ; give ADB some time
DontSkip rts ; unsupported format, just return
endwith
endwith
endproc
seg 'WordConsts'
SkipDataDecode proc
dc.w SkipUnknownData ; 0 - uncheckedFormat
dc.w SkipUnknownData ; 1 - unknownFormat
dc.w SkipUnknownData ; 2 - HD20Format
dc.w SkipGCRData ; 3 - GCR400Kformat
dc.w SkipGCRData ; 4 - GCR800Kformat
dc.w SkipMFMData ; 5 - MFM720Kformat
dc.w SkipMFMData ; 6 - MFM1440Kformat
dc.w SkipGCRData ; 7 - GCRonHDformat
dc.w SkipUnknownData ; 8 - reserved for future use
dc.w SkipUnknownData ; 9 - reserved for future use
dc.w SkipUnknownData ; 10 - reserved for future use
endproc
title 'IOP SWIM Driver - Format Disk Track'
;_______________________________________________________________________
;
; Routine: jsr FormatTrack
; Inputs:
; Outputs: A - error status code
; n,z - based on value returned in A
; Destroys: X, Y, n, z, c
; Calls: FmtUnknownTrack, FmtGCRTrack, FmtMFMTrack
; Called by: SWIMFormat
;
; Function: Formats a Cylinder on the current drive.
;
;_______________________________________________________________________
seg 'code'
FormatTrack proc
entry FmtTrackDecode
entry FmtUnknownTrack
entry FmtGCRTrack
entry FmtMFMTrack
with SWIMVarsZ
with SWIMVars
with SectorBuffers
ply ; pop pcL
sty <AsyncPcL ; save PcL
ply ; pop pcH
sty <AsyncPcH ; save PcH
ldy <CurrentDrive ; get the active drive number
ldx DiskFormat,y ; see what format to read
lda RequiredMedia,x ; see what media is required
cpa MediaKind,y ; see if we have correct media
bne FmtUnknownTrack ; if wrong kind of media
txa ; get the DiskFormat
asl a ; compute the table index
tax ; load the index register
jmp (FmtTrackDecode,x) ; dispatch to the routine
FmtUnknownTrack lda #paramErr ; unsupported format, return with error
FmtTrackDone tax ; save the error code
lda <AsyncPcH ; restore PcH
pha ; push pcH
lda <AsyncPcL ; restore PcL
pha ; push pcL
lda <BaseBufferNum ; get base from last head formatted
clc ; setup for addition
adc <PhysSectsPerHead ; point to the first buffer for this head
sta <BaseBufferNum ; update the base buffer number
txa ; restore error code, set flags
rts ; all done
HdrFields record 0,increment
GCRCkSum
MFMBlkSize ds.b 1
GCRFmtKind
MFMSector ds.b 1
GCRHeadCyl
MFMHead ds.b 1
GCRSector
MFMCylinder ds.b 1
GCRCylinder
MFMLastAddrMark ds.b 1
endr
with HdrFields
WriteHdrInfo lda <SectHdrInfo+5-1 ; get the first byte to write
@Poll bit rHandshake ; see if we have room in the FIFO
assert Dat2Bytes=$40
bvc @Poll ; wait until there is room for two bytes
sta (<SwimWriteReg) ; write the byte
lda <SectHdrInfo+5-2 ; get the second byte to write
sta (<SwimWriteReg) ; write the byte
jsr SetupBufferPtrs ; setup DataBufPtr and TagBufPtr for this sector
lda <SectHdrInfo+5-3 ; get the third byte to write
sta (<SwimWriteReg) ; blindly write the byte
lda <SectHdrInfo+5-4 ; get the fourth byte to write
sta (<SwimWriteReg) ; blindly write the byte
lda <SectHdrInfo+5-5 ; get the final byte to write
jmp WriteByte ; write it out
; Create a buffer filled with the sector format pattern so that DMA can be used to blast them out
FillDataBuffer bit <CurDataBCPB ; see if optional data buffer exists
bpl @dataDone ; if so, don't fill buffer
ldx #>DataBuffers ; get the starting page number
stx <DataBufPtr+1 ; initialize high byte of buffer pointer
ldx #>DataBufSize ; number of pages to initialize
@fillerLoop sta (<DataBufPtr),y ; initialize the next byte of the buffer
iny ; update the page offset
bne @fillerLoop ; loop through the page
inc <DataBufPtr+1 ; update high byte of buffer pointer
dex ; update page count
bne @fillerLoop ; loop through all of the pages
@dataDone rts ; all done
FillTagBuffer sta TagBufStart,y ; initialize the first page of the buffer
sta TagBufEnd-$100,y ; initialize the last page of the buffer
iny ; update the page offset
bne FillTagBuffer ; loop through the page
rts ; all done
FmtStartWrite ldy <PhysHead ; get the desired head number
bne @start ; if not the first one, skip initialization
stz <BaseBufferNum ; reset buffer number for first head of new cylinder
ldy <PhysCylinder ; get the desired cylinder number
bne @start ; if not the first one, skip initialization
stz <DataBufPtr ; initialize low byte of buffer pointer
bcc @GCRgap ; if GCR mode, setup GCR gap sync buffer
; Create a buffer filled with MFM gap bytes so that DMA can be used to blast them out
@MFMgap lda MFMFmtFillValue ; get the data value to write
jsr FillDataBuffer ; fill the data buffer with the format pattern
lda MFMGapValue ; get the gap byte value
jsr FillTagBuffer ; fill the buffer with the gap value
lda #$FF ; MFM doesn't need tags, so don't fetch them next time
sta <CurTagBCPB ; see if optional tag buffer exists
bra @start ; go start the track format
; Create a buffer filled with GCR sync groups so that DMA can be used to blast them out
@GCRgap lda #0 ; zero's if encoding on the fly, 96 if raw data
bit <CurTagBCPB ; see if optional tag buffer exists
bpl @fillGCR ; if so, use zero's as the data buffer pattern
jsr FillTagBuffer ; initialize the tags to zero's if no buffer exists
lda GCRFmtFillValue ; get the data value to write
bit <CurDataBCPB ; see if optional data buffer exists
bpl @fillGCR ; if so, use encode the data on the fly, using write code
stz <WritingForFmt ; if no tag or data buffers, use DMA to blast the constant patterh
@fillGCR jsr FillDataBuffer ; fill the data buffer with the format pattern
ldx #>GCRGapBuffer ; point to the data buffer
stx <DataBufPtr+1 ; initialize high byte of buffer pointer
ldx #GCRInitialSyncCount; number of sync groups to put into buffer
@syncGroupLoop ldy #GCRGapSyncSize-1 ; loop count and index for each sync group
@syncCopyLoop lda GCRGapSync,y ; get a byte of sync
sta (<DataBufPtr),y ; copy it into the buffer
dey ; update the loop counter / index
bpl @syncCopyLoop ; copy all of the bytes in the sync group
lda <DataBufPtr ; get the low byte of the pointer
clc ; setup carry for addition
adc #GCRGapSyncSize ; point to next sync group in the buffer
sta <DataBufPtr ; update the low byte of the pointer
bcc @updateCount ; if no carry, upper byte is OK
inc <DataBufPtr+1 ; if carry, update page number
@updateCount dex ; update the sync group count
bne @syncGroupLoop ; loop through all of the sync groups
@start stz <DataBufPtr ; initialize low byte of buffer pointer
ldy <PhysHead ; get the desired head number
lda HeadSelectDecode,y ; get the head select command
jsr AdrAndSense ; select the disk head
lda rError ; read and clear any pending errors
lda #StartAction\
+WriteMode ; prepare to clear action and write mode
sta wZeroes ; clear action and write mode
lda #WriteMode ; prepare to enter write mode
sta wOnes ; change to write mode
lda #ClearFIFO ; prepare to clear the FIFO
sta wOnes ; toggle it to one
sta wZeroes ; and back to zero to clear it
lda rError ; read and clear errors again
lda #$FF ; garbage bytes to write initially
sta wData ; write it to the FIFO
sta wData ; write it to the FIFO
ldx #StartAction ; prepare to start writing
stx wOnes ; turn on Action to start shifting out the write data
jmp WriteByte ; fill the fifo with yet another byte and return
title 'IOP SWIM Driver - Format Track - GCR'
FmtGCRTrack lda <PhysCylinder ; get the current cylinder
tax ; save a copy
and #$3F ; mask to six bits
sta <SectHdrInfo\
+GCRCylinder ; setup low half of cylinder number
stz <SectHdrInfo\
+GCRSector ; start with sector zero
lda <PhysHead ; get the head number
sta <SeekingHead ; save head for ReadSectorHdr later
beq @HeadOK ; if zero use it
lda #$20 ; otherwise, set high bit of nibble
@HeadOK ora EncodeGCRHighC,x ; position and insert upper 2 bits of cylinder
sta <SectHdrInfo\
+GCRHeadCyl ; setup the side/upper cylinder bits
lda <FmtByteBlkSize ; get format byte
and #$20 ; get just the sides bit
ora <Interleave ; include interleave
sta <SectHdrInfo\
+GCRFmtKind ; setup the format kind
eor <SectHdrInfo\
+GCRCylinder ; compute checksum
eor <SectHdrInfo\
+GCRHeadCyl ; compute checksum
sta Sect0CkSum ; remember the checksum for sector zero
ldy #5-1 ; loop counter / index
@EncodeHdrLoop ldx <SectHdrInfo,y ; get a byte to encode
lda EncodeGCRnibble,x ; encode it
sta SectHdrInfo,y ; replace it
dey ; decrement counter / index
bne @EncodeHdrLoop ; encode all remaining bytes
clc ; indicate GCR format
jsr FmtStartWrite ; select the head and start writing
stz <PhysSector ; start sector index at zero
lda #>GCRGapBuffer ; point to gap sync data buffer
sta <DataBufPtr+1 ; initialize high byte of buffer pointer
ldx #<(GCRInitialSyncCount\
*GCRGapSyncSize) ; low byte of byte count
ldy #>(GCRInitialSyncCount\
*GCRGapSyncSize) ; high byte of byte count
lda #$FF ; garbage bytes to write initially
jsr WriteDataBuffer ; write out the data buffer
bne FmtGCRTrack ; if error due to DMA timeout, try re-formatting the track
@NextSector lda <SectorGapSize ; add the inter sector sync count
sta <LoopCountL ; setup Sync loop counter
@FmtSyncs ldx #GCRGapSyncSize ; number of bytes to write
ldy #GCRGapSync\
-SectorTemplates ; offset of gap sync template
jsr WriteTemplate ; write a gap sync group
dec <LoopCountL ; update the gap sync loop count
bne @FmtSyncs ; write all of the sync groups
ldy #GCRAddrMark\
-SectorTemplates ; offset of addr mark template
ldx #GCRAddrMarkSize ; number of bytes to write
jsr WriteTemplate ; write the address mark
ldx <PhysSector ; get sector index
lda <SectorMap,x ; get the sector number
sta <SectHdrSector ; save the sector number for buffer indexing
tay ; save for later
eor Sect0CkSum ; compute the new checksum
tax ; setup to encode
lda EncodeGCRnibble,x ; encode the checksum
sta <SectHdrInfo\
+GCRCkSum ; save computed checksum
lda EncodeGCRnibble,y ; encode the sector number
sta <SectHdrInfo\
+GCRSector ; save encoded sector number
jsr WriteHdrInfo ; write out the sector header info
ldy #GCRAddrSlipMark\
-SectorTemplates ; offset of addr slip mark template
ldx #GCRAddrSlipMarkSize+1 ; the end of the sector header, first byte of gap sync
jsr WriteTemplate ; write the end of the header, partial gap sync
bit <WritingForFmt ; see if we have optional data to write
bpl @FmtDefaultGCR ; if not, just write out the default data
* ldx #0 ; still zero from WriteTemplate above
ldy #1 ; point to next tag byte
jsr WriteGCRFmtData ; write out the remaining gap, and sector data
bra @sectorDataDone ; get back in sync with default format code
@FmtDefaultGCR ldx #GCRGapSyncSize-1+\ ; remainder of gap sync before the sector data
GCRDataMarkSize ; the beginning of the sector data
jsr WriteTemplate ; write the end of the header, gap, begining of data
lda <SectHdrInfo\
+GCRSector ; get the encoded sector number
@ByteCount set (TagSize\
+BlockSize+3) ; tag, data, and 3 byte checksum
@ByteCount set (@ByteCount*8+5)/6 ; number of bytes after encoding (rounded up)
ldx #<@ByteCount ; low byte of byte count
ldy #>@ByteCount ; high byte of byte count
jsr WriteDataBuffer ; write out the data buffer
bne @toFmtGCRTrack ; if error due to DMA timeout, try re-formatting the track
ldy #GCRDataSlipMark\
-SectorTemplates ; offset of addr slip mark template
ldx #GCRDataSlipMarkSize; the end of the sector data
jsr WriteTemplate ; write the end of the sector data
@sectorDataDone inc <PhysSector ; update the sector index
lda <PhysSector ; get the updated index
cpa <PhysSectsPerHead ; see if entire track formatted
blt @NextSector ; if not, go onto next sector (x=0)
lda GCRGapValue ; get the gap value
jsr WriteDataExit ; flush the fifo and shift register
bne @ErrExit ; exit if error detected
jsr ReadSectorHdr ; try to find sector 1
bcc @readOK ; if no error, go check the sector number
tay ; save error code
bne @DecSync ; if any error, try again with less sync
@readOK ldy #fmt1Err ; assume "can't find sector 0 after format"
lda <SectHdrSector ; see if sector zero found
bne @DecSync ; if not sect zero, try again with less sync
ldy #fmt2Err ; assume "can't get enough sync"
lda <AdrSearchCountL ; get low byte of count
clc ; setup for addition
adc #(GCRWriteToRead*5)\
/(16*6) ; account for dead time
sta <AdrSearchCountL ; update low byte of count
lda <AdrSearchCountH ; get high byte of count
adc #0 ; add in carry out
ldx #8-1 ; divide loop counter
asl <AdrSearchCountL ; setup for divide
@DivideLoop rol a ; shift high byte of numerator
cpa #5 ; compare to denominator
bcc @DivideShift ; if N < D, don't subtract, just shift
sbc #5 ; if N >= D, subtract denominator
@DivideShift rol <AdrSearchCountL ; shift in quotient bit
dex ; update loop counter
bpl @DivideLoop ; loop through all quotient bits
lda <AdrSearchCountL ; get final quotient
sec ; setup for subtraction
sbc <SectorGapSize ; subtract num of syncs we were using
cpa #-1 ; see if gap was too short
bmi @DecSync ; if too short, try again with less sync
ldy #noErr ; enough sync, format will succeed
lsr a ; divide excess bytes by 2
cpa <PhysSectsPerHead ; see if SectorGapSize cound inc by 2
blt @Exit ; exit if gap sync still reasonable
inc <SectorGapSize ; use more sync next time
@Exit tya ; return the error code
@ErrExit jmp FmtTrackDone ; all done
@DecSync dec <SectorGapSize ; use less sync next time
lda <SectorGapSize ; get sync size
cpa #GCRMinSyncCount ; see if still reasonable
blt @Exit ; if too small, return with error
@toFmtGCRTrack jmp FmtGCRTrack ; otherwise, try again with less sync
title 'IOP SWIM Driver - Format Track - MFM'
FmtMFMTrack lda <FmtByteBlkSize ; get format byte
and #$1F ; get just the block size
sta <SectHdrInfo\
+MFMBlkSize ; setup block size
lda MFMAddrMark+\
MFMAddrMarkSize-1 ; get final byte of address mark field
sta <SectHdrInfo\
+MFMLastAddrMark ; setup final byte of address mark field
lda <PhysCylinder ; get the current cylinder
sta <SectHdrInfo\
+MFMCylinder ; setup cylinder number
lda <PhysHead ; get the head number
sta <SectHdrInfo\
+MFMHead ; setup head number
bne @StartFormat ; if not side zero, start immediatly
; on side zero, sleep while the disk is rotating. We get here after the seek completes
; which is about 3 sector times, and we want to start writing about 2 sectors before
; index goes high, so we want to delay PhysSectsPerHead-5 sector times.
lda <PhysSectsPerHead ; total number of sectors
sec ; prepare carry for subtract
sbc #3+2 ; subtract off seek and pre-index gap times
tay ; setup multiply loop counter
ldx #0 ; initialize high byte of sleep time
lda #SectorDelay ; delay time for 1 sector
@RotateMultCLC clc ; initialize carry
@RotateMult dey ; decrement loop counter
beq @RotateWait ; loop for all remaining sectors
adc #SectorDelay ; add delay for next sector
bcc @RotateMult ; loop through remaining sectors
inx ; propagate carry into upper byte
bra @RotateMultCLC ; clear carry, loop through remaining sectors
@RotateWait jsr SleepLong ; wait for the disk to rotate
@StartFormat sec ; indicate MFM format
jsr FmtStartWrite ; select the head and start writing
ldx <PhysHead ; see which side we are on
bne @FindIndex ; if side zero, write 768 bytes before checking index
lda #>MFMGapBuffer ; point to gap data buffer
sta <DataBufPtr+1 ; initialize high byte of buffer pointer
ldx #$80 ; low byte of byte count
ldy #$01 ; high byte of byte count (1.5 pages, 384 bytes)
lda MFMGapValue ; get the gap byte value
jsr WriteDataBuffer ; write out the data buffer
bne @StartFormat ; if error due to DMA timeout, try re-formatting the track
lda #>MFMGapBuffer ; point to gap data buffer
sta <DataBufPtr+1 ; initialize high byte of buffer pointer
ldx #$80 ; low byte of byte count
ldy #$01 ; high byte of byte count (1.5 pages, 384 bytes)
lda MFMGapValue ; get the gap byte value
jsr WriteDataBuffer ; write out the data buffer
bne @StartFormat ; if error due to DMA timeout, try re-formatting the track
@FindIndex stz <LoopCountH ; setup index timeout high byte, low byte in x
ldy MFMGapValue ; get the gap byte value
lda #DriveRdData ; setup to test index pulse
sta <PhysSector ; indicate that low pulse not found yet
@FindIndexLoop inx ; update low byte of timeout
bne @FindIndexWait ; if no overflow, wait for a byte
inc <LoopCountH ; update index timeout high byte
bne @FindIndexWait ; if no overflow, wait for a byte
@IndexTimeout lda #noIndexErr ; index pulse not found during MFM format
ldy #StartAction\
+WriteMode ; prepare to clear action and write mode
sty wZeroes ; clear action and write mode (write done)
jmp FmtTrackDone ; return with the error
@FindIndexWait bit rHandshake ; see if there is room
assert Dat1Byte=$80
bpl @FindIndexWait ; wait for room
sty wData ; write out a gap byte
bne @IndexHigh ; index is high, check for low to high transition
stz <PhysSector ; indicate that index low has been seen
bra @FindIndexLoop ; go on to next byte
@IndexHigh bit <PhysSector ; see if index low has been seen
bne @FindIndexLoop ; if not, go on to next byte
; De-select RdData0/1 to de-select index pulse during format to prevent noise/crosstalk
; on the RdData line from interfering with WrData and causing a bad write. This is a
; workaround for a noisy external drive cable. Instead we select somthing that will be
; a constant high.
assert (rMFMDriveAdr+HeadSelect)=rMFMModeOnAdr
lda #rMFMDriveAdr\
++ph0123en ; select rMFMDriveAdr/rMFMModeOnAdr
sta wPhase ; change the phase lines, but not HeadSelect.
ldx #MFMInitialGapSize ; size of gap after physical index
lda MFMGapValue ; get the gap byte value
jsr WriteRepeated ; write out the gap field
ldx #MFMSyncSize ; number of sync bytes to write
lda MFMSyncValue ; get the sync value
jsr WriteRepeated ; write out the sync field bytes
ldx #MFMIndexMarkSize-1 ; number of MARK bytes to write
ldy #MFMIndexMark-SectorTemplates
assert (wData+1)=wMark
inc <SwimWriteReg ; point to wMark
jsr WriteTemplate ; write the index mark mark bytes
assert (wMark-1)=wData
dec <SwimWriteReg ; point back to wData
lda SectorTemplates,y ; get final byte
jsr WriteByte ; write it out
ldx #MFMIndexMarkGapSize; size of gap after index mark field
@NextSector lda MFMGapValue ; get the gap byte value
jsr WriteRepeated ; write out the gap field
ldx #MFMSyncSize ; number of sync bytes to write
lda MFMSyncValue ; get the sync value
jsr WriteRepeated ; write out the sync field bytes
ldx #MFMAddrMarkSize-1 ; number of MARK bytes to write
ldy #MFMAddrMark-SectorTemplates
assert (wData+1)=wMark
inc <SwimWriteReg ; point to wMark
jsr WriteTemplate ; write the addr mark mark bytes
assert (wMark-1)=wData
dec <SwimWriteReg ; point back to wData
ldx <PhysSector ; get sector index
lda <SectorMap,x ; get the zero based sector number
sta <SectHdrSector ; save the sector number for buffer indexing
ina ; MFM sector numbers are one based
sta <SectHdrInfo\
+MFMSector ; save header sector number
jsr WriteHdrInfo ; write out the sector header info
jsr WriteMFMCRC ; write out the sector header CRC
ldx #MFMAddrMarkGapSize ; number of gap bytes to write
lda MFMGapValue ; get the gap value to write
jsr WriteRepeated ; write out the gap field
; write out the sector data
ldx #MFMSyncSize ; number of sync bytes to write
lda MFMSyncValue ; get the sync value
jsr WriteRepeated ; write out the sync field bytes
ldx #MFMDataMarkSize-1 ; number of MARK bytes to write
ldy #MFMDataMark-SectorTemplates
assert (wData+1)=wMark
inc <SwimWriteReg ; point to wMark
jsr WriteTemplate ; write the data mark mark bytes
assert (wMark-1)=wData
dec <SwimWriteReg ; point back to wData
lda SectorTemplates,y ; get final byte
* ldx #<BlockSize ; low byte of byte count
ldy #>BlockSize ; high byte of byte count
jsr WriteDataBuffer ; write out the data buffer
bne @ToStartFormat ; if DMA timeout, re-write the track with ints disabled
jsr WriteMFMCRC ; write the 2 CRC bytes
ldx <SectorGapSize ; number of gap bytes to write
inc <PhysSector ; update the sector index
lda <PhysSector ; get the updated index
cpa <PhysSectsPerHead ; see if entire track formatted
blt @NextSector ; if not, go onto next sector
lda MFMGapValue ; get the gap value to write
ldy <PhysHead ; see if this is side zero
beq @TrackDone ; don't write gap after last sector on side zero
ldx #4 ; write 4 bytes to flush the FIFO and shift reg
jsr WriteRepeated ; write out the gap field
assert (rRdData0Adr+HeadSelect)=rRdData1Adr
ldx #rRdData0Adr\
++ph0123en ; select rRdData0Adr/rRdData1Adr
stx wPhase ; change the phase lines, but not HeadSelect.
ldx #>(-MFMFinalGapSize); get high byte of negated timeout
sta <LoopCountH ; initialize timeout high byte
ldx #<(-MFMFinalGapSize); get low byte of negated timeout
tay ; setup gap value
lda #DriveRdData ; setup to test index pulse
@PadTrack bit rHandshake ; see if we have room in the FIFO
assert Dat1Byte=$80
bpl @PadTrack ; wait until there is room for one byte
bne @PadTrackDone ; if index found, stop padding
sty wData ; write the byte
inx ; update timeout low byte
bne @PadTrack ; loop until index or timeout
inc <LoopCountH ; update timeout high byte
bne @PadTrack ; loop until index or timeout
jmp @IndexTimeout ; return timeout error, if index not found
@PadTrackDone tya ; setup gap value
@TrackDone jsr WriteDataExit ; flush the fifo and shift register
bne @Exit ; if error, exit now
* lda #0 ; initialize loop counter (already zero)
@HeadSwitchLoop dea ; allow a short delay before head switch
bne @HeadSwitchLoop ; loop 256 times for 1280 clocks, ≈650µsec
* lda #noErr ; indicate format succeeded (already zero)
@Exit jmp FmtTrackDone ; all done
@ToStartFormat jmp @StartFormat
endwith
endwith
endwith
endproc
seg 'WordConsts'
FmtTrackDecode proc
dc.w FmtUnknownTrack ; 0 - uncheckedFormat
dc.w FmtUnknownTrack ; 1 - unknownFormat
dc.w FmtUnknownTrack ; 2 - HD20Format
dc.w FmtGCRTrack ; 3 - GCR400Kformat
dc.w FmtGCRTrack ; 4 - GCR800Kformat
dc.w FmtMFMTrack ; 5 - MFM720Kformat
dc.w FmtMFMTrack ; 6 - MFM1440Kformat
dc.w FmtUnknownTrack ; 7 - GCRonHDformat
dc.w FmtUnknownTrack ; 8 - reserved for future use
dc.w FmtUnknownTrack ; 9 - reserved for future use
dc.w FmtUnknownTrack ; 10 - reserved for future use
endproc
title 'IOP SWIM Driver - Initialize SWIM chip'
;_______________________________________________________________________
;
; Routine: jsr InitSWIMChip
; Inputs: none
; Outputs: A - error status code
; n,z - based on value returned in A
; Destroys: A, X, Y, n, z, c
; Calls: LoadSWIMparams
; Called by: SWIMInitialize, ReCalibrate
;
; Function: Initializes the SWIM chip, and switches it into ISM mode.
; Returns an error indication if initialization failed.
;
;_______________________________________________________________________
seg 'code'
InitSWIMChip proc
; Initialize the SWIM chip, and force ISM mode
ldy #3 ; retry count
initSWIMloop dey ; decrement retry count
beq initSWIMerr ; if retry count exceeded
**??** lda mtrOff ; Disable the interface in case we're in IWM
lda #startAction\
+WriteMode ; and turn off ACTION/WRITE in case we're not
sta wZeroes
lda #ph0123en+ph0+ph2
sta wPhase
cpa rPhase ; see if we can write/read phase lines
bne inIWMmode ; couldn't, must be IWM mode
lda #ph0123en+ph1+ph2
sta wPhase
cpa rPhase ; see if we can write/read phase lines
bne inIWMmode ; couldn't, must be IWM mode
lda #ph0123en+ph0+ph1+ph2
sta wPhase
cpa rPhase ; see if we can write/read phase lines
bne inIWMmode ; couldn't, must be IWM mode
inISMmode lda #IWMtimerOverride\
+IWMtimer2X ; set timer kill and 16mhz timer
sta wIWMConfig ; for IWM timer
lda #Select35 ; clear all bits except 3.5 select (ADB out)
and rSetup ; read and clear the setup bits
**??** ora #IBMDrive ; write using pulses, not transitions
sta wSetup ; init the setup register
eor rSetup ; make sure it was written OK
beq LoadSWIMparams ; load some parameters, if compared OK
initSWIMerr lda #initIWMErr ; return error code
rts ; return
inIWMmode lda q6H ; set IWM to sense mode
lda #$1F ; mask for mode bits
and q7L ; sense the mode register
bit q6L ; and back to read mode
cpa #IWMmode ; see if correct mode is set
beq IWMmodeSet ; if correct
ldx #0 ; loop retry count
initIWMloop dex ; decrement count
beq initSWIMerr ; if timed out
lda mtrOff ; change the IWM mode now
lda q6H ; set IWM to sense state
lda #$3f ; mask for sense, mode bits
and q7L ; sense the mode register
bit #$20 ; test enables
bne initIWMloop ; if interface not disabled yet
cpa #IWMmode ; see if low bits match
beq IWMmodeSet ; if correct
lda #IWMmode ; try setting it again
sta q7H ; set to IWM mode
lda q7L ; set IWM back to sense state
bra initIWMloop ; try again
IWMmodeSet lda q6L ; change back to read mode
lda q7L ; select the mode register
lda mtrOff
lda q6H
lda #$40+IWMmode ; "magic sequence" bit 6 = 1, 0, 1, 1
sta q7H ; put the chip in ISM mode bit 6 = 1
eor #$40 ; clear bit 6
sta q7H ; put the chip in ISM mode bit 6 = 0
eor #$40 ; set bit 6
sta q7H ; put the chip in ISM mode bit 6 = 1
sta q7H ; put the chip in ISM mode bit 6 = 1
jmp initSWIMloop ; verify that it is now an ISM
endproc
title 'IOP SWIM Driver - Load SWIM parameters'
;_______________________________________________________________________
;
; Routine: jsr LoadSWIMparams
; Inputs: CurrentDrive - active drive number
; Outputs: A - error status code
; n,z - based on value returned in A
; Destroys: A, X, Y, n, z, c
; Cycles: 348 - if same param set as last call, first cylinder zone
; 613 - if new param set, first cylinder zone
; +15 cycles per additional cylinder zone searched
; Calls: none
; Called by: SetUpDrive, Seek, 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
;
;_______________________________________________________________________
seg 'code'
LoadSWIMparams proc
entry SWIMparamIndex
entry SWIMcylTable
entry SWIMparams
with SWIMVarsZ
with SWIMVars
lda #5 ; retry count
pha ; save retry count
ldx <CurrentDrive ; get the drive number
ldy DiskFormat,x ; get the disk format
lda SWIMparamIndex,y ; get the parameter table index
tay ; setup the table index
CylinderLoop lda SWIMcylTable,y ; get upper bound of this cylinder range
iny ; point to parameter index
iny ; point to next cylinder range
cpa CurrentCylinder,x ; compare to current cylinder
blt CylinderLoop ; loop until proper range found
ldx SWIMcylTable-1,y ; get parameter table index
cpx LastParamSet ; see if same as last time
stx LastParamSet ; mark current index as most recent
beq checkParams ; if a match, just compare first
ReLoadParams plx ; get retry count
dex ; count the retry
bmi LoadParamErr ; retries exhausted, return error
phx ; save the retry count
ldx LastParamSet ; get current index
lda #startAction\
+WriteMode ; need to write to wZeroes
sta wZeroes ; to reset parameter ram ptr
ldy #16 ; loop counter
loadParamLoop lda SWIMparams,x ; get the parameter value
sta wParams ; store it in the param ram
dex ; point to next param
dey ; decrement the loop count
bne loadParamLoop ; process next parameter
ldx LastParamSet ; get current index
checkParams lda #startAction\
+WriteMode ; need to write to wZeroes
sta wZeroes ; to reset parameter ram ptr
ldy #16 ; loop counter
checkParamLoop lda SWIMparams,x ; get the parameter value
eor rParams ; compare it
bne ReLoadParams ; if it didn't compare
dex ; point to next param
dey ; decrement the loop count
bne checkParamLoop ; process next parameter
lda #$FF-(TransSpaceDis*1+IBMDrive*1+EnableECM*1+GCRMode*1)
and rSetup ; get bits that don't change
ora SWIMparams,x ; insert bits that do change
sta wSetup ; setup the SWIM chip modes
eor rSetup ; compare it
bne ReLoadParams ; if it didn't compare
plx ; pop retry count
tax ; return noErr, and update flags
rts ; all done
LoadParamErr lda #initIWMErr ; return error code
rts ; return
endwith
endwith
endproc
title 'IOP SWIM Driver - SWIM parameters'
seg 'constants'
SWIMparamConsts proc ; SWIM chip parameter constants
entry SWIMcylTable
SWIMcylTable
GCRtable dc.b $ff,GCRparams1-SWIMparams+16
MFMtable dc.b $ff,MFMparams1-SWIMparams+16
dc.b $ff,MFMparams2-SWIMparams+16 ; unused, but just in case we need it
dc.b $ff,MFMparams1-SWIMparams+16 ; unused, but just in case we need it
SPAREtable dc.b $ff,SPAREparams-SWIMparams+16 ; unused, but just in case we need it
; table indexed by disk format kind
entry SWIMparamIndex
SWIMparamIndex dc.b GCRtable-SWIMcylTable ; 0 - uncheckedFormat (use GCR)
dc.b GCRtable-SWIMcylTable ; 1 - unknownFormat (use GCR)
dc.b GCRtable-SWIMcylTable ; 2 - HD20Format (use GCR)
dc.b GCRtable-SWIMcylTable ; 3 - GCR400Kformat
dc.b GCRtable-SWIMcylTable ; 4 - GCR800Kformat
dc.b MFMtable-SWIMcylTable ; 5 - MFM720Kformat
dc.b MFMtable-SWIMcylTable ; 6 - MFM1440Kformat
dc.b GCRtable-SWIMcylTable ; 7 - GCRonHDformat
dc.b SPAREtable-SWIMcylTable ; 8 - reserved for future use
dc.b SPAREtable-SWIMcylTable ; 9 - reserved for future use
dc.b SPAREtable-SWIMcylTable ; 10 - reserved for future use
entry SWIMparams
SWIMparams
; Parameter register values.
;
; The timing values Time1, Time0, xSx, xLx and Min have a resolution to
; the nearest half clock, so their actual register values are doubled so
; that bits 1-7 become the integer part and bit 0 becomes the ".5" part.
; xSx and xLx are reduced by 2 clocks, and Min is reduced by 3 clocks to
; take into account gate delays in the SWIM.
; For a 15.6672MHz input clock
; with 16.33usec byte times (400K, 800K GCR):
; Cell times 2.0424836, 4.0849672, 6.1274508 microseconds
; GCR params1 (more accuratly reflect IWM operation)
; peak shift = 0, pre-comp = 0.
GCRparams1 dc.b (TransSpaceDis*1+IBMDrive*0+EnableECM*0+GCRMode*1) ; Setup Reg
dc.b (32-2)*2+0 ; [F] Time1 = 32.0 (2.0424836 uSec)
dc.b (8*16)+8 ; [E] Early/Norm = 8 / 8
dc.b (32-2)*2+0 ; [D] Time0 = 32.0 (2.0424836 uSec)
dc.b (8*16)+8 ; [C] Late/Norm = 8 / 8
dc.b (32-2)*2+0 ; [B] LLS = 32.0
dc.b (32-2)*2+0 ; [A] LLL = 32.0
dc.b (32-2)*2+0 ; [9] LSS = 32.0
dc.b (32-2)*2+0 ; [8] LSL = 32.0
dc.b (32-2)*2+0 ; [7] CSLS = 32.0
dc.b (32-2)*2+0 ; [6] RPT = 32.0
dc.b (32-2)*2+0 ; [5] SLS = 32.0
dc.b (32-2)*2+0 ; [4] SLL = 32.0
dc.b (32-2)*2+0 ; [3] SSS = 32.0
dc.b (32-2)*2+0 ; [2] SSL = 32.0
dc.b 64 ; [1] Mult = 64
dc.b (16-3)*2+0 ; [0] Min = 16.0
; For a 15.6672MHz input clock
; with 16usec byte times (720K, 1440K MFM):
; Cell times 2.0105698, 2.9998978, 3.9892258 microseconds
; MFM params1
MFMparams1 dc.b (TransSpaceDis*0+IBMDrive*1+EnableECM*0+GCRMode*0) ; Setup Reg
dc.b (31-2)*2+1 ; [F] Time1 = 31.5 (2.0105698 uSec)
dc.b $57 ; [E] Early/Norm = $57
dc.b (15-2)*2+1 ; [D] Time0 = 15.5 (0.9893280 uSec)
dc.b $97 ; [C] Late/Norm = $97
dc.b (14-2)*2+1 ; [B] LLS = 14.5
dc.b (14-2)*2+1 ; [A] LLL = 14.5
dc.b (25-2)*2+1 ; [9] LSS = 25.5
dc.b (25-2)*2+1 ; [8] LSL = 25.5
dc.b (15-2)*2+1 ; [7] CSLS = 15.5
dc.b (15-2)*2+1 ; [6] RPT = 15.5
dc.b (14-2)*2+0 ; [5] SLS = 14.0
dc.b (14-2)*2+0 ; [4] SLL = 14.0
dc.b (25-2)*2+0 ; [3] SSS = 25.0
dc.b (25-2)*2+0 ; [2] SSL = 25.0
dc.b 65 ; [1] Mult = 65
dc.b (15-3)*2+0 ; [0] Min = 15.0
; For a 15.6672MHz input clock
; with 16usec byte times (720K, 1440K MFM):
; Cell times 2.0105698, 2.9998978, 3.9892258 microseconds
; MFM params2
MFMparams2 dc.b (TransSpaceDis*0+IBMDrive*1+EnableECM*0+GCRMode*0) ; Setup Reg
dc.b (31-2)*2+1 ; [F] Time1 = 31.5 (2.0105698 uSec)
dc.b $57 ; [E] Early/Norm = $57
dc.b (15-2)*2+1 ; [D] Time0 = 15.5 (0.9893280 uSec)
dc.b $97 ; [C] Late/Norm = $97
dc.b (14-2)*2+1 ; [B] LLS = 14.5
dc.b (14-2)*2+1 ; [A] LLL = 14.5
dc.b (25-2)*2+1 ; [9] LSS = 25.5
dc.b (25-2)*2+1 ; [8] LSL = 25.5
dc.b (15-2)*2+1 ; [7] CSLS = 15.5
dc.b (15-2)*2+1 ; [6] RPT = 15.5
dc.b (14-2)*2+0 ; [5] SLS = 14.0
dc.b (14-2)*2+0 ; [4] SLL = 14.0
dc.b (25-2)*2+0 ; [3] SSS = 25.0
dc.b (25-2)*2+0 ; [2] SSL = 25.0
dc.b 65 ; [1] Mult = 65
dc.b (15-3)*2+0 ; [0] Min = 15.0
; spare table entry, for possible future use
; SPARE params
SPAREparams dc.b (TransSpaceDis*1+IBMDrive*0+EnableECM*0+GCRMode*1) ; Setup Reg
dc.b (00-2)*2+0 ; [F] Time1 = 00.0 (0.0000000 uSec)
dc.b (0*16)+0 ; [E] Early/Norm = 0 / 0
dc.b (00-2)*2+0 ; [D] Time0 = 00.0 (0.0000000 uSec)
dc.b (0*16)+0 ; [C] Late/Norm = 0 / 0
dc.b (00-2)*2+0 ; [B] LLS = 00.0
dc.b (00-2)*2+0 ; [A] LLL = 00.0
dc.b (00-2)*2+0 ; [9] LSS = 00.0
dc.b (00-2)*2+0 ; [8] LSL = 00.0
dc.b (00-2)*2+0 ; [7] CSLS = 00.0
dc.b (00-2)*2+0 ; [6] RPT = 00.0
dc.b (00-2)*2+0 ; [5] SLS = 00.0
dc.b (00-2)*2+0 ; [4] SLL = 00.0
dc.b (00-2)*2+0 ; [3] SSS = 00.0
dc.b (00-2)*2+0 ; [2] SSL = 00.0
dc.b 00 ; [1] Mult = 00
dc.b (00-3)*2+0 ; [0] Min = 00.0
; For a 15.6672MHz input clock
; with 16.33usec byte times (400K, 800K GCR):
; Cell times 2.0424836, 4.0849672, 6.1274508 microseconds
; GCR params2 (computed using formula, with 100ns Peak Shift, 125ns PreComp)
GCRparams2 dc.b (TransSpaceDis*1+IBMDrive*0+EnableECM*0+GCRMode*1) ; Setup Reg
dc.b (32-2)*2+0 ; [F] Time1 = 32.0 (2.0424836 uSec)
dc.b (6*16)+8 ; [E] Early/Norm = 6 / 8
dc.b (32-2)*2+0 ; [D] Time0 = 32.0 (2.0424836 uSec)
dc.b (10*16)+8 ; [C] Late/Norm = 10 / 8
dc.b (30-2)*2+1 ; [B] LLS = 30.5
dc.b (31-2)*2+0 ; [A] LLL = 31.0
dc.b (32-2)*2+0 ; [9] LSS = 32.0
dc.b (33-2)*2+1 ; [8] LSL = 33.5
dc.b (30-2)*2+0 ; [7] CSLS = 30.0
dc.b (24-2)*2+0 ; [6] RPT = 24.0
dc.b (31-2)*2+0 ; [5] SLS = 31.0
dc.b (30-2)*2+1 ; [4] SLL = 30.5
dc.b (30-2)*2+1 ; [3] SSS = 30.5
dc.b (32-2)*2+0 ; [2] SSL = 32.0
dc.b 64 ; [1] Mult = 64
dc.b (16-3)*2+0 ; [0] Min = 16.0
endproc
title 'IOP SWIM Driver - Address and Sense / Sense'
;_______________________________________________________________________
;
; Routine: jsr AdrAndSense
; Inputs: A - drive address [0,0, HeadSelect, 0,0, ca2,ca1,ca0]
; Outputs: z - 1 (BEQ) if DriveRdData line was zero
; z - 0 (BNE) if DriveRdData line was one
; Destroys: A, Y, n, v
; Cycles: 35 / 37
; Calls: none
; Called by: PollingTask, SWIMEject, SWIMGetRawData, CheckStaticAttr,
; CheckDriveMode, TurnOnDrive, WaitDriveReady, ReCalibrate, Seek
;
; Function: Sets up the disk register address for the currently enabled
; disk and reads the DriveRdData line for that register.
;
;_______________________________________________________________________
;_______________________________________________________________________
;
; Routine: jsr Sense
; Inputs: none
; Outputs: z - 1 (BEQ) if DriveRdData line was zero
; z - 0 (BNE) if DriveRdData line was one
; Destroys: A, n, v
; Cycles: 12
; Calls: none
; Called by: SWIMGetRawData, Seek
;
; Function: Reads the DriveRdData line for the last addressed register.
;
;_______________________________________________________________________
seg 'code'
AdrAndSense proc
ldy #ph0123en+ca1+ca0 ; set ca1 and ca0 high
sty wPhase ; before changing HeadSelect
ldy #HeadSelect ; prepare to change HeadSelect
bit #HeadSelect ; test new head select value
beq ResetHeadSelect ; if new value is zero
sty wOnes ; otherwise set head select
bra HeadSelectDone ; join common code
ResetHeadSelect sty wZeroes ; reset head select
HeadSelectDone ora #ph0123en ; set the phase line enables
sta wPhase ; write the phase lines
entry Sense
Sense lda #DriveRdData ; prepare to test bit
and rHandshake ; test the DriveRdData bit
rts ; all done
endproc
title 'IOP SWIM Driver - Address and Strobe / Pulse'
;_______________________________________________________________________
;
; Routine: jsr AdrAndStrb
; Inputs: A - drive address [0,0, HeadSelect, 0,0, ca2,ca1,ca0]
; Outputs: none
; Destroys: A, Y, n, z
; Cycles: 41 / 43
; Calls: none
; Called by: PollingTask, SWIMEject, TurnOnDrive, TurnOffDrive,
; ReCalibrate, Seek
;
; 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.
;
;_______________________________________________________________________
;_______________________________________________________________________
;
; Routine: jsr Pulse
; Inputs: none
; Outputs: none
; Destroys: A, n, z
; Cycles: 25
; Calls: none
; Called by: Seek
;
; Function: pulses the ph3 line, causing the data from ca2 to
; be written to the last addressed register.
;
;_______________________________________________________________________
seg 'code'
AdrAndStrb proc
ldy #ph0123en+ca1+ca0 ; set ca1 and ca0 high
sty wPhase ; before changing HeadSelect
ldy #HeadSelect ; prepare to change HeadSelect
bit #HeadSelect ; test new head select value
beq ResetHeadSelect ; if new value is zero
sty wOnes ; otherwise set head select
bra HeadSelectDone ; join common code
ResetHeadSelect sty wZeroes ; reset head select
HeadSelectDone ora #ph0123en ; set the phase line enables
sta wPhase ; write the phase lines
doPulse ora #ph0123en+ph3 ; prepare to set ph3 bit
sta wPhase ; turn ph3 on
eor #ph3 ; prepare to reset ph3 bit
sta wPhase ; turn ph3 off
rts ; all done
entry Pulse
Pulse lda rPhase ; get the old phase lines
bra doPulse ; finish the pulse
endproc
title 'IOP SWIM Driver - Disk Select'
;_______________________________________________________________________
;
; Routine: jsr DiskSelect
; Inputs: X - Drive Number
; Outputs: z - 1 (BEQ) if illegal drive number
; z - 0 (BNE) if legal drive number
; Destroys: A, Y, n, v, c
; Cycles: 22 clocks for internal drive
; 36 or 71 clocks for unknown drive
; 45 clocks if PassThru doesn't work
; 54 clocks + 37 clocks per HD20 for external SONY drive
; 76 clocks + 37 clocks per prior HD20 for HD20 drives
; Calls: none
; Called by: SWIMInitialize, PollingTask, SWIMEject, TurnOnDrive
;
; Function: Asserts the ENABLE line for the specified drive.
;
;_______________________________________________________________________
seg 'code'
DiskSelect proc
with SWIMVars
cpx #intDriveNumber ; check for internal drive
bne chkExternal ; if not internal drive
lda #Drive2Enabled ; prepare to disable the ext drive
sta wZeroes ; disable external drive
lda #Drive1Enabled\
+MotorOn ; prepare to enable int drive
sta wOnes ; enable the internal drive
rts ; all done
chkExternal lda #ph0123en\
++rNoDriveAdr ; address the drive exists reg
sta wPhase ; write the phase lines
lda #HeadSelect ; prepare to reset head select
sta wZeroes ; HeadSelect is 0 for rNoDriveAdr
lda PassThruBroken ; see if pass-thru connector works
beq usePassThru ; if you've got it, use it
; if PassThru is not working, then external drive port can only have a single HD20
; connected to it.
cpx #FirstHD20DriveNumber ; check for 1st HD20
bne unknownDrive ; if not 1st HD20, give up
lda #Drive1Enabled ; prepare to disable the int drive
sta wZeroes ; disable internal drive
lda #Drive2Enabled\
+MotorOn ; prepare to enable ext drive
sta wOnes ; enable the external drive
rts ; all done
usePassThru lda #Drive1Enabled ; prepare to disable the int drive
sta wZeroes ; disable internal drive
lda #Drive2Enabled\
+MotorOn ; prepare to enable ext drive
sta wOnes ; enable the external drive
cpx #extDriveNumber ; check for external drive
bne chkHD20 ; if not external, check for HD20s
ldy #maxHD20Cnt ; Try all HD20s + 1 ext SONY drive
bra searchExtDrive ; start looking for it
; the following sequence will cause the next drive on the chain to be enabled
searchLoop lda #ph0123en++rNoDriveAdr++ph3
sta wPhase ; pulse phase 3 high
eor #ph3 ; and then
sta wPhase ; low again
eor #ph1 ; reset phase 1
sta wPhase ; pulse phase 1 low
eor #ph1 ; and then
sta wPhase ; high again
searchExtDrive lda #DriveRdData ; prepare to test sense line
bit rHandShake ; test the sense line (rNoDrive)
beq loopExit ; exit when SONY drive found
dey ; decrement the loop counter
bpl searchLoop ; try next drive on the chain
loopExit tay ; return z <- false
rts ; all done
chkHD20 lda #MotorOn ; prepare to pulse the drive enable
sta wZeroes ; disable the drive
sta wOnes ; enable the drive
txa ; get drive number
sec ; set carry for subtract
sbc #FirstHD20DriveNumber ; make drive number 0 based
tay ; load search counter
bge searchExtDrive ; start searching for it
unknownDrive lda #0 ; return z <- true
rts ; all done
endwith
endproc
title 'IOP SWIM Driver - Find Drive Kind'
;_______________________________________________________________________
;
; Routine: jsr FindDriveKind
; Inputs: none
; Outputs: A - Disk Drive Kind
; Destroys: X, Y, n, z, c
; Cycles: 116
; Calls: none
; Called by: SWIMInitialize
;
; 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 NoDrive
;
; Revised 1 1 1 1 0 1 1 x 1
; /DrvIn 0 1 1 1 0 0 1 0 1
; /SingleSide 0 1 1 0 0 1 1 1 1
; SuperDrive 0 1 0 1 0 0 0 1 1
;_______________________________________________________________________
seg 'code'
FindDriveKind proc
entry DriveKindXlate
ldy #ph0123en\
+ca2+ca1+ca0 ; prepare to test REVISED status
sty wPhase ; set the phase lines
ldx #HeadSelect ; prepare to set HeadSelect
stx wOnes ; Set HeadSelect
lda rHandshake ; prepare to test bit
stx wZeroes ; Clear HeadSelect
ldx #%00010000 ; init drive kind index / loop counter
bra start
loop sty wPhase ; set the phase lines
dey ; decrement ca2..ca0 phase values
lda rHandshake ; prepare to test bit
start and #DriveRdData ; isolate the DriveRdData bit
cpa #DriveRdData ; Carry := DriveRdData bit
txa ; get result
rol a ; shift next bit into result
tax ; restore result
bcc loop ; loop until last bit shifted in
lda DriveKindXlate,x ; translate statuses to drive kind
rts ; all done
endproc
seg 'constants'
DriveKindXlate proc
dc.b SSGCRDriveKind ; 0 0 0 0 - 400K GCR drive
dc.b unknownDriveKind ; 0 0 0 1 - unknown
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
endproc
end
Reference in New Issue View Git Blame Copy Permalink