![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Sym8xxExecute.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Drivers / scsi / drvSymbios8xx|
Return to Sym8xxExecute.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Drivers / scsi / drvSymbios8xx |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22:
23: /* Sym8xxExecute.m created by russb2 on Sat 30-May-1998 */
24:
25: #include "Sym8xxController.h"
26:
27: extern "C"
28: {
29: unsigned int ml_phys_read( vm_offset_t paddr );
30: };
31:
32: #if 0
33: static UInt32 dropInt = 0;
34: #endif
35:
36: void Sym8xxSCSIController::Sym8xxStartSRB( SRB *srb )
37: {
38:
39: srb->nexus.targetParms.scntl3Reg = adapter->targetClocks[srb->target].scntl3Reg;
40: srb->nexus.targetParms.sxferReg = adapter->targetClocks[srb->target].sxferReg;
41:
42: adapter->nexusPtrsVirt[srb->nexus.tag] = &srb->nexus;
43: adapter->nexusPtrsPhys[srb->nexus.tag] = (Nexus *)OSSwapHostToLittleInt32( (UInt32)&srb->srbPhys->nexus );
44: adapter->schedMailBox[mailBoxIndex++] = (Nexus *)OSSwapHostToLittleInt32 ( (UInt32)&srb->srbPhys->nexus );
45:
46: Sym8xxSignalScript( srb );
47: }
48:
49:
50: /*-----------------------------------------------------------------------------*
51: * Interrupts from the Symbios chipset are dispatched here at task time under the
52: * IOThread's context.
53: *-----------------------------------------------------------------------------*/
54: void Sym8xxSCSIController::interruptOccurred( IOInterruptEventSource *ies, int intCount )
55: {
56: do
57: {
58: /*
59: * The chipset's ISTAT reg gives us the general interrupting condiditions,
60: * with DSTAT and SIST providing more detailed information.
61: */
62: istatReg = Sym8xxReadRegs( chipBaseAddr, ISTAT, ISTAT_SIZE );
63:
64: /* The INTF bit in ISTAT indicates that the script is signalling the driver
65: * that its IODone mailbox is full and that we should process a completed
66: * request. The script continues to run after posting this interrupt unlike
67: * other chipset interrupts which require the driver to restart the script
68: * engine.
69: */
70: if ( istatReg & INTF )
71: {
72: Sym8xxWriteRegs( chipBaseAddr, ISTAT, ISTAT_SIZE, istatReg );
73: #if 0
74: if ( dropInt++ > 100 )
75: {
76: dropInt = 0;
77: SCRIPT_VAR(R_ld_IOdone_mailbox) = 0;
78: continue;
79: }
80: #endif
81: Sym8xxProcessIODone();
82: }
83:
84: /*
85: * Handle remaining interrupting conditions
86: */
87: if ( istatReg & (SIP | DIP) )
88: {
89: Sym8xxProcessInterrupt();
90: }
91: }
92: while ( istatReg & (SIP | DIP | INTF) );
93:
94: getWorkLoop()->enableAllInterrupts();
95:
96: }
97:
98: /*-----------------------------------------------------------------------------*
99: * Process a request posted in the script's IODone mailbox.
100: *
101: *-----------------------------------------------------------------------------*/
102: void Sym8xxSCSIController::Sym8xxProcessIODone()
103: {
104: SRB *srb;
105: Nexus *nexus;
106: IODoneMailBox *pMailBox;
107:
108:
109: /*
110: * The IODone mailbox contains an index into our Nexus pointer tables.
111: *
112: * The Nexus struct is part of the SRB so we can get our SRB address
113: * by subtracting the offset of the Nexus struct in the SRB.
114: */
115: pMailBox = (IODoneMailBox *)&SCRIPT_VAR(R_ld_IOdone_mailbox);
116: nexus = adapter->nexusPtrsVirt[pMailBox->nexus];
117: srb = (SRB *)((UInt32)nexus - offsetof(SRB, nexus));
118:
119: srb->srbSCSIStatus = pMailBox->status;
120:
121: if ( srb->srbSCSIStatus == kSCSIStatusCheckCondition )
122: {
123: Sym8xxCheckRequestSense( srb );
124: }
125:
126: if ( srb->srbSCSIResult == kIOReturnSuccess )
127: {
128: if ( srb->srbSCSIStatus != kSCSIStatusGood )
129: {
130: srb->srbSCSIResult = kIOReturnIOError;
131: }
132: }
133:
134: Sym8xxUpdateXferOffset( srb );
135:
136: /*
137: * Clear the completed Nexus pointer from our tables and clear the
138: * IODone mailbox.
139: */
140: adapter->nexusPtrsVirt[pMailBox->nexus] = (Nexus *) -1;
141: adapter->nexusPtrsPhys[pMailBox->nexus] = (Nexus *) -1;
142: SCRIPT_VAR(R_ld_IOdone_mailbox) = 0;
143:
144: /*
145: * Wake up the client's thread to do post-processing
146: */
147: Sym8xxCompleteSRB( srb );
148:
149: scriptRestartAddr = (UInt32) &chipRamAddrPhys[Ent_select_phase];
150: }
151: /*-----------------------------------------------------------------------------*
152: *
153: *
154: *-----------------------------------------------------------------------------*/
155: void Sym8xxSCSIController::Sym8xxCompleteSRB( SRB *srb )
156: {
157: IOSCSICommand *scsiCommand;
158: SCSIResults scsiResults;
159:
160: scsiCommand = srb->scsiCommand;
161:
162: bzero( &scsiResults, sizeof(scsiResults) );
163:
164: scsiResults.returnCode = srb->srbSCSIResult;
165:
166: if ( srb == abortSRB )
167: {
168: abortSRB = 0;
169: if ( abortReqPending == true )
170: {
171: abortReqPending = false;
172: enableCommands();
173: }
174: }
175: else
176: {
177: scsiResults.bytesTransferred = srb->xferDone;
178: scsiResults.scsiStatus = srb->srbSCSIStatus;
179: }
180:
181: scsiCommand->setResults( &scsiResults );
182: scsiCommand->complete();
183: }
184:
185: /*-----------------------------------------------------------------------------*
186: * General script interrupt processing
187: *
188: *-----------------------------------------------------------------------------*/
189: void Sym8xxSCSIController::Sym8xxProcessInterrupt()
190: {
191: SRB *srb = NULL;
192: Nexus *nexus = NULL;
193: UInt32 nexusIndex;
194: UInt32 scriptPhase;
195: UInt32 fifoCnt = 0;
196: UInt32 dspsReg = 0;
197: UInt32 dspReg = 0;
198:
199:
200: /*
201: * Read DSTAT/SIST regs to determine why the script stopped.
202: */
203: dstatReg = Sym8xxReadRegs( chipBaseAddr, DSTAT, DSTAT_SIZE );
204: IODelay(5);
205: sistReg = Sym8xxReadRegs( chipBaseAddr, SIST, SIST_SIZE );
206:
207: // printf( "SCSI(Symbios8xx): SIST = %04x DSTAT = %02x\n\r", sistReg, dstatReg );
208:
209: /*
210: * This Script var tells us what the script thinks it was doing when the interrupt occurred.
211: */
212: scriptPhase = OSSwapHostToLittleInt32( SCRIPT_VAR(R_ld_phase_flag) );
213:
214: /*
215: * SCSI Bus reset detected
216: *
217: * Clean up the carnage.
218: * Note: This may be either an adapter or target initiated reset.
219: */
220: if ( sistReg & RSTI )
221: {
222: Sym8xxProcessSCSIBusReset();
223: return;
224: }
225:
226: /*
227: * Calculate our current SRB/Nexus.
228: *
229: * Read a script var to determine the index of the nexus it was processing
230: * when the interrupt occurred. The script will invalidate the index if there
231: * is no target currently connected or the script cannot determine which target
232: * has reconnected.
233: */
234: nexusIndex = OSSwapHostToLittleInt32(SCRIPT_VAR(R_ld_nexus_index));
235: if ( nexusIndex >= MAX_SCSI_TAG )
236: {
237: Sym8xxProcessNoNexus();
238: return;
239: }
240: nexus = adapter->nexusPtrsVirt[nexusIndex];
241: if ( nexus == (Nexus *) -1 )
242: {
243: Sym8xxProcessNoNexus();
244: return;
245: }
246: srb = (SRB *)((UInt32)nexus - offsetof(SRB, nexus));
247:
248: scriptRestartAddr = (UInt32) &chipRamAddrPhys[Ent_phase_handler];
249:
250: /*
251: * Parity and SCSI Gross Errors.
252: *
253: * Abort the current connection. The abort completion will trigger
254: * clean-up of the current SRB/Nexus.
255: */
256: if ( sistReg & PAR )
257: {
258: srb->srbSCSIResult = kIOReturnIOError;
259: Sym8xxAbortCurrent( srb );
260: }
261:
262: else if ( sistReg & SGE )
263: {
264: Sym8xxAbortCurrent( srb );
265: }
266:
267: /*
268: * Unexpected disconnect.
269: *
270: * If we were currently trying to abort this connection then mark the abort
271: * as completed. For all cases clean-up and wake-up the client thread.
272: */
273: else if ( sistReg & UDC )
274: {
275: if ( srb->srbSCSIResult == kIOReturnSuccess )
276: {
277: srb->srbSCSIResult = kIOReturnAborted;
278: }
279: adapter->nexusPtrsVirt[nexusIndex] = (Nexus *) -1;
280: adapter->nexusPtrsPhys[nexusIndex] = (Nexus *) -1;
281:
282: if ( scriptPhase == A_kphase_ABORT_CURRENT )
283: {
284: abortCurrentSRB = NULL;
285: }
286:
287: Sym8xxCompleteSRB( srb );
288:
289: scriptRestartAddr = (UInt32) &chipRamAddrPhys[Ent_select_phase];
290: }
291:
292: /*
293: * Phase Mis-match
294: *
295: * If we are in MsgOut phase then calculate how much of the message we sent. For
296: * now, however, we dont handle the target rejecting messages, so the request is aborted.
297: *
298: * If we are in DataIn/DataOut phase. We update the SRB/Nexus with our current data
299: * pointers.
300: */
301: else if ( sistReg & MA )
302: {
303: if ( scriptPhase == A_kphase_MSG_OUT )
304: {
305: srb->srbMsgResid = Sym8xxCheckFifo( srb, &fifoCnt );
306: nexus->msg.ppData = OSSwapHostToLittleInt32( OSSwapHostToLittleInt32(nexus->msg.ppData)
307: + OSSwapHostToLittleInt32(nexus->msg.length)
308: - srb->srbMsgResid );
309: nexus->msg.length = OSSwapHostToLittleInt32( srb->srbMsgResid );
310:
311: Sym8xxAbortCurrent( srb );
312: }
313: else if ( (scriptPhase == A_kphase_DATA_OUT) || (scriptPhase == A_kphase_DATA_IN) )
314: {
315: Sym8xxAdjustDataPtrs( srb, nexus );
316: }
317: else
318: {
319: IOLog("SCSI(Symbios8xx): Unexpected phase mismatch - scriptPhase = %08x\n\r", (int)scriptPhase);
320: Sym8xxAbortCurrent( srb );
321: }
322:
323: Sym8xxClearFifo();
324: }
325:
326: /*
327: * Selection Timeout.
328: *
329: * Clean-up the current request.
330: */
331: else if ( sistReg & STO )
332: {
333: srb->srbSCSIResult = kIOReturnOffline;
334:
335: adapter->nexusPtrsVirt[nexusIndex] = (Nexus *) -1;
336: adapter->nexusPtrsPhys[nexusIndex] = (Nexus *) -1;
337: SCRIPT_VAR(R_ld_IOdone_mailbox) = 0;
338:
339: Sym8xxCompleteSRB( srb );
340:
341: scriptRestartAddr = (UInt32) &chipRamAddrPhys[Ent_select_phase];
342: }
343:
344: /*
345: * Handle script initiated interrupts
346: */
347: else if ( dstatReg & SIR )
348: {
349: dspsReg = Sym8xxReadRegs( chipBaseAddr, DSPS, DSPS_SIZE );
350:
351: // printf( "SCSI(Symbios8xx): DSPS = %08x\n\r", dspsReg );
352:
353: switch ( dspsReg )
354: {
355: /*
356: * Non-zero SCSI status
357: *
358: * Send request sense CDB or complete request depending on SCSI status value
359: */
360: case A_status_error:
361: Sym8xxProcessIODone();
362: break;
363:
364: /*
365: * Received SDTR/WDTR message from target.
366: *
367: * Prepare reply message if we requested negotiation. Otherwise reject
368: * target initiated negotiation.
369: */
370: case A_negotiateSDTR:
371: Sym8xxNegotiateSDTR( srb, nexus );
372: break;
373:
374: case A_negotiateWDTR:
375: Sym8xxNegotiateWDTR( srb, nexus );
376: break;
377:
378: /*
379: * Partial SG List completed.
380: *
381: * Refresh the list from the remaining addresses to be transfered and set the
382: * script engine to branch into the list.
383: */
384: case A_sglist_complete:
385: Sym8xxUpdateSGList( srb );
386: scriptRestartAddr = (UInt32)&srb->srbPhys->nexus.sgListData[2];
387: break;
388:
389: /*
390: * Completed abort request
391: *
392: * Clean-up the aborted request.
393: */
394: case A_abort_current:
395: adapter->nexusPtrsVirt[nexusIndex] = (Nexus *) -1;
396: adapter->nexusPtrsPhys[nexusIndex] = (Nexus *) -1;
397:
398: abortCurrentSRB = NULL;
399:
400: Sym8xxCompleteSRB( srb );
401:
402: scriptRestartAddr = (UInt32) &chipRamAddrPhys[Ent_select_phase];
403: break;
404:
405: /*
406: * Script detected protocol errors
407: *
408: * Abort the current request.
409: */
410: case A_unknown_msg_reject:
411: case A_unknown_phase:
412: case A_unexpected_msg:
413: case A_unexpected_ext_msg:
414: srb->srbSCSIResult = kIOReturnAborted;
415: Sym8xxAbortCurrent( srb );
416: break;
417:
418: default:
419: IOLog( "SCSI(Symbios8xx): Unknown Script Int = %08x\n\r", (int)dspsReg );
420: Sym8xxAbortCurrent( srb );
421: }
422: }
423:
424: /*
425: * Illegal script instruction.
426: *
427: * We're toast! Abort the current request and hope for the best!
428: */
429: else if ( dstatReg & IID )
430: {
431: dspReg = Sym8xxReadRegs( chipBaseAddr, DSP, DSP_SIZE );
432:
433: IOLog("SCSI(Symbios8xx): Illegal script instruction - dsp = %08x srb=%08x\n\r", (int)dspReg, (int)srb );
434:
435: Sym8xxAbortCurrent( srb );
436: }
437:
438: if ( scriptRestartAddr )
439: {
440: Sym8xxWriteRegs( chipBaseAddr, DSP, DSP_SIZE, scriptRestartAddr );
441: }
442: }
443:
444:
445: /*-----------------------------------------------------------------------------*
446: * Current Data Pointer calculations
447: *
448: * To do data transfers the driver generates a list of script instructions
449: * in system storage to deliver data to the requested physical addresses. The
450: * script branches to the list when the target enters data transfer phase.
451: *
452: * When the target changes phase during a data transfer, data is left trapped
453: * inside the various script engine registers. This routine determines how much
454: * data was not actually transfered to/from the target and generates a new
455: * S/G List entry for the partial transfer and a branch back into the original
456: * S/G list. These script instructions are stored in two reserved slots at the
457: * top of the original S/G List.
458: *
459: *-----------------------------------------------------------------------------*/
460: void Sym8xxSCSIController::Sym8xxAdjustDataPtrs( SRB *srb, Nexus *nexus )
461: {
462: UInt32 i;
463: UInt32 sgResid;
464: UInt32 fifoCnt;
465: UInt32 dspReg;
466: UInt32 sgDone;
467: UInt8 scntl2Reg;
468: Nexus *nexusPhys;
469:
470: /*
471: * Determine SG element residual
472: *
473: * This routine returns how much of the current S/G List element the
474: * script was processing remains to be sent/received. All the information
475: * required to do this is stored in the script engine's registers.
476: */
477: sgResid = Sym8xxCheckFifo( srb, &fifoCnt );
478:
479: /*
480: * Determine which script instruction in our SGList we were executing when
481: * the target changed phase.
482: *
483: * The script engine's dspReg tells us where the script thinks it was. Based
484: * on the physical address of our current SRB/Nexus we can calculate
485: * an index into our S/G List.
486: */
487: dspReg = Sym8xxReadRegs( chipBaseAddr, DSP, DSP_SIZE );
488:
489: i = ((dspReg - (UInt32)srb->srbPhys->nexus.sgListData) / sizeof(SGEntry)) - 1;
490:
491: if ( i > MAX_SGLIST_ENTRIES-1 )
492: {
493: IOLog("SCSI(Symbios8xx): Bad sgListIndex\n\r");
494: Sym8xxAbortCurrent( srb );
495: return;
496: }
497:
498: /*
499: * Wide/odd-byte transfers.
500: *
501: * When dealing with Wide data transfers, if a S/G List ends with an odd-transfer count, then a
502: * valid received data byte is left in the script engine's SWIDE register. The least painful way
503: * to recover this byte is to construct a small script thunk to transfer one additional byte. The
504: * script will automatically draw this byte from the SWIDE register rather than the SCSI bus.
505: * The script thunk then branches back to script's PhaseHandler entrypoint.
506: *
507: */
508: nexusPhys = &srb->srbPhys->nexus;
509:
510: scntl2Reg = Sym8xxReadRegs( chipBaseAddr, SCNTL2, SCNTL2_SIZE );
511: if ( scntl2Reg & WSR )
512: {
513: adapter->xferSWideInst[0] = OSSwapHostToLittleInt32( srb->directionMask | 1 );
514: adapter->xferSWideInst[1] = nexus->sgListData[i].physAddr;
515: adapter->xferSWideInst[2] = OSSwapHostToLittleInt32( 0x80080000 );
516: adapter->xferSWideInst[3] = OSSwapHostToLittleInt32( (UInt32)&chipRamAddrPhys[Ent_phase_handler] );
517:
518: scriptRestartAddr = (UInt32) adapterPhys->xferSWideInst;
519:
520: /*
521: * Note: There is an assumption here that the sgResid count will be > 1. It appears
522: * that the script engine does not generate a phase-mismatch interrupt until
523: * we attempt to move > 1 byte from the SCSI bus and the only byte available is
524: * in SWIDE.
525: */
526: sgResid--;
527: }
528:
529: /*
530: * Calculate partial S/G List instruction and branch
531: *
532: * Fill in slots 0/1 of the SGList based on the SGList index (i) and SGList residual count
533: * (sgResid) calculated above.
534: *
535: */
536: sgDone = (OSSwapHostToLittleInt32( nexus->sgListData[i].length ) & 0x00ffffff) - sgResid;
537:
538: nexus->sgListData[0].length = OSSwapHostToLittleInt32( sgResid | srb->directionMask );
539: nexus->sgListData[0].physAddr = OSSwapHostToLittleInt32( OSSwapHostToLittleInt32(nexus->sgListData[i].physAddr) + sgDone );
540: /*
541: * If a previously calculated SGList 0 entry was interrupted again, we dont need to calculate
542: * a new branch address since the previous one is still valid.
543: */
544: if ( i != 0 )
545: {
546: nexus->sgListData[1].length = OSSwapHostToLittleInt32( 0x80080000 );
547: nexus->sgListData[1].physAddr = OSSwapHostToLittleInt32( (UInt32)&nexusPhys->sgListData[i+1] );
548: nexus->sgNextIndex = i + 1;
549: }
550: nexus->ppSGList = (SGEntry *)OSSwapHostToLittleInt32( (UInt32) &nexusPhys->sgListData[0] );
551:
552: /*
553: * The script sets this Nexus variable to non-zero each time it calls the driver generated
554: * S/G list. This allows the driver's completion routines to differentiate between a successful
555: * transfer vs no data transfer at all.
556: */
557: nexus->dataXferCalled = 0;
558:
559: return;
560: }
561:
562: /*-----------------------------------------------------------------------------*
563: * Determine SG element residual
564: *
565: * This routine returns how much of the current S/G List element the
566: * script was processing remains to be sent/received. All the information
567: * required to do this is stored in the script engine's registers.
568: *
569: *-----------------------------------------------------------------------------*/
570: UInt32 Sym8xxSCSIController::Sym8xxCheckFifo( SRB *srb, UInt32 *pfifoCnt )
571: {
572: bool fSCSISend;
573: bool fXferSync;
574: UInt32 scriptPhase = 0;
575: UInt32 dbcReg = 0;
576: UInt32 dfifoReg = 0;
577: UInt32 ctest5Reg = 0;
578: UInt8 sstat0Reg = 0;
579: UInt8 sstat1Reg = 0;
580: UInt8 sstat2Reg = 0;
581: UInt32 fifoCnt = 0;
582: UInt32 sgResid = 0;
583:
584: scriptPhase = OSSwapHostToLittleInt32( SCRIPT_VAR(R_ld_phase_flag) );
585:
586: fSCSISend = (scriptPhase == A_kphase_DATA_OUT) || (scriptPhase == A_kphase_MSG_OUT);
587:
588: fXferSync = ((scriptPhase == A_kphase_DATA_OUT) || (scriptPhase == A_kphase_DATA_IN))
589: && (srb->nexus.targetParms.sxferReg & 0x1F);
590:
591: dbcReg = Sym8xxReadRegs( chipBaseAddr, DBC, DBC_SIZE ) & 0x00ffffff;
592:
593: if ( !(dstatReg & DFE) )
594: {
595: ctest5Reg = Sym8xxReadRegs( chipBaseAddr, CTEST5, CTEST5_SIZE );
596: dfifoReg = Sym8xxReadRegs( chipBaseAddr, DFIFO, DFIFO_SIZE );
597:
598: if ( ctest5Reg & DFS )
599: {
600: fifoCnt = ((((ctest5Reg & 0x03) << 8) | dfifoReg) - dbcReg) & 0x3ff;
601: }
602: else
603: {
604: fifoCnt = (dfifoReg - dbcReg) & 0x7f;
605: }
606: }
607:
608: sstat0Reg = Sym8xxReadRegs( chipBaseAddr, SSTAT0, SSTAT0_SIZE );
609: sstat2Reg = Sym8xxReadRegs( chipBaseAddr, SSTAT2, SSTAT2_SIZE );
610:
611: if ( fSCSISend )
612: {
613: fifoCnt += (sstat0Reg & OLF ) ? 1 : 0;
614: fifoCnt += (sstat2Reg & OLF1) ? 1 : 0;
615:
616: if ( fXferSync )
617: {
618: fifoCnt += (sstat0Reg & ORF ) ? 1 : 0;
619: fifoCnt += (sstat2Reg & ORF1) ? 1 : 0;
620: }
621: }
622: else
623: {
624: if ( fXferSync )
625: {
626: sstat1Reg = Sym8xxReadRegs( chipBaseAddr, SSTAT0, SSTAT0_SIZE );
627: fifoCnt += (sstat1Reg >> 4) | (sstat2Reg & FF4);
628: }
629: else
630: {
631: fifoCnt += (sstat0Reg & ILF ) ? 1 : 0;
632: fifoCnt += (sstat2Reg & ILF1) ? 1 : 0;
633: }
634: }
635:
636: sgResid = dbcReg + fifoCnt;
637: *pfifoCnt = fifoCnt;
638:
639: return sgResid;
640: }
641:
642: /*-----------------------------------------------------------------------------*
643: * Calculate transfer counts.
644: *
645: * This routine updates srb->xferDone with the amount of data transferred
646: * by the last S/G List executed.
647: *
648: *-----------------------------------------------------------------------------*/
649: void Sym8xxSCSIController::Sym8xxUpdateXferOffset( SRB *srb )
650: {
651: UInt32 i;
652: UInt32 xferOffset;
653:
654: /*
655: * srb->xferOffset contains the client buffer offset INCLUDING the range
656: * covered by the current SGList.
657: */
658: xferOffset = srb->xferOffset;
659:
660: /*
661: * If script did not complete the current transfer list then we need to determine
662: * how much of the list was completed.
663: */
664: if ( srb->nexus.dataXferCalled == 0 )
665: {
666: /*
667: * srb->xferOffsetPrev contains the client buffer offset EXCLUDING the
668: * range covered by the current SGList.
669: */
670: xferOffset = srb->xferOffsetPrev;
671:
672: /*
673: * Calculate bytes transferred for partially completed list.
674: *
675: * To calculate the amount of this list completed, we sum the residual amount
676: * in SGList Slot 0 and the completed list elements 2 to sgNextIndex-1.
677: */
678: if ( srb->nexus.sgNextIndex != 0 )
679: {
680: xferOffset += OSSwapHostToLittleInt32( srb->nexus.sgListData[srb->nexus.sgNextIndex-1].length )
681: - OSSwapHostToLittleInt32( srb->nexus.sgListData[0].length );
682:
683: for ( i=2; i < srb->nexus.sgNextIndex-1; i++ )
684: {
685: xferOffset += OSSwapHostToLittleInt32( srb->nexus.sgListData[i].length ) & 0x00ffffff;
686: }
687: }
688: }
689:
690: /*
691: * The script leaves the result of any Ignore Wide Residual message received from the target
692: * during the transfer.
693: */
694: xferOffset -= srb->nexus.wideResidCount;
695:
696:
697: #if 0
698: {
699: UInt32 resid = srb->xferOffset - xferOffset;
700: if ( resid )
701: {
702: IOLog( "SCSI(Symbios8xx): Incomplete transfer - Req Count = %08x Act Count = %08x - srb = %08x\n\r",
703: srb->xferCount, xferOffset, (UInt32)srb );
704: }
705: }
706: #endif
707:
708: srb->xferDone = xferOffset;
709: }
710:
711: /*-----------------------------------------------------------------------------*
712: * No SRB/Nexus Processing.
713: *
714: * In some cases (mainly Aborts) not having a SRB/Nexus is normal. In other
715: * cases it indicates a problem such a reconnection from a target that we
716: * have no record of.
717: *
718: *-----------------------------------------------------------------------------*/
719: void Sym8xxSCSIController::Sym8xxProcessNoNexus()
720: {
721: UInt32 dspsReg;
722: UInt32 dspReg = 0;
723: UInt32 scriptPhase = (UInt32)-1 ;
724:
725: scriptRestartAddr = (UInt32) &chipRamAddrPhys[Ent_select_phase];
726:
727: dspsReg = Sym8xxReadRegs( chipBaseAddr, DSPS, DSPS_SIZE );
728:
729: scriptPhase = OSSwapHostToLittleInt32( SCRIPT_VAR(R_ld_phase_flag) );
730:
731: /*
732: * If we were trying to abort or disconnect a target and the bus
733: * is now free we consider the abort to have completed.
734: */
735: if ( sistReg & UDC )
736: {
737: if ( (scriptPhase == A_kphase_ABORT_MAILBOX) && abortSRB )
738: {
739: Sym8xxCompleteSRB( abortSRB );
740: SCRIPT_VAR(R_ld_AbortBdr_mailbox) = 0;
741: }
742: else if ( scriptPhase == A_kphase_ABORT_CURRENT )
743: {
744: abortCurrentSRB = NULL;
745: }
746: }
747: /*
748: * If we were trying to connect to a target to send it an abort message, and
749: * we timed out, we consider the abort as completed.
750: *
751: * Note: In this case the target may be hung, but at least its not on the bus.
752: */
753: else if ( sistReg & STO )
754: {
755: if ( (scriptPhase == A_kphase_ABORT_MAILBOX) && abortSRB )
756: {
757: Sym8xxCompleteSRB( abortSRB );
758: SCRIPT_VAR(R_ld_AbortBdr_mailbox) = 0;
759: }
760: }
761:
762: /*
763: * If the script died, without a vaild nexusIndex, we abort anything that is currently
764: * connected and hope for the best!
765: */
766: else if ( dstatReg & IID )
767: {
768: dspReg = Sym8xxReadRegs( chipBaseAddr, DSP, DSP_SIZE );
769: IOLog("SCSI(Symbios8xx): Illegal script instruction - dsp = %08x srb=0\n\r", (int)dspReg );
770: Sym8xxAbortCurrent( (SRB *)-1 );
771: }
772:
773: /*
774: * Script signaled conditions
775: */
776: else if ( dstatReg & SIR )
777: {
778: switch ( dspsReg )
779: {
780: case A_abort_current:
781: abortCurrentSRB = NULL;
782: break;
783:
784: case A_abort_mailbox:
785: Sym8xxCompleteSRB( abortSRB );
786: SCRIPT_VAR(R_ld_AbortBdr_mailbox) = 0;
787: break;
788:
789: default:
790: Sym8xxAbortCurrent( (SRB *)-1 );
791: }
792: }
793: else
794: {
795: Sym8xxAbortCurrent( (SRB *)-1 );
796: }
797:
798: if ( scriptRestartAddr )
799: {
800: Sym8xxWriteRegs( chipBaseAddr, DSP, DSP_SIZE, scriptRestartAddr );
801: }
802: }
803:
804:
805: /*-----------------------------------------------------------------------------*
806: * Abort currently connected target.
807: *
808: *-----------------------------------------------------------------------------*/
809: void Sym8xxSCSIController::Sym8xxAbortCurrent( SRB *srb )
810: {
811: if ( abortCurrentSRB )
812: {
813: if ( abortCurrentSRB != srb )
814: {
815: IOLog("SCSI(Symbios8xx): Multiple abort immediate SRBs - resetting\n\r");
816: Sym8xxSCSIBusReset( (SRB *)0 );
817: }
818: return;
819: }
820:
821: abortCurrentSRB = srb;
822:
823: if ( srb != (SRB *)-1 )
824: {
825: if ( srb->srbSCSIResult == kIOReturnSuccess )
826: {
827: srb->srbSCSIResult = kIOReturnAborted;
828: }
829: }
830:
831: /*
832: * Issue abort or abort tag depending on whether the is a tagged request
833: */
834: SCRIPT_VAR(R_ld_AbortCode) = OSSwapHostToLittleInt32( ((srb != (SRB *)-1) && (srb->nexus.tag >= MIN_SCSI_TAG)) ? 0x0d : 0x06 );
835: scriptRestartAddr = (UInt32) &chipRamAddrPhys[Ent_issueAbort_BDR];
836:
837: Sym8xxClearFifo();
838: }
839:
840: /*-----------------------------------------------------------------------------*
841: * This routine clears the script engine's SCSI and DMA fifos.
842: *
843: *-----------------------------------------------------------------------------*/
844: void Sym8xxSCSIController::Sym8xxClearFifo()
845: {
846: UInt8 ctest3Reg;
847: UInt8 stest2Reg;
848: UInt8 stest3Reg;
849:
850: stest2Reg = Sym8xxReadRegs( chipBaseAddr, STEST2, STEST2_SIZE );
851: if ( stest2Reg & ROF )
852: {
853: Sym8xxWriteRegs( chipBaseAddr, STEST2, STEST2_SIZE, stest2Reg );
854: }
855:
856: ctest3Reg = Sym8xxReadRegs( chipBaseAddr, CTEST3, CTEST3_SIZE );
857: ctest3Reg |= CLF;
858: Sym8xxWriteRegs( chipBaseAddr, CTEST3, CTEST3_SIZE, ctest3Reg );
859:
860: stest3Reg = Sym8xxReadRegs( chipBaseAddr, STEST3, STEST3_SIZE );
861: stest3Reg |= CSF;
862: Sym8xxWriteRegs( chipBaseAddr,STEST3, STEST3_SIZE, stest3Reg );
863:
864: do
865: {
866: ctest3Reg = Sym8xxReadRegs( chipBaseAddr, CTEST3, CTEST3_SIZE );
867: stest2Reg = Sym8xxReadRegs( chipBaseAddr, STEST3, STEST3_SIZE );
868: stest3Reg = Sym8xxReadRegs( chipBaseAddr, STEST3, STEST3_SIZE );
869: }
870: while( (ctest3Reg & CLF) || (stest3Reg & CSF) || (stest2Reg & ROF) );
871: }
872:
873: /*-----------------------------------------------------------------------------*
874: * This routine processes the target's response to our SDTR message.
875: *
876: * We calculate the values for the script engine's timing registers
877: * for synchronous registers, and update our tables indicating that
878: * requested data transfer mode is in-effect.
879: *
880: *-----------------------------------------------------------------------------*/
881: void Sym8xxSCSIController::Sym8xxNegotiateSDTR( SRB *srb, Nexus *nexus )
882: {
883: UInt32 x;
884: UInt8 *pMsg;
885: UInt32 syncPeriod;
886:
887: /*
888: * If we were not negotiating, the send MsgReject to targets negotiation
889: * attempt.
890: */
891: if ( !(srb->srbCDBFlags & kCDBFlagsNegotiateSDTR) )
892: {
893: Sym8xxSendMsgReject( srb );
894: return;
895: }
896:
897: /*
898: * Get pointer to negotiation message received from target.
899: */
900: pMsg = (UInt8 *) &SCRIPT_VAR(R_ld_message);
901:
902: /*
903: * The target's SDTR response contains the (transfer period / 4).
904: *
905: * We set our sync clock divisor to 1, 2, or 4 giving us a clock rates
906: * of:
907: * 80Mhz (Period = 12.5ns),
908: * 40Mhz (Period = 25.0ns)
909: * 20Mhz (Period = 50.0ns)
910: *
911: * This is further divided by the value in the sxfer reg to give us the final sync clock rate.
912: *
913: * The requested sync period is scaled up by 1000 and the clock periods are scaled up by 10
914: * giving a result scaled up by 100. This is rounded-up and converted to sxfer reg values.
915: */
916: if ( pMsg[4] == 0 )
917: {
918: nexus->targetParms.scntl3Reg &= 0x0f;
919: nexus->targetParms.sxferReg = 0x00;
920: }
921: else
922: {
923: syncPeriod = (UInt32)pMsg[3] << 2;
924: if ( syncPeriod < 100 )
925: {
926: nexus->targetParms.scntl3Reg |= SCNTL3_INIT_875_ULTRA;
927: x = (syncPeriod * 1000) / 125;
928: }
929: else if ( syncPeriod < 200 )
930: {
931: nexus->targetParms.scntl3Reg |= SCNTL3_INIT_875_FAST;
932: x = (syncPeriod * 1000) / 250;
933: }
934: else
935: {
936: nexus->targetParms.scntl3Reg |= SCNTL3_INIT_875_SLOW;
937: x = (syncPeriod * 1000) / 500;
938: }
939:
940: if ( x % 100 ) x += 100;
941:
942: /*
943: * sxferReg Bits: 5-0 - Transfer offset
944: * 7-6 - Sync Clock Divisor (0 = sync clock / 4)
945: */
946: nexus->targetParms.sxferReg = ((x/100 - 4) << 5) | pMsg[4];
947: }
948:
949: /*
950: * Update our per-target tables and set-up the hardware regs for this request.
951: *
952: * On reconnection attempts, the script will use our per-target tables to set-up
953: * the scntl3 and sxfer registers in the script engine.
954: */
955: adapter->targetClocks[srb->target].sxferReg = nexus->targetParms.sxferReg;
956: adapter->targetClocks[srb->target].scntl3Reg = nexus->targetParms.scntl3Reg;
957:
958: Sym8xxWriteRegs( chipBaseAddr, SCNTL3, SCNTL3_SIZE, nexus->targetParms.scntl3Reg );
959: Sym8xxWriteRegs( chipBaseAddr, SXFER, SXFER_SIZE, nexus->targetParms.sxferReg );
960:
961: scriptRestartAddr = (UInt32) &chipRamAddrPhys[Ent_clearACK];
962: }
963:
964: /*-----------------------------------------------------------------------------*
965: * This routine processes the target's response to our WDTR message.
966: *
967: * In addition, if there is a pending SDTR message, this routine sends it
968: * to the target.
969: *
970: *-----------------------------------------------------------------------------*/
971: void Sym8xxSCSIController::Sym8xxNegotiateWDTR( SRB *srb, Nexus *nexus )
972: {
973: UInt8 *pMsg;
974: UInt32 msgBytesSent;
975: UInt32 msgBytesLeft;
976:
977: /*
978: * If we were not negotiating, the send MsgReject to targets negotiation
979: * attempt.
980: */
981: if ( !(srb->srbCDBFlags & kCDBFlagsNegotiateWDTR) )
982: {
983: Sym8xxSendMsgReject( srb );
984: return;
985: }
986:
987: /*
988: * Set Wide (16-bit) vs Narrow (8-bit) data transfer mode based on target's response.
989: */
990: pMsg = (UInt8 *) &SCRIPT_VAR(R_ld_message);
991:
992: if ( pMsg[3] == 1 )
993: {
994: nexus->targetParms.scntl3Reg |= EWS;
995: }
996: else
997: {
998: nexus->targetParms.scntl3Reg &= ~EWS;
999: }
1000:
1001: /*
1002: * Update our per-target tables and set-up the hardware regs for this request.
1003: *
1004: * On reconnection attempts, the script will use our per-target tables to set-up
1005: * the scntl3 and sxfer registers in the script engine.
1006: */
1007:
1008: adapter->targetClocks[srb->target].scntl3Reg = nexus->targetParms.scntl3Reg;
1009: Sym8xxWriteRegs( chipBaseAddr, SCNTL3, SCNTL3_SIZE, nexus->targetParms.scntl3Reg );
1010:
1011:
1012: /*
1013: * If there any pending messages left for the target, send them now,
1014: */
1015: msgBytesSent = OSSwapHostToLittleInt32( nexus->msg.length );
1016: msgBytesLeft = srb->srbMsgLength - msgBytesSent;
1017: if ( msgBytesLeft )
1018: {
1019: nexus->msg.length = OSSwapHostToLittleInt32( msgBytesLeft );
1020: nexus->msg.ppData = OSSwapHostToLittleInt32( OSSwapHostToLittleInt32( nexus->msg.ppData ) + msgBytesSent );
1021: scriptRestartAddr = (UInt32) &chipRamAddrPhys[Ent_issueMessageOut];
1022: }
1023:
1024: /*
1025: * Otherwise, tell the script we're done with MsgOut phase.
1026: */
1027: else
1028: {
1029: scriptRestartAddr = (UInt32) &chipRamAddrPhys[Ent_clearACK];
1030: }
1031: }
1032:
1033: /*-----------------------------------------------------------------------------*
1034: * Reject message received from target.
1035: *
1036: *-----------------------------------------------------------------------------*/
1037: void Sym8xxSCSIController::Sym8xxSendMsgReject( SRB *srb )
1038: {
1039: srb->nexus.msg.ppData = OSSwapHostToLittleInt32((UInt32)&srb->srbPhys->nexus.msgData);
1040: srb->nexus.msg.length = OSSwapHostToLittleInt32(0x01);
1041: srb->nexus.msgData[0] = 0x07;
1042:
1043: scriptRestartAddr = (UInt32) &chipRamAddrPhys[Ent_issueMessageOut];
1044: }
1045:
1046:
1047: /*-----------------------------------------------------------------------------*
1048: * This routine initiates a SCSI Bus Reset.
1049: *
1050: * This may be an internally generated request as part of error recovery or
1051: * a client's bus reset request.
1052: *
1053: *-----------------------------------------------------------------------------*/
1054: void Sym8xxSCSIController::Sym8xxSCSIBusReset( SRB *srb )
1055: {
1056: if ( srb )
1057: {
1058: if ( resetSRB )
1059: {
1060: srb->srbSCSIResult = kIOReturnBusy;
1061: Sym8xxCompleteSRB( srb );
1062: return;
1063: }
1064: resetSRB = srb;
1065: }
1066:
1067: Sym8xxAbortScript();
1068:
1069: Sym8xxWriteRegs( chipBaseAddr, SCNTL1, SCNTL1_SIZE, SCNTL1_SCSI_RST );
1070: IODelay( 100 );
1071: Sym8xxWriteRegs( chipBaseAddr, SCNTL1, SCNTL1_SIZE, SCNTL1_INIT );
1072: }
1073:
1074: /*-----------------------------------------------------------------------------*
1075: * This routine handles a SCSI Bus Reset interrupt.
1076: *
1077: * The SCSI Bus reset may be generated by a target on the bus, internally from
1078: * the driver's error recovery or from a client request.
1079: *
1080: * Once the reset is detected we establish a settle period where new client requests
1081: * are blocked in the client thread. In addition we flush all currently executing
1082: * scsi requests back to the client.
1083: *
1084: *-----------------------------------------------------------------------------*/
1085: void Sym8xxSCSIController::Sym8xxProcessSCSIBusReset()
1086: {
1087: UInt32 i;
1088:
1089: Sym8xxClearFifo();
1090:
1091: /*
1092: * We clear the script's request mailboxes. Any work in the script mailboxes is
1093: * already in the NexusPtr tables so we have already have handled the SRB/Nexus
1094: * cleanup.
1095: */
1096: for ( i=0; i < MAX_SCHED_MAILBOXES; i++ )
1097: {
1098: adapter->schedMailBox[i] = 0;
1099: }
1100:
1101: SCRIPT_VAR(R_ld_AbortBdr_mailbox) = 0;
1102: SCRIPT_VAR(R_ld_IOdone_mailbox) = 0;
1103: SCRIPT_VAR(R_ld_counter) = 0;
1104: mailBoxIndex = 0;
1105:
1106:
1107: /*
1108: * Reset the data transfer mode/clocks in our per-target tables back to Async/Narrow 8-bit
1109: */
1110: for ( i=0; i < MAX_SCSI_TARGETS; i++ )
1111: {
1112: adapter->targetClocks[i].scntl3Reg = SCNTL3_INIT_875;
1113: adapter->targetClocks[i].sxferReg = 0;
1114: }
1115:
1116: scriptRestartAddr = (UInt32) &chipRamAddrPhys[Ent_select_phase];
1117: Sym8xxWriteRegs( chipBaseAddr, DSP, DSP_SIZE, scriptRestartAddr );
1118:
1119: if ( resetSRB )
1120: {
1121: resetSRB->srbSCSIResult = kIOReturnSuccess;
1122: Sym8xxCompleteSRB( resetSRB );
1123: resetSRB = 0;
1124: }
1125: else if ( initialReset == true )
1126: {
1127: initialReset = false;
1128: }
1129: else
1130: {
1131: resetOccurred();
1132: }
1133: }
1134:
1135: /*-----------------------------------------------------------------------------*
1136: * This routine sets the SIGP bit in the script engine's ISTAT
1137: * register. This signals the script to wake-up for a WAIT for
1138: * reselection instruction. The script will then check the mailboxes
1139: * for work to do.
1140: *
1141: *-----------------------------------------------------------------------------*/
1142: void Sym8xxSCSIController::Sym8xxSignalScript( SRB *srb )
1143: {
1144: Sym8xxWriteRegs( chipBaseAddr, ISTAT, ISTAT_SIZE, SIGP );
1145: }
1146:
1147: /*-----------------------------------------------------------------------------*
1148: *
1149: *
1150: *
1151: *
1152: *
1153: *-----------------------------------------------------------------------------*/
1154: void Sym8xxSCSIController::Sym8xxCheckRequestSense( SRB *srb )
1155: {
1156: IOSCSICommand *scsiCommand;
1157: IOMemoryDescriptor *reqSenseDesc;
1158:
1159: scsiCommand = srb->scsiCommand;
1160:
1161: scsiCommand->getPointers( &reqSenseDesc, 0, 0, true );
1162:
1163: if ( reqSenseDesc != 0 )
1164: {
1165: Sym8xxCancelMailBox( srb->target, srb->lun, true );
1166: }
1167: }
1168:
1169: /*-----------------------------------------------------------------------------*
1170: * This routine does a mailbox abort.
1171: *
1172: * This type of abort is used for targets not currently connected to the SCSI Bus.
1173: *
1174: * The script will select the target and send a tag (if required) followed by the
1175: * appropriate abort message (abort/abort-tag)
1176: *
1177: *-----------------------------------------------------------------------------*/
1178: void Sym8xxSCSIController::Sym8xxAbortBdr( SRB *srb )
1179: {
1180: IOAbortBdrMailBox abortMailBox;
1181:
1182: abortSRB = srb;
1183:
1184: /*
1185: * Setup a script variable containing the abort information.
1186: */
1187: abortMailBox.identify = srb->nexus.msgData[0];
1188: abortMailBox.tag = srb->nexus.msgData[1];
1189: abortMailBox.message = srb->nexus.msgData[2];
1190: abortMailBox.scsi_id = srb->target;
1191:
1192: SCRIPT_VAR(R_ld_AbortBdr_mailbox) = *(UInt32 *) &abortMailBox;
1193:
1194: Sym8xxSignalScript( srb );
1195: }
1196:
1197: /*-----------------------------------------------------------------------------*
1198: *
1199: *
1200: *
1201: *
1202: *-----------------------------------------------------------------------------*/
1203: bool Sym8xxSCSIController::Sym8xxCancelMailBox( Nexus *nexusCancel )
1204: {
1205: Nexus *nexusPhys;
1206: UInt32 i;
1207:
1208: nexusPhys = (Nexus *)OSSwapHostToLittleInt32( (UInt32)nexusCancel );
1209: for ( i=0; i < MAX_SCHED_MAILBOXES; i++ )
1210: {
1211: if ( nexusPhys == adapter->schedMailBox[i] )
1212: {
1213: adapter->schedMailBox[i] = (Nexus *)OSSwapHostToLittleInt32( kMailBoxCancel );
1214: return true;
1215: }
1216: }
1217: return false;
1218: }
1219:
1220:
1221: /*-----------------------------------------------------------------------------*
1222: *
1223: *
1224: *
1225: *
1226: *-----------------------------------------------------------------------------*/
1227: void Sym8xxSCSIController::Sym8xxCancelMailBox( UInt32 target, UInt32 lun, bool fReschedule )
1228: {
1229: UInt32 tag;
1230: UInt32 tagPos;
1231: UInt32 tagShift;
1232:
1233: UInt32 i;
1234:
1235: SRB *srb;
1236: Nexus *nexus;
1237: Nexus *nexusPhys;
1238:
1239: tagPos = offsetof(Nexus, tag) & 0x03;
1240: tagShift = 24 - (tagPos << 3);
1241:
1242: for ( i=0; i < MAX_SCHED_MAILBOXES; i++ )
1243: {
1244: nexusPhys = (Nexus *)OSSwapHostToLittleInt32( (UInt32)adapter->schedMailBox[i] );
1245: if ( (nexusPhys != (Nexus *)kMailBoxEmpty) && (nexusPhys != (Nexus *)kMailBoxCancel) )
1246: {
1247: /*
1248: * Read the 'tag' byte given Nexus physical address from the mailBox.
1249: * Look-up the virtual address of the corresponding Nexus struct.
1250: */
1251: tag = ml_phys_read((UInt32)&nexusPhys->tag - tagPos);
1252: tag = (tag >> tagShift) & 0xff;
1253:
1254: nexus = adapter->nexusPtrsVirt[tag];
1255: if ( nexus == (Nexus *)-1 )
1256: {
1257: continue;
1258: }
1259:
1260: /*
1261: * If the SCSI target of the mailbox entry matches the abort SRB target,
1262: * then we may have a winner.
1263: */
1264: srb = (SRB *)((UInt32)nexus - offsetof(SRB, nexus));
1265:
1266: if ( srb->target == target )
1267: {
1268: /*
1269: * For a device reset, we cancel all requests for that target regardless of lun.
1270: * For an abort all, we must match on both target and lun
1271: */
1272: if ( (lun == (UInt32)-1) || (srb->lun == lun) )
1273: {
1274: adapter->schedMailBox[i] = (Nexus *)OSSwapHostToLittleInt32( kMailBoxCancel );
1275:
1276: if ( fReschedule == true )
1277: {
1278: rescheduleCommand( srb->scsiCommand );
1279: }
1280: }
1281: }
1282: }
1283: }
1284: }
1285:
1286: /*-----------------------------------------------------------------------------*
1287: * This routine is used to shutdown the script engine in an orderly fashion.
1288: *
1289: * Normally the script engine automatically stops when an interrupt is generated. However,
1290: * in the case of timeouts we need to change the script engine's dsp reg (instruction pointer).
1291: * to issue an abort.
1292: *
1293: *-----------------------------------------------------------------------------*/
1294: void Sym8xxSCSIController::Sym8xxAbortScript()
1295: {
1296: mach_timespec_t currentTime;
1297: mach_timespec_t startTime;
1298:
1299: getWorkLoop()->disableAllInterrupts();
1300:
1301: /*
1302: * We set the ABRT bit in ISTAT and spin until the script engine acknowledges the
1303: * abort or we timeout.
1304: */
1305: Sym8xxWriteRegs( chipBaseAddr, ISTAT, ISTAT_SIZE, ABRT );
1306:
1307: IOGetTime( &startTime );
1308:
1309: do
1310: {
1311: IOGetTime( ¤tTime );
1312: SUB_MACH_TIMESPEC( ¤tTime, &startTime );
1313:
1314: istatReg = Sym8xxReadRegs( chipBaseAddr, ISTAT, ISTAT_SIZE );
1315:
1316: if ( istatReg & SIP )
1317: {
1318: Sym8xxReadRegs( chipBaseAddr, SIST, SIST_SIZE );
1319: continue;
1320: }
1321:
1322: if ( istatReg & DIP )
1323: {
1324: Sym8xxWriteRegs( chipBaseAddr, ISTAT, ISTAT_SIZE, 0x00 );
1325: Sym8xxReadRegs( chipBaseAddr, DSTAT, DSTAT_SIZE );
1326: break;
1327: }
1328: }
1329: while ( currentTime.tv_nsec < (kAbortScriptTimeoutMS * 1000 * 1000) );
1330:
1331: istatReg = SIGP;
1332: Sym8xxWriteRegs( chipBaseAddr, ISTAT, ISTAT_SIZE, istatReg );
1333:
1334: getWorkLoop()->enableAllInterrupts();
1335:
1336: if ( currentTime.tv_nsec >= (kAbortScriptTimeoutMS * 1000 * 1000) )
1337: {
1338: IOLog( "SCSI(Symbios8xx): Abort script failed - resetting bus\n\r" );
1339: }
1340:
1341: }
1342:
1343:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.