00000000 =00000000 23 diskUnitPtr equ 0 ; pointer to device control entry 00000000 =00000004 24 diskQVE equ diskUnitPtr+4 ; disk VBL task control block 00000000 =00000012 25 drive equ diskQVE+14 ; 0001 = int drive, 0002 = ext drive 00000000 =00000014 26 wait equ drive+2 ; extra wait time for speed changes 00000000 =00000016 27 sideTrack equ wait+2 ; destination side/track 00000000 =00000018 28 oneToOne equ sideTrack+2 ; open up rupts flg (no longer used) 00000000 =00000019 29 active equ oneToOne+1 ; non-zero when driver is active 00000000 =0000001A 30 timeOut equ active+1 ; power time out 00000000 31 00000000 =0000001C 32 diskBuffer equ timeOut+2 ; pointer to track data buffer 00000000 =00000020 33 firstSect equ diskBuffer+4 ; low sector number needed on a track 00000000 =00000022 34 sectMap equ firstSect+2 ; bit map of sectors needed on a track 00000000 =00000026 35 firstFSeq equ sectMap+4 ; first file seq # for current r/w request 00000000 =00000028 36 fBlksDone equ firstFSeq+2 ; file blocks done previous to this track 00000000 37 00000000 =0000002A 38 readErrInit equ fBlksDone+2 ; init value, read error countdown cntr 00000000 =0000002B 39 readErrCnt equ readErrInit+1 ; read error countdown cntr 00000000 =0000002C 40 recalInit equ readErrCnt+1 ; init value, recal count 00000000 =0000002D 41 recalCnt equ recalInit+1 ; recal count 00000000 =0000002E 42 wrgSectInit equ recalCnt+1 ; init value, wrong sector countdown cnt 00000000 =0000002F 43 wrgSectCnt equ wrgSectInit+1 ; wrong sector countdown cnt 00000000 =00000030 44 badSpdInit equ wrgSectCnt+1 ; init value, bad speed 00000000 =00000031 45 badSpdCnt equ badSpdInit+1 ; bad speed countdown value 00000000 46 00000000 =00000032 47 command equ badSpdCnt+1 ; I/O command 00000000 48 00000000 =00000034 49 headSettle equ command+2 ; disk head settle time (@100usec) 00000000 =00000036 50 spdChgTime equ headSettle+2 ; motor speed change time (@100usec) 00000000 =00000038 51 pwrOnTime equ spdChgTime+2 ; * power-on wait time (@100usec) 00000000 =0000003A 52 pwrOffTime equ pwrOnTime+2 ; * power down time (@1/2sec) 00000000 =0000003C 53 seekTime equ pwrOffTime+2 ; seek wait time (@100usec) 00000000 =0000003E 54 sectTime equ seekTime+2 ; * sector time (@100usec) 00000000 =00000040 55 dskVBLTime equ sectTime+2 ; VBL task time (@16ms) 00000000 =00000042 56 ejectTime equ dskVBLTime+2 ; Eject time (@100usec) 00000000 =00000044 57 ckDelta equ ejectTime+2 ; delta time before speed recheck 00000000 =00000048 58 ejectWait equ ckDelta+4 ; VBL times after eject to ignore DIP 00000000 59 00000000 60 ; Format/Verify code reuses some of these fields as follows: 00000000 61 00000000 =00000022 62 gapSync equ sectMap ; (2) start with 7 groups of intersector sync 00000000 =00000032 63 twoSided equ command ; (1) set non-zero for 2-sided format 00000000 =00000020 64 sectSave equ firstSect ; (2) SectMpSave must follow 00000000 =00000022 65 sectMapSave equ sectMap ; (8) uses SectMap, FirstFSeq, FBlksDone 00000000 =00000020 66 sectCnt equ firstSect ; (2) loop counter . . . 00000000 67 00000000 68 ;_______________________________________; 00000000 69 ; 00000000 70 ; (2) Drive-specific vars. 00000000 71 00000000 =00000042 72 drvLclLth equ 66 00000000 =0000004A 73 drive1 equ ejectWait+2 ; * internal drive variables 00000000 =0000008C 74 drive2 equ drive1+drvLclLth ; * external drive variables 00000000 75 00000000 =00000000 76 track equ 0 ; current track location (used for spd) 00000000 =00000002 77 writeProt equ 2 ; * bit7=1=write-protected 00000000 =00000003 78 diskInPlace equ 3 ; * $FC-$FF= just ejected, 00000000 79 ; ; 0=no disk in place,1=DIP,2=clamped 00000000 =00000004 80 installed equ 4 ; * 0=don't know, 1=inst., $FF=not inst. 00000000 =00000005 81 sides equ 5 ; * bit7=0=1 sided 00000000 =00000006 82 dqel equ 6 ; drive queue element for this drive 00000000 =00000006 83 driveQLink equ 6 00000000 =0000000A 84 driveQVers equ 10 00000000 =00000012 85 driveSize equ 18 ; drive block size (DCD only!) 00000000 =00000012 86 twoSideFmt equ 18 ; * non-zero if 2-sided format 00000000 =00000013 87 newIntf equ 19 ; $FF if new interface, $00 for old 00000000 =00000014 88 driveErrs equ 20 ; drive soft errs 00000000 89 00000000 =00000014 90 driveS1 equ 20 ; drive block size (high word) 00000000 =00000016 91 driveType equ 22 ; old OffSpeed (no longer supported) 00000000 =00000018 92 driveManf equ 24 00000000 =0000001A 93 driveChar equ 26 00000000 =0000001B 94 driveMisc equ 27 00000000 95 00000000 =00000018 96 spdAdjCnt equ 24 ; speed adjust count this drive 00000000 =0000001A 97 trkSpeedTbl equ 26 ; 5-entry track speed table 00000000 98 00000000 =00000000 99 tSTblCode equ 0 ; first is speed code 00000000 =00000002 100 tSTblDelta equ 2 ; 2% speed code delta 00000000 =00000004 101 tSTblTicks equ 4 ; longword last time checked tick cnt 00000000 =00000042 102 trkSTEnd equ 66 ; end of drive vars 00000000 103 00000000 104 ;_______________________________________; 00000000 105 ; 00000000 106 ; (3) More driver local vars. 00000000 107 00000000 =000000CE 108 wakeTimeCnt equ drive2+drvLclLth ; WakeUp remainder count 00000000 =000000D0 109 saveRegs equ wakeTimeCnt+2 ; * wakeup routine saves D3-D7,A3-A6 here 00000000 110 00000000 =000000F4 111 tagBufPtr equ saveRegs+36 ; if non-zero, pointer to separate 00000000 112 ; ; buffer for file tags . . . 00000000 =000000F8 113 tagBufOS equ tagBufPtr+4 ; temp offset into buffer 00000000 =000000FA 114 diskErrs equ tagBufOS+2 ; global soft errors 00000000 =000000FC 115 passThru equ diskErrs+2 ; 0 if pass thru on external port 00000000 =000000FD 116 sonyExtra equ passThru+1 ; extra byte 00000000 =000000FE 117 curSector equ sonyExtra+1 ; current sector being read/written 00000000 118 00000000 =00000100 119 tcRdEnable equ curSector+2 ; (byte) set non-zero to activate reads into cache 00000000 =00000101 120 tcInstalled equ tcRdEnable+1 ; (byte) non-zero when caching is installed and on 00000000 =00000102 121 tcDrive equ tcInstalled+1 ; (word) drive number of cache blks (zero to inval) 00000000 =00000104 122 tcSideTrack equ tcDrive+2 ; (word) side/track of cache blocks 00000000 =00000106 123 tcSectMap equ tcSideTrack+2 ; (long) bitmap of sectors currently cached 00000000 =0000010A 124 tcBuffer equ tcSectMap+4 ; (long) pointer to track cache buffer (512+12)*12 00000000 =0000010E 125 tcNumCached equ tcBuffer+4 ; (word) number read into cache 00000000 =00000110 126 tcNumUsed equ tcNumCached+2 ; (word actual number used 00000000 127 00000000 =00000112 128 lastDrive equ tcNumUsed+2 ; (word) set at CkDrvNum to previous value of Drive 00000000 =00000116 129 timeOutDrive equ lastDrive+4 ; (word) set at PowerDown to value of Drive 00000000 130 ; ; Above value should have been +2 since lastDrive is a word. 00000000 =00000118 131 timeQEl equ timeOutDrive+2 ; a time queue element 00000000 =00000124 132 nextGZProc equ timeQEl+$C ; (long) saved old GZ proc 00000000 133 ; ; Above had been +tmQSize, but that changed from $C to $E. 00000000 =00000128 134 sonyVarEnd equ nextGZProc+4 ; end of sony vars excluding DCD 00000000 135 00000000 136 00000000 137 ;_______________________________________; 00000000 138 ; 00000000 139 ; (4) Direct-connect driver locals. 00000000 140 00000000 =00000014 141 TagSize equ 20 ; 20 bytes tags/block 00000000 142 00000000 =0000001C 143 dcdLclLth equ 28 ; (use fields through DriveMisc) 00000000 =00000128 144 drive3 equ sonyVarEnd ; first DCD 00000000 =00000144 145 drive4 equ drive3+dcdLclLth ; second DCD 00000000 =00000160 146 drive5 equ drive4+dcdLclLth ; third DCD 00000000 =0000017C 147 drive6 equ drive5+dcdLclLth ; fourth DCD 00000000 148 00000000 =00000198 149 stsRtnAddr equ drive6+dcdLclLth ; DCD status call return address 00000000 150 00000000 =0000019C 151 dcdCmd equ stsRtnAddr+4 ; command byte to DCD 00000000 =0000019C 152 response equ dcdCmd ; response byte (command+$80) 00000000 =0000019D 153 seqNum equ response+1 ; mb sequence number (sys commands only) 00000000 =0000019E 154 status equ seqNum+1 ; returned status bytes 00000000 =0000019E 155 startBlock equ status ; starting block # (in commands) 00000000 =000001A1 156 driveOut equ startBlock+3 ; we send drive number in this field 00000000 =000001A0 157 driveIn equ status+2 ; low 6 bits 00000000 =000001A2 158 tagBytes equ status+4 ; tag bytes get stuffed here temporarily 00000000 =000001A2 159 devType equ tagBytes ; first 20 bytes of status are written 00000000 =000001A4 160 devManufctr equ devType+2 ; in the 20-byte tag buffer 00000000 =000001A6 161 devChar equ devManufctr+2 00000000 =000001A6 162 devBlks equ devChar ; low 3 bytes of this longword 00000000 =000001AA 163 devSpares equ devChar+4 00000000 =000001AC 164 devBadBlks equ devSpares+2 00000000 =000001AE 165 devMisc equ devBadBlks+2 ; 8 bytes misc 00000000 =000001B6 166 bufSize equ tagBytes+tagSize ; number of bytes/block 00000000 =000001BA 167 lastStatus equ bufSize+4 ; last status returned 00000000 =000001BE 168 lastResult equ lastStatus+4 ; error type 00000000 =000001BF 169 dcdFlags equ lastResult+1 ; flag of whether we've done a reset 00000000 =000001C0 170 chkTime equ dcdFlags+1 ; 100usec check ready count 00000000 =000001C2 171 maxTime equ chkTime+2 ; maximum number of checks 00000000 =000001C4 172 stsBuffer equ maxTime+2 ; 512 bytes of status 00000000 =000001C4 173 devReserve equ stsBuffer 00000000 =000001F0 174 devIcon equ devReserve+44 00000000 =000002F0 175 devFiller equ devIcon+256 ; 32 bytes for optional name 00000000 176 00000000 =00000310 177 diskVarLth equ devFiller+32 00000000 178 00000000 =0000014C 179 stsBufSize equ diskVarLth-stsBuffer 00000000 180 00000000 181 00000000 182 ; device characteristics byte: 00000000 183 00000000 =00000004 184 devChEject equ 4 ; ejectable if 1 00000000 =00000003 185 devChWP equ 3 ; write protected if 1 00000000 =00000002 186 devChIcon equ 2 ; icon available if 1 00000000 187 00000000 188 00000000 189 ;_______________________________________; 00000000 190 ; ; 00000000 191 ; Drive Constants: ; 00000000 192 ;_______________________________________; 00000000 193 00000000 194 00000000 =FFFFFFFF 195 dqSides equ -1 ; Bit 7 of this byte: 0=single-sided Sony, 1=double sided 00000000 =FFFFFFFE 196 dqInstall equ -2 ; 0=unknown, 1=installed, FF=no disk 00000000 =FFFFFFFD 197 dqDIP equ -3 ; $FC-$FF = disk just ejected, 00000000 198 ; 0 = no disk in place 00000000 199 ; 1 = disk in place 00000000 200 ; 2 = disk has been read 00000000 201 ; >8 = non-ejectable disk 00000000 =FFFFFFFC 202 dqWrPrt equ -4 ; Bit 7 of this byte: 1=disk is write protected. 00000000 203 00000000 204 ;_______________________________________; 00000000 205 ; 00000000 206 ; (1) Floppy drive constants (tuneable). 00000000 207 00000000 =00000078 208 kSeekTime equ 120 ; 12 ms trk-to-trk 00000000 =0000012C 209 kHdSetTime equ 300 ; 30 ms head settle time 00000000 =00001D4C 210 kEjectTime equ 7500 ; .75 seconds eject time 00000000 =FFFFFFFC 211 kEjectWait equ -4 ; - number of VBL calls after eject before dip check 00000000 =00000064 212 kSectTime equ 100 ; minimum sector time in 100 us increments (10 ms) 00000000 =00000FA0 213 kPowerOn equ 4000 ; read/write powerup time in 100 us increments 00000000 =00000005 214 kRWPOff equ 5 ; read/write power off time (in 1/2 seconds) 00000000 =0000001E 215 kDskVBLTime equ 30 ; happens every 1/2 second 00000000 =000005DC 216 kSpdChgTime equ 1500 ; speed change wait time = 150ms 00000000 =00003840 217 kCkDelta equ 14400 ; speed check delta time (in 1/60 sec) (4 min) 00000000 218 00000000 219 ;_______________________________________; 00000000 220 ; 00000000 221 ; (2) Floppy drive sense/control constants. 00000000 222 ; (ca1-ca0-sel-ca2). 00000000 223 00000000 =00000000 224 dirLAdr equ 0 ; dirtn low 00000000 =00000001 225 dirHAdr equ 1 00000000 =00000001 226 rdDtaAdr equ 1 ; side 0 read data 00000000 =00000003 227 rdDta1Adr equ 3 ; side 1 read data 00000000 =00000004 228 stepLAdr equ 4 ; step low and step sense address 00000000 =00000005 229 stepHAdr equ 5 00000000 =00000008 230 mtrOnAdr equ 8 00000000 =00000009 231 mtrOffAdr equ 9 00000000 =0000000C 232 ejectLAdr equ 12 00000000 =0000000D 233 ejectHAdr equ 13 00000000 234 00000000 =00000002 235 dipAdr equ 2 ; disk in place sense address 00000000 =00000006 236 wrProtAdr equ 6 ; write protect sense address 00000000 =00000009 237 sidesAdr equ 9 ; sense for number of sides 00000000 =0000000A 238 tk0Adr equ 10 ; track 0 sense address 00000000 =0000000B 239 readyAdr equ 11 ; /Ready sense address 00000000 =0000000D 240 drvExstAdr equ 13 ; sense=0 when a drive is connected 00000000 =0000000E 241 tachAdr equ 14 ; tach feedback sense address 00000000 =0000000F 242 newIntfAdr equ 15 ; implements ready handshake if 1 00000000 243 00000000 244 ;_______________________________________; 00000000 245 ; 00000000 246 ; (3) Floppy drive formatting constants. 00000000 247 00000000 =00000002 248 fmtByte equ $02 ; 2-1 interleave, single-sided 00000000 =00000022 249 fmt2Byte equ $22 ; 2-1 interleave, double-sided 00000000 250 00000000 =000005DC 251 mustFindCt equ 1500 00000000 =00000004 252 minSync equ 4 ; min number of inter-sector sync groups 00000000 253 00000000 254 00000000 255 ;_______________________________________; 00000000 256 ; 00000000 257 ; (4) Direct-connect drive constants. 00000000 258 00000000 259 ;This variable has been renamed SONYRetry and placed in Privates 00000000 260 ;RetryCount equ 5 ; Number of HardReset/retries allowed 00000000 261 00000000 =00000200 262 blkSize equ 512 ; 512 bytes data/block 00000000 =000000AA 263 syncByte equ $AA ; Sync byte for start of transmission 00000000 264 00000000 =00000000 265 noError equ 0 ; resultTypes 00000000 =00000001 266 nonZerStat equ 1 00000000 =00000002 267 comErr equ 2 00000000 268 00000000 269 ; New HD20 error codes 00000000 270 00000000 =00000010 271 wrtHsLw equ $10 ; HSHK low before starting 00000000 =00000011 272 wrtHSLwTO equ $11 ; Time out waiting for HSHK to go low 00000000 =00000013 273 wrtHSHighTO equ $13 ; Time out waiting for HSHK to go high 00000000 =00000020 274 rdHsHi equ $20 ; HSHK high before starting 00000000 =00000021 275 rdSyncTO equ $21 ; Time out waiting for sync ($AA) bye 00000000 =00000022 276 rdGroupTO equ $22 ; Time out waiting for group 00000000 =00000024 277 rdHoffSyncTO equ $24 ; Time out waiting for sync after holdoff 00000000 =00000025 278 rdHsHiTO equ $25 ; Time out waiting for HSHK high 00000000 =00000026 279 rdChksumErr equ $26 ; Checksum error on response packet 00000000 =00000030 280 invalidResp equ $30 ; First byte in response packet was wrong 00000000 =00000031 281 sqncNumErr equ $31 ; Sequence number in response packet was wrong 00000000 =00000032 282 dNumberErr equ $32 ; Drive number in response packet was wrong 00000000 =00000040 283 noResp equ $40 ; No response packet ever received 00000000 284 00000000 285 ; LastStatus 00000000 286 00000000 =00000018 287 opFailed equ 24 ; bit to test for operation failed 00000000 =0000001E 288 bChksum equ 30 ; bit number for checksum error 00000000 289 ; DCDFlags 00000000 290 00000000 =00000000 291 resetonce equ 0 00000000 =00000001 292 retryonce equ 1 00000000 293 00000000 =00000004 294 maxTries equ 4 ; max # times to try command 00000000 =0000000A 295 tSeekChk equ 10 ; check during a seek every 1 ms 00000000 =00002710 296 tSeekMax equ 10000 ; max time for seek = 10 secs 00000000 =0000000A 297 tStsChk equ 10 ; check during a status every 1 ms 00000000 =00002710 298 tStsMax equ 10000 ; max time for status = 10 secs 00000000 =00000064 299 tQuickTime equ 100 00000000 =00000007 300 tNextChk equ 7 ; check for next block after 700 sec 00000000 =00002710 301 tNextMax equ 10000 ; max time for next block = 7 secs 00000000 =00000064 302 tFVChk equ 100 ; check during fmt/vfy every 10 ms 00000000 =00004650 303 tFVMax equ 18000 ; max time for fmt/vfy = 3 minutes 00000000 =000003E8 304 tRstAssert equ 1000 ; assert reset for 100 msec 00000000 =00004E20 305 tRstSettle equ 20000 ; 2 sec wait for busy to settle 00000000 =00000064 306 tRstChk equ 100 ; check during reset every 10 ms 00000000 =00000640 307 tRstMax equ 1600 ; max time for reset = 16 seconds 00000000 308 00000000 309 ; DCD sense/cntl addr (ca1-ca0-sel-ca2) 00000000 310 00000000 =00000005 311 dcdExist equ 5 ; /Exist (/Sides=/DrvIn=1 also) 00000000 =00000001 312 dcdReset equ 1 ; for 1ms resets DCD controller 00000000 313 00000000 314 00000000 315 ;_______________________________________; 00000000 316 ; ; 00000000 317 ; Driver Constants: ; 00000000 318 ;_______________________________________; 00000000 319 00000000 320 ;_______________________________________; 00000000 321 ; 00000000 322 ; (1) Driver Control codes. 00000000 323 00000000 =00000005 324 verifyCC equ 5 ; 'verify' control code 00000000 =00000006 325 formatCC equ 6 ; 'format' control code 00000000 =00000008 326 tagBufCC equ 8 ; 'set tag buffer' control code 00000000 =00000009 327 TCacheCC equ 9 ; 'track cache' control 00000000 =00000014 328 iconIDCC equ 20 ; 'get icon id' control code 00000000 =00000015 329 iconCC equ 21 ; 'get icon' control code 00000000 330 00000000 331 ;_______________________________________; 00000000 332 ; ; 00000000 333 ; Driver Vectors: ; 00000000 334 ;_______________________________________; 00000000 335 00000000 336 ;_______________________________________; 00000000 337 ; 00000000 338 ; (1) Location of disk routine vectors. 00000000 339 00000000 =00000222 340 diskVars equ $0222 00000000 =00000222 341 jFigTrkSpd equ diskVars 00000000 =00000226 342 jDiskPrime equ jFigTrkSpd+4 00000000 =0000022A 343 jRdAddr equ jDiskPrime+4 00000000 =0000022E 344 jRdData equ jRdAddr+4 00000000 345 00000000 =00000232 346 jWrData equ jRdData+4 00000000 =00000236 347 jSeek equ jWrData+4 00000000 =0000023A 348 jSetUpPoll equ jSeek+4 00000000 =0000023E 349 jRecal equ jSetUpPoll+4 00000000 350 00000000 =00000242 351 jControl equ jRecal+4 00000000 =00000246 352 jWakeUp equ jControl+4 00000000 =0000024A 353 jReSeek equ jWakeUp+4 00000000 =0000024E 354 jMakeSpdTbl equ jReSeek+4 00000000 355 00000000 =00000252 356 jAdrDisk equ jMakeSpdTbl+4 00000000 =00000256 357 jSetSpeed equ jAdrDisk+4 00000000 =0000025A 358 niblTbl equ jSetSpeed+4 00000000 359 00000000 =00000B40 360 jDiskSel equ $B40 (long) vector to .Sony DiskSelect routine 00000000 =00000B44 361 jSendCmd equ $B44 (long) vector to .Sony DCD SendCmd routine 00000000 =00000B48 362 jDCDReset equ $B48 (long) vector to .Sony DCD DCDReset routine 00000000 363 00000000 364 ;************** NEW SONY DRIVER EQUATES *************/ 00000000 365 00000000 366 ; Sony Driver Equates 00000000 367 00000000 368 00000000 =000007DC 369 jDoEject equ 4*($F7)+$0400 Sony Driver jump vectors ; **************************************** ; ROM-ADDR DATA-BYTES DISASSEMBLY ; resource header 17D28 C000 2070 DC.L $C0002070 ; Length 17D2C 0000 005C DC.L $0000005C ; ? ; resource : 'DRVR' 4 '.Sony' ; Disk Driver 17D30 4F00 DC.W $4F00 ; flags 17D32 0000 DC.W $0000 ; number of ticks between periodic actions 17D34 0000 DC.W $0000 ; desk accessory event mask 17D36 0000 DC.W $0000 ; menu ID 17D38 006E DC.W $006E ; offset to open routine 17D3A 033A DC.W $033A ; offset to prime routine 17D3C 01E2 DC.W $01E2 ; offset to control routine 17D3E 02EC DC.W $02EC ; offset to status routine 17D40 0018 DC.W $0018 ; offset to close routine 17D42 05 DC.B $05 ; length of driver name ; Name 17D43 2E53 6F6E 79 DC.B '.Sony' ; end of Name E_Sony_Close: 17D48 70E8 MoveQ.L $-18, D0 17D4A 4E75 Rts ; Jump Table 17D4C 0D44 0324 0ED6 DT77: DC.B ' D $ ' 17D52 0F9C 11F4 09DA DC.B ' ' 17D58 0E9E 0B0C 01CC DC.B ' ' 17D5E 0A8E 0596 0C9E DC.B ' ' 17D64 0878 0900 133E DC.B ' x >' ; Jump Table, part 2 17D6A 0BE8 1966 1F20 DC.B ' f ' 17D70 0800 0200 4000 DT78: DC.B ' @ ' 17D76 0800 0000 012C DC.B ' ,' 17D7C 05DC 0FA0 0005 DC.B ' ' 17D82 0078 0064 001E DC.B ' x d ' 17D88 1D4C 0000 3840 DC.B ' L 8@' 17D8E FC00 DC.B ' ' 17D90 7400 P713: MoveQ.L $0, D2 17D92 3418 Move (A0)+, D2 17D94 D480 Add.L D0, D2 17D96 22C2 Move.L D2, (A1)+ 17D98 51C9 FFF6 DBF D1, P713 17D9C 4E75 Rts ; floppy-related portions of the Sony driver code omitted for brevity ; ... ; start of HD20 driver routines 194D6 027C F8FF L4702: And $-701, SR ; HD20? enable interrupts? 194DA 3029 0112 Move $112(A1), D0 ; lastDrive 194DE B069 0012 Cmp $12(A1), D0 ; drive number 194E2 6706 BEQ L4703 194E4 700A MoveQ.L $A, D0 194E6 6100 F2EC Bsr E_Sony_WakeUp ; never returns? 194EA 2078 01E0 L4703: Move.L (IWM), A0 194EE 4A10 Tst.B (A0) ; CA0 off 194F0 4A28 0800 Tst.B $800(A0) ; CA2 off - now is state 2 idle? 194F4 0C31 0002 1003 Cmp.B $2, $3(A1,D1.W) ; disk in place? 2==MacOS Read 194FA 6C48 BGE L4704 194FC 41FA 000A Lea.L DT178, A0 19500 2348 0198 Move.L A0, $198(A1) ; stsRtnAddr = DCD status call return address 19504 6000 07E2 Bra L4806 DT178: 19508 6600 013E BNE L4718 1950C 6100 F09E Bsr Sony_SetupRegs 19510 13BC 0008 1003 Move.B $8, $3(A1,D1.W) ; disk in place, 8=???? 19516 23A9 01A2 1016 Move.L $1A2(A1), $16(A1,D1.W) 1951C 2029 01A6 Move.L $1A6(A1), D0 ; devBlks (disk blocks in low 3 bytes) 19520 4840 Swap D0 19522 2380 1012 Move.L D0, $12(A1,D1.W) ; driveSize (drive block size for DCD) 19526 4231 1014 Clr.B $14(A1,D1.W) ; drive error count 1952A E048 LsR $8, D0 1952C 1380 101A Move.B D0, $1A(A1,D1.W) ; driveChar 19530 0800 0003 BTst.B $3, D0 19534 56F1 1002 SNE.B $2(A1,D1.W) ; write protect? FF=protected 19538 0800 0004 BTst.B $4, D0 ; ejectable? 1953C 6706 BEQ L4704 1953E 13BC 0002 1003 Move.B $2, $3(A1,D1.W) ; disk in place, 2=MacOS Read 19544 2451 L4704: Move.L (A1), A2 ; pointer to device control entry 19546 2A2A 0010 Move.L $10(A2), D5 1954A 7209 MoveQ.L $9, D1 1954C E2AD LsR.L D1, D5 1954E 206A 0008 Move.L $8(A2), A0 19552 2A69 00F4 Move.L $F4(A1), A5 19556 2868 0020 Move.L $20(A0), A4 1955A 2628 0024 Move.L $24(A0), D3 1955E 70CE MoveQ.L $-32, D0 ; error -50, bad positioning info 19560 0243 01FF And $1FF, D3 19564 6600 00E2 BNE L4718 19568 2628 0024 Move.L $24(A0), D3 1956C 4A38 012C Tst.B (DskVerify) 19570 6714 BEQ L4705 19572 6100 EF90 Bsr P856 19576 660E BNE L4705 19578 2143 0028 Move.L D3, $28(A0) 1957C D7AA 0010 Add.L D3, $10(A2) 19580 7000 MoveQ.L $0, D0 19582 6000 00C4 Bra L4718 19586 1369 0033 019C L4705: Move.B $33(A1), $19C(A1) ; high/low byte I/O command to command/response byte 1958C 5529 019C SubQ.B $2, $19C(A1) ; subtract 2 from the command number?? 19590 7209 L4706: MoveQ.L $9, D1 19592 E2AB LsR.L D1, D3 19594 7000 MoveQ.L $0, D0 19596 5300 SubQ.L $1, D0 19598 B680 Cmp.L D0, D3 1959A 6D02 BLT L4707 1959C 2600 Move.L D0, D3 1959E 3403 L4707: Move D3, D2 195A0 4843 Swap D3 195A2 3602 Move D2, D3 195A4 137C 0003 002D Move.B $3, $2D(A1) ; recalCnt 195AA 4229 01BF Clr.B $1BF(A1) ; dcdFlags - flag of whether we've done a reset 195AE 6100 00CC L4708: Bsr P883 195B2 6100 00F8 Bsr E_Sony_SendCmd 195B6 6624 BNE L4711 195B8 6100 009E L4709: Bsr P882 195BC 6A12 BPL L4710 195BE 137C 0002 01BE Move.B $2, $1BE(A1) ; lastResult 195C4 42A9 01BA Clr.L $1BA(A1) ; lastStatus 195C8 137C 0040 01BA Move.B $40, $1BA(A1) ; possible HD20 error 64, noResp: No response packet ever received 195CE 600C Bra L4711 195D0 6100 0184 L4710: Bsr P885 ; HD20 read? 195D4 67E2 BEQ L4709 195D6 DA84 Add.L D4, D5 195D8 4A40 Tst D0 195DA 673C BEQ L4716 195DC 5329 002D L4711: SubQ $1, $2D(A1) ; recalCnt 195E0 6D28 BLT L4714 195E2 671A BEQ L4712 195E4 0C29 0002 01BE Cmp.B $2, $1BE(A1) ; lastResult 195EA 661C BNE L4713 195EC 0829 001E 01BA BTst.B $1E, $1BA(A1) ; lastStatus 195F2 6614 BNE L4713 195F4 4A29 01BF Tst.B $1BF(A1) ; dcdFlags - flag of whether we've done a reset 195F8 6704 BEQ L4712 195FA 4229 002D Clr.B $2D(A1) ; recalCnt 195FE 6100 0666 L4712: Bsr E_Sony_DCDReset 19602 6606 BNE L4714 19604 50E9 01BF ST.B $1BF(A1) ; dcdFlags - flag of whether we've done a reset 19608 60A4 L4713: Bra L4708 1960A 70ED L4714: MoveQ.L $-13, D0 ; error -19, read error, driver can't respond to read calls 1960C 0C29 0002 0033 Cmp.B $2, $33(A1) ; I/O command high/low byte?? 19612 6702 BEQ L4715 19614 70EC MoveQ.L $-14, D0 ; error -20, write error, can't respond to write calls 19616 6030 L4715: Bra L4718 19618 7209 L4716: MoveQ.L $9, D1 1961A 4243 Clr D3 1961C 4843 Swap D3 1961E 0C29 0002 0033 Cmp.B $2, $33(A1) ; I/O command high/low byte?? 19624 6704 BEQ L4717 19626 D7B8 0300 Add.L D3, (BufTgFFlg) 1962A E3AB L4717: LsL.L D1, D3 1962C 2651 Move.L (A1), A3 1962E D7AB 0010 Add.L D3, $10(A3) 19632 206B 0008 Move.L $8(A3), A0 19636 D7A8 0028 Add.L D3, $28(A0) 1963A 2628 0024 Move.L $24(A0), D3 1963E 96A8 0028 Sub.L $28(A0), D3 19642 6E00 FF4C BGT L4706 19646 7000 MoveQ.L $0, D0 19648 2078 01E0 L4718: Move.L (IWM), A0 1964C 4A28 1000 Tst.B $1000(A0) ; enable off 19650 027C F8FF And $-701, SR 19654 6000 E88A Bra Sony_ReturnResult P882: ; wait for /HSHK to go low? 19658 265F Move.L (A7)+, A3 1965A 7064 L4719: MoveQ.L $64, D0 1965C 4A28 1A00 L4720: Tst.B $1A00(A0) ; Q6 on 19660 4A28 1C00 Tst.B $1C00(A0) ; Q7 on, read 19664 5AC8 FFF6 DBPL D0, L4720 19668 6A10 BPL L4721 1966A 5369 01C2 SubQ $1, $1C2(A1) ; maximum number of checks 1966E 6B0A BMI L4721 19670 3029 01C0 Move $1C0(A1), D0 ; 100usec check ready count 19674 6100 F15E Bsr E_Sony_WakeUp 19678 60E0 Bra L4719 1967A 4ED3 L4721: Jmp (A3) P883: 1967C 2005 Move.L D5, D0 1967E E188 LsL.L $8, D0 19680 2340 019E Move.L D0, $19E(A1) 19684 1343 019D Move.B D3, $19D(A1) ; sequence number?? 19688 337C 000A 01C0 Move $A, $1C0(A1) 1968E 337C 2710 01C2 Move $2710, $1C2(A1) 19694 2C3C 0000 0200 Move.L $200, D6 1969A 7E00 MoveQ.L $0, D7 ; maybe D7 low word is the number of 8-byte groups of data to read, and D7 high word is the number of subsequent padding bytes before the checksum 1969C 4A29 019C Tst.B $19C(A1) ; command number? 196A0 6602 BNE L4722 196A2 CD47 Exg.L D6, D7 ; maybe D7 low word is the number of 8-byte groups of data to read, and D7 high word is the number of subsequent padding bytes before the checksum 196A4 0229 003F 019C L4722: And.B $3F, $19C(A1) 196AA 4E75 Rts E_Sony_SendCmd: 196AC 2F38 0B44 Move.L (JSendCmd), -(A7) 196B0 4E75 Rts P_Sony_SendCmd: ; HD20? 196B2 2078 01E0 Move.L (IWM), A0 196B6 47E8 1800 Lea.L $1800(A0), A3 ; Q6 off address? 196BA 2346 01B6 Move.L D6, $1B6(A1) ; bufSize. D6=0 for status 196BE DFA9 01B6 Add.L D7, $1B6(A1) ; buffSize. D7=332 for status 196C2 1229 019C Move.B $19C(A1), D1 ; command number. From doc: read = 0, write = 1, status = 3 196C6 0C01 0003 Cmp.B $3, D1 196CA 6C2E BGE L4724 196CC 4A01 Tst.B D1 196CE 6606 BNE L4723 196D0 0647 0014 Add $14, D7 ; 20 bytes tags 196D4 6024 Bra L4724 196D6 0646 0014 L4723: Add $14, D6 ; 20 bytes tags 196DA 200D Move.L A5, D0 196DC 661C BNE L4724 196DE D2FC 01A2 AddA $1A2, A1 196E2 22F8 02FC Move.L (BufTgFNum), (A1)+ ; 20 bytes of tags per sector, plus 512 bytes data, 532 total 196E6 22F8 0300 Move.L (BufTgFFlg), (A1)+ 196EA 22F8 0304 Move.L (BufTgDate), (A1)+ 196EE 22F8 038A Move.L (BufTgHD20), (A1)+ 196F2 22F8 038E Move.L (BufTgHD20.1), (A1)+ 196F6 2278 0134 Move.L (SonyVars), A1 196FA 5C46 L4724: AddQ.L $6, D6 ; cmd 3 (status) and higher jump here 196FC 8CFC 0007 DivU $7, D6 19700 0246 007F And $7F, D6 ; D6 = groups of 7 logical bytes 19704 5C47 AddQ $6, D7 ; maybe D7 low word is the number of 7-byte groups of data, and D7 high word is the number of subsequent padding bytes before the checksum 19706 8EFC 0007 DivU $7, D7 1970A 0247 007F And $7F, D7 1970E 7800 MoveQ.L $0, D4 19710 601E Bra L4726 19712 4A01 L4725: Tst.B D1 19714 673E BEQ L4728 19716 0029 0040 019C Or.B $40, $19C(A1) ; command number 1971C 1343 019D Move.B D3, $19D(A1) ; mb sequence number (sys commands only) 19720 52A9 01A6 AddQ.B $1, $1A6(A1) ; devChar or devBlks? 19724 337C 0007 01C0 Move $7, $1C0(A1) ; 100usec check ready count 1972A 337C 2710 01C2 Move $2710, $1C2(A1) ; maximum number of checks 19730 0C01 0003 L4726: Cmp.B $3, D1 ; command 3? 19734 6C16 BGE L4727 19736 4A01 Tst.B D1 19738 6712 BEQ L4727 1973A 200D Move.L A5, D0 1973C 670E BEQ L4727 1973E D2FC 01A2 AddA $1A2, A1 19742 22DD Move.L (A5)+, (A1)+ 19744 22DD Move.L (A5)+, (A1)+ 19746 22DD Move.L (A5)+, (A1)+ 19748 2278 0134 Move.L (SonyVars), A1 1974C 6100 02D2 L4727: Bsr P887 ; send (or convert?) HD20 data in buffer (at SonyVars?) 19750 6600 00AC BNE L4733 ; error? 19754 4E75 L4728: Rts 19756 2078 01E0 P885: Move.L (IWM), A0 1975A 47E8 1800 Lea.L $1800(A0), A3 ; Q6 off address? 1975E 1229 019C Move.B $19C(A1), D1 ; the command number 19762 0201 003F And.B $3F, D1 ; max of 63 19766 6100 00A6 Bsr P886 ; HD20 read one group of 8? Which is actually 7 logical bytes? 1976A 6600 0092 BNE L4733 ; error? 1976E 2029 019C Move.L $19C(A1), D0 ; response, sequence, status, startblock 19772 103C 0030 Move.B $30, D0 ; HD20 error 48, invalidResp: First byte in response packet was wrong 19776 0429 0080 019C Sub.B $-80, $19C(A1) ; subtract 128? why? Per doc, first byte of the HD20 response should be the same as the command, but +$80. 1977C B229 019C Cmp.B $19C(A1), D1 ; was it the expected command number? 19780 667C BNE L4733 19782 0C01 0003 Cmp.B $3, D1 19786 6C4C BGE L4731 19788 103C 0031 Move.B $31, D0 ; HD20 error 49, sqncNumErr: Sequence number in response packet was wrong 1978C B629 019D Cmp.B $19D(A1), D3 ; sequence number? 19790 6710 BEQ L4729 19792 4840 Swap D0 19794 1003 Move.B D3, D0 19796 4840 Swap D0 19798 E098 ROR.L $8, D0 1979A 1029 019D Move.B $19D(A1), D0 ; sequence number 1979E E198 ROL.L $8, D0 197A0 605C Bra L4733 197A2 4A01 L4729: Tst.B D1 197A4 662E BNE L4731 197A6 200D Move.L A5, D0 197A8 670E BEQ L4730 197AA D2FC 01A2 AddA $1A2, A1 ; ptr to tag bytes area 197AE 2AD9 Move.L (A1)+, (A5)+ 197B0 2AD9 Move.L (A1)+, (A5)+ 197B2 2AD9 Move.L (A1)+, (A5)+ 197B4 2278 0134 Move.L (SonyVars), A1 197B8 D2FC 01A2 L4730: AddA $1A2, A1 197BC 21D9 02FC Move.L (A1)+, (BufTgFNum) ; 20 bytes of tags per sector, plus 512 bytes data, 532 total 197C0 21D9 0300 Move.L (A1)+, (BufTgFFlg) 197C4 21D9 0304 Move.L (A1)+, (BufTgDate) 197C8 21D9 038A Move.L (A1)+, (BufTgHD20) 197CC 21D9 038E Move.L (A1)+, (BufTgHD20.1) 197D0 2278 0134 Move.L (SonyVars), A1 197D4 7401 L4731: MoveQ.L $1, D2 197D6 2029 019E Move.L $19E(A1), D0 ; status/startBlock 197DA 0800 0018 BTst.B $18, D0 197DE 6622 BNE L4734 197E0 0C29 000A 019E Cmp.B $A, $19E(A1) 197E6 671A BEQ L4734 197E8 D9E9 01B6 AddA.L $1B6(A1), A4 ; bufSize 197EC 5284 AddQ.L $1, D4 197EE 5303 SubQ.L $1, D3 ; sequence number 197F0 6600 FF20 BNE L4725 197F4 7000 MoveQ.L $0, D0 197F6 5243 L4732: AddQ.L $1, D3 ; sequence number 197F8 027C FFFB And $-5, SR 197FC 4E75 Rts 197FE 7402 L4733: MoveQ.L $2, D2 19800 E098 ROR.L $8, D0 19802 2340 01BA L4734: Move.L D0, $1BA(A1) ; lastStatus 19806 1342 01BE Move.B D2, $1BE(A1) ; lastResult 1980A 7001 MoveQ.L $1, D0 1980C 60E8 Bra L4732 ; Sub to read the first 7/8 group from HD20 1980E 40E7 P886: Move SR, -(A7) 19810 48E7 7F4E MoveM.L D1-D7/A1/A4-A6, -(A7) 19814 D2FC 019C AddA $19C, A1 ; the address where data will be saved 19818 7A00 MoveQ.L $0, D5 1981A 4A28 1A00 Tst.B $1A00(A0) ; Q6 on 1981E 7020 MoveQ.L $20, D0 ; HD20 error 32, rdHsHi: HSHK high before starting 19820 4A28 1C00 Tst.B $1C00(A0) ; read /HSHK? 19824 6B00 01E8 BMI L4770 19828 4CF8 6000 01D8 MoveM.L (SCCRd), A5-A6 1982E 544D AddQ.L $2, A5 19830 544E AddQ.L $2, A6 19832 007C 0700 Or $700, SR 19836 4A28 0200 Tst.B $200(A0) ; CA0 on 1983A 4A28 0400 Tst.B $400(A0) ; CA1 off - now in state 1 read/write? 1983E 4A13 Tst.B (A3) 19840 7021 MoveQ.L $21, D0 ; HD20 error 33, rdSyncTO: Time out waiting for sync ($AA) byte 19842 7C01 MoveQ.L $1, D6 19844 4846 Swap D6 19846 5386 L4735: SubQ $1, D6 19848 6700 01C4 BEQ L4770 ; error, no sync 1984C 0C13 00AA Cmp.B $-56, (A3) ; check for sync: $-56 = $AA = HD20 sync byte 19850 66F4 BNE L4735 19852 3C3C 0050 Move $50, D6 ; try 80 times for next byte 19856 1213 L4736: Move.B (A3), D1 ; read byte 1 19858 5BCE FFFC DBMI D6, L4736 1985C 6A58 BPL L4745 ; error, no data after sync 1985E 0C01 00BF Cmp.B $-41, D1 ; $-41 = $BF = NAK (before decoding) 19862 6604 BNE L4737 19864 7E06 MoveQ.L $6, D7 ; maybe D7 low word is the number of 8-byte groups of data to read, and D7 high word is the number of subsequent padding bytes before the checksum 19866 4847 Swap D7 19868 4841 L4737: Swap D1 1986A 1213 L4738: Move.B (A3), D1 ; read byte 2 1986C 5BCE FFFC DBMI D6, L4738 19870 6A44 BPL L4745 ; error, no data after sync 19872 4841 Swap D1 19874 1413 L4739: Move.B (A3), D2 ; read byte 3 19876 5BCE FFFC DBMI D6, L4739 1987A 6A3A BPL L4745 ; error, no data after sync 1987C 4842 Swap D2 1987E 1413 L4740: Move.B (A3), D2 ; read byte 4 19880 5BCE FFFC DBMI D6, L4740 19884 6A30 BPL L4745 ; error, no data after sync 19886 4842 Swap D2 19888 1613 L4741: Move.B (A3), D3 ; read byte 5 1988A 5BCE FFFC DBMI D6, L4741 1988E 6A26 BPL L4745 ; error, no data after sync 19890 4843 Swap D3 19892 1613 L4742: Move.B (A3), D3 ; read byte 6 19894 5BCE FFFC DBMI D6, L4742 19898 6A1C BPL L4745 ; error, no data after sync 1989A 4843 Swap D3 1989C 1813 L4743: Move.B (A3), D4 ; read byte 7 1989E 5BCE FFFC DBMI D6, L4743 198A2 6A12 BPL L4745 ; error, no data after sync 198A4 4844 Swap D4 198A6 1813 L4744: Move.B (A3), D4 ; read byte 8 198A8 5BCE FFFC DBMI D6, L4744 198AC 6A08 BPL L4745 ; error, no data after sync 198AE 51CF 000C DBF D7, L4746 ; D7 = number of 8-byte groups remaining? 198B2 6000 00EC Bra L4763 198B6 7022 L4745: MoveQ.L $22, D0 ; HD20 error 34, rdGroupTO: Time out waiting for group 198B8 6000 0154 Bra L4770 ; Convert and store 8-to-7 group in D1-D4 lo/hi, while also reading the next group 198BC 7C03 L4746: MoveQ.L $3, D6 198BE 4846 Swap D6 198C0 3C3C 0050 Move $50, D6 198C4 E20C L4747: LsR.B $1, D4 198C6 D301 AddX.B D1, D1 198C8 DA01 Add.B D1, D5 198CA 12C1 Move.B D1, (A1)+ 198CC 1213 L4748: Move.B (A3), D1 ; read ?? 198CE 5BCE FFFC DBMI D6, L4748 198D2 6AE2 BPL L4745 198D4 4841 Swap D1 198D6 1CBC 0003 Move.B $3, (A6) 198DA E20C LsR.B $1, D4 198DC D301 AddX.B D1, D1 198DE DA01 Add.B D1, D5 198E0 12C1 Move.B D1, (A1)+ 198E2 1213 L4749: Move.B (A3), D1 ; read ?? 198E4 5BCE FFFC DBMI D6, L4749 198E8 6ACC BPL L4745 198EA 4841 Swap D1 198EC 4A47 Tst D7 ; D7 = number of 8-byte groups remaining? 198EE 6702 BEQ L4750 198F0 4A15 Tst.B (A5) ; check for holdoff? 198F2 56C0 L4750: SNE.B D0 ; holdoff? 198F4 E20C LsR.B $1, D4 198F6 D502 AddX.B D2, D2 198F8 DA02 Add.B D2, D5 198FA 12C2 Move.B D2, (A1)+ 198FC 1413 L4751: Move.B (A3), D2 ; read ?? 198FE 5BCE FFFC DBMI D6, L4751 19902 6AB2 BPL L4745 19904 4842 Swap D2 19906 E20C LsR.B $1, D4 19908 D502 AddX.B D2, D2 1990A DA02 Add.B D2, D5 1990C 12C2 Move.B D2, (A1)+ 1990E 1413 L4752: Move.B (A3), D2 ; read ?? 19910 5BCE FFFC DBMI D6, L4752 19914 6AA0 BPL L4745 19916 4842 Swap D2 19918 4A00 Tst.B D0 ; holdoff? 1991A 6702 BEQ L4753 1991C 4A10 Tst.B (A0) ; CA0 off. Now in state 0, holdoff 1991E E20C L4753: LsR.B $1, D4 19920 D703 AddX.B D3, D3 19922 DA03 Add.B D3, D5 19924 12C3 Move.B D3, (A1)+ 19926 1613 L4754: Move.B (A3), D3 ; read ?? 19928 5BCE FFFC DBMI D6, L4754 1992C 6A88 L4755: BPL L4745 1992E 4843 Swap D3 19930 4846 Swap D6 ; D6 = 3 initially. Switch from filling tags to data buffer? 19932 51CE 0004 DBF D6, L4756 19936 224C Move.L A4, A1 19938 4846 L4756: Swap D6 1993A E20C LsR.B $1, D4 1993C D703 AddX.B D3, D3 1993E DA03 Add.B D3, D5 19940 12C3 Move.B D3, (A1)+ 19942 1613 L4757: Move.B (A3), D3 ; read ?? 19944 5BCE FFFC DBMI D6, L4757 19948 6AE2 BPL L4755 1994A 4843 Swap D3 1994C E20C LsR.B $1, D4 1994E 4844 Swap D4 19950 D904 AddX.B D4, D4 19952 DA04 Add.B D4, D5 19954 12C4 Move.B D4, (A1)+ 19956 1813 L4758: Move.B (A3), D4 ; read?? 19958 5BCE FFFC DBMI D6, L4758 1995C 6ACE BPL L4755 1995E 4844 Swap D4 19960 3C3C 0050 Move $50, D6 19964 1813 L4759: Move.B (A3), D4 ; read?? 19966 5BCE FFFC DBMI D6, L4759 1996A 6AC0 BPL L4755 1996C 4A00 Tst.B D0 1996E 56CF FF54 DBNE D7, L4747 ; D7 = number groups remaining 19972 672C BEQ L4763 ; done with all groups, or holdoff 19974 4A15 Tst.B (A5) ; holdoff? 19976 027C F8FF And $-701, SR ; enable interrupts, so they can process 1997A 5347 SubQ $1, D7 ; D7 = number groups remaining 1997C 7010 MoveQ.L $10, D0 1997E 51C8 FFFE L4760: DBF D0, L4760 ; short busy-wait 19982 007C 0700 Or $700, SR ; disable interrupts 19986 4A28 0200 Tst.B $200(A0) ; CA0 on - return to state 1 1998A 4A13 Tst.B (A3) 1998C 4240 Clr D0 1998E 5340 L4761: SubQ $1, D0 ; test for holdoff? 19990 670A BEQ L4762 19992 0C13 00AA Cmp.B $-56, (A3) ; $-56 = $AA = sync 19996 66F6 BNE L4761 19998 6000 FF2A Bra L4747 1999C 7024 L4762: MoveQ.L $24, D0 ; HD20 error 36, rdHoffSyncTO: Time out waiting for sync after holdoff 1999E 606E Bra L4770 ; Convert and store the last 8-to-7 group 199A0 4847 L4763: Swap D7 ; D7 = actual data bytes in this last group 199A2 E20C LsR.B $1, D4 199A4 D301 AddX.B D1, D1 199A6 DA01 Add.B D1, D5 ; D5 = checksum 199A8 5347 SubQ.B $1, D7 ; D7 = tag bytes remaining? 199AA 6B02 BMI L4764 199AC 12C1 Move.B D1, (A1)+ 199AE 4841 L4764: Swap D1 199B0 E20C LsR.B $1, D4 199B2 D301 AddX.B D1, D1 199B4 DA01 Add.B D1, D5 199B6 5347 SubQ.B $1, D7 199B8 6B02 BMI L4765 199BA 12C1 Move.B D1, (A1)+ 199BC E20C L4765: LsR.B $1, D4 199BE D502 AddX.B D2, D2 199C0 DA02 Add.B D2, D5 199C2 5347 SubQ.B $1, D7 ; D7 = tag bytes remaining? 199C4 6B02 BMI L4766 199C6 12C2 Move.B D2, (A1)+ 199C8 4842 L4766: Swap D2 199CA E20C LsR.B $1, D4 199CC D502 AddX.B D2, D2 199CE DA02 Add.B D2, D5 199D0 5347 SubQ.B $1, D7 ; D7 = tag bytes remaining? 199D2 6B02 BMI L4767 199D4 12C2 Move.B D2, (A1)+ 199D6 E20C L4767: LsR.B $1, D4 199D8 D703 AddX.B D3, D3 199DA DA03 Add.B D3, D5 199DC 5347 SubQ.B $1, D7 ; D7 = tag bytes remaining? 199DE 6B02 BMI L4768 199E0 12C3 Move.B D3, (A1)+ 199E2 4843 L4768: Swap D3 199E4 E20C LsR.B $1, D4 199E6 D703 AddX.B D3, D3 199E8 DA03 Add.B D3, D5 199EA 5347 SubQ.B $1, D7 ; D7 = tag bytes remaining? 199EC 6B02 BMI L4769 199EE 12C3 Move.B D3, (A1)+ 199F0 E20C L4769: LsR.B $1, D4 199F2 4844 Swap D4 199F4 D904 AddX.B D4, D4 199F6 DA04 Add.B D4, D5 199F8 4A28 0600 Tst.B $600(A0) ; CA1 on 199FC 4A28 1A00 Tst.B $1A00(A0) ; Q6 on 19A00 7025 MoveQ.L $25, D0 ; HD20 error 37, rdHsHiTO: Time out waiting for HSHK high 19A02 4A28 1C00 Tst.B $1C00(A0) ; read /HSHK 19A06 6A06 BPL L4770 19A08 1005 Move.B D5, D0 19A0A 6702 BEQ L4770 19A0C 7026 MoveQ.L $26, D0 ; HD20 error 38, rdChksumErr: Checksum error on response packet 19A0E 4A15 L4770: Tst.B (A5) 19A10 4A28 0600 Tst.B $600(A0) ; CA1 on 19A14 4A10 Tst.B (A0) ; CA0 off - now we're in state 2 idle 19A16 4CDF 72FE MoveM.L (A7)+, D1-D7/A1/A4-A6 19A1A 46DF Move (A7)+, SR 19A1C 4A00 Tst.B D0 19A1E 4E75 Rts ; HD20 write? 19A20 40E7 P887: Move SR, -(A7) 19A22 48E7 7F4E MoveM.L D1-D7/A1/A4-A6, -(A7) 19A26 D2FC 019C AddA $19C, A1 ; command number, or response byte 19A2A 4CF8 6000 01D8 MoveM.L (SCCRd), A5-A6 19A30 544D AddQ.L $2, A5 19A32 544E AddQ.L $2, A6 ; check serial? 19A34 1801 Move.B D1, D4 ; also the command number? 19A36 4844 Swap D4 ; put command number in high word 19A38 4846 Swap D6 ; D6 = write size? Now in high word. 19A3A 3C07 Move D7, D6 ; D7 = read size? 19A3C 4846 Swap D6 ; D6 now = readSize | writeSize 19A3E 7A00 MoveQ.L $0, D5 ; D5 = checkum 19A40 50C4 ST.B D4 ; sets D4 = command number | 0xFF 19A42 1219 Move.B (A1)+, D1 ; command number 19A44 DA01 Add.B D1, D5 ; D5 = checksum 19A46 E211 RXR.B $1, D1 ; shift out LSB 19A48 0001 0080 Or.B $-80, D1 ; set MSB for IWM 19A4C E214 RXR.B $1, D4 ; D4 = collected LSB's 19A4E 4841 Swap D1 19A50 1219 Move.B (A1)+, D1 ; sequence number 19A52 DA01 Add.B D1, D5 19A54 E211 RXR.B $1, D1 19A56 0001 0080 Or.B $-80, D1 19A5A E214 RXR.B $1, D4 19A5C 4841 Swap D1 19A5E 1419 Move.B (A1)+, D2 ; starting block number 19A60 DA02 Add.B D2, D5 19A62 E212 RXR.B $1, D2 19A64 0002 0080 Or.B $-80, D2 19A68 E214 RXR.B $1, D4 19A6A 4842 Swap D2 19A6C 1419 Move.B (A1)+, D2 ; starting block number high? 19A6E DA02 Add.B D2, D5 19A70 E212 RXR.B $1, D2 19A72 0002 0080 Or.B $-80, D2 19A76 E214 RXR.B $1, D4 19A78 4842 Swap D2 19A7A 1619 Move.B (A1)+, D3 ; driveOut - drive number 19A7C DA03 Add.B D3, D5 19A7E E213 RXR.B $1, D3 19A80 0003 0080 Or.B $-80, D3 19A84 E214 RXR.B $1, D4 19A86 4843 Swap D3 19A88 1619 Move.B (A1)+, D3 ; driveIn - low 6 bits 19A8A DA03 Add.B D3, D5 19A8C E213 RXR.B $1, D3 19A8E 0003 0080 Or.B $-80, D3 19A92 E214 RXR.B $1, D4 19A94 4843 Swap D3 19A96 4844 Swap D4 ; D4 = LSB's | command number 19A98 4A28 1A00 Tst.B $1A00(A0) ; Q6 on 19A9C 7010 MoveQ.L $10, D0 ; HD20 error 16, wrtHsLw: HSHK low before starting 19A9E 4A28 1C00 Tst.B $1C00(A0) ; read /HSHK 19AA2 6A00 01B2 BPL L4802 19AA6 4A28 0200 Tst.B $200(A0) ; CA0 on - now in state 3 wait for handshake? 19AAA 7011 MoveQ.L $11, D0 ; HD20 error 17, wrtHSLwTO: Time out waiting for HSHK to go low 19AAC 7E14 MoveQ.L $14, D7 19AAE 4847 Swap D7 19AB0 5387 L4771: SubQ $1, D7 19AB2 6700 01A2 BEQ L4802 19AB6 4A28 1C00 Tst.B $1C00(A0) ; read /HSHK 19ABA 6BF4 BMI L4771 19ABC 4A28 0400 Tst.B $400(A0) ; CA1 off - now in state 1 read/write 19AC0 41E8 1A00 Lea.L $1A00(A0), A0 19AC4 007C 0700 Or $700, SR 19AC8 7E02 MoveQ.L $2, D7 19ACA 0C04 0004 Cmp.B $4, D4 ; command < 4 ? 19ACE 6D04 BLT L4772 19AD0 7EFF MoveQ.L $-1, D7 19AD2 224C Move.L A4, A1 19AD4 7004 L4772: MoveQ.L $4, D0 19AD6 51C8 FFFE L4773: DBF D0, L4773 ; tiny delay loop - wait for HD20 to be ready? 19ADA 2006 Move.L D6, D0 ; readSize | writeSize 19ADC 0680 0081 0081 Add.L $810081, D0 ; D6 + $810081? 19AE2 117C 00AA 0400 Move.B $-56, $400(A0) ; write $-56 = $AA = sync 19AE8 4A13 L4774: Tst.B (A3) ; wait for IWM? 19AEA 6AFC BPL L4774 19AEC 1080 Move.B D0, (A0) ; HD20 write writeSize 19AEE 4840 Swap D0 19AF0 4A13 L4775: Tst.B (A3) 19AF2 6AFC BPL L4775 19AF4 1080 Move.B D0, (A0) ; HD20 write readSize 19AF6 7080 MoveQ.L $-80, D0 19AF8 6000 00B4 Bra L4785 ; HD20 write one group while encoding the next? 19AFC 1819 L4776: Move.B (A1)+, D4 ; start of a group of 8 19AFE DA04 Add.B D4, D5 19B00 E214 RXR.B $1, D4 19B02 8800 Or.B D0, D4 19B04 4844 Swap D4 19B06 E414 RXR.B $2, D4 19B08 4A13 L4777: Tst.B (A3) 19B0A 6AFC BPL L4777 19B0C 1084 Move.B D4, (A0) ; HD20 write data 1? 19B0E 50C4 ST.B D4 19B10 1CBC 0003 Move.B $3, (A6) 19B14 4A13 L4778: Tst.B (A3) 19B16 6AFC BPL L4778 19B18 1081 Move.B D1, (A0) ; HD20 write data 2? 19B1A 1219 Move.B (A1)+, D1 19B1C DA01 Add.B D1, D5 19B1E E211 RXR.B $1, D1 19B20 8200 Or.B D0, D1 19B22 E214 RXR.B $1, D4 19B24 4841 Swap D1 19B26 4A15 Tst.B (A5) 19B28 6704 BEQ L4779 19B2A 08C6 001F BSet.B $1F, D6 19B2E 4A13 L4779: Tst.B (A3) 19B30 6AFC BPL L4779 19B32 1081 Move.B D1, (A0) ; HD20 write data 3? 19B34 1219 Move.B (A1)+, D1 19B36 DA01 Add.B D1, D5 19B38 E211 RXR.B $1, D1 19B3A 8200 Or.B D0, D1 19B3C E214 RXR.B $1, D4 19B3E 4841 Swap D1 19B40 4A46 Tst D6 19B42 6604 BNE L4780 19B44 0886 001F BClr.B $1F, D6 19B48 4A13 L4780: Tst.B (A3) 19B4A 6AFC BPL L4780 19B4C 1082 Move.B D2, (A0) ; HD20 write data 4? 19B4E 1419 Move.B (A1)+, D2 19B50 DA02 Add.B D2, D5 19B52 E212 RXR.B $1, D2 19B54 8400 Or.B D0, D2 19B56 E214 RXR.B $1, D4 19B58 4842 Swap D2 19B5A 0806 001F BTst.B $1F, D6 19B5E 6704 BEQ L4781 19B60 4A28 E600 Tst.B $-1A00(A0) 19B64 4A13 L4781: Tst.B (A3) 19B66 6AFC BPL L4781 19B68 1082 Move.B D2, (A0) ; HD20 write data 5? 19B6A 1419 Move.B (A1)+, D2 19B6C DA02 Add.B D2, D5 19B6E E212 RXR.B $1, D2 19B70 8400 Or.B D0, D2 19B72 E214 RXR.B $1, D4 19B74 4842 Swap D2 19B76 4A13 L4782: Tst.B (A3) 19B78 6AFC BPL L4782 19B7A 1083 Move.B D3, (A0) ; HD20 write data 6? 19B7C 1619 Move.B (A1)+, D3 19B7E DA03 Add.B D3, D5 19B80 E213 RXR.B $1, D3 19B82 8600 Or.B D0, D3 19B84 E214 RXR.B $1, D4 19B86 4843 Swap D3 19B88 51CF 0004 DBF D7, L4783 19B8C 224C Move.L A4, A1 19B8E 4A13 L4783: Tst.B (A3) 19B90 6AFC BPL L4783 19B92 1083 Move.B D3, (A0) ; HD20 write data 7? 19B94 1619 Move.B (A1)+, D3 19B96 DA03 Add.B D3, D5 19B98 E213 RXR.B $1, D3 19B9A 8600 Or.B D0, D3 19B9C E214 RXR.B $1, D4 19B9E 4843 Swap D3 19BA0 4844 Swap D4 19BA2 4A13 L4784: Tst.B (A3) 19BA4 6AFC BPL L4784 19BA6 1084 Move.B D4, (A0) ; HD20 write data 8? 19BA8 0886 001F BClr.B $1F, D6 19BAC 6606 BNE L4786 19BAE 51CE FF4C L4785: DBF D6, L4776 ; any more groups to write? 19BB2 603C Bra L4790 19BB4 4200 L4786: Clr.B D0 19BB6 4A13 L4787: Tst.B (A3) 19BB8 6AFC BPL L4787 19BBA 1080 Move.B D0, (A0) ; HD20 write checksum?? 19BBC 027C F8FF And $-701, SR 19BC0 303C 0010 Move $10, D0 19BC4 51C8 FFFE L4788: DBF D0, L4788 ; short delay loop 19BC8 5346 SubQ $1, D6 19BCA 4A28 0200 Tst.B $200(A0) 19BCE 4A28 FE00 Tst.B $-200(A0) 19BD2 4A10 Tst.B (A0) 19BD4 4A28 E800 Tst.B $-1800(A0) ; CA0 on??? 19BD8 303C 0010 Move $10, D0 19BDC 51C8 FFFE L4789: DBF D0, L4789 ; short delay loop 19BE0 7080 MoveQ.L $-80, D0 19BE2 007C 0700 Or $700, SR 19BE6 117C 00AA 0400 Move.B $-56, $400(A0) ; write $-56 = $AA = sync 19BEC 6000 FF0E Bra L4776 ; HD20 write the last group 19BF0 4405 L4790: Neg.B D5 ; D5 = checksum 19BF2 E215 RXR.B $1, D5 19BF4 8A00 Or.B D0, D5 ; D0 = -$80? 19BF6 4844 Swap D4 ; sets D4 = command number | LSB's 19BF8 E414 RXR.B $2, D4 19BFA 4A13 L4791: Tst.B (A3) 19BFC 6AFC BPL L4791 19BFE 1084 Move.B D4, (A0) ; HD20 write LSB's 19C00 4A13 L4792: Tst.B (A3) 19C02 6AFC BPL L4792 19C04 1081 Move.B D1, (A0) ; HD20 write command number 19C06 4841 Swap D1 19C08 4A13 L4793: Tst.B (A3) 19C0A 6AFC BPL L4793 19C0C 1081 Move.B D1, (A0) ; HD20 write sequence number 19C0E 4A13 L4794: Tst.B (A3) 19C10 6AFC BPL L4794 19C12 1082 Move.B D2, (A0) ; HD20 write data 19C14 4842 Swap D2 19C16 4A13 L4795: Tst.B (A3) 19C18 6AFC BPL L4795 19C1A 1082 Move.B D2, (A0) ; HD20 write data 19C1C 4A13 L4796: Tst.B (A3) 19C1E 6AFC BPL L4796 19C20 1083 Move.B D3, (A0) ; HD20 write data 19C22 4843 Swap D3 19C24 4A13 L4797: Tst.B (A3) 19C26 6AFC BPL L4797 19C28 1083 Move.B D3, (A0) ; HD20 write data 19C2A 4A13 L4798: Tst.B (A3) 19C2C 6AFC BPL L4798 19C2E 1085 Move.B D5, (A0) ; HD20 write checksum 19C30 4A13 L4799: Tst.B (A3) 19C32 6AFC BPL L4799 19C34 7000 MoveQ.L $0, D0 19C36 1080 Move.B D0, (A0) ; HD20 write zero 19C38 4A13 L4800: Tst.B (A3) 19C3A 6AFC BPL L4800 19C3C 1080 Move.B D0, (A0) ; HD20 write zero 19C3E 2078 01E0 Move.L (IWM), A0 19C42 4A28 0600 Tst.B $600(A0) ; CA1 on - back to state 3? 19C46 7013 MoveQ.L $13, D0 ; HD20 error 19, wrtHSHighTO: Time out waiting for HSHK to go high 19C48 7EFF MoveQ.L $-1, D7 19C4A 5347 L4801: SubQ.L $1, D7 19C4C 6708 BEQ L4802 19C4E 4A28 1C00 Tst.B $1C00(A0) ; test /HSHK 19C52 6AF6 BPL L4801 19C54 7000 MoveQ.L $0, D0 19C56 4A28 0600 L4802: Tst.B $600(A0) ; CA1 on - an error occurred, it's in D0 19C5A 4A10 Tst.B (A0) ; CA0 off - now in state 2 idle 19C5C 4CDF 72FE MoveM.L (A7)+, D1-D7/A1/A4-A6 19C60 46DF Move (A7)+, SR 19C62 4A00 Tst.B D0 19C64 4E75 Rts ; perform a power-on reset of HD20 E_Sony_DCDReset: 19C66 2F38 0B48 Move.L (JDCDReset), -(A7) 19C6A 4E75 Rts P_Sony_DCDReset: 19C6C 265F Move.L (A7)+, A3 19C6E 6100 ECBA Bsr Sony_JumpDiskSel 19C72 4A28 0A00 Tst.B $A00(A0) ; CA2 on 19C76 4A28 0400 Tst.B $400(A0) ; CA1 off 19C7A 4A10 Tst.B (A0) ; CA0 off 19C7C 303C 03E8 Move $3E8, D0 ; 1000 decimal = 100 milliseconds 19C80 6100 EB52 Bsr E_Sony_WakeUp ; HD20 state 100: RESET 19C84 4A28 0600 Tst.B $600(A0) ; CA1 on 19C88 4A28 0800 Tst.B $800(A0) ; CA2 off 19C8C 303C 4E20 Move $4E20, D0 ; 20000 decimal = 2 seconds 19C90 6100 EB42 Bsr E_Sony_WakeUp ; HD20 state 010: Idle 19C94 337C 0064 01C0 Move $64, $1C0(A1) 19C9A 337C 0640 01C2 Move $640, $1C2(A1) ; 1600 tries 19CA0 6100 E95E L4803: Bsr Sony_ReadDriveReg ; read /HSHK 19CA4 6B10 BMI L4804 ; if it's 1, we're good 19CA6 5369 01C2 SubQ $1, $1C2(A1) ; decrement try count 19CAA 6B0E BMI L4805 ; timeout, return -255 error 19CAC 3029 01C0 Move $1C0(A1), D0 19CB0 6100 EB22 Bsr E_Sony_WakeUp 19CB4 60EA Bra L4803 19CB6 7000 L4804: MoveQ.L $0, D0 19CB8 4ED3 Jmp (A3) 19CBA 4A28 1800 L4805: Tst.B $1800(A0) ; Q6 off 19CBE 70FF MoveQ.L $-1, D0 19CC0 4ED3 Jmp (A3) DT196: 19CC2 660E BNE L4962 19CC4 45E9 01F0 Lea.L $1F0(A1), A2 ; devIcon 19CC8 2051 Move.L (A1), A0 19CCA 2068 0008 Move.L $8(A0), A0 19CCE 214A 001C Move.L A2, $1C(A0) ; pointer to track data buffer?? 19CD2 6000 F974 L4962: Bra L4718 ; HD20 drive status? E_1120: 19CD6 0831 0002 101A BTst.B $2, $1A(A1,D1.W) ; driveChar iconIncluded?? 19CDC 6700 E200 BEQ Sony_ReturnErrUnimplementedControl 19CE0 41FA FFE0 Lea.L DT196, A0 19CE4 2348 0198 Move.L A0, $198(A1) ; return address for status command 19CE8 7603 L4806: MoveQ.L $3, D3 ; 3 = status. Send drive status command to DCD? 19CEA 6006 Bra L4807 E_1121: ; per dougg3, handler command 26 (decimal?) which is verify format 19CEC 761A MoveQ.L $1A, D3 19CEE 6002 Bra L4807 E_1122: 19CF0 7619 MoveQ.L $19, D3 ; command $19 (25 decimal) == what?? 19CF2 6100 EC36 L4807: Bsr Sony_JumpDiskSel ; generic routine to send command number in D3 19CF6 4A10 Tst.B (A0) ; CA0 off 19CF8 4A28 0800 Tst.B $800(A0) ; CA2 off; now in idle state 2? 19CFC 4229 01BF Clr.B $1BF(A1) ; DCD flag of whether we've done a reset 19D00 1343 019C Move.B D3, $19C(A1) ; command number 19D04 2278 0134 L4808: Move.L (SonyVars), A1 19D08 0229 003F 019C And.B $3F, $19C(A1) ; command number max is 63 decimal 19D0E 99CC SubA.L A4, A4 ; A4 = 0 19D10 9BCD SubA.L A5, A5 ; A5 = 0 19D12 7601 MoveQ.L $1, D3 19D14 7C00 MoveQ.L $0, D6 19D16 7E00 MoveQ.L $0, D7 19D18 337C 0064 01C0 Move $64, $1C0(A1) ; 100usec check ready count 19D1E 337C 4650 01C2 Move $4650, $1C2(A1) ; maximum number of checks 19D24 0C29 0003 019C Cmp.B $3, $19C(A1) ; command number 19D2A 6616 BNE L4809 19D2C 2E3C 0000 014C Move.L $14C, D7 ; magic number for D7 - size of status reply? = 332 decimal 19D32 337C 000A 01C0 Move $A, $1C0(A1) ; 100usec check ready count 19D38 337C 2710 01C2 Move $2710, $1C2(A1) ; maximum number of checks 19D3E 49E9 01C4 Lea.L $1C4(A1), A4 ; 512 byte status buffer 19D42 6100 F968 L4809: Bsr E_Sony_SendCmd 19D46 6728 BEQ L4812 19D48 0C29 0002 01BA L4810: Cmp.B $2, $1BA(A1) ; lastStatus 19D4E 6710 BEQ L4811 19D50 0829 001E 01BA BTst.B $1E, $1BA(A1) 19D56 6708 BEQ L4811 19D58 08E9 0001 01BF BSet.B $1, $1BF(A1) ; flag of whether we've done a reset. set Z if bit 1 is zero. Then set bit 1. 19D5E 66A4 BNE L4808 19D60 08E9 0000 01BF L4811: BSet.B $0, $1BF(A1) ; flag of whether we've done a reset. set Z if bit 0 is zero. Then set bit 0. 19D66 661A BNE L4813 19D68 6100 FEFC Bsr E_Sony_DCDReset 19D6C 6614 BNE L4813 19D6E 6094 Bra L4808 19D70 6100 F8E6 L4812: Bsr P882 ; await response begins here? wait for HSHK? 19D74 6BD2 BMI L4810 19D76 6100 F9DE Bsr P885 ; HD20 Read? 19D7A 4A40 Tst D0 19D7C 66CA BNE L4810 19D7E 7000 MoveQ.L $0, D0 19D80 6002 Bra L4814 19D82 70EF L4813: MoveQ.L $-11, D0 ; error -17, driver can't respond to this control call 19D84 0C29 0003 019C L4814: Cmp.B $3, $19C(A1) ; command number 19D8A 6704 BEQ L4815 19D8C 6000 F8BA Bra L4718 19D90 2069 0198 L4815: Move.L $198(A1), A0 19D94 4A40 Tst D0 19D96 4ED0 Jmp (A0) ; end of resource : 'DRVR' 4 '.Sony'