![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Sym8xxExecute.m 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 Sym8xxExecute.m CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc / drvSymbios8xx |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /* Sym8xxExecute.m created by russb2 on Sat 30-May-1998 */
26:
27: #import "Sym8xxController.h"
28:
29: /*-----------------------------------------------------------------------------*
30: * IOThread Routines
31: *
32: * This module contains routines that run on the driver's IOThread.
33: *
34: *-----------------------------------------------------------------------------*/
35:
36: @implementation Sym8xxController(Execute)
37:
38: /*-----------------------------------------------------------------------------*
39: * This is the main command processing loop for the driver's I/O thread.
40: * It removes SRBs from the driver's command queue and processes them according
41: * to the command code in srb->srbCmd.
42: *
43: *-----------------------------------------------------------------------------*/
44: - (void) commandRequestOccurred
45: {
46: SRB *srb = NULL;
47:
48: while ( 1 )
49: {
50: [srbPendingQLock lock];
51:
52: if ( queue_empty(&srbPendingQ) )
53: {
54: [srbPendingQLock unlock];
55: break;
56: }
57: queue_remove_first( &srbPendingQ, srb, SRB *, srbQ );
58:
59: [srbPendingQLock unlock];
60:
61:
62: /*
63: * If we are in the quiet period after a SCSI Bus reset, then reject new SRBs. In
64: * general the client thread processing will block new SRBs, however, some may have
65: * been on the IOThread's SRB queue when the reset occurred.
66: */
67: if ( resetQuiesceTimer )
68: {
69: srb->srbSCSIResult = SR_IOST_RESET;
70: [srb->srbCmdLock unlockWith: ksrbCmdComplete];
71: continue;
72: }
73:
74: switch ( srb->srbCmd )
75: {
76: /*
77: * For a SCSI CDB request, stuff the physical address of the SRB's Nexus struct into a
78: * mailbox and signal the Symbios script engine.
79: */
80: case ksrbCmdExecuteReq:
81: srb->nexus.targetParms.scntl3Reg = adapter->targetClocks[srb->target].scntl3Reg;
82: srb->nexus.targetParms.sxferReg = adapter->targetClocks[srb->target].sxferReg;
83:
84: adapter->nexusPtrsVirt[srb->nexus.tag] = &srb->nexus;
85: adapter->nexusPtrsPhys[srb->nexus.tag] = (Nexus *)EndianSwap32( (u_int32_t)&srb->srbPhys->nexus );
86: adapter->schedMailBox[mailBoxIndex++] = (Nexus *)EndianSwap32 ( (u_int32_t)&srb->srbPhys->nexus );
87:
88: [self Sym8xxSignalScript: srb];
89: break;
90:
91: case ksrbCmdResetSCSIBus:
92: [self Sym8xxSCSIBusReset: srb];
93: break;
94:
95: case ksrbCmdAbortReq:
96: case ksrbCmdBusDevReset:
97: [self Sym8xxAbortBdr: srb];
98: break;
99:
100: default:
101: ;
102: }
103: }
104: }
105:
106:
107: /*-----------------------------------------------------------------------------*
108: * Interrupts from the Symbios chipset are dispatched here at task time under the
109: * IOThread's context.
110: *-----------------------------------------------------------------------------*/
111: - (void) interruptOccurred
112: {
113: do
114: {
115: /*
116: * The chipset's ISTAT reg gives us the general interrupting condiditions,
117: * with DSTAT and SIST providing more detailed information.
118: */
119: istatReg = Sym8xxReadRegs( chipBaseAddr, ISTAT, ISTAT_SIZE );
120:
121: /* The INTF bit in ISTAT indicates that the script is signalling the driver
122: * that its IODone mailbox is full and that we should process a completed
123: * request. The script continues to run after posting this interrupt unlike
124: * other chipset interrupts which require the driver to restart the script
125: * engine.
126: */
127: if ( istatReg & INTF )
128: {
129: Sym8xxWriteRegs( chipBaseAddr, ISTAT, ISTAT_SIZE, istatReg );
130: [self Sym8xxProcessIODone];
131: }
132:
133: /*
134: * Handle remaining interrupting conditions
135: */
136: if ( istatReg & (SIP | DIP) )
137: {
138: [self Sym8xxProcessInterrupt];
139: }
140: }
141: while ( istatReg & (SIP | DIP | INTF) );
142:
143: [self enableAllInterrupts];
144:
145: }
146:
147: /*-----------------------------------------------------------------------------*
148: * Process a request posted in the script's IODone mailbox.
149: *
150: *-----------------------------------------------------------------------------*/
151: - (void) Sym8xxProcessIODone
152: {
153: SRB *srb;
154: Nexus *nexus;
155: IODoneMailBox *pMailBox;
156:
157:
158: /*
159: * The IODone mailbox contains an index into our Nexus pointer tables.
160: *
161: * The Nexus struct is part of the SRB so we can get our SRB address
162: * by subtracting the offset of the Nexus struct in the SRB.
163: */
164: pMailBox = (IODoneMailBox *)&SCRIPT_VAR(R_ld_IOdone_mailbox);
165: nexus = adapter->nexusPtrsVirt[pMailBox->nexus];
166: srb = (SRB *)((u_int32_t)nexus - offsetof(SRB, nexus));
167:
168: /*
169: * If there was no request sense performed, then update the transfer
170: * counts in the SRB.
171: */
172: if ( srb->srbState == ksrbStateCDBDone )
173: {
174: [self Sym8xxUpdateXferOffset: srb];
175: }
176:
177: /*
178: * Clear the completed Nexus pointer from our tables and clear the
179: * IODone mailbox.
180: */
181: adapter->nexusPtrsVirt[pMailBox->nexus] = (Nexus *) -1;
182: adapter->nexusPtrsPhys[pMailBox->nexus] = (Nexus *) -1;
183: SCRIPT_VAR(R_ld_IOdone_mailbox) = 0;
184:
185: /*
186: * Don't ask why we need to do this -- we shouldn't if the Indirect SCSI
187: * drivers worked properly!
188: *
189: */
190: if ( nexus->cdbData.cdb_opcode == C6OP_INQUIRY )
191: {
192: [self Sym8xxCheckInquiryData: srb];
193: }
194:
195: /*
196: * Wake up the client's thread to do post-processing
197: */
198: [srb->srbCmdLock unlockWith: ksrbCmdComplete];
199: }
200:
201: /*-----------------------------------------------------------------------------*
202: * General script interrupt processing
203: *
204: *-----------------------------------------------------------------------------*/
205: - (void) Sym8xxProcessInterrupt
206: {
207: SRB *srb = NULL;
208: Nexus *nexus = NULL;
209: u_int32_t nexusIndex;
210: u_int32_t scriptPhase;
211: u_int32_t fifoCnt = 0;
212: u_int32_t dspsReg = 0;
213: u_int32_t dspReg = 0;
214:
215:
216: /*
217: * Read DSTAT/SIST regs to determine why the script stopped.
218: */
219: dstatReg = Sym8xxReadRegs( chipBaseAddr, DSTAT, DSTAT_SIZE );
220: IODelay(5);
221: sistReg = Sym8xxReadRegs( chipBaseAddr, SIST, SIST_SIZE );
222:
223: // kprintf( "SCSI(Symbios8xx): SIST = %04x DSTAT = %02x\n\r", sistReg, dstatReg );
224:
225: /*
226: * This Script var tells us what the script thinks it was doing when the interrupt occurred.
227: */
228: scriptPhase = EndianSwap32( SCRIPT_VAR(R_ld_phase_flag) );
229:
230: /*
231: * SCSI Bus reset detected
232: *
233: * Clean up the carnage.
234: * Note: This may be either an adapter or target initiated reset.
235: */
236: if ( sistReg & RSTI )
237: {
238: [self Sym8xxProcessSCSIBusReset];
239: return;
240: }
241:
242: /*
243: * Calculate our current SRB/Nexus.
244: *
245: * Read a script var to determine the index of the nexus it was processing
246: * when the interrupt occurred. The script will invalidate the index if there
247: * is no target currently connected or the script cannot determine which target
248: * has reconnected.
249: */
250: nexusIndex = EndianSwap32(SCRIPT_VAR(R_ld_nexus_index));
251: if ( nexusIndex >= MAX_SCSI_TAG )
252: {
253: [self Sym8xxProcessNoNexus];
254: return;
255: }
256: nexus = adapter->nexusPtrsVirt[nexusIndex];
257: if ( nexus == (Nexus *) -1 )
258: {
259: [self Sym8xxProcessNoNexus];
260: return;
261: }
262: srb = (SRB *)((u_int32_t)nexus - offsetof(SRB, nexus));
263:
264: scriptRestartAddr = (u_int32_t) &chipRamAddrPhys[Ent_phase_handler];
265:
266: /*
267: * Parity and SCSI Gross Errors.
268: *
269: * Abort the current connection. The abort completion will trigger
270: * clean-up of the current SRB/Nexus.
271: */
272: if ( sistReg & PAR )
273: {
274: srb->srbSCSIResult = SR_IOST_PARITY;
275: [self Sym8xxAbortCurrent: srb];
276: }
277:
278: else if ( sistReg & SGE )
279: {
280: srb->srbSCSIResult = SR_IOST_BV;
281: [self Sym8xxAbortCurrent: srb];
282: }
283:
284: /*
285: * Unexpected disconnect.
286: *
287: * If we were currently trying to abort this connection then mark the abort
288: * as completed. For all cases clean-up and wake-up the client thread.
289: */
290: else if ( sistReg & UDC )
291: {
292: if ( srb->srbSCSIResult == SR_IOST_GOOD )
293: {
294: srb->srbSCSIResult = SR_IOST_BV;
295: }
296: adapter->nexusPtrsVirt[nexusIndex] = (Nexus *) -1;
297: adapter->nexusPtrsPhys[nexusIndex] = (Nexus *) -1;
298:
299: if ( scriptPhase == A_kphase_ABORT_CURRENT )
300: {
301: abortCurrentSRB = NULL;
302: }
303:
304: [srb->srbCmdLock unlockWith: ksrbCmdComplete];
305:
306: scriptRestartAddr = (u_int32_t) &chipRamAddrPhys[Ent_select_phase];
307: }
308:
309: /*
310: * Phase Mis-match
311: *
312: * If we are in MsgOut phase then calculate how much of the message we sent. For
313: * now, however, we dont handle the target rejecting messages, so the request is aborted.
314: *
315: * If we are in DataIn/DataOut phase. We update the SRB/Nexus with our current data
316: * pointers.
317: */
318: else if ( sistReg & MA )
319: {
320: if ( scriptPhase == A_kphase_MSG_OUT )
321: {
322: srb->srbMsgResid = [self Sym8xxCheckFifo:srb FifoCnt:&fifoCnt];
323: nexus->msg.ppData = EndianSwap32( EndianSwap32(nexus->msg.ppData) + EndianSwap32(nexus->msg.length)
324: - srb->srbMsgResid );
325: nexus->msg.length = EndianSwap32( srb->srbMsgResid );
326:
327: [self Sym8xxAbortCurrent: srb];
328: }
329: else if ( (scriptPhase == A_kphase_DATA_OUT) || (scriptPhase == A_kphase_DATA_IN) )
330: {
331: [self Sym8xxAdjustDataPtrs:srb Nexus:nexus];
332: }
333: else
334: {
335: // kprintf("SCSI(Symbios8xx): Unexpected phase mismatch - scriptPhase = %08x\n\r", scriptPhase);
336: srb->srbSCSIResult = SR_IOST_BV;
337: [self Sym8xxAbortCurrent: srb];
338: }
339:
340: [self Sym8xxClearFifo];
341: }
342:
343: /*
344: * Selection Timeout.
345: *
346: * Clean-up the current request.
347: */
348: else if ( sistReg & STO )
349: {
350: srb->srbSCSIResult = SR_IOST_SELTO;
351:
352: adapter->nexusPtrsVirt[nexusIndex] = (Nexus *) -1;
353: adapter->nexusPtrsPhys[nexusIndex] = (Nexus *) -1;
354: SCRIPT_VAR(R_ld_IOdone_mailbox) = 0;
355:
356: [srb->srbCmdLock unlockWith: ksrbCmdComplete];
357:
358: scriptRestartAddr = (u_int32_t) &chipRamAddrPhys[Ent_select_phase];
359: }
360:
361: /*
362: * Handle script initiated interrupts
363: */
364: else if ( dstatReg & SIR )
365: {
366: dspsReg = Sym8xxReadRegs( chipBaseAddr, DSPS, DSPS_SIZE );
367:
368: switch ( dspsReg )
369: {
370: /*
371: * Non-zero SCSI status
372: *
373: * Send request sense CDB or complete request depending on SCSI status value
374: */
375: case A_status_error:
376: if ( [self Sym8xxProcessStatus:srb] == NO )
377: {
378: [self Sym8xxProcessIODone];
379: }
380: break;
381:
382: /*
383: * Received SDTR/WDTR message from target.
384: *
385: * Prepare reply message if we requested negotiation. Otherwise reject
386: * target initiated negotiation.
387: */
388: case A_negotiateSDTR:
389: [self Sym8xxNegotiateSDTR:srb Nexus: nexus];
390: break;
391:
392: case A_negotiateWDTR:
393: [self Sym8xxNegotiateWDTR:srb Nexus: nexus];
394: break;
395:
396: /*
397: * Partial SG List completed.
398: *
399: * Refresh the list from the remaining addresses to be transfered and set the
400: * script engine to branch into the list.
401: */
402: case A_sglist_complete:
403: [self Sym8xxUpdateSGList:srb];
404: scriptRestartAddr = (u_int32_t)&srb->srbPhys->nexus.sgListData[2];
405: break;
406:
407: /*
408: * Completed abort request
409: *
410: * Clean-up the aborted request.
411: */
412: case A_abort_current:
413: if ( srb->srbSCSIResult == SR_IOST_GOOD )
414: {
415: srb->srbSCSIResult = SR_IOST_BV;
416: }
417:
418: adapter->nexusPtrsVirt[nexusIndex] = (Nexus *) -1;
419: adapter->nexusPtrsPhys[nexusIndex] = (Nexus *) -1;
420:
421: abortCurrentSRB = NULL;
422:
423: [srb->srbCmdLock unlockWith: ksrbCmdComplete];
424:
425: scriptRestartAddr = (u_int32_t) &chipRamAddrPhys[Ent_select_phase];
426: break;
427:
428: /*
429: * Script detected protocol errors
430: *
431: * Abort the current request.
432: */
433: case A_unknown_msg_reject:
434: case A_unknown_phase:
435: case A_unexpected_msg:
436: case A_unexpected_ext_msg:
437: srb->srbSCSIResult = SR_IOST_TABT;
438: [self Sym8xxAbortCurrent: srb];
439: break;
440:
441: default:
442: kprintf( "SCSI(Symbios8xx): Unknown Script Int = %08x\n\r", dspsReg );
443: srb->srbSCSIResult = SR_IOST_INT;
444: [self Sym8xxAbortCurrent: srb];
445: }
446: }
447:
448: /*
449: * Illegal script instruction.
450: *
451: * We're toast! Abort the current request and hope for the best!
452: */
453: else if ( dstatReg & IID )
454: {
455: dspReg = Sym8xxReadRegs( chipBaseAddr, DSP, DSP_SIZE );
456:
457: kprintf("SCSI(Symbios8xx): Illegal script instruction - dsp = %08x srb=%08x\n\r", dspReg, (u_int32_t)srb );
458:
459: srb->srbSCSIResult = SR_IOST_INT;
460: [self Sym8xxAbortCurrent: srb];
461: }
462:
463: if ( scriptRestartAddr )
464: {
465: Sym8xxWriteRegs( chipBaseAddr, DSP, DSP_SIZE, scriptRestartAddr );
466: }
467: }
468:
469: /*-----------------------------------------------------------------------------*
470: * Handle non-zero SCSI status
471: *
472: * Returns:
473: * NO - Clean-up request now.
474: * YES - Wait for request sense to complete.
475: *
476: * This routine filter's out BUSY and more arcane SCSI status conditions,
477: * leaving CHECK_CONDITION, for which it set's up a request sense operation.
478: *
479: *-----------------------------------------------------------------------------*/
480: - (BOOL) Sym8xxProcessStatus: (SRB *) srb;
481: {
482: IODoneMailBox *pMailBox;
483:
484: scriptRestartAddr = (u_int32_t) &chipRamAddrPhys[Ent_select_phase];
485:
486: pMailBox = (IODoneMailBox *)&SCRIPT_VAR(R_ld_IOdone_mailbox);
487:
488: /*
489: * If a previous request sense failed, then clean-up the request now.
490: */
491: if ( srb->srbState != ksrbStateCDBDone )
492: {
493: if ( srb->srbSCSIResult == SR_IOST_GOOD )
494: {
495: srb->srbSCSIResult = SR_IOST_CHKSNV;
496: }
497: return NO;
498: }
499:
500: /*
501: * Update the SRB with our byte transferred count and SCSI status.
502: * This information needs to be captured before we issue the request
503: * sense.
504: */
505: srb->srbSCSIStatus = pMailBox->status;
506:
507: [self Sym8xxUpdateXferOffset: srb];
508:
509: if ( pMailBox->status != STAT_CHECK )
510: {
511: srb->srbSCSIResult = ST_IOST_BADST;
512: return NO;
513: }
514: if ( srb->senseData == NULL )
515: {
516: srb->srbSCSIResult = SR_IOST_CHKSNV;
517: return NO;
518: }
519:
520: [self Sym8xxIssueRequestSense: srb];
521:
522: return YES;
523: }
524:
525: /*-----------------------------------------------------------------------------*
526: * Prepare request sense request.
527: *
528: *-----------------------------------------------------------------------------*/
529: - (void) Sym8xxIssueRequestSense:(SRB *) srb
530: {
531: IODoneMailBox *pMailBox;
532: u_int32_t reqSenseMailBox;
533:
534: pMailBox = (IODoneMailBox *)&SCRIPT_VAR(R_ld_IOdone_mailbox);
535:
536: /*
537: * We put the request sense Nexus in the last completed script mailbox and
538: * back-up the script's mailbox pointer.
539: */
540: reqSenseMailBox = (u_int8_t)(EndianSwap32(SCRIPT_VAR(R_ld_counter)) - 1);
541: SCRIPT_VAR(R_ld_counter) = EndianSwap32( reqSenseMailBox );
542:
543: srb->srbTimeout = kReqSenseTimeoutMS / kSCSITimerIntervalMS + 1;
544:
545: srb->srbState = ksrbStateReqSenseDone;
546: srb->srbSCSIResult = SR_IOST_CHKSV;
547:
548: /*
549: * Reuse the original Nexus struct. The original CDB is not preserved. The
550: * original status and transfer counts and tag are kept in the SRB.
551: */
552: bzero( &srb->nexus.cdbData, 6 );
553: srb->nexus.cdbData.cdb_c6.c6_opcode = C6OP_REQSENSE;
554: srb->nexus.cdbData.cdb_c6.c6_lun = srb->lun;
555: srb->nexus.cdbData.cdb_c6.c6_len = srb->senseDataLength;
556: srb->nexus.cdb.length = EndianSwap32( 6 );
557:
558: /*
559: * Force renegotiation on request sense.
560: */
561: targets[srb->target].flags &= ~(kTFXferSync | kTFXferWide16);
562: srb->srbRequestFlags &= ~(ksrbRFCmdQueueAllowed | ksrbRFDisconnectAllowed);
563: [self Sym8xxCalcMsgs:srb];
564:
565: /*
566: * Create a new SG List for the request sense data
567: *
568: */
569: srb->xferOffset = 0;
570: srb->xferOffsetPrev = 0;
571: srb->xferClient = IOVmTaskSelf();
572: srb->xferBuffer = srb->senseData;
573: srb->xferCount = srb->senseDataLength;
574: srb->directionMask = 0x01000000;
575: srb->nexus.ppSGList = (SGEntry *)EndianSwap32((u_int32_t)&srb->srbPhys->nexus.sgListData[2]);
576: [self Sym8xxUpdateSGList: srb];
577:
578: /*
579: * If the original request was using cmd-queuing, we clean-up the original tagged request
580: * and convert it to a non-tagged request sense.
581: */
582: if ( srb->nexus.tag >= MIN_SCSI_TAG )
583: {
584: adapter->nexusPtrsVirt[pMailBox->nexus] = (Nexus *) -1;
585: adapter->nexusPtrsPhys[pMailBox->nexus] = (Nexus *) -1;
586:
587: srb->nexus.tag = (srb->target << 3) | srb->lun;
588: adapter->nexusPtrsVirt[srb->nexus.tag] = &srb->nexus;
589: adapter->nexusPtrsPhys[srb->nexus.tag] = (Nexus *)EndianSwap32( (u_int32_t)&srb->srbPhys->nexus );
590: }
591:
592: adapter->schedMailBox[reqSenseMailBox] = (Nexus *)EndianSwap32 ( (u_int32_t)&srb->srbPhys->nexus );
593:
594: [self Sym8xxSignalScript: srb];
595:
596: SCRIPT_VAR(R_ld_IOdone_mailbox) = 0;
597: }
598:
599: /*-----------------------------------------------------------------------------*
600: * Current Data Pointer calculations
601: *
602: * To do data transfers the driver generates a list of script instructions
603: * in system storage to deliver data to the requested physical addresses. The
604: * script branches to the list when the target enters data transfer phase.
605: *
606: * When the target changes phase during a data transfer, data is left trapped
607: * inside the various script engine registers. This routine determines how much
608: * data was not actually transfered to/from the target and generates a new
609: * S/G List entry for the partial transfer and a branch back into the original
610: * S/G list. These script instructions are stored in two reserved slots at the
611: * top of the original S/G List.
612: *
613: *-----------------------------------------------------------------------------*/
614: - (void) Sym8xxAdjustDataPtrs:(SRB *) srb Nexus:(Nexus *) nexus
615: {
616: u_int32_t i;
617: u_int32_t sgResid;
618: u_int32_t fifoCnt;
619: u_int32_t dspReg;
620: u_int32_t sgDone;
621: u_int8_t scntl2Reg;
622: Nexus *nexusPhys;
623:
624: /*
625: * Determine SG element residual
626: *
627: * This routine returns how much of the current S/G List element the
628: * script was processing remains to be sent/received. All the information
629: * required to do this is stored in the script engine's registers.
630: */
631: sgResid = [self Sym8xxCheckFifo:srb FifoCnt:&fifoCnt];
632:
633: /*
634: * Determine which script instruction in our SGList we were executing when
635: * the target changed phase.
636: *
637: * The script engine's dspReg tells us where the script thinks it was. Based
638: * on the physical address of our current SRB/Nexus we can calculate
639: * an index into our S/G List.
640: */
641: dspReg = Sym8xxReadRegs( chipBaseAddr, DSP, DSP_SIZE );
642:
643: i = ((dspReg - (u_int32_t)srb->srbPhys->nexus.sgListData) / sizeof(SGEntry)) - 1;
644:
645: if ( i > MAX_SGLIST_ENTRIES-1 )
646: {
647: kprintf("SCSI(Symbios8xx): Bad sgListIndex\n\r");
648: [self Sym8xxAbortCurrent: srb];
649: return;
650: }
651:
652: /*
653: * Wide/odd-byte transfers.
654: *
655: * When dealing with Wide data transfers, if a S/G List ends with an odd-transfer count, then a
656: * valid received data byte is left in the script engine's SWIDE register. The least painful way
657: * to recover this byte is to construct a small script thunk to transfer one additional byte. The
658: * script will automatically draw this byte from the SWIDE register rather than the SCSI bus.
659: * The script thunk then branches back to script's PhaseHandler entrypoint.
660: *
661: */
662: nexusPhys = &srb->srbPhys->nexus;
663:
664: scntl2Reg = Sym8xxReadRegs( chipBaseAddr, SCNTL2, SCNTL2_SIZE );
665: if ( scntl2Reg & WSR )
666: {
667: adapter->xferSWideInst[0] = EndianSwap32( srb->directionMask | 1 );
668: adapter->xferSWideInst[1] = nexus->sgListData[i].physAddr;
669: adapter->xferSWideInst[2] = EndianSwap32( 0x80080000 );
670: adapter->xferSWideInst[3] = EndianSwap32( (u_int32_t)&chipRamAddrPhys[Ent_phase_handler] );
671:
672: scriptRestartAddr = (u_int32_t) adapterPhys->xferSWideInst;
673:
674: /*
675: * Note: There is an assumption here that the sgResid count will be > 1. It appears
676: * that the script engine does not generate a phase-mismatch interrupt until
677: * we attempt to move > 1 byte from the SCSI bus and the only byte available is
678: * in SWIDE.
679: */
680: sgResid--;
681: }
682:
683: /*
684: * Calculate partial S/G List instruction and branch
685: *
686: * Fill in slots 0/1 of the SGList based on the SGList index (i) and SGList residual count
687: * (sgResid) calculated above.
688: *
689: */
690: sgDone = (EndianSwap32( nexus->sgListData[i].length ) & 0x00ffffff) - sgResid;
691:
692: nexus->sgListData[0].length = EndianSwap32( sgResid | srb->directionMask );
693: nexus->sgListData[0].physAddr = EndianSwap32( EndianSwap32(nexus->sgListData[i].physAddr) + sgDone );
694: /*
695: * If a previously calculated SGList 0 entry was interrupted again, we dont need to calculate
696: * a new branch address since the previous one is still valid.
697: */
698: if ( i != 0 )
699: {
700: nexus->sgListData[1].length = EndianSwap32( 0x80080000 );
701: nexus->sgListData[1].physAddr = EndianSwap32( (u_int32_t)&nexusPhys->sgListData[i+1] );
702: nexus->sgNextIndex = i + 1;
703: }
704: nexus->ppSGList = (SGEntry *)EndianSwap32( (u_int32_t) &nexusPhys->sgListData[0] );
705:
706: /*
707: * The script sets this Nexus variable to non-zero each time it calls the driver generated
708: * S/G list. This allows the driver's completion routines to differentiate between a successful
709: * transfer vs no data transfer at all.
710: */
711: nexus->dataXferCalled = 0;
712:
713: return;
714: }
715:
716: /*-----------------------------------------------------------------------------*
717: * Determine SG element residual
718: *
719: * This routine returns how much of the current S/G List element the
720: * script was processing remains to be sent/received. All the information
721: * required to do this is stored in the script engine's registers.
722: *
723: *-----------------------------------------------------------------------------*/
724: - (u_int32_t) Sym8xxCheckFifo: (SRB *) srb FifoCnt:(u_int32_t *)pfifoCnt
725: {
726: BOOL fSCSISend;
727: BOOL fXferSync;
728: u_int32_t scriptPhase = 0;
729: u_int32_t dbcReg = 0;
730: u_int32_t dfifoReg = 0;
731: u_int32_t ctest5Reg = 0;
732: u_int8_t sstat0Reg = 0;
733: u_int8_t sstat1Reg = 0;
734: u_int8_t sstat2Reg = 0;
735: u_int32_t fifoCnt = 0;
736: u_int32_t sgResid = 0;
737:
738: scriptPhase = EndianSwap32( SCRIPT_VAR(R_ld_phase_flag) );
739:
740: fSCSISend = (scriptPhase == A_kphase_DATA_OUT) || (scriptPhase == A_kphase_MSG_OUT);
741:
742: fXferSync = ((scriptPhase == A_kphase_DATA_OUT) || (scriptPhase == A_kphase_DATA_IN))
743: && (srb->nexus.targetParms.sxferReg & 0x1F);
744:
745: dbcReg = Sym8xxReadRegs( chipBaseAddr, DBC, DBC_SIZE ) & 0x00ffffff;
746:
747: if ( !(dstatReg & DFE) )
748: {
749: ctest5Reg = Sym8xxReadRegs( chipBaseAddr, CTEST5, CTEST5_SIZE );
750: dfifoReg = Sym8xxReadRegs( chipBaseAddr, DFIFO, DFIFO_SIZE );
751:
752: if ( ctest5Reg & DFS )
753: {
754: fifoCnt = ((((ctest5Reg & 0x03) << 8) | dfifoReg) - dbcReg) & 0x3ff;
755: }
756: else
757: {
758: fifoCnt = (dfifoReg - dbcReg) & 0x7f;
759: }
760: }
761:
762: sstat0Reg = Sym8xxReadRegs( chipBaseAddr, SSTAT0, SSTAT0_SIZE );
763: sstat2Reg = Sym8xxReadRegs( chipBaseAddr, SSTAT2, SSTAT2_SIZE );
764:
765: if ( fSCSISend )
766: {
767: fifoCnt += (sstat0Reg & OLF ) ? 1 : 0;
768: fifoCnt += (sstat2Reg & OLF1) ? 1 : 0;
769:
770: if ( fXferSync )
771: {
772: fifoCnt += (sstat0Reg & ORF ) ? 1 : 0;
773: fifoCnt += (sstat2Reg & ORF1) ? 1 : 0;
774: }
775: }
776: else
777: {
778: if ( fXferSync )
779: {
780: sstat1Reg = Sym8xxReadRegs( chipBaseAddr, SSTAT0, SSTAT0_SIZE );
781: fifoCnt += (sstat1Reg >> 4) | (sstat2Reg & FF4);
782: }
783: else
784: {
785: fifoCnt += (sstat0Reg & ILF ) ? 1 : 0;
786: fifoCnt += (sstat2Reg & ILF1) ? 1 : 0;
787: }
788: }
789:
790: sgResid = dbcReg + fifoCnt;
791: *pfifoCnt = fifoCnt;
792:
793: return sgResid;
794: }
795:
796: /*-----------------------------------------------------------------------------*
797: * Calculate transfer counts.
798: *
799: * This routine updates srb->xferDone with the amount of data transferred
800: * by the last S/G List executed.
801: *
802: *-----------------------------------------------------------------------------*/
803: - (void) Sym8xxUpdateXferOffset:(SRB *) srb
804: {
805: u_int32_t i;
806: u_int32_t xferOffset;
807:
808: /*
809: * srb->xferOffset contains the client buffer offset INCLUDING the range
810: * covered by the current SGList.
811: */
812: xferOffset = srb->xferOffset;
813:
814: /*
815: * If script did not complete the current transfer list then we need to determine
816: * how much of the list was completed.
817: */
818: if ( srb->nexus.dataXferCalled == 0 )
819: {
820: /*
821: * srb->xferOffsetPrev contains the client buffer offset EXCLUDING the
822: * range covered by the current SGList.
823: */
824: xferOffset = srb->xferOffsetPrev;
825:
826: /*
827: * Calculate bytes transferred for partially completed list.
828: *
829: * To calculate the amount of this list completed, we sum the residual amount
830: * in SGList Slot 0 and the completed list elements 2 to sgNextIndex-1.
831: */
832: if ( srb->nexus.sgNextIndex != 0 )
833: {
834: xferOffset += EndianSwap32( srb->nexus.sgListData[srb->nexus.sgNextIndex-1].length )
835: - EndianSwap32( srb->nexus.sgListData[0].length );
836:
837: for ( i=2; i < srb->nexus.sgNextIndex-1; i++ )
838: {
839: xferOffset += EndianSwap32( srb->nexus.sgListData[i].length ) & 0x00ffffff;
840: }
841: }
842: }
843:
844: /*
845: * The script leaves the result of any Ignore Wide Residual message received from the target
846: * during the transfer.
847: */
848: xferOffset -= srb->nexus.wideResidCount;
849:
850:
851: #if 0
852: {
853: u_int32_t resid = srb->xferOffset - xferOffset;
854: if ( resid )
855: {
856: kprintf( "SCSI(Symbios8xx): Incomplete transfer - Req Count = %08x Act Count = %08x - srb = %08x\n\r",
857: srb->xferCount, xferOffset, (u_int32_t)srb );
858: }
859: }
860: #endif
861:
862: srb->xferDone = xferOffset;
863: }
864:
865: /*-----------------------------------------------------------------------------*
866: * No SRB/Nexus Processing.
867: *
868: * In some cases (mainly Aborts) not having a SRB/Nexus is normal. In other
869: * cases it indicates a problem such a reconnection from a target that we
870: * have no record of.
871: *
872: *-----------------------------------------------------------------------------*/
873: - (void) Sym8xxProcessNoNexus
874: {
875: u_int32_t dspsReg;
876: u_int32_t dspReg = 0;
877: u_int32_t scriptPhase = -1 ;
878:
879: scriptRestartAddr = (u_int32_t) &chipRamAddrPhys[Ent_select_phase];
880:
881: dspsReg = Sym8xxReadRegs( chipBaseAddr, DSPS, DSPS_SIZE );
882:
883: scriptPhase = EndianSwap32( SCRIPT_VAR(R_ld_phase_flag) );
884:
885: /*
886: * If we were trying to abort or disconnect a target and the bus
887: * is now free we consider the abort to have completed.
888: */
889: if ( sistReg & UDC )
890: {
891: if ( (scriptPhase == A_kphase_ABORT_MAILBOX) && abortSRB )
892: {
893: [abortSRB->srbCmdLock unlockWith: ksrbCmdComplete];
894: abortSRB = (SRB *) NULL;
895: SCRIPT_VAR(R_ld_AbortBdr_mailbox) = 0;
896: }
897: else if ( scriptPhase == A_kphase_ABORT_CURRENT )
898: {
899: abortCurrentSRB = NULL;
900: }
901: }
902: /*
903: * If we were trying to connect to a target to send it an abort message, and
904: * we timed out, we consider the abort as completed.
905: *
906: * Note: In this case the target may be hung, but at least its not on the bus.
907: */
908: else if ( sistReg & STO )
909: {
910: if ( (scriptPhase == A_kphase_ABORT_MAILBOX) && abortSRB )
911: {
912: [abortSRB->srbCmdLock unlockWith: ksrbCmdComplete];
913: abortSRB = (SRB *) NULL;
914: SCRIPT_VAR(R_ld_AbortBdr_mailbox) = 0;
915: }
916: }
917:
918: /*
919: * If the script died, without a vaild nexusIndex, we abort anything that is currently
920: * connected and hope for the best!
921: */
922: else if ( dstatReg & IID )
923: {
924: dspReg = Sym8xxReadRegs( chipBaseAddr, DSP, DSP_SIZE );
925: kprintf("SCSI(Symbios8xx): Illegal script instruction - dsp = %08x srb=0\n\r", dspReg );
926: [self Sym8xxAbortCurrent: (SRB *) -1];
927: }
928:
929: /*
930: * Script signaled conditions
931: */
932: else if ( dstatReg & SIR )
933: {
934: switch ( dspsReg )
935: {
936: case A_abort_current:
937: abortCurrentSRB = NULL;
938: break;
939:
940: case A_abort_mailbox:
941: [abortSRB->srbCmdLock unlockWith: ksrbCmdComplete];
942: abortSRB = (SRB *) NULL;
943: SCRIPT_VAR(R_ld_AbortBdr_mailbox) = 0;
944: break;
945:
946: default:
947: [self Sym8xxAbortCurrent: (SRB *)-1];
948: }
949: }
950: else
951: {
952: [self Sym8xxAbortCurrent: (SRB *)-1];
953: }
954:
955: if ( scriptRestartAddr )
956: {
957: Sym8xxWriteRegs( chipBaseAddr, DSP, DSP_SIZE, scriptRestartAddr );
958: }
959: }
960:
961:
962: /*-----------------------------------------------------------------------------*
963: * Abort currently connected target.
964: *
965: *-----------------------------------------------------------------------------*/
966: - (void) Sym8xxAbortCurrent:(SRB *)srb
967: {
968: if ( abortCurrentSRB )
969: {
970: if ( abortCurrentSRB != srb )
971: {
972: // kprintf("SCSI(Symbios8xx): Multiple abort immediate SRBs - resetting\n\r");
973: [self Sym8xxSCSIBusReset: (SRB *)NULL];
974: }
975: return;
976: }
977:
978: abortCurrentSRB = srb;
979: abortCurrentSRBTimeout = kAbortTimeoutMS / kSCSITimerIntervalMS + 1;
980:
981: /*
982: * Issue abort or abort tag depending on whether the is a tagged request
983: */
984: SCRIPT_VAR(R_ld_AbortCode) = EndianSwap32( ((srb != (SRB *)-1) && (srb->nexus.tag >= MIN_SCSI_TAG)) ? 0x0d : 0x06 );
985: scriptRestartAddr = (u_int32_t) &chipRamAddrPhys[Ent_issueAbort_BDR];
986:
987: [self Sym8xxClearFifo];
988: }
989:
990: /*-----------------------------------------------------------------------------*
991: * This routine clears the script engine's SCSI and DMA fifos.
992: *
993: *-----------------------------------------------------------------------------*/
994: - (void) Sym8xxClearFifo
995: {
996: u_int8_t ctest3Reg;
997: u_int8_t stest2Reg;
998: u_int8_t stest3Reg;
999:
1000: stest2Reg = Sym8xxReadRegs( chipBaseAddr, STEST2, STEST2_SIZE );
1001: if ( stest2Reg & ROF )
1002: {
1003: Sym8xxWriteRegs( chipBaseAddr, STEST2, STEST2_SIZE, stest2Reg );
1004: }
1005:
1006: ctest3Reg = Sym8xxReadRegs( chipBaseAddr, CTEST3, CTEST3_SIZE );
1007: ctest3Reg |= CLF;
1008: Sym8xxWriteRegs( chipBaseAddr, CTEST3, CTEST3_SIZE, ctest3Reg );
1009:
1010: stest3Reg = Sym8xxReadRegs( chipBaseAddr, STEST3, STEST3_SIZE );
1011: stest3Reg |= CSF;
1012: Sym8xxWriteRegs( chipBaseAddr,STEST3, STEST3_SIZE, stest3Reg );
1013:
1014: do
1015: {
1016: ctest3Reg = Sym8xxReadRegs( chipBaseAddr, CTEST3, CTEST3_SIZE );
1017: stest2Reg = Sym8xxReadRegs( chipBaseAddr, STEST3, STEST3_SIZE );
1018: stest3Reg = Sym8xxReadRegs( chipBaseAddr, STEST3, STEST3_SIZE );
1019: }
1020: while( (ctest3Reg & CLF) || (stest3Reg & CSF) || (stest2Reg & ROF) );
1021: }
1022:
1023: /*-----------------------------------------------------------------------------*
1024: * This routine processes the target's response to our SDTR message.
1025: *
1026: * We calculate the values for the script engine's timing registers
1027: * for synchronous registers, and update our tables indicating that
1028: * requested data transfer mode is in-effect.
1029: *
1030: *-----------------------------------------------------------------------------*/
1031: - (void) Sym8xxNegotiateSDTR:(SRB *) srb Nexus:(Nexus *)nexus
1032: {
1033: u_int32_t x;
1034: u_int8_t *pMsg;
1035: u_int32_t syncPeriod;
1036:
1037: /*
1038: * If we were not negotiating, the send MsgReject to targets negotiation
1039: * attempt.
1040: */
1041: if ( !(srb->srbRequestFlags & ksrbRFNegotiateSync) )
1042: {
1043: [self Sym8xxSendMsgReject: srb];
1044: return;
1045: }
1046:
1047: /*
1048: * Get pointer to negotiation message received from target.
1049: */
1050: pMsg = (u_int8_t *) &SCRIPT_VAR(R_ld_message);
1051:
1052: /*
1053: * The target's SDTR response contains the (transfer period / 4).
1054: *
1055: * We set our sync clock divisor to 1, 2, or 4 giving us a clock rates
1056: * of:
1057: * 80Mhz (Period = 12.5ns),
1058: * 40Mhz (Period = 25.0ns)
1059: * 20Mhz (Period = 50.0ns)
1060: *
1061: * This is further divided by the value in the sxfer reg to give us the final sync clock rate.
1062: *
1063: * The requested sync period is scaled up by 1000 and the clock periods are scaled up by 10
1064: * giving a result scaled up by 100. This is rounded-up and converted to sxfer reg values.
1065: */
1066: syncPeriod = (u_int32_t)pMsg[3] << 2;
1067: if ( syncPeriod < 100 )
1068: {
1069: nexus->targetParms.scntl3Reg |= SCNTL3_INIT_875_ULTRA;
1070: x = (syncPeriod * 1000) / 125;
1071: }
1072: else if ( syncPeriod < 200 )
1073: {
1074: nexus->targetParms.scntl3Reg |= SCNTL3_INIT_875_FAST;
1075: x = (syncPeriod * 1000) / 250;
1076: }
1077: else
1078: {
1079: nexus->targetParms.scntl3Reg |= SCNTL3_INIT_875_SLOW;
1080: x = (syncPeriod * 1000) / 500;
1081: }
1082:
1083: if ( x % 100 ) x += 100;
1084:
1085: /*
1086: * sxferReg Bits: 5-0 - Transfer offset
1087: * 7-6 - Sync Clock Divisor (0 = sync clock / 4)
1088: */
1089: nexus->targetParms.sxferReg = ((x/100 - 4) << 5) | pMsg[4];
1090:
1091: /*
1092: * Update our per-target tables and set-up the hardware regs for this request.
1093: *
1094: * On reconnection attempts, the script will use our per-target tables to set-up
1095: * the scntl3 and sxfer registers in the script engine.
1096: */
1097: adapter->targetClocks[srb->target].sxferReg = nexus->targetParms.sxferReg;
1098: adapter->targetClocks[srb->target].scntl3Reg = nexus->targetParms.scntl3Reg;
1099:
1100: Sym8xxWriteRegs( chipBaseAddr, SCNTL3, SCNTL3_SIZE, nexus->targetParms.scntl3Reg );
1101: Sym8xxWriteRegs( chipBaseAddr, SXFER, SXFER_SIZE, nexus->targetParms.sxferReg );
1102:
1103: targets[srb->target].flags |= kTFXferSync;
1104:
1105: scriptRestartAddr = (u_int32_t) &chipRamAddrPhys[Ent_clearACK];
1106: }
1107:
1108: /*-----------------------------------------------------------------------------*
1109: * This routine processes the target's response to our WDTR message.
1110: *
1111: * In addition, if there is a pending SDTR message, this routine sends it
1112: * to the target.
1113: *
1114: *-----------------------------------------------------------------------------*/
1115: - (void) Sym8xxNegotiateWDTR:(SRB *) srb Nexus:(Nexus *)nexus
1116: {
1117: u_int8_t *pMsg;
1118: u_int32_t msgBytesSent;
1119: u_int32_t msgBytesLeft;
1120:
1121: /*
1122: * If we were not negotiating, the send MsgReject to targets negotiation
1123: * attempt.
1124: */
1125: if ( !(srb->srbRequestFlags & ksrbRFNegotiateWide) )
1126: {
1127: [self Sym8xxSendMsgReject: srb];
1128: return;
1129: }
1130:
1131: /*
1132: * Set Wide (16-bit) vs Narrow (8-bit) data transfer mode based on target's response.
1133: */
1134: pMsg = (u_int8_t *) &SCRIPT_VAR(R_ld_message);
1135:
1136: if ( pMsg[3] == 1 )
1137: {
1138: nexus->targetParms.scntl3Reg |= EWS;
1139: }
1140: else
1141: {
1142: nexus->targetParms.scntl3Reg &= ~EWS;
1143: }
1144:
1145: /*
1146: * Update our per-target tables and set-up the hardware regs for this request.
1147: *
1148: * On reconnection attempts, the script will use our per-target tables to set-up
1149: * the scntl3 and sxfer registers in the script engine.
1150: */
1151:
1152: adapter->targetClocks[srb->target].scntl3Reg = nexus->targetParms.scntl3Reg;
1153: Sym8xxWriteRegs( chipBaseAddr, SCNTL3, SCNTL3_SIZE, nexus->targetParms.scntl3Reg );
1154:
1155: targets[srb->target].flags |= kTFXferWide16;
1156:
1157: /*
1158: * If there any pending messages left for the target, send them now,
1159: */
1160: msgBytesSent = EndianSwap32( nexus->msg.length );
1161: msgBytesLeft = srb->srbMsgLength - msgBytesSent;
1162: if ( msgBytesLeft )
1163: {
1164: nexus->msg.length = EndianSwap32( msgBytesLeft );
1165: nexus->msg.ppData = EndianSwap32( EndianSwap32( nexus->msg.ppData ) + msgBytesSent );
1166: scriptRestartAddr = (u_int32_t) &chipRamAddrPhys[Ent_issueMessageOut];
1167: }
1168:
1169: /*
1170: * Otherwise, tell the script we're done with MsgOut phase.
1171: */
1172: else
1173: {
1174: scriptRestartAddr = (u_int32_t) &chipRamAddrPhys[Ent_clearACK];
1175: }
1176: }
1177:
1178: /*-----------------------------------------------------------------------------*
1179: * Reject message received from target.
1180: *
1181: *-----------------------------------------------------------------------------*/
1182: - (void) Sym8xxSendMsgReject:(SRB *) srb
1183: {
1184: srb->nexus.msg.ppData = EndianSwap32((u_int32_t)&srb->srbPhys->nexus.msgData);
1185: srb->nexus.msg.length = EndianSwap32(0x01);
1186: srb->nexus.msgData[0] = 0x07;
1187:
1188: scriptRestartAddr = (u_int32_t) &chipRamAddrPhys[Ent_issueMessageOut];
1189: }
1190:
1191: /*-----------------------------------------------------------------------------*
1192: * This routine snoops inquiry data.
1193: *
1194: * The indirect SCSI Disk driver in driverKit, does not bother to check the target's
1195: * capabilities before enabling Synchronous Negotiation or Cmd Queueing. If things
1196: * were left to themselves, targets that did not support tags would be broken since
1197: * the request comming from driverKit always indicate that tags are allowed.
1198: *
1199: *-----------------------------------------------------------------------------*/
1200: - (void) Sym8xxCheckInquiryData: (SRB *)srb
1201: {
1202: IOMemoryDescriptor *mem;
1203: inquiry_reply_t inqData;
1204: u_int32_t inqSize;
1205:
1206: bzero( &inqData, sizeof(inqData) );
1207:
1208: inqSize = (srb->xferDone < sizeof(inqData)) ? srb->xferDone : sizeof(inqData);
1209:
1210: mem = [[ IOSimpleMemoryDescriptor alloc ] initWithAddress: (void *)srb->xferBuffer length: inqSize ];
1211: [mem setClient: srb->xferClient];
1212:
1213: do
1214: {
1215: if ( srb->srbSCSIResult != SR_IOST_GOOD )
1216: {
1217: continue;
1218: }
1219: if ( srb->xferDone < offsetof(inquiry_reply_t, ir_vendorid) )
1220: {
1221: continue;
1222: }
1223:
1224: if ( [mem readFromClient: (void *) &inqData count: inqSize] != inqSize )
1225: {
1226: continue;
1227: }
1228: if ( inqData.ir_qual != DEVQUAL_OK )
1229: {
1230: continue;
1231: }
1232:
1233: if ( inqData.ir_wbus16 )
1234: {
1235: targets[srb->target].flags |= kTFXferWide16Supported;
1236: }
1237: if ( inqData.ir_sync )
1238: {
1239: targets[srb->target].flags |= kTFXferSyncSupported;
1240: }
1241: if ( inqData.ir_cmdque )
1242: {
1243: targets[srb->target].flags |= kTFCmdQueueSupported;
1244: }
1245: }
1246: while ( 0 );
1247: [mem release];
1248: }
1249:
1250:
1251: /*-----------------------------------------------------------------------------*
1252: * This routine initiates a SCSI Bus Reset.
1253: *
1254: * This may be an internally generated request as part of error recovery or
1255: * a client's bus reset request.
1256: *
1257: *-----------------------------------------------------------------------------*/
1258: - (void) Sym8xxSCSIBusReset: (SRB *)srb
1259: {
1260: if ( srb )
1261: {
1262: if ( resetSRB )
1263: {
1264: srb->srbSCSIResult = SR_IOST_CMDREJ;
1265: [srb->srbCmdLock unlockWith: ksrbCmdComplete];
1266: return;
1267: }
1268: resetSRB = srb;
1269: }
1270:
1271: Sym8xxWriteRegs( chipBaseAddr, SCNTL1, SCNTL1_SIZE, SCNTL1_SCSI_RST );
1272: IODelay( 25 );
1273: Sym8xxWriteRegs( chipBaseAddr, SCNTL1, SCNTL1_SIZE, SCNTL1_INIT );
1274: }
1275:
1276: /*-----------------------------------------------------------------------------*
1277: * This routine handles a SCSI Bus Reset interrupt.
1278: *
1279: * The SCSI Bus reset may be generated by a target on the bus, internally from
1280: * the driver's error recovery or from a client request.
1281: *
1282: * Once the reset is detected we establish a settle period where new client requests
1283: * are blocked in the client thread. In addition we flush all currently executing
1284: * scsi requests back to the client.
1285: *
1286: *-----------------------------------------------------------------------------*/
1287: - (void) Sym8xxProcessSCSIBusReset
1288: {
1289: SRB *srb = 0;
1290: Nexus *nexus = 0;
1291: u_int32_t i;
1292:
1293: /*
1294: * If we got another bus reset event during the settle period we extend the settle
1295: * period accordingly.
1296: */
1297: if ( resetQuiesceTimer )
1298: {
1299: resetQuiesceTimer = kResetQuiesceDelayMS / kSCSITimerIntervalMS + 1;
1300: return;
1301: }
1302:
1303: resetSeqNum = srbSeqNum;
1304: // kprintf("SCSI(Symbios8xx): Reset Started - SRB Seq = %d\n\r", resetSeqNum);
1305:
1306: /*
1307: * We take the resetQuiesceSem lock which will block new client thread requests.
1308: *
1309: * Note: The client thread checks resetQuiesceTimer for <> 0 before taking this lock.
1310: */
1311: [resetQuiesceSem lock];
1312: resetQuiesceTimer = kResetQuiesceDelayMS / kSCSITimerIntervalMS + 1;
1313:
1314: /*
1315: * We end any aborts currently in progress
1316: */
1317: abortCurrentSRB = (SRB *)NULL;
1318:
1319: if ( abortSRB )
1320: {
1321: [abortSRB->srbCmdLock unlockWith: ksrbCmdComplete];
1322: abortSRB = (SRB *) NULL;
1323: }
1324:
1325: [self Sym8xxClearFifo];
1326:
1327: /*
1328: * We return anything in our Nexus table back to the client
1329: */
1330: for ( i=0; i < MAX_SCSI_TAG; i++ )
1331: {
1332: nexus = adapter->nexusPtrsVirt[i];
1333: if ( nexus == (Nexus *) -1 )
1334: {
1335: continue;
1336: }
1337:
1338: srb = (SRB *)((u_int32_t)nexus - offsetof(SRB, nexus));
1339:
1340: srb->srbSCSIResult = SR_IOST_RESET;
1341:
1342: adapter->nexusPtrsVirt[i] = (Nexus *) -1;
1343: adapter->nexusPtrsPhys[i] = (Nexus *) -1;
1344:
1345: [srb->srbCmdLock unlockWith: ksrbCmdComplete];
1346: }
1347:
1348: /*
1349: * We clear the script's request mailboxes. Any work in the script mailboxes is
1350: * already in the NexusPtr tables so we have already have handled the SRB/Nexus
1351: * cleanup.
1352: */
1353: for ( i=0; i < MAX_SCHED_MAILBOXES; i++ )
1354: {
1355: adapter->schedMailBox[i] = 0;
1356: }
1357:
1358: SCRIPT_VAR(R_ld_AbortBdr_mailbox) = 0;
1359: SCRIPT_VAR(R_ld_IOdone_mailbox) = 0;
1360: SCRIPT_VAR(R_ld_counter) = 0;
1361: mailBoxIndex = 0;
1362:
1363: /*
1364: * Reset the data transfer mode/clocks in our per-target tables back to Async/Narrow 8-bit
1365: */
1366: for ( i=0; i < MAX_SCSI_TARGETS; i++ )
1367: {
1368: targets[i].flags &= ~(kTFXferSync | kTFXferWide16);
1369:
1370: adapter->targetClocks[i].scntl3Reg = SCNTL3_INIT_875;
1371: adapter->targetClocks[i].sxferReg = 0;
1372: }
1373:
1374: scriptRestartAddr = (u_int32_t) &chipRamAddrPhys[Ent_select_phase];
1375: Sym8xxWriteRegs( chipBaseAddr, DSP, DSP_SIZE, scriptRestartAddr );
1376:
1377: }
1378:
1379: /*-----------------------------------------------------------------------------*
1380: * This routine sets the SIGP bit in the script engine's ISTAT
1381: * register. This signals the script to wake-up for a WAIT for
1382: * reselection instruction. The script will then check the mailboxes
1383: * for work to do.
1384: *
1385: *-----------------------------------------------------------------------------*/
1386: - (void) Sym8xxSignalScript:(SRB *)srb
1387: {
1388: Sym8xxWriteRegs( chipBaseAddr, ISTAT, ISTAT_SIZE, SIGP );
1389: }
1390:
1391: /*-----------------------------------------------------------------------------*
1392: * Timeout handler.
1393: *
1394: * This routine is scheduled and implements timeouts for the driver.
1395: *
1396: * The following items are timed:
1397: *
1398: * - Reset settle period.
1399: * - Aborts
1400: * - SRBs
1401: *
1402: *-----------------------------------------------------------------------------*/
1403: - (void) timeoutOccurred
1404: {
1405: SRB *srb;
1406: Nexus *nexus;
1407: u_int32_t i;
1408: u_int32_t nexusIndex;
1409: u_int32_t mailboxNexusIndex = -1;
1410:
1411: if ( SCRIPT_VAR( R_ld_IOdone_mailbox ) )
1412: {
1413: mailboxNexusIndex = ((IODoneMailBox *)&SCRIPT_VAR(R_ld_IOdone_mailbox))->nexus;
1414: }
1415:
1416: nexusIndex = EndianSwap32( SCRIPT_VAR(R_ld_nexus_index) );
1417:
1418: /*
1419: * If we are in a reset settle period, suspend all other timing.
1420: *
1421: * When the reset settle period completes, return the SRB if the
1422: * client requested the bus reset. Also unlock the reset semaphore.
1423: */
1424: if ( resetQuiesceTimer )
1425: {
1426: if ( --resetQuiesceTimer )
1427: {
1428: goto timeoutOccurred_Exit;
1429: }
1430:
1431: if ( resetSRB )
1432: {
1433: [resetSRB->srbCmdLock unlockWith: ksrbCmdComplete];
1434: resetSRB = (SRB *) NULL;
1435: }
1436: // kprintf("SCSI(Symbios8xx): Reset Ended - SRB Seq = %d\n\r", srbSeqNum);
1437: [resetQuiesceSem unlock];
1438: }
1439:
1440: /*
1441: * Check whether an abort timed out. If it does, then its likely that a target is
1442: * hung on the bus. In this case the only recourse is to issue a SCSI Bus reset.
1443: */
1444: if ( abortCurrentSRB && abortCurrentSRBTimeout )
1445: {
1446: if ( !(--abortCurrentSRBTimeout) )
1447: {
1448: // kprintf("SCSI(Symbios8xx): Abort Current SRB failed - resetting\n\r");
1449: [self Sym8xxSCSIBusReset: (SRB *)NULL];
1450: goto timeoutOccurred_Exit;
1451: }
1452: }
1453:
1454: if ( abortSRB && abortSRBTimeout )
1455: {
1456: if ( !(--abortSRBTimeout) )
1457: {
1458: // kprintf("SCSI(Symbios8xx): MailBox abort failed - resetting\n\r");
1459: [self Sym8xxSCSIBusReset: (SRB *)NULL];
1460: goto timeoutOccurred_Exit;
1461: }
1462: }
1463:
1464: /*
1465: * Scan the Nexus pointer table looking for SRBs to timeout
1466: */
1467: for ( i=0; i < MAX_SCSI_TAG; i++ )
1468: {
1469: nexus = adapter->nexusPtrsVirt[i];
1470: if ( nexus == (Nexus *) -1 )
1471: {
1472: continue;
1473: }
1474:
1475: srb = (SRB *)((u_int32_t)nexus - offsetof(SRB, nexus));
1476: if ( srb->srbTimeout )
1477: {
1478: if ( !(--srb->srbTimeout) )
1479: {
1480: // kprintf("SCSI(Symbios8xx): Timeout - Target = %d SRB = %08x SRB Seq = %d\n\r",
1481: // srb->target, (u_int32_t)srb, srb->srbSeqNum );
1482:
1483: /* If the SRB we're timing out is in the script's IODone mailbox, then
1484: * clear the mailbox in addition to timing out the request.
1485: */
1486: if ( i == mailboxNexusIndex )
1487: {
1488: SCRIPT_VAR(R_ld_IOdone_mailbox) = 0;
1489: }
1490:
1491: /*
1492: * If the target for the SRB we're timing out is currently connected on
1493: * the SCSI Bus, then issue an abort. Since it is likely that the script
1494: * is running in this scenario, we call a Sym8xxAbortScript to shutdown the
1495: * script engine in an orderly fashion.
1496: */
1497: if ( i == nexusIndex )
1498: {
1499: [self Sym8xxAbortScript];
1500: srb->srbSCSIResult = SR_IOST_IOTO;
1501: [self Sym8xxAbortCurrent: srb];
1502: Sym8xxWriteRegs( chipBaseAddr, DSP, DSP_SIZE, scriptRestartAddr );
1503: }
1504:
1505: /*
1506: * If target for the SRB we're timing out is not on the SCSI bus, then
1507: * we mark the request as requiring an Abort and return it to the client
1508: * thread. The client thread will then schedule the abort.
1509: */
1510: else
1511: {
1512: adapter->nexusPtrsVirt[i] = (Nexus *) -1;
1513: adapter->nexusPtrsPhys[i] = (Nexus *) -1;
1514:
1515: srb->srbSCSIResult = SR_IOST_IOTO;
1516: srb->srbCmd = ksrbCmdProcessTimeout;
1517: [srb->srbCmdLock unlockWith: ksrbCmdComplete];
1518: }
1519: }
1520: }
1521: }
1522:
1523:
1524: timeoutOccurred_Exit: ;
1525: /*
1526: * Reschedule the next timer interval.
1527: */
1528: ns_timeout((func) Sym8xxTimerReq, (void *) self, (ns_time_t) kSCSITimerIntervalMS * 1000 * 1000, (int)CALLOUT_PRI_THREAD);
1529: }
1530:
1531: /*-----------------------------------------------------------------------------*
1532: * This routine does a mailbox abort.
1533: *
1534: * This type of abort is used for targets not currently connected to the SCSI Bus.
1535: *
1536: * The script will select the target and send a tag (if required) followed by the
1537: * appropriate abort message (abort/abort-tag)
1538: *
1539: *-----------------------------------------------------------------------------*/
1540: - (void) Sym8xxAbortBdr:(SRB *) srb
1541: {
1542: IOAbortBdrMailBox abortMailBox;
1543:
1544: abortSRB = srb;
1545: abortSRBTimeout = kAbortTimeoutMS / kSCSITimerIntervalMS + 1;
1546:
1547: /*
1548: * Setup a script variable containing the abort information.
1549: */
1550: abortMailBox.message = ( srb->nexus.tag < MIN_SCSI_TAG) ? 0x06 : 0x0d;
1551: abortMailBox.identify = srb->lun | 0xC0 ;
1552: abortMailBox.scsi_id = srb->target;
1553: abortMailBox.tag = ( srb->nexus.tag < MIN_SCSI_TAG) ? 0 : srb->nexus.tag;
1554:
1555: SCRIPT_VAR(R_ld_AbortBdr_mailbox) = *(u_int32_t *) &abortMailBox;
1556:
1557: [self Sym8xxSignalScript: srb];
1558: }
1559:
1560: /*-----------------------------------------------------------------------------*
1561: * This routine is used to shutdown the script engine in an orderly fashion.
1562: *
1563: * Normally the script engine automatically stops when an interrupt is generated. However,
1564: * in the case of timeouts we need to change the script engine's dsp reg (instruction pointer).
1565: * to issue an abort.
1566: *
1567: *-----------------------------------------------------------------------------*/
1568: - (void) Sym8xxAbortScript
1569: {
1570: ns_time_t currentTime;
1571: ns_time_t endTime;
1572:
1573: [self disableAllInterrupts];
1574:
1575: /*
1576: * We set the ABRT bit in ISTAT and spin until the script engine acknowledges the
1577: * abort or we timeout.
1578: */
1579: Sym8xxWriteRegs( chipBaseAddr, ISTAT, ISTAT_SIZE, ABRT );
1580:
1581: IOGetTimestamp( &endTime );
1582:
1583: endTime += (kAbortScriptTimeoutMS * 1000 * 1000);
1584:
1585: do
1586: {
1587: IOGetTimestamp( ¤tTime );
1588:
1589: istatReg = Sym8xxReadRegs( chipBaseAddr, ISTAT, ISTAT_SIZE );
1590:
1591: if ( istatReg & SIP )
1592: {
1593: Sym8xxReadRegs( chipBaseAddr, SIST, SIST_SIZE );
1594: continue;
1595: }
1596:
1597: if ( istatReg & DIP )
1598: {
1599: Sym8xxWriteRegs( chipBaseAddr, ISTAT, ISTAT_SIZE, 0x00 );
1600: Sym8xxReadRegs( chipBaseAddr, DSTAT, DSTAT_SIZE );
1601: break;
1602: }
1603: }
1604: while ( currentTime < endTime );
1605:
1606: istatReg = SIGP;
1607: Sym8xxWriteRegs( chipBaseAddr, ISTAT, ISTAT_SIZE, istatReg );
1608:
1609: [self enableAllInterrupts];
1610:
1611: if ( currentTime >= endTime )
1612: {
1613: // kprintf( "SCSI(Symbios8xx): Abort script failed - resetting bus\n\r" );
1614: [self Sym8xxSCSIBusReset: NULL];
1615: }
1616:
1617: }
1618:
1619: @end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.