7719 lines
303 KiB
Plaintext
7719 lines
303 KiB
Plaintext
;
|
|
; 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
|
|
|