![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Sym8xxScript.lis CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Drivers / scsi / drvSymbios8xx|
Return to Sym8xxScript.lis CVS log | Up to [Apple XNU] / XNU / iokit / Drivers / scsi / drvSymbios8xx |
1.1 ! root 1: 1 ! 2: 2 ; Copyright (c) 1997-1999 Apple Computer, Inc. All rights reserved. ! 3: 3 ; ! 4: 4 ; @APPLE_LICENSE_HEADER_START@ ! 5: 5 ; ! 6: 6 ; The contents of this file constitute Original Code as defined in and ! 7: 7 ; are subject to the Apple Public Source License Version 1.1 (the ! 8: 8 ; "License"). You may not use this file except in compliance with the ! 9: 9 ; License. Please obtain a copy of the License at ! 10: 10 ; http://www.apple.com/publicsource and read it before using this file. ! 11: 11 ; ! 12: 12 ; This Original Code and all software distributed under the License are ! 13: 13 ; distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: 14 ; EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: 15 ; INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: 16 ; FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: 17 ; License for the specific language governing rights and limitations ! 18: 18 ; under the License. ! 19: 19 ; ! 20: 20 ; @APPLE_LICENSE_HEADER_END@ ! 21: 21 ; ! 22: 22 ; File Ownership: ! 23: 23 ; ! 24: 24 ; DRI: Mike Johnson ! 25: 25 ; ! 26: 26 ; Other Contact: Russ Berkoff ! 27: 27 ; ! 28: 28 ; Technology: SCSI ! 29: 29 ; ! 30: 30 ; Writers: ! 31: 31 ; ! 32: 32 ; (MLJ) Mike Johnson ! 33: 33 ; (RRA) Rick Auricchio ! 34: 34 ! 35: 35 ! 36: 36 ; NCR Errata Listing 125 Item 1 : Clear the SCNTL0 start bit ! 37: 37 ; when jump to reselect during select (try_reselect) ! 38: 38 ; ! 39: 39 ; NCR Errata Listing 117 Item 4 : Bad parity if odd bytes during ! 40: 40 ; wide transfer. Only for DATA OUT in Initiator mode. ! 41: 41 ; (Confirm by Manfred Eierle 3rd June 93 not during DATA IN) ! 42: 42 ! 43: 43 ARCH 825A ;specifically for 825a and 875 (new instructions) ! 44: 44 ! 45: 45 ! 46: 46 ;***************************************************************** ! 47: 47 ; ! 48: 48 ; Phase codes - These values represent which action is being handled ! 49: 49 ; ! 50: 50 ;***************************************************************** ! 51: 51 ! 52: 52 ABSOLUTE kphase_DATA_OUT = 0x00 ! 53: 53 ABSOLUTE kphase_DATA_IN = 0x01 ! 54: 54 ABSOLUTE kphase_COMMAND = 0x02 ! 55: 55 ABSOLUTE kphase_STATUS = 0x03 ! 56: 56 ABSOLUTE kphase_MSG_OUT = 0x06 ! 57: 57 ABSOLUTE kphase_MSG_IN = 0x07 ! 58: 58 ABSOLUTE kphase_SELECT = 0x08 ! 59: 59 ABSOLUTE kphase_RESELECT = 0x09 ! 60: 60 ABSOLUTE kphase_ABORT_CURRENT = 0x0A ! 61: 61 ABSOLUTE kphase_ABORT_MAILBOX = 0x0B ! 62: 62 ABSOLUTE kphase_CMD_COMPLETE = 0x0C ! 63: 63 ABSOLUTE kphase_DISCONNECT = 0x0D ! 64: 64 ABSOLUTE kphase_saveDataPointer = 0x0E ; ??? driver work to be done ! 65: 65 ABSOLUTE kphase_restoreDataPointer = 0x0F ; ??? driver work to be done ! 66: 66 ! 67: 67 ! 68: 68 ;***************************************************************** ! 69: 69 ; interrupt codes ! 70: 70 ;***************************************************************** ! 71: 71 ! 72: 72 ABSOLUTE unknown_phase = 0x00 ; A spurious phase on SCSI Bus ! 73: 73 ABSOLUTE status_error = 0x01 ; IO completes, but with status error ! 74: 74 ABSOLUTE unexpected_msg = 0x02 ; An 'unknown' message is in ld_message var ! 75: 75 ABSOLUTE unexpected_ext_msg = 0x03 ; An 'unknown' extended message in ld_message ! 76: 76 ABSOLUTE wide_32_not_supported = 0x04 ; The device wants 32 bits data phase ! 77: 77 ABSOLUTE no_msgin_after_reselect = 0x05 ; No message-in after reselection ! 78: 78 ABSOLUTE reqack_too_large = 0x06 ; The device answer ReqAck offset is greater than 8 ! 79: 79 ABSOLUTE unknown_reselect = 0x07 ; The valid bit in SFBR reg not set ! 80: 80 ABSOLUTE unallocated_nexus = 0x08 ; nexus index -> 0xFFFFFFFF ! 81: 81 ABSOLUTE abort_mailbox = 0x09 ; Abort/BDR mailbox completed ! 82: 82 ABSOLUTE abort_current = 0x0A ; Abort/BDR current op completed ! 83: 83 ABSOLUTE unknown_message_out = 0x0B ; Unknown phase before message out ! 84: 84 ABSOLUTE unknown_msg_reject = 0x0C ; Unknown message reject ! 85: 85 ABSOLUTE negotiateSDTR = 0x0D ; Sync negotiation rx'd ! 86: 86 ABSOLUTE negotiateWDTR = 0x0E ; Wide negotiation rx'd ! 87: 87 ABSOLUTE sglist_complete = 0x0F ; SGList complete ! 88: 88 ! 89: 89 ! 90: 90 ;***************************************************************** ! 91: 91 ; ! 92: 92 ; Data structure for T/L/Q Nexus: ! 93: 93 ; ! 94: 94 ;***************************************************************** ! 95: 95 ! 96: 96 ABSOLUTE TLQ_SCSI_ID = 0 ; 4 SCSI ID et al for SELECT instruction ! 97: 97 ABSOLUTE TLQ_xferAdr = 4 ; 4 Physical address of CHMOV instructions ! 98: 98 ABSOLUTE TLQ_MSGOp = 8 ; 8 Byte count, data adr -> TLQ_MSGO ! 99: 99 ABSOLUTE TLQ_CDBp = 16 ; 8 Byte count, data adr -> TLQ_CDB ! 100: 100 ABSOLUTE TLQ_CDP = 24 ; 4 Current Data Pointer ! 101: 101 ABSOLUTE TLQ_SDP = 28 ; 4 Saved Data Pointer ! 102: 102 ABSOLUTE TLQ_index = 32 ; 1 index into nexus array ! 103: 103 ABSOLUTE TLQ_xferStarted= 33 ; 1 transfer started flag ! 104: 104 ABSOLUTE TLQ_IWR = 34 ; 1 flag to Ignore Wide Residue ! 105: 105 ABSOLUTE TLQ_pad = 35 ; 1 pad byte ! 106: 106 ! 107: 107 ! 108: 108 ;***************************************************************** ! 109: 109 ; ! 110: 110 ; ENTRY declarations - Declare entry points for driver ! 111: 111 ; ! 112: 112 ;***************************************************************** ! 113: 113 ! 114: 114 ENTRY select_phase ! 115: 115 ENTRY phase_handler ! 116: 116 ENTRY issueMessageOut ; for negotiation and Reject messages ! 117: 117 ENTRY issueAbort_BDR ; to immediately Abort or Bus-Device-Reset ! 118: 118 ENTRY clearACK ; MsgIn done - clr ACK, jump to phase handler ! 119: 119 ! 120: 120 ! 121: 121 ;***************************************************************** ! 122: 122 ; ! 123: 123 ; Define local data structure at start of SCRIPTS. ! 124: 124 ; This structure is allocated by the following nops. ! 125: 125 ; ! 126: 126 ;***************************************************************** ! 127: 127 ; ! 128: 128 ! 129: 129 RELATIVE local_data \ ! 130: 130 00000000: ld_AbortCode = 4{??}\ ; 1 byte code to Abort or BDR ! 131: 131 00000004: ld_zeroes = 4{??}\ ; 4 bytes of 0 to clear registers ! 132: 132 00000008: ld_status = 4{??}\ ; Status byte from target ! 133: 133 0000000C: ld_counter = 4{??}\ ; index into mailbox array ! 134: 134 00000010: ld_AbortBdr_mailbox = 4{??}\ ; Abort/BusDeviceReset mailbox ! 135: 135 00000014: ld_IOdone_mailbox = 4{??}\ ; [ nexus 0 0 semaphore ] ! 136: 136 00000018: ld_sched_mlbx_base_adr = 4{??}\ ; base addr of mailbox array ! 137: 137 0000001C: ld_mailboxp = 4{??}\ ; address of current mailbox ! 138: 138 00000020: ld_scsi_id = 4{??}\ ; ptr to current mailbox ! 139: 139 00000024: ld_nexus_array_base = 4{??}\ ; base address of Nexus pointers ! 140: 140 00000028: ld_nexus_index = 4{??}\ ; index to Nexus pointer ! 141: 141 0000002C: ld_nexus = 4{??}\ ; address of Nexus ! 142: 142 00000030: ld_phase_flag = 4{??}\ ; for debugging ! 143: 143 00000034: ld_device_table_base_adr = 4{??}\ ; device configuration table ! 144: 144 00000038: ld_scratch = 4{??}\ ; scratch memory ! 145: 145 0000003C: ld_unused = 4{??}\ ; unused ! 146: 146 00000040: ld_message = 4{??}\ ; buffer for MsgIn bytes ! 147: 147 00000044: ld_message4 = 4{??}\ ; buffer continuation ! 148: 148 00000048: ld_pad = 4{??}\ ; padding ! 149: 149 0000004C: ld_size = 4{??} ; size of this structure ! 150: 150 ! 151: 151 ! 152: 152 00000000: PROC BSC_SCRIPT: ! 153: 153 ! 154: 154 ; *** These NOPs must be at address 0. *** ! 155: 155 ; *** This is reserved space for the structure "local_data". *** ! 156: 156 ; *** The driver inits this area to zero. *** ! 157: 157 ! 158: 158 00000000: 80000000 00000000 nop 0 ; ld_AbortCode, ld_zeroes ! 159: 159 00000008: 80000000 00000000 nop 0 ; ld_status, ld_counter ! 160: 160 ! 161: 161 00000010: 80000000 00000000 nop 0 ; ld_AbortBdr_mailbox, ld_IOdone_mailbox ! 162: 162 00000018: 80000000 00000000 nop 0 ; ld_sched_mlbx_base_adr, ld_mailboxp ! 163: 163 ! 164: 164 00000020: 80000000 00000000 nop 0 ; ld_scsi_id, ld_nexus_array_base ! 165: 165 00000028: 80000000 00000000 nop 0 ; ld_nexus_index, ld_nexus ! 166: 166 ! 167: 167 00000030: 80000000 00000000 nop 0 ; ld_phase_flag, ld_device_table_base_adr ! 168: 168 00000038: 80000000 00000000 nop 0 ; ld_scratch, ld_unused ! 169: 169 ! 170: 170 00000040: 80000000 00000000 nop 0 ; ld_message, ld_message4 ! 171: 171 00000048: 80000000 0000004C nop ld_size ; ld_pad, ld_size (Use ld_size or lose it) ! 172: 172 ! 173: 173 00000050: 80000000 0000000F nop sglist_complete ; use sglist_complete or lose it from gen'd output file ! 174: 174 ! 175: 175 ;**************************************************************************** ! 176: 176 ; ! 177: 177 ; findNexusFromIndex - load DSA with pointer to Nexus given a Nexus index: ! 178: 178 ; ! 179: 179 ;**************************************************************************** ! 180: 180 ! 181: 181 00000058: findNexusFromIndex: ! 182: 182 ! 183: 183 00000058: E1340004 00000028 load SCRATCHA0, 4, ld_nexus_index ; load index and leading zeroes ! 184: 184 00000060: 60000400 00000000 clear CARRY ! 185: 185 00000068: 79340000 00000000 move SCRATCHA0 SHL 0 to SCRATCHA0 ; double the index ! 186: 186 00000070: 79350000 00000000 move SCRATCHA1 SHL 0 to SCRATCHA1 ! 187: 187 00000078: 79340000 00000000 move SCRATCHA0 SHL 0 to SCRATCHA0 ; double again ! 188: 188 00000080: 79350000 00000000 move SCRATCHA1 SHL 0 to SCRATCHA1 ; A0 now has index to 4-byte address ! 189: 189 00000088: E0340004 0000009C store SCRATCHA0, 4, patchArrayOffset+4 ; *** patch the code ! 190: 190 ! 191: 191 00000090: E1100004 00000024 load DSA0, 4, ld_nexus_array_base ; load base address of array of Nexus pointers ! 192: 192 00000098: patchArrayOffset: ! 193: 193 00000098: F1100004 00000000 load DSA0, 4, DSAREL( 0 ) ; *** patched offset. Load pointer. ! 194: 194 ! 195: 195 000000A0: 72100000 00000000 move DSA0 to SFBR ; Ensure pointer is not 0xFFFFFFFF ! 196: 196 000000A8: 980C00FF 00000008 int unallocated_nexus, if 0xFF ; Interrupt if NFG ! 197: 197 ! 198: 198 000000B0: E0100004 0000002C store DSA0, 4, ld_nexus ; Store the Nexus pointer ! 199: 199 000000B8: 90080000 00000000 return ; end findNexusFromIndex ! 200: 200 ! 201: 201 ! 202: 202 ;**************************************************************************** ! 203: 203 ; ! 204: 204 ; initContext - Initialize the registers for Sync and Wide using ! 205: 205 ; values stored in the device configuration table. ! 206: 206 ; Return with values in SCRATCHB for Select code. ! 207: 207 ; ! 208: 208 ;**************************************************************************** ! 209: 209 ! 210: 210 000000C0: initContext: ! 211: 211 ! 212: 212 000000C0: E15C0004 00000020 load SCRATCHB0, 4, ld_scsi_id ; load 4-bit SCSI ID and zeroes ! 213: 213 000000C8: 60000400 00000000 clear CARRY ! 214: 214 000000D0: 795C0000 00000000 move SCRATCHB0 SHL SCRATCHB0 ; * 2 ! 215: 215 000000D8: 795C0000 00000000 move SCRATCHB0 SHL SCRATCHB0 ; * 2 -> UInt32 index ! 216: 216 000000E0: E05C0004 000000F4 store SCRATCHB0, 4, patchGetDevConfigOffset+4 ; *** Patch load code ! 217: 217 ! 218: 218 000000E8: E1100004 00000034 load DSA0, 4, ld_device_table_base_adr ; load base physical addr of tables ! 219: 219 ! 220: 220 000000F0: patchGetDevConfigOffset: ! 221: 221 000000F0: F15C0004 00000000 load SCRATCHB0, 4, DSAREL( 0 ) ; *** Patched table offset *** ! 222: 222 ! 223: 223 ; SCRATCHB0 = 0 ! 224: 224 ; SCRATCHB1 = TP,MO (SXFER bits7-5 bits3-0) ! 225: 225 ; SCRATCHB2 = 0 (position for SCSI ID) ! 226: 226 ; SCRATCHB3 = SCCF,EWS (SCNTL3 bits6-4 bit 3) ! 227: 227 ! 228: 228 000000F8: 725D0000 00000000 move SCRATCHB1 to SFBR ; init SXFER from B1 ! 229: 229 00000100: 6A050000 00000000 move SFBR to SXFER ! 230: 230 ; Init SCNTL3 from B3 ! 231: 231 00000108: 725F0000 00000000 move SCRATCHB3 to SFBR ! 232: 232 00000110: 6A030000 00000000 move SFBR to SCNTL3 ! 233: 233 00000118: 90080000 00000000 return ; return with SCRATCHB intact. ! 234: 234 ! 235: 235 ! 236: 236 ;***************************************************************** ! 237: 237 ; ! 238: 238 ; Select_phase: ! 239: 239 ; Clear the SIGP bit. ! 240: 240 ; Check if any Abort/BusDeviceReset request waiting. ! 241: 241 ; Nexus is found in the list of 256 mailboxes. ! 242: 242 ; If current mailbox is empty, jump to reselect_phase. ! 243: 243 ; SCRIPTS tries to select device. ! 244: 244 ; If select fails due to reselect, jump to reselect_phase ! 245: 245 ; Select Timeout handled by driver. ! 246: 246 ; If select succeeds, clear the mailbox entry ! 247: 247 ; and increment the mailbox counter. ! 248: 248 ; Jump to the phase_handler (hopefully for MSG_OUT) ! 249: 249 ; ! 250: 250 ;***************************************************************** ! 251: 251 ! 252: 252 00000120: select_phase: ! 253: 253 ! 254: 254 00000120: 7A1A0000 00000000 move CTEST2 | 0x00 to CTEST2 ; Clear SIGP bit from ISTAT reg ! 255: 255 ! 256: 256 ; Check abort mailbox: ! 257: 257 ! 258: 258 00000128: E1340004 00000010 load SCRATCHA0, 4, ld_AbortBdr_mailbox ; Get AbortBdr mailbox ! 259: 259 ; The Identify byte in byte 0 is also the semaphore ! 260: 260 ; A0 = Identify byte (0xC0 + LUN N.B. Disconnect allowed) ! 261: 261 ; A1 = Tag, if any ! 262: 262 ; A2 = SCSI ID ! 263: 263 ; A3 = Abort code Abort=0x06; Abort Tag=0D; Bus Device Reset=0x0C ! 264: 264 00000130: 72340000 00000000 move SCRATCHA0 to SFBR ; test the semaphore/Identify ! 265: 265 00000138: 80840000 000005F0 jump rel( AbortMailbox ), if not 0 ; jump if aborting ! 266: 266 ! 267: 267 ! 268: 268 ; Get the next IO nexus in the mailboxes circular list. ! 269: 269 ; Calculate current mailbox address as so: ! 270: 270 ; counter byte index * 4 to get mailbox index ! 271: 271 ; add base physical address of mailboxes giving current mailbox address ! 272: 272 ! 273: 273 00000140: E1340004 0000000C load SCRATCHA0, 4, ld_counter ; get 1-byte mailbox counter & 0s ! 274: 274 00000148: 60000400 00000000 clear CARRY ! 275: 275 00000150: 79340000 00000000 move SCRATCHA0 SHL 0 to SCRATCHA0 ; double it ! 276: 276 00000158: 79350000 00000000 move SCRATCHA1 SHL 0 to SCRATCHA1 ! 277: 277 00000160: 79340000 00000000 move SCRATCHA0 SHL 0 to SCRATCHA0 ; double it again ! 278: 278 00000168: 79350000 00000000 move SCRATCHA1 SHL 0 to SCRATCHA1 ; now have a UInt32 index ! 279: 279 00000170: E0340004 0000018C store SCRATCHA0, 4, fetchMailbox+4 ; *** patch the load DSA instruction ! 280: 280 00000178: E0340004 0000025C store SCRATCHA0, 4, clear_mailbox+4 ; *** patch the store DSA instruction ! 281: 281 ! 282: 282 00000180: E1100004 00000018 load DSA0, 4, ld_sched_mlbx_base_adr ; load base physical address of mailboxes ! 283: 283 ! 284: 284 00000188: fetchMailbox: ! 285: 285 00000188: F1100004 00000000 load DSA0, 4, DSAREL( 0 ) ; *** Patched offset. Load Nexus address ! 286: 286 00000190: E0100004 0000002C store DSA0, 4, ld_nexus ; save pointer to current Nexus ! 287: 287 00000198: E1340004 0000002C load SCRATCHA0, 4, ld_nexus ; copy to A0 ! 288: 288 ! 289: 289 000001A0: 72340000 00000000 move SCRATCHA0 to SFBR ; ! 290: 290 000001A8: 808C0001 00000098 jump rel( next_mailbox ), if 1 ; if low-byte == 0x01 then cancelled mailbox ! 291: 291 ! 292: 292 000001B0: 72B50000 00000000 move SCRATCHA1 | SFBR to SFBR ; if non-zero, have implicit semaphore ! 293: 293 000001B8: 72B60000 00000000 move SCRATCHA2 | SFBR to SFBR ! 294: 294 000001C0: 72B70000 00000000 move SCRATCHA3 | SFBR to SFBR ! 295: 295 000001C8: 808C0000 00000458 jump rel( reselect_phase ), if 0 ; go to reselect_phase if empty ! 296: 296 ! 297: 297 ;***************************************************************** ! 298: 298 ; ! 299: 299 ; Something in mailbox: we have work to do ! 300: 300 ; ! 301: 301 ;***************************************************************** ! 302: 302 ! 303: 303 000001D0: 785C0800 00000000 move kphase_SELECT to SCRATCHB0 ; set phase indicator ! 304: 304 000001D8: E05C0001 00000030 store SCRATCHB0, 1, ld_phase_flag ! 305: 305 ! 306: 306 000001E0: E15C0004 00000004 load SCRATCHB0, 4, ld_zeroes ; clr the invalid-nexus-index flag ! 307: 307 000001E8: F15C0001 00000020 load SCRATCHB0, 1, DSAREL( TLQ_index ) ; get index byte from nexus ! 308: 308 000001F0: E05C0004 00000028 store SCRATCHB0, 4, ld_nexus_index ; save it in local data ! 309: 309 ! 310: 310 000001F8: E1100004 0000002C load DSA0, 4, ld_nexus ; restore DSA register ! 311: 311 00000200: F15E0001 00000002 load SCRATCHB2, 1, DSAREL( TLQ_SCSI_ID+2 ) ; get Target's SCSI ID ! 312: 312 00000208: 725E0000 00000000 move SCRATCHB2 to SFBR ! 313: 313 00000210: 6A5C0000 00000000 move SFBR to SCRATCHB0 ; position it ! 314: 314 00000218: E05C0001 00000020 store SCRATCHB0, 1, ld_scsi_id ; save it ! 315: 315 00000220: 88880000 FFFFFE98 call rel( initContext ) ; setup Sync/Wide regs in SCRATCHB ! 316: 316 00000228: E1100004 0000002C load DSA0, 4, ld_nexus ; restore DSA register ! 317: 317 00000230: F05D0001 00000001 store SCRATCHB1, 1, DSAREL( TLQ_SCSI_ID+1 ) ; SXFER ! 318: 318 00000238: F05F0001 00000003 store SCRATCHB3, 1, DSAREL( TLQ_SCSI_ID+3 ) ; SCNTL3 ! 319: 319 ! 320: 320 ;********************** select the device ******************************** ! 321: 321 00000240: 47000000 000003D0 SELECT ATN from TLQ_SCSI_ID, rel( try_reselect ) ; ************************ ! 322: 322 ;************************************************************************* ! 323: 323 ! 324: 324 ; looking good - clear the mailbox: ! 325: 325 ! 326: 326 00000248: next_mailbox: ! 327: 327 00000248: E1340004 00000004 load SCRATCHA0, 4, ld_zeroes ; zero out scratch register A ! 328: 328 00000250: E1100004 00000018 load DSA0, 4, ld_sched_mlbx_base_adr ; load base physical address of mailboxes ! 329: 329 00000258: clear_mailbox: ! 330: 330 00000258: F0340004 00000000 store SCRATCHA0, 4, DSAREL( 0 ) ; *** Patched offset. Zero the mailbox ! 331: 331 ! 332: 332 ; Update the index to the mailbox circular list: ! 333: 333 00000260: E15C0001 0000000C load SCRATCHB0, 1, ld_counter ; get counter (mailbox index) ! 334: 334 00000268: 7E5C0100 00000000 move SCRATCHB0 + 1 to SCRATCHB0 ; add 1 ! 335: 335 00000270: E05C0001 0000000C store SCRATCHB0, 1, ld_counter ; put it back ! 336: 336 ! 337: 337 00000278: E15C0001 0000002C load SCRATCHB0, 1, ld_nexus ; if low-byte == 0x01 then cancelled mailbox ! 338: 338 00000280: 725C0000 00000000 move SCRATCHB0 to SFBR ! 339: 339 00000288: 808C0001 FFFFFE90 jump rel( select_phase ), if 1 ! 340: 340 ! 341: 341 ; *** FALL THROUGH TO phase_handler *** ! 342: 342 ! 343: 343 ! 344: 344 ;***************************************************************** ! 345: 345 ; ! 346: 346 ; Phase_handler ! 347: 347 ; The phase handler script is a dispatcher function of SCSI phase ! 348: 348 ; ! 349: 349 ;***************************************************************** ! 350: 350 ! 351: 351 00000290: phase_handler: ! 352: 352 00000290: E1100004 0000002C load DSA0, 4, ld_nexus ; reload DSA ! 353: 353 00000298: 828B0000 00000088 jump rel( command_phase ), when CMD ; wait for REQ ! 354: 354 000002A0: 808A0000 000000A8 jump rel( data_out_phase ), if DATA_OUT ; already latched REQ signal ! 355: 355 000002A8: 868A0000 00000020 jump rel( message_out_phase ), if MSG_OUT ! 356: 356 000002B0: 818A0000 000000E0 jump rel( data_in_phase ), if DATA_IN ! 357: 357 000002B8: 838A0000 00000108 jump rel( status_phase ), if STATUS ! 358: 358 000002C0: 878A0000 00000120 jump rel( message_in_phase ), if MSG_IN ! 359: 359 000002C8: 98080000 00000000 int unknown_phase ! 360: 360 ! 361: 361 ! 362: 362 ;***************************************************************** ! 363: 363 ; ! 364: 364 ; Message-Out phase ! 365: 365 ; ! 366: 366 ;***************************************************************** ! 367: 367 ! 368: 368 000002D0: message_out_phase: ! 369: 369 000002D0: 785C0600 00000000 move kphase_MSG_OUT to SCRATCHB0 ; Set phase indicator ! 370: 370 000002D8: E05C0001 00000030 store SCRATCHB0, 1, ld_phase_flag ! 371: 371 ! 372: 372 000002E0: 1E000000 00000008 move from TLQ_MSGOp, when MSG_OUT ; put out the message(s) ! 373: 373 000002E8: 80880000 FFFFFFA0 jump rel( phase_handler ) ! 374: 374 ! 375: 375 ! 376: 376 ; issueMessageOut - Driver entry point for Sync/Wide negotiation and ! 377: 377 ; to issue message Reject: ! 378: 378 ! 379: 379 000002F0: issueMessageOut: ! 380: 380 000002F0: 58000008 00000000 set ATN ; tell Target we have something to say ! 381: 381 000002F8: 60000040 00000000 clear ACK ! 382: 382 00000300: 868B0000 FFFFFFC8 jump rel( message_out_phase ), when MSG_OUT ; wait for REQ. Jump if msg-out phase. ! 383: 383 00000308: 87820000 FFFFFF80 jump rel( phase_handler ), if not MSG_IN ; jump if weird phase ! 384: 384 00000310: 0F000001 00000039 move 1, ld_scratch+1, when MSG_IN ; dump the msg byte ! 385: 385 00000318: 60000040 00000000 clear ACK ; accept Target's last msg-in byte ! 386: 386 00000320: 80880000 FFFFFFC8 jump rel( issueMessageOut ) ! 387: 387 ! 388: 388 ! 389: 389 ;***************************************************************** ! 390: 390 ; ! 391: 391 ; Command phase ! 392: 392 ; ! 393: 393 ;***************************************************************** ! 394: 394 ! 395: 395 00000328: command_phase: ! 396: 396 00000328: 785C0200 00000000 move kphase_COMMAND to SCRATCHB0 ; Set phase indicator ! 397: 397 00000330: E05C0001 00000030 store SCRATCHB0, 1, ld_phase_flag ! 398: 398 ! 399: 399 00000338: 60000008 00000000 clear ATN ; In case we missed the sending nego ! 400: 400 00000340: 1A000000 00000010 move FROM TLQ_CDBp, when CMD ; issue the CDB ! 401: 401 00000348: 80880000 FFFFFF40 jump rel( phase_handler ) ! 402: 402 ! 403: 403 ! 404: 404 ;***************************************************************** ! 405: 405 ; ! 406: 406 ; Data_out_phase ! 407: 407 ; ! 408: 408 ;***************************************************************** ! 409: 409 ! 410: 410 00000350: data_out_phase: ! 411: 411 00000350: 785C0000 00000000 move kphase_DATA_OUT to SCRATCHB0 ; Set phase indicator ! 412: 412 00000358: E05C0001 00000030 store SCRATCHB0, 1, ld_phase_flag ! 413: 413 ! 414: 414 00000360: 88880000 00000008 call rel( driverXfer ) ; call driver-built CHMOV instructions ! 415: 415 00000368: 80880000 FFFFFF20 jump rel( phase_handler ) ; if all data xfer'd, get next phase ! 416: 416 ! 417: 417 00000370: driverXfer: ; get here from data-in code also ! 418: 418 00000370: F1340004 00000004 load SCRATCHA0, 4, DSAREL( TLQ_xferAdr ) ! 419: 419 00000378: E0340004 00000394 store SCRATCHA0, 4, doItPatch+4 ; *** patch the JUMP address ! 420: 420 00000380: 7835FF00 00000000 move 0xFF to SCRATCHA1 ! 421: 421 00000388: F0350001 00000021 store SCRATCHA1, 1, DSAREL( TLQ_xferStarted ) ! 422: 422 ! 423: 423 00000390: doItPatch: ! 424: 424 00000390: 80080000 00000333 jump 0x0333 ; *** patched address ! 425: 425 ! 426: 426 ! 427: 427 ! 428: 428 ;***************************************************************** ! 429: 429 ; ! 430: 430 ; Data_in_phase ! 431: 431 ; 875 sets ATN if bad parity detected. ! 432: 432 ; Use of CHMOV instructions assures that we properly handle ! 433: 433 ; a leftover wide byte in the SWIDE or SODL register, depending ! 434: 434 ; on the data direction. This can happen in either of two conditions: ! 435: 435 ; 1. The Target disconnects at an odd boundary. This is ! 436: 436 ; extremely unlikely with disk devices. ! 437: 437 ; 2. The client passes either an odd buffer address or ! 438: 438 ; an odd transfer count. When the Target disconnects (at ! 439: 439 ; an even boundary, we end up with the extra wide ! 440: 440 ; byte in SWIDE or SODL. MacOS does this with VM on. ! 441: 441 ; ! 442: 442 ;***************************************************************** ! 443: 443 ! 444: 444 00000398: data_in_phase: ! 445: 445 00000398: 785C0100 00000000 move kphase_DATA_IN to SCRATCHB0 ; Set phase indicator ! 446: 446 000003A0: E05C0001 00000030 store SCRATCHB0, 1, ld_phase_flag ! 447: 447 ! 448: 448 000003A8: 88880000 FFFFFFC0 call rel( driverXfer ) ; call driver-built CHMOV instructions ! 449: 449 ! 450: 450 ; The driver gets interrupted if a phase mismatch occurs as when ! 451: 451 ; the Target goes MSG-IN with a Disconnect. ! 452: 452 ; The driver codes either a RETURN if the Scatter/Gather list is complete or ! 453: 453 ; an INT if more Scatter/Gather elements need to be generated. ! 454: 454 ; On the Macintosh, client programs expect extra incoming data to be dumped. ! 455: 455 ; For example, during boot the ROM reads 512 bytes from a 2K-byte-sector CD. ! 456: 456 ! 457: 457 000003B0: bucket_loop: ! 458: 458 000003B0: 81830000 FFFFFED8 jump rel( phase_handler ), when not DATA_IN ; wait for phase, exit if changed ! 459: 459 000003B8: 01000001 00000008 CHMOV 1, ld_status, when DATA_IN ; eat a byte ! 460: 460 000003C0: 80880000 FFFFFFE8 jump rel( bucket_loop ); ; keep dumping bytes ! 461: 461 ! 462: 462 ! 463: 463 ;***************************************************************** ! 464: 464 ; ! 465: 465 ; Status phase ! 466: 466 ; ! 467: 467 ;***************************************************************** ! 468: 468 ! 469: 469 000003C8: status_phase: ! 470: 470 000003C8: 785C0300 00000000 move kphase_STATUS to SCRATCHB0 ; Set phase indicator ! 471: 471 000003D0: E05C0001 00000030 store SCRATCHB0, 1, ld_phase_flag ! 472: 472 ! 473: 473 000003D8: 0B000001 00000008 move 1, ld_status, when STATUS ; Read Status byte from bus ! 474: 474 000003E0: 80880000 FFFFFEA8 jump rel( phase_handler ) ! 475: 475 ! 476: 476 ! 477: 477 ;***************************************************************** ! 478: 478 ; ! 479: 479 ; Message-In phase ! 480: 480 ; ! 481: 481 ;***************************************************************** ! 482: 482 ! 483: 483 000003E8: message_in_phase: ! 484: 484 000003E8: 785C0700 00000000 move kphase_MSG_IN to SCRATCHB0 ; Set phase indicator ! 485: 485 000003F0: E05C0001 00000030 store SCRATCHB0, 1, ld_phase_flag ! 486: 486 ! 487: 487 000003F8: 0F000001 00000040 move 1, ld_message, when MSG_IN ; Read byte from bus ! 488: 488 ! 489: 489 00000400: 808C0000 000000C0 jump rel( cmdComplete ), if 0x00 ; Command Complete ! 490: 490 00000408: 808C0002 000001A8 jump rel( saveDataPointer ), if 0x02 ; Save Data Pointer ! 491: 491 00000410: 808C0004 00000148 jump rel( disconnect_msg ), if 0x04 ; Disconnect ! 492: 492 00000418: 808C0023 00000038 jump rel( ignoreWideResidue ), if 0x23 ; Ignore Wide Residue ! 493: 493 00000420: 808C0003 000001B0 jump rel( restoreDataPointer ), if 0x03 ; Restore Data Pointer ! 494: 494 00000428: 808C0001 00000058 jump rel( extended_msg ), if 0x01 ; Extended message ! 495: 495 00000430: 808C0007 00000008 jump rel( msg_reject ), if 0x07 ; Message Reject ! 496: 496 ; Identify, if 0x80-FF ; Identify + LUN ! 497: 497 ; simple_queue_tag, if 0x20 ; Simple Queue Tag ! 498: 498 ; initiate_recovery, if 0x0F ; Initiate Recovery ! 499: 499 ; linked_cde_complete, if 0x0A/0x0B ! 500: 500 00000438: 98080000 00000002 int unexpected_msg ; unknown ! 501: 501 ! 502: 502 00000440: msg_reject: ! 503: 503 00000440: 98080000 0000000C int unknown_msg_reject ! 504: 504 ! 505: 505 00000448: clearACK: ; ENTRY point to end negotiation ! 506: 506 00000448: 60000040 00000000 clear ACK ! 507: 507 00000450: 80880000 FFFFFE38 jump rel( phase_handler ) ! 508: 508 ! 509: 509 ! 510: 510 ! 511: 511 ;***************************************************************** ! 512: 512 ; ! 513: 513 ; Ignore Wide Residue ! 514: 514 ; ! 515: 515 ;***************************************************************** ! 516: 516 ! 517: 517 00000458: ignoreWideResidue: ; this is a two byte message so snag the 2nd byte here ! 518: 518 00000458: 60000040 00000000 clear ACK ! 519: 519 00000460: 0F000001 00000041 move 1, ld_message+1, when MSG_IN ; save residue count ! 520: 520 00000468: 6A5E0000 00000000 move SFBR to SCRATCHB2 ; byte is still in SFBR. Position it. ! 521: 521 00000470: F05E0001 00000022 store SCRATCHB2, 1, DSAREL( TLQ_IWR ) ; Store residue count in Nexus for driver. ! 522: 522 00000478: 60000040 00000000 clear ACK ! 523: 523 00000480: 80880000 FFFFFE08 jump rel( phase_handler ) ! 524: 524 ! 525: 525 ! 526: 526 ;***************************************************************** ! 527: 527 ; ! 528: 528 ; Extended message ! 529: 529 ; Accept Wide and Synchronous Data Transfer messages ! 530: 530 ; ! 531: 531 ;***************************************************************** ! 532: 532 ! 533: 533 00000488: extended_msg: ! 534: 534 00000488: 60000040 00000000 clear ACK ! 535: 535 00000490: 0F000001 00000041 move 1, ld_message+1, when MSG_IN ; read msg length byte from bus ! 536: 536 00000498: 60000040 00000000 clear ACK ! 537: 537 000004A0: 0F000001 00000042 move 1, ld_message+2, when MSG_IN ; read ext msg code from bus ! 538: 538 000004A8: 60000040 00000000 clear ACK ! 539: 539 ; extended_identify, IF 0x02 ! 540: 540 ; modify_data_pointer, if 0x00 ! 541: 541 000004B0: 808C0001 00000140 jump rel( sdtr ), if 0x01 ; jump if SDTR, sync negotiation msg ! 542: 542 000004B8: 808C0003 00000148 jump rel( wdtr ), if 0x03 ; jump if WDTR, wide negotiation msg ! 543: 543 000004C0: 98080000 00000003 int unexpected_ext_msg ; let driver deal with unknown ! 544: 544 ! 545: 545 ! 546: 546 ;***************************************************************** ! 547: 547 ; ! 548: 548 ; Command complete ! 549: 549 ; The Command-Complete message is sent to indicate that the ! 550: 550 ; IO operation has completed and valid status has been sent. ! 551: 551 ; The Target should then disconnect. ! 552: 552 ; SCRIPTS must spin until the IOdone mailbox is empty. ! 553: 553 ; Then it sets the IOdone mailbox with the current Nexus. ! 554: 554 ; The status message is analyzed. ! 555: 555 ; If status is good, INTF the driver and jump to select_phase. ! 556: 556 ; If status is NG, save it in the NEXUS and INT the driver. ! 557: 557 ; ! 558: 558 ;***************************************************************** ! 559: 559 ! 560: 560 000004C8: cmdComplete: ! 561: 561 000004C8: 785C0C00 00000000 move kphase_CMD_COMPLETE to SCRATCHB0 ; Set phase indicator ! 562: 562 000004D0: E05C0001 00000030 store SCRATCHB0, 1, ld_phase_flag ! 563: 563 ! 564: 564 000004D8: 7C027F00 00000000 move SCNTL2 & 0X7F to SCNTL2 ; Clr SDU: SCSI Disconnect Unexpected ! 565: 565 000004E0: 60000040 00000000 clear ACK ! 566: 566 000004E8: 48000000 00000000 WAIT DISCONNECT ! 567: 567 ! 568: 568 000004F0: testMbxLp: ; loop until IOdone mailbox empty ! 569: 569 000004F0: E1340004 00000014 load SCRATCHA0, 4, ld_IOdone_mailbox ! 570: 570 000004F8: 72370000 00000000 move SCRATCHA3 to SFBR ; A3 = semaphore ! 571: 571 00000500: 80840000 FFFFFFE8 jump rel( testMbxLp ), if not 0 ! 572: 572 ! 573: 573 ; Fill in the IOdone mailbox with the following: ! 574: 574 ; A0 = index to Nexus ! 575: 575 ; A1 = Status ! 576: 576 ; A2 = 0 ! 577: 577 ; A3 = semaphore (FF = set) ! 578: 578 00000508: E1340001 00000028 load SCRATCHA0, 1, ld_nexus_index ; A0 = index to Nexus ! 579: 579 00000510: E15C0001 00000008 load SCRATCHB0, 1, ld_status ! 580: 580 00000518: 725C0000 00000000 move SCRATCHB0 to SFBR ! 581: 581 00000520: 6A350000 00000000 move SFBR to SCRATCHA1 ; A1 = Status ! 582: 582 00000528: 78360000 00000000 move 0x00 to SCRATCHA2 ; A2 = 0 ! 583: 583 00000530: 7837FF00 00000000 move 0xFF to SCRATCHA3 ; A3 = semaphore IOdone mailbox ! 584: 584 00000538: E0340004 00000014 store SCRATCHA0, 4, ld_IOdone_mailbox ! 585: 585 ! 586: 586 00000540: 72350000 00000000 move SCRATCHA1 to SFBR ; Test the Status of this IO ! 587: 587 ; SFBR = status msg ! 588: 588 ; Test status - If good, Interrupt on the fly and jump to select phase ! 589: 589 00000548: 981CC100 000000FF intfly 0xFF, if 0 and mask 0xC1 ; mask off reserved bits ! 590: 590 00000550: 808CC100 FFFFFBC8 jump rel( select_phase ), if 0 and mask 0xC1 ! 591: 591 00000558: 98080000 00000001 int status_error ; Status err. Interrupt driver & stop ! 592: 592 ! 593: 593 ! 594: 594 ;***************************************************************** ! 595: 595 ; ! 596: 596 ; Disconnect ! 597: 597 ; The 8xx Accepts the disconnection and jumps to the select_phase ! 598: 598 ; to check for another IO ! 599: 599 ; ! 600: 600 ;***************************************************************** ! 601: 601 ! 602: 602 00000560: disconnect_msg: ! 603: 603 00000560: E15C0001 00000030 load SCRATCHB0, 1, ld_phase_flag ! 604: 604 00000568: 725C0000 00000000 move SCRATCHB0 to SFBR ! 605: 605 ; If we got here from reselect just bailout since ld_nexus is ! 606: 606 ; not setup and the code using it is not needed anyway (no data xfer) ! 607: 607 00000570: 808C0009 00000010 jump rel( bailout ), if kphase_RESELECT ! 608: 608 ! 609: 609 00000578: 785C0D00 00000000 move kphase_DISCONNECT to SCRATCHB0 ! 610: 610 00000580: E05C0001 00000030 store SCRATCHB0, 1, ld_phase_flag ! 611: 611 ! 612: 612 00000588: bailout: ! 613: 613 00000588: 785FFF00 00000000 move 0xFF to SCRATCHB3 ; invalidate nexus index for driver ! 614: 614 00000590: E05F0001 0000002B store SCRATCHB3, 1, ld_nexus_index+3 ! 615: 615 00000598: 7C027F00 00000000 move SCNTL2 & 0x7F to SCNTL2 ; Clr SDU: SCSI Disconnect Unexpected ! 616: 616 000005A0: 60000040 00000000 clear ACK ! 617: 617 000005A8: 48000000 00000000 WAIT DISCONNECT ; wait for bus-free ! 618: 618 000005B0: 80880000 FFFFFB68 jump rel( select_phase ) ; go see if more to do ! 619: 619 ! 620: 620 ! 621: 621 ;****************************************************************** ! 622: 622 ; ! 623: 623 ; ??? mlj - saveDataPointer and restoreDataPointer are incorrect. ! 624: 624 ; ??? They basically do nothing. ! 625: 625 ; Save Data Pointer ! 626: 626 ; ! 627: 627 ;***************************************************************** ! 628: 628 ! 629: 629 000005B8: saveDataPointer: ! 630: 630 000005B8: 785C0E00 00000000 move kphase_saveDataPointer to SCRATCHB0 ! 631: 631 000005C0: E05C0001 00000030 store SCRATCHB0, 1, ld_phase_flag ! 632: 632 000005C8: 60000040 00000000 clear ACK ! 633: 633 000005D0: 80880000 FFFFFCB8 jump rel( phase_handler ) ! 634: 634 ! 635: 635 ! 636: 636 ;****************************************************************** ! 637: 637 ; ! 638: 638 ; ??? mlj - saveDataPointer and restoreDataPointer are incorrect. ! 639: 639 ; ??? They basically do nothing. ! 640: 640 ; Restore Data Pointer ! 641: 641 ; The local values still blocks, still bytes and data address ! 642: 642 ; must be loaded from the corresponding NEXUS data set. ! 643: 643 ; This message should followed an IDE (parity error) ! 644: 644 ; ! 645: 645 ;***************************************************************** ! 646: 646 ! 647: 647 000005D8: restoreDataPointer: ! 648: 648 000005D8: 785C0F00 00000000 move kphase_restoreDataPointer to SCRATCHB0 ! 649: 649 000005E0: E05C0001 00000030 store SCRATCHB0, 1, ld_phase_flag ! 650: 650 000005E8: 60000040 00000000 clear ACK ! 651: 651 000005F0: 80880000 FFFFFC98 jump rel( phase_handler ) ! 652: 652 ! 653: 653 ! 654: 654 ;***************************************************************** ! 655: 655 ; ! 656: 656 ; Synchronous data transfer request or response ! 657: 657 ; ! 658: 658 ;***************************************************************** ! 659: 659 000005F8: sdtr: ! 660: 660 000005F8: 0F000002 00000043 move 2, ld_message+3, when MSG_IN ; Read period & offset from bus ! 661: 661 00000600: 98080000 0000000D int negotiateSDTR ! 662: 662 ! 663: 663 ! 664: 664 ;*************************************************************************** ! 665: 665 ; ! 666: 666 ; Wide Data Transfer request or response ! 667: 667 ; ! 668: 668 ;*************************************************************************** ! 669: 669 00000608: wdtr: ! 670: 670 00000608: 0F000001 00000043 move 1, ld_message+3, when MSG_IN ; get Transfer Width Exponent fm bus ! 671: 671 00000610: 98080000 0000000E int negotiateWDTR ! 672: 672 ! 673: 673 ! 674: 674 ;***************************************************************** ! 675: 675 ; ! 676: 676 ; Reselect phase ! 677: 677 ; The chip waits here either for a Reselection from a Target or ! 678: 678 ; a SIGP from the driver indicating something in the mailbox. ! 679: 679 ; If reselected, the script uses the Nexus value which is either ! 680: 680 ; a Tag or a SCSI ID/LUN combo to lookup the Nexus. ! 681: 681 ; Then init the SXFER and SCNTL3 registers from the device config table. ! 682: 682 ; ! 683: 683 ;***************************************************************** ! 684: 684 ! 685: 685 00000618: try_reselect: ; Select failed - probably reselecting ! 686: 686 ; Cf NCR Errata Listing 117 Item 1: ! 687: 687 00000618: 7C00DF00 00000000 move SCNTL0 & 0xDF to SCNTL0 ; clr Start bit ! 688: 688 00000620: 7A1A0000 00000000 move CTEST2 | 0x00 to CTEST2 ; Clear SIGP bit from ISTAT reg ! 689: 689 ! 690: 690 00000628: reselect_phase: ! 691: 691 00000628: 785C0900 00000000 move kphase_RESELECT to SCRATCHB0 ; Set phase indicator ! 692: 692 00000630: E05C0001 00000030 store SCRATCHB0, 1, ld_phase_flag ! 693: 693 ! 694: 694 00000638: 785FFF00 00000000 move 0xFF to SCRATCHB3 ; invalidate nexus index for driver ! 695: 695 00000640: E05F0001 0000002B store SCRATCHB3, 1, ld_nexus_index+3 ! 696: 696 ! 697: 697 ; wait here for reselect from a Target ! 698: 698 ; or SIGP from the driver ! 699: 699 ! 700: 700 00000648: 54000000 FFFFFAD0 WAIT RESELECT REL( select_phase ) ; jump if SIGP ! 701: 701 ! 702: 702 ; Reselected: ! 703: 703 ! 704: 704 00000650: 720A0000 00000000 move SSID to SFBR ; SSID = [ Valxxx Scsi_id ] ! 705: 705 00000658: 980C7F00 00000007 int unknown_reselect, if 0 and mask 0x7F; Interrupt if VAL bit not set ! 706: 706 00000660: 6C5C0F00 00000000 move SFBR & 0x0F to SCRATCHB0 ; B0 = Target ID ! 707: 707 00000668: E05C0001 00000020 store SCRATCHB0, 1, ld_scsi_id ; save it ! 708: 708 ! 709: 709 00000670: 88880000 FFFFFA48 call rel( initContext ) ; setup sync regs here ! 710: 710 ! 711: 711 00000678: 9F030000 00000005 int no_msgin_after_reselect, when not MSG_IN ! 712: 712 ! 713: 713 00000680: 0F000001 00000040 move 1, ld_message, when MSG_IN ; Read Identify byte from bus ! 714: 714 ! 715: 715 ; if another REQ is asserted, a SimpleQueueTag message should be next ! 716: 716 ! 717: 717 00000688: 60000040 00000000 clear ACK ; notify Target: msg byte rx'd ! 718: 718 00000690: 878B0000 00000048 jump rel( getNextMsg ), when MSG_IN ; jump if SimpleQueueTag coming ! 719: 719 ! 720: 720 ; untagged operation: ! 721: 721 ! 722: 722 00000698: 6C340700 00000000 move SFBR & 0x07 to SCRATCHA0 ; isolate LUN from Identify byte ! 723: 723 ! 724: 724 000006A0: E15C0001 00000020 load SCRATCHB0, 1, ld_scsi_id ; B0 = Target ID ! 725: 725 000006A8: 60000400 00000000 clear CARRY ! 726: 726 000006B0: 715C0000 00000000 move SCRATCHB0 SHL SFBR ; shift left #1 ! 727: 727 000006B8: 695C0000 00000000 move SFBR SHL SCRATCHB0 ; shift left #2 ! 728: 728 000006C0: 715C0000 00000000 move SCRATCHB0 SHL SFBR ; shift left #3 ! 729: 729 000006C8: 7AB40000 00000000 move SCRATCHA0 | SFBR to SCRATCHA0 ; form Nexus index = 0b0TTTTLLL ! 730: 730 ! 731: 731 000006D0: E0340001 00000028 store SCRATCHA0, 1, ld_nexus_index ; store as index to Nexus ! 732: 732 000006D8: 80880000 00000030 jump rel( haveNexusIndex ) ! 733: 733 ! 734: 734 ; should be tagged operation: ! 735: 735 ! 736: 736 000006E0: getNextMsg: ! 737: 737 000006E0: 0F000001 00000040 move 1, ld_message, when MSG_IN ; read message byte from bus ! 738: 738 000006E8: 808C0004 FFFFFE70 jump rel( disconnect_msg ), if 0x04 ; if Disconnect, oh well. ! 739: 739 000006F0: 60000040 00000000 clear ACK ! 740: 740 000006F8: 80840020 FFFFFB90 jump rel( phase_handler ), if not 0x20; Branch if not Queue tag code ! 741: 741 ; get the Queue Tag and save as the nexus index ! 742: 742 00000700: 0F000001 00000028 move 1, ld_nexus_index, when MSG_IN ; Nexus index <- Tag from bus ! 743: 743 00000708: 60000040 00000000 clear ACK ; acknowledge it ! 744: 744 ! 745: 745 00000710: haveNexusIndex: ! 746: 746 00000710: 785F0000 00000000 move 0x00 to SCRATCHB3 ; clear invalid-nexus-index flag ! 747: 747 00000718: E05F0001 0000002B store SCRATCHB3, 1, ld_nexus_index+3 ! 748: 748 00000720: 88880000 FFFFF930 call rel( findNexusFromIndex ) ; set DSA <- Nexus pointer ! 749: 749 00000728: 80880000 FFFFFB60 jump rel( phase_handler ) ; start handling phases. ! 750: 750 ! 751: 751 ! 752: 752 ;***************************************************************** ! 753: 753 ; ! 754: 754 ; AbortMailbox - Abort (or BusDeviceReset) the mailbox entry. ! 755: 755 ; This is a queued operation - not an immediate ! 756: 756 ; operation as is issueAbort_BDR. ! 757: 757 ; The Abort message clears all IO processes for the ! 758: 758 ; selecting Initiator on the specified LUN. ! 759: 759 ; ! 760: 760 ; The Bus Device Reset message clears all IO processes for ! 761: 761 ; all Initiators on all LUNs of selected Target. ! 762: 762 ; It forces a hard reset condition to the selected SCSI device. ! 763: 763 ; ! 764: 764 ; A0 = Identify byte (0xC0 + LUN N.B. Disconnect allowed) ! 765: 765 ; A1 = Tag, if any ! 766: 766 ; A2 = SCSI ID ! 767: 767 ; A3 = Abort code Abort=0x06; Abort Tag=0D; Bus Device Reset=0x0C ! 768: 768 ; ! 769: 769 ; Mailbox not cleared by SCRIPTS so that driver can find SCSI ID when done ! 770: 770 ; N.B.: Device is Async and Narrow after BDR!!! ! 771: 771 ; Driver must set the device config table values accordingly. ! 772: 772 ;***************************************************************** ! 773: 773 ! 774: 774 00000730: AbortMailbox: ! 775: 775 00000730: 785C0B00 00000000 move kphase_ABORT_MAILBOX to SCRATCHB0 ; Set phase code ! 776: 776 00000738: E05C0001 00000030 store SCRATCHB0, 1, ld_phase_flag ! 777: 777 ! 778: 778 00000740: 785FFF00 00000000 move 0xFF to SCRATCHB3 ; invalidate nexus index for driver ! 779: 779 00000748: E05F0001 0000002B store SCRATCHB3, 1, ld_nexus_index+3 ! 780: 780 ! 781: 781 00000750: E15E0001 00000012 load SCRATCHB2, 1, ld_AbortBdr_mailbox+2 ; get SCSI ID ! 782: 782 00000758: E05E0001 00000762 store SCRATCHB2, 1, AbortSelect+2 ; *** Patch the Select/ATN instruction ! 783: 783 ! 784: 784 00000760: AbortSelect: ! 785: 785 00000760: 45000000 FFFFFEB0 SELECT ATN 0, REL( try_reselect ) ; *** Patched SCSI ID ! 786: 786 ! 787: 787 00000768: 72350000 00000000 move SCRATCHA1 to SFBR ; check for Tag ! 788: 788 00000770: 80840000 00000038 jump rel( taggedAbort ) if not 0x00 ; jump if tagged abort ! 789: 789 ! 790: 790 ; untagged Abort or BusDeviceReset: ! 791: 791 ! 792: 792 00000778: 72370000 00000000 move SCRATCHA3 to SFBR ; position the abort code ! 793: 793 00000780: 6A350000 00000000 move SFBR to SCRATCHA1 ! 794: 794 00000788: E0340002 00000038 store SCRATCHA0, 2, ld_scratch ; Store Identify and Abort msgs ! 795: 795 00000790: 78020000 00000000 move 0x00 to SCNTL2 ; Clr SDU SCSI Disconnect Unexpected ! 796: 796 00000798: 0E000002 00000038 move 2, ld_scratch , when MSG_OUT ; emit Identify and Abort messages ! 797: 797 000007A0: 48000000 00000000 WAIT DISCONNECT ! 798: 798 000007A8: 98080000 00000009 int abort_mailbox ! 799: 799 ! 800: 800 ; AbortTag: ! 801: 801 ! 802: 802 000007B0: taggedAbort: ! 803: 803 000007B0: 72350000 00000000 move SCRATCHA1 to SFBR ; position the Tag ! 804: 804 000007B8: 6A360000 00000000 move SFBR to SCRATCHA2 ! 805: 805 000007C0: 78352000 00000000 move 0x20 to SCRATCHA1 ; gen SimpleQueueTag code ! 806: 806 000007C8: E0340004 00000038 store SCRATCHA0, 4, ld_scratch ; store Identify, SQT, Tag, AbortTag ! 807: 807 000007D0: 78020000 00000000 move 0x00 to SCNTL2 ; Clr SDU SCSI Disconnect Unexpected ! 808: 808 000007D8: 0E000004 00000038 move 4, ld_scratch, when MSG_OUT ; emit all 4 bytes ! 809: 809 000007E0: 48000000 00000000 WAIT DISCONNECT ! 810: 810 000007E8: 98080000 00000009 int abort_mailbox ! 811: 811 ! 812: 812 ! 813: 813 ;***************************************************************** ! 814: 814 ; ! 815: 815 ; issueAbort_BDR - Abort (or BusDeviceReset) the current operation. ! 816: 816 ; This is an immediate operation - not a queued operation ! 817: 817 ; as is AbortMailbox. ! 818: 818 ; The Abort message clears all IO processes for the ! 819: 819 ; selecting Initiator on the specified LUN. ! 820: 820 ; ! 821: 821 ; The Bus Device Reset message clears all IO processes for ! 822: 822 ; all Initiators on all LUNs of selected Target. ! 823: 823 ; It forces a hard reset condition to the selected SCSI device. ! 824: 824 ; ! 825: 825 ;***************************************************************** ! 826: 826 ! 827: 827 000007F0: issueAbort_BDR: ! 828: 828 000007F0: 785C0A00 00000000 move kphase_ABORT_CURRENT to SCRATCHB0 ; Set phase code ! 829: 829 000007F8: E05C0001 00000030 store SCRATCHB0, 1, ld_phase_flag ! 830: 830 ! 831: 831 00000800: 74140800 00000000 move ISTAT & 0x08 to SFBR ; see if Target connected to bus ! 832: 832 00000808: 980C0000 0000000A int abort_current, if 0 ; interrupt driver if not connected ! 833: 833 ! 834: 834 00000810: 58000008 00000000 SET ATN ; get Target's attention ! 835: 835 00000818: E1100004 0000002C load DSA0, 4, ld_nexus ; load pointer to Nexus ! 836: 836 ! 837: 837 00000820: bucketLoop: ! 838: 838 00000820: 60000040 00000000 clear ACK ! 839: 839 00000828: 868B0000 000000A8 jump rel( sendAbortBDR ), when MSG_OUT ; wait for REQ. Jump if OK. ! 840: 840 ! 841: 841 00000830: 838A0000 00000030 jump rel( BucketInStatus ), if STATUS ; bit bucket in ! 842: 842 00000838: 878A0000 00000038 jump rel( BucketInMsg ), if MSG_IN ; bit bucket in ! 843: 843 00000840: 818A0000 00000040 jump rel( BucketInData ), if DATA_IN ; bit bucket in ! 844: 844 ! 845: 845 00000848: 7834AD00 00000000 move 0xAD to SCRATCHA0 ! 846: 846 00000850: 808A0000 00000040 jump rel( BucketOutData ), if DATA_OUT ; bit bucket out ! 847: 847 00000858: 828A0000 00000058 jump rel( BucketOutCmd ), if CMD ; bit bucket out ! 848: 848 00000860: 98080000 00000000 int unknown_phase ; back to driver for harsher measures ! 849: 849 ! 850: 850 ! 851: 851 00000868: BucketInStatus: ! 852: 852 00000868: 0B000001 00000038 move 1, ld_scratch, when STATUS ; eat the Status byte ! 853: 853 00000870: 80880000 FFFFFFA8 jump rel( bucketLoop ); ; keep bit-bucketing bytes ! 854: 854 ! 855: 855 00000878: BucketInMsg: ! 856: 856 00000878: 0F000001 00000038 move 1, ld_scratch, when MSG_IN ; eat a message byte ! 857: 857 00000880: 80880000 FFFFFF98 jump rel( bucketLoop ); ; keep bit-bucketing bytes ! 858: 858 ! 859: 859 00000888: BucketInData: ! 860: 860 00000888: 09000001 00000038 move 1, ld_scratch, when DATA_IN ; eat a data byte ! 861: 861 00000890: 80880000 FFFFFF88 jump rel( bucketLoop ); ; keep bit-bucketing bytes ! 862: 862 ! 863: 863 00000898: BucketOutData: ! 864: 864 00000898: 7B347300 00000000 move SCRATCHA0 xor 0x73 to SCRATCHA0 ; gen 0xDEAD ... ! 865: 865 000008A0: E0340001 00000038 store SCRATCHA0, 1, ld_scratch ! 866: 866 000008A8: 08000001 00000038 move 1, ld_scratch, when DATA_OUT ; pad a byte out ! 867: 867 000008B0: 80880000 FFFFFF68 jump rel( bucketLoop ); ; keep bit-bucketing bytes ! 868: 868 ! 869: 869 000008B8: BucketOutCmd: ! 870: 870 000008B8: 78340000 00000000 move 0x00 to SCRATCHA0 ; load Null, TestUnitReady, whatever ! 871: 871 000008C0: E0340001 00000038 store SCRATCHA0, 1, ld_scratch ! 872: 872 000008C8: 0A000001 00000038 move 1, ld_scratch, when CMD ; pad a byte out ! 873: 873 000008D0: 80880000 FFFFFF48 jump rel( bucketLoop ); ; keep bit-bucketing bytes ! 874: 874 ! 875: 875 ! 876: 876 000008D8: sendAbortBDR: ! 877: 877 000008D8: 78020000 00000000 move 0x00 to SCNTL2 ; Clr SDU SCSI Disconnect Unexpected ! 878: 878 000008E0: 0E000001 00000000 move 1, ld_AbortCode, when MSG_OUT ; Send Abort(06) or BDR(0C) message ! 879: 879 000008E8: E1340004 00000004 load SCRATCHA0, 4, ld_zeroes ; load 0's ! 880: 880 000008F0: E0340004 00000000 store SCRATCHA0, 4, ld_AbortCode ; clear the Abort code ! 881: 881 000008F8: 48000000 00000000 WAIT DISCONNECT ! 882: 882 00000900: 98080000 0000000A int abort_current ; went BusFree - tell Driver ! 883: ! 884: --SYMBOL---------------------------VALUE------TYPE------- ! 885: abort_current 0000000A ABSOLUTE ! 886: abort_mailbox 00000009 ABSOLUTE ! 887: kphase_ABORT_MAILBOX 0000000B ABSOLUTE ! 888: kphase_ABORT_CURRENT 0000000A ABSOLUTE ! 889: kphase_CMD_COMPLETE 0000000C ABSOLUTE ! 890: kphase_COMMAND 00000002 ABSOLUTE ! 891: kphase_DATA_IN 00000001 ABSOLUTE ! 892: kphase_DATA_OUT 00000000 ABSOLUTE ! 893: kphase_DISCONNECT 0000000D ABSOLUTE ! 894: kphase_MSG_IN 00000007 ABSOLUTE ! 895: kphase_MSG_OUT 00000006 ABSOLUTE ! 896: kphase_RESELECT 00000009 ABSOLUTE ! 897: kphase_SELECT 00000008 ABSOLUTE ! 898: kphase_STATUS 00000003 ABSOLUTE ! 899: kphase_restoreDataPointer 0000000F ABSOLUTE ! 900: kphase_saveDataPointer 0000000E ABSOLUTE ! 901: negotiateWDTR 0000000E ABSOLUTE ! 902: negotiateSDTR 0000000D ABSOLUTE ! 903: no_msgin_after_reselect 00000005 ABSOLUTE ! 904: reqack_too_large 00000006 ABSOLUTE ! 905: sglist_complete 0000000F ABSOLUTE ! 906: status_error 00000001 ABSOLUTE ! 907: TLQ_CDP 00000018 ABSOLUTE ! 908: TLQ_CDBp 00000010 ABSOLUTE ! 909: TLQ_IWR 00000022 ABSOLUTE ! 910: TLQ_MSGOp 00000008 ABSOLUTE ! 911: TLQ_SDP 0000001C ABSOLUTE ! 912: TLQ_index 00000020 ABSOLUTE ! 913: TLQ_pad 00000023 ABSOLUTE ! 914: TLQ_xferAdr 00000004 ABSOLUTE ! 915: TLQ_SCSI_ID 00000000 ABSOLUTE ! 916: TLQ_xferStarted 00000021 ABSOLUTE ! 917: unallocated_nexus 00000008 ABSOLUTE ! 918: unexpected_ext_msg 00000003 ABSOLUTE ! 919: unexpected_msg 00000002 ABSOLUTE ! 920: unknown_message_out 0000000B ABSOLUTE ! 921: unknown_msg_reject 0000000C ABSOLUTE ! 922: unknown_phase 00000000 ABSOLUTE ! 923: unknown_reselect 00000007 ABSOLUTE ! 924: wide_32_not_supported 00000004 ABSOLUTE ! 925: BSC_SCRIPT 00000000 CODE SEGMENT ! 926: SCRIPT 00000000 CODE SEGMENT ! 927: local_data 00000000 DATA SEGMENT ! 928: clearACK 00000448 ENTRY ! 929: issueAbort_BDR 000007F0 ENTRY ! 930: issueMessageOut 000002F0 ENTRY ! 931: phase_handler 00000290 ENTRY ! 932: select_phase 00000120 ENTRY ! 933: AbortSelect 00000760 LABEL ! 934: AbortMailbox 00000730 LABEL ! 935: BucketInData 00000888 LABEL ! 936: BucketInMsg 00000878 LABEL ! 937: BucketInStatus 00000868 LABEL ! 938: BucketOutCmd 000008B8 LABEL ! 939: BucketOutData 00000898 LABEL ! 940: bucketLoop 00000820 LABEL ! 941: bailout 00000588 LABEL ! 942: bucket_loop 000003B0 LABEL ! 943: clear_mailbox 00000258 LABEL ! 944: cmdComplete 000004C8 LABEL ! 945: command_phase 00000328 LABEL ! 946: data_in_phase 00000398 LABEL ! 947: data_out_phase 00000350 LABEL ! 948: disconnect_msg 00000560 LABEL ! 949: doItPatch 00000390 LABEL ! 950: driverXfer 00000370 LABEL ! 951: extended_msg 00000488 LABEL ! 952: fetchMailbox 00000188 LABEL ! 953: findNexusFromIndex 00000058 LABEL ! 954: getNextMsg 000006E0 LABEL ! 955: haveNexusIndex 00000710 LABEL ! 956: ignoreWideResidue 00000458 LABEL ! 957: initContext 000000C0 LABEL ! 958: message_in_phase 000003E8 LABEL ! 959: message_out_phase 000002D0 LABEL ! 960: msg_reject 00000440 LABEL ! 961: next_mailbox 00000248 LABEL ! 962: patchGetDevConfigOffset 000000F0 LABEL ! 963: patchArrayOffset 00000098 LABEL ! 964: reselect_phase 00000628 LABEL ! 965: restoreDataPointer 000005D8 LABEL ! 966: sdtr 000005F8 LABEL ! 967: saveDataPointer 000005B8 LABEL ! 968: sendAbortBDR 000008D8 LABEL ! 969: status_phase 000003C8 LABEL ! 970: taggedAbort 000007B0 LABEL ! 971: testMbxLp 000004F0 LABEL ! 972: try_reselect 00000618 LABEL ! 973: wdtr 00000608 LABEL ! 974: ld_IOdone_mailbox 00000014 RELATIVE. ! 975: ld_AbortBdr_mailbox 00000010 RELATIVE. ! 976: ld_counter 0000000C RELATIVE. ! 977: ld_device_table_base_adr 00000034 RELATIVE. ! 978: ld_mailboxp 0000001C RELATIVE. ! 979: ld_message 00000040 RELATIVE. ! 980: ld_message4 00000044 RELATIVE. ! 981: ld_nexus 0000002C RELATIVE. ! 982: ld_nexus_array_base 00000024 RELATIVE. ! 983: ld_nexus_index 00000028 RELATIVE. ! 984: ld_pad 00000048 RELATIVE. ! 985: ld_phase_flag 00000030 RELATIVE. ! 986: ld_sched_mlbx_base_adr 00000018 RELATIVE. ! 987: ld_scratch 00000038 RELATIVE. ! 988: ld_scsi_id 00000020 RELATIVE. ! 989: ld_size 0000004C RELATIVE. ! 990: ld_status 00000008 RELATIVE. ! 991: ld_unused 0000003C RELATIVE. ! 992: ld_zeroes 00000004 RELATIVE. ! 993: ld_AbortCode 00000000 RELATIVE.
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.