![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Sym8xxClient.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Drivers / scsi / drvSymbios8xx|
Return to Sym8xxClient.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Drivers / scsi / drvSymbios8xx |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22:
23: /* Sym8xxClient.m created by russb2 on Sat 30-May-1998 */
24:
25: #include "Sym8xxController.h"
26:
27: extern pmap_t kernel_pmap;
28:
29:
30: /*-----------------------------------------------------------------------------*
31: *
32: *-----------------------------------------------------------------------------*/
33: void Sym8xxSCSIController::executeCommand( IOSCSICommand *scsiCommand )
34: {
35: SRB *srb = NULL;
36: SCSICDBInfo scsiCDB;
37: SCSITargetLun targetLun;
38: Nexus *nexus;
39: Nexus *nexusPhys;
40: UInt32 len;
41: bool isWrite;
42:
43: srb = (SRB *) scsiCommand->getCommandData();
44: bzero( srb, sizeof(SRB) );
45:
46: srb->srbPhys = (SRB *) pmap_extract( kernel_pmap, (vm_offset_t) srb );
47: srb->scsiCommand = scsiCommand;
48:
49: scsiCommand->getCDB( &scsiCDB );
50: scsiCommand->getTargetLun( &targetLun );
51:
52: nexus = &srb->nexus;
53: nexusPhys = &srb->srbPhys->nexus;
54:
55: srb->target = targetLun.target;
56: srb->lun = targetLun.lun;
57: srb->srbCDBFlags = scsiCDB.cdbFlags;
58:
59: /*
60: * Setup the Nexus struct. This part of the SRB is read/written both by the
61: * script and the driver.
62: */
63: nexus->targetParms.target = srb->target;
64:
65: // printf( "SCSI(Symbios8xx): executeCommand: T/L = %d:%d Cmd = %08x CmdType = %d\n\r",
66: // targetLun.target, targetLun.lun, (int)scsiCommand, scsiCommand->getCmdType() );
67:
68: switch ( scsiCommand->getCmdType() )
69: {
70: case kSCSICommandAbort:
71: case kSCSICommandAbortAll:
72: case kSCSICommandDeviceReset:
73: Sym8xxAbortCommand( scsiCommand );
74: return;
75:
76: default:
77: ;
78: }
79:
80: /*
81: * Set client data buffer pointers in the SRB
82: */
83: scsiCommand->getPointers( &srb->xferDesc, &srb->xferCount, &isWrite );
84:
85: srb->directionMask = (isWrite) ? 0x00000000 :0x01000000;
86:
87: nexus->cdb.ppData = OSSwapHostToLittleInt32((UInt32)&nexusPhys->cdbData);
88:
89: len = scsiCDB.cdbLength;
90:
91: nexus->cdb.length = OSSwapHostToLittleInt32( len );
92: nexus->cdbData = scsiCDB.cdb;
93:
94: Sym8xxCalcMsgs( scsiCommand );
95:
96: /*
97: * Setup initial data transfer list (SGList)
98: */
99: nexus->ppSGList = (SGEntry *)OSSwapHostToLittleInt32((UInt32)&nexusPhys->sgListData[2]);
100: Sym8xxUpdateSGList( srb );
101:
102: Sym8xxStartSRB( srb );
103: }
104:
105:
106: /*-----------------------------------------------------------------------------*
107: * This routine queues an SRB to reset the SCSI Bus
108: *
109: *-----------------------------------------------------------------------------*/
110: void Sym8xxSCSIController::resetCommand( IOSCSICommand *scsiCommand )
111: {
112: SRB *srb;
113:
114: // printf( "SCSI(Symbios8xx): resetCommand\n\r" );
115:
116: srb = (SRB *) scsiCommand->getCommandData();
117: bzero( srb, sizeof(SRB) );
118:
119: srb->srbPhys = (SRB *) pmap_extract( kernel_pmap, (vm_offset_t) srb );
120: srb->scsiCommand = scsiCommand;
121:
122: Sym8xxSCSIBusReset( srb );
123: }
124:
125: /*-----------------------------------------------------------------------------*
126: *
127: *-----------------------------------------------------------------------------*/
128: void Sym8xxSCSIController::cancelCommand( IOSCSICommand *scsiCommand )
129: {
130: IOSCSICommand *origCommand;
131: SRB *srb;
132: SCSITargetLun targetLun;
133: SCSIResults scsiResults;
134:
135: origCommand = scsiCommand->getOriginalCmd();
136: srb = (SRB *)origCommand->getCommandData();
137:
138: switch ( origCommand->getCmdType() )
139: {
140: case kSCSICommandAbort:
141: case kSCSICommandAbortAll:
142: case kSCSICommandDeviceReset:
143: if ( abortSRB == srb )
144: {
145: SCRIPT_VAR(R_ld_AbortBdr_mailbox) = 0;
146: abortSRB = 0;
147:
148: origCommand->complete();
149: }
150: break;
151:
152: default:
153:
154: if ( adapter->nexusPtrsVirt[srb->nexus.tag] == &srb->nexus )
155: {
156: adapter->nexusPtrsVirt[srb->nexus.tag] = (Nexus *) -1;
157: adapter->nexusPtrsPhys[srb->nexus.tag] = (Nexus *) -1;
158:
159: origCommand->complete();
160: }
161: else
162: {
163: origCommand->getTargetLun( &targetLun );
164: origCommand->complete();
165:
166: IOLog( "SCSI(Symbios8xx): Aborted SRB not found - T/L = %d:%d\n\r", targetLun.target, targetLun.lun );
167: }
168: }
169:
170: bzero( &scsiResults, sizeof(scsiResults) );
171: scsiCommand->setResults( &scsiResults );
172: scsiCommand->complete();
173: }
174:
175: /*-----------------------------------------------------------------------------*
176: *
177: *
178: *
179: *
180: *-----------------------------------------------------------------------------*/
181: void Sym8xxSCSIController::Sym8xxAbortCommand( IOSCSICommand *scsiCommand )
182: {
183: SRB *srb;
184: SCSICDBInfo scsiCDB;
185: SCSITargetLun targetLun;
186:
187:
188: scsiCommand->getTargetLun( &targetLun );
189:
190: switch ( scsiCommand->getCmdType() )
191: {
192: case kSCSICommandAbort:
193: srb = (SRB *)scsiCommand->getOriginalCmd()->getCommandData();
194: Sym8xxCancelMailBox( &srb->srbPhys->nexus );
195: break;
196:
197: case kSCSICommandAbortAll:
198: Sym8xxCancelMailBox( targetLun.target, targetLun.lun, false );
199: break;
200:
201: case kSCSICommandDeviceReset:
202: Sym8xxCancelMailBox( targetLun.target, (UInt32) -1, false );
203: break;
204:
205: default:
206: ;
207: }
208:
209: if ( abortSRB )
210: {
211: abortReqPending = true;
212:
213: rescheduleCommand( scsiCommand );
214: disableCommands();
215: return;
216: }
217:
218: scsiCommand->getCDB( &scsiCDB );
219:
220: srb = (SRB *) scsiCommand->getCommandData();
221:
222: srb->nexus.msgData[0] = srb->lun | ((srb->srbCDBFlags & kCDBFlagsNoDisconnect ) ? 0x80 : 0xC0);
223:
224: if ( scsiCDB.cdbTagMsg != 0 )
225: {
226: srb->nexus.tag = scsiCDB.cdbTag + 128;
227: srb->nexus.msgData[1] = srb->nexus.tag;
228: }
229: else
230: {
231: srb->nexus.tag = ((UInt32)srb->target << 3) | srb->lun;
232: srb->nexus.msgData[1] = 0;
233: }
234: srb->tag = srb->nexus.tag;
235:
236: srb->nexus.msgData[2] = scsiCDB.cdbAbortMsg;
237:
238: Sym8xxAbortBdr( srb );
239: }
240:
241:
242: /*-----------------------------------------------------------------------------*
243: * This routine creates SCSI messages to send during the initial connection
244: * to the target. It is called during client request processing and also by
245: * the I/O thread when a request sense operation is required.
246: *
247: * Outbound messages are setup in the MsgOut buffer in the Nexus structure of
248: * the SRB.
249: *
250: *-----------------------------------------------------------------------------*/
251: void Sym8xxSCSIController::Sym8xxCalcMsgs( IOSCSICommand *scsiCommand )
252: {
253: SRB *srb;
254: Nexus *nexus;
255: Nexus *nexusPhys;
256: UInt32 msgIndex;
257: SCSICDBInfo scsiCDB;
258: SCSITargetParms targetParms;
259: UInt32 i;
260: UInt32 tw;
261:
262:
263: srb = (SRB *)scsiCommand->getCommandData();
264: nexus = &srb->nexus;
265: nexusPhys = &srb->srbPhys->nexus;
266:
267: scsiCommand->getCDB( &scsiCDB );
268:
269: /*
270: * Setup Identify message
271: */
272: msgIndex = 0;
273: nexus->msg.ppData = OSSwapHostToLittleInt32((UInt32)&nexusPhys->msgData);
274: nexus->msgData[msgIndex++] = srb->lun | (( scsiCDB.cdbFlags & kCDBFlagsNoDisconnect ) ? 0x80 : 0xC0);
275:
276: /*
277: * Allocate tag for request.
278: *
279: * For non-tagged requests a pseudo-tag is created consisting of target*16+lun. For tagged
280: * requests a tag in the range 128-255 is allocated.
281: *
282: * If a pseudo-tag is inuse for a non-tagged command or there are no tags available for
283: * a tagged request, then the command is blocked until a tag becomes available.
284: *
285: * Note: If we are being called during request sense processing (srbState != ksrbStateCDBDone)
286: * then a tag has already been allocated to the request.
287: */
288: if ( scsiCDB.cdbTagMsg != 0 )
289: {
290: nexus->msgData[msgIndex++] = scsiCDB.cdbTagMsg;
291: nexus->msgData[msgIndex++] = srb->tag = srb->nexus.tag = scsiCDB.cdbTag + 128;
292: }
293: else
294: {
295: srb->tag = srb->nexus.tag = ((UInt32)srb->target << 3) | srb->lun;
296: }
297: /*
298: * Setup to negotiate for Wide (16-bit) data transfers
299: *
300: * Note: There is no provision to negotiate back to narrow transfers although
301: * SCSI does support this.
302: */
303:
304: scsiCommand->getDevice(kIOSCSIDevice)->getTargetParms( &targetParms );
305:
306: if ( scsiCDB.cdbFlags & kCDBFlagsNegotiateWDTR )
307: {
308: nexus->msgData[msgIndex++] = kSCSIMsgExtended;
309: nexus->msgData[msgIndex++] = 2;
310: nexus->msgData[msgIndex++] = kSCSIMsgWideDataXferReq;
311:
312: for ( tw = targetParms.transferWidth, i = (UInt32)-1;
313: tw;
314: tw >>= 1, i++ )
315: ;
316:
317: nexus->msgData[msgIndex++] = i;
318: }
319:
320: /*
321: * Setup to negotiate for Synchronous data transfers.
322: *
323: * Note: We can negotiate back to async based on the flags in the command.
324: */
325:
326: if ( scsiCDB.cdbFlags & kCDBFlagsNegotiateSDTR )
327: {
328: nexus->msgData[msgIndex++] = kSCSIMsgExtended;
329: nexus->msgData[msgIndex++] = 3;
330: nexus->msgData[msgIndex++] = kSCSIMsgSyncXferReq;
331: if ( targetParms.transferOffset != 0 )
332: {
333: nexus->msgData[msgIndex++] = targetParms.transferPeriodpS / 4000;
334: nexus->msgData[msgIndex++] = targetParms.transferOffset;
335: }
336: else
337: {
338: nexus->msgData[msgIndex++] = 0;
339: nexus->msgData[msgIndex++] = 0;
340: }
341:
342: }
343:
344: /*
345: * If we are negotiating for both Sync and Wide data transfers, we setup both messages
346: * in the Nexus msgOut buffer. However, after each message the script needs to wait for
347: * a reply message from the target. In this case, we set the msgOut length to include
348: * bytes upto the end of the Wide message. When we get the reply from the target, the
349: * routine handling the WDTR will setup the Nexus pointers/counts to send the remaining
350: * message bytes. See Sym8xxExecute.m(Sym8xxNegotiateWDTR).
351: */
352: srb->srbMsgLength = msgIndex;
353:
354: if ((scsiCDB.cdbFlags & (kCDBFlagsNegotiateWDTR | kCDBFlagsNegotiateSDTR))
355: == (kCDBFlagsNegotiateWDTR | kCDBFlagsNegotiateSDTR))
356: {
357: msgIndex -= 5;
358: }
359:
360: nexus->msg.length = OSSwapHostToLittleInt32( msgIndex );
361:
362: srb->srbCDBFlags = scsiCDB.cdbFlags;
363: }
364:
365: /*-----------------------------------------------------------------------------*
366: * This routine sets up the data transfer SG list for the client's buffer in the
367: * Nexus structure.
368: *
369: * The SGList actually consists of script instructions. The script will branch
370: * to the SGList when the target enters data transfer phase. When the SGList completes
371: * it will either execute a script INT instruction if there are more segments of the
372: * user buffer that need to be transferred or will execute a script RETURN instruction
373: * to return to the script.
374: *
375: * The first two slots in the SGList are reserved for partial data transfers. See
376: * Sym8xxExecute.m(Sym8xxAdjustDataPtrs).
377: *
378: *-----------------------------------------------------------------------------*/
379:
380:
381: /*-----------------------------------------------------------------------------*
382: * Build SG list based on an IOMemoryDescriptor object.
383: *
384: *-----------------------------------------------------------------------------*/
385: bool Sym8xxSCSIController::Sym8xxUpdateSGList( SRB *srb )
386: {
387: IOPhysicalSegment range;
388: UInt32 actRanges;
389: UInt32 offset;
390: UInt32 bytesLeft;
391: UInt32 i;
392: IOReturn rc = true;
393:
394: offset = srb->xferOffset;
395: bytesLeft = srb->xferCount - srb->xferOffset;
396:
397: if ( bytesLeft == 0 ) return rc;
398:
399: i = 2;
400:
401: while ( (bytesLeft > 0) && (i < MAX_SGLIST_ENTRIES-1))
402: {
403: actRanges = memoryCursor->getPhysicalSegments( srb->xferDesc,
404: offset,
405: &range,
406: 1 );
407:
408: if ( actRanges != 1 )
409: {
410: rc = false;
411: break;
412: }
413:
414: /*
415: * Note: The script instruction(s) to transfer data to/from the scsi bus
416: * have the same format as a typical SGList with the transfer length
417: * as the first word and the physical transfer address as the second.
418: * The data transfer direction is specified by a bit or'd into the
419: * high byte of the SG entry's length field.
420: */
421: srb->nexus.sgListData[i].physAddr = OSSwapHostToLittleInt32( (UInt32)range.location );
422: srb->nexus.sgListData[i].length = OSSwapHostToLittleInt32( range.length | srb->directionMask );
423:
424: bytesLeft -= range.length;
425: offset += range.length;
426: i++;
427: }
428:
429: if ( !bytesLeft )
430: {
431: srb->nexus.sgListData[i].length = OSSwapHostToLittleInt32( 0x90080000 );
432: srb->nexus.sgListData[i].physAddr = OSSwapHostToLittleInt32( 0x00000000 );
433: }
434: else
435: {
436: srb->nexus.sgListData[i].length = OSSwapHostToLittleInt32( 0x98080000 );
437: srb->nexus.sgListData[i].physAddr = OSSwapHostToLittleInt32( A_sglist_complete );
438: }
439:
440: srb->xferOffsetPrev = srb->xferOffset;
441: srb->xferOffset = offset;
442:
443: return rc;
444: }
445:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.