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