![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to MESH_DBDMA.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc / drvAppleMesh_SCSI|
Return to MESH_DBDMA.m CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc / drvAppleMesh_SCSI |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /**
26: * Copyright (c) 1994-1996 NeXT Software, Inc. All rights reserved.
27: * Copyright 1993-1995 by Apple Computer, Inc., all rights reserved.
28: * Copyright 1997-1998 Apple Computer Inc. All Rights Reserved.
29: * @author Martin Minow mailto:[email protected]
30: * @revision 1997.02.13 Initial conversion from Copland sources.
31: *
32: * Set tabs every 4 characters.
33: *
34: * Edit History
35: * 1997.02.25 MM Initial conversion from Copland sources.
36: */
37:
38: #import <sys/systm.h>
39: #import <driverkit/generalFuncs.h>
40: #import <driverkit/kernelDriver.h>
41: #import <driverkit/align.h>
42: #import <driverkit/interruptMsg.h>
43: #import <driverkit/scsiTypes.h>
44: #import <driverkit/debugging.h>
45: #import <driverkit/IODirectDevice.h>
46: #import <driverkit/IOMemoryDescriptor.h>
47: #import <driverkit/IOSimpleMemoryDescriptor.h>
48: #import <driverkit/IOSCSIController.h>
49: #import <driverkit/IOPower.h>
50: #import <driverkit/return.h>
51: #import <bsd/dev/scsireg.h>
52: #import <mach/kern_return.h>
53: #import <mach/mach_interface.h>
54: #import <mach/message.h>
55: #import <machkit/NXLock.h>
56: #import <machdep/ppc/proc_reg.h>
57: #import <machdep/ppc/powermac.h>
58: #import <machdep/ppc/interrupts.h>
59: #import <machdep/ppc/dbdma.h>
60: #import <kernserv/prototypes.h>
61: #import <objc/objc.h>
62:
63: extern void flush_cache_v( vm_offset_t pa, unsigned length ); /* Should be available from kernel headers! */
64: // extern void invalidate_cache_v( vm_offset_t pa, unsigned length );
65: extern void kprintf( const char *, ... );
66: extern kern_return_t msg_send_from_kernel( msg_header_t*, int, int );
67:
68:
69: #import "MESH_DBDMA.h"
70:
71: #undef ASSERT
72: #define ASSERT(x)
73:
74: #if CustomMiniMon
75: extern globals g; /**** Use custom MiniMon's globals ****/
76: extern UInt32 gMESH_DBDMA, gMESH_DBDMA_Phys;
77: #else
78: globals g; /**** Instantiate the globals ****/
79: #endif /* CustomMiniMon */
80:
81:
82:
83: /* Channel Program. Note that this script must match the offsets */
84: /* specified in AppleMeshDefinitions.h. This script is copied into */
85: /* the channel command area (with appropriate entries byte-swapped */
86: /* so it ends up with the correct endian-ness). */
87: /* Lines beginning with "slash, star, star, slash" are modified */
88: /* by the driver before it starts the Channel Program. */
89:
90: const DBDMADescriptor gDescriptorList[] =
91: {
92: /* 0x00 kcclProblem - Branch here for anomalies */
93:
94: { MESH_REG( kMeshInterruptMask, kMeshIntrMask ) }, // Enable MESH interrupt
95: { STOP( kcclStageCCLx ) }, // anomaly
96:
97: /* 0x20 through 0x60 - Data for information phases: */
98:
99: { RESERVE }, // kcclCMDOdata - CDB ( 6,10,12,16 bytes)
100: { RESERVE }, // kcclMSGOdata - MSGO data (last byte @3F)
101: { RESERVE }, // kcclMSGIdata - MSGI data & STATUS
102: { RESERVE }, // kcclSenseCDB - CDB for (auto) Sense
103: { RESERVE }, // kcclBatchSize, kcclStageLabel
104:
105: /* 0x70 - kcclSense - AutoSense input: */
106:
107: { MESH_REG( kMeshTransferCount1, 0x00 ) }, // set MESH xfer count to 255
108: { MESH_REG( kMeshTransferCount0, kMaxAutosenseByteCount & 0xFF )},
109: { MESH_REG( kMeshSequence, kMeshDataInCmd | kMeshSeqDMA )},// Data-In to Seq register
110: { SENSE( kMaxAutosenseByteCount ) }, // Sense INPUT
111: { BRANCH( kcclGetStatus ) }, // do finish sequence
112:
113: /* 0xC0 - kcclPrototype - Prototype MESH 4-command Transfer sequence: */
114:
115: { MOVE_4( kcclBatchSize, 0, kRelAddressCP ) }, // MESH batch size
116: { MESH_REG( kMeshTransferCount1, 0 ) }, // Set high order Transfer Count
117: { MESH_REG( kMeshTransferCount0, 0 ) }, // Set low order Transfer Count
118: { MESH_REG( kMeshSequence, kMeshDataInCmd | kMeshSeqDMA )}, // Assume Data-In
119:
120: { RESERVE }, // spare
121: { RESERVE }, // spare
122:
123: /* 0x120 kcclStart - Arbitrate (START CHANNEL PROGRAM HERE): */
124: /* 0x140 kcclBrProblem */
125:
126: { STAGE( kcclStageArb ) },
127: { MESH_REG( kMeshSequence, kMeshArbitrateCmd ) }, // issue Arbitrate
128: { BR_IF_PROBLEM }, // branch if exception or error
129:
130: /* 0x150 - Select with Attention: */
131:
132: { STAGE( kcclStageSelA ) },
133: { CLEAR_CMD_DONE },
134: { MESH_REG( kMeshSequence, kMeshSelectCmd | kMeshSeqAtn ) }, // select with attention
135: { BR_IF_PROBLEM }, // branch if failed
136:
137: /* 0x190 kcclMsgoStage- Message-Out: */
138:
139: { STAGE( kcclStageMsgO ) },
140: { CLEAR_CMD_DONE },
141:
142: /* 0x1B0 kcclMsgoBranch - modify this BRANCH to fall through for multibyte messages: */
143:
144: /**/{ BRANCH( kcclLastMsgo ) }, // kcclMsgoBranch - go do only byte of Msg
145:
146: /* 0x1C0 - do all but last byte of multibyte message: */
147:
148: { MESH_REG( kMeshTransferCount1, 0x00 ) }, // count does include last byte
149: /**/{ MESH_REG( kMeshTransferCount0, 0xFF ) }, // kcclMsgoMTC - modify MESH xfer count here
150: { MESH_REG( kMeshSequence, kMeshMessageOutCmd | kMeshSeqAtn | kMeshSeqDMA ) }, // DMA MsgO with ATN
151: /**/{ MSGO( kcclMSGOdata, 255 ) }, // kcclMsgoDTC - output all but last byte
152: { CLEAR_CMD_DONE },
153:
154: /* 0x210 kcclLastMsgo - wait for REQ signal before dropping ATN: */
155:
156: { MESH_REG( kMeshInterruptMask, 0 ) }, // inhibit MESH interrupt
157: { MESH_REG_WAIT( kMeshSequence, kMeshStatusCmd | kMeshSeqAtn ) }, // gen PhaseMM
158: { CLEAR_INT_REG }, // clear PhaseMM & CmdDone
159: { MESH_REG( kMeshInterruptMask, kMeshIntrException | kMeshIntrError ) }, // re-enable ERR/EXC Ints
160:
161: /* 0x250 - put out the last or only byte of Message-Out phase: */
162:
163: { MESH_REG( kMeshTransferCount1, 0x00 ) },
164: { MESH_REG( kMeshTransferCount0, 0x01 ) },
165: { MESH_REG( kMeshSequence, kMeshMessageOutCmd | kMeshSeqDMA ) },// no more ATN
166: { MSGO( kcclMSGOLast, 1 ) },
167:
168: /* 0x290 kcclCmdoStage - Command Out: */
169:
170: { STAGE( kcclStageCmdO ) },
171: { CLEAR_CMD_DONE },
172: { MESH_REG( kMeshTransferCount1, 0x00 ) },
173: /**/{ MESH_REG( kMeshTransferCount0, 0x06 ) }, // kcclCmdoMTC - Set MESH xfer count to 6
174: { MESH_REG( kMeshSequence, kMeshCommandCmd | kMeshSeqDMA )}, // Command phase with DMA on
175: /**/{ CMDO( 6 ) }, // kcclCmdoDTC - output the CDB
176:
177: /* 0x2F0 - DATA XFER - branch to the built CCL @ 0x05D0: */
178: /* also, kcclReselect - reselect code enters here: */
179:
180: { CLEAR_CMD_DONE },
181: { STAGE( kcclStageXfer ) },
182: { BRANCH( kcclDataXfer ) }, // go do Xfer CCL
183:
184: /* 0x320 kcclOverrun - dump excess data in the bit bucket: */
185: /* Exc and Err are still disabled. */
186:
187: { STAGE( kcclStageBucket ) },
188: { MESH_REG( kMeshTransferCount1, 0x00 ) }, // set MESH Transfer Count to max
189: { MESH_REG( kMeshTransferCount0, 0x00 ) },
190: { CLR_PHASEMM },
191: { MESH_REG( kMeshInterruptMask, kMeshIntrException | kMeshIntrError ) }, // re-enable ERR/EXC Ints
192: /**/{ MESH_REG( kMeshSequence, kMeshDataInCmd | kMeshSeqDMA ) }, // set Seq Reg
193: /**/{ BUCKET }, // OUT/INPUT_LAST the bits
194: { BR_NO_PROBLEM( kcclOverrunDBDMA ) }, // loop til PhaseMismatch
195: { BR_IF_PROBLEM }, // take the interrupt now
196:
197: /* 0x3B0 kcclSyncCleanUp - clean up after Sync xfer: */
198: { CLEAR_INT_REG }, // clear PhaseMM & CmdDone (& Err?)
199: { MESH_REG( kMeshInterruptMask, kMeshIntrException | kMeshIntrError ) }, // re-enable ERR/EXC Ints
200:
201: /* 0x3D0 kcclGetStatus - setup CCL for status, command complete and bus free: */
202:
203: { STAGE( kcclStageStat ) },
204: { MESH_REG( kMeshTransferCount1, 0x00 ) },
205: { MESH_REG( kMeshTransferCount0, 0x01 ) }, // set MESH xfer count to 1
206: { MESH_REG( kMeshSequence, kMeshStatusCmd | kMeshSeqDMA )},// Status-in phase with DMA on
207: { STATUS_IN }, // input the status byte
208:
209: /* 0x420 - Message In: */
210:
211: { STAGE( kcclStageMsgI ) },
212: { CLEAR_CMD_DONE },
213: { MESH_REG( kMeshTransferCount1, 0x00 ) },
214: { MESH_REG( kMeshTransferCount0, 0x01 ) }, // set MESH xfer count to 1
215: { MESH_REG( kMeshSequence, kMeshMessageInCmd | kMeshSeqDMA )}, // Status-in phase with DMA on
216: { MSGI( 1 ) }, // get the Message-In byte
217:
218: /* 0x480 - Bus Free: */
219:
220: { STAGE( kcclStageFree ) },
221: { CLEAR_CMD_DONE },
222: { MESH_REG( kMeshSequence, kMeshEnableReselect ) }, // Enable Reselect
223: { MESH_REG( kMeshSequence, kMeshBusFreeCmd ) }, // Bus Free phase
224: { BR_IF_PROBLEM }, // branch if failed
225:
226: /* 0x4D0 kcclMESHintr - Good completion: */
227:
228: { STAGE( kcclStageGood ) },
229: { MESH_REG( kMeshInterruptMask, kMeshIntrMask ) }, // latch MESH interrupt
230: { STOP( kcclStageStop ) }, // Stop
231:
232: /* The rest of the Channel Program area is used for autosense */
233: /* and data transfer channel commands: */
234: /* kcclSenseBuffer Autosense area */
235: /* kcclDataXfer Start of data transfer channel commands */
236: /* kcclSenseResult Autosense result stored here */
237:
238: }; /* end gDescriptorList structure */
239:
240: const UInt32 gDescriptorListSize = sizeof( gDescriptorList );
241:
242: enum /* values for g.intLevel: */
243: {
244: kLevelISR = 0x80, /* In Interrupt Service Routine */
245: kLevelLocked = 0x40, /* MESH interrupts locked out */
246: kLevelSIH = 0x20, /* In Secondary Interrupt Handler */
247: kLevelLatched = 0x10 /* Interrupt latched */
248: };
249:
250:
251: // IONamedValue scsiChipRegisterStrings[] = { { 0, NULL, } };
252:
253: static int getConfigParam( id configTable, const char *paramName );
254: static unsigned int GetSCSICommandLength( const cdb_t *cdbPtr, unsigned int defaultLength );
255:
256:
257: /* MAX_DMA_XFER is set so that we don't have to worry about the */
258: /* ambiguous "zero" value in the MESH and DBDMA transfer registers */
259: /* that can mean either 65536 bytes or zero bytes. */
260:
261: #define MAX_DMA_XFER 0x0000F000
262:
263: #define ONE_SECOND 1 /* for IOScheduleFunc and serviceTimeoutInterrupt */
264:
265: /* Template for command message sent to the IO thread: */
266:
267: static const msg_header_t cmdMessageTemplate =
268: {
269: 0, /* msg_unused */
270: 1, /* msg_simple */
271: sizeof( msg_header_t ), /* msg_size */
272: MSG_TYPE_NORMAL, /* msg_type */
273: PORT_NULL, /* msg_local_port */
274: PORT_NULL, /* msg_remote_port - filled in */
275: IO_COMMAND_MSG /* msg_id */
276: };
277:
278: /* Template for timeout message. */
279:
280: static const msg_header_t gTimeoutMsgTemplate =
281: {
282: 0, /* msg_unused */
283: 1, /* msg_simple */
284: sizeof( msg_header_t ), /* msg_size */
285: MSG_TYPE_NORMAL, /* msg_type */
286: PORT_NULL, /* msg_local_port */
287: PORT_NULL, /* msg_remote_port - filled in */
288: IO_TIMEOUT_MSG /* msg_id */
289: };
290:
291: static port_t gKernelInterruptPort; /* for int/timeout msgs */
292:
293: static void serviceTimeoutInterrupt( void *arg );
294: static AppleMesh_SCSI *gInstance;
295:
296:
297: #if USE_ELG && !CustomMiniMon
298: void AllocateEventLog( UInt32 size )
299: {
300: if ( !g.evLogBuf ) g.evLogBuf = (UInt8*)kalloc( size );
301: if ( !g.evLogBuf )
302: kprintf( "probe - MESH evLog allocation failed " );
303:
304: g.evLogFlag = 0; /* assume insufficient memory */
305: g.evLogBufp = g.evLogBuf;
306:
307: if ( g.evLogBuf )
308: {
309: g.evLogBufe = g.evLogBufp + kEvLogSize - 0x20; // ??? overran buffer?
310: g.evLogFlag = 0xFEEDBEEF;
311: // g.evLogFlag = 0x0333;
312: }
313: return;
314: }/* end AllocateEventLog */
315:
316:
317: void EvLog( UInt32 a, UInt32 b, UInt32 ascii, char* str )
318: {
319: register UInt32 *lp; /* Long pointer */
320: ns_time_t time;
321:
322: if ( g.evLogFlag == 0 )
323: return;
324:
325: IOGetTimestamp( &time );
326:
327: lp = (UInt32*)g.evLogBufp;
328: g.evLogBufp += 0x10;
329:
330: if ( g.evLogBufp >= g.evLogBufe ) /* handle buffer wrap around if any */
331: { g.evLogBufp = g.evLogBuf;
332: if ( g.evLogFlag != 0xFEEDBEEF ) // make 0xFEEDBEEF a symbolic ???
333: g.evLogFlag = 0; /* stop tracing if wrap undesired */
334: }
335:
336: /* compose interrupt level with 3 byte time stamp: */
337:
338: *lp++ = (g.intLevel << 24) | ((time >> 10) & 0x003FFFFF); // ~ 1 microsec resolution
339: *lp++ = a;
340: *lp++ = b;
341: *lp = ascii;
342:
343: if( g.evLogFlag == 'step' )
344: kprintf( str );
345:
346: return;
347: }/* end EvLog */
348:
349:
350: void Pause( UInt32 a, UInt32 b, UInt32 ascii, char* str )
351: {
352: char work [256 ];
353: char name[] = "AppleMeshSCSI:";
354: char *bp = work;
355: UInt8 x;
356: int i;
357:
358:
359: EvLog( a, b, ascii, str );
360: EvLog( '****', '** P', 'ause', "*** Pause" );
361:
362: bcopy( name, bp, sizeof( name ) );
363: bp += sizeof( name ) - 1;
364:
365: *bp++ = '{'; // prepend p1 in hex:
366: for ( i = 7; i >= 0; --i )
367: {
368: x = a & 0x0F;
369: if ( x < 10 )
370: x += '0';
371: else x += 'A' - 10;
372: bp[ i ] = x;
373: a >>= 4;
374: }
375: bp += 8;
376:
377: *bp++ = ' '; // prepend p2 in hex:
378:
379: for ( i = 7; i >= 0; --i )
380: {
381: x = b & 0x0F;
382: if ( x < 10 )
383: x += '0';
384: else x += 'A' - 10;
385: bp[ i ] = x;
386: b >>= 4;
387: }
388: bp += 8;
389: *bp++ = '}';
390:
391: *bp++ = ' ';
392:
393: for ( i = sizeof( work ) - (int)(bp - work); i && (*bp++ = *str++); --i ) ;
394:
395: kprintf( work );
396: // call_kdp(); // ??? use kdp=3 in boot parameters
397: return;
398: }/* end Pause */
399: #endif /* not CustomMiniMon */
400:
401:
402: /* serviceTimeoutInterrupt - Handle timeouts. */
403: /* This function is invoked in kernel context on a DriverKit thread. */
404: /* Just send a timeout message to the IO thread to wake it up. */
405:
406: static void serviceTimeoutInterrupt( void *arg )
407: {
408: msg_header_t msg = gTimeoutMsgTemplate;
409:
410:
411: ELG( 0, 0, 'Tick', "serviceTimeoutInterrupt\n" );
412:
413: /* roll me another one: */
414: IOScheduleFunc( serviceTimeoutInterrupt, (void*)0x333, ONE_SECOND );
415:
416: /* Tell the IO thread: */
417: msg.msg_remote_port = gKernelInterruptPort;
418: msg_send_from_kernel( &msg, MSG_OPTION_NONE, 0 );
419: return;
420: }/* end serviceTimeoutInterrupt */
421:
422:
423: /* Used in timeoutOccurred to determine if specified cmdBuf has timed out. */
424: /* Returns YES if timeout, else NO. */
425:
426: static Boolean isCmdTimedOut( CommandBuffer *cmdBuf )
427: {
428: IOSCSIRequest *scsiReq = cmdBuf->scsiReq;
429: ns_time_t now, expire;
430: Boolean result;
431:
432:
433: IOGetTimestamp( &now );
434: expire = cmdBuf->startTime +
435: (1000000000ULL * (unsigned long long)scsiReq->timeoutLength);
436: result = (now > expire);
437: if ( result ) ELG( cmdBuf, cmdBuf->scsiReq->timeoutLength, 'Tim-', "isCmdTimedOut" );
438: return result;
439: }/* end isCmdTimedOut */
440:
441:
442: /* Implement the public methods for the MESH controller. */
443:
444: @implementation AppleMesh_SCSI
445:
446: /* Create and initialize one instance of AppleMesh_SCSI. */
447: /* The work is done by architecture- and chip-specific modules. */
448:
449: + (Boolean) probe : deviceDescription
450: {
451: Boolean result;
452:
453:
454: gInstance = [ self alloc ]; /* Instantiate yourself */
455: g.intLevel = 0;
456:
457: MakeTimestampRecord( 512 ); /* conditionally compiled */
458:
459: #if USE_ELG
460: AllocateEventLog( kEvLogSize );
461: ELG( g.evLogBufp, &g.evLogFlag, 'Prob', "probe - event logging set up.\n" );
462: #endif /* USE_ELG */
463:
464: /* Perform device-specific initialization. */
465: /* Free the instance on failure. */
466:
467: if ( [ gInstance InitializeHardware : deviceDescription ] == nil )
468: result = NO;
469: else result = YES;
470:
471: return result;
472: }/* end probe */
473:
474:
475: /* The driver is shutting down. Kill everything worth killing. */
476:
477: - free
478: {
479: CommandBuffer cmdBuf;
480:
481:
482: /* First kill the IO thread if running. */
483:
484: if ( gFlagIOThreadRunning )
485: {
486: cmdBuf.op = kCommandAbortRequest;
487: cmdBuf.scsiReq = NULL;
488: [ self executeCmdBuf : &cmdBuf ];
489: }
490:
491: if ( incomingCmdLock )
492: [ incomingCmdLock free ];
493:
494: dbdma_stop( DBDMA_MESH_SCSI );
495:
496: if ( cclLogAddr )
497: {
498: IOFree( cclLogAddr, cclLogAddrSize );
499: cclLogAddr = NULL;
500: }
501: /* ??? Unmap physical address mapping to registers. */
502:
503: return [ super free ];
504: }/* end free */
505:
506:
507: /* Return required DMA alignment for current architecture. */
508: /* We specify 8-byte alignment to avoid a bug in the Grand Central chip:*/
509: /* if (Reading */
510: /* && (kdbdmaSetFlush || kdbdmaClrRun) */
511: /* && no bytes transferred yet */
512: /* && buffer not 8-byte aligned) */
513: /* { */
514: /* THEN memory in front of buffer will be trashed. */
515: /* } */
516:
517: - (void) getDMAAlignment : (IODMAAlignment*)alignment
518: {
519: alignment->readStart = DBDMA_ReadStartAlignment;
520: alignment->writeStart = DBDMA_WriteStartAlignment;
521: alignment->readLength = 0;
522: alignment->writeLength = 0;
523: return;
524: }/* end getDMAAlignment */
525:
526:
527: /* Statistics support. */
528:
529: - (unsigned int) numQueueSamples
530: {
531: return gTotalCommands;
532: }/* end numQueueSamples */
533:
534:
535: - (unsigned int) sumQueueLengths
536: {
537: return gQueueLenTotal;
538: }/* end sumQueueLengths */
539:
540:
541: - (unsigned int) maxQueueLength
542: {
543: return gMaxQueueLen;
544: }/* end maxQueueLength */
545:
546:
547: - (void) resetStatistics
548: {
549: gMaxQueueLen = 0;
550: gQueueLenTotal = 0;
551: gMaxQueueLen = 0;
552: return;
553: }/* resetStatistics */
554:
555:
556: /* Do a SCSI command, as specified by an IOSCSIRequest. */
557: /* All the work is done by the IO thread. */
558: /* @param scsiReq The request to execute */
559: /* @param buffer The data buffer to transfer to/from, if any */
560: /* @param client The data buffer owner task (for VM munging) */
561: /* */
562: /* This method is called from IOSCSIDevice */
563: - (sc_status_t) executeRequest : (IOSCSIRequest*)scsiReq
564: buffer : (void*)buffer
565: client : (vm_task_t)client
566: {
567: IOMemoryDescriptor *mem = NULL;
568: sc_status_t scsiStatus = SR_IOST_GOOD; /* Fool compiler */
569:
570:
571: ELG( scsiReq->lun<<16 | scsiReq->target, scsiReq, 'sReq', "executeRequest (buffer)" );
572: ELG( buffer, scsiReq->maxTransfer, 'Buff', "executeRequest" );
573:
574: /* Create a simple IO memory descriptor for this client, */
575: /* then toss it to the common method. */
576:
577: if ( buffer )
578: {
579: if ( scsiReq->read && ((UInt32)buffer & (DBDMA_ReadStartAlignment - 1)) )
580: {
581: ELG( scsiReq->maxTransfer, buffer, 'Aln-', "executeRequest/simple buffer - unaligned read buffer." );
582: return SR_IOST_ALIGN;
583: }
584: mem = [ [ IOSimpleMemoryDescriptor alloc ]
585: initWithAddress : (void*)buffer
586: length : scsiReq->maxTransfer ];
587: [ mem setClient : client ];
588: }
589:
590: scsiStatus = [ self executeRequest : scsiReq ioMemoryDescriptor : mem ];
591:
592: if ( mem )
593: [ mem release ];
594:
595: return scsiStatus;
596: }/* end executeRequest buffer */
597:
598:
599: /* Execute a SCSI request using an IOMemoryDescriptor. */
600: /* This allows callers to provide (kernel-resident) logical */
601: /* scatter-gather lists. For compatibility with existing */
602: /* implementations, the low-level SCSI device driver must */
603: /* first ensure that executeRequestWithIOMemoryDescriptor */
604: /* is supported by executing: */
605: /* [ controller respondsToSelector : executeRequestWithIOMemoryDescriptor ] */
606:
607: - (sc_status_t) executeRequest : (IOSCSIRequest*)scsiReq
608: ioMemoryDescriptor : (IOMemoryDescriptor*)ioMemoryDescriptor
609: {
610: CommandBuffer commandBuffer;
611:
612:
613: ELG( scsiReq->lun<<16 | scsiReq->target, scsiReq, 'dReq', "executeRequest (IOMemoryDescriptor)" );
614: ELG( 0, ioMemoryDescriptor, 'iomd', "executeRequest" );
615:
616: scsiReq->driverStatus = SR_IOST_INVALID; /* "In progress" */
617: if ( ioMemoryDescriptor )
618: {
619: [ ioMemoryDescriptor setMaxSegmentCount : MAX_DMA_XFER ];
620: [ ioMemoryDescriptor state : &commandBuffer.savedDataState ];
621: }
622: bzero( &commandBuffer, sizeof( CommandBuffer ) );
623: commandBuffer.op = kCommandExecute;
624: commandBuffer.scsiReq = scsiReq;
625: commandBuffer.mem = ioMemoryDescriptor;
626:
627: [ self executeCmdBuf : &commandBuffer ];
628:
629: #if TIMESTAMP_AT_IOCOMPLETE
630: [ self logTimestamp : "IO complete" ]; /* After RESULT macro */
631: #endif
632:
633: return commandBuffer.scsiReq->driverStatus;
634: }/* end executeRequest IOMemoryDescriptor */
635:
636:
637: /* Reset the SCSI bus. All the work is done by the IO thread. */
638:
639: - (sc_status_t) resetSCSIBus
640: {
641: CommandBuffer commandBuffer;
642:
643:
644: commandBuffer.op = kCommandResetBus;
645: commandBuffer.scsiReq = NULL;
646:
647: [ self executeCmdBuf : &commandBuffer ];
648: return SR_IOST_GOOD; /* can not fail */
649: }/* end resetSCSIBus */
650:
651:
652: /* The following 6 methods, */
653: /* interruptOccurred, interruptOccurredAt, otherOccurred, */
654: /* receiveMsg, timeoutOccurred, commandRequestOccurred, */
655: /* are all called from the IO thread in IODirectDevice. */
656:
657: /* Called from the IO thread when it receives an interrupt message. */
658: /* Currently all work is done by chip-specific module; maybe we should */
659: /* put this method there.... */
660:
661: - (void) interruptOccurred
662: {
663: g.intLevel |= kLevelISR; /* set ISR flag */
664: g.intLevel &= ~kLevelLatched; /* clear latched */
665: ELG( dbdmaAddr->d_status, dbdmaAddr->d_cmdptrlo, 'Int+', "interruptOccurred." );
666: // ELG( *(UInt32*)0xF3000024, *(UInt32*)0xF300002C, 'Int ', "interruptOccurred." );
667:
668: [ self DoHardwareInterrupt ]; /**** HANDLE THE INTERRUPT ****/
669:
670: // ELG( gActiveCommand, *(UInt32*)0xF300002C, 'Intx', "interruptOccurred." );
671:
672: g.intLevel &= ~kLevelISR; /* clear ISR flag */
673: return;
674: }/* end interruptOccurred */
675:
676:
677: /* These three should not occur; they are here as error traps. */
678: /* All three are called out from the IO thread upon receipt of */
679: /* messages which it should not be seeing. */
680:
681: - (void) interruptOccurredAt : (int)localNum
682: {
683: PAUSE( 0, localNum, 'int@', "interruptOccurredAt.\n" );
684: return;
685: }/* end interruptOccurredAt */
686:
687:
688: - (void) otherOccurred : (int)id
689: {
690: PAUSE( 0, id, 'Othr', "otherOccurred.\n" );
691: return;
692: }/* end otherOccurred */
693:
694:
695: - (void) receiveMsg
696: {
697: PAUSE( 0, 0, 'RcvM', "receiveMsg.\n" );
698:
699: /* We have to let IODirectDevice take care of this (i.e., */
700: /* dequeue the bogus message). */
701:
702: [ super receiveMsg ];
703: return;
704: }/* end receiveMsg */
705:
706:
707: /* This method is invoked by DriverKit when it receives a message */
708: /* generated by the function serviceTimeoutInterrupt() which was called */
709: /* by the kernel on some DriverKit thread. */
710:
711: - (void) timeoutOccurred
712: {
713: CommandBuffer *cmdBuf = gActiveCommand;
714: CommandBuffer *nextCmdBuf;
715:
716:
717: if ( g.intLevel & kLevelLatched )
718: {
719: ELG( cmdBuf, 0, 'TocL', "timeoutOccurred - interrupt already latched; do nothing" );
720: return;
721: }
722:
723: g.intLevel |= kLevelISR; /* set IOthread-running-flag */
724: ELG( CCLWord( kcclStageLabel ), dbdmaAddr->d_cmdptrlo, 'Tock', "timeoutOccurred - tick.\n" );
725: [ self GetHBARegsAndClear : FALSE ]; /* get the MESH registers */
726:
727: /* If gActiveCommand timed out: */
728:
729: if ( cmdBuf )
730: { if ( isCmdTimedOut( cmdBuf )
731: && ((CCLWord( kcclStageLabel ) != kcclStageFree)
732: || (CCLWord( kcclStageLabel ) != kcclStageGood) ) )
733: {
734: dbdma_flush( DBDMA_MESH_SCSI ); /* DBDMA may be hung in */
735: dbdma_stop( DBDMA_MESH_SCSI ); /* middle of transfer. */
736: // invalidate_cache_v( (vm_offset_t)cclLogAddr, cclLogAddrSize );
737:
738: cmdBuf->scsiReq->driverStatus = SR_IOST_IOTO;
739: [ self ioComplete : cmdBuf ];
740:
741: [ self AbortActiveCommand ];
742:
743: g.intLevel &= ~kLevelISR; /* clear IOthread-running-flag */
744: return;
745: }
746: }
747: else /* Move any/all timed-out disconnected commands to abortCmdQ: */
748: {
749: cmdBuf = (CommandBuffer*)queue_first( &disconnectedCmdQ );
750: while ( !queue_end( &disconnectedCmdQ, (queue_entry_t)cmdBuf ) )
751: {
752: nextCmdBuf = (CommandBuffer*)queue_next( &cmdBuf->link );
753: if ( isCmdTimedOut( cmdBuf ) )
754: { /* Move cmdBuf from disconnectQ to abortQ: */
755: queue_remove( &disconnectedCmdQ, cmdBuf, CommandBuffer*, link );
756: queue_enter( &abortCmdQ, cmdBuf, CommandBuffer*, link );
757: cmdBuf->scsiReq->driverStatus = SR_IOST_IOTO;
758: }
759: cmdBuf = nextCmdBuf;
760: }/* end WHILE scanning commands in the disconnected queue */
761: [ self AbortDisconnectedCommand ];
762: }
763: g.intLevel &= ~kLevelISR; /* clear IOthread-running-flag */
764: return;
765: }/* end timeoutOccurred */
766:
767:
768: /* Process all commands in incomingCmdQ. At most one of these */
769: /* will become gActiveCommand. The remainder of kCommandExecute commands*/
770: /* go to pendingCmdQ. Other types of commands (such as bus reset) */
771: /* are executed immediately. */
772: /* This method is called from IODirectDevice. */
773: /* */
774: /* Note that we don't have a concept of frozen queue. */
775:
776: - (void) commandRequestOccurred
777: {
778: CommandBuffer *cmdBuf, *pendCmd;
779:
780:
781: [ incomingCmdLock lock ];
782:
783: while ( !queue_empty( &incomingCmdQ ) )
784: {
785: cmdBuf = (CommandBuffer*)queue_first( &incomingCmdQ );
786: queue_remove( &incomingCmdQ, cmdBuf, CommandBuffer*, link );
787: [ incomingCmdLock unlock ];
788: ELG( gActiveCommand, cmdBuf, 'CRO+', "commandRequestOccurred" );
789:
790: switch ( cmdBuf->op )
791: {
792: case kCommandResetBus:
793: /* Note all active and disconnected commands will be terminated.*/
794: [ self threadResetBus : "Reset Command Received" ];
795: [ self ioComplete : cmdBuf ];
796: break;
797:
798: case kCommandAbortRequest:
799: /* 1. Abort all active, pending, and disconnected commands. */
800: /* 2. Notify caller of completion. */
801: /* 3. Self-terminate. */
802:
803: [ self abortAllCommands : SR_IOST_INT ];
804: pendCmd = (CommandBuffer*)queue_first( &pendingCmdQ );
805:
806: while ( !queue_end( &pendingCmdQ, (queue_entry_t)pendCmd ) )
807: {
808: pendCmd->scsiReq->driverStatus = SR_IOST_INT;
809: [ self ioComplete : pendCmd ];
810: pendCmd = (CommandBuffer*)queue_next( &pendCmd->link );
811: }
812:
813: [ cmdBuf->cmdLock lock ];
814: [ cmdBuf->cmdLock unlockWith : CMD_COMPLETE ];
815: IOExitThread();
816: /***** not reached *****/
817:
818: case kCommandExecute:
819: [ self threadExecuteRequest : cmdBuf ];
820: break;
821: }/* end SWITCH */
822:
823: [ incomingCmdLock lock ];
824: }/* end WHILE queue not empty */
825:
826: [ incomingCmdLock unlock ];
827: return;
828: }/* end commandRequestOccurred */
829:
830:
831: /* Power management methods. All we care about is power off, when */
832: /* we must reset the SCSI bus due to the Compaq BIOS's lack of a */
833: /* SCSI reset, which causes a hang if we have set up targets for */
834: /* sync data transfer mode. */
835:
836: - (IOReturn) getPowerState : (PMPowerState*)state_p
837: {
838: return IO_R_UNSUPPORTED;
839: }/* end getPowerState */
840:
841:
842: - (IOReturn) setPowerState : (PMPowerState) state
843: {
844: ELG( 0, state, 'sPwr', "setPowerState.\n" );
845:
846: if ( state == PM_OFF )
847: {
848: // [ self scsiReset ];
849: // ** ** ** TBS: [ self powerDown ];
850: return IO_R_SUCCESS;
851: }
852: return IO_R_UNSUPPORTED;
853: }/* end setPowerState */
854:
855:
856: - (IOReturn) getPowerManagement : (PMPowerManagementState*)state_p
857: {
858: return IO_R_UNSUPPORTED;
859: }/* end getPowerManagement */
860:
861:
862: - (IOReturn) setPowerManagement : (PMPowerManagementState)state
863: {
864: return IO_R_UNSUPPORTED;
865: }/* end setPowerManagement */
866:
867:
868: #if APPLE_MESH_ENABLE_GET_SET
869:
870: - (IOReturn) setIntValues : (unsigned*) parameterArray
871: forParameter : (IOParameterName) parameterName
872: count : (unsigned int) count
873: {
874: int target;
875: PerTargetData *perTargetPtr;
876: IOReturn ioReturn = IO_R_INVALID_ARG;
877:
878:
879: if ( strcmp( parameterName, APPLE_MESH_AUTOSENSE ) == 0 )
880: {
881: if ( count == 1 )
882: {
883: autoSenseEnable = parameterArray[0] ? 1 : 0;
884: ELG( 0, autoSenseEnable, 'sVas', "setIntValues - autoSense\n" );
885: ioReturn = IO_R_SUCCESS;
886: }
887: }
888: else if ( strcmp( parameterName, APPLE_MESH_CMD_QUEUE ) == 0 )
889: {
890: if ( count == 1 )
891: {
892: cmdQueueEnable = parameterArray[0] ? 1 : 0;
893: ELG( 0, cmdQueueEnable, 'sVqe', "setIntValues - cmdQueueEnable\n" );
894: ioReturn = IO_R_SUCCESS;
895: }
896: }
897: else if ( strcmp( parameterName, APPLE_MESH_SYNC ) == 0 )
898: {
899: if ( count == 1 )
900: {
901: syncModeEnable = parameterArray[0] ? 1 : 0;
902: ELG( 0, syncModeEnable, 'sVse', "setIntValues - syncModeEnable\n" );
903: ioReturn = IO_R_SUCCESS;
904: }
905: }
906: else if ( strcmp( parameterName, APPLE_MESH_FAST_SCSI ) == 0 )
907: {
908: if ( count == 1 )
909: {
910: fastModeEnable = parameterArray[0] ? 1 : 0;
911: ELG( 0, fastModeEnable, 'sVfe', "setIntValues - fastModeEnable\n" );
912: ioReturn = IO_R_SUCCESS;
913: }
914: }
915: else if ( strcmp( parameterName, APPLE_MESH_RESET_TARGETS ) == 0 )
916: {
917: if ( count == 0 )
918: {
919: /* Re-enable sync and command queuing. */
920: /* The disable bits persist after a reset. */
921: for ( target = 0; target < SCSI_NTARGETS; target++ )
922: {
923: perTargetPtr = &gPerTargetData[ target ];
924: perTargetPtr->syncDisable = FALSE;
925: perTargetPtr->maxQueue = 0;
926: perTargetPtr->inquiry_7 = 0;
927: }
928: ELG( 0, 0, 'sVrt', "setIntValues - reset targets\n" );
929: ioReturn = IO_R_SUCCESS;
930: }
931: }
932: else if ( strcmp( parameterName, APPLE_MESH_RESET_TIMESTAMP ) == 0 )
933: {
934: ResetTimestampIndex();
935: ioReturn = IO_R_SUCCESS;
936: }
937: else if ( strcmp( parameterName, APPLE_MESH_ENABLE_TIMESTAMP ) == 0 )
938: {
939: EnableTimestamp( TRUE );
940: ioReturn = IO_R_SUCCESS;
941: }
942: else if ( strcmp( parameterName, APPLE_MESH_DISABLE_TIMESTAMP ) == 0 )
943: {
944: EnableTimestamp( FALSE );
945: ioReturn = IO_R_SUCCESS;
946: }
947: else if ( strcmp( parameterName, APPLE_MESH_PRESERVE_FIRST_TIMESTAMP ) == 0 )
948: {
949: PreserveTimestamp( TRUE );
950: ioReturn = IO_R_SUCCESS;
951: }
952: else if ( strcmp( parameterName, APPLE_MESH_PRESERVE_LAST_TIMESTAMP ) == 0 )
953: {
954: PreserveTimestamp( FALSE );
955: ioReturn = IO_R_SUCCESS;
956: }
957: else
958: {
959: ioReturn [ super setIntValues : parameterArray
960: forParameter : parameterName
961: count : count ];
962: }
963: return ioReturn;
964: }/* end setIntValues */
965:
966:
967: - (IOReturn) getIntValues : (unsigned*) parameterArray
968: forParameter : (IOParameterName) parameterName
969: count : (unsigned*) count /* in/out */
970: {
971: IOReturn ioReturn = IO_R_INVALID_ARG;
972:
973:
974: if ( strcmp( parameterName, APPLE_MESH_AUTOSENSE) == 0 )
975: {
976: if ( *count == 1 )
977: {
978: parameterArray[0] = autoSenseEnable;
979: ioReturn = IO_R_SUCCESS;
980: }
981: }
982: else if ( strcmp( parameterName, APPLE_MESH_CMD_QUEUE ) == 0 )
983: {
984: if ( *count == 1 )
985: {
986: parameterArray[0] = cmdQueueEnable;
987: ioReturn = IO_R_SUCCESS;
988: }
989: }
990: else if ( strcmp( parameterName, APPLE_MESH_SYNC ) == 0 )
991: {
992: if ( *count == 1 )
993: {
994: parameterArray[0] = syncModeEnable;
995: ioReturn = IO_R_SUCCESS;
996: }
997: }
998: else if ( strcmp( parameterName, APPLE_MESH_FAST_SCSI ) == 0 )
999: {
1000: if ( *count == 1 )
1001: {
1002: parameterArray[0] = fastModeEnable;
1003: ioReturn = IO_R_SUCCESS;
1004: }
1005: }
1006: else if ( strcmp( parameterName, APPLE_MESH_RESET_TIMESTAMP ) == 0 )
1007: {
1008: ResetTimestampIndex();
1009: ioReturn = IO_R_SUCCESS;
1010: }
1011: else if ( strcmp( parameterName, APPLE_MESH_ENABLE_TIMESTAMP ) == 0 )
1012: {
1013: EnableTimestamp( TRUE );
1014: ioReturn = IO_R_SUCCESS;
1015: }
1016: else if ( strcmp( parameterName, APPLE_MESH_DISABLE_TIMESTAMP ) == 0 )
1017: {
1018: EnableTimestamp( FALSE );
1019: ioReturn = IO_R_SUCCESS;
1020: }
1021: else if ( strcmp( parameterName, APPLE_MESH_PRESERVE_FIRST_TIMESTAMP ) == 0 )
1022: {
1023: PreserveTimestamp( TRUE );
1024: ioReturn = IO_R_SUCCESS;
1025: }
1026: else if ( strcmp( parameterName, APPLE_MESH_PRESERVE_LAST_TIMESTAMP ) == 0 )
1027: {
1028: PreserveTimestamp( FALSE );
1029: ioReturn = IO_R_SUCCESS;
1030: }
1031: else
1032: {
1033: ioReturn = [ super getIntValues : parameterArray
1034: forParameter : parameterName
1035: count : count ];
1036: }
1037: return ioReturn;
1038: }/* end getIntValues */
1039:
1040: #endif APPLE_MESH_ENABLE_GET_SET
1041:
1042: @end /* AppleMesh_SCSI */
1043:
1044:
1045:
1046: @implementation AppleMesh_SCSI( Hardware )
1047:
1048: /* Perform MESH-specific initialization. */
1049: /* Fetch the device's bus address and interrupt port number. */
1050: /* Also, allocate one page of memory for the channel program. */
1051:
1052: - InitializeHardware : deviceDescription
1053: {
1054: IOReturn ioReturn = IO_R_SUCCESS;
1055: id result = self;
1056: kern_return_t kernelReturn;
1057: UInt8 target, lun;
1058: id configTable;
1059: const char *configValue;
1060: UInt8 deviceNumber;
1061: UInt8 functionNumber;
1062: UInt8 busNumber;
1063:
1064:
1065: configTable = [ deviceDescription configTable ];
1066: ASSERT( configTable );
1067: configValue = [ configTable valueForStringKey: "Bus Type" ];
1068:
1069: if ( configValue == NULL || strcmp( configValue, "PPC" ) )
1070: {
1071: PAUSE( 0, 'init', 'Hdw-', "InitializeHardware - bus type NG.\n" );
1072: ioReturn = IO_R_NO_DEVICE;
1073: }
1074:
1075: if ( ioReturn == IO_R_SUCCESS )
1076: {
1077: #if 0 // ** ** ** Need correct definition ** ** **
1078: ioReturn = [ deviceDescription getPCIDevice
1079: : &deviceNumber
1080: function : &functionNumber
1081: bus : &busNumber ];
1082: #else
1083: deviceNumber = 0;
1084: functionNumber = 0;
1085: busNumber = 0;
1086: kernelReturn = 0;
1087: #endif
1088: if ( ioReturn != IO_R_SUCCESS )
1089: PAUSE( 0, ioReturn, 'iHd-', "InitializeHardware - Can't get PCI device information.\n" );
1090: }
1091:
1092: if ( configValue )
1093: {
1094: [ configTable freeString : configValue ];
1095: configValue = NULL;
1096: }
1097:
1098: if ( ioReturn == IO_R_SUCCESS )
1099: ioReturn = [ self AllocHdwAndChanMem : deviceDescription ];
1100:
1101: if ( ioReturn == IO_R_SUCCESS )
1102: {
1103: for ( target = 0; target < SCSI_NTARGETS; target++ )
1104: {
1105: gPerTargetData[ target ].syncParms = kSyncParmsAsync;
1106: gPerTargetData[ target ].negotiateSDTR = kSyncParmsFast; // negotiate Fast
1107: gPerTargetData[ target ].inquiry_7 = 0;
1108: }
1109:
1110: /* All of the addresses are established. */
1111: /* Check that the hardware is present and working. */
1112: ioReturn = [ self DoHBASelfTest ];
1113: }
1114:
1115: if ( ioReturn == IO_R_SUCCESS )
1116: {
1117: /* Tell the superclass to initialize our IO thread. */
1118: /* After this, we should be able to execute SCSI requests. */
1119:
1120: if ( [ super initFromDeviceDescription : deviceDescription ] == NULL )
1121: {
1122: PAUSE( 0, 0, 'i h-', "InitializeHardware - Host Adaptor was not initialized. Fatal.\n" );
1123: ioReturn = IO_R_NO_DEVICE;
1124: }
1125: }
1126:
1127: if ( ioReturn == IO_R_SUCCESS )
1128: {
1129: gFlagIOThreadRunning = 1;
1130:
1131: /* Initialize local variables. Note that activeArray and */
1132: /* perTarget arrays are zeroed by objc runtime. */
1133:
1134: queue_init( &disconnectedCmdQ );
1135: queue_init( &incomingCmdQ );
1136: queue_init( &pendingCmdQ );
1137: queue_init( &abortCmdQ );
1138: incomingCmdLock = [ [ NXLock alloc ] init ];
1139: gActiveCommand = NULL;
1140: [ self resetStatistics ];
1141: gNextQueueTag = QUEUE_TAG_NONTAGGED + 1;
1142: gInitiatorID = kInitiatorIDDefault;
1143: gInitiatorIDMask = 1 << gInitiatorID; /* BusID bitmask for selection. */
1144: gFlagReselecting = FALSE;
1145:
1146: /* Reserve the initiator ID for all LUNs: */
1147:
1148: for ( lun = 0; lun < SCSI_NLUNS; lun++ )
1149: [ self reserveTarget : gInitiatorID lun : lun forOwner : self ];
1150:
1151: /* Get tagged command queueing, sync mode, */
1152: /* fast mode enables from configTable. */
1153:
1154: gOptionCmdQueueEnable = getConfigParam( configTable, CMD_QUEUE_ENABLE );
1155: gOptionSyncModeEnable = getConfigParam( configTable, SYNC_ENABLE );
1156: gOptionFastModeEnable = getConfigParam( configTable, FAST_ENABLE );
1157: gOptionExtendTiming = getConfigParam( configTable, EXTENDED_TIMING );
1158: gOptionAutoSenseEnable = AUTO_SENSE_ENABLE; // from bringup.h
1159:
1160: gOptionCmdQueueEnable = 1; /* Temp for testing??? */
1161:
1162: /* Get internal version of interruptPort; */
1163: /* set the port queue length to the maximum size. */
1164: /* It is not clear if we want to do this. */
1165:
1166: gKernelInterruptPort = IOConvertPort( [ self interruptPort ],
1167: IO_KernelIOTask,
1168: IO_Kernel );
1169: #if 0 /***** Need correct header file *****/
1170: kernelReturn = port_set_backlog( task_self(),
1171: [ self interruptPort ],
1172: PORT_BACKLOG_MAX );
1173: if ( kernelReturn != KERN_SUCCESS )
1174: PAUSE( 0, kernelReturn, 'i H-', "InitializeHardware - warning, port_set_backlog error.\n" );
1175: #endif
1176:
1177: /* Initialize the chip and reset the bus: */
1178:
1179: ioReturn = [ self ResetHardware : TRUE ];
1180: meshAddr->sourceID = gInitiatorID; // mlj ??? fix this
1181: }
1182:
1183: if ( ioReturn == IO_R_SUCCESS )
1184: {
1185: /* OK, we're ready to roll. */
1186:
1187: [ self enableInterrupt : 0 ];
1188: [ self registerDevice ];
1189:
1190: IOScheduleFunc( serviceTimeoutInterrupt, (void*)0x333, ONE_SECOND );
1191: }
1192: else
1193: { /* Do we need to free the locks and similar? */
1194: [ self free ];
1195: result = NULL;
1196: }
1197:
1198: return result;
1199: }/* end InitializeHardware */
1200:
1201:
1202: /* This includes a SCSI reset. */
1203: /* Handling of ioComplete of active and disconnected commands */
1204: /* must be done elsewhere. Returns IO_R_SUCCESS if successful. */
1205: /* This is called from a Task thread. It will disable and */
1206: /* re-enable interrupts. Reason is for error logging. */
1207:
1208: - (IOReturn) ResetHardware : (Boolean)resetSCSIBus
1209: {
1210: ELG( 0, resetSCSIBus, 'RstH', "ResetHardware - Bus Reset.\n" );
1211:
1212: [ self abortAllCommands : SR_IOST_RESET ];
1213: [ self ResetMESH : resetSCSIBus ];
1214:
1215: return IO_R_SUCCESS;
1216: }/* end ResetHardware */
1217:
1218:
1219: /* Start a SCSI transaction for the specified command. */
1220: /* ActiveCmd must be NULL. A return of kHardwareStartRejected */
1221: /* indicates that caller may try again with another command; */
1222: /* kHardwareStartBusy indicates a condition other than */
1223: /* (activeCmd != NULL) which prevents the processing of the command. */
1224:
1225: - (HardwareStartResult) hardwareStart : (CommandBuffer*) cmdBuf
1226: {
1227: IOSCSIRequest *scsiReq;
1228: HardwareStartResult result = kHardwareStartOK;
1229: cdb_t *cdbp;
1230: Boolean okToDisconnect = TRUE;
1231: Boolean okToQueue = gOptionCmdQueueEnable;
1232: UInt8 msgByte;
1233:
1234:
1235: ASSERT( cmdBuf && cmdBuf->scsiReq );
1236:
1237: scsiReq = cmdBuf->scsiReq;
1238: gCurrentTarget = scsiReq->target;
1239: gCurrentLUN = scsiReq->lun;
1240: cdbp = &scsiReq->cdb;
1241: gMsgOutFlag = 0;
1242:
1243: cmdBuf->cdbLength = GetSCSICommandLength( cdbp, scsiReq->cdbLength );
1244: if ( cmdBuf->cdbLength == 0 )
1245: {
1246: /* Failure: we can't determine the length of this command. */
1247:
1248: scsiReq->driverStatus = SR_IOST_CMDREJ;
1249: [ self ioComplete : cmdBuf ];
1250: result = kHardwareStartRejected;
1251: }
1252: { UInt8 *bp = (UInt8*)cdbp;
1253: ELG( ( bp[0]<<24) | (bp[1]<<16) | (bp[2]<<8) | bp[3],
1254: ( bp[4]<<24) | (bp[5]<<16) | (bp[6]<<8) | bp[7],
1255: '=CDB', "hardwareStart - CDB" );
1256: }
1257:
1258: if ( result == kHardwareStartOK )
1259: {
1260: /* Peek at the control byte (the last byte in the command). */
1261:
1262: msgByte = ((UInt8*)cdbp)[ cmdBuf->cdbLength - 1 ];
1263: if ( (msgByte & CTRL_LINKFLAG) != CTRL_NOLINK )
1264: {
1265: /* Failure: we don't support linked commands. */
1266:
1267: scsiReq->driverStatus = SR_IOST_CMDREJ;
1268: [ self ioComplete : cmdBuf ];
1269: result = kHardwareStartRejected;
1270: }
1271: }
1272:
1273: if ( result == kHardwareStartOK )
1274: {
1275: /* Autosense always renegotiates synchronous transfer mode. */
1276: /* This is necessary as the target might have been reset */
1277: /* or hit with a power-cycle. Autosense is never issued */
1278: /* with a queue tag. */
1279:
1280: cmdBuf->queueTag = QUEUE_TAG_NONTAGGED; /* No tag just yet */
1281: if ( cmdBuf->flagIsAutosense )
1282: {
1283: okToDisconnect = FALSE;
1284: gPerTargetData[ gCurrentTarget ].negotiateSDTR = gPerTargetData[ gCurrentTarget ].syncParms;
1285: }
1286: else
1287: {
1288: /* This is a real command. Setup the user data pointers */
1289: /* and counters and build a SCSI request CCL. */
1290: /* First, peek at the command for some special cases. */
1291:
1292: switch ( cdbp->cdb_opcode )
1293: {
1294: case kScsiCmdInquiry:
1295:
1296: /* The first command SCSIDisk sends us is an Inquiry. */
1297: /* This never gets retried, so avoid a possible */
1298: /* reject of a command queue tag. Avoid this hack if */
1299: /* there are any other commands outstanding for this */
1300: /* Target/LUN. */
1301:
1302: if ( gActiveArray[ scsiReq->target ][ scsiReq->lun ] == 0 )
1303: scsiReq->cmdQueueDisable = TRUE;
1304:
1305: okToDisconnect = FALSE; /* no disconnect, no queuing */
1306: break;
1307:
1308: case kScsiCmdRequestSense:
1309: /* Always force sync renegotiation on any Request Sense */
1310: /* to catch independent target power cycles. */
1311: /* (Sync renegotiation needed should be set after all */
1312: /* target-detected errors -- fix needed in MessageIn). */
1313: /* Sense is always issued with disconnect disabled to */
1314: /* maintain T/L/Q nexus. */
1315: /* Watch it: request sense from a client is incompatible*/
1316: /* with tagged queuing. */
1317:
1318: gPerTargetData[ gCurrentTarget ].negotiateSDTR
1319: = gPerTargetData[ gCurrentTarget ].syncParms;
1320: okToDisconnect = FALSE;
1321: break;
1322:
1323: case kScsiCmdTestUnitReady:
1324: case kScsiCmdReadCapacity:
1325: okToDisconnect = FALSE;
1326: break;
1327: }/* end SWITCH on opcode */
1328: }/* end ELSE not auto sense */
1329: }/* end IF kHardwareStartOK */
1330:
1331: okToDisconnect &= scsiReq->disconnect;
1332:
1333: okToQueue &= okToDisconnect
1334: && (scsiReq->cmdQueueDisable == FALSE)
1335: && (gPerTargetData[ scsiReq->target ].inquiry_7 & 0x02);
1336:
1337: cmdBuf->flagActive = 0; /* Initialize flags for this command. */
1338:
1339: /* Make sure that the HBA is stable before we */
1340: /* try to start a request. */
1341:
1342: if ( result == kHardwareStartOK )
1343: {
1344: if ( gActiveCommand )
1345: {
1346: /* This should never happen. It ensures that there are */
1347: /* no race conditions that reselect us between the time */
1348: /* threadExecuteRequest looked at gActiveCommand and */
1349: /* the time we disabled interrupts. */
1350:
1351: queue_enter( &pendingCmdQ, cmdBuf, CommandBuffer*, link );
1352: result = kHardwareStartBusy;
1353: }
1354: }
1355:
1356: if ( result == kHardwareStartOK )
1357: {
1358: /* Activate this command - if we fail later, we'll de-activate it. */
1359:
1360: ASSERT( gActiveCommand == NULL );
1361: [ self activateCommand : cmdBuf ];
1362: ASSERT( scsiReq->target == gCurrentTarget && scsiReq->lun == gCurrentLUN );
1363: [ self ClearCPResults ];
1364:
1365: /* Reset the message-out buffer pointer for the */
1366: /* Identify, SDTR, and queue tag messages. */
1367:
1368: msgOutPtr = (UInt8*)CCLAddress( kcclMSGOdata );
1369: msgByte = kScsiMsgIdentify | scsiReq->lun;
1370:
1371: if ( okToDisconnect )
1372: msgByte |= kScsiMsgEnableDisconnectMask;
1373:
1374: *msgOutPtr++ = msgByte;
1375:
1376: /* According to the SCSI Spec, the tag command */
1377: /* immediately follows the selection. */
1378: /* Note that autosense is never tagged.. */
1379: /* The command was initialized with QUEUE_TAG_NONTAGGED. */
1380: /***** Driver Kit only supports simple queue tags. *****/
1381:
1382: if ( okToQueue )
1383: {
1384: /* Avoid using tag QUEUE_TAG_NONTAGGED (zero). */
1385:
1386: cmdBuf->queueTag = gNextQueueTag;
1387: if ( ++gNextQueueTag == QUEUE_TAG_NONTAGGED )
1388: gNextQueueTag++;
1389: *msgOutPtr++ = kScsiMsgSimpleQueueTag;
1390: *msgOutPtr++ = cmdBuf->queueTag;
1391: gMsgOutFlag |= kFlagMsgOut_Queuing;
1392: }
1393:
1394: /* Do we need to negotiate SDTR for this target? */
1395:
1396: msgByte = gPerTargetData[ scsiReq->target ].negotiateSDTR;
1397: ELG( scsiReq->target << 16 | gPerTargetData[ scsiReq->target ].inquiry_7,
1398: gPerTargetData[ scsiReq->target ].syncParms << 16 | msgByte,
1399: 'SYN?', "Sync" );
1400: if ( !(gPerTargetData[ scsiReq->target ].inquiry_7 & 0x10) )
1401: {
1402: msgByte = 0; /* if Inquiry data doesn't permit Synchronous */
1403: }
1404: if ( msgByte )
1405: {
1406: // gPerTargetData[ scsiReq->target ].negotiateSDTR = 0;
1407: *msgOutPtr++ = kScsiMsgExtended; /* Extended Message */
1408: *msgOutPtr++ = 0x03; /* Message Length */
1409: *msgOutPtr++ = kScsiMsgSyncXferReq;
1410: if ( msgByte == kSyncParmsAsync )
1411: {
1412: *msgOutPtr++ = 200 >> 4; /* Period? used? */
1413: *msgOutPtr++ = 0; /* Offset (async) */
1414: }
1415: else
1416: {
1417: *msgOutPtr++ = 100 >> 2; /* 100 nSec period */
1418: *msgOutPtr++ = msgByte >> 4; /* FIFO size */
1419: }
1420: gMsgOutFlag |= kFlagMsgOut_SDTR;
1421: }/* end IF need to negotiate (a)sync */
1422:
1423: if ( cmdBuf->flagIsAutosense )
1424: {
1425: [ self InitAutosenseCCL ];
1426: }
1427: else
1428: {
1429: cmdBuf->currentDataIndex = 0;
1430: cmdBuf->savedDataIndex = 0;
1431: if ( cmdBuf->mem )
1432: {
1433: [ cmdBuf->mem setPosition : 0 ];
1434: [ cmdBuf->mem state : &cmdBuf->savedDataState ];
1435: }
1436: scsiReq->driverStatus = SR_IOST_INVALID;
1437: scsiReq->totalTime = 0;
1438: scsiReq->latentTime = 0;
1439: [ self UpdateCP : FALSE ]; /* Update the DBDMA Channel Program */
1440: }
1441:
1442: /***** Can a caller override the default timeout? *****/
1443:
1444: meshAddr->selectionTimeOut = gSelectionTimeout;
1445: meshAddr->destinationID = scsiReq->target;
1446: meshAddr->syncParms = gPerTargetData[ scsiReq->target ].syncParms;
1447: SynchronizeIO();
1448: [ self RunDBDMA : kcclStart stageLabel : kcclStageInit ];
1449: IOGetTimestamp( &cmdBuf->startTime );
1450: }
1451: return result;
1452: }/* end hardwareStart */
1453:
1454:
1455: @end /* AppleMesh_SCSI( Hardware ) */
1456:
1457:
1458: /* Obtain a YES/NO type parameter from the config table. */
1459: /* @param configTable The table to examine. */
1460: /* @param paramName The parameter to look for. */
1461: /* @result Zero if missing from the table or the table */
1462: /* value is not YES. One if present in the table and the */
1463: /* table value is YES. */
1464:
1465: static int getConfigParam( id configTable, const char *paramName )
1466: {
1467: const char *value;
1468: int rtn = 0; // default if not present in table
1469:
1470:
1471: value = [ configTable valueForStringKey : paramName ];
1472: if ( value )
1473: {
1474: if ( strcmp( value, "YES" ) == 0 )
1475: rtn = 1;
1476: [ configTable freeString : value ];
1477: }
1478: return rtn;
1479: }/* end getConfigParam */
1480:
1481:
1482: static unsigned int GetSCSICommandLength( const cdb_t *cdbPtr, unsigned int defaultLength )
1483: {
1484: unsigned int result;
1485:
1486: /* Warning: don't use sizeof here - the compiler rounds */
1487: /* the value up to the next word boundary. */
1488:
1489: switch ( ((UInt8*)cdbPtr)[0] & 0xE0 )
1490: {
1491: case (0 << 5): result = 6; break;
1492: case (1 << 5):
1493: case (2 << 5): result = 10; break;
1494: case (5 << 5): result = 12; break;
1495: case (6 << 5): result = (defaultLength != 0) ? defaultLength : 6; break;
1496: case (7 << 5): result = (defaultLength != 0) ? defaultLength : 10; break;
1497: default: result = 0; break;
1498: }
1499: return result;
1500: }/* end GetSCSICommandLength */
1501:
1502:
1503: /* These are the hardware-specific methods that are not */
1504: /* explicitly tied to Mesh and DBDMA. */
1505:
1506: @implementation AppleMesh_SCSI( HardwarePrivate )
1507:
1508: /* Fetch the device's bus address and allocate one page of memory */
1509: /* for the channel command. (Strictly speaking, we don't need an */
1510: /* entire page, but we can use the rest of the page for a permanent */
1511: /* status log). */
1512: /* @param deviceDescription Specify the device to initialize. */
1513: /* @return IO_R_SUCCESS if successful, else an error status. */
1514:
1515: - (IOReturn) AllocHdwAndChanMem : deviceDescription
1516: {
1517: IOReturn ioReturn = IO_R_SUCCESS;
1518: enum
1519: { kMESHRegisterBase = 0,
1520: kDBDMARegisterBase = 1,
1521: kNumberRegisters = 2
1522: };
1523:
1524:
1525: meshAddr = (MeshRegister*)gMESHPhysAddr = 0;
1526: dbdmaAddr = (dbdma_regmap_t*)dbdmaAddrPhys = 0;
1527:
1528: /* Set the default selection timeout to the MESH value (10 msec units). */
1529:
1530: gSelectionTimeout = 250 / 10; // ??? symbolic
1531:
1532: /* Allocate a page of wired-down memory in the kernel. Although */
1533: /* Driver Kit provides a memory allocator, IOMalloc, it does */
1534: /* not guarantee page alignment. Thus, we call the Mach kernel */
1535: /* routine. According to the description of kalloc(), 8192 is */
1536: /* the smallest amount of memory we can allocate. The channel */
1537: /* command area will fit into the start of this area. */
1538:
1539: cclLogAddrSize = page_size;
1540: cclLogAddr = (DBDMADescriptor*)kalloc( cclLogAddrSize );
1541: if ( !cclLogAddr )
1542: { PAUSE( 0, cclLogAddrSize, 'CCA-', "AllocHdwAndChanMem - can't allocate channel command area.\n" );
1543: ioReturn = IO_R_NO_MEMORY;
1544: }
1545:
1546: if ( ioReturn == IO_R_SUCCESS )
1547: {
1548: if ( IOIsAligned( cclLogAddr, page_size ) == 0 )
1549: {
1550: PAUSE( 0, cclLogAddr, 'cca-', "AllocHdwAndChanMem - not page-aligned.\n" );
1551: ioReturn = IO_R_NO_MEMORY;
1552: }
1553: }
1554:
1555: if ( ioReturn == IO_R_SUCCESS )
1556: {
1557: /* Remember the number of DBDMA descriptors that */
1558: /* can be used for data transfer channel commands. */
1559:
1560: gDBDMADescriptorMax = (cclLogAddrSize - kcclDataXfer)
1561: / sizeof( DBDMADescriptor );
1562: #if 0
1563: /* Fetch the logical and physical addresses */
1564: /* to access the MESH and DBDMA hardware. */
1565:
1566: memoryRangeList = [ deviceDescription memoryRangeList ];
1567: numMemoryRanges = [ deviceDescription numMemoryRanges ];
1568: for ( i = 0; i < numMemoryRanges; i++ )
1569: ELG( memoryRangeList[ i ].start, memoryRangeList[ i ].size, 'Rang', "AllocHdwAndChanMem - range start & size.\n" );
1570: if ( numMemoryRanges != kNumberRegisters )
1571: { PAUSE( memoryRangeList[ i ].start, memoryRangeList[ i ].size, 'Rng-', "AllocHdwAndChanMem - numMemoryRanges != kNumberRegisters.\n" );
1572: ioReturn = IO_R_INVALID; /* This "can't happen" */
1573: }
1574: #endif
1575: }
1576:
1577: #if 0
1578: if ( ioReturn == IO_R_SUCCESS )
1579: {
1580: /* We know that the first range describes the MESH chip, */
1581: /* and the second range describes the DBDMA chip. */
1582:
1583: gMESHPhysAddr = (PhysicalAddress)memoryRangeList[ kMESHRegisterBase ].start;
1584: dbdmaAddrPhys = (PhysicalAddress)memoryRangeList[ kDBDMARegisterBase ].start;
1585:
1586: /* Weave together the logical and physical addresses. */
1587: /* First, map the MESH and DBDMA chips into our address space. */
1588:
1589: ioReturn = IOMapPhysicalIntoIOTask( (UInt32)gMESHPhysAddr,
1590: sizeof( MeshRegister ),
1591: (vm_address_t*)&meshAddr );
1592: if ( ioReturn != IO_R_SUCCESS )
1593: PAUSE( 0, ioReturn, 'map-', "AllocHdwAndChanMem - MESH mapping err.\n" );
1594: }
1595:
1596: if ( ioReturn == IO_R_SUCCESS )
1597: {
1598: ioReturn = IOMapPhysicalIntoIOTask( (UInt32)dbdmaAddrPhys,
1599: sizeof( dbdma_regmap_t ),
1600: (vm_address_t*)&dbdmaAddr );
1601: if ( ioReturn != IO_R_SUCCESS )
1602: PAUSE( 0, ioReturn, 'Map-', "AllocHdwAndChanMem - DBDMA mapping err.\n" );
1603: }
1604: #else
1605: if ( ioReturn == IO_R_SUCCESS )
1606: {
1607: meshAddr = (MeshRegister*)gMESHPhysAddr = (PhysicalAddress)PCI_MESH_BASE_PHYS;
1608:
1609: // dbdmaAddr = (dbdma_regmap_t*)PCI_MESH_DMA_BASE_PHYS;
1610: dbdmaAddr = (dbdma_regmap_t*)DBDMA_REGMAP( DBDMA_MESH_SCSI );
1611: // dbdmaAddrPhys = (PhysicalAddress)KVTOPHYS( (vm_offset_t)dbdmaAddr );
1612: dbdmaAddrPhys = (PhysicalAddress)dbdmaAddr;
1613:
1614: ELG( dbdmaAddrPhys, dbdmaAddr, 'DBDM',
1615: "AllocHdwAndChanMem - DBDMA phys/logical addresses." );
1616: g.meshAddr = (UInt32)meshAddr; // for debugging, miniMon ...
1617: #if CustomMiniMon
1618: gMESH_DBDMA = (UInt32)dbdmaAddr;
1619: gMESH_DBDMA_Phys = (UInt32)dbdmaAddrPhys;
1620: #endif /* CustomMiniMon */
1621: }
1622:
1623: #endif
1624:
1625: if ( ioReturn == IO_R_SUCCESS )
1626: {
1627: /* Ensure that the addresses are valid: */
1628:
1629: ASSERT( probe_rb( meshAddr ) == 0 );
1630: ASSERT( probe_rb( dbdmaAddr ) == 0 );
1631:
1632: /* Get the physical address corresponding the DBDMA channel area: */
1633:
1634: ioReturn = IOPhysicalFromVirtual( IOVmTaskSelf(),
1635: (UInt32)cclLogAddr,
1636: (vm_offset_t*)&cclPhysAddr );
1637: g.cclPhysAddr = (UInt32)cclPhysAddr; // for debugging ease
1638: g.cclLogAddr = (UInt32)cclLogAddr;
1639: if ( ioReturn != IO_R_SUCCESS )
1640: PAUSE( 0, ioReturn, 'MAP-', "AllocHdwAndChanMem - DBDMA mapping err.\n" );
1641: }
1642:
1643: if ( ioReturn == IO_R_SUCCESS)
1644: {
1645: ELG( cclPhysAddr, cclLogAddr, '=CCL',
1646: "AllocHdwAndChanMem - CCL phys/logical addresses." );
1647: [ self InitCP ];
1648: }
1649: /* What do we do on failure? Should we try to deallocate */
1650: /* the stuff we created, or will the system do this for us? */
1651:
1652: return ioReturn;
1653: }/* end AllocHdwAndChanMem */
1654:
1655:
1656: /* Perform one-time-only channel command program initialization. */
1657:
1658: - (void) InitCP
1659: {
1660: register DBDMADescriptor *dst = cclLogAddr;
1661: register const DBDMADescriptor *src = gDescriptorList;
1662: UInt32 i;
1663: UInt8 *bp;
1664:
1665:
1666:
1667: /* Set the interrupt, branch, and wait DBDMA registers. */
1668: /* Caution: the following MESH interrupt register bits are */
1669: /* EndianSwapped, reverse polarity and in a different position. */
1670: /* The pattern is: 0xvv00mm00, where mm is a mask byte */
1671: /* and vv is a value byte to match. (After EndianSwapping). */
1672: /* 0x80 means NO errors (kMeshIntrError) */
1673: /* 0x40 means NO exceptions (kMeshIntrException) */
1674: /* 0x20 means NO command done (kMeshIntrCmdDone) */
1675: /* Branch Select is used with BRANCH_FALSE */
1676:
1677: // DBDMASetInterruptSelect( 0x00000000 ); /* Never let DBDMA interrupt */
1678: // DBDMASetWaitSelect( 0x00200020 ); /* Wait until command done */
1679: // DBDMASetBranchSelect( 0x00C000C0 ); /* Branch if exception or error */
1680:
1681: *(volatile UInt32*)&dbdmaAddr->d_intselect = 0x00000000; /* Never let DBDMA interrupt */
1682: *(volatile UInt32*)&dbdmaAddr->d_wait = 0x20002000; /* Wait until command done */
1683: *(volatile UInt32*)&dbdmaAddr->d_branch = 0xC000C000; /* Br if Exc or Err */
1684: SynchronizeIO();
1685:
1686: /* Relocate and EndianSwap the global channel command list */
1687: /* into the page that is shared with the DBDMA device. */
1688:
1689: for ( i = 0; i < gDescriptorListSize; i += sizeof( DBDMADescriptor ) )
1690: {
1691: dst->operation = SWAP( src->operation ); /* copy command with count */
1692:
1693: switch ( src->result & kRelAddress )
1694: {
1695: case kRelAddressMESH:
1696: dst->address = SWAP( src->address + (UInt32)gMESHPhysAddr );
1697: break;
1698: case kRelAddressCP:
1699: dst->address = SWAP( src->address + (UInt32)cclPhysAddr );
1700: break;
1701: case kRelAddressPhys:
1702: dst->address = SWAP( src->address );
1703: break;
1704: default:
1705: dst->address = SWAP( src->address );
1706: break;
1707: }
1708:
1709: switch ( src->result & kRelCmdDep )
1710: {
1711: case kRelCmdDepCP:
1712: dst->cmdDep = SWAP( src->cmdDep + (UInt32)cclPhysAddr );
1713: break;
1714: case kRelCmdDepLabel:
1715: dst->cmdDep = src->cmdDep;
1716: break;
1717: default:
1718: dst->cmdDep = SWAP( src->cmdDep );
1719: break;
1720: }
1721:
1722: dst->result = 0;
1723: src++;
1724: dst++;
1725: } /* FOR all elements in the descriptor list */
1726:
1727: /* Build a SCSI CDB for the autosense Request Sense command. */
1728:
1729: bp = (UInt8*)CCLAddress( kcclSenseCDB );
1730: *bp++ = kScsiCmdRequestSense; /* Command */
1731: *bp++ = 0; /* LUN to be filled in */
1732: *bp++ = 0; /* reserved */
1733: *bp++ = 0; /* reserved */
1734: *bp++ = kMaxAutosenseByteCount; /* Allocation length - to be filled in */
1735: *bp++ = 0; /* Control (flag) */
1736: return;
1737: }/* end InitCP */
1738:
1739:
1740: /* Initialize the data transfer channel command list for a normal SCSI */
1741: /* command. The channel command list has a complex structure of */
1742: /* transfer groups and items, where: */
1743: /* transfer group The number of bytes transferred by a single */
1744: /* MESH operation. This will be from 1 to */
1745: /* kMaxDMATransferLength (65536 - 4096). */
1746: /* transfer item The number of bytes transferred by a single */
1747: /* DBDMA operation. These bytes are guaranteed */
1748: /* to be physically-contiguous. */
1749: /* Thus, the data transfer CCL looks like the following: */
1750: /* Prolog 1: Load MESH with the first group count. */
1751: /* Item 1.1: Load DBDMA with the first physical address and */
1752: /* item count. */
1753: /* Item 1.2 etc: Load DBDMA with the next physical address and */
1754: /* item count. */
1755: /* Prolog 2, etc. Load MESH with the next group count. */
1756: /* Item 2.1, etc. Load DBDMA with the next group of physical */
1757: /* addresses. */
1758: /* Stop/Branch If all of the data transfer commands fit in the */
1759: /* channel command list, branch to the Status phase*/
1760: /* channel command. Otherwise, stop transfer */
1761: /* (which stops in Data phase) and re-build the */
1762: /* command list for the next set of data. */
1763: /* Note that the last DBDMA command must be INPUT_LAST or OUTPUT_LAST */
1764: /* to handle synchronous transfer odd-byte disconnect. */
1765:
1766: - (void) UpdateCP : (Boolean) reselecting
1767: {
1768: CommandBuffer *cmdBuf;
1769: IOSCSIRequest *scsiReq;
1770: DBDMADescriptor *descProto = CCLDescriptor( kcclPrototype );
1771: IOReturn ioReturn = IO_R_SUCCESS;
1772: DBDMADescriptor *descriptorPtr; /* current data descriptor */
1773: DBDMADescriptor *descriptorMax; /* beyond the last data descriptor */
1774: DBDMADescriptor *preamblePtr; /* current prolog descriptor */
1775: UInt32 dbdmaOpProto; /* prototype Opcode for DBDMA */
1776: UInt32 dbdmaOp; /* Opcode for DBDMA */
1777: UInt32 meshSeq; /* Opcode for MESH request */
1778: SInt32 transferLength; /* Number of bytes left to transfer */
1779: UInt32 totalXferLen = 0; /* Total length of this transfer */
1780: UInt32 groupLength; /* Number of bytes in this group */
1781: UInt8 syncParms; /* Fast synchronous param value */
1782: ByteCount bc;
1783: PhysicalRange range;
1784: ItemCount rangeByteCount;
1785: DBDMADescriptor *dp;
1786:
1787:
1788: ASSERT( gActiveCommand && gActiveCommand->scsiReq );
1789: cmdBuf = gActiveCommand;
1790: scsiReq = cmdBuf->scsiReq;
1791: ASSERT( scsiReq->target == gCurrentTarget && scsiReq->lun == gCurrentLUN );
1792:
1793: /* How many descriptors can we store (need some slop for the */
1794: /* terminator commands). Get a pointer to the first free */
1795: /* descriptor and the total number of bytes left to transfer in */
1796: /* this IO request. */
1797:
1798: descriptorPtr = CCLDescriptor( kcclDataXfer );
1799: descriptorMax = &descriptorPtr[ gDBDMADescriptorMax - 16 ];
1800: transferLength = scsiReq->maxTransfer - cmdBuf->currentDataIndex;
1801: ELG( cmdBuf, transferLength, 'UpCP', "UpdateCP" );
1802:
1803: if ( reselecting == FALSE )
1804: {
1805: [ self SetupMsgO ]; /* Setup for Message Out phase. */
1806:
1807: /* Setup for Command phase: */
1808: CCLByte( kcclCmdoMTC ) = cmdBuf->cdbLength; /* MESH transfer count */
1809: CCLByte( kcclCmdoDTC ) = cmdBuf->cdbLength; /* DBDMA count */
1810: bcopy( &scsiReq->cdb, CCLAddress( kcclCMDOdata ), cmdBuf->cdbLength );
1811: }
1812:
1813: /* Generate MESH "sequence" & DBDMA "operation" for Input or Output: */
1814:
1815: if ( scsiReq->read )
1816: { dbdmaOpProto = INPUT_MORE | kBranchIfFalse;
1817: meshSeq = kMeshDataInCmd | kMeshSeqDMA;
1818: }
1819: else
1820: { dbdmaOpProto = OUTPUT_MORE | kBranchIfFalse;
1821: meshSeq = kMeshDataOutCmd | kMeshSeqDMA;
1822: }
1823:
1824: CCLWord( kcclBatchSize ) = 0;
1825:
1826: while ( ioReturn == IO_R_SUCCESS
1827: && transferLength > 0
1828: && descriptorPtr < descriptorMax )
1829: {
1830: /* Do one group, ie, enough CCs to fill a MESH transfer count. */
1831: /* There are more data to be transferred, and CCL space to store*/
1832: /* another group of data. First, leave space for the preamble. */
1833:
1834: preamblePtr = descriptorPtr;
1835: groupLength = 0;
1836: descriptorPtr += 4; /* Preamble takes 4 descriptors */
1837:
1838: while ( transferLength > 0 /* more to xfer */
1839: && descriptorPtr < descriptorMax ) /* room in CCL */
1840: {
1841: /* Do one physically contiguous segment: */
1842:
1843: bc = MAX_DMA_XFER - groupLength; /* calc room left in group */
1844: if ( bc < page_size )
1845: break;
1846: rangeByteCount = [ cmdBuf->mem getPhysicalRanges : (ItemCount) 1
1847: maxByteCount : bc
1848: newPosition : NULL
1849: actualRanges : NULL
1850: physicalRanges : &range ];
1851:
1852: if ( rangeByteCount == 0 )
1853: break;
1854:
1855: ASSERT( range.length > 0 );
1856: groupLength += range.length;
1857: transferLength -= range.length;
1858: dbdmaOp = dbdmaOpProto | range.length;
1859: if ( transferLength <= 0 )
1860: dbdmaOp |= (OUTPUT_MORE ^ OUTPUT_LAST); /* add LAST to cmd */
1861: descriptorPtr->operation = SWAP( dbdmaOp );
1862: descriptorPtr->address = SWAP( (UInt32)range.address );
1863: descriptorPtr->cmdDep = SWAP( (UInt32)cclPhysAddr + kcclProblem );
1864: descriptorPtr->result = 0; // for debugging
1865: descriptorPtr++;
1866: }/* end inner WHILE */
1867:
1868: if ( groupLength == 0 )
1869: {
1870: /* Nothing was built - we apparently failed to get */
1871: /* a physical address. Note: there is a potential problem with */
1872: /* the following sequence as the *previous* DBDMA command, if */
1873: /* any, should be changed to set xxPUT_LAST. */
1874:
1875: ELG( 0, 0, 'Grp-', "UpdateCP - groupLength is 0" );
1876: preamblePtr->operation = SWAP(
1877: NOP_CMD | kBranchIfFalse | kWaitIfTrue );
1878: preamblePtr->address = 0;
1879: preamblePtr->cmdDep = SWAP( (UInt32)cclPhysAddr + kcclProblem );
1880: preamblePtr->result = 0;
1881: descriptorPtr = preamblePtr + 1;
1882: ioReturn = IO_R_INVALID; /* Exit the outer loop */
1883: }
1884: else
1885: {
1886: totalXferLen += groupLength;
1887:
1888: /* This group is complete. Fill in the preamble. */
1889: /* The preamble consists of the following commands: */
1890: /* [0] Move <totalXferLen> to kcclBatchSize */
1891: /* [1] Store group length high-byte in MESH */
1892: /* transfer count 1 register */
1893: /* [2] Store group length low-byte in MESH */
1894: /* transfer count 1 register */
1895: /* [3] Store the input/output command in the MESH */
1896: /* sequence register. */
1897: /* If the command finishes prematurely (perhaps the */
1898: /* device wants to disconnect), the interrupt service */
1899: /* routine will use totalXferLen - the residual byte */
1900: /* count to determine the number of bytes xferred. */
1901:
1902: descProto[0].cmdDep = totalXferLen; // update batch size
1903: descProto[1].cmdDep = SWAP( groupLength >> 8 );
1904: descProto[2].cmdDep = SWAP( groupLength & 0xFF );
1905: descProto[3].cmdDep = SWAP( meshSeq );
1906: bcopy( descProto, preamblePtr, sizeof( DBDMADescriptor ) * 4 );
1907: ELG( preamblePtr, totalXferLen, '=Tot', "UpdateCP - set preamble" );
1908:
1909: /* If there is another group, wait for */
1910: /* cmdDone and clear it: */
1911: if ( transferLength > 0 )
1912: { /* Wait for CmdDone: */
1913: bcopy( CCLDescriptor( kcclBrProblem ), descriptorPtr, sizeof( DBDMADescriptor ) );
1914: ++descriptorPtr;
1915: /* Clear CmdDone: */
1916: /* HACK - if we reached the end of the CCL page, */
1917: /* we don't want to clear cmdDone because we will lose */
1918: /* an interrupt. So, this instruction may be deleted */
1919: /* down below. (Radar 2298440) */
1920: descriptorPtr->operation = SWAP( STORE_QUAD | KEY_SYSTEM | 1 );
1921: descriptorPtr->address = SWAP( (UInt32)gMESHPhysAddr + kMeshInterrupt );
1922: descriptorPtr->cmdDep = SWAP( kMeshIntrCmdDone );
1923: descriptorPtr->result = 0;
1924: ++descriptorPtr;
1925: }/* end IF not last group */
1926: }/* end if/ELSE a group was built */
1927: }/* end outer WHILE */
1928:
1929: /* All of the data have been transferred (or we ran off the end */
1930: /* of the CCL). Update the transfer start index to reflect on */
1931: /* what we *think* we will transfer in this DATA operation. If */
1932: /* we completed DATA phase, branch to the Status Phase CCL; */
1933: /* if not, stop the channel command so we can reload the CCL */
1934: /* with the next big chunk. */
1935: /* When the transfer completes, the last prolog will have stored*/
1936: /* the total number of bytes transferred in a known location in */
1937: /* the CCL area. */
1938: /* Now, append the data transfer postamble to handle */
1939: /* synchronous odd-byte disconnect and jump to status phase */
1940: /* (or just stop if there's more DMA) */
1941:
1942: #define kMaxPostamble 9
1943: #define kDBDMADescriptorEnd (CCLDescriptor(kcclDataXfer) + gDBDMADescriptorMax)
1944:
1945: ASSERT( descriptorPtr + kMaxPostamble < kDBDMADescriptorEnd );
1946:
1947: /* Do some synchronous data transfer cleanup: */
1948:
1949: syncParms = gPerTargetData[ scsiReq->target ].syncParms;
1950: meshAddr->syncParms = syncParms;
1951: SynchronizeIO();
1952: ELG( gMsgOutFlag, syncParms, 'SynP', "UpdateCP - sync parms" );
1953:
1954: if ( ((syncParms & 0xF0) || (gMsgOutFlag & kFlagMsgOut_SDTR)) // Sync?
1955: && (totalXferLen > 0) // any data moving?
1956: && (transferLength == 0) ) // end of xfer?
1957: {
1958: gFlagIncompleteDBDMA = FALSE; /* indicate complete xfer */
1959:
1960: /* MESH has a problem at the end of Synchronous transfers. */
1961: /* If the target is fast enough, it can move from data phase to */
1962: /* Status phase while MESH still has ACKed bytes in its FIFO and */
1963: /* the DBDMA is still running. MESH raises PhaseMismatch Exception */
1964: /* causing an interrupt in which we must empty the FIFO and move */
1965: /* the bytes to the user's buffer by programmed IO. */
1966: /* If the target is not fast enough, we can save the interrupt and */
1967: /* bypass the mess. */
1968: /* So, we do the following: */
1969: /* 1) Enable only MESH Err interrupts; disable Exc and CmdDone. */
1970: /* 2) Don't Wait; Branch if an interrupt may have already occurred.*/
1971: /* 3) Wait for cmdDone at least for TC = FIFO count = 0 and */
1972: /* maybe including PhaseMismatch. Branch to SyncCleanup if PMM. */
1973: /* 4) Assume an interphase condition as opposed to an */
1974: /* overrun condition and Branch Always to get Status. */
1975:
1976: /* If the Channel Program gets this far, the OUTPUT_LAST */
1977: /* has finished writing its data to the FIFO and MESH may still */
1978: /* be putting bytes on the bus OR the INPUT_LAST has read all */
1979: /* its data from the FIFO and MESH has already ACKed them. */
1980: /* There may be or not some time before REQ appears again, */
1981: /* either for data overrun or the next phase. */
1982:
1983: /* Disable Exc and CmdDone (leave Err enabled): */
1984:
1985: descriptorPtr->operation = SWAP( STORE_QUAD | KEY_SYSTEM | 1 );
1986: descriptorPtr->address = SWAP( (UInt32)gMESHPhysAddr + kMeshInterruptMask );
1987: descriptorPtr->cmdDep = SWAP( kMeshIntrError );
1988: descriptorPtr->result = 0;
1989: ++descriptorPtr;
1990:
1991: /* Take the interrupt if PhaseMismatch not definitely caught. */
1992: /* Branch (don't wait for cmdDone) if Exc may have already occurred: */
1993:
1994: descriptorPtr->operation = SWAP( NOP_CMD | kBranchIfFalse );
1995: descriptorPtr->address = 0;
1996: descriptorPtr->cmdDep = SWAP( (UInt32)cclPhysAddr + kcclProblem );
1997: descriptorPtr->result = 0;
1998: /* Radar 2281306 ( and 2272931 ): */
1999: /* Output may completely fit in the FIFO and not make it out */
2000: /* to the SCSI bus if the target disconnects after the command. */
2001: /* If that's possible, wait here for cmdDone and */
2002: /* take the PhaseMismatch interrupt. This situation occurred on a */
2003: /* Mode Select with an output of 12 bytes. Do this to prevent */
2004: /* the Stage from advancing from kcclStageXfer so that proper */
2005: /* cleanup can take place. */
2006: if ( (totalXferLen < 16) && !scsiReq->read )
2007: descriptorPtr->operation= SWAP( NOP_CMD | kWaitIfTrue | kBranchIfFalse );
2008: ++descriptorPtr;
2009:
2010: /* Possible PhaseMisMatch caught after FIFO emptied. */
2011: /* Wait for cmdDone. If Exc, branch to SyncCleanUp: */
2012:
2013: descriptorPtr->operation = SWAP( NOP_CMD | kWaitIfTrue | kBranchIfFalse );
2014: descriptorPtr->address = 0;
2015: descriptorPtr->cmdDep = SWAP( (UInt32)cclPhysAddr + kcclSyncCleanUp );
2016: descriptorPtr->result = 0;
2017: descriptorPtr++;
2018:
2019: /* Interphase condition or possible overrun. */
2020: /* 29sep98 PhaseMismatch occurred even after */
2021: /* CmdDone was set. */
2022:
2023:
2024: /* Branch Always to assume we will bit bucket some data: */
2025:
2026: descriptorPtr->operation = SWAP( NOP_CMD | kBranchAlways );
2027: descriptorPtr->address = 0;
2028: descriptorPtr->cmdDep = SWAP( (UInt32)cclPhysAddr + kcclOverrun );
2029: descriptorPtr->result = 0;
2030: descriptorPtr++;
2031:
2032: /* Fix up the DataOverrun code just in case: */
2033:
2034: dp = CCLDescriptor( kcclOverrunMESH );
2035: if ( scsiReq->read )
2036: { dp->cmdDep = SWAP( kMeshDataInCmd | kMeshSeqDMA );
2037: dp = CCLDescriptor( kcclOverrunDBDMA );
2038: dp->operation = SWAP( INPUT_LAST | kBranchIfFalse | 8 );
2039: }
2040: else
2041: { dp->cmdDep = SWAP( kMeshDataOutCmd | kMeshSeqDMA );
2042: dp = CCLDescriptor( kcclOverrunDBDMA );
2043: dp->operation = SWAP( OUTPUT_LAST | kBranchIfFalse | 8 );
2044: }
2045: }/* end IF last of Synchronous transfer */
2046: else
2047: {
2048: /* Async or incomplete Sync. Append Branches to finish this process: */
2049:
2050: /* If this is a partial transfer, set 'incomplete' flag. */
2051:
2052: if ( transferLength > 0 )
2053: gFlagIncompleteDBDMA = TRUE; /* set incomplete */
2054: else gFlagIncompleteDBDMA = FALSE; /* assume complete xfer */
2055:
2056:
2057: if ( gFlagIncompleteDBDMA )
2058: { /* Delete the ccl to clear cmdDone: */
2059: --descriptorPtr; /* see HACK note above. */
2060: }
2061: else if ( totalXferLen > 0 )
2062: { /* If something moved AND (Radar 2298440) xfer completed, */
2063: /* Wait & Branch if problem: */
2064: /* Radar 2272931 - If entire output fits in FIFO, then */
2065: /* the OUTPUT_LAST completes OK without a PhaseMismatch if */
2066: /* the target disconnects right after the command phase. */
2067: bcopy( CCLDescriptor( kcclBrProblem ), descriptorPtr, sizeof( DBDMADescriptor ) );
2068: descriptorPtr++;
2069: }
2070: /* Assume all's well - Branch to get status: */
2071: descriptorPtr->operation = SWAP( NOP_CMD | kBranchAlways );
2072: descriptorPtr->address = 0;
2073: descriptorPtr->cmdDep = SWAP( (UInt32)cclPhysAddr + kcclGetStatus );
2074: descriptorPtr->result = 0;
2075:
2076: /* If this is a partial transfer, set 'incomplete' flag and */
2077: /* change the Branch from GetStatus to Good: */
2078:
2079: if ( gFlagIncompleteDBDMA )
2080: { /* change last Branch from Status to Good: */
2081: descriptorPtr->cmdDep = SWAP( (UInt32)cclPhysAddr + kcclMESHintr );
2082: ELG( descriptorPtr, transferLength, 'Part', "UpdateCP - built partial CCL." );
2083: }
2084: descriptorPtr++;
2085: }/* end if/ELSE Async or partial xfer */
2086:
2087: ASSERT( descriptorPtr < kDBDMADescriptorEnd );
2088: return;
2089: }/* end UpdateCP */
2090:
2091:
2092: /* StartBucket - Start the channel commands to run the bit bucket. */
2093:
2094: - (void) StartBucket
2095: {
2096: CommandBuffer *cmdBuf;
2097: IOSCSIRequest *scsiReq;
2098: DBDMADescriptor *dp; /* current data descriptor */
2099: UInt32 dbdmaOp; /* Opcode for DBDMA */
2100: UInt32 meshSeq; /* Opcode for MESH request */
2101:
2102:
2103: cmdBuf = gActiveCommand;
2104: scsiReq = cmdBuf->scsiReq;
2105: ELG( cmdBuf, scsiReq, 'Bkt-', "StartBucket" );
2106:
2107: /* Generate MESH "sequence" & DBDMA "operation" for Input or Output: */
2108:
2109: if ( scsiReq->read )
2110: { dbdmaOp = INPUT_MORE | kBranchIfFalse | 8;
2111: meshSeq = kMeshDataInCmd | kMeshSeqDMA;
2112: }
2113: else
2114: { dbdmaOp = OUTPUT_MORE | kBranchIfFalse | 8;
2115: meshSeq = kMeshDataOutCmd | kMeshSeqDMA;
2116: }
2117:
2118: dp = CCLDescriptor( kcclOverrunMESH ); dp->cmdDep = meshSeq;
2119: dp = CCLDescriptor( kcclOverrunDBDMA ); dp->operation = dbdmaOp;
2120:
2121: [ self RunDBDMA : kcclDataXfer stageLabel : kcclStageBucket ];
2122: return;
2123: }/* end StartBucket */
2124:
2125:
2126: /* Set up the channel commands for MsgO phase. */
2127:
2128: - (void) SetupMsgO
2129: {
2130: UInt8 msgoSize;
2131:
2132:
2133: msgOutPtr--; /* treat the last or only byte special (drop ATN) */
2134: msgoSize = msgOutPtr - CCLAddress( kcclMSGOdata );
2135: if( msgoSize == 0 )
2136: { /* Identify byte only: */
2137: CCLWord( kcclMsgoBranch ) = SWAP( NOP_CMD | kBranchAlways );
2138: }
2139: else /* multibyte message - set counts for all but last byte: */
2140: { CCLByte( kcclMsgoMTC ) = msgoSize;
2141: CCLByte( kcclMsgoDTC ) = msgoSize;
2142: /* NOP the BRANCH: */
2143: CCLWord( kcclMsgoBranch ) = SWAP( NOP_CMD );
2144: }
2145: CCLByte( kcclMSGOLast )= *msgOutPtr; /* position last byte */
2146: return;
2147: }/* end SetupMsgO */
2148:
2149:
2150: /* Initialize the autosense area and build the autosense channel command. */
2151:
2152: - (void) InitAutosenseCCL
2153: {
2154: ELG( 0, 0, 'Auto', "InitAutosenseCCL" );
2155: /* Make sure we've allocated enough space in the CCL area. */
2156:
2157: ASSERT( kcclSenseBuffer + kMaxAutosenseByteCount < kcclSenseResult );
2158: bzero( CCLAddress( kcclSenseBuffer ), kMaxAutosenseByteCount );
2159:
2160: /* Copy the Sense CDB to the CDB area and */
2161: /* copy the Sense CCL to the Xfer area */
2162:
2163: /* Copy the Sense CDB & Sense CCL */
2164: bcopy( CCLAddress( kcclSenseCDB ), CCLAddress( kcclCMDOdata ), 6 );
2165: bcopy( CCLAddress( kcclSense ), CCLAddress( kcclDataXfer ), 5 * sizeof( DBDMADescriptor ) );
2166:
2167: /* Set the MESH and DBDMA transfer counts for the command. */
2168: CCLByte( kcclCmdoMTC ) = 6;
2169: CCLByte( kcclCmdoDTC ) = 6;
2170:
2171: /* Set the data transfer count (use a hard-wired value). */
2172:
2173: CCLWord( kcclBatchSize ) = kMaxAutosenseByteCount;
2174:
2175: [ self SetupMsgO ];
2176:
2177: return;
2178: }/* end InitAutosenseCCL */
2179:
2180:
2181: - (void) ClearCPResults
2182: {
2183: register DBDMADescriptor *dp = CCLDescriptor( kcclStart );
2184: register int i;
2185:
2186:
2187: /* Don't clear the reserved areas or prototypes */
2188:
2189: for ( i = (gDescriptorListSize - kcclStart) / sizeof ( DBDMADescriptor ); i; --i )
2190: {
2191: dp->result = 0;
2192: dp++;
2193: }
2194:
2195: return;
2196: }/* end ClearCPResults */
2197:
2198:
2199: @end /* AppleMesh_SCSI(HardwarePrivate) */
2200:
2201:
2202:
2203:
2204: @implementation AppleMesh_SCSI( MeshInterrupt )
2205:
2206:
2207: /* DoHardwareInterrupt - Handle an Interrupt Service message */
2208:
2209: - (void) DoHardwareInterrupt /* called from interruptOccurred */
2210: {
2211: [ self GetHBARegsAndClear : TRUE ]; /* get the MESH registers */
2212: [ self SetIntMask : 0 ]; /* Disable MESH interrupts */
2213:
2214: gFlagReselecting = FALSE;
2215:
2216: if ( g.shadow.mesh.interrupt == 0 )
2217: { /* Interrupts can occur with no bits set in the */
2218: /* interrupt register one way: */
2219: /* - Eating interrupts in the driver (the ASIC */
2220: /* latches the interrupt even though the */
2221: /* driver or Channel Program clears the MESH */
2222: /* interrupt register). */
2223: PAUSE( dbdmaAddr->d_cmdptrlo,
2224: (g.shadow.mesh.busStatus0 << 8) | g.shadow.mesh.busStatus1,
2225: 'ISR?',
2226: "DoHardwareInterrupt - spurious interrupt" );
2227:
2228: if ( !gActiveCommand )
2229: {
2230: [ self selectNextRequest ];
2231: if ( !gActiveCommand && queue_empty( &abortCmdQ ) )
2232: /* if neither new request nor aborting: */
2233: [ self SetIntMask : kMeshIntrMask ];/* Enable interrupts */
2234: }
2235: return;
2236: }/* end IF no bit set in interrupt register */
2237:
2238: dbdma_flush( DBDMA_MESH_SCSI ); /* DBDMA may be hung in */
2239: dbdma_stop( DBDMA_MESH_SCSI ); /* middle of transfer. */
2240: // invalidate_cache_v( (vm_offset_t)cclLogAddr, cclLogAddrSize );
2241:
2242: /* If the DBDMA was running a channel command, handle this */
2243: /* (this could be done at a lower priority level). */
2244:
2245: if ( CCLWord( kcclStageLabel ) )
2246: {
2247: [ self ProcessInterrupt ];
2248: return;
2249: }
2250:
2251: /* This was not a DBDMA completion. */
2252: /* See if the last MESH operation completed */
2253: /* without errors or exceptions. */
2254:
2255: if ( g.shadow.mesh.interrupt == kMeshIntrCmdDone )
2256: {
2257: /* This was presumably a Programmed IO completion. */
2258:
2259: if ( gActiveCommand )
2260: { /* The command has not completed yet. */
2261: /* We need to wait for a phase stabilizing interrupt. */
2262:
2263: PAUSE( 0, 0, 'dhi-', "DoHardwareInterrupt - MESH interrupt problem: need phase stabilizing wait.\n" );
2264: return;
2265: }
2266: else
2267: { /* There is no active command. */
2268: /* This is presumably a bus-free completion. */
2269:
2270: [ self selectNextRequest ]; /* Try to start another request.*/
2271:
2272: if ( !gActiveCommand && queue_empty( &abortCmdQ ) )
2273: /* If still nothing to do: */
2274: [ self SetIntMask : kMeshIntrMask ];/* Re-enable ints */
2275: return;
2276: }
2277: }/* end IF CmdDone without Err or Exc */
2278:
2279: /* None of the above "completion" states occurred. */
2280: /* Either a command completed unsuccessfully, or we */
2281: /* were reselected. First, check for phase mismatch. */
2282: if ( g.shadow.mesh.interrupt == (kMeshIntrCmdDone | kMeshIntrException)
2283: && g.shadow.mesh.exception == kMeshExcPhaseMM )
2284: {
2285: PAUSE( 0, 0, 'DHI-', "DoHardwareInterrupt - MESH interrupt problem: phase mismatch interrupt.\n" );
2286: }
2287: else
2288: { /* Handle reselection and all other problems separately. */
2289: /* (This can be done at a lower priority.) */
2290: [ self ProcessInterrupt ];
2291: }
2292: return;
2293: }/* end DoHardwareInterrupt */
2294:
2295:
2296: /* Respond to a DBDMA channel command completion interrupt */
2297: /* or some error or exception condition. */
2298:
2299: - (void) ProcessInterrupt
2300: {
2301: register CommandBuffer *cmdBuf;
2302: register IOSCSIRequest *scsiReq;
2303: UInt32 stage; /* Stage in the Channel Program */
2304: UInt32 cclIndex; /* Index of CCL descriptor */
2305: UInt32 count; /* transfer count */
2306: UInt8 phase; /* Current bus phase */
2307: IOReturn rc;
2308:
2309:
2310: if ( gActiveCommand == NULL )
2311: {
2312: if ( g.shadow.mesh.exception & kMeshExcResel )
2313: {
2314: [ self HandleReselectionInterrupt ];
2315: }
2316: else
2317: { /* There is no active request and we are not reselecting. */
2318: /* Can get here if Reject/Abort occurs or after a BusFree */
2319: /* command is put in the Sequence register and we exit the */
2320: /* interrupt. */
2321: if ( !queue_empty( &abortCmdQ ) )
2322: {
2323: [ self SetSeqReg : kMeshFlushFIFO ]; /* flush the FIFO */
2324: queue_remove_first( &abortCmdQ, cmdBuf, CommandBuffer*, link );
2325: [ self ioComplete : cmdBuf ];
2326: }/* end IF Aborting disconnected commands */
2327: else
2328: { /* This should be a Bus Free interrupt: */
2329: ELG( 0, 0, 'Int0', "Process interrupt with no active request\n" );
2330: }
2331:
2332: [ self selectNextRequest ];
2333: if ( !gActiveCommand && queue_empty( &abortCmdQ ) )
2334: /* Re-enable ints for reselect */
2335: [ self SetIntMask : (kMeshIntrException | kMeshIntrError) ];
2336: }
2337: return;
2338: }/* end IF had no active command */
2339:
2340: /* There is an active request: */
2341: /* get the stage of the CCL and Switch on it. */
2342: stage = CCLWord( kcclStageLabel );
2343: cmdBuf = gActiveCommand;
2344: scsiReq = cmdBuf->scsiReq;
2345: cclIndex = SWAP( dbdmaAddr->d_cmdptrlo )
2346: - (UInt32) cclPhysAddr;
2347: CCLWord( kcclStageLabel ) = 0;
2348: ASSERT( scsiReq->target == gCurrentTarget && scsiReq->lun == gCurrentLUN );
2349:
2350: /* Analyse where the DBDMA ended up: */
2351:
2352: switch ( stage )
2353: {
2354: case kcclStageGood: /* Normal completion */
2355: [ self DoInterruptStageGood ];
2356: break;
2357:
2358: case kcclStageInit: /* Value before DBDMA runs */
2359: case kcclStageArb: /* Arbitration anomaly */
2360: [ self DoInterruptStageArb ];
2361: break;
2362:
2363: case kcclStageSelA: /* Selection anomaly */
2364: [ self DoInterruptStageSelA ];
2365: break;
2366:
2367: case kcclStageMsgO: /* Message Out */
2368: [ self DoInterruptStageMsgO ];
2369: break;
2370:
2371: case kcclStageCmdO: /* Command stage anomaly */
2372: [ self DoInterruptStageCmdO ];
2373: break;
2374:
2375: case kcclStageXfer:
2376: if ( cmdBuf->flagIsAutosense )
2377: [ self DoInterruptStageXferAutosense ];
2378: else [ self DoInterruptStageXfer ]; /* DMA transfer complete */
2379: break;
2380:
2381: case kcclStageStat: /* Synchronous, odd transfer, data-out */
2382: /* OR no data, disconnect */
2383:
2384: /* Don't use UpdateCurrentIndex here because */
2385: /* kcclStageStat destroys TC with a 1. */
2386: count = CCLWord( kcclBatchSize ); /* Our transfer count */
2387: cmdBuf->currentDataIndex += count; /* Increment data index */
2388: if ( cmdBuf->mem )
2389: [ cmdBuf->mem setPosition : cmdBuf->currentDataIndex ];
2390:
2391: ELG( count, cmdBuf->currentDataIndex, 'Uidx', "ProcessInterrupt" );
2392: CCLWord( kcclBatchSize ) = 0; /* Clear our count */
2393:
2394: /* Analyze the current bus signals: */
2395:
2396: if ( !(g.shadow.mesh.busStatus0 & kMeshReq) )
2397: { /* Get here if Sync Read or Write is too short as */
2398: /* in reading 512 bytes from a 2K block of CD-ROM. */
2399: [ self StartBucket ];
2400: return;
2401: }/* end IF no REQ signal */
2402:
2403: phase = g.shadow.mesh.busStatus0 & kMeshPhaseMask;
2404: switch ( phase )
2405: {
2406: case kBusPhaseMSGI:
2407: rc = [ self DoMessageInPhase ];
2408: // if ( rc == IO_R_SUCCESS && gActiveCommand )
2409: // break; /* msg processed ok & not disconnect */
2410: /* Enable Exc (for Reselect) and Err interrupts (not CmdDone)*/
2411: break;
2412:
2413: case kBusPhaseDATO:
2414: case kBusPhaseDATI:
2415: /* Get here if Async Read or Write is too short as */
2416: /* in reading 512 bytes from a 2K block of CD-ROM */
2417: [ self StartBucket ];
2418: break;
2419:
2420: default:
2421: PAUSE( scsiReq->target, phase, 'pmm-',
2422: "ProcessInterrupt - expected Status phase.\n" );
2423: break;
2424: }/* end SWITCH on phase */
2425: break;
2426:
2427: case kcclStageBucket:
2428: count = CCLWord( kcclBatchSize ); /* Our transfer count */
2429: cmdBuf->currentDataIndex += count; /* Increment data index */
2430: if ( cmdBuf->mem )
2431: [ cmdBuf->mem setPosition : cmdBuf->currentDataIndex ];
2432: CCLWord( kcclBatchSize ) = 0; /* Clear our count */
2433:
2434: ELG( count, cmdBuf->currentDataIndex, 'Buck', "ProcessInterrupt - bit bucket done.\n" );
2435:
2436: // scsiReq->driverStatus = SR_IOST_DMAOR; /* set DMA OverRun error */
2437:
2438: [ self SetSeqReg : kMeshFlushFIFO ]; /* flush the FIFO */
2439: [ self RunDBDMA : kcclGetStatus stageLabel : kcclStageStat ];
2440: break;
2441:
2442: case kcclStageMsgI: /* Message-in: */
2443: case kcclStageFree: /* Bus free: */
2444: default: /* Can't happen? */
2445: PAUSE( cclIndex, stage, 'P i-', "ProcessInterrupt - strange or unknown interrupt for device.\n" );
2446: break;
2447: }/* end SWITCH on Channel Program stage */
2448: return;
2449: }/* end ProcessInterrupt */
2450:
2451:
2452: /* The channel command (and, hence, the IO request) ran to */
2453: /* completion without problems. Complete this IO request */
2454: /* and try to start another. */
2455:
2456: - (void) DoInterruptStageGood
2457: {
2458: register CommandBuffer *cmdBuf;
2459: register IOSCSIRequest *scsiReq;
2460: UInt32 totalXferLen;
2461: IOMemoryDescriptorState state;
2462: UInt8 byte;
2463:
2464:
2465: ASSERT( gActiveCmd && gActiveCmd->scsiReq );
2466:
2467: // [ self SetSeqReg : kMeshEnableReselect ]; // done by CCL
2468:
2469: cmdBuf = gActiveCommand;
2470: scsiReq = cmdBuf->scsiReq;
2471:
2472: /* Retrieve the total number of bytes transferred */
2473: /* in the last data phase. */
2474:
2475: cmdBuf->flagRequestSelectOK = FALSE;
2476: totalXferLen = CCLWord( kcclBatchSize );
2477: CCLWord( kcclBatchSize ) = 0;
2478:
2479: ELG( scsiReq, totalXferLen, 'Good', "DoInterruptStageGood" );
2480:
2481: if ( cmdBuf->flagIsAutosense )
2482: {
2483: /* We are completing an autosense command. */
2484: /* Copy the status byte (which had better be */
2485: /* "good" ) from the CCL to the autosense status*/
2486: /* and complete the IO request. The autosense */
2487: /* data itself was copied into the user buffer */
2488: /* by a previous 'Xfer' interrupt. */
2489:
2490: cmdBuf->autosenseStatus = CCLByte( kcclStatusData );
2491: [ self deactivateCmd : cmdBuf ];
2492: [ self ioComplete : cmdBuf ];
2493: }
2494: else
2495: { /* We are completing a normal command. */
2496: /* Update the transfer count and current data pointer. */
2497:
2498: cmdBuf->currentDataIndex += totalXferLen;
2499: if ( cmdBuf->mem )
2500: [ cmdBuf->mem setPosition : cmdBuf->currentDataIndex ];
2501:
2502: if ( gFlagIncompleteDBDMA == FALSE )
2503: {
2504: /* Yes, the IO is really complete: */
2505:
2506: scsiReq->scsiStatus = CCLByte( kcclStatusData );
2507: scsiReq->driverStatus = SR_IOST_GOOD;
2508:
2509: /* If this was an Inquiry, peek at the data */
2510: /* for Synchronous and Queuing support: */
2511:
2512: if ( (*(UInt8*)&scsiReq->cdb == kScsiCmdInquiry)
2513: && (cmdBuf->currentDataIndex > 7) )
2514: {
2515: [ cmdBuf->mem state : &state ]; /* save context */
2516: [ cmdBuf->mem setPosition : 7 ];
2517: if ( [ cmdBuf->mem readFromClient : &byte count : 1 ] == 1 )
2518: {
2519: gPerTargetData[ scsiReq->target ].inquiry_7 = byte;
2520: ELG( scsiReq->target, byte, 'Inq+',
2521: "DoInterruptStageGood - peek at Inquiry data" );
2522: }
2523: [ cmdBuf->mem setState : &state ]; /* restore context */
2524: }
2525: [ self deactivateCmd : cmdBuf ];
2526: [ self ioComplete : cmdBuf ];
2527: }
2528: else
2529: { /* The CCL ended, but the caller expected more data. */
2530: /* Restart the CCL. */
2531: /* Don't regenerate arbitration or command stuff. */
2532:
2533: [ self UpdateCP : TRUE ];
2534: [ self RunDBDMA : kcclDataXfer stageLabel : kcclStageXfer ];
2535: return;
2536: }/* end ELSE need to continue Channel Program */
2537: }/* end ELSE not AutoSense */
2538:
2539: /* Since IO completed (otherwise, we would have exited in the */
2540: /* "return" above), check whether a reselection attempt */
2541: /* is piggy-backed on top of the good DBDMA completion. */
2542:
2543: if ( g.shadow.mesh.exception & kMeshExcResel )
2544: [ self HandleReselectionInterrupt ];
2545: else /* Nothing happening. Try to start another request. */
2546: {
2547: [ self selectNextRequest ];
2548: if ( !gActiveCommand && queue_empty( &abortCmdQ ) )
2549: /* Re-enable ints for reselect */
2550: [ self SetIntMask : (kMeshIntrException | kMeshIntrError) ];
2551: }
2552:
2553: return;
2554: }/* end DoInterruptStageGood */
2555:
2556:
2557: /* Process the autosense data transfer phase. IO is not complete. */
2558: /* There are several reasons why we might get here: */
2559: /* -- autosense completion (which could be a separate stage) */
2560: /* -- DMA completion with more DMA to do */
2561: /* -- Bus phase mismatch (short transfer or disconnect) */
2562:
2563: - (void) DoInterruptStageXferAutosense
2564: {
2565: register CommandBuffer *cmdBuf = gActiveCommand;
2566: IOSCSIRequest *scsiReq = cmdBuf->scsiReq;
2567: UInt32 residual;
2568: UInt32 count;
2569:
2570:
2571: cmdBuf->flagRequestSelectOK = FALSE;
2572:
2573: /* An autosense Data In transfer is complete. Copy the */
2574: /* autosense data from our private buffer to the */
2575: /* caller's sense_data area and restart IO to get the */
2576: /* status and command-complete message byte. */
2577:
2578: residual = SWAP( CCLWord( kcclSenseResult ) ) & 0xFF;
2579: count = kMaxAutosenseByteCount - residual;
2580: ASSERT( count <= sizeof( esense_reply_t ) );
2581: bcopy( CCLAddress( kcclSenseBuffer ), &scsiReq->senseData, count );
2582:
2583: /* Driver Kit does not return "sense valid" or */
2584: /* the actual sense transfer count. */
2585: /* Restart the channel command to fetch the */
2586: /* status byte and Command Completion byte. */
2587:
2588: [ self RunDBDMA : kcclGetStatus stageLabel : kcclStageStat ];
2589: return;
2590: }/* end DoInterruptStageXferAutosense */
2591:
2592:
2593: /* Process a normal data phase interrupt. IO is not complete. */
2594: /* There are several reasons why we might get here: */
2595: /* -- autosense completion (which could be a separate stage) */
2596: /* -- DMA completion with more DMA to do */
2597: /* -- Bus phase mismatch (short transfer or disconnect, MsgIn) */
2598: /* Note that we know that we are not in autosense. */
2599:
2600: - (void) DoInterruptStageXfer
2601: {
2602: register CommandBuffer *cmdBuf = gActiveCommand;
2603: UInt32 count; /* DMA transfer count */
2604: UInt8 phase; /* Current bus phase */
2605: IOReturn rc;
2606: int goAround;
2607:
2608:
2609: cmdBuf->flagRequestSelectOK = FALSE;
2610: count = cmdBuf->currentDataIndex;
2611:
2612: [ self UpdateCurrentIndex ];
2613:
2614: do
2615: { goAround = FALSE; /* assume loop not repeated */
2616: [ self SetSeqReg : kMeshFlushFIFO ];
2617:
2618: /* We've cleaned up the mess from the previous data transfer. */
2619: /* Look at the current bus phase. The channel command waited */
2620: /* for REQ to be set before interrupting the processor. */
2621:
2622: phase = g.shadow.mesh.busStatus0 & kMeshPhaseMask;
2623: ASSERT( g.shadow.mesh.busStatus0 & kMeshReq ); /* REQ is set, right? */
2624:
2625: switch ( phase )
2626: {
2627: case kBusPhaseSTS:
2628: gFlagIncompleteDBDMA = FALSE; /* indicate no-more-data */
2629: [ self RunDBDMA : kcclGetStatus stageLabel : kcclStageStat ];
2630: break;
2631:
2632: case kBusPhaseMSGI:
2633: rc = [ self DoMessageInPhase ];
2634: if ( rc == IO_R_SUCCESS && gActiveCommand )
2635: goAround = TRUE; /* msg ok & not disconnect */
2636: break;
2637:
2638: case kBusPhaseDATO:
2639: case kBusPhaseDATI:
2640: if ( count != cmdBuf->currentDataIndex )
2641: { /* Data phase had already started: */
2642: PAUSE( 0, phase, 'dat-', "DoInterruptStageXfer - unexpected Data phase.\n" );
2643: }
2644: else
2645: { /* try starting data phase again */
2646: [ self RunDBDMA : kcclDataXfer stageLabel : kcclStageXfer ];
2647: }
2648: break;
2649:
2650: default:
2651: PAUSE( cmdBuf->scsiReq->target, phase, 'Phs-', "DoInterruptStageXfer - bogus phase.\n" );
2652: break;
2653: }/* end SWITCH on phase */
2654: } while ( goAround );
2655: return;
2656: }/* end DoInterruptStageXfer */
2657:
2658:
2659: /* DoInterruptStageArb - Process an anomaly during arbitration. */
2660:
2661: - (void) DoInterruptStageArb
2662: {
2663: ASSERT( gActiveCommand );
2664: ELG( 0, 0, 'Arb-', "DoInterruptStageArb - Lost arbitration.\n" );
2665:
2666: [ self pushbackCurrentRequest : gActiveCommand ];
2667: ASSERT( gActiveCommand == NULL );
2668:
2669: if ( g.shadow.mesh.exception & kMeshExcResel )
2670: { if ( g.shadow.mesh.error & kMeshErrDisconnected )
2671: {
2672: /* 18sep98 - Sometimes MESH gets real confused when its */
2673: /* arbitration loses to a target's reselect arbitration. */
2674: /* The registers show Exc:ArbLost, Resel and Err:UnExpDisc. */
2675: /* The FIFO count is 1 (should be SCSI ID bits) while the */
2676: /* BusStatus0,1 registers show IO and Sel both of which are */
2677: /* set by the reselecting Target. */
2678: /* The SCSI bus anaylzer shows the following events occcurring */
2679: /* within a few microseconds of BSY being set by the target: */
2680: /* bus free for at least hundreds of microseconds */
2681: /* Target raises BSY along with its ID bit */
2682: /* Target raises SEL */
2683: /* Target raises IO to indicate reselection */
2684: /* Target adds MESH's ID bit */
2685: /* Target drops BSY */
2686: /* MESH raises BSY to accept reselection */
2687: /* **** MESH drops BSY **** here is where MESH is confused */
2688: /* Target stays on bus for 250 milliseconds. */
2689: /* To solve this problem, whack MESH with a RstMESH. */
2690:
2691: ELG( ' Rst', 'MESH', 'UEP-', "DoInterruptStageArb - Resel/Unexpected Disconnect.\n" );
2692: [ self SetSeqReg : kMeshResetMESH ]; /* completes quickly */
2693: [ self GetHBARegsAndClear : TRUE ]; /* clear cmdDone */
2694: [ self SetSeqReg : kMeshEnableReselect ];
2695: [ self SetIntMask : kMeshIntrMask ]; /* Enable Interrupts */
2696: return; /* now wait for another reselect interrupt */
2697: }
2698: [ self HandleReselectionInterrupt ];
2699: }
2700: else
2701: { /* 22sep97 - lost arbitration without reselection. */
2702: /* Probably lost the reselect condition processing an */
2703: /* error or something. */
2704: ELG( 0, 0, 'ARB-', "DoInterruptStageArb - Lost arbitration without reselect.\n" );
2705: }
2706: return;
2707: }/* end DoInterruptStageArb */
2708:
2709:
2710: /* Process an anomaly during target selection. */
2711:
2712: - (void) DoInterruptStageSelA
2713: {
2714: ASSERT( gActiveCommand );
2715: [ self SetSeqReg : kMeshEnableReselect ];
2716: [ self SetSeqReg : kMeshBusFreeCmd ]; /* clear ATN signal MESH left on */
2717: [ self killCurrentRequest ];
2718: [ self GetHBARegsAndClear : FALSE ]; /* check MESH registers */
2719: [ self SetIntMask : kMeshIntrMask ]; /* Enable Interrupts */
2720: return;
2721: }/* end DoInterruptStageSelA */
2722:
2723:
2724: /* Process an anomaly during Message-Out phase. */
2725: /* Target probably doing Message Reject (0x07). */
2726:
2727: - (void) DoInterruptStageMsgO
2728: {
2729: UInt8 phase;
2730: IOReturn rc;
2731:
2732:
2733: ASSERT( gActiveCommand );
2734:
2735: phase = g.shadow.mesh.busStatus0 & kMeshPhaseMask; /* phase me */
2736: PAUSE( gActiveCommand, phase, 'Mgo-',
2737: "DoInterruptStageMsgO - error during msg-out phase.\n" );
2738:
2739: switch ( phase )
2740: {
2741: case kBusPhaseMSGI:
2742: rc = [ self DoMessageInPhase ];
2743: if ( rc != IO_R_SUCCESS )
2744: {
2745: PAUSE( 0, rc, ' MI-',
2746: "DoInterruptStageMsgO - MsgIn during MsgOut phase.\n" );
2747: // ??? need to get to bus-free from here
2748: // ??? need to blow off the IO
2749: }
2750: else
2751: { ELG( 0, gMsgInFlag, 'rej?', "DoInterruptStageMsgO - got MsgIn.\n" );
2752: if ( gMsgInFlag & kFlagMsgIn_Reject )
2753: [ self AbortActiveCommand ];
2754: }
2755: break;
2756:
2757: default:
2758: PAUSE( gMsgInFlag, phase, 'mgo-',
2759: "DoInterruptStageMsgO - unknown phase during MsgOut phase.\n" );
2760: break;
2761: }
2762: return;
2763: }/* end DoInterruptStageMsgO */
2764:
2765:
2766: /* DoInterruptStageCmdO - Process an anomaly during command stage. */
2767:
2768: - (void) DoInterruptStageCmdO
2769: {
2770: register CommandBuffer *cmdBuf;
2771: UInt8 phase;
2772: IOReturn rc;
2773:
2774:
2775: /* See if this is part of the normal AbortTag/BusDeviceReset process: */
2776:
2777:
2778: if ( !queue_empty( &abortCmdQ ) )
2779: {
2780: [ self SetSeqReg : kMeshFlushFIFO ]; /* flush the FIFO */
2781: cmdBuf = (CommandBuffer*)queue_first( &abortCmdQ );
2782: ELG( cmdBuf, 0, 'Abo-', "DoInterruptStageCmdO - Aborting." );
2783: queue_remove( &abortCmdQ, cmdBuf, CommandBuffer*, link );
2784: [ self ioComplete : cmdBuf ];
2785: [ self AbortDisconnectedCommand ]; /* do the next, if any */
2786: return;
2787: }
2788:
2789: /* Not aborting - something bad happened: */
2790:
2791: ASSERT( gActiveCommand );
2792: cmdBuf = gActiveCommand;
2793: cmdBuf->flagRequestSelectOK = FALSE;
2794: phase = g.shadow.mesh.busStatus0 & kMeshPhaseMask; /* phase me */
2795: ELG( cmdBuf, phase, 'CMD?', "DoInterruptStageCmdO - anomaly during Cmd phase.\n" );
2796:
2797: if ( phase == kBusPhaseMSGI )
2798: { /* We are probably negotiating SDTR or */
2799: /* getting rejected on a nonzero LUN. */
2800: rc = [ self DoMessageInPhase ];
2801: if ( rc != IO_R_SUCCESS )
2802: {
2803: PAUSE( 0, rc, ' mi-',
2804: "DoInterruptStageCmdO - MsgIn during Cmd phase.\n" );
2805: }
2806: else
2807: { /* Message processed - where do we go from here? */
2808:
2809: if ( !gActiveCommand ) /* if Rejected, */
2810: return; /* return */
2811:
2812: phase = g.shadow.mesh.busStatus0 & kMeshPhaseMask;
2813: switch ( phase )
2814: {
2815: case kBusPhaseSTS:
2816: [ self RunDBDMA : kcclCmdoStage stageLabel : kcclStageInit ];
2817: break;
2818:
2819: case kBusPhaseMSGO:
2820: msgOutPtr = (UInt8*)CCLAddress( kcclMSGOdata );
2821: [ self SetupMsgO ];
2822: [ self RunDBDMA : kcclMsgoStage stageLabel : kcclStageInit ];
2823: break;
2824:
2825: case kBusPhaseCMD:
2826: [ self RunDBDMA : kcclCmdoStage stageLabel : kcclStageInit ];
2827: break;
2828: }
2829: }
2830: }
2831: else if ( phase == kBusPhaseSTS ) /* Probably Check Condition */
2832: { /* Perhaps block # invalid */
2833: gFlagIncompleteDBDMA = FALSE; /* indicate no-more-data */
2834: [ self RunDBDMA : kcclGetStatus stageLabel : kcclStageStat ];
2835: }
2836: else
2837: {
2838: PAUSE( 0, phase, 'Phs?', "DoInterruptStageCmdO - error during Command phase.\n" );
2839: }
2840: return;
2841: }/* end DoInterruptStageCmdO */
2842:
2843:
2844: /* We are in MSGI phase. Read the bytes. Return TRUE if an entire */
2845: /* message was read (we may still be in MSGI phase). Note that this */
2846: /* is done by programmed IO, which will fail (logging the error) if */
2847: /* the target sets MSGI but does not send us a message quickly enough. */
2848: /* This method is called from the normal data transfer interrupt when */
2849: /* the target enters message in phase, and from the reselection */
2850: /* interrupt handler when we read a valid reselection target ID. */
2851: /* Note that MESH interrupts are disabled on exit. */
2852:
2853: - (IOReturn) DoMessageInPhase
2854: {
2855: register UInt8 messageByte;
2856: UInt32 index = 0;
2857: IOReturn ioReturn = IO_R_SUCCESS;
2858:
2859:
2860: /* We do not necessarily have a valid command in this method. */
2861: /* While we're processing Message-In bytes, we don't want any */
2862: /* MESH hardware interrupts. */
2863:
2864: [ self SetIntMask : 0 ]; /* no MESH interrupt latching */
2865: [ self SetSeqReg : kMeshFlushFIFO ]; /* Flush the FIFO */
2866:
2867: gMsgInCount = 0;
2868: gMsgInState = kMsgInInit;
2869:
2870: while ( gMsgInState != kMsgInReady /* Disconnect makes gActiveCommand */
2871: && ioReturn == IO_R_SUCCESS ) /* go away */
2872: {
2873: meshAddr->transferCount1 = 0;
2874: meshAddr->transferCount0 = 1; /* get single byte */
2875: [ self SetSeqReg : kMeshMessageInCmd ]; /* issue MsgIn */
2876:
2877: ioReturn = [ self WaitForMesh : TRUE ]; /* wait for cmdDone */
2878: if ( ioReturn != IO_R_SUCCESS )
2879: {
2880: PAUSE( gCurrentTarget, ioReturn, 'Mgi-', "DoMessageInPhase - Target hung: message in timeout.\n" );
2881: break; /* Bus reset here? */
2882: }
2883:
2884: if ( (g.shadow.mesh.exception & kMeshExcPhaseMM)
2885: || (g.shadow.mesh.busStatus0 & kMeshPhaseMask) != kBusPhaseMSGI )
2886: {
2887: break; /* exit loop if no longer in Msg-In phase */
2888: }
2889:
2890: if ( g.shadow.mesh.FIFOCount == 0 )
2891: {
2892: PAUSE( gCurrentTarget, 0, 'mgi-', "DoMessageInPhase - no message byte.\n" );
2893: break;
2894: }
2895:
2896: messageByte = meshAddr->xFIFO;
2897:
2898: ASSERT( index < 256 );
2899: gMsgInBuffer[ index++ ] = messageByte;
2900:
2901: switch ( gMsgInState )
2902: {
2903: case kMsgInInit:
2904: /* This is the first message byte. Check for 1-byte codes. */
2905: if ( messageByte == kScsiMsgCmdComplete
2906: || (messageByte >= kScsiMsgOneByteMin && messageByte <= kScsiMsgOneByteMax)
2907: || messageByte >= kScsiMsgIdentify )
2908: {
2909: gMsgInState = kMsgInReady;
2910: }
2911: else if ( messageByte >= kScsiMsgTwoByteMin
2912: && messageByte <= kScsiMsgTwoByteMax )
2913: {
2914: /* This is a two-byte message. */
2915: /* Set the count and read the next byte. */
2916:
2917: gMsgInState = kMsgInReading; /* Need one more */
2918: gMsgInCount = 1;
2919: }
2920: else
2921: { /* This is an extended message. */
2922: /* The next byte has the count. */
2923: gMsgInState = kMsgInCounting;
2924: }
2925: break;
2926:
2927: case kMsgInCounting: /* Count byte of multi-byte message: */
2928: gMsgInCount = messageByte;
2929: gMsgInState = kMsgInReading;
2930: break;
2931:
2932: case kMsgInReading: /* Body of multi-byte message: */
2933: if ( --gMsgInCount <= 0 )
2934: gMsgInState = kMsgInReady;
2935: break;
2936:
2937: default:
2938: ASSERT( gMsgInState ); /* Bogus state */
2939: PAUSE( 0, 0, 'Msg-', "DoMessageInPhase - Bogus MSGI state!\n" );
2940: gMsgInState = kMsgInReady;
2941: break;
2942: }/* end SWITCH on MSGI state */
2943:
2944: if ( gMsgInState == kMsgInReady )
2945: {
2946: [ self ProcessMSGI ];
2947: gMsgInState = kMsgInInit;
2948: index = 0;
2949: if ( gMsgInBuffer[0] == kScsiMsgDisconnect )
2950: ioReturn = IO_R_IO; /* break out of WHILE loop */
2951:
2952: if ( gMsgInFlag & kFlagMsgIn_Reject )
2953: {
2954: [ self AbortActiveCommand ];
2955: break;
2956: }
2957:
2958: if ( gFlagReselecting )
2959: break; /* Take Identify only - leave +ACK */
2960: }/* end IF have a complete message-in to process */
2961: }/* end WHILE there are more message bytes */
2962:
2963: /***** If the target switches out of MSGI phase without *****/
2964: /***** sending a complete message, we should do some *****/
2965: /***** sort of error recovery. *****/
2966:
2967: if ( gMsgInState != kMsgInInit )
2968: {
2969: PAUSE( gCurrentTarget, gMsgInState, 'MGI-', "DoMessageInPhase - incomplete message.\n" );
2970: if ( ioReturn == IO_R_SUCCESS )
2971: ioReturn = IO_R_IO; /* General IO error */
2972: }
2973:
2974: return ioReturn;
2975: }/* end DoMessageInPhase */
2976:
2977:
2978: /* ProcessMSGI - DoMessageInPhase has read a complete message. */
2979: /* Process it (this will probably change our internal state). */
2980:
2981: - (void) ProcessMSGI
2982: {
2983: /* Note that, during reselection, we may not have */
2984: /* a current target or LUN, nor possibly a valid command */
2985:
2986: register CommandBuffer *cmdBuf;
2987: register IOSCSIRequest *scsiReq;
2988:
2989: UInt8 sdtr;
2990: UInt8 currentTarget, currentLUN;
2991: UInt8 period, offset;
2992: UInt8 targetResponse; /* responding or requesting? */
2993:
2994:
2995: cmdBuf = gActiveCommand; /* May be NULL */
2996: scsiReq = (cmdBuf == NULL) ? NULL : cmdBuf->scsiReq;
2997: if ( scsiReq )
2998: { currentTarget = scsiReq->target;
2999: currentLUN = scsiReq->lun;
3000: ASSERT( currentTarget == gCurrentTarget && currentLUN == gCurrentLUN );
3001: }
3002: else
3003: { currentTarget = gCurrentTarget;
3004: currentLUN = gCurrentLUN;
3005: }
3006:
3007: ELG( 0, *(UInt32*)gMsgInBuffer, '<Msg', "ProcessMSGI" );
3008:
3009: switch ( gMsgInBuffer[0] )
3010: {
3011: case kScsiMsgCmdComplete:
3012: if ( cmdBuf )
3013: {
3014: /* This command is complete. Clear interrupts and */
3015: /* allow subsequent MESH interrupts. Then tell the */
3016: /* MESH to wait for the target to release the bus. */
3017:
3018: [ self SetSeqReg : kMeshEnableReselect ];
3019: [ self SetSeqReg : kMeshBusFreeCmd ]; /* cause Int */
3020:
3021: if ( cmdBuf->flagIsAutosense == FALSE )
3022: {
3023: if ( scsiReq )
3024: scsiReq->scsiStatus = CCLByte( kcclStatusData );
3025:
3026: /* Driver Kit does not return the command-complete byte. */
3027:
3028: }
3029: [ self ioComplete : cmdBuf ];
3030: }
3031: goto exit; /* Don't exit through the SWITCH end */
3032:
3033: case kScsiMsgLinkedCmdComplete:
3034: case kScsiMsgLinkedCmdCompleteFlag:
3035: PAUSE( gCurrentTarget, 0, 'pmi-', "ProcessMSGI - linked command complete not supported.\n" );
3036: [ self AbortActiveCommand ];
3037: break;
3038:
3039: case kScsiMsgNop:
3040: break;
3041:
3042: case kScsiMsgRestorePointers:
3043: if ( cmdBuf )
3044: {
3045: cmdBuf->currentDataIndex = cmdBuf->savedDataIndex;
3046: if ( cmdBuf->mem )
3047: [ cmdBuf->mem setState : &cmdBuf->savedDataState ];
3048: }
3049: break;
3050:
3051: case kScsiMsgSaveDataPointers:
3052: if ( cmdBuf )
3053: {
3054: cmdBuf->savedDataIndex = cmdBuf->currentDataIndex;
3055: if ( cmdBuf->mem )
3056: [ cmdBuf->mem state : &cmdBuf->savedDataState ];
3057: }
3058: break;
3059:
3060: case kScsiMsgDisconnect:
3061: /* Driver Kit does not support automatic Save Data Pointers on */
3062: /* Disconnect. */
3063: /* Move this request to the disconnect queue, enable reselection, */
3064: /* re-enable MESH interrupts, and wait (here) for bus free, but */
3065: /* don't eat the interrupt. */
3066:
3067: gMsgInFlag |= kFlagMsgIn_Disconnect;
3068: [ self disconnect ]; /* requeue active */
3069: [ self SetSeqReg : kMeshEnableReselect ]; /* enable reselect */
3070: [ self SetIntMask : kMeshIntrMask ]; /* Enable Ints */
3071: [ self SetSeqReg : kMeshBusFreeCmd ]; /* issue BusFree */
3072:
3073: /* wait for Bus Free command to complete: */
3074:
3075: [ self WaitForMesh : FALSE ]; /* don't clear possible reselect */
3076:
3077: /* Interrupt for bus-free now latched. Prevent a double interrupt, */
3078: /* 1 from bus-free + 1 from reselect from occurring. */
3079: /* This fixes the following BADNESS: */
3080: /* Issue bus-free for disconnect. */
3081: /* Interrupt occurs in microseconds - even before exiting */
3082: /* "interruptOccurred" routine. */
3083: /* Mach queues message to driverKit. */
3084: /* Exit "interruptOccurred" routine. */
3085: /* DriverKit dequeues and starts handling 1st Mach message. */
3086: /* Interrupt occurs for reselect while driverKit running. */
3087: /* Mach queues 2nd message to driverKit. */
3088: /* DriverKit invokes MESH driver for 1st msg. */
3089: /* MESH driver sees cmdDone fm bus-free AND reselect exception.*/
3090: /* MESH driver handles reselect by setting up and running */
3091: /* DBDMA. MESH driver exits. */
3092: /* DriverKit invokes MESH driver with 2nd Mach message. */
3093: /* MESH driver handles this as a DBDMA completion and royally */
3094: /* screws up. */
3095:
3096: g.intLevel |= kLevelLatched; /* set latched-interrupt flag */
3097: [ self SetIntMask : 0 ]; /* prevent multiple MESH ints */
3098: break;
3099:
3100: case kScsiMsgRejectMsg:
3101: ELG( currentTarget, gMsgOutFlag, 'Rej-', "ProcessMSGI - Reject." );
3102: gMsgInFlag |= kFlagMsgIn_Reject;
3103: break;
3104:
3105: case kScsiMsgSimpleQueueTag:
3106: msgInTagType = gMsgInBuffer[0];
3107: msgInTag = gMsgInBuffer[1];
3108: ELG( 0, msgInTag, '=Tag', "Simple Queue Tag" );
3109: break;
3110:
3111: case kScsiMsgExtended:
3112:
3113: /* Multi-byte message, presumably Synchronous Negotiation: */
3114:
3115: switch ( gMsgInBuffer[ 2 ] ) /* switch on the msg code byte */
3116: {
3117: case kScsiMsgSyncXferReq: /* handle sync negotiation: */
3118: if ( scsiReq == NULL ) // ??? can this happen?
3119: {
3120: PAUSE( currentTarget, 0, 'pMI-', "ProcessMSGI - attempted to negotiate SDTR without a nexus.\n" );
3121: [ self AbortActiveCommand ];
3122: }
3123: else
3124: { /* Get period in nanoseconds */
3125: period = gMsgInBuffer[ 3 ] * 4; /* SCSI uses 4ns granularity */
3126:
3127: /* determine target responding or initiating? */
3128: targetResponse = gPerTargetData[ scsiReq->target ].negotiateSDTR;
3129: gPerTargetData[ scsiReq->target ].negotiateSDTR = 0;
3130: if ( targetResponse )
3131: {
3132: if ( gMsgInBuffer[ 4 ] == 0 ) /* check offset */
3133: {
3134: sdtr = kSyncParmsAsync; /* Offset == 0 implies async */
3135: }
3136: else /* synchronous: */
3137: {
3138: if ( period == 100 ) /* special-case 100=FAST */
3139: {
3140: sdtr = kSyncParmsFast & 0x0F;
3141: }
3142: else /* Older CD-ROMs get here. */
3143: { /* The MESH manual says: */
3144: /* period = 4 * clk + 2 * clk * P */
3145: /* where: */
3146: /* period is the target nanoseconds */
3147: /* clk is the MESH clock rate which is */
3148: /* 20 nanoseconds for a 50 MHz clock */
3149: /* P is the 1-nibble period code we stuff */
3150: /* in the syncParms register */
3151: /* So: */
3152: /* period = 4 * 20 + 2 * 20 * P */
3153: /* period = 80 + 40 * P */
3154: /* P = (period - 80) / 40 */
3155: /* Since P must round up for safety: */
3156: /* P = ((period - 80) + 39) / 40 */
3157: /* P = (period - 41) / 40 */
3158: /* A value of P == 3 results in 5 MB/s */
3159: sdtr = (UInt8)((period - 41) / 40);
3160: }
3161: #ifdef CRAP
3162: /* If period is longer than 200 ns resulting */
3163: /* in less than 5 MB/s, renegotiate async later.*/
3164: if ( period >= 200 )
3165: gPerTargetData[ scsiReq->target ].negotiateSDTR = kSyncParmsAsync;
3166: #endif /* CRAP */
3167: }/* end ELSE have offset ergo Synchronous */
3168:
3169: /* OR in the offset. */
3170: sdtr |= (gMsgInBuffer[ 4 ] << 4);
3171: }/* end IF Target is responding to negotiation */
3172:
3173: else /* target is initiating negotiation: */
3174: {
3175: msgOutPtr = (UInt8*)CCLAddress( kcclMSGOdata );
3176: *msgOutPtr++ = kScsiMsgExtended; /* 0x01 Ext Msg */
3177: *msgOutPtr++ = 0x03; /* 0x03 Message Len */
3178: *msgOutPtr++ = kScsiMsgSyncXferReq; /* 0x01 SDTR code */
3179: offset = gMsgInBuffer[ 4 ];
3180: if ( offset == 0 ) /* Offset == 0 means async: */
3181: {
3182: *msgOutPtr++ = 0; /* clear period byte */
3183: *msgOutPtr++ = 0; /* offset byte = 0 for async*/
3184: sdtr = kSyncParmsAsync; /* set value for MESH reg */
3185: }
3186: else /* have offset ergo sync: */
3187: {
3188: if ( offset > 15 )
3189: offset = 15; /* MESH can only handle 15 */
3190:
3191: if ( period <= 100 ) /* special-case 100=FAST */
3192: period = 100;
3193: else
3194: { /* round up to MESH's 40 ns granularity */
3195: period = ((period + 39) / 40) * 40;
3196: }
3197: *msgOutPtr++ = period / 4; /* SCSI 4ns granularity */
3198: *msgOutPtr++ = offset;
3199: sdtr = (offset << 8) | (UInt8)((period - 41) / 40);
3200: }/* end target is negotiating Sync */
3201: /* respond to target: */
3202: [ self RunDBDMA : kcclMsgoStage stageLabel : kcclStageInit ];
3203: gPerTargetData[ scsiReq->target ].negotiateSDTR = 0;
3204: }/* end ELSE target is initiating negotiation */
3205:
3206: meshAddr->syncParms = sdtr;
3207: SynchronizeIO();
3208: gPerTargetData[ scsiReq->target ].syncParms = sdtr;
3209: ELG( *(UInt32*)&gMsgInBuffer[0], gMsgInBuffer[4]<<24 | sdtr, 'SDTR', "ProcessMSGI - SDTR" );
3210: } /* end ELSE have a nexus */
3211: break;
3212:
3213: default:
3214: PAUSE( currentTarget, gMsgInBuffer[0], 'PMi-', "ProcessMSGI - unsupported extended message.\n" );
3215: [ self AbortActiveCommand ];
3216: break;
3217: }/* end SWITCH on extended message code */
3218: break;
3219:
3220: default:
3221: if ( gMsgInBuffer[0] >= kScsiMsgIdentify )
3222: {
3223: ASSERT( gCurrentTarget != kInvalidTarget );
3224: ASSERT( gCurrentLUN == kInvalidLUN );
3225: gCurrentLUN = gMsgInBuffer[0] & kScsiMsgIdentifyLUNMask;
3226: currentLUN = gCurrentLUN;
3227: }
3228: else
3229: {
3230: PAUSE( currentTarget, gMsgInBuffer[0], 'mi -', "ProcessMSGI - unsupported message: rejected.\n" );
3231: [ self AbortActiveCommand ];
3232: }
3233: }/* end SWITCH on message selection */
3234:
3235: exit:
3236: return;
3237: }/* end ProcessMSGI */
3238:
3239:
3240: /* Process a reselection interrupt. */
3241:
3242: - (void) HandleReselectionInterrupt
3243: {
3244: IOReturn ioReturn;
3245:
3246:
3247: ASSERT( gActiveCommand == NULL );
3248:
3249: gFlagReselecting = TRUE;
3250:
3251: /* Sometimes MESH gives a bogus Disconnected error during Reselection. */
3252: /* 31mar98 - Issuing an Abort message, causes "unexpected disconnect". */
3253: /* When Err:UnexpDisc and Exc:Resel are simultaneously set, the */
3254: /* busStatus0,1 registers may not be current. */
3255: if ( g.shadow.mesh.error & kMeshErrDisconnected )
3256: {
3257: [ self SetSeqReg : kMeshBusFreeCmd ];
3258: [ self WaitForMesh : TRUE ]; // now maybe busStatus0,1 are live
3259: PAUSE( 0, 0, 'Dsc-',
3260: "HandleReselectionInterrupt: Caught disconnected glitch\n" );
3261: }/* End IF bus disconnect error */
3262:
3263: /* Read the target ID (which should be our initiator ID OR'd with the */
3264: /* Target and the Identify byte with the reselecting LUN. Store this */
3265: /* in gTargetID and gTargetLUN. Note that, during reselection, we will */
3266: /* have a NULL gCurrentCommand and a valid gCurrentTarget and gCurrentLUN. */
3267: /* If we get a valid reselection target, call the message in phase */
3268: /* directly to read the LUN byte. */
3269: /* @return TRUE if successful. */
3270:
3271: msgInTag = 0;
3272: if ( meshAddr->FIFOCount == 0 )
3273: {
3274: PAUSE( 0, 0, 'HRI-', "HandleReselectionInterrupt - Empty FIFO in reselection.\n" );
3275: return;
3276: }
3277: else /* get the Target ID bit from the bus out of the FIFO */
3278: { /* then, get the msg-in Identify byte for the LUN. */
3279: if ( [ self getReselectionTargetID ] )
3280: {
3281: if ( [ self DoMessageInPhase ] != IO_R_SUCCESS ) /* get Identify */
3282: {
3283: PAUSE( 0, 0, 'Id -', "HandleReselectionInterrupt - Expected Identify byte after reselection.\n" );
3284: }
3285: }
3286: else return;
3287: }
3288:
3289: /* Try to find an untagged command for this Target/LUN: */
3290:
3291: ioReturn = [ self reselectNexus : gCurrentTarget
3292: lun : gCurrentLUN
3293: queueTag : 0 ];
3294:
3295: if ( ioReturn != IO_R_SUCCESS )
3296: { /* No untagged command, try to get a Tag. Hope that */
3297: /* you're still in Message-In phase at this point. */
3298: if ( [ self DoMessageInPhase ] != IO_R_SUCCESS ) /* get Tag msg */
3299: {
3300: PAUSE( 0, 0, 'tag-', "HandleReselectionInterrupt - Expected tag message.\n" );
3301: }
3302: ioReturn = [ self reselectNexus : gCurrentTarget
3303: lun : gCurrentLUN
3304: queueTag : msgInTag ];
3305: }
3306:
3307: if ( ioReturn == IO_R_SUCCESS )
3308: {
3309: ELG( gActiveCommand,
3310: (msgInTag<<16) | (gCurrentLUN<<8) | gCurrentTarget,
3311: 'Resl', "HandleReselectionInterrupt" );
3312: /* If reselectNexus succeeded, gActiveCommand is set to the command.*/
3313: /* Clear out the channel command results and build the channel */
3314: /* command to continue operation. The TRUE flag prevents */
3315: /* constructing an arbitrate/select/command sequence. */
3316:
3317: [ self ClearCPResults ];
3318: [ self UpdateCP : TRUE ];
3319: [ self RunDBDMA : kcclReselect stageLabel : kcclStageInit ];
3320: }
3321: else
3322: { /* There is no associated command. */
3323: /* Reject the reselection attempt. */
3324: /* This should cycle back to selectNextRequest. */
3325: PAUSE( gCurrentTarget, msgInTag, 'Rsl-',
3326: "HandleReselectionInterrupt - No command for reselection attempt.\n" );
3327: [ self AbortActiveCommand ];
3328: }
3329: return;
3330: }/* end HandleReselectionInterrupt */
3331:
3332:
3333: /* Validate the target's reselection byte (put on the bus before */
3334: /* reselecting us). Erase the initiator ID and convert the other */
3335: /* bit into an index. The algorithm should be faster than a */
3336: /* sequential search, but it probably doesn't matter much. */
3337: /* @return TRUE if successful (gCurrentTarget is now valid). */
3338: /* This function does not check whether there actually */
3339: /* is a command pending for this target. */
3340:
3341: - (Boolean) getReselectionTargetID
3342: {
3343: Boolean success = FALSE;
3344: register UInt8 targetID = 0;
3345: register UInt8 bitValue = 0; /* Suppress warning */
3346: register UInt8 targetBits;
3347:
3348:
3349: targetBits = meshAddr->xFIFO; /***** Read the FIFO *****/
3350: targetBits &= ~gInitiatorIDMask; /* Remove our bit */
3351: if ( targetBits )
3352: { /* Is there another bit? */
3353: bitValue = targetBits;
3354: if ( bitValue > 0x0F )
3355: {
3356: targetID += 4;
3357: bitValue >>= 4;
3358: }
3359: if ( bitValue > 0x03 )
3360: {
3361: targetID += 2;
3362: bitValue >>= 2;
3363: }
3364: if ( bitValue > 0x01 )
3365: {
3366: targetID += 1;
3367: }
3368: targetBits &= ~(1 << targetID); /* Remove the target mask */
3369: if ( targetBits == 0 )
3370: { /* Was exactly one set? */
3371: success = TRUE; /* Yes: success! */
3372: gCurrentTarget = targetID; /* Save the current target */
3373: }
3374: }
3375:
3376: if ( !success )
3377: PAUSE( targetID, targetBits, 'rsl-', "getReselectionTargetID - Expected Identify byte after reselection.\n" );
3378:
3379: return success;
3380: }/* end getReselectionTargetID */
3381:
3382:
3383: @end /* AppleMesh_SCSI(MeshInterrupt) */
3384:
3385:
3386: @implementation AppleMesh_SCSI( Mesh )
3387:
3388: /* Reusable hardware initializer function. if resetSCSIBus is TRUE, */
3389: /* this includes a SCSI reset. Handling of ioComplete of active and */
3390: /* disconnected commands must be done elsewhere. Returns IO_R_SUCCESS. */
3391:
3392: - (IOReturn) ResetMESH : (Boolean)resetSCSIBus
3393: {
3394: IOReturn ioReturn = IO_R_SUCCESS;
3395: UInt8 defaultSelectionTimeout = 25; // mlj ??? fix this value
3396: UInt8 target;
3397:
3398:
3399: /* Reset interrupts, the MESH Hardware Bus Adapter, and the DMA engine. */
3400:
3401: // [ self SetIntMask : 0 ]; /* ResetMESH clrs interruptMask */
3402: [ self SetSeqReg : kMeshResetMESH ]; /* completes quickly */
3403: [ self GetHBARegsAndClear : TRUE ]; /* clear cmdDone */
3404:
3405: dbdma_reset( DBDMA_MESH_SCSI );
3406:
3407: /* Init state variables: */
3408:
3409: gFlagIncompleteDBDMA = FALSE;
3410: // gBusState = SCS_DISCONNECTED;
3411:
3412: /* Smash all active command state (just in case): */
3413:
3414: gActiveCommand = NULL;
3415: gCurrentTarget = kInvalidTarget;
3416: gCurrentLUN = kInvalidLUN;
3417: gMsgInState = kMsgInInit;
3418: msgOutPtr = (UInt8*)CCLAddress( kcclMSGOdata );
3419:
3420: if ( resetSCSIBus )
3421: {
3422: ASSERT( gInterruptNestingLevel > 0 );
3423: meshAddr->busStatus1 = kMeshRst; /***** ASSERT RESET SIGNAL *****/
3424: SynchronizeIO();
3425: IODelay( 25 ); /* leave asserted for 25 mikes */
3426: meshAddr->busStatus1 = 0; /***** CLEAR RESET SIGNAL *****/
3427: SynchronizeIO();
3428:
3429: /* Delay for 250 msec after resetting the bus. */
3430: /* This serves two purposes: it gives the MESH time to */
3431: /* stabilize (about 10 msec is sufficient) and gives */
3432: /* some devices time to re-initialize themselves. */
3433:
3434: IOSleep( APPLE_SCSI_RESET_DELAY ); /* Give Targets time to clean up */
3435: [ self SetSeqReg : kMeshResetMESH ]; /* clear Err condition */
3436: [ self GetHBARegsAndClear : TRUE ]; /* check regs */
3437:
3438: for ( target = 0; target < SCSI_NTARGETS; target++ )
3439: {
3440: gPerTargetData[ target ].syncParms = kSyncParmsAsync;
3441: gPerTargetData[ target ].negotiateSDTR = kSyncParmsFast; // negotiate Fast
3442: }
3443: }/* end IF resetSCSIBus */
3444:
3445: meshAddr->selectionTimeOut = defaultSelectionTimeout;
3446: SynchronizeIO();
3447:
3448: return ioReturn;
3449: }/* end ResetMESH */
3450:
3451:
3452: /* Wait for an immediate (non-interrupting) command to complete. */
3453: /* Note that it spins while waiting. It is timed to prevent a buggy */
3454: /* chip or target from hanging the system. */
3455:
3456: - (IOReturn) WaitForMesh : (Boolean) clearInterrupts
3457: {
3458: ns_time_t startTime, endTime;
3459: IOReturn ioReturn = IO_R_SUCCESS;
3460: #if USE_ELG
3461: UInt8 *logp = g.evLogBufp;
3462: #endif /* USE_ELG */
3463: //#define WAIT_TIME (1000000000ULL)
3464: //#define WAIT_TIME (3000000ULL) // mlj - make it 3 milliseconds
3465: //#define WAIT_TIME 19000000 // mlj - make it 19 milliseconds for ZIP
3466: #define WAIT_TIME 250000000 // mlj - make it 250 milliseconds for SONY CD-ROM
3467:
3468:
3469: IOGetTimestamp( &startTime );
3470:
3471: for ( g.shadow.mesh.interrupt = 0; g.shadow.mesh.interrupt == 0; )
3472: {
3473: #if USE_ELG
3474: g.evLogBufp = logp; /* set back the log pointer */
3475: #endif /* USE_ELG */
3476: [ self GetHBARegsAndClear : clearInterrupts ];
3477:
3478: IOGetTimestamp( &endTime );
3479: if ( (endTime - startTime) >= WAIT_TIME )
3480: { /* It took too long! We're dead. */
3481: PAUSE( 0, 0, 'WFM-', "WaitForMesh - MESH chip does not respond to command.\n" );
3482: ioReturn = IO_R_INTERNAL;
3483: break;
3484: }
3485: }/* end FOR */
3486:
3487: return ioReturn;
3488: }/* end WaitForMesh */
3489:
3490:
3491: /* WaitForReq - spins while waiting. It is timed to prevent a buggy */
3492: /* chip or target from hanging the system. */
3493:
3494: - (IOReturn) WaitForReq /* This method is currently unused. */
3495: {
3496: ns_time_t startTime, endTime;
3497: IOReturn ioReturn = IO_R_SUCCESS;
3498:
3499:
3500: IOGetTimestamp( &startTime );
3501:
3502: g.shadow.mesh.busStatus0 = 0;
3503: while ( (g.shadow.mesh.busStatus0 & kMeshReq) == 0 )
3504: {
3505: [ self GetHBARegsAndClear : FALSE ];
3506:
3507: IOGetTimestamp( &endTime );
3508: if ( (endTime - startTime) >= 1000000000L )
3509: { /* It took too long! */
3510: PAUSE( endTime, startTime, 'WFR-', "WaitForReq - Target not in valid phase.\n" );
3511: ioReturn = IO_R_INTERNAL;
3512: break;
3513: }
3514: if ( (endTime - startTime) >= 1000000L
3515: && (g.shadow.mesh.busStatus0 & kMeshReq) == 0 )
3516: {
3517: IODelay( 1000 ); /* After 1 ms, start yielding time */
3518: }
3519: }/* end WHILE REQ not set */
3520:
3521: return ioReturn;
3522: }/* end WaitForReq */
3523:
3524:
3525: /* Send a command to the MESH chip. This may cause an interrupt. */
3526:
3527: - (void) SetSeqReg : (MeshCommand) meshCommand
3528: {
3529: ELG( (meshAddr->interruptMask<<16) | meshAddr->interrupt, meshCommand, '=Seq', "SetSeqReg" );
3530:
3531: if ( meshAddr->interruptMask & kMeshIntrCmdDone
3532: && meshCommand <= kMeshBusFreeCmd )
3533: ELG( meshAddr->interrupt, meshAddr->interruptMask, 'Trig',
3534: "SetSeqReg - may trigger interrupt.\n" );
3535:
3536: meshAddr->sequence = (UInt8)meshCommand; /***** DO IT *****/
3537: SynchronizeIO();
3538: IODelay( 1 ); /* G3 is too fast */
3539:
3540: return;
3541: }/* end SetSeqReg */
3542:
3543:
3544: /* MESH chip self-test. (Minimal: it could be extended.) */
3545: /* @return IO_R_SUCCESS if successful. */
3546:
3547: - (IOReturn) DoHBASelfTest
3548: {
3549: IOReturn ioReturn = IO_R_SUCCESS;
3550: UInt8 tempByte;
3551:
3552:
3553: ELG( gMESHPhysAddr, meshAddr, 'MESH', "DoHBASelfTest" );
3554: #ifdef CRAP
3555: if ( probe_rb( ((void*)((UInt32)gMESHPhysAddr) + kMeshMESHID) ) == 0 )
3556: {
3557: PAUSE( 0, gMESHPhysAddr, 'HBA-', "DoHBASelfTest - Invalid MESH physical address.\n" );
3558: ioReturn = IO_R_NO_DEVICE;
3559: }
3560: #else
3561: ASSERT( probe_rb( ((void*)((UInt32)gMESHPhysAddr) + kMeshMESHID) ) == 0 );
3562: #endif /* CRAP */
3563:
3564: if ( ioReturn == IO_R_SUCCESS )
3565: {
3566: tempByte = meshAddr->MESHID & 0x1f;
3567: if ( tempByte < kMeshMESHID_Value )
3568: {
3569: PAUSE( 0, tempByte, 'hba-', "DoHBASelfTest - Invalid MESH chip ID .\n" );
3570: ioReturn = IO_R_NO_DEVICE;
3571: }
3572: }
3573: return ioReturn;
3574: }/* end DoHBASelfTest */
3575:
3576:
3577: /* Start a Channel Program at the given offset */
3578: /* with the specified stage label. */
3579:
3580: - (void) RunDBDMA : (UInt32) offset stageLabel : (UInt32) stageLabel
3581: {
3582: register UInt8 intReg;
3583: ns_time_t arbEndTime, curTime;
3584:
3585:
3586: gMsgInFlag = 0; /* clear message-in flags. */
3587:
3588: CCLWord( kcclStageLabel ) = stageLabel; /* set the stage */
3589:
3590: /* Let MESH interrupt only for errors or exceptions, but not cmdDone */
3591: [ self SetIntMask : (kMeshIntrException | kMeshIntrError) ];
3592:
3593: intReg = meshAddr->interrupt;
3594: switch ( intReg )
3595: {
3596: case kMeshIntrCmdDone:
3597: if ( !gFlagReselecting ) // ??? Don't drop ACK fm MSG-IN or Sync data flows
3598: /* clear any pending command interrupts (but not reselect et al) */
3599: meshAddr->interrupt = kMeshIntrCmdDone; SynchronizeIO();
3600: /***** fall through *****/
3601: case 0:
3602: /* This is a Go: */
3603: /* Flush any CCL and related data to the CCL physical page */
3604: /* that may still be sitting in cache: */
3605: flush_cache_v( (vm_offset_t)cclLogAddr, cclLogAddrSize );
3606: //ELG( *(UInt32*)0xF3000020, 0, 'G C+', "RunDBDMA." );
3607: //ELG( 0, *(UInt32*)0xF300002C, 'G C ', "RunDBDMA." );
3608:
3609: if ( offset == kcclStart )
3610: {
3611: gFlagReselecting = FALSE;
3612: [ self SetSeqReg : kMeshArbitrateCmd ]; /* ARBITRATE */
3613:
3614: /* wait 50 mikes or cmdDone, whichever comes first: */
3615:
3616: IOGetTimestamp( &arbEndTime );
3617: arbEndTime += 50000;
3618: do
3619: {
3620: [ self GetHBARegsAndClear : FALSE ]; /* get regs without hosing */
3621: IOGetTimestamp( &curTime );
3622: }while ( !(g.shadow.mesh.interrupt & kMeshIntrCmdDone) && curTime < arbEndTime );
3623:
3624: if ( g.shadow.mesh.interrupt == kMeshIntrCmdDone )
3625: { /* No err, no exc: Arbitration won: */
3626: meshAddr->interrupt = kMeshIntrCmdDone;
3627: SynchronizeIO();
3628: [ self SetSeqReg : kMeshDisableReselect ]; /* disable reselect */
3629: offset = 0x150; // ??? fix this. Point to Select/Atn
3630: CCLWord( kcclStageLabel ) = kcclStageArb; /* set stage to Arbitrate */
3631: }/* end IF won Arbitration */
3632: else /* Arbitration not won - CAUTION - HACK AHEAD: */
3633: { /* Sometimes, MESH does not return ArbLost as it says in */
3634: /* the documentation. Instead, it waits for the winner to */
3635: /* get off the bus (usually after the 250 ms timeout) and */
3636: /* then MESH continues its arbitration. This wastes 250 ms */
3637: /* of valuable bus time. Further, IOmega's Zip drive has a */
3638: /* nasty bug whereby if its reselection is snubbed and it */
3639: /* times out, it leaves the I/O signal asserted on the bus */
3640: /* even as other activity on the bus unrelated to the Zip */
3641: /* is ongoing. */
3642: /* We don't need to hack if ArbLost is indicated correctly */
3643: /* or Reselect is indicated. If either is true, don't bother*/
3644: /* starting the DBDMA; rather, let the interrupt already */
3645: /* latched handle the situation. */
3646:
3647: if ( !(g.shadow.mesh.exception & (kMeshExcArbLost | kMeshExcResel)) )
3648: {
3649: ELG( '****', '****', 'HACK', "RunDBDMA - Arbitrate HACK." );
3650: [ self SetSeqReg : kMeshResetMESH ]; /* hack it: whack it*/
3651: [ self GetHBARegsAndClear : TRUE ]; /* get regs/preserve*/
3652: [ self SetSeqReg : kMeshEnableReselect ]; /* Let reselect again*/
3653: [ self GetHBARegsAndClear : FALSE ]; /* get regs/preserve*/
3654: if ( g.shadow.mesh.interrupt == 0 )
3655: PAUSE( 0, 0, 'Arb*', "RunDBDMA - Arbitrate/Reselect problem." );
3656: }
3657: if ( g.shadow.mesh.interrupt ) /* If Err or Exc set: */
3658: { g.intLevel |= kLevelLatched; /* set latched-interrupt flag. */
3659: return; /* let pending Int clean up. */
3660: }
3661: }/* end ELSE lost Arbitration */
3662: }/* end IF DBDMA to start at Arbitrate */
3663:
3664: [ self GetHBARegsAndClear : FALSE ]; // ??? debug: see if ACK still set
3665: ELG( 0, offset<<16 | stageLabel, 'DMA+', "RunDBDMA" );
3666: dbdma_start( DBDMA_MESH_SCSI, (dbdma_command_t*)((UInt32)cclPhysAddr + offset) );
3667: break;
3668:
3669: default: /* Err or Exc or both are set */
3670: ELG( 'Err ', 'Exc ', 'Pnd-', "RunDBDMA - interrupt probably pending (reselect?)." );
3671: [ self GetHBARegsAndClear : FALSE ]; // display without hosing
3672: }/* end SWITCH on interrupt register */
3673: return;
3674: }/* end RunDBDMA */
3675:
3676:
3677: /* Retrieve the MESH volatile register contents, */
3678: /* storing them in the global register shadow. */
3679: /* @param clearInts YES to clear MESH interrupts. */
3680:
3681: - (void) GetHBARegsAndClear : (Boolean) clearInts
3682: {
3683: register MeshRegister *mesh = meshAddr;
3684:
3685:
3686: g.shadow.mesh.interrupt = mesh->interrupt;
3687: g.shadow.mesh.error = mesh->error;
3688: g.shadow.mesh.exception = mesh->exception;
3689: g.shadow.mesh.FIFOCount = mesh->FIFOCount;
3690:
3691: g.shadow.mesh.busStatus0 = mesh->busStatus0;
3692: g.shadow.mesh.busStatus1 = mesh->busStatus1;
3693: g.shadow.mesh.transferCount1 = mesh->transferCount1;
3694: g.shadow.mesh.transferCount0 = mesh->transferCount0;
3695:
3696: g.shadow.mesh.sequence = mesh->sequence; // debugging
3697: g.shadow.mesh.interruptMask = mesh->interruptMask; // debugging
3698: g.shadow.mesh.syncParms = mesh->syncParms; // debugging
3699: g.shadow.mesh.destinationID = mesh->destinationID; // debugging
3700:
3701: ELG( g.shadow.longWord[ 0 ], g.shadow.longWord[ 1 ], clearInts ? 'Regs' : 'regs', "GetHBARegsAndClear." );
3702:
3703: if ( g.shadow.mesh.error ) // this occurs when dbdma -> Seq while reselect
3704: ELG( g.shadow.mesh.interruptMask, g.shadow.mesh.sequence, 'Err-',
3705: "GetHBARegsAndClear - MESH error detected" );
3706:
3707: /* It is possible to have the Reselected bit set in the Exception */
3708: /* register without an Exception bit in the interrupt register. */
3709: /* This may be caused by timing window where we clear the interrupt */
3710: /* register with the interrupt register instead of 0x07. */
3711: /* Handle this by faking an exception. */
3712: /* 04may98 - it is also possible to have PhaseMisMatch set in the */
3713: /* Exception register without Exception indicated in the Interrupt */
3714: /* register. This happened when a Synchronous output finished and */
3715: /* the target went to Message-In phase with Save-Data-Pointer. */
3716:
3717:
3718: if ( g.shadow.mesh.exception )
3719: g.shadow.mesh.interrupt |= kMeshIntrException;
3720:
3721: if ( clearInts && g.shadow.mesh.interrupt )
3722: {
3723: mesh->interrupt = g.shadow.mesh.interrupt;
3724: SynchronizeIO();
3725: }
3726: return;
3727: }/* end GetHBARegsAndClear */
3728:
3729:
3730: - (void) SetIntMask : (UInt8) mask
3731: {
3732: ELG( (meshAddr->interrupt<<16) | meshAddr->interruptMask, mask, 'Mask', "SetIntMask" );
3733: meshAddr->interruptMask = mask; /* enable whatever */
3734: SynchronizeIO();
3735: return;
3736: }/* end SetIntMask */
3737:
3738:
3739: - (void) AbortActiveCommand
3740: {
3741: IOReturn ioReturn;
3742:
3743:
3744: ELG( gActiveCommand, 0, '-AB*', "AbortActiveCommand" );
3745: [ self GetHBARegsAndClear : TRUE ]; /* clear possible cmdDone et al */
3746: [ self SetIntMask : 0 ]; /* Disable MESH interrupts */
3747:
3748: gMsgInFlag = 0; /* clear kFlagMsgIn_Reject et al */
3749:
3750: meshAddr->busStatus0 = kMeshAtn; /***** Raise ATN signal *****/
3751: SynchronizeIO();
3752:
3753: [ self SetSeqReg : kMeshBusFreeCmd ]; /* clear ACK */
3754: [ self WaitForMesh : TRUE ]; /* wait for PhaseMM */
3755:
3756: if ( (g.shadow.mesh.busStatus0 & (kMeshPhaseMask | kMeshReq))
3757: == (kBusPhaseMSGO | kMeshReq) )
3758: { /* this is what we want: */
3759: [ self SetSeqReg : kMeshFlushFIFO ]; /* Flush the FIFO */
3760: meshAddr->transferCount0 = 1; /* set TC low = 1 */
3761: meshAddr->transferCount1 = 0;
3762: meshAddr->busStatus0 = 0; /***** clear ATN signal *****/
3763: SynchronizeIO();
3764:
3765: /* Issue the Message Out sending the Abort on its way. */
3766: /* Note that this will cause an Unexpected-Disconnect. */
3767: [ self SetSeqReg : kMeshMessageOutCmd ]; /* drop ATN signal */
3768: meshAddr->xFIFO = kScsiMsgAbort; /* put out the Abort byte */
3769: ioReturn = [ self WaitForMesh : TRUE ]; /* wait for cmdDone */
3770: if ( ioReturn == IO_R_SUCCESS )
3771: {
3772: [ self SetSeqReg : kMeshEnableReselect ];/* bus about to go free */
3773: [ self SetIntMask : kMeshIntrMask ]; /* Enable interrupts */
3774: [ self SetSeqReg : kMeshBusFreeCmd ]; /* Clr ACK & go Bus-Free */
3775: g.intLevel |= kLevelLatched; /* set latched-int flag */
3776: return;
3777: }
3778: }/* end IF MSGO phase and REQ is set */
3779:
3780: /***** USE THE HAMMER - NUKE THE BUS: *****/
3781:
3782: ELG( 0, 0, '-AB-', "AbortActiveCommand - target refused to enter MSGO phase" );
3783: [ self ResetHardware : TRUE ];
3784: return;
3785: }/* end AbortActiveCommand */
3786:
3787:
3788: - (void) AbortDisconnectedCommand
3789: {
3790: CommandBuffer *cmdBuf;
3791: IOSCSIRequest *scsiReq;
3792: UInt8 msgByte;
3793:
3794:
3795: if ( !queue_empty( &abortCmdQ ) )
3796: {
3797: cmdBuf = (CommandBuffer*)queue_first( &abortCmdQ );
3798: scsiReq = cmdBuf->scsiReq;
3799: meshAddr->destinationID = scsiReq->target;
3800: msgOutPtr = (UInt8*)CCLAddress( kcclMSGOdata );
3801: msgByte = kScsiMsgIdentify | scsiReq->lun;
3802: *msgOutPtr++ = msgByte;
3803: if ( cmdBuf->queueTag )
3804: { /* Tagged command: */
3805: *msgOutPtr++ = kScsiMsgSimpleQueueTag;
3806: *msgOutPtr++ = cmdBuf->queueTag;
3807: *msgOutPtr++ = kScsiMsgAbortTag;
3808: ELG( cmdBuf, cmdBuf->queueTag, 'AbT-', "AbortDisconnectedCommand - Tag" );
3809: }
3810: else
3811: { /* Untagged command: */
3812: *msgOutPtr++ = kScsiMsgAbort;
3813: ELG( cmdBuf, 0, 'AbU-', "AbortDisconnectedCommand - Abort (untagged)" );
3814: }
3815: [ self SetupMsgO ]; /* Setup for Message Out phase. */
3816:
3817: [ self RunDBDMA : kcclStart stageLabel : kcclStageInit ];
3818: }
3819: return;
3820: }/* end AbortDisconnectedCommand */
3821:
3822:
3823: - (void) logTimestamp : (const char*) reason
3824: {
3825: #if DEBUG
3826: /* kMaxTimestamp should be greater than twice the expected method depth */
3827: /* since, if we dump the timestamp after it has wrapped around, we expect */
3828: /* to lose earlier entries and, hence, the shallower method starts. */
3829: #ifndef kMaxTimestampStack
3830: #define kMaxTimestampStack 64
3831: #endif
3832:
3833: TimestampDataRecord stack[ kMaxTimestampStack + 1 ]; /* Allocate one extra */
3834: UInt32 index = 0;
3835: int start;
3836: UInt32 count = 0;
3837: UInt32 maxDepth = 0;
3838: Boolean wasEnabled, unused;
3839: char work[ 8 ];
3840: struct timeval tv;
3841: ns_time_t lastEventTime;
3842: UInt32 elapsed;
3843: UInt32 sinceMethodStart;
3844:
3845:
3846: if ( reason )
3847: {
3848: IOLog( "%s: *** Log timestamp: %s\n", [ self name ], reason );
3849: }
3850:
3851: /* In case something we call causes timestamping, */
3852: /* we want to avoid getting into an infinite loop. */
3853:
3854: wasEnabled = EnableTimestamp( FALSE );
3855: lastEventTime = 0;
3856: while ( ReadTimestamp( &stack[ index ] ) )
3857: {
3858: ++count;
3859: work[0] = stack[ index ].timestampTag >> 24 & 0xFF;
3860: work[1] = stack[ index ].timestampTag >> 16 & 0xFF;
3861: work[2] = stack[ index ].timestampTag >> 8 & 0xFF;
3862: work[3] = stack[ index ].timestampTag >> 0 & 0xFF;
3863: work[4] = '\0';
3864:
3865: elapsed = (unsigned)stack[ index ].eventTime - lastEventTime;
3866: lastEventTime = stack[ index ].eventTime;
3867: ns_time_to_timeval( stack[ index ].eventTime, &tv );
3868:
3869: switch ( work[0] )
3870: {
3871: case '+': /* Entering a method */
3872: IOLog( "%s: '%s' %u.%06u %u.%03u 0.0 %d\n",
3873: [ self name ], work,
3874: tv.tv_sec, tv.tv_usec,
3875: elapsed / 1000, elapsed - ((elapsed / 1000) * 1000),
3876: stack[ index ].timestampValue );
3877: if ( index < kMaxTimestampStack )
3878: { if ( ++index > maxDepth )
3879: maxDepth = index;
3880: }
3881: break;
3882:
3883: case '=': /* Intermediate tag: find the method start */
3884: case '-': /* End of method: find the method start */
3885: sinceMethodStart = 0;
3886: for ( start = index - 1; start >= 0; --start )
3887: {
3888: if ( (stack[ start ].timestampTag & 0x00FFFFFF)
3889: == (stack[ index ].timestampTag & 0x00FFFFFF) )
3890: {
3891: sinceMethodStart = (unsigned)stack[ index ].eventTime
3892: - stack[ start ].eventTime;
3893: break;
3894: }
3895: }
3896: IOLog( "%s: '%s' %u.%06u %u.%03u %u.%03u %d\n",
3897: [ self name ], work,
3898: tv.tv_sec, tv.tv_usec,
3899: elapsed / 1000, elapsed - ((elapsed / 1000) * 1000),
3900: sinceMethodStart / 1000,
3901: sinceMethodStart - ((sinceMethodStart / 1000) * 1000),
3902: stack[ index ].timestampValue );
3903: if ( start >= 0 && work[0] == '-' )
3904: index = start; /* Pop the stack */
3905: break;
3906:
3907: default:
3908: IOLog( "%s: '%s' %u.%06u %u.%03u 0.0 %d _NoNestMark_\n",
3909: [ self name ],
3910: work,
3911: tv.tv_sec,
3912: tv.tv_usec,
3913: elapsed / 1000,
3914: elapsed - ((elapsed / 1000) * 1000),
3915: stack[ index ].timestampValue );
3916: break;
3917: }
3918: }/* end WHILE */
3919:
3920: IOLog( "%s: *** %d timestamps, %d max method depth\n",
3921: [ self name ], count, maxDepth );
3922: unused = EnableTimestamp( wasEnabled );
3923: #endif /* DEBUG */
3924: return;
3925: }/* end logTimestamp */
3926:
3927: @end /* AppleMesh_SCSI(Mesh) */
3928:
3929:
3930: @implementation AppleMesh_SCSI( Private )
3931:
3932: /* Private chip- and architecture-independent methods. */
3933:
3934: /* Pass one CommandBuffer to the IO thread; wait for completion. */
3935: /* (We are called on the client's execution thread.) */
3936: /* Normal completion status is in cmdBuf->scsiReq->driverStatus; */
3937: /* a non-zero return from this function indicates a Mach IPC error. */
3938: /* This method allocates and frees cmdBuf->cmdLock. */
3939:
3940: - (IOReturn) executeCmdBuf : (CommandBuffer*) cmdBuf
3941: {
3942: msg_header_t msg = cmdMessageTemplate;
3943: kern_return_t kernelReturn;
3944: IOReturn ioReturn = IO_R_SUCCESS;
3945:
3946:
3947: cmdBuf->flagActive = 0;
3948: cmdBuf->cmdLock = [ [ NXConditionLock alloc ] initWith : CMD_PENDING ];
3949: [ incomingCmdLock lock ];
3950: queue_enter( &incomingCmdQ, cmdBuf, CommandBuffer*, link );
3951: [ incomingCmdLock unlock ];
3952: ELG( cmdBuf, *(UInt32*)&incomingCmdQ, 'ExeC', "executeCmdBuf" );
3953:
3954: /* Create a Mach message and send it in order to wake up the IO thread: */
3955:
3956: msg.msg_remote_port = gKernelInterruptPort;
3957: kernelReturn = msg_send_from_kernel( &msg, MSG_OPTION_NONE, 0 );
3958: if ( kernelReturn != KERN_SUCCESS )
3959: {
3960: PAUSE( 0, kernelReturn, 'exe-', "executeCmdBuf - msg_send_from_kernel() error status .\n" );
3961: ioReturn = IO_R_IPC_FAILURE;
3962: }
3963: else /* Wait for IO complete: */
3964: {
3965: [ cmdBuf->cmdLock lockWhen : CMD_COMPLETE ];
3966: }
3967:
3968: [ cmdBuf->cmdLock free ];
3969: return ioReturn;
3970: }/* end executeCmdBuf */
3971:
3972:
3973: /* Abort all active and disconnected commands with specified status. */
3974: /* No hardware action. Currently used by threadResetBus and during */
3975: /* processing of a kCommandAbortRequest command. */
3976:
3977: - (void) abortAllCommands : (sc_status_t)status
3978: {
3979: ELG( 0, status, 'AbAl', "abortAllCommands" );
3980: [ incomingCmdLock lock ];
3981:
3982: [ self killActiveCommand : status ];
3983:
3984: [ self killQueue : &abortCmdQ finalStatus : status ];
3985: [ self killQueue : &disconnectedCmdQ finalStatus : status ];
3986: [ self killQueue : &pendingCmdQ finalStatus : status ];
3987: [ self killQueue : &incomingCmdQ finalStatus : status ];
3988:
3989: [ incomingCmdLock unlock ];
3990: return;
3991: }/* end abortAllCommands */
3992:
3993:
3994: /* Abort all active and disconnected commands with status SR_IOST_RESET. */
3995: /* Reset hardware and SCSI bus. */
3996: /* If there is a command in pendingCmdQ, start it up. */
3997:
3998: - (void) threadResetBus : (const char*) reason
3999: {
4000: [ self abortAllCommands : SR_IOST_RESET ];
4001: [ self ResetHardware : TRUE ]; /* Reset SCSI and chip */
4002: [ self selectNextRequest ]; /* This restarts processing commands */
4003: return;
4004: }/* end threadResetBus */
4005:
4006:
4007: /* Commence processing of the specified command. This is called by */
4008: /* commandRequestOccurred when it receives a kCommandExecute message */
4009: /* from IODirectDevice. There is a new SCSI request. Either start it */
4010: /* now, or add it to the end of our pending request queue. */
4011:
4012: - (void) threadExecuteRequest : (CommandBuffer*) cmdBuf
4013: {
4014: HardwareStartResult rc;
4015:
4016:
4017: if ( gActiveCommand || (g.intLevel & kLevelLatched) )
4018: {
4019: /* We are currently executing a request. */
4020:
4021: ELG( gActiveCommand, cmdBuf, 'Busy', "threadExecuteRequest - bus busy so queue this cmd" );
4022: queue_enter( &pendingCmdQ, cmdBuf, CommandBuffer*, link );
4023: }
4024: else if ( [ self commandCanBeStarted : cmdBuf ] == FALSE )
4025: {
4026: /* This request can't be started right now (perhaps the */
4027: /* target's tagged command limit has been reached). */
4028:
4029: ELG( cmdBuf, 0, 'qFul', "threadExecuteRequest - can't start cmd so queue this cmd" );
4030: queue_enter( &pendingCmdQ, cmdBuf, CommandBuffer*, link );
4031: }
4032: else
4033: { /* Apparently, we can start this request. Call the hardware layer. */
4034:
4035: rc = [ self hardwareStart : cmdBuf ];
4036: switch ( rc )
4037: {
4038: case kHardwareStartOK: /* Command started correctly */
4039: case kHardwareStartBusy: /* Hardware can't start now */
4040: break;
4041: case kHardwareStartRejected: /* Command rejected, try another */
4042: [ self selectNextRequest ]; /* Try another command */
4043: }
4044: }
4045: return;
4046: }/* end threadExecuteRequest */
4047:
4048:
4049: /* Called when a transaction associated with cmdBuf is complete. */
4050: /* Notify waiting thread. If cmdBuf->scsiReq exists (i.e., this */
4051: /* is not a reset or an abort), scsiReq->driverStatus must be valid.*/
4052: /* If cmdBuf is active, caller must remove from gActiveCommand. */
4053: /* We decrement activeArray[][] counter if appropriate. */
4054:
4055: - (void) ioComplete : (CommandBuffer*) cmdBuf
4056: {
4057: ns_time_t currentTime;
4058: IOSCSIRequest *scsiReq;
4059:
4060:
4061: ASSERT( cmdBuf );
4062: ELG( cmdBuf->scsiReq, cmdBuf->scsiReq->driverStatus, ' IOC', "ioComplete" );
4063:
4064: if ( cmdBuf == gActiveCommand )
4065: [ self deactivateCmd : cmdBuf ];
4066:
4067: scsiReq = cmdBuf->scsiReq;
4068: if ( scsiReq )
4069: {
4070: IOGetTimestamp( ¤tTime );
4071: scsiReq->totalTime = currentTime - cmdBuf->startTime;
4072: scsiReq->bytesTransferred = cmdBuf->currentDataIndex;
4073:
4074: /* Catch bad SCSI status now. */
4075:
4076: if ( scsiReq->driverStatus == SR_IOST_GOOD )
4077: {
4078: if ( cmdBuf->flagIsAutosense )
4079: {
4080: /* We are completing an autosense command. Don't touch */
4081: /* the request status (it should still be Check Condition). */
4082: /* Queue full is a real problem. */
4083:
4084: ASSERT( scsiReq->scsiStatus == kScsiStatusCheckCondition );
4085: switch ( cmdBuf->autosenseStatus )
4086: {
4087: case kScsiStatusGood:
4088: scsiReq->driverStatus = SR_IOST_CHKSV;
4089: break;
4090:
4091: case kScsiStatusQueueFull:
4092: if ( [ self pushbackFullTargetQueue : cmdBuf ] == SR_IOST_GOOD)
4093: {
4094: return; /* We'll try this one again */
4095: }
4096: /* Fall through to failure */
4097:
4098: default:
4099: scsiReq->driverStatus = SR_IOST_CHKSNV;
4100: break;
4101: }
4102: }
4103: else /* not AutoSense: */
4104: {
4105: switch ( scsiReq->scsiStatus )
4106: {
4107: case kScsiStatusGood:
4108: break;
4109:
4110: case kScsiStatusCheckCondition:
4111:
4112: /***** The 386 hardware suppresses autosense for ****/
4113: /***** Test Unit Ready to avoid request sense ****/
4114: /***** when polling for removable devices. This ****/
4115: /***** should be the caller's decision. ****/
4116:
4117: ELG( 0, 0, 'Chek', "ioComplete - Check Condition" );
4118: if ( gOptionAutoSenseEnable
4119: && (scsiReq->ignoreChkcond == FALSE) )
4120: {
4121: cmdBuf->flagIsAutosense = 1;/* We're doing autosense */
4122: queue_enter_first( &pendingCmdQ, cmdBuf, CommandBuffer*, link );
4123: return;
4124: }
4125: else
4126: { /* This command failed and we aren't doing autosense. */
4127: scsiReq->driverStatus = SR_IOST_CHKSNV;
4128: }
4129: break;
4130:
4131: case kScsiStatusQueueFull:
4132: if ( [ self pushbackFullTargetQueue : cmdBuf ] == SR_IOST_GOOD)
4133: {
4134: return;
4135: }
4136: /* Huh? we weren't doing tagged queuing, fall through */
4137:
4138: default:
4139: scsiReq->driverStatus = SR_IOST_BADST;
4140: break;
4141: }/* end SWITCH on SCSI status */
4142:
4143: }/* end IF driverStatus is SR_IOST_GOOD */
4144: }/* end IF not autosense */
4145: }/* end IF have scsiReq */
4146:
4147: if ( cmdBuf->flagActive )
4148: { /* Note that the active flag is false for non-kCommandExecute */
4149: /* commands and commands aborted from pendingCmdQ. */
4150:
4151: ASSERT( cmdBuf == gActiveCommand );
4152: [ self deactivateCmd : cmdBuf ];
4153: }
4154:
4155: [ cmdBuf->cmdLock lock ];
4156: [ cmdBuf->cmdLock unlockWith : YES ];
4157:
4158: return;
4159: }/* end ioComplete */
4160:
4161:
4162: /* A target reported a full queue. Push this command back */
4163: /* on the pending queue and try it again, later. */
4164: /* Return SR_IOST_GOOD if successful, SR_IOST_BADST on failure. */
4165:
4166: - (sc_status_t) pushbackFullTargetQueue : (CommandBuffer*) cmdBuf
4167: {
4168: IOSCSIRequest *scsiReq;
4169: int target, lun;
4170: IOReturn ioReturn;
4171:
4172:
4173: ASSERT( cmdBuf && cmdBuf->scsiReq );
4174: /* Avoid notifying client of this condition; update */
4175: /* perTarget.maxQueue and place this request on pendingCmdQ. */
4176: /* We'll try this again when we ioComplete at least one */
4177: /* command in this target's queue. */
4178: /* Note that this can execute commands out of order. */
4179: /* This can be disastrous for directory commands. */
4180: /* In the long run, the client (disk/tape/whatever) */
4181: /* needs to tell us how to execute the command */
4182: /* (in-order, out-of-order, etc.) For example, */
4183: /* virtual-memory page faults can be executed */
4184: /* out of order, but directory and volume bitmap */
4185: /* updates must be executed in-order to preserve */
4186: /* volume integrity. */
4187: if ( cmdBuf->queueTag == QUEUE_TAG_NONTAGGED )
4188: {
4189: /* Huh? We're not doing command queueing... */
4190: ioReturn = SR_IOST_BADST;
4191: }
4192: else
4193: {
4194: scsiReq = cmdBuf->scsiReq;
4195: target = scsiReq->target;
4196: lun = scsiReq->lun;
4197: gPerTargetData[ target ].maxQueue = gActiveArray[ target ][ lun ];
4198: [ self pushbackCurrentRequest : cmdBuf ];
4199: ioReturn = SR_IOST_GOOD;
4200: }
4201: return ioReturn;
4202: }/* end pushbackFullTargetQueue */
4203:
4204:
4205: /* Push this request back on the pending queue. */
4206:
4207: - (void) pushbackCurrentRequest : (CommandBuffer*) cmdBuf
4208: {
4209: ASSERT( cmdBuf );
4210: if ( cmdBuf->flagActive )
4211: {
4212: ASSERT( cmdBuf == gActiveCommand );
4213: [ self deactivateCmd : cmdBuf ];
4214: }
4215: queue_enter_first( &pendingCmdQ, cmdBuf, CommandBuffer*, link );
4216: return;
4217: }/* end pushbackCurrentRequest */
4218:
4219:
4220: /* Kill a request that can't be continued. */
4221:
4222: - (void) killCurrentRequest
4223: {
4224: CommandBuffer *cmdBuf;
4225: IOSCSIRequest *scsiReq;
4226:
4227:
4228: if ( gActiveCommand )
4229: {
4230: cmdBuf = gActiveCommand;
4231: ASSERT( cmdBuf->scsiReq );
4232: scsiReq = cmdBuf->scsiReq;
4233:
4234: if ( cmdBuf->flagRequestSelectOK == FALSE )
4235: scsiReq->driverStatus = SR_IOST_SELTO; /* No such device */
4236: else scsiReq->driverStatus = SR_IOST_HW; /* Target went away */
4237:
4238: [ self deactivateCmd : cmdBuf ];
4239: [ self ioComplete : cmdBuf ];
4240: }
4241: return;
4242: }/* end killCurrentRequest */
4243:
4244:
4245: /* IO associated with gActiveCommand has disconnected. */
4246: /* Place it on the disconnected command queue and */
4247: /* enable another transaction. */
4248:
4249: - (void) disconnect
4250: {
4251: ASSERT( gActiveCommand );
4252: queue_enter( &disconnectedCmdQ, gActiveCommand, CommandBuffer*, link );
4253:
4254:
4255: /* Record this time so that gActiveCommand can be billed */
4256: /* for disconnect latency at reselect time. */
4257:
4258: IOGetTimestamp( &gActiveCommand->disconnectTime );
4259: gActiveCommand = NULL;
4260: gCurrentTarget = kInvalidTarget;
4261: gCurrentLUN = kInvalidLUN;
4262:
4263: /* Since there is no active command, the caller */
4264: /* must configure the bus interface to wait for */
4265: /* bus free, then allow reselection. */
4266:
4267: return;
4268: }/* end disconnect */
4269:
4270:
4271: /* The specified target, LUN, and queueTag is trying to reselect. */
4272: /* If we have a CommandBuffer for this TLQ nexus on disconnectQ, */
4273: /* remove it, make it the current gActiveCommand, and return YES. */
4274: /* Else return NO. A value of zero for queueTag indicates a */
4275: /* nontagged command (zero is never used as the queue tag value for */
4276: /* a tagged command). */
4277:
4278: - (IOReturn) reselectNexus : (UInt8) target
4279: lun : (UInt8) lun
4280: queueTag : (UInt8) queueTag
4281: {
4282: CommandBuffer *cmdBuf;
4283: IOSCSIRequest *scsiReq;
4284: ns_time_t currentTime;
4285: IOReturn ioReturn = SR_IOST_BV; /* Presume failure */
4286:
4287:
4288: /* Scan the disconnected queue looking for */
4289: /* a command for this nexus. */
4290:
4291: ASSERT( gActiveCommand == NULL );
4292:
4293: cmdBuf = (CommandBuffer*)queue_first( &disconnectedCmdQ );
4294:
4295: while ( !queue_end( &disconnectedCmdQ, (queue_t)cmdBuf ) )
4296: {
4297: scsiReq = cmdBuf->scsiReq;
4298: if (scsiReq->target == target
4299: && scsiReq->lun == lun
4300: && cmdBuf->queueTag == queueTag )
4301: {
4302: /* We found the correct command. */
4303:
4304: queue_remove( &disconnectedCmdQ, cmdBuf, CommandBuffer*, link );
4305: gActiveCommand = cmdBuf;
4306: ASSERT( scsiReq->target == gCurrentTarget && scsiReq->lun == gCurrentLUN );
4307:
4308: /* Bill this operation for latency time: */
4309:
4310: IOGetTimestamp( ¤tTime );
4311: scsiReq->latentTime += (currentTime - gActiveCommand->disconnectTime);
4312: ioReturn = IO_R_SUCCESS;
4313: break;
4314: }
4315: /* Try next element in queue. */
4316:
4317: cmdBuf = (CommandBuffer*)cmdBuf->link.next;
4318: }/* end WHILE */
4319:
4320: return ioReturn;
4321: }/* end reselectNexus */
4322:
4323:
4324: /* Determine if gActiveArray[][], maxQueue, cmdQueueEnable, and a cmd's */
4325: /* Target and LUN show that it's OK to start processing cmdBuf. */
4326: /* Returns YES if this command can be started. */
4327: /***** Here's where we can test for a frozen LUN queue. *****/
4328:
4329: - (Boolean) commandCanBeStarted : (CommandBuffer*) cmdBuf
4330: {
4331: IOSCSIRequest *scsiReq;
4332: unsigned target;
4333: unsigned lun;
4334: UInt8 active;
4335: UInt8 maxQ;
4336: Boolean result;
4337:
4338:
4339: ASSERT( cmdBuf && cmdBuf->scsiReq );
4340:
4341: scsiReq = cmdBuf->scsiReq;
4342: target = scsiReq->target;
4343: lun = scsiReq->lun;
4344: active = gActiveArray[ target ][ lun ];
4345: if ( active == 0 )
4346: { /* No commands are active for this target, always ok. */
4347: result = TRUE;
4348: }
4349: else if ( gOptionCmdQueueEnable == FALSE
4350: || ((gPerTargetData[ target ].inquiry_7 & 0x02) == 0) )
4351: {
4352: ELG( active, gOptionCmdQueueEnable, 'CQE-', "commandCanBeStarted - cmd q'n disabled" );
4353: result = FALSE; /* q'ing is disabled for target (or disabled globally) */
4354: }
4355: else
4356: {
4357: maxQ = gPerTargetData[ target ].maxQueue;
4358: if ( maxQ == 0 || active < maxQ )
4359: { /* If maxQ is zero, we haven't reached the target's limit. */
4360: /* Otherwise, we're under the limit. */
4361: /* In both cases, we can (presumably) start this command. */
4362:
4363: result = TRUE;
4364: }
4365: else
4366: {
4367: ELG( maxQ, active, 'QLm-', "commandCanBeStarted - queue limit reached." );
4368: result = FALSE; /* We're over the target limit. Wait on this one. */
4369: }
4370: }
4371: return result;
4372: }/* end commandCanBeStarted */
4373:
4374:
4375: /* The bus has gone free. Start up a command from pendingCmdQ, */
4376: /* if any, and if allowed by cmdQueueEnable and gActiveArray[][]. */
4377: /* This is called from the interrupt routine when it is about to exit */
4378: /* (and the bus is free and there is no active command). It may also */
4379: /* be called from threadExecuteRequest when the selected command */
4380: /* couldn't be started. */
4381:
4382: - (void) selectNextRequest
4383: {
4384: CommandBuffer *cmdBuf = NULL;
4385: Boolean foundRequest = FALSE;
4386:
4387:
4388: if ( !queue_empty( &abortCmdQ ) )
4389: {
4390: [ self AbortDisconnectedCommand ];
4391: return;
4392: }
4393:
4394: if ( !queue_empty( &pendingCmdQ ) )
4395: {
4396: /* Attempt to find a CommandBuffer in pendingCmdQ */
4397: /* which we are in a position to process: */
4398:
4399: cmdBuf = (CommandBuffer*)queue_first( &pendingCmdQ );
4400: while ( !queue_end( &pendingCmdQ, (queue_entry_t)cmdBuf ) )
4401: {
4402: if ( [ self commandCanBeStarted : cmdBuf ] )
4403: {
4404: queue_remove( &pendingCmdQ, cmdBuf, CommandBuffer*, link);
4405: ELG( cmdBuf, cmdBuf->scsiReq->lun<<16 | cmdBuf->scsiReq->target, 'De Q', "selectNextRequest - dequeued one." );
4406: foundRequest = TRUE;
4407: break;
4408:
4409: /* Note that threadExecuteRequest may call selectNextRequest */
4410: /* if the command was rejected. If so, the rejected */
4411: /* command will have been returned (with an error */
4412: /* status) to its client, so there is no chance of */
4413: /* an infinite loop here. */
4414: }
4415: else
4416: {
4417: cmdBuf = (CommandBuffer*)queue_next( &cmdBuf->link );
4418: }
4419: }/* end WHILE */
4420: }/* end IF queue not empty */
4421:
4422: if ( foundRequest )
4423: [ self threadExecuteRequest : cmdBuf ];
4424:
4425: return;
4426: }/* end selectNextRequest */
4427:
4428:
4429: - (void) killActiveCommand : (sc_status_t)status
4430: {
4431: ELG( gActiveCommand, status, 'KilA', "killActiveCommand" );
4432: if ( gActiveCommand )
4433: {
4434: gActiveCommand->scsiReq->driverStatus = status;
4435: [ self ioComplete : gActiveCommand ];
4436: gActiveCommand = NULL;
4437: gCurrentTarget = kInvalidTarget;
4438: gCurrentLUN = kInvalidLUN;
4439: }
4440: return;
4441: }/* end killActiveCommand */
4442:
4443:
4444: /* Called by chip level to indicate that a command */
4445: /* has gone out to the hardware. */
4446:
4447: - (void) activateCommand : (CommandBuffer*)cmdBuf
4448: {
4449: ASSERT( gActiveCommand == NULL );
4450:
4451: /* This is the only place where a gActiveArray[][] counter */
4452: /* is incremented (and, hence, the only place where */
4453: /* cmdBuf->active is set). The only other place gActiveCommand */
4454: /* is set to non-NULL is in reselectNexus:target:lun:queueTag */
4455: /* (but that doesn't increment the active command counter) */
4456:
4457: gActiveCommand = cmdBuf;
4458: gCurrentTarget = cmdBuf->scsiReq->target;
4459: gCurrentLUN = cmdBuf->scsiReq->lun;
4460: gActiveArray[ gCurrentTarget ][ gCurrentLUN ]++;
4461: gActiveCount++;
4462:
4463: cmdBuf->flagActive = TRUE;
4464:
4465: /* Accumulate statistics. */
4466:
4467: gMaxQueueLen = MAX( gMaxQueueLen, gActiveCount );
4468: gQueueLenTotal += gActiveCount;
4469: gTotalCommands++;
4470: return;
4471: }/* end activateCommand */
4472:
4473:
4474: /* Remove specified cmdBuf from "active" status. */
4475: /* Update activeArray, activeCount, and unschedule pending timer. */
4476:
4477: - (void) deactivateCmd : (CommandBuffer*)cmdBuf
4478: {
4479: IOSCSIRequest *scsiReq;
4480: unsigned target, lun;
4481:
4482:
4483: ASSERT( cmdBuf && cmdBuf->scsiReq );
4484: ASSERT( cmdBuf == gActiveCommand ); /* ?? */
4485: gActiveCommand = NULL;
4486: gCurrentTarget = kInvalidTarget;
4487: gCurrentLUN = kInvalidLUN;
4488: scsiReq = cmdBuf->scsiReq;
4489: target = scsiReq->target;
4490: lun = scsiReq->lun;
4491:
4492: ASSERT( gActiveArray[ target ][ lun ] );
4493: gActiveArray[ target ][ lun ]--;
4494: ASSERT( gActiveCount );
4495: gActiveCount--;
4496:
4497: /* Cancel pending timeout request. */
4498: /* Commands which timed out don't have a timer request pending anymore. */
4499:
4500: if ( scsiReq->driverStatus != SR_IOST_IOTO )
4501: {
4502: IOUnscheduleFunc( serviceTimeoutInterrupt, cmdBuf );
4503: }
4504: cmdBuf->flagActive = FALSE;
4505: return;
4506: }/* end deactivateCmd */
4507:
4508:
4509: /* Kill everything in the indicated queue. Called after bus reset. */
4510:
4511: - (void) killQueue : (queue_head_t*)queuePtr finalStatus : (sc_status_t)scsiStatus
4512: {
4513: CommandBuffer *cmdBuf;
4514:
4515:
4516: ELG( 0, queuePtr, 'KilQ', "killQueue" );
4517: while ( !queue_empty( queuePtr ) )
4518: {
4519: cmdBuf = (CommandBuffer*)queue_first( queuePtr );
4520: queue_remove( queuePtr, cmdBuf, CommandBuffer*, link );
4521: cmdBuf->scsiReq->driverStatus = scsiStatus;
4522: [ self ioComplete : cmdBuf ];
4523: }
4524: return;
4525: }/* end killQueue */
4526:
4527:
4528: - (void) UpdateCurrentIndex
4529: {
4530: CommandBuffer *cmdBuf = gActiveCommand;
4531: IOSCSIRequest *scsiReq = cmdBuf->scsiReq;
4532: UInt32 count; /* DMA transfer count */
4533: UInt32 length = g.shadow.mesh.FIFOCount;
4534: UInt8 buffer[ 16 ];
4535: UInt32 i;
4536:
4537: /* Calculate the number of bytes xferred by this channel command. */
4538: /* We don't trust the DBDMA residual count. */
4539:
4540: count = CCLWord( kcclBatchSize ); /* Our transfer count */
4541: if ( count == 0 ) /* If batch is empty, */
4542: return; /* look at nothing else.*/
4543: count -= g.shadow.mesh.transferCount1 << 8; /* MESH residual high */
4544: count -= g.shadow.mesh.transferCount0; /* MESH residual low */
4545: cmdBuf->currentDataIndex += count; /* Increment data index */
4546: if ( cmdBuf->mem )
4547: [ cmdBuf->mem setPosition : cmdBuf->currentDataIndex ];
4548: CCLWord( kcclBatchSize ) = 0; /* Clear our count */
4549:
4550: /* Check the FIFO, if empty, increment the current data pointer. */
4551: /* If there is stuff in it, we have more work to do. */
4552:
4553: if ( g.shadow.mesh.FIFOCount ) /* If data in FIFO: */
4554: {
4555: if ( scsiReq->read == FALSE ) /* If Writing: */
4556: {
4557: [ self SetSeqReg : kMeshFlushFIFO ];
4558: /* We didn't write these bytes in the FIFO - adjust index */
4559: cmdBuf->currentDataIndex -= g.shadow.mesh.FIFOCount;
4560: if ( cmdBuf->mem )
4561: [ cmdBuf->mem setPosition : cmdBuf->currentDataIndex ];
4562:
4563: }
4564: else /* Must be Reading: */
4565: { /* On a Read with data left in the FIFO, we must copy */
4566: /* the FIFO directly into the user's data buffer: */
4567:
4568: ELG( cmdBuf->currentDataIndex, g.shadow.mesh.FIFOCount, 'FIFO',
4569: "UpdateCurrentIndex - copy FIFO to user buffer." );
4570: [ cmdBuf->mem setPosition : cmdBuf->currentDataIndex ];
4571: count = scsiReq->maxTransfer - cmdBuf->currentDataIndex;
4572: if ( count > length )
4573: count = length;
4574:
4575: /* FYI - emptying the FIFO causes cmdDone to get set. */
4576:
4577: for ( i = 0; i < count; i++ )
4578: buffer[ i ] = meshAddr->xFIFO;
4579:
4580: [ cmdBuf->mem writeToClient : buffer count : count ];
4581: cmdBuf->currentDataIndex += count;
4582: [ cmdBuf->mem setPosition : cmdBuf->currentDataIndex ];
4583: }/* end if/ELSE must be Reading */
4584: }/* end IF FIFO was not empty */
4585: ELG( 0, cmdBuf->currentDataIndex, 'UpIx', "UpdateCurrentIndex" );
4586: return;
4587: }/* end UpdateCurrentIndex */
4588:
4589:
4590: @end /* AppleMesh_SCSI( Private ) */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.