![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to curio.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 / drvCurio|
Return to curio.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Drivers / scsi / drvCurio |
1.1 root 1: /*
2: * Copyright (c) 1998-2000 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: /* Copyright 1997-1999 Apple Computer Inc. All Rights Reserved. */
24: /* @author Martin Minow */
25: /* Edit History */
26: /* 1997.02.13 MM Initial conversion from AMDPCSCSIDriver sources. */
27: /* */
28:
29:
30:
31:
32: #include <string.h> /* bzero is defined in string.h */
33: #include <mach/clock_types.h>
34: #include <libkern/OSByteOrder.h>
35: #include <IOKit/IOLib.h>
36: #include <IOKit/IOInterruptEventSource.h>
37: #include <IOKit/pci/IOPCIDevice.h>
38: #include <IOKit/ppc/IODBDMA.h>
39: #include <IOKit/system.h> /* Definition of flush_dcache */
40: #include <IOKit/scsi/IOSCSIParallelInterface.h>
41:
42: #include "curio.h"
43:
44:
45:
46:
47: extern void IOGetTime( mach_timespec_t *clock_time );
48: extern void kprintf( const char *, ... );
49: extern void call_kdp(); // for debugging
50:
51:
52: #if CustomMiniMon
53: extern globals g; /**** Use custom MiniMon's globals ****/
54: extern UInt32 gMESH_DBDMA, gMESH_DBDMA_Phys;
55: #else
56: // globals g; /**** Instantiate the globals ****/
57: static globals g; /**** Instantiate the globals ****/
58: #endif /* CustomMiniMon */
59:
60:
61: OSDefineMetaClassAndStructors( CurioSCSIController, IOSCSIParallelController ) ;
62:
63:
64: #define kIOReturnParityError kIOReturnIOError /// ??? add to IOReturn.h
65: #define kIOReturnSelectionError kIOReturnIOError /// ??? add to IOReturn.h
66:
67:
68: enum /***** values for g.intLevel: *****/
69: {
70: kLevelISR = 0x80, /* In Interrupt Service Routine */
71: kLevelLocked = 0x40, /* Curio interrupts locked out */
72: kLevelSIH = 0x20, /* In Secondary Interrupt Handler */
73: kLevelLatched = 0x10 /* Interrupt latched */
74: };
75:
76:
77:
78: #if USE_ELG && !CustomMiniMon
79: static void AllocateEventLog( UInt32 size )
80: {
81: if ( g.evLogBuf )
82: return;
83:
84: g.evLogFlag = 0; /* assume insufficient memory */
85: g.evLogBuf = (UInt8*)kalloc( size );
86: if ( !g.evLogBuf )
87: {
88: kprintf( "AllocateEventLog - CurioSCSIController evLog allocation failed " );
89: return;
90: }
91:
92: bzero( g.evLogBuf, size );
93: g.evLogBufp = g.evLogBuf;
94: g.evLogBufe = g.evLogBufp + kEvLogSize - 0x20; // ??? overran buffer?
95: g.evLogFlag = 0xFEEDBEEF;
96: // g.evLogFlag = 'step';
97: // g.evLogFlag = 0x0333;
98: return;
99: }/* end AllocateEventLog */
100:
101:
102: static void EvLog( UInt32 a, UInt32 b, UInt32 ascii, char* str )
103: {
104: register UInt32 *lp; /* Long pointer */
105: mach_timespec_t time;
106:
107: if ( g.evLogFlag == 0 )
108: return;
109:
110: IOGetTime( &time );
111:
112: lp = (UInt32*)g.evLogBufp;
113: g.evLogBufp += 0x10;
114:
115: if ( g.evLogBufp >= g.evLogBufe ) /* handle buffer wrap around if any */
116: { g.evLogBufp = g.evLogBuf;
117: if ( g.evLogFlag != 0xFEEDBEEF )
118: g.evLogFlag = 0; /* stop tracing if wrap undesired */
119: }
120:
121: /* compose interrupt level with 3 byte time stamp: */
122:
123: *lp++ = (g.intLevel << 24) | ((time.tv_nsec >> 10) & 0x003FFFFF); // ~ 1 microsec resolution
124: *lp++ = a;
125: *lp++ = b;
126: *lp = ascii;
127:
128: if( g.evLogFlag == 'step' )
129: { char code[ 5 ];
130: *(UInt32*)&code = ascii; code[ 4 ] = 0;
131: // kprintf( "%8x curio: %8x %8x %s %s\n", time.tv_nsec>>10, a, b, code, str );
132: kprintf( "%8x curio: %8x %8x %s\n", time.tv_nsec>>10, a, b, code );
133: }
134:
135: return;
136: }/* end EvLog */
137:
138:
139: static void Pause( UInt32 a, UInt32 b, UInt32 ascii, char* str )
140: {
141: char work [ 256 ];
142: char name[] = "CurioSCSIController:";
143: char *bp = work;
144: UInt8 x;
145: int i;
146:
147:
148: EvLog( a, b, ascii, str );
149: EvLog( '****', '** P', 'ause', "*** Pause" );
150:
151: bcopy( name, bp, sizeof( name ) );
152: bp += sizeof( name ) - 1;
153:
154: *bp++ = '{'; // prepend p1 in hex:
155: for ( i = 7; i >= 0; --i )
156: {
157: x = a & 0x0F;
158: if ( x < 10 )
159: x += '0';
160: else x += 'A' - 10;
161: bp[ i ] = x;
162: a >>= 4;
163: }
164: bp += 8;
165:
166: *bp++ = ' '; // prepend p2 in hex:
167:
168: for ( i = 7; i >= 0; --i )
169: {
170: x = b & 0x0F;
171: if ( x < 10 )
172: x += '0';
173: else x += 'A' - 10;
174: bp[ i ] = x;
175: b >>= 4;
176: }
177: bp += 8;
178: *bp++ = '}';
179:
180: *bp++ = ' ';
181:
182: for ( i = sizeof( work ) - (int)(bp - work); i && (*bp++ = *str++); --i ) ;
183:
184: // kprintf( work );
185: panic( work );
186: // call_kdp(); // ??? use kdp=3 in boot parameters
187: return;
188: }/* end Pause */
189: #endif /* not CustomMiniMon */
190:
191:
192:
193: bool CurioSCSIController::configure( IOService *provider,
194: SCSIControllerInfo *controllerInfo )
195: {
196: IOReturn ioReturn = kIOReturnInternalError;
197:
198:
199: g.intLevel = 0;
200: g.curioInstance = this;
201: #if USE_ELG
202: AllocateEventLog( kEvLogSize );
203: ELG( g.evLogBufp, &g.evLogFlag, 'Curo', "configure - event logging set up." );
204: #endif /* USE_ELG */
205:
206: ELG( this, provider, 'Cnfg', "configure" );
207:
208: fProvider = (IOPCIDevice*)provider;
209:
210: ioReturn = initHardware();
211: if ( ioReturn != kIOReturnSuccess )
212: return false;
213:
214: /* Register our interrupt handler routine: */
215:
216: fInterruptEvent = IOInterruptEventSource::interruptEventSource(
217: (OSObject*)this,
218:
219: (IOInterruptEventAction)&CurioSCSIController::interruptOccurred,
220: provider,
221: 0 );
222:
223: if ( fInterruptEvent == NULL )
224: {
225: ELG( 0, 0, 'IES-', "CurioSCSIController::configure - can't register interrupt action" );
226: return false;
227: }
228:
229: getWorkLoop()->addEventSource( fInterruptEvent );
230: fInterruptEvent->enable();
231:
232: /* allocate a big-endian memory cursor: */
233:
234: fMemoryCursor = IOBigMemoryCursor::withSpecification( kMaxDMATransfer, kMaxDMATransfer );
235: if ( fMemoryCursor == NULL )
236: {
237: ELG( 0, kMaxDMATransfer, 'Mem-', "CurioSCSIController::start - IOBigMemoryCursor::withSpecification NG" );
238: return false;
239: }
240:
241:
242: /* Fill in the SCSIControllerInfo structure and return: */
243:
244: controllerInfo->initiatorId = 7;
245:
246: controllerInfo->maxTargetsSupported = 8;
247: controllerInfo->maxLunsSupported = 8;
248:
249: controllerInfo->minTransferPeriodpS = 200000; /* picoSecs for 5 MHz */
250: controllerInfo->maxTransferOffset = 0;
251: controllerInfo->maxTransferWidth = 1;
252:
253: controllerInfo->maxCommandsPerController= 0; // 0 is unlimited
254: controllerInfo->maxCommandsPerTarget = 0;
255: controllerInfo->maxCommandsPerLun = 0;
256:
257: controllerInfo->tagAllocationMethod = kTagAllocationPerLun;
258: controllerInfo->maxTags = 256;
259:
260: controllerInfo->commandPrivateDataSize = sizeof( PrivCmdData );
261:
262: controllerInfo->disableCancelCommands = false;
263:
264: return true;
265: }/* end configure */
266:
267:
268: void CurioSCSIController::executeCommand( IOSCSICommand *scsiCommand )
269: {
270: SCSICDBInfo scsiCDB;
271: SCSITargetParms targetParms;
272: UInt8 msgByte;
273: bool rc;
274:
275:
276:
277: if ( fCmd || fBusBusy )
278: {
279: ELG( fCmd, scsiCommand, 'Busy', "CurioSCSIController::executeCommand - bus busy so bounce this cmd" );
280: disableCommands();
281: rescheduleCommand( scsiCommand );
282: return;
283: }
284:
285: fCmd = scsiCommand;
286: fCmdData = (PrivCmdData*)scsiCommand->getCommandData();
287:
288: scsiCommand->getTargetLun( &fCurrentTargetLun );
289: scsiCommand->getCDB( &scsiCDB );
290: scsiCommand->getDevice(kIOSCSIDevice)->getTargetParms( &targetParms );
291:
292: ELG( scsiCommand,
293: *(UInt16*)&fCurrentTargetLun<<16 | (scsiCDB.cdbTag & 0xFF),
294: 'Exec', "CurioSCSIController::executeCommand" );
295: ELG( *(UInt32*)&scsiCDB.cdb[0], *(UInt32*)&scsiCDB.cdb[4] , '=CDB', "executeCommand - CDB" );
296:
297: fpMsgOut = fpMsgPut = &fMsgOutBuffer[ 0 ];
298:
299: /* Identify byte: */
300:
301: msgByte = kSCSIMsgIdentify | kSCSIMsgEnableDisconnectMask | fCurrentTargetLun.lun;
302: if ( scsiCDB.cdbFlags & kCDBFlagsNoDisconnect )
303: msgByte &= ~kSCSIMsgEnableDisconnectMask;
304: *fpMsgOut++ = msgByte;
305:
306: /* Tag msg: */
307:
308: if ( scsiCDB.cdbTagMsg )
309: {
310: *fpMsgOut++ = scsiCDB.cdbTagMsg;
311: *fpMsgOut++ = scsiCDB.cdbTag;
312: ELG( 0, scsiCDB.cdbTagMsg<<16 | (scsiCDB.cdbTag & 0xFF), ' tag', "CurioSCSIController::executeCommand - tag" );
313: }
314:
315: /* Abort msg: */
316:
317: if ( scsiCDB.cdbAbortMsg )
318: {
319: ELG( scsiCommand->getOriginalCmd(), scsiCDB.cdbAbortMsg, 'Abor', "CurioSCSIController::executeCommand - abort msg." );
320: *fpMsgOut++ = scsiCDB.cdbAbortMsg;
321: }
322:
323: fMsgOutCount = (UInt8)(fpMsgOut - &fMsgOutBuffer[ 0 ]);
324: ELG( fMsgOutCount, *(UInt32*)&fMsgOutBuffer[0], '=MgO', "executeCommand" );
325:
326: /***** Try to start the command on the hardware: *****/
327:
328: rc = startCommand(); /* Call the hardware layer. */
329:
330: if ( rc )
331: { /* Hardware can't start now */
332: ELG( fCmd, 0, 'Exe-', "CurioSCSIController::executeCommand - command bounced back" );
333: fCmd = NULL; /// ?redundant? - rescheduleCommand done in fsmSelecting
334: return;
335: }
336:
337: return;
338: }/* end executeCommand */
339:
340:
341:
342: bool CurioSCSIController::startCommand()
343: {
344: SCSICDBInfo scsiCDB;
345: UInt8 selectCmd;
346:
347:
348: fCmd->getPointers( &fCmdData->mdp, &fCmdData->xferCount, &fCmdData->isWrite );
349:
350: fCmdData->results.bytesTransferred = 0;
351: fCmdData->savedDataPosition = 0;
352:
353: fCmd->getCDB( &scsiCDB );
354:
355: setCmdReg( cFlshFFO );
356: WRITE_REGISTER( rSTA, fCurrentTargetLun.target );
357:
358: /* Put the contents of the message buffer into the FIFO. */
359: /* Figure out which flavor of Select command is indicated. */
360: /* The command depends on the number of message bytes. */
361:
362: switch ( fMsgOutCount )
363: {
364: case 0: /* Select, no ATN, send CDB */
365: selectCmd = cSlctNoAtn;
366: break;
367:
368: case 1: /* Select, ATN, 1 Msg, send CDB */
369: selectCmd = cSlctAtn;
370: break;
371:
372: case 3: /* Select, ATN, 3 Msg, send CDB */
373: selectCmd = cSlctAtn3;
374: break;
375:
376: default: /* Select, ATN, 1 Msg, stop */
377: selectCmd = cSlctAtnStp;
378: break;
379: }/* end SWITCH on size of MsgOut */
380:
381: if ( (fMsgOutCount > 3) || (fMsgOutCount + scsiCDB.cdbLength >= 16) )
382: { /* The FIFO only holds 16 bytes. */
383: /* We have to do the command phase in the state automaton. */
384: WRITE_REGISTER( rFFO, *fpMsgPut++ );
385: selectCmd = cSlctAtnStp;
386: }
387: else
388: { /* MsgOut and CDB both fit in FIFO: */
389: while ( fpMsgPut < fpMsgOut )
390: {
391: WRITE_REGISTER( rFFO, *fpMsgPut++ );
392: }
393: }
394:
395: if ( selectCmd != cSlctAtnStp )
396: { /* If we're not stopping after the messages, */
397: /* stuff the command into the FIFO, too. */
398: putCDBIntoFIFO();
399: }
400: /* Init the finite state automaton: */
401:
402: fBusState = SCS_SELECTING;
403: fCurrentBusPhase = kBusPhaseBusFree;
404:
405: /***** Issue the Arbitrate/Select/MessageOut combo: *****/
406:
407: setCmdReg( selectCmd );
408:
409: return false; /* return No Problem */
410: }/* end startCommand */
411:
412:
413: void CurioSCSIController::completeCommand()
414: {
415: ELG( fCmdData->results.returnCode, fCmdData->results.bytesTransferred, ' IOC', "CurioSCSIController::completeCommand" );
416:
417: switch ( fCmdData->results.scsiStatus )
418: {
419: case kSCSIStatusGood:
420: break;
421:
422: case kSCSIStatusCheckCondition:
423: ELG( 0, 0, 'Chek', "CurioSCSIController::completeCommand - Check Condition" );
424: fCmdData->results.returnCode = kIOReturnError;
425: break;
426:
427: default:
428: ELG( fCmd, fCmdData->results.scsiStatus, 'Sta?', "CurioSCSIController::completeCommand - bad status" );
429: fCmdData->results.returnCode = kIOReturnError;
430: break;
431: }/* end SWITCH on SCSI status */
432:
433: fCmd->setResults( &fCmdData->results );
434: fCmd->complete();
435:
436: fCmd = NULL;
437: fCmdData = NULL;
438: fCurrentTargetLun.target = kInvalidTarget;
439: fCurrentTargetLun.lun = kInvalidLUN;
440: return;
441: }/* end completeCommand */
442:
443:
444: void CurioSCSIController::cancelCommand( IOSCSICommand *scsiCommand )
445: {
446: IOSCSICommand *origCmd;
447: PrivCmdData *origCmdData;
448: SCSIResults results;
449:
450: origCmd = scsiCommand->getOriginalCmd();
451: origCmdData = (PrivCmdData*)origCmd->getCommandData();
452:
453: ELG( scsiCommand, origCmd, 'Can-', "CurioSCSIController::cancelCommand" );
454:
455: origCmd->getResults( &results );
456: results.bytesTransferred = origCmdData->results.bytesTransferred;
457: origCmd->setResults( &results );
458:
459: origCmd->complete();
460:
461: scsiCommand->complete();
462: return;
463: }/* end cancelCommand */
464:
465:
466: void CurioSCSIController::resetCommand( IOSCSICommand *scsiCommand )
467: {
468: ELG( scsiCommand, 0, 'Rst-', "CurioSCSIController::resetCommand" );
469: resetBus();
470: fCmdData = scsiCommand->getCommandData();
471: bzero( &fCmdData->results, sizeof( fCmdData->results ) );
472: scsiCommand->setResults( &fCmdData->results );
473: scsiCommand->complete();
474: return;
475: }/* end resetCommand */
476:
477:
478: /* Fetch the device's bus address and interrupt port number. */
479: /* Also, allocate one page of memory for the Channel Program. */
480:
481: IOReturn CurioSCSIController::initHardware()
482: {
483: IOReturn ioReturn;
484:
485:
486: fInitiatorID = kInitiatorIDDefault;
487: fInitiatorIDMask = 1 << kInitiatorIDDefault; /* BusID bitmask for reselection. */
488:
489: ELG( 0, fInitiatorID, 'IniH', "initHardware" );
490:
491: ioReturn = getHardwareMemoryMaps();
492:
493: if ( ioReturn == kIOReturnSuccess ) ioReturn = allocHdwAndChanMem();
494: if ( ioReturn == kIOReturnSuccess ) ioReturn = doHBASelfTest();
495: if ( ioReturn == kIOReturnSuccess ) ioReturn = resetHardware( true );
496:
497: if ( ioReturn != kIOReturnSuccess )
498: this->free();
499:
500: return ioReturn;
501: }/* end initHardware */
502:
503:
504: IOReturn CurioSCSIController::getHardwareMemoryMaps()
505: {
506:
507: if ( !fSCSIMemoryMap )
508: {
509: fSCSIMemoryMap = fProvider->mapDeviceMemoryWithIndex( kCurioRegisterBase );
510: if ( !fSCSIMemoryMap )
511: {
512: ELG( 0, 0, 'Map-', "CurioSCSIController::getHardwareMemoryMaps - can't map Curio." );
513: return kIOReturnInternalError;
514: }
515:
516: fCurioPhysAddr = fSCSIMemoryMap->getPhysicalAddress();
517: fCurioAddr = (UInt8*)fSCSIMemoryMap->getVirtualAddress();
518: ELG( fCurioPhysAddr, fCurioAddr, '=Cur', "getHardwareMemoryMaps - MESH regs" );
519: g.curioAddr = (UInt32)fCurioAddr; // for debugging, miniMon ...
520: }
521:
522: if ( !fDBDMAMemoryMap )
523: {
524: fDBDMAMemoryMap = fProvider->mapDeviceMemoryWithIndex( kDBDMARegisterBase );
525: if ( !fDBDMAMemoryMap )
526: {
527: ELG( 0, 0, 'map-', "CurioSCSIController::getHardwareMemoryMaps - can't map DBDMA." );
528: return kIOReturnInternalError;
529: }
530: fDBDMAAddrPhys = fDBDMAMemoryMap->getPhysicalAddress();
531: fDBDMAAddr = (IODBDMAChannelRegisters*)fDBDMAMemoryMap->getVirtualAddress();
532: ELG( fDBDMAAddrPhys, fDBDMAAddr, '=DMA', "getHardwareMemoryMaps - DBDMA regs" );
533: #if CustomMiniMon
534: gMESH_DBDMA = (UInt32)fDBDMAAddr;
535: gMESH_DBDMA_Phys = (UInt32)fDBDMAAddrPhys;
536: #endif /* CustomMiniMon */
537: }
538:
539: return kIOReturnSuccess;
540: }/* end getHardwareMemoryMaps */
541:
542:
543:
544: /* Fetch the device's bus address and allocate one page of memory */
545: /* for the channel command. (Strictly speaking, we don't need an */
546: /* entire page, but we can use the rest of the page for a permanent */
547: /* status log). */
548: /* @param deviceDescription Specify the device to initialize. */
549: /* @return kIOReturnSuccess if successful, else an error status. */
550:
551: IOReturn CurioSCSIController::allocHdwAndChanMem()
552: {
553: IOReturn ioReturn = kIOReturnSuccess;
554:
555:
556: fCCLSize = page_size;
557: fCCL = (UInt8*)kalloc( fCCLSize );
558: if ( !fCCL )
559: { PAUSE( 0, fCCLSize, 'CCA-', "allocHdwAndChanMem - can't allocate channel command area.\n" );
560: ioReturn = kIOReturnNoMemory;
561: }
562:
563: if ( ioReturn == kIOReturnSuccess )
564: {
565: /* Get the physical address corresponding the DBDMA channel area: */
566:
567: fCCLPhysAddr = pmap_extract( kernel_pmap,
568: (vm_offset_t)fCCL );
569:
570: g.cclPhysAddr = (UInt32)fCCLPhysAddr; // for debugging ease
571: g.cclLogAddr = (UInt32)fCCL;
572: if ( ioReturn != kIOReturnSuccess )
573: PAUSE( 0, ioReturn, 'MAP-', "allocHdwAndChanMem - DBDMA mapping err.\n" );
574: }
575:
576: if ( ioReturn == kIOReturnSuccess )
577: {
578: ELG( fCCLPhysAddr, fCCL, '=CCL', "allocHdwAndChanMem - CCL phys/logical addresses." );
579:
580: /* Set the Interrupt, Branch, and Wait DBDMA registers. */
581: /* Caution: the following Curio interrupt register bits */
582: /* are reverse polarity and are in a different position. */
583: /* The pattern is: 0x00MM00VV, where MM is a mask byte */
584: /* and VV is a value byte to match. */
585: /* 0x80 means NO errors (kMeshIntrError) */
586: /* 0x40 means NO exceptions (kMeshIntrException) */
587: /* 0x20 means NO command done (kMeshIntrCmdDone) */
588: /* Branch Select is used with BRANCH_FALSE */
589:
590: // IOSetDBDMAInterruptSelect( fDBDMAAddr, 0x00000000); /* Never let DBDMA interrupt */
591: // IOSetDBDMAWaitSelect( fDBDMAAddr, 0x00200020); /* Wait until command done */
592: // IOSetDBDMABranchSelect( fDBDMAAddr, 0x00000000); /* Never branch on error */
593: fDBDMAAddr->interruptSelect = 0x00000000;
594: fDBDMAAddr->waitSelect = 0x20002000;
595: fDBDMAAddr->branchSelect = 0x00000000;
596: SynchronizeIO();
597: }
598: /* What do we do on failure? Should we try to deallocate */
599: /* the stuff we created, or will the system do this for us? */
600:
601: return ioReturn;
602: }/* end allocHdwAndChanMem */
603:
604:
605: /* doHBASelfTest - This should be extended to perform a real chip self-test. */
606:
607: IOReturn CurioSCSIController::doHBASelfTest()
608: {
609: IOReturn ioReturn = kIOReturnSuccess;
610: UInt8 chipID;
611: UInt8 temp;
612:
613:
614: ELG( fCurioPhysAddr, fCurioAddr, 'Test', "doHBASelfTest" );
615: resetCurio();
616:
617: WRITE_REGISTER( rCF2, CF2_EPL );
618: setCmdReg( cNOP | bDMAEnBit );
619:
620: chipID = fCurioAddr[ rTCH ];
621:
622: /* Check data integrity by writing a NOP to the command register */
623: /* and verifying that it was read back correctly. */
624:
625: setCmdReg( cNOP );
626: temp = fCurioAddr[ rCMD ];
627: if ( temp != cNOP )
628: {
629: PAUSE( cNOP, temp, 'hba-', "doHBASelfTest - Expected NOP" );
630: ioReturn = kIOReturnNoDevice;
631: }
632: /* To do: write a test pattern into the FIFO and */
633: /* check for correct count and bits. */
634:
635: return ioReturn;
636: }/* end doHBASelfTest */
637:
638:
639: void CurioSCSIController::interruptOccurred( IOInterruptEventSource *ies, int intCount )
640: {
641: // DBDMAChannelRegisters *DBDMARegs = (DBDMAChannelRegisters*)fDBDMAAddr;
642:
643:
644: // ELG( ies, intCount, 'Int+', "interruptOccurred" );
645:
646: g.intLevel |= kLevelISR; /* set ISR flag */
647: g.intLevel &= ~kLevelLatched; /* clear latched */
648:
649: // ELG( DBDMARegs->channelStatus, DBDMARegs->commandPtrLo, 'Int+', "interruptOccurred." );
650: ELG( fCmd, 0, 'Int+', "interruptOccurred." );
651: // ELG( *(UInt32*)0xF3000024, *(UInt32*)0xF300002C, 'Int ', "interruptOccurred." );
652:
653: doHardwareInterrupt(); /**** HANDLE THE INTERRUPT ****/
654:
655: // ELG( fCmd, *(UInt32*)0xF300002C, 'Intx', "interruptOccurred." );
656:
657: g.intLevel &= ~kLevelISR; /* clear ISR flag */
658: return;
659: }/* end interruptOccurred */
660:
661:
662:
663: void CurioSCSIController::doHardwareInterrupt()
664: {
665: if ( !interruptPending() )
666: {
667: ELG( 0, 0, 'Int?', "CurioSCSIController::doHardwareInterrupt - spurious interrupt" );
668: return;
669: }
670:
671: fCkForAnotherInt = true; // keep going around
672: do
673: {
674: ELG( fCkForAnotherInt<<16 | fNeedAnotherInterrupt, fBusState, 'loop', "doHardwareInterrupt" );
675: fNeedAnotherInterrupt = false;
676:
677: /* Gross error is set incorrectly (according to Clinton Bauder). */
678:
679: if ( fSaveStatus & sGrossErr ) // ??? mlj was fSaveInterrupt
680: {
681: ELG( 0, fSaveInterrupt, 'GEr-', "doHardwareInterrupt - Gross Error set." );
682: fSaveStatus &= ~sGrossErr;
683: }
684:
685: /* iIlegalCmd - Software messed up. */
686: /* Start over from scratch. */
687: /* We can get this if we write too */
688: /* many commands into the register. */
689:
690: if ( fSaveInterrupt & iIlegalCmd )
691: {
692: ELG( 0, fSaveInterrupt, 'IllC', "doHardwareInterrupt - Illegal command interrupt" );
693: if ( fBusState != SCS_DEATH_MARCH )
694: fsmStartErrorRecovery( kIOReturnInternalError );
695:
696: fCkForAnotherInt = false;
697: }/* end IF iIlegalCmd */
698:
699:
700: /* Check for disconnect: */
701:
702: if ( fSaveInterrupt & iDisconnect )
703: {
704: setCmdReg( cEnSelResel );
705: /* Radar 1678545: this is the only (normal) place */
706: /* that fBusBusy is cleared. (It's also cleared by */
707: /* bus reset and driver initialization.) */
708: fBusBusy = false;
709: }
710:
711: if ( fSaveInterrupt & iResetDetect )
712: {
713: ELG( fSaveStatus, fSaveInterrupt, 'BusR', "doHardwareInterrupt - SCSI Bus Reset\n" );
714: if ( fCmd )
715: {
716: fCmdData->results.returnCode = kIOReturnSelectionError;
717: completeCommand();
718: }
719: super::resetOccurred();
720: enableCommands(); /* let superclass issue another command */
721: fCkForAnotherInt = false;
722: }/* end IF iResetDetect */
723: else if ( (fSaveStatus & sParityErr) && fBusBusy )
724: {
725: fsmStartErrorRecovery( kIOReturnParityError );
726: fCkForAnotherInt = false;
727: } /* If Parity Error and not disconnected */
728: else
729: { /* Only certain states are legal if the bus is busy. */
730: if ( fBusBusy )
731: {
732: /* This is a legitimate interrupt (parity error and */
733: /* bus reset have already been handled). The entity */
734: /* that started the chip action that caused the */
735: /* interrupt (deep breath) set fBusState to indicate*/
736: /* why the interrupt happened. */
737: /* Call the proper finite-state machine function. */
738: /* On return, fBusState will be set to one of the */
739: /* following values: */
740: /* SCS_INITIATOR Start an action on the */
741: /* current phase. */
742: /* SCS_DISCONNECT The bus is free. */
743: /* SCS_WAIT_FOR_BUS_FREE The bus should go free */
744: /* shortly. */
745: /* Note that SCS_WAIT_FOR_BUS_FREE and */
746: /* fsmWaitForBusFree short-circuit some of the */
747: /* automaton to avoid unnecessary interrupt events. */
748: switch ( fBusState )
749: {
750: case SCS_DISCONNECTED: fsmDisconnected(); break;
751: case SCS_SELECTING: fsmSelecting(); break;
752: case SCS_RESELECTING: fsmReselecting(); break;
753: case SCS_INITIATOR: fsmInitiator(); break;
754: case SCS_COMPLETING: fsmCompleting(); break;
755: case SCS_DMACOMPLETE: fsmDMAComplete(); break;
756: case SCS_SENDINGMSG: break;
757: case SCS_GETTINGMSG: fsmGettingMsg(); break;
758: case SCS_SENDINGCMD: fsmSendingCmd(); break;
759: case SCS_WAIT_FOR_BUS_FREE: fsmWaitForBusFree();break;
760: case SCS_DEATH_MARCH: fsmErrorRecoveryInterruptService(); break;
761:
762: default:
763: PAUSE( fSaveStatus, fBusState, 'FSM-', "doHardwareInterrupt - Illegal bus automaton state." );
764: }/* end SWITCH fBusState */
765: }/* end IF bus is busy */
766: else
767: { /* The bus is (or just went) free. */
768: /* We only allow selection, reselection, */
769: /* wait for disconnect, or death march interrupts. */
770: switch ( fBusState )
771: {
772: case SCS_DISCONNECTED: fsmDisconnected(); break;
773: case SCS_SELECTING: fsmSelecting(); break;
774: case SCS_WAIT_FOR_BUS_FREE: fsmWaitForBusFree(); break;
775: case SCS_DEATH_MARCH: fsmErrorRecoveryInterruptService(); break;
776:
777: default:
778: fsmStartErrorRecovery( kIOReturnInternalError );
779: fCkForAnotherInt = false;
780: break;
781: }/* end SWITCH on fBusState */
782: }/* end ELSE bus is not busy */
783: }
784:
785: /* We have (presumably) completely handled the previous */
786: /* interrupt. At this point, there are five legitimate */
787: /* fBusState values: */
788: /* SCS_RESELECTING Just got a reselection interrupt */
789: /* SCS_INITIATOR Continue operation for this target. */
790: /* SCS_DISCONNECTED Enable selection/reselection */
791: /* SCS_WAIT_FOR_BUS_FREE Command completion transition */
792: /* SCS_DEATH_MARCH Error recovery */
793: /* Handle a SCSI Phase change if necessary. This will */
794: /* leave the bus state in the "expected" state for the next */
795: /* operation. */
796:
797: switch ( fBusState )
798: {
799: case SCS_DEATH_MARCH:
800: fCkForAnotherInt = false;
801: break;
802:
803: case SCS_INITIATOR:
804: ELG( fCkForAnotherInt<<16 | fNeedAnotherInterrupt, 0, 'SCSi', "doHardwareInterrupt" );
805: if ( fNeedAnotherInterrupt )
806: { // from tagged reselect
807: fNeedAnotherInterrupt = false;
808: if ( quickCheckForInterrupt() )
809: {
810: fsmPhaseChange();
811: }
812: }
813: else
814: {
815: fsmPhaseChange();
816: }
817: break;
818:
819: case SCS_WAIT_FOR_BUS_FREE:
820: default:
821: break;
822: }/* end SWITCH on fBusState */
823:
824: /* This is the final check: if we determine that the */
825: /* previous action will complete quickly (for example, */
826: /* it's a message in byte), we'll spin for up to ten */
827: /* microseconds to see if the chip is ready for another */
828: /* operation. */
829:
830: } while ( fCkForAnotherInt && quickCheckForInterrupt() );
831:
832: if ( fBusState == SCS_DEATH_MARCH )
833: fsmContinueErrorRecovery();
834:
835: if ( fBusState == SCS_DISCONNECTED )
836: enableCommands(); /* Try to start another command */
837:
838: return;
839: }/* end doHardwareInterrupt */
840:
841:
842: /* This is called from fsmDisconnected when we receive a reselected interrupt. */
843:
844: void CurioSCSIController::handleReselectionInterrupt()
845: {
846: UInt8 selectByte;
847: UInt32 fifoDepth;
848: UInt8 msgByte;
849: IOReturn ioReturn = kIOReturnSuccess;
850:
851:
852: /* Make sure there's a selection byte and an Identify message in the FIFO. */
853:
854: fBusBusy = ((fSaveInterrupt & iDisconnect) == 0);
855: fifoDepth = fCurioAddr[ rFOS ] & kFIFOCountMask;
856:
857: ELG( fifoDepth, fSaveInterrupt, 'fHRI', "handleReselectionInterrupt" );
858: if ( fifoDepth != 2 )
859: {
860: ioReturn = kIOReturnInternalError;
861: PAUSE( 0, 0, 'Rsl-', "handleReselectionInterrupt - Bad FIFO count on reselect" );
862: }
863:
864: if ( ioReturn == kIOReturnSuccess )
865: {
866: selectByte = fCurioAddr[ rFFO ];
867: /* During reselection, the first message byte */
868: /* must be an Identify with the LUN. */
869: ioReturn = getReselectionTargetID( selectByte );
870: }
871:
872: if ( ioReturn == kIOReturnSuccess )
873: {
874: msgByte = fCurioAddr[ rFFO ]; /* Pull the Identify byte */
875: if ( fSaveStatus & sParityErr )
876: ioReturn = kIOReturnParityError;
877: }
878:
879: if ( ioReturn == kIOReturnSuccess )
880: {
881: if ( (msgByte & kSCSIMsgIdentify) == 0 )
882: {
883: ioReturn = kIOReturnInternalError;
884: PAUSE( 0, msgByte, ' ID-', "handleReselectionInterrupt - Bad ID Message (no Identify) on reselect" );
885: }
886:
887: fCurrentTargetLun.lun = msgByte & ~kSCSIMsgIdentify;
888: fTag = kInvalidTag;
889: fBusState = SCS_RESELECTING;
890:
891: /* At this point, the chip is waiting for us to validate */
892: /* the Identify message. While we have a Target and LUN, */
893: /* we don't have a command to reconnect to. */
894: setCmdReg( cMsgAcep ); /* Accept the Identify message */
895: }
896:
897: if ( ioReturn != kIOReturnSuccess )
898: fsmStartErrorRecovery( ioReturn );
899:
900: return;
901: }/* end handleReselectionInterrupt */
902:
903:
904: /* Complete the processing of a reselection interrupt. */
905: /* We have just ACK'd the Identify message. Try to find the command */
906: /* that corresponds to this target.lun (without a queue tag). */
907: /* If we're successful, complete the reselection and start */
908: /* following phases by calling fsmPhaseChange directly. */
909: /* If the first disconnected command has a non-zero tag queue, we */
910: /* expect to be in messsage in phase, and will receive a tagged */
911: /* queue message eventually. */
912:
913: void CurioSCSIController::fsmReselecting()
914: {
915: ELG( fBusState, *(UInt16*)&fCurrentTargetLun<<16 | (UInt16)fTag, 'fRsl', "fsmReselecting" );
916:
917: reselectNexus();
918: if ( fCmd )
919: { /* We have successfully reselected this target. */
920: /* Wait until the target tells us what to do next. */
921: fBusState = SCS_INITIATOR;
922: return;
923: }
924:
925: /* We don't have a nexus yet. If we're in MSGI phase, */
926: /* continue grabbing message bytes until we receive */
927: /* a queue tag message (we might receive an SDTR), */
928: /* continuing at fsmReselecting to process interrupts. */
929:
930: quickCheckForInterrupt(); // clear pending interrupt(s) and update phase
931: fCurrentBusPhase = fSaveStatus & mPhase;
932: if ( fCurrentBusPhase == kBusPhaseMSGI )
933: {
934: if ( (fCurioAddr[ rFOS ] & kFIFOCountMask) == 0 )
935: {
936: if ( fMsgInState == kMsgInInit )
937: {
938: setCmdReg( cNOP | bDMAEnBit ); // clear TC zero bit
939: setCmdReg( cIOXfer );
940: if ( !quickCheckForInterrupt() )
941: { fCkForAnotherInt = true;
942: return;
943: }
944: }
945: }
946: fsmGettingMsg();
947: }
948: else
949: { /* We're in the wrong phase. Bail out. */
950: fsmStartErrorRecovery( kIOReturnInternalError );
951: }
952: return;
953: }/* end fsmReselecting */
954:
955:
956:
957: /* Disconnected - only legal event here is reselection. */
958: /* handleReselectionInterrupt may set fBusState to SCS_INITIATOR */
959:
960: void CurioSCSIController::fsmDisconnected()
961: {
962: UInt8 selectByte, target;
963:
964:
965: ELG( 0, fSaveInterrupt, 'fDis', "fsmDisconnected" );
966:
967: if ( fSaveInterrupt & iReselected )
968: {
969: handleReselectionInterrupt();
970: return;
971: }
972:
973: /* See if some target trying to Select us - should never happen: */
974:
975: if ( fSaveInterrupt & (iSelected | iSelectWAtn) )
976: {
977: selectByte = fCurioAddr[ rFFO ];
978: selectByte &= ~fInitiatorIDMask;
979: for ( target = 0; target < 8; target++ )
980: {
981: if ( selectByte & (1 << target) )
982: break;
983: }
984: PAUSE( selectByte, target, 'Tar-', "fsmDisconnected - Selected by external target - not supported." );
985: setCmdReg( cDisconnect );
986: return;
987: }/* end IF bogus selection by target */
988:
989:
990: fCkForAnotherInt = false;
991:
992: if ( fBusBusy == false )
993: { /* disconnect interrupted while disconnected */
994: /* This always happens when we finish an IO request. */
995: /* fBusBusy is cleared when the "bus disconnected" bit */
996: /* is set in the NCR 53C96 interrupt register. */
997: ELG( 0, 0, 'Dis-', "fsmDisconnected - disconnect interrupted while disconnected" );
998: enableCommands();
999: return;
1000: }
1001:
1002: /* Since we're disconnected, just ignore the interrupt */
1003:
1004: if ( fCmd )
1005: {
1006: fCmdData->results.returnCode = kIOReturnSelectionError;
1007: completeCommand();
1008: }
1009:
1010: fCurrentBusPhase = kBusPhaseBusFree;
1011: return;
1012: }/* end fsmDisconnected */
1013:
1014:
1015: /* This state is called when we expect to disconnect from a */
1016: /* target after receiving a Command Complete, Disconnect, or */
1017: /* Abort message and the bus is still busy on exit from the */
1018: /* finite state automaton (because curioQuickCheckForBusFree */
1019: /* returned false). */
1020:
1021: void CurioSCSIController::fsmWaitForBusFree()
1022: {
1023: ELG( fBusBusy, fSaveInterrupt, 'fWBF', "fsmWaitForBusFree" );
1024:
1025: if ( fSaveInterrupt & (iReselected | iSelected | iSelectWAtn) )
1026: {
1027: /* We went straight from command completion to (presumably) */
1028: /* reselection. Treat it as a normal selection/reselection */
1029: /* interrupt from "disconnected" state. (This is an abuse of*/
1030: /* the finite-state automaton design.) */
1031: fsmDisconnected();
1032: }
1033: else if ( fBusBusy == false )
1034: {
1035: /* This is expected: the bus has just gone free after a */
1036: /* command completed. We can now safely try to start */
1037: /* another command. */
1038: fBusState = SCS_DISCONNECTED;
1039: fCkForAnotherInt = false;
1040: enableCommands();
1041: }
1042: else
1043: { /* This is strange. It may not be an error, but I don't know */
1044: /* if there are other legal bus states after disconnect. */
1045: /* (The one counter example would be after a linked command */
1046: /* when the target goes to Command phase, but we should have */
1047: /* rejected this at command complete.) */
1048: ELG( fCmd, 0, 'WBF-', "fsmWaitForBusFree - strangeness" );
1049: fsmStartErrorRecovery( kIOReturnInternalError );
1050: }
1051: return;
1052: }/* end fsmWaitForBusFree */
1053:
1054:
1055: /* fsmSelecting - One of three things can happen here: */
1056: /* the selection could succeed (though with possible */
1057: /* incomplete message out), */
1058: /* it could time out, or */
1059: /* we can be reselected. */
1060:
1061: void CurioSCSIController::fsmSelecting()
1062: {
1063: SCSICDBInfo scsiCDB;
1064: UInt8 fifoDepth;
1065: IOReturn ioReturn = kIOReturnSuccess;
1066:
1067:
1068: ELG( 0, fSaveInterrupt, 'fSel', "fsmSelecting" );
1069:
1070: fBusBusy = ((fSaveInterrupt & iDisconnect) == 0 );
1071: if ( fBusBusy == false )
1072: { /* Selection timed-out. Abort this request. */
1073: ELG( fCmd, 0, 'Tim-', "fsmSelecting - timeout" );
1074:
1075: setCmdReg( cFlshFFO );
1076: fBusState = SCS_DISCONNECTED;
1077: fCmdData->results.returnCode = kIOReturnNoDevice;
1078: completeCommand();
1079: return;
1080: }
1081:
1082: ELG( fSaveInterrupt, fSaveSeqStep, 'Sel-', "fsmSelecting - problem other than timeout" );
1083: fCmd->getCDB( &scsiCDB );
1084:
1085: if ( fSaveInterrupt == (iFuncComp | iBusService) )
1086: {
1087: switch ( fSaveSeqStep & INS_STATE_MASK )
1088: {
1089: case 0: /* No message phase. If we really wanted one, */
1090: /* this could be significant. */
1091: /* OK, let's try to continue following phase changes. */
1092: fBusState = SCS_INITIATOR;
1093: break;
1094:
1095: case 3: /* didn't complete cmd phase, parity? */
1096: case 4: /* everything worked */
1097: case 1: /* everything worked, SCMD_SELECT_ATN_STOP case */
1098: /* We're connected. Start following the target's phase changes. */
1099: /* If we're trying to do sync negotiation, */
1100: /* this is the place to do it. In that case, we */
1101: /* sent a SCMD_SELECT_ATN_STOP command, and */
1102: /* ATN is now asserted (and we're hopefully in */
1103: /* msgOut phase). We want to send 5 bytes. */
1104: /* Drop them into currMsgOut */
1105: fBusState = SCS_INITIATOR;
1106: break;
1107:
1108: case 2: /* Either no command phase, or incomplete message transfer. */
1109: fifoDepth = fCurioAddr[ rFOS ] & kFIFOCountMask;
1110: /* Spec says ATN is asserted if all message bytes were not sent. */
1111: if ( fifoDepth > scsiCDB.cdbLength )
1112: setCmdReg( cRstAtn );
1113:
1114: /* 970611: clear the FIFO. If we don't do this and the */
1115: /* target is entering MSGI phase (trying to send us a */
1116: /* Message Reject), it will sit on top of the FIFO, and */
1117: /* we'll read garbage from the FIFO. */
1118:
1119: setCmdReg( cFlshFFO ); /* The command is still in the FIFO */
1120: /* OK, let's try to continue following phase changes. */
1121: fBusState = SCS_INITIATOR;
1122: break;
1123:
1124: default: /* fBusBusy = true; -- Radar 1678545 */
1125: ioReturn = kIOReturnInternalError;
1126: break;
1127: }/* end SWITCH */
1128: }
1129: else if ( fSaveInterrupt & iReselected )
1130: {
1131: /* We were reselected while trying to do a selection. */
1132: /* Enqueue this cmdBuf on the HEAD of pendingQ, then deal */
1133: /* with the reselect. */
1134: /* Tricky case, we have to "deactivate" this command */
1135: /* since this hardwareStart attempt failed. */
1136:
1137: ELG( fCmd, fSaveInterrupt, 'Arb-', "fsmSelecting - Reselection interrupt while selecting" );
1138: disableCommands();
1139: rescheduleCommand( fCmd );
1140: fCmd = NULL;
1141:
1142: fBusState = SCS_DISCONNECTED;
1143: handleReselectionInterrupt(); /* Go deal with reselect. */
1144: }
1145: else
1146: {
1147: ioReturn = kIOReturnInternalError;
1148: PAUSE( 0, 0, 'int-', "Bogus select/reselect interrupt" );
1149: }
1150:
1151: if ( ioReturn != kIOReturnSuccess )
1152: fsmStartErrorRecovery( ioReturn );
1153:
1154: return;
1155: }/* end fsmSelecting */
1156:
1157:
1158: /* This is a dummy interrupt service state that we enter after selection */
1159: /* when the previous Curio operation has no interrupt-service completion */
1160: /* requirement. For example, we can get here after a Message Out or */
1161: /* reselection. Nothing happens here; we continue at fsmPhaseChange. */
1162:
1163: void CurioSCSIController::fsmInitiator()
1164: {
1165: ELG( 0, fSaveInterrupt, 'fIni', "fsmInitiator" );
1166: fBusState = SCS_INITIATOR;
1167: return;
1168: }/* end fsmInitiator */
1169:
1170:
1171: /* We just did a SCMD_INIT_CMD_CMPLT command, hopefully all that's left */
1172: /* is to drop ACK. Command Complete message is handled in fscAcceptinfMsg. */
1173: /* We can't go to SCS_DISCONNECTED until the target disconnects. If we */
1174: /* go to "disconnected" state too soon, we'll encounter a load-dependent */
1175: /* race condition that causes us to start another command before we've */
1176: /* cleaned up from the last command. The actual state change is in */
1177: /* fsmProcessMessage. */
1178:
1179: void CurioSCSIController::fsmCompleting()
1180: {
1181: unsigned fifoDepth;
1182: IOReturn ioReturn = kIOReturnSuccess;
1183: UInt8 statusByte;
1184:
1185:
1186: ELG( 0, fSaveInterrupt, 'fCmp', "fsmCompleting" );
1187:
1188: if ( fSaveInterrupt & iDisconnect )
1189: {
1190: ioReturn = kIOReturnInternalError;
1191: PAUSE( 0, 0, ' BF-', "fsmCompleting - Bus free before target completion complete" );
1192: }
1193:
1194: if ( ioReturn == kIOReturnSuccess )
1195: {
1196: fifoDepth = fCurioAddr[ rFOS ] & kFIFOCountMask;
1197: if ( fSaveInterrupt & iFuncComp )
1198: { /* Got both Status and MsgIn in FIFO; ACK is still asserted. */
1199: if ( fifoDepth != 2 )
1200: { /* This is pretty bogus - we expect a status and msg in the FIFO. */
1201: PAUSE( 0, fifoDepth, 'ffc-', "fsmCompleting - FIFO problem with Status/MsgIn" );
1202: ioReturn = kIOReturnInternalError;
1203: }
1204:
1205: if ( ioReturn == kIOReturnSuccess )
1206: {
1207: statusByte = fCurioAddr[ rFFO ];
1208: fMsgInBuffer[0] = fCurioAddr[ rFFO ];
1209: fCmdData->results.scsiStatus = statusByte;
1210: fMsgInIndex = 1;
1211: ioReturn = fsmProcessMessage();
1212: }
1213: }
1214: else
1215: { /* We only received a status byte. */
1216: /* This can occur if we responded to the interrupt before */
1217: /* the device successfully transmitted the Command Complete */
1218: /* message. This is kind of weird, but let's try to handle it. */
1219: if ( fifoDepth != 1 )
1220: {
1221: ioReturn = kIOReturnInternalError;
1222: PAUSE( 0, fifoDepth, 'Cmp-', "IO complete: incorrect FIFO count (expecting one byte)" );
1223: }
1224:
1225: /* Back to watching phase changes. */
1226: /* Presumably, the target will switch to MSGI phase and */
1227: /* complete the command at its leisure. */
1228: fBusState = SCS_INITIATOR;
1229: }
1230: }
1231:
1232: if ( ioReturn != kIOReturnSuccess )
1233: fsmStartErrorRecovery( ioReturn );
1234:
1235: return;
1236: }/* end fsmCompleting */
1237:
1238:
1239: /* DMA Complete. */
1240:
1241: void CurioSCSIController::fsmDMAComplete()
1242: {
1243: UInt32 fifoResidualCount, actualTransferCount, dmaResidualCount;
1244: UInt8 residualByte;
1245:
1246:
1247: /* Stop the DMA engine and retrieve the total number of */
1248: /* bytes transferred. This will be */
1249: /* fCmd->thisTransferLength The number of bytes requested */
1250: /* - the current DMA residual count */
1251: /* - the current FIFO residual count */
1252: /* Note that there may still be bytes in the FIFO. */
1253:
1254: // IODBDMAReset( fDBDMAAddr );
1255: fDBDMAAddr->channelControl = SWAP( 0x20002000 ); // set FLUSH bit
1256: SynchronizeIO();
1257: fDBDMAAddr->channelControl = SWAP( 0x80000000 ); // clr RUN bit
1258: SynchronizeIO();
1259:
1260: /* Get residual count from DMA transfer. */
1261:
1262: dmaResidualCount = fCurioAddr[ rXCM ] << 8 | fCurioAddr[ rXCL ];
1263: actualTransferCount = fThisTransferLength - dmaResidualCount;
1264:
1265: ELG( dmaResidualCount, actualTransferCount, 'fDMA', "fsmDMAComplete" );
1266:
1267: /* Now, see if there are any bytes lurking in the FIFO: */
1268:
1269: fifoResidualCount = fCurioAddr[ rFOS ] & kFIFOCountMask;
1270:
1271: if ( fifoResidualCount > 0 )
1272: { /* Drain the FIFO after DMA for a normal transfer: */
1273: ELG( 0, fifoResidualCount, 'MTFF', "fsmDMAComplete - empty the FIFO" );
1274:
1275: if ( !fCmdData->isWrite )
1276: {
1277: while ( fifoResidualCount > 0 )
1278: { /* Try to move residual data from the FIFO into */
1279: /* the user's buffer. */
1280: residualByte = fCurioAddr[ rFFO ];
1281: fCmdData->mdp->writeBytes( fCmdData->results.bytesTransferred + actualTransferCount,
1282: &residualByte, 1 );
1283: ++actualTransferCount;
1284: }/* end WHILE bytes in FIFO */
1285: }
1286: else
1287: { /* Write command - just flush the data */
1288: setCmdReg( cFlshFFO );
1289: setCmdReg( cNOP | bDMAEnBit ); // clear TC zero bit;
1290: actualTransferCount -= fifoResidualCount;
1291: }/* end IF Write */
1292: }/* end IF bytes left in FIFO */
1293:
1294: fCmdData->results.bytesTransferred += actualTransferCount;
1295:
1296: if ( fSaveStatus & sParityErr )
1297: {
1298: PAUSE( 0, 0, 'par-', "fsmDMAComplete - parity error" );
1299: fsmStartErrorRecovery( kIOReturnParityError );
1300: }
1301: else
1302: {
1303: fBusState = SCS_INITIATOR; /* Continue following phase changes. */
1304: }
1305:
1306: return;
1307: }/* end fsmDMAComplete */
1308:
1309:
1310: /* Just completed the SCMD_TRANSFER_INFO operation for message in. */
1311: /* ACK is not asserted (we have not ACK'ed this byte). */
1312: /* There is no parity error. */
1313: /* We will not have a command if we're reselecting. */
1314:
1315: void CurioSCSIController::fsmGettingMsg()
1316: {
1317: UInt32 fifoCount;
1318: UInt8 msgInByte;
1319: IOReturn ioReturn = kIOReturnSuccess;
1320:
1321:
1322: ELG( fBusBusy, fMsgInState<<16 | fCurioAddr[ rFOS ], 'fGtM', "fsmGettingMsg" );
1323:
1324: if ( fBusBusy == false )
1325: {
1326: /* This (non-fatal) error is handled on return... */
1327: ioReturn = kIOReturnInternalError; /* Any non-zero non-fatal error status */
1328: }
1329: else
1330: {
1331: fifoCount = fCurioAddr[ rFOS ] & kFIFOCountMask;
1332: if ( fifoCount != 1 )
1333: {
1334: PAUSE( 0, fifoCount, 'GtM-', "fsmGettingMsg - MsgIn FIFO count error" );
1335: ioReturn = kIOReturnInternalError;
1336: }
1337: }
1338:
1339: if ( ioReturn == kIOReturnSuccess )
1340: {
1341: msgInByte = fCurioAddr[ rFFO ];
1342: ELG( 0, msgInByte, '=Msg', "fsmGettingMsg - got a byte" );
1343: if ( fSaveStatus & sParityErr )
1344: {
1345: PAUSE( 0, fSaveStatus, 'Par-', "fsmGettingMsg - Parity error getting MsgIn" );
1346: ioReturn = kIOReturnParityError;
1347: }
1348: }
1349:
1350: if ( ioReturn == kIOReturnSuccess )
1351: {
1352: if ( fMsgInState == kMsgInInit )
1353: {
1354: fMsgInCount = 0;
1355: fMsgInIndex = 0;
1356: }
1357: if ( fMsgInIndex >= kMessageInBufferLength )
1358: {
1359: PAUSE( 0, fMsgInIndex, 'Par-', "fsmGettingMsg - too many bytes" );
1360: ioReturn = kIOReturnInternalError;
1361: }
1362: }
1363:
1364: if ( ioReturn == kIOReturnSuccess )
1365: {
1366: fMsgInBuffer[ fMsgInIndex++ ] = msgInByte;
1367: switch ( fMsgInState )
1368: {
1369: case kMsgInInit: /* This is the first message byte. */
1370: if ( (msgInByte == kSCSIMsgCmdComplete)
1371: || (msgInByte >= (UInt8)kSCSIMsgIdentify) )
1372: { /* This is 1-byte cmdComplete or Identify message. */
1373: fMsgInState = kMsgInReady;
1374: }
1375: else if ( msgInByte == kSCSIMsgExtended )
1376: { /* This is an extended message. The next byte has the count. */
1377: fMsgInState = kMsgInCounting;
1378: }
1379: else if ( msgInByte <= kSCSIMsgOneByteMax )
1380: { /* These are other 1-byte messages. */
1381: fMsgInState = kMsgInReady;
1382: }
1383: else if ( msgInByte >= kSCSIMsgTwoByteMin
1384: && msgInByte <= kSCSIMsgTwoByteMax )
1385: { /* This is a two-byte message. */
1386: /* Set the count and read the next byte. */
1387: fMsgInState = kMsgInReading; /* Need one more */
1388: fMsgInCount = 1;
1389: }
1390: else
1391: { /* This is an unknown message. */
1392: fMsgInState = kMsgInReady;
1393: }
1394: break;
1395:
1396: case kMsgInCounting: /* Count byte of multi-byte message: */
1397: fMsgInCount = msgInByte;
1398: fMsgInState = kMsgInReading;
1399: break;
1400:
1401: case kMsgInReading: /* Body of multi-byte message: */
1402: if ( --fMsgInCount <= 0 )
1403: fMsgInState = kMsgInReady;
1404: break;
1405:
1406: default:
1407: PAUSE( 0, 0, 'Msg-', "DoMessageInPhase - Bogus MSGI state!\n" );
1408: ioReturn = kIOReturnInternalError;
1409: }/* SWITCH on message state */
1410: }
1411:
1412: if ( ioReturn == kIOReturnSuccess )
1413: {
1414: switch ( fMsgInState )
1415: {
1416: case kMsgInReading:
1417: case kMsgInCounting: /* We have more message bytes to read. */
1418: /* Accept this byte (this sets ACK) and setup */
1419: /* to transfer the next byte. */
1420: setCmdReg( cMsgAcep );
1421: /* Since the message accept command sets "interrupt", */
1422: /* eat it here so we don't get a second interrupt. */
1423: quickCheckForInterrupt();
1424: setCmdReg( cNOP );
1425: setCmdReg( cIOXfer );
1426: if ( fBusState != SCS_RESELECTING )
1427: fBusState = SCS_GETTINGMSG;
1428: /* This would be a good place to spin-wait for completion, */
1429: /* continuing at the start of this method if there is */
1430: /* another byte (and we're still in message in phase). */
1431: /* Perhaps this method should return a "spinwait" status to */
1432: /* the mainline FSM. */
1433: break;
1434:
1435: case kMsgInReady:
1436: fMsgInState = kMsgInInit;
1437: ioReturn = fsmProcessMessage();
1438: break;
1439:
1440: case kMsgInInit:
1441: default:
1442: /* that's strange: we should never be in idle state */
1443: /* *after* successfully reading a message byte. */
1444: ioReturn = kIOReturnInternalError;
1445: break;
1446: }/* end SWITCH */
1447: }
1448:
1449: if ( ioReturn != kIOReturnSuccess )
1450: fsmStartErrorRecovery( ioReturn );
1451:
1452: return;
1453: }/* end fsmGettingMsg */
1454:
1455:
1456: /* Just read a message; ACK is false and the message */
1457: /* has been read into fMsgInBuffer[0..fMsgInIndex]. We have not */
1458: /* ACK'ed the last byte yet. */
1459: /* If we fail here, the caller will start error recovery. */
1460:
1461: IOReturn CurioSCSIController::fsmProcessMessage()
1462: {
1463: IOReturn ioReturn = kIOReturnSuccess;
1464: bool messageAckNeeded = true;
1465:
1466:
1467: ELG( fBusState, *(UInt32*)fMsgInBuffer, 'fMgI', "fsmProcessMessage" );
1468:
1469: /* Message-in complete. Handle message(s) in currMsgIn: */
1470:
1471: if ( fBusState == SCS_RESELECTING )
1472: {
1473: /* The only interesting message here is queue tag. */
1474: /* (What about target SDTR or Abort?) */
1475:
1476: switch ( fMsgInBuffer[0] )
1477: {
1478: case kSCSIMsgHeadOfQueueTag:
1479: case kSCSIMsgOrderedQueueTag:
1480: case kSCSIMsgSimpleQueueTag:
1481: if ( fMsgInIndex != 2 )
1482: {
1483: PAUSE( fMsgInBuffer[0], fMsgInIndex, 'Que-', "fsmProcessMessage - queue tag without tag value" );
1484: ioReturn = kIOReturnInternalError;
1485: }
1486: else
1487: { fTag = fMsgInBuffer[ 1 ];
1488: ELG( 0, fTag, '=Tag', "fsmProcessMessage - tag" );
1489: reselectNexus();
1490: if ( fCmd )
1491: {
1492: setCmdReg( cMsgAcep );
1493: fNeedAnotherInterrupt = true;
1494: fBusState = SCS_INITIATOR;
1495: return kIOReturnSuccess;
1496: }
1497: }
1498: break;
1499:
1500: default:
1501: ioReturn = kIOReturnInternalError;
1502: break;
1503: }/* end SWITCH on message */
1504:
1505: /* Since we process commands one by one, whack this */
1506: /* command so we fall through the regular message handler. */
1507: fMsgInBuffer[0] = kSCSIMsgNop;
1508: fMsgInIndex = 1;
1509: }
1510:
1511: fBusState = SCS_INITIATOR;
1512: fNeedAnotherInterrupt = true;
1513:
1514: switch ( fMsgInBuffer[0] )
1515: {
1516: case kSCSIMsgNop:
1517: break;
1518:
1519: case kSCSIMsgCmdComplete:
1520: /* Normally, we get here from fsmCommandComplete. */
1521: /* All we need to do is to Ack the message and complete the */
1522: /* command. Exit in a transitional bus state that becomes */
1523: /* SCS_DISCONNECTED when the bus is no longer busy. */
1524: fBusState = SCS_WAIT_FOR_BUS_FREE;
1525: completeCommand();
1526: break;
1527:
1528: case kSCSIMsgDisconnect:
1529: fCmd = NULL;
1530: /* Exit the interrupt service routine so */
1531: /* we don't miss a reselection interrupt. */
1532: fBusState = SCS_WAIT_FOR_BUS_FREE;
1533: fCkForAnotherInt = false;
1534: break;
1535:
1536: case kSCSIMsgSaveDataPointers:
1537: if ( fCmd )
1538: fCmdData->savedDataPosition = fCmdData->results.bytesTransferred;
1539: break;
1540:
1541: case kSCSIMsgRestorePointers:
1542: if ( fCmd )
1543: fCmdData->results.bytesTransferred = fCmdData->savedDataPosition;
1544: break;
1545:
1546: case kSCSIMsgRejectMsg:
1547: ioReturn = kIOReturnInternalError;
1548:
1549: // don't break - fall through to kSCSIMsgAbort */
1550:
1551: case kSCSIMsgAbort:
1552: case kSCSIMsgAbortTag:
1553: if ( fCmd )
1554: { /* Oops: something is terribly wrong with this command. */
1555: /* This can happen if we get a parity error, set ATN, */
1556: /* and send an inititor detected error to the target. */
1557: fCmdData->results.returnCode = kIOReturnInternalError;
1558: completeCommand();
1559: fCkForAnotherInt = false;
1560: }
1561: /* After receiving an Abort, the target will go free */
1562: fBusState = SCS_WAIT_FOR_BUS_FREE;
1563: break;
1564:
1565: case kSCSIMsgLinkedCmdComplete:
1566: case kSCSIMsgLinkedCmdCompleteFlag:
1567: /* These are impossible: we reject commands with the link bit set. */
1568: /* About all we can do is to fail the client's command and */
1569: /* stagger onwards. */
1570: PAUSE( fCmd, 0, 'Abo-', "fsmProcessMessage - recv'd Abort" );
1571: fCmdData->results.returnCode = kIOReturnInternalError;
1572: completeCommand();
1573: fBusState = SCS_WAIT_FOR_BUS_FREE;
1574: break;
1575:
1576: case kSCSIMsgExtended:
1577: /* The only expected extended message is */
1578: /* synchronous negotiation which isn't supported. */
1579: switch ( fMsgInBuffer[2] )
1580: {
1581: case kSCSIMsgSyncXferReq:
1582: /* We don't support SDTR (yet), so send a message reject */
1583: /* Perhaps it would be better to send an "async only" */
1584: /* response, but message reject is legal. */
1585: WRITE_REGISTER( rFFO, kSCSIMsgRejectMsg );
1586: setCmdReg( cSetAtn );
1587: messageAckNeeded = false;
1588: break;
1589:
1590: default:
1591: WRITE_REGISTER( rFFO, kSCSIMsgRejectMsg );
1592: setCmdReg( cSetAtn );
1593: messageAckNeeded = false;
1594: break;
1595: }
1596: break;
1597:
1598: default: /* all others are unacceptable. */
1599: WRITE_REGISTER( rFFO, kSCSIMsgRejectMsg );
1600: setCmdReg( cSetAtn );
1601: messageAckNeeded = false;
1602: }/* end SWITCH on Message byte */
1603:
1604: if ( messageAckNeeded )
1605: setCmdReg( cMsgAcep );
1606:
1607: return ioReturn;
1608: }/* end fsmProcessMessage */
1609:
1610:
1611: /* Just completed the SCMD_TRANSFER_INFO operation for command. */
1612: void CurioSCSIController::fsmSendingCmd()
1613: {
1614: fBusState = SCS_INITIATOR;
1615: return;
1616: }/* end fsmSendingCmd */
1617:
1618:
1619: /* Follow SCSI Phase change. Called while SCS_INITIATOR. */
1620:
1621: void CurioSCSIController::fsmPhaseChange()
1622: {
1623: int i;
1624:
1625:
1626: ELG( 0, fSaveStatus, 'fPhC', "fsmPhaseChange" );
1627:
1628: fCurrentBusPhase = fSaveStatus & mPhase;
1629:
1630: switch ( fCurrentBusPhase )
1631: {
1632: case kBusPhaseCMD:
1633: /* The normal case here is after a host-initiated SDTR sequence. */
1634: setCmdReg( cFlshFFO );
1635: putCDBIntoFIFO();
1636: setCmdReg( cIOXfer ); /* Start non-DMA xfer */
1637: fMsgInState = kMsgInInit;
1638: fBusState = SCS_SENDINGCMD;
1639: break;
1640:
1641: case kBusPhaseDATI: /* From target to Initiator (read) */
1642: case kBusPhaseDATO: /* To Target from Initiator (write) */
1643: fMsgInState = kMsgInInit;
1644: fsmStartDataPhase( fCurrentBusPhase == kBusPhaseDATI );
1645: fCkForAnotherInt = false;
1646: break;
1647:
1648: case kBusPhaseSTS: /* Status from Target to Initiator */
1649: /* fsmCompleting will collect the STATUS byte (and */
1650: /* hopefully a MSG) from the FIFO when this completes. */
1651: fMsgInState = kMsgInInit;
1652: fBusState = SCS_COMPLETING;
1653: setCmdReg( cFlshFFO );
1654: setCmdReg( cCmdComp );
1655: break;
1656:
1657: case kBusPhaseMSGI: /* Message from Target to Initiator */
1658: if ( fBusState != SCS_RESELECTING )
1659: fBusState = SCS_GETTINGMSG;
1660: setCmdReg( cNOP );
1661: setCmdReg( cIOXfer );
1662: break;
1663:
1664: case kBusPhaseMSGO: /* Message from Initiator to Target */
1665: fMsgInState = kMsgInInit;
1666: setCmdReg( cFlshFFO );
1667:
1668: if ( fpMsgPut == fpMsgOut )
1669: *fpMsgOut++ = kSCSIMsgNop; /* no message waiting to be sent. */
1670:
1671:
1672: for ( i = 0; i < 16 && fpMsgPut < fpMsgOut; i++ )
1673: { WRITE_REGISTER( rFFO , *fpMsgPut );
1674: fpMsgPut++;
1675: }
1676:
1677: if ( fpMsgPut == fpMsgOut )
1678: fpMsgPut = fpMsgOut = fMsgOutBuffer;
1679:
1680: fBusState = SCS_SENDINGMSG;
1681: /* ATN is automatically cleared when transfer info completes. */
1682: setCmdReg( cIOXfer ); /* Start non-DMA xfer */
1683: break;
1684:
1685: default:
1686: fsmStartErrorRecovery( kIOReturnInternalError );
1687: break;
1688: }
1689: return;
1690: }/* end fsmPhaseChange */
1691:
1692:
1693: void CurioSCSIController::fsmStartDataPhase( bool isDataInPhase )
1694: {
1695: IOReturn ioReturn = kIOReturnSuccess;
1696:
1697:
1698: ELG( fCmd, fThisTransferLength, 'fDat', "fsmStartDataPhase" );
1699:
1700: /* DataIn phase is legal if this is a read command: */
1701:
1702: if ( isDataInPhase != !fCmdData->isWrite )
1703: {
1704: ioReturn = kIOReturnInternalError;
1705: PAUSE( fCmd, isDataInPhase, 'Dir-', "fsmStartDataPhase - data direction" );
1706: }
1707:
1708: if ( ioReturn == kIOReturnSuccess )
1709: {
1710: ioReturn = generateCCL();
1711: }
1712:
1713: if ( ioReturn == kIOReturnSuccess )
1714: {
1715: if ( fThisTransferLength == 0 )
1716: {
1717: ioReturn = kIOReturnInternalError;
1718: PAUSE( fCmd, 0, 'Dat0', "fsmStartDataPhase - no data" );
1719: }
1720: }
1721:
1722: if ( ioReturn == kIOReturnSuccess )
1723: {
1724: // IOSetDBDMACommandPtr( fDBDMAAddr, fCCLPhysAddr );
1725: fDBDMAAddr->commandPtrLo = SWAP( fCCLPhysAddr );
1726: SynchronizeIO();
1727:
1728: // IOSetDBDMAChannelControl( fDBDMAAddr, kdbdmaRun * 0x1001 );
1729: // fDBDMAAddr->channelControl = SWAP( kdbdmaRun * 0x1001 );
1730: fDBDMAAddr->channelControl = SWAP( 0x80008000 ); // set RUN bit
1731: SynchronizeIO();
1732:
1733: WRITE_REGISTER( rXCM, fThisTransferLength >> 8 );
1734: WRITE_REGISTER( rXCL, fThisTransferLength & 0xFF );
1735: setCmdReg( cDMAXfer );
1736:
1737: fBusState = SCS_DMACOMPLETE;
1738: }
1739:
1740: if ( ioReturn != kIOReturnSuccess )
1741: {
1742: PAUSE( 0, 0, 'Dat-', "fsmStartDataPhase - data phase error" );
1743: fsmStartErrorRecovery( ioReturn );
1744: }
1745: return;
1746: }/* end fsmStartDataPhase */
1747:
1748:
1749: /* Start error recovery by doing something reasonable for the */
1750: /* current bus phase. This is called when we enter error recovery */
1751: /* (SCS_DEATH_MARCH) from an interrupt or other bus phase action handler. */
1752:
1753: void CurioSCSIController::fsmStartErrorRecovery( IOReturn status )
1754: {
1755:
1756: ELG( fCmd, 0, 'fSER', "fsmStartErrorRecovery" );
1757: killActiveCommand( status );
1758: /* Clean out the SCSI and DBDMA hardware */
1759: setCmdReg( cFlshFFO );
1760: setCmdReg( cNOP | bDMAEnBit ); // clear TC zero bit
1761: // IODBDMAReset( fDBDMAAddr );
1762: fDBDMAAddr->channelControl = SWAP( 0x20002000 ); // set FLUSH bit
1763: SynchronizeIO();
1764: fDBDMAAddr->channelControl = SWAP( 0x80000000 ); // clr RUN bit
1765: SynchronizeIO();
1766:
1767: if ( fBusBusy == false )
1768: fBusState = SCS_DISCONNECTED;
1769: else fBusState = SCS_DEATH_MARCH;/* We will continue at fsmContinueErrorRecovery */
1770:
1771: fCkForAnotherInt = false;
1772: return;
1773: }/* end fsmStartErrorRecovery */
1774:
1775:
1776: /* Manage error recovery by responding to a target interrupt while in */
1777: /* an error recovery state. On exit, the bus state will be as follows: */
1778: /* SCS_DEATH_MARCH Still in error recovery. Call fsmContinueErrorRecovery */
1779: /* to continue processing target requests. */
1780: /* SCS_DISCONNECTED The target is finally off the bus. We can restart */
1781: /* normal operation. */
1782: /* Each bus phase requires a different action: */
1783: /* Data Out Clean up after DMA. */
1784: /* Data In Clean up after DMA. */
1785: /* Command Flush the FIFO */
1786: /* Status Drain the FIFO, if we get two bytes, just ACK the message */
1787: /* Message Out Do nothing */
1788: /* Message In Read the message byte, ACK it. */
1789:
1790: void CurioSCSIController::fsmErrorRecoveryInterruptService()
1791: {
1792: setCmdReg( cFlshFFO );
1793:
1794: switch ( fCurrentBusPhase )
1795: {
1796: case kBusPhaseDATO:
1797: case kBusPhaseDATI:
1798: // IODBDMAReset( fDBDMAAddr );
1799: fDBDMAAddr->channelControl = SWAP( 0x20002000 ); // set FLUSH bit
1800: SynchronizeIO();
1801: fDBDMAAddr->channelControl = SWAP( 0x80000000 ); // clr RUN bit
1802: SynchronizeIO();
1803: setCmdReg( cNOP | bDMAEnBit ); // clear TC zero bit
1804: break;
1805:
1806: case kBusPhaseCMD:
1807: break;
1808:
1809: case kBusPhaseSTS:
1810: if ( fSaveInterrupt & iFuncComp )
1811: {
1812: /* We got both bytes: ACK the command complete */
1813: setCmdReg( cMsgAcep );
1814: }
1815: break;
1816:
1817: case kBusPhaseMSGO:
1818: break;
1819:
1820: case kBusPhaseMSGI:
1821: setCmdReg( cMsgAcep );
1822: break;
1823:
1824: case kBusPhaseBusFree: /* Selecting */
1825: break;
1826:
1827: default:
1828: killActiveCommand( kIOReturnInternalError );
1829: resetBus();
1830: break;
1831: }
1832: return;
1833: }/* end fsmErrorRecoveryInterruptService */
1834:
1835:
1836: /* Continue to manage error recovery. We are here because the target */
1837: /* is still on the bus and doing strange bus phase things. Follow the */
1838: /* target bus phase (one phase at a time) until the target disconnects. */
1839: /* We just run bit-bucket commands until the target gives up. */
1840: /* (Note that this means that we might send a Command Complete message */
1841: /* to the target. We'll look for this case and send an Abort or */
1842: /* Abort Tag instead.) */
1843:
1844: void CurioSCSIController::fsmContinueErrorRecovery()
1845: {
1846: UInt8 msgByte;
1847:
1848:
1849: quickCheckForInterrupt();
1850:
1851:
1852: if ( fBusBusy )
1853: {
1854: interruptPending();
1855: if ( fSaveInterrupt & iDisconnect )
1856: fBusBusy = false;
1857: }
1858:
1859: if ( fBusBusy == false )
1860: {
1861: fBusState = SCS_DISCONNECTED;
1862: }
1863: else
1864: {
1865: fCurrentBusPhase = fSaveStatus & mPhase;
1866:
1867: switch ( fCurrentBusPhase )
1868: {
1869: case kBusPhaseMSGO:
1870: msgByte = kSCSIMsgAbort;
1871: WRITE_REGISTER( rFFO, msgByte );
1872: setCmdReg( cIOXfer ); /* Start non-DMA xfer */
1873: break;
1874:
1875: case kBusPhaseDATO:
1876: case kBusPhaseCMD:
1877: WRITE_REGISTER( rXCM, 0xFF );
1878: WRITE_REGISTER( rXCL, 0xFF );
1879: setCmdReg( cDMAXferPad ); /* DMA out pad */
1880: break;
1881:
1882: case kBusPhaseMSGI:
1883: case kBusPhaseDATI:
1884: case kBusPhaseSTS:
1885: WRITE_REGISTER( rXCM, 0xFF );
1886: WRITE_REGISTER( rXCL, 0xFF );
1887: setCmdReg( cXferPad ); /* non-DMA out pad */
1888: break;
1889:
1890: default:
1891: killActiveCommand( kIOReturnInternalError );
1892: resetBus();
1893: break;
1894: }
1895: }/* end SWITCH on current phase */
1896:
1897: return;
1898: }/* end fsmContinueErrorRecovery */
1899:
1900:
1901:
1902: IOReturn CurioSCSIController::getReselectionTargetID( UInt8 selectByte )
1903: {
1904: register UInt8 targetBits = selectByte;
1905: register UInt8 targetID = 0;
1906: register UInt8 bitValue; /* Supress warning */
1907:
1908:
1909: if ( (targetBits & fInitiatorIDMask) == 0 )
1910: {
1911: PAUSE( 0, selectByte, 'IId-', "getReselectionTargetID - Reselection failed: initiator ID bit not set" );
1912: return kIOReturnInternalError;
1913: }
1914:
1915: targetBits = selectByte;
1916: targetBits &= ~fInitiatorIDMask; /* Remove our bit */
1917: if ( targetBits == 0 )
1918: {
1919: PAUSE( 0, selectByte, 'TId-', "getReselectionTargetID - Reselection failed: Target ID bit not set" );
1920: return kIOReturnInternalError;
1921: }
1922:
1923: bitValue = targetBits;
1924:
1925: if ( bitValue > 0x0F ) { targetID += 4; bitValue >>= 4; }
1926: if ( bitValue > 0x03 ) { targetID += 2; bitValue >>= 2; }
1927: if ( bitValue > 0x01 ) targetID += 1;
1928:
1929: targetBits &= ~(1 << targetID); /* Remove the target mask */
1930: if ( targetBits != 0 )
1931: {
1932: PAUSE( 0, selectByte, 'TTT-', "getReselectionTargetID - Reselection failed: multiple targets" );
1933: return kIOReturnInternalError;
1934: }
1935:
1936: ELG( 0, targetID, '=Tar', "getReselectionTargetID" );
1937:
1938: fCurrentTargetLun.target = targetID; /* Save the current target */
1939: return kIOReturnSuccess;
1940: }/* end getReselectionTargetID */
1941:
1942:
1943: void CurioSCSIController::reselectNexus()
1944: {
1945: fCmd = findCommandWithNexus( fCurrentTargetLun, fTag );
1946: if ( fCmd )
1947: { fCmdData = (PrivCmdData*)fCmd->getCommandData();
1948: ELG( fCmd, *(UInt16*)&fCurrentTargetLun<<16 | (UInt16)fTag, '=Nex', "reselectNexus" );
1949: }
1950: else
1951: { if ( fTag != kInvalidTag )
1952: ELG( 0, *(UInt16*)&fCurrentTargetLun<<16 | (UInt16)fTag, 'Nex-', "reselectNexus" );
1953: }
1954:
1955: return;
1956: }/* end reselectNexus */
1957:
1958:
1959: /* Send a command to the MESH chip. This may cause an interrupt. */
1960:
1961: void CurioSCSIController::setCmdReg( UInt8 command )
1962: {
1963: ELG( 0, command, '=Cmd', "setCmdReg" );
1964:
1965: fCurioAddr[ rCMD ] = command; /***** DO IT *****/
1966: SynchronizeIO();
1967:
1968: return;
1969: }/* end setCmdReg */
1970:
1971:
1972:
1973: /* This spin-loop looks for another chip operation - it prevents */
1974: /* exiting the interrupt service routine if the chip presents */
1975: /* another operation within ten microseconds. Note that this */
1976: /* must be called from an IOThread, not from a "real" primary */
1977: /* interrupt service routine. */
1978: /* @return true if an interrupt is pending. */
1979:
1980: #define OVERTIME( now, end ) \
1981: ( ((now)->tv_sec > (end)->tv_sec) \
1982: || (((now)->tv_sec == (end)->tv_sec) && ((now)->tv_nsec > (end)->tv_nsec)) )
1983:
1984:
1985: bool CurioSCSIController::quickCheckForInterrupt()
1986: {
1987: mach_timespec_t thisTime, endTime;
1988:
1989:
1990: IOGetTime( &endTime ); // calc the omega
1991: endTime.tv_nsec += 10000; // 10 mikes from now
1992: if ( endTime.tv_nsec >= NSEC_PER_SEC )
1993: {
1994: endTime.tv_sec += 1;
1995: endTime.tv_nsec -= NSEC_PER_SEC;
1996: }
1997: /* whiz til interrupt or time's up: */
1998: do
1999: {
2000: if ( interruptPending() )
2001: return true;
2002:
2003: IOGetTime( &thisTime );
2004: } while ( OVERTIME( &thisTime, &endTime ) == false );
2005:
2006: return false;
2007: }/* end quickCheckForInterrupt */
2008:
2009:
2010: /* Determine if SCSI interrupt is pending. If so, store the current */
2011: /* chip state. Note that reading the interrupt register clears the */
2012: /* interrupt source, so this should be done once for each interrupt.*/
2013: /* @return true if an interrupt is pending. */
2014:
2015: bool CurioSCSIController::interruptPending()
2016: {
2017: bool result = false;
2018:
2019:
2020: /* mlj - use WHILE to check for double interrupts */
2021: /* and get get most recent conditions. */
2022:
2023: while ( (fSaveStatus = fCurioAddr[ rSTA ]) & sIntPend ) // ??? volatile
2024: {
2025: result = true;
2026: fSaveSeqStep = fCurioAddr[ rSQS ];
2027: fSaveInterrupt = fCurioAddr[ rINT ]; /* this clears rSTA and rSQS */
2028: ELG( fSaveSeqStep, fSaveStatus<<16 | fSaveInterrupt, 'Regs', "interruptPending" );
2029: }
2030: return result;
2031: }/* end interruptPending */
2032:
2033:
2034:
2035: void CurioSCSIController::putCDBIntoFIFO()
2036: {
2037: SCSICDBInfo scsiCDB;
2038: UInt32 i;
2039:
2040:
2041: fCmd->getCDB( &scsiCDB );
2042: for ( i = 0; i < scsiCDB.cdbLength; i++ )
2043: WRITE_REGISTER( rFFO, scsiCDB.cdb[ i ] );
2044:
2045: return;
2046: }/* end putCDBIntoFIFO */
2047:
2048:
2049: /* resetCurio - Reset the chip to hardware power on state. */
2050:
2051: void CurioSCSIController::resetCurio()
2052: {
2053: ELG( 0, 0, 'ResC', "resetCurio" );
2054: setCmdReg( cRstSChp ); /* Reset chip */
2055: IODelay( 50 ); /* Chip settle */
2056: setCmdReg( cNOP ); /* Re-enable chip */
2057: setCmdReg( cFlshFFO ); /* In a clean state */
2058: return;
2059: }/* end resetCurio */
2060:
2061:
2062: /* resetHardware - Reusable hardware initializer function. */
2063: /* if busReset is true, this includes a SCSI bus reset. */
2064:
2065: IOReturn CurioSCSIController::resetHardware( bool busReset )
2066: {
2067: IOReturn ioReturn = kIOReturnSuccess;
2068: UInt8 configValue;
2069: UInt8 clockConversionFactor;
2070: UInt8 defaultSelectionTimeout;
2071: UInt8 temp;
2072:
2073:
2074: /* Temp for debugging */
2075:
2076: fSCSIClockRate = kChipDefaultBusClockMHz;
2077:
2078: ELG( fSCSIClockRate, busReset, 'ResH', "resetHardware" );
2079:
2080: /* First of all, reset interrupts, the SCSI chip, and the DMA engine. */
2081:
2082: // resetCurio(); /* Clear out the chip */
2083:
2084: temp = fCurioAddr[ rINT ]; /* Clear pending interrupt */
2085:
2086: // IODBDMAReset( fDBDMAAddr ); /* Stop the DMA engine */
2087: fDBDMAAddr->channelControl = SWAP( 0x20002000 ); // set FLUSH bit
2088: SynchronizeIO();
2089: fDBDMAAddr->channelControl = SWAP( 0x80000000 ); // clr RUN bit
2090: SynchronizeIO();
2091:
2092: /* Initialize the chip: */
2093:
2094: WRITE_REGISTER( rCF2, CF2_EPL ); /* Enable Phase Latching */
2095: setCmdReg(cNOP | bDMAEnBit); /* DMA Nop */
2096:
2097: /* Init state variables: */
2098:
2099: fCkForAnotherInt = false;
2100: fBusState = SCS_DISCONNECTED;
2101: fBusBusy = false;
2102: fCurrentBusPhase = kBusPhaseBusFree;
2103:
2104: /* Smash all active command state (just in case). */
2105:
2106: fCmd = NULL;
2107: fMsgInState = kMsgInInit;
2108: fpMsgOut = fpMsgPut = fMsgOutBuffer;
2109:
2110: fCurrentTargetLun.target = kInvalidTarget;
2111: fCurrentTargetLun.lun = kInvalidLUN;
2112:
2113: /* Configuration Register 1 */
2114: /* Disable interrupt on initiator-instantiated bus reset */
2115: /* (is this correct?) */
2116: /* Enable parity. */
2117: /* Set default bus ID (7) (This should be overriden by the */
2118: /* Inspector) */
2119:
2120: fInitiatorID = kDefaultInitiatorID;
2121: configValue = CF1_SRD | CF1_ENABPAR | fInitiatorID;
2122:
2123: #define gOptionExtendTiming 0
2124: if ( gOptionExtendTiming )
2125: { /* Per instance table. This slows down transfers on the bus. */
2126: configValue |= CF1_SLOW;
2127: }
2128:
2129: WRITE_REGISTER( rCF1, configValue );
2130:
2131: /* Clock factor and select timeout. */
2132:
2133: /* Use the clock frequency (in MHz) to select the clock conversion */
2134: /* factor. According to the NCR53CF94/96 data manual, the conversion */
2135: /* factor is defined by the following table: Currently, we don't allow */
2136: /* the caller to change selection timeout from the ANSI standard */
2137: /* 250 Msec to avoid having to support floating-point register */
2138: /* manipulation */
2139:
2140: if ( fSCSIClockRate < 10) fSCSIClockRate = 10;
2141: if ( fSCSIClockRate > 40 ) fSCSIClockRate = 40;
2142:
2143: if ( fSCSIClockRate <= 10 )
2144: {
2145: clockConversionFactor = ccf10MHz;
2146: defaultSelectionTimeout = SelTO16Mhz;
2147: }
2148: else if ( fSCSIClockRate <= 15 )
2149: {
2150: clockConversionFactor = ccf11to15MHz;
2151: defaultSelectionTimeout = SelTO16Mhz;
2152: }
2153: else if ( fSCSIClockRate <= 20 )
2154: {
2155: clockConversionFactor = ccf16to20MHz;
2156: defaultSelectionTimeout = SelTO16Mhz;
2157: }
2158: else if ( fSCSIClockRate <= 25 )
2159: {
2160: clockConversionFactor = ccf21to25MHz;
2161: defaultSelectionTimeout = SelTO25Mhz;
2162: }
2163: else if ( fSCSIClockRate <= 30 )
2164: {
2165: clockConversionFactor = ccf26to30MHz;
2166: defaultSelectionTimeout = SelTO33Mhz;
2167: }
2168: else if ( fSCSIClockRate <= 35 )
2169: {
2170: clockConversionFactor = ccf31to35MHz;
2171: defaultSelectionTimeout = SelTO40Mhz;
2172: }
2173: else
2174: {
2175: clockConversionFactor = ccf31to35MHz;
2176: defaultSelectionTimeout = SelTO40Mhz;
2177: }
2178:
2179: WRITE_REGISTER( rCKF, clockConversionFactor );
2180:
2181: WRITE_REGISTER( rINT, defaultSelectionTimeout);
2182:
2183: /* Configuration Register 2 - enable extended features */
2184: /* - mainly, 24-bit transfer count. */
2185:
2186: WRITE_REGISTER( rCF2, CF2_EPL );
2187:
2188: /* Configuration Register 3 */
2189:
2190: configValue = 0;
2191:
2192: #define gOptionFastModeEnable 0
2193: #define gOptionFastModeSupportedByHardware 0
2194:
2195: if ( (gOptionFastModeEnable && gOptionFastModeSupportedByHardware)
2196: || fSCSIClockRate > 25 )
2197: {
2198: configValue |= CF3_FASTSCSI;
2199: }
2200:
2201: WRITE_REGISTER( rCF3, configValue );
2202:
2203: /* Configuration Register 4 - glitch eater, active negation. */
2204: /* Let's not worry about these whizzy features just yet. */
2205:
2206: WRITE_REGISTER( rCF4, 0 );
2207:
2208: /* Go to async xfer mode for now. */
2209:
2210: WRITE_REGISTER( rFOS, 0 );
2211:
2212: /* Reset SCSI bus, wait, clear possible interrupt. */
2213:
2214: if ( busReset )
2215: {
2216: setCmdReg( cRstSBus );
2217: IOSleep( kSCSIResetDelay );
2218: temp = fCurioAddr[ rINT ]; // clear the Interrupt register
2219: }
2220: return ioReturn;
2221: }/* end resetHardware */
2222:
2223:
2224: void CurioSCSIController::releaseHardwareMemoryMaps()
2225: {
2226: if ( fDBDMAMemoryMap )
2227: {
2228: fDBDMAMemoryMap->release();
2229: fDBDMAMemoryMap = NULL;
2230: }
2231:
2232: if ( fSCSIMemoryMap )
2233: {
2234: fSCSIMemoryMap->release();
2235: fSCSIMemoryMap = NULL;
2236: }
2237:
2238: if ( fCCL )
2239: {
2240: IOFree( fCCL, fCCLSize );
2241: }
2242:
2243: return;
2244: }/* end releaseHardwareMemoryMaps */
2245:
2246:
2247: /* When a legitimate data phase starts, this method */
2248: /* is called to configure the DBDMA Channel Command list. */
2249:
2250: IOReturn CurioSCSIController::generateCCL()
2251: {
2252: IODBDMADescriptor *dp; /* current descriptor */
2253: IODBDMADescriptor *dpMax; /* past the last descriptor */
2254: UInt32 dbdmaOp; /* DBDMA opcode */
2255: UInt32 rangeByteCount, actualRanges;
2256: UInt32 i;
2257: IOPhysicalSegment range[ kMaxMemoryCursorSegments ];
2258:
2259:
2260:
2261: // IODBDMAReset( fDBDMAAddr ); /* make sure that the DBDMA is idle. */
2262: fDBDMAAddr->channelControl = SWAP( 0x20002000 ); // set FLUSH bit
2263: SynchronizeIO();
2264: fDBDMAAddr->channelControl = SWAP( 0x80000000 ); // clr RUN bit
2265: SynchronizeIO();
2266:
2267: if ( fCmdData->isWrite ) /* Select the correct DBDMA: */
2268: dbdmaOp = OUTPUT_MORE;
2269: else dbdmaOp = INPUT_MORE;
2270:
2271: /* How many descriptors can we store (need some slop for the */
2272: /* terminator commands). */
2273: /* Get a pointer to the first free descriptor and the total */
2274: /* number of bytes left to transfer in this I/O request. */
2275:
2276: dp = (IODBDMADescriptor*)fCCL;
2277: dpMax = (IODBDMADescriptor*)(fCCL + fCCLSize - 256);
2278:
2279: /* fThisTransferLength will contain the actual number */
2280: /* of bytes we intend to transfer in this DMA request, */
2281: /* which is needed when DMA completes to recover the */
2282: /* residual transfer length. */
2283: fThisTransferLength = 0;
2284:
2285: while ( (dp < dpMax) && (fThisTransferLength < kMaxDMATransfer) )
2286: {
2287: actualRanges = fMemoryCursor->getPhysicalSegments( fCmdData->mdp,
2288: fCmdData->results.bytesTransferred + fThisTransferLength,
2289: range,
2290: (unsigned int)kMaxMemoryCursorSegments,
2291: 0, &rangeByteCount );
2292: if ( actualRanges == 0 )
2293: break;
2294:
2295: for ( i = 0; i < actualRanges; i++ )
2296: {
2297: ELG( range[ i ].location, range[ i ].length, '=Rng', "generateCCL - range" );
2298: dp->operation = SWAP( dbdmaOp | range[ i ].length );
2299: dp->address = SWAP( (UInt32)range[ i ].location );
2300: dp->cmdDep = 0; // no branch address
2301: dp->result = 0;
2302: dp++;
2303: }/* end FOR each range */
2304:
2305: fThisTransferLength += rangeByteCount;
2306: }/* end WHILE there is data to xfer */
2307:
2308: if ( (UInt8*)dp > fCCL )
2309: {
2310: /* We stored at least one descriptor. */
2311: /* Change the last one so it is an INPUT_LAST or OUTPUT_LAST. */
2312:
2313: dp->operation |= SWAP( IO_LAST );
2314: }
2315:
2316: dp->operation = SWAP( STOP_CMD );
2317: dp->address = 0;
2318: dp->cmdDep = 0;
2319: dp->result = 0;
2320: dp++;
2321:
2322: if( dp >= dpMax )
2323: PAUSE( dpMax, dp, 'Big-', "InitCmdCCL - CCL overrun" );
2324:
2325: flush_dcache( (vm_offset_t)fCCL, (UInt32)dp - (UInt32)fCCL, false );
2326:
2327: return kIOReturnSuccess;
2328: }/* end generateCCL */
2329:
2330:
2331: void CurioSCSIController::killActiveCommand( IOReturn finalStatus )
2332: {
2333: if ( fCmd )
2334: {
2335: fCmdData->results.returnCode = finalStatus;
2336: completeCommand();
2337: }
2338: return;
2339: }/* end killActiveCommand */
2340:
2341:
2342: void CurioSCSIController::resetBus()
2343: {
2344: setCmdReg( cRstSBus );
2345: super::resetOccurred();
2346: IOSleep( kSCSIResetDelay );
2347: enableCommands();
2348: return;
2349: }/* end resetBus */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.