![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to Sym8xxClient.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc / drvSymbios8xx|
Return to Sym8xxClient.m CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / dev / ppc / drvSymbios8xx |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /* Sym8xxClient.m created by russb2 on Sat 30-May-1998 */
26:
27: #import "Sym8xxController.h"
28:
29: static u_int8_t xferMsgSync[] = {0x01, 0x03, 0x01, 0x0c, 0x10};
30: static u_int8_t xferMsgAsync[] = {0x01, 0x03, 0x01, 0x00, 0x00};
31: static u_int8_t xferMsgWide16[] = {0x01, 0x02, 0x03, 0x01};
32: static u_int8_t cdbLength[8] = { 6, 10, 10, 0, 0, 12, 0, 0 };
33:
34: @implementation Sym8xxController(Client)
35:
36: /*-----------------------------------------------------------------------------*
37: * Client thread routines.
38: *
39: * This module processes I/O requests from driverKit. It does most of the resource
40: * allocation and command preparation. Once a command is prepared it is queued
41: * to the driver's I/O Thread for execution.
42: *
43: *-----------------------------------------------------------------------------*/
44: - (sc_status_t) executeRequest:(IOSCSIRequest *)scsiReq buffer:(void *)buffer client:(vm_task_t)client
45: {
46: SRB *srb;
47: Nexus *nexus, *nexusPhys;
48: u_int32_t len;
49: ns_time_t startTime, endTime;
50:
51: IOGetTimestamp( &startTime );
52:
53: /*
54: * If a SCSI Bus reset is detected, we hold-off command processing until the targets have
55: * had a chance to recover.
56: */
57: while ( resetQuiesceTimer )
58: {
59: [resetQuiesceSem lock];
60: }
61: [resetQuiesceSem unlock];
62:
63: /*
64: * Allocate and initialize a SRB structure.
65: * Note: This routine clears the SRB and initializes srb->srbPhys
66: * which contains the physical address of the srb.
67: */
68: srb = [self Sym8xxAllocSRB];
69: if ( srb == NULL )
70: {
71: return -1;
72: }
73:
74: nexus = &srb->nexus;
75: nexusPhys = &srb->srbPhys->nexus;
76:
77: /*
78: * Set client data buffer pointers in the SRB
79: */
80: srb->xferClient = client;
81: srb->xferBuffer = (vm_offset_t) buffer;
82: srb->xferCount = scsiReq->maxTransfer;
83:
84: /*
85: * Set request sense buffer pointers in the SRB
86: */
87: if ( !scsiReq->ignoreChkcond )
88: {
89: srb->senseData = (vm_offset_t) &scsiReq->senseData;
90: srb->senseDataLength = sizeof(esense_reply_t);
91: }
92:
93: srb->srbCmd = ksrbCmdExecuteReq;
94: srb->srbState = ksrbStateCDBDone;
95:
96: srb->target = scsiReq->target;
97: srb->lun = scsiReq->lun;
98:
99: /*
100: * Setup timeout. (250ms ticks)
101: */
102: if ( scsiReq->timeoutLength )
103: {
104: srb->srbTimeout = (scsiReq->timeoutLength * 1000) / kSCSITimerIntervalMS + 1;
105: }
106:
107: srb->directionMask = (scsiReq->read) ? 0x01000000 : 0x00000000;
108:
109: /*
110: * Setup the Nexus struct. This part of the SRB is read/written both by the
111: * script and the driver.
112: */
113: nexus->targetParms.target = srb->target;
114:
115: nexus->cdb.ppData = EndianSwap32((u_int32_t)&nexusPhys->cdbData);
116:
117: len = cdbLength[scsiReq->cdb.cdb_opcode >> 5];
118: if ( len == 0 ) len = scsiReq->cdbLength;
119:
120: nexus->cdb.length = EndianSwap32( len );
121: nexus->cdbData = scsiReq->cdb;
122:
123: /*
124: * Setup SCSI Messages to send on inital selection of the target.
125: * Note: A SCSI tag for command-queuing requests is allocated
126: * when messages are generated.
127: */
128: srb->srbRequestFlags |= (scsiReq->disconnect) ? ksrbRFDisconnectAllowed : 0;
129: srb->srbRequestFlags |= (!scsiReq->syncDisable) ? ksrbRFXferSyncAllowed : 0;
130: srb->srbRequestFlags |= (!scsiReq->cmdQueueDisable) ? ksrbRFCmdQueueAllowed : 0;
131:
132: [self Sym8xxCalcMsgs:srb];
133:
134: /*
135: * Setup initial data transfer list (SGList)
136: */
137: nexus->ppSGList = (SGEntry *)EndianSwap32((u_int32_t)&nexusPhys->sgListData[2]);
138: [self Sym8xxUpdateSGList: srb ];
139:
140: /*
141: * Queue command to I/O Thread and wait for completion.
142: */
143: [self Sym8xxSendCommand: srb];
144:
145: /*
146: * If the command timed-out then issue a Maibox abort to clear
147: * the request from the target.
148: *
149: * Note: We lock the abortBdrSem to insure there is only one abort
150: * active at a time.
151: */
152: if ( srb->srbCmd == ksrbCmdProcessTimeout )
153: {
154: [abortBdrSem lock];
155: srb->srbCmd = ksrbCmdAbortReq;
156: [self Sym8xxSendCommand: srb];
157: [abortBdrSem unlock];
158: }
159:
160: /*
161: * Release the tag for the request.
162: */
163: [self Sym8xxFreeTag: srb];
164:
165: /*
166: * Transfer final request status from the SRB to the original request
167: */
168: IOGetTimestamp( &endTime );
169: scsiReq->totalTime = endTime - startTime;
170: scsiReq->driverStatus = srb->srbSCSIResult;
171: scsiReq->scsiStatus = srb->srbSCSIStatus;
172: scsiReq->bytesTransferred = srb->xferDone;
173:
174: [self Sym8xxFreeSRB: srb];
175:
176: return scsiReq->driverStatus;
177: }
178:
179: /*-----------------------------------------------------------------------------*
180: * Requests from Blue Box.
181: *
182: * Note: Hopefully this kludge of having multiple variants of executeRequest
183: * will go away soon!
184: *-----------------------------------------------------------------------------*/
185: - (sc_status_t) executeRequest : (IOSCSIRequest *) scsiReq
186: ioMemoryDescriptor : (IOMemoryDescriptor *) ioMemoryDescriptor
187: {
188: return [self executeRequest:scsiReq buffer:(void *)ioMemoryDescriptor client:(vm_task_t) -1];
189: }
190:
191:
192: /*-----------------------------------------------------------------------------*
193: * This routine queues an SRB to reset the SCSI Bus
194: *
195: *-----------------------------------------------------------------------------*/
196: - (sc_status_t) resetSCSIBus
197: {
198: SRB *srb;
199: sc_status_t scsiResult;
200:
201: srb = [self Sym8xxAllocSRB];
202: if ( srb == NULL )
203: {
204: return -1;
205: }
206:
207: srb->srbCmd = ksrbCmdResetSCSIBus;
208: [self Sym8xxSendCommand: srb];
209:
210: scsiResult = srb->srbSCSIResult;
211: [self Sym8xxFreeSRB: srb];
212:
213: return scsiResult;
214: }
215:
216:
217: /*-----------------------------------------------------------------------------*
218: * This routine queues a command on the driver's I/O Thread, wakes up
219: * the I/O Thread and then waits for the command to complete.
220: *
221: *-----------------------------------------------------------------------------*/
222: - (void) Sym8xxSendCommand: (SRB *) srb
223: {
224: kern_return_t kr;
225:
226: msg_header_t msg =
227: {
228: 0, // msg_unused
229: 1, // msg_simple
230: sizeof(msg_header_t), // msg_size
231: MSG_TYPE_NORMAL, // msg_type
232: PORT_NULL, // msg_local_port
233: PORT_NULL, // msg_remote_port - TO BE FILLED IN
234: IO_COMMAND_MSG // msg_id
235: };
236:
237: srb->srbCmdLock = [[NXConditionLock alloc] initWith: ksrbCmdPending];
238:
239: [srbPendingQLock lock];
240: queue_enter( &srbPendingQ, srb, SRB *, srbQ );
241: [srbPendingQLock unlock];
242:
243: msg.msg_remote_port = interruptPortKern;
244: kr = msg_send_from_kernel(&msg, MSG_OPTION_NONE, 0);
245: if( kr != KERN_SUCCESS )
246: {
247: goto executeCmd_error;
248: }
249:
250: [srb->srbCmdLock lockWhen: ksrbCmdComplete];
251: [srb->srbCmdLock free];
252:
253: executeCmd_error:
254: ;
255: return;
256: }
257:
258:
259: /*-----------------------------------------------------------------------------*
260: * This routine provides our data alignment/length restrictions to the
261: * super class.
262: *
263: *-----------------------------------------------------------------------------*/
264: - (void)getDMAAlignment:(IODMAAlignment *)alignment
265: {
266: alignment->readStart = 1;
267: alignment->writeStart = 1;
268: alignment->readLength = 1;
269: alignment->writeLength = 2;
270: }
271:
272: /*-----------------------------------------------------------------------------*
273: * This routine returns the number of targets we support.
274: *
275: *-----------------------------------------------------------------------------*/
276: - (int) numberOfTargets
277: {
278: return MAX_SCSI_TARGETS;
279: }
280:
281: /*-----------------------------------------------------------------------------*
282: * This routine creates SCSI messages to send during the initial connection
283: * to the target. It is called during client request processing and also by
284: * the I/O thread when a request sense operation is required.
285: *
286: * Outbound messages are setup in the MsgOut buffer in the Nexus structure of
287: * the SRB.
288: *
289: *-----------------------------------------------------------------------------*/
290: - (void) Sym8xxCalcMsgs: (SRB *)srb
291: {
292: Nexus *nexus;
293: Nexus *nexusPhys;
294: u_int32_t msgIndex;
295: BOOL fCmdQueue;
296: BOOL fNegotiateSync;
297: BOOL fNegotiateWide;
298: u_int32_t targetFlags;
299: u_int32_t reqFlags;
300: u_int8_t *xferMsg = NULL;
301:
302: nexus = &srb->nexus;
303: nexusPhys = &srb->srbPhys->nexus;
304:
305: reqFlags = srb->srbRequestFlags;
306:
307: /*
308: * Setup Identify message
309: */
310: msgIndex = 0;
311: nexus->msg.ppData = EndianSwap32((u_int32_t)&nexusPhys->msgData);
312: nexus->msgData[msgIndex++] = srb->lun | (( reqFlags & ksrbRFDisconnectAllowed ) ? 0xC0 : 0x80);
313:
314: targetFlags = targets[srb->target].flags;
315:
316: /*
317: * Setup Tag message if cmdQueueing is supported.
318: *
319: * Note: On target flags:
320: * kTFxxxxSupported - Inquiry data indicates the function is supported.
321: * kTFxxxxAllowed - The function is not explicity disabled for this target.
322: * kRFxxxxAllowed - The function is not explicitly disabled by the command
323: */
324: fCmdQueue = ( (targetFlags & kTFCmdQueueSupported)
325: && (targetFlags & kTFCmdQueueAllowed)
326: && (reqFlags & ksrbRFCmdQueueAllowed) );
327:
328: /*
329: * Allocate tag for request.
330: *
331: * For non-tagged requests a pseudo-tag is created consisting of target*16+lun. For tagged
332: * requests a tag in the range 128-255 is allocated.
333: *
334: * If a pseudo-tag is inuse for a non-tagged command or there are no tags available for
335: * a tagged request, then the command is blocked until a tag becomes available.
336: *
337: * Note: If we are being called during request sense processing (srbState != ksrbStateCDBDone)
338: * then a tag has already been allocated to the request.
339: */
340: if ( srb->srbState == ksrbStateCDBDone )
341: {
342: srb->tag = srb->nexus.tag = [self Sym8xxAllocTag:(SRB *)srb CmdQueue:(BOOL)fCmdQueue];
343: }
344:
345: if ( fCmdQueue )
346: {
347: nexus->msgData[msgIndex++] = 0x20;
348: nexus->msgData[msgIndex++] = srb->nexus.tag;
349: }
350:
351: /*
352: * Setup to negotiate for Wide (16-bit) data transfers
353: *
354: * Note: There is no provision to negotiate back to narrow transfers although
355: * SCSI does support this.
356: */
357: fNegotiateWide = (targetFlags & kTFXferWide16Supported)
358: && (targetFlags & kTFXferWide16Allowed)
359: && !(targetFlags & kTFXferWide16);
360:
361: if ( fNegotiateWide )
362: {
363: srb->srbRequestFlags |= ksrbRFNegotiateWide;
364: bcopy( xferMsgWide16, &nexus->msgData[msgIndex], sizeof(xferMsgWide16) );
365: msgIndex += sizeof(xferMsgWide16);
366: }
367:
368: /*
369: * Setup to negotiate for Synchronous data transfers.
370: *
371: * Note: We can negotiate back to async based on the flags in the command.
372: */
373:
374: fNegotiateSync = (targetFlags & kTFXferSyncSupported)
375: && (targetFlags & kTFXferSyncAllowed)
376: && ( ((reqFlags & ksrbRFXferSyncAllowed) != 0) ^ ((targetFlags & kTFXferSync) != 0) ) ;
377:
378: if ( fNegotiateSync )
379: {
380: srb->srbRequestFlags |= ksrbRFNegotiateSync;
381: xferMsg = (reqFlags & ksrbRFXferSyncAllowed) ? xferMsgSync : xferMsgAsync;
382: bcopy( xferMsg, &nexus->msgData[msgIndex], sizeof(xferMsgSync) );
383: msgIndex += sizeof(xferMsgSync);
384: }
385:
386: /*
387: * If we are negotiating for both Sync and Wide data transfers, we setup both messages
388: * in the Nexus msgOut buffer. However, after each message the script needs to wait for
389: * a reply message from the target. In this case, we set the msgOut length to include
390: * bytes upto the end of the Wide message. When we get the reply from the target, the
391: * routine handling the WDTR will setup the Nexus pointers/counts to send the remaining
392: * message bytes. See Sym8xxExecute.m(Sym8xxNegotiateWDTR).
393: */
394: srb->srbMsgLength = msgIndex;
395:
396: if ( fNegotiateSync && fNegotiateWide ) msgIndex -= sizeof(xferMsgSync);
397:
398: nexus->msg.length = EndianSwap32( msgIndex );
399: }
400:
401: /*-----------------------------------------------------------------------------*
402: * This routine sets up the data transfer SG list for the client's buffer in the
403: * Nexus structure.
404: *
405: * The SGList actually consists of script instructions. The script will branch
406: * to the SGList when the target enters data transfer phase. When the SGList completes
407: * it will either execute a script INT instruction if there are more segments of the
408: * user buffer that need to be transferred or will execute a script RETURN instruction
409: * to return to the script.
410: *
411: * The first two slots in the SGList are reserved for partial data transfers. See
412: * Sym8xxExecute.m(Sym8xxAdjustDataPtrs).
413: *
414: *-----------------------------------------------------------------------------*/
415: - (BOOL) Sym8xxUpdateSGList: (SRB *) srb
416: {
417: BOOL rc;
418:
419: if ( srb->xferClient != (vm_task_t)-1 )
420: {
421: rc = [self Sym8xxUpdateSGListVirt: srb];
422: }
423: else
424: {
425: rc = [self Sym8xxUpdateSGListDesc: srb];
426: }
427: return rc;
428: }
429:
430: /*-----------------------------------------------------------------------------*
431: * Build SG list based on a single virtual address range/length
432: *
433: *-----------------------------------------------------------------------------*/
434: - (BOOL) Sym8xxUpdateSGListVirt: (SRB *) srb
435: {
436: u_int32_t offset;
437: u_int32_t physAddr;
438: u_int32_t bytesLeft;
439: u_int32_t bytesOnPage;
440: u_int32_t i;
441: u_int32_t len = 0;
442: IOReturn rc = IO_R_SUCCESS;
443:
444: offset = srb->xferOffset;
445: bytesLeft = srb->xferCount - srb->xferOffset;
446: i = 2;
447:
448: while ( (bytesLeft > 0) && (i < MAX_SGLIST_ENTRIES-1))
449: {
450:
451: rc = IOPhysicalFromVirtual( (vm_task_t) srb->xferClient,
452: (vm_address_t) (srb->xferBuffer+offset),
453: (u_int32_t *) &physAddr );
454:
455: if ( rc != IO_R_SUCCESS )
456: {
457: break;
458: }
459:
460: /*
461: * Note: The script instruction(s) to transfer data to/from the scsi bus
462: * have the same format as a typical SGList with the transfer length
463: * as the first word and the physical transfer address as the second.
464: * The data transfer direction is specified by a bit or'd into the
465: * high byte of the SG entry's length field.
466: */
467: srb->nexus.sgListData[i].physAddr = EndianSwap32( physAddr );
468:
469: bytesOnPage = page_size - ((srb->xferBuffer + offset) & (page_size - 1));
470: len = ( bytesLeft < bytesOnPage ) ? bytesLeft : bytesOnPage;
471:
472: srb->nexus.sgListData[i].length = EndianSwap32( len | srb->directionMask );
473:
474: bytesLeft -= len;
475: offset += len;
476: i++;
477: }
478:
479: if ( !bytesLeft )
480: {
481: srb->nexus.sgListData[i].length = EndianSwap32( 0x90080000 );
482: srb->nexus.sgListData[i].physAddr = EndianSwap32( 0x00000000 );
483: }
484: else
485: {
486: srb->nexus.sgListData[i].length = EndianSwap32( 0x98080000 );
487: srb->nexus.sgListData[i].physAddr = EndianSwap32( A_sglist_complete );
488: }
489:
490: srb->xferOffsetPrev = srb->xferOffset;
491: srb->xferOffset = offset;
492:
493: return ((rc != IO_R_SUCCESS) ? NO : YES) ;
494: }
495:
496: /*-----------------------------------------------------------------------------*
497: * Build SG list based on an IOMemoryDescriptor object.
498: *
499: *-----------------------------------------------------------------------------*/
500: - (BOOL) Sym8xxUpdateSGListDesc: (SRB *) srb
501: {
502:
503: PhysicalRange range;
504: u_int32_t actRanges;
505: u_int32_t offset;
506: u_int32_t bytesLeft;
507: u_int32_t i;
508: IOReturn rc = YES;
509:
510: offset = srb->xferOffset;
511: bytesLeft = srb->xferCount - srb->xferOffset;
512: i = 2;
513:
514: [(id)srb->xferBuffer setPosition: offset];
515:
516: while ( (bytesLeft > 0) && (i < MAX_SGLIST_ENTRIES-1))
517: {
518: [(id)srb->xferBuffer getPhysicalRanges: 1
519: maxByteCount: 0x00FFFFFF
520: newPosition: &offset
521: actualRanges: &actRanges
522: physicalRanges: &range];
523:
524: if ( actRanges != 1 )
525: {
526: rc = NO;
527: break;
528: }
529:
530: /*
531: * Note: The script instruction(s) to transfer data to/from the scsi bus
532: * have the same format as a typical SGList with the transfer length
533: * as the first word and the physical transfer address as the second.
534: * The data transfer direction is specified by a bit or'd into the
535: * high byte of the SG entry's length field.
536: */
537: srb->nexus.sgListData[i].physAddr = EndianSwap32( (u_int32_t)range.address );
538: srb->nexus.sgListData[i].length = EndianSwap32( range.length | srb->directionMask );
539:
540: bytesLeft -= range.length;
541: i++;
542: }
543:
544: if ( !bytesLeft )
545: {
546: srb->nexus.sgListData[i].length = EndianSwap32( 0x90080000 );
547: srb->nexus.sgListData[i].physAddr = EndianSwap32( 0x00000000 );
548: }
549: else
550: {
551: srb->nexus.sgListData[i].length = EndianSwap32( 0x98080000 );
552: srb->nexus.sgListData[i].physAddr = EndianSwap32( A_sglist_complete );
553: }
554:
555: srb->xferOffsetPrev = srb->xferOffset;
556: srb->xferOffset = offset;
557:
558: return rc;
559: }
560:
561:
562: /*-----------------------------------------------------------------------------*
563: * This routine allocates a SCSI Tag value for a request. For non-tagged requests
564: * a pseudo-tag is generated with the value target*16+lun.
565: *
566: * If all tags are in-use or a pseudo tag is in-use, the request is blocked until
567: * the tag becomes available.
568: *
569: *-----------------------------------------------------------------------------*/
570: - (u_int32_t) Sym8xxAllocTag:(SRB *) srb CmdQueue:(BOOL)fCmdQueue
571: {
572: u_int32_t i;
573: u_int32_t tagIndex;
574: u_int32_t tagMask;
575:
576: while ( 1 )
577: {
578: if ( fCmdQueue )
579: {
580: for ( i = MIN_SCSI_TAG; i < MAX_SCSI_TAG; i ++ )
581: {
582: tagIndex = i / 32;
583: tagMask = 1 << (i % 32);
584: if ( !(tags[tagIndex] & tagMask) )
585: {
586: tags[tagIndex] |= tagMask;
587: return i;
588: }
589: }
590: /*
591: * This semaphore gets unlocked whenever a tag gets returned to the pool. Any
592: * requests waiting for a tag will wake-up and try to allocate a tag. If they
593: * fail they will return here and will be put back to sleep.
594: */
595: [cmdQTagSem lock];
596: }
597: else
598: {
599: i = ((u_int32_t)srb->target << 3) | srb->lun;
600: tagIndex = i / 32;
601: tagMask = 1 << (i % 32);
602: if ( !(tags[tagIndex] & tagMask) )
603: {
604: tags[tagIndex] |= tagMask;
605: return i;
606: }
607: /*
608: * This per-target semaphore gets unlocked whenever a request completes on a target. Any
609: * requests pending for this target will wake-up and try to allocate this pseudo-tag. If they
610: * fail they will return here and will be put back to sleep.
611: */
612: [targets[srb->target].targetTagSem lock];
613: }
614: }
615: return -1;
616: }
617:
618: /*-----------------------------------------------------------------------------*
619: * This routine frees a previously allocates SCSI tag. It unlocks the appropriate
620: * semaphore based on the type of tag returned.
621: *
622: *-----------------------------------------------------------------------------*/
623: - (void) Sym8xxFreeTag:(SRB *) srb
624: {
625: u_int32_t i;
626:
627: i = srb->tag;
628: tags[i/32] &= ~(1 << (i % 32));
629:
630: if ( i < MIN_SCSI_TAG )
631: {
632: [targets[srb->target].targetTagSem unlock];
633: }
634: else
635: {
636: [cmdQTagSem unlock];
637: }
638: }
639:
640:
641: /*-----------------------------------------------------------------------------*
642: * This routine maintains a list of pages which are divided up into SRB sized
643: * allocations. The list of pages is grown or shrunk as needed.
644: *
645: * The reason we dont use the driverKit IOMalloc function is that it does not
646: * guarantee that allocations will not cross page boundaries. The driver does
647: * require this since the script accesses memory based on physical rather than
648: * virtual addresses.
649: *
650: *-----------------------------------------------------------------------------*/
651: - (SRB *) Sym8xxAllocSRB
652: {
653: SRBPool *pSRBPool;
654: SRB *pSRB = NULL;
655:
656: do
657: {
658: /*
659: * We hold the srbPoolLock when we are searching or changing the SRB pool
660: * data structures
661: */
662: [srbPoolLock lock];
663:
664: /*
665: * Search the list of pages currently in the SRB pool until we find a page
666: * with at least one free SRB to allocate.
667: */
668: pSRBPool = (SRBPool *) queue_first( &srbPool );
669: while (!queue_end( &srbPool, &pSRBPool->nextPage ) )
670: {
671: if ( !queue_empty( &pSRBPool->freeSRBList ) )
672: {
673: pSRBPool->srbInUseCount++;
674: queue_remove_first( &pSRBPool->freeSRBList, pSRB, SRB *, srbQ );
675: break;
676: }
677: pSRBPool = (SRBPool *)queue_next( &pSRBPool->nextPage );
678: }
679:
680: [srbPoolLock unlock];
681:
682: if ( pSRB )
683: {
684: bzero( pSRB, sizeof(SRB) );
685: pSRB->srbPhys = (SRB *)(pSRBPool->pagePhysAddr + (uint)pSRB - (uint)pSRBPool);
686: pSRB->srbSeqNum = ++srbSeqNum;
687: break;
688: }
689:
690: /*
691: * If we can find no available SRBs, we unlock a thread to grow the SRB pool and
692: * block this request until the pool grow operation completes. When our thread runs
693: * again it will retry the SRB allocation.
694: */
695: if ( srbPoolGrow == NO )
696: {
697: srbPoolGrow = YES;
698: [srbPoolGrowLock unlockWith: kSRBGrowPoolRunning];
699: }
700:
701: [srbPoolGrowLock lockWhen: kSRBGrowPoolIdle];
702: [srbPoolGrowLock unlockWith: kSRBGrowPoolIdle];
703: }
704: while ( 1 );
705:
706: return pSRB;
707: }
708:
709: /*-----------------------------------------------------------------------------*
710: * This routine returns SRBs to the SRB pool.
711: *
712: * The page in the pool containing the SRB is located and the
713: * SRB is added to that page's SRB free list.
714: *
715: * The pool is then scanned for pages with no SRBs allocated.
716: * If more than two pages are found with zero SRBs allocate, the
717: * additional idle pages are returned to the kernel.
718: *
719: *-----------------------------------------------------------------------------*/
720: - (void) Sym8xxFreeSRB: (SRB *) pSRB
721: {
722: SRB *srbMin, *srbMax;
723: SRBPool *pSRBPool, *pSRBPoolNext;
724: u_int32_t numSRBs;
725: kern_return_t kr;
726: u_int32_t idlePageCount = 0;
727:
728: [srbPoolLock lock];
729:
730: numSRBs = (page_size - sizeof(SRBPool)) / sizeof(SRB);
731:
732: /*
733: * Scan the pool for a page containing the returned SRB
734: */
735: pSRBPool = (SRBPool *) queue_first( &srbPool );
736: while (!queue_end( &srbPool, &pSRBPool->nextPage ) )
737: {
738: srbMin = (SRB *) (pSRBPool+1);
739: srbMax = &srbMin[numSRBs-1];
740:
741: if ( pSRB >= srbMin && pSRB <= srbMax )
742: {
743: pSRBPool->srbInUseCount--;
744: queue_enter( &pSRBPool->freeSRBList, pSRB, SRB *, srbQ );
745: break;
746: }
747: pSRBPool = (SRBPool *)queue_next( &pSRBPool->nextPage );
748: }
749:
750: /*
751: * If we fell off the end of the SRB Pool page list without finding
752: * the owning page, we have a bug.
753: */
754: if ( queue_end( &srbPool, &pSRBPool->nextPage ) )
755: {
756: kprintf("Sym8xxFreeSRB: Bad SRB returned = %08x\n\r", (u_int32_t)pSRB );
757: }
758:
759: /*
760: * We scan the SRBPool page list again looking for pages with no SRBs inuse.
761: * If more than idle pool pages are found, we release the remaining pages to
762: * the kernel.
763: */
764: pSRBPool = (SRBPool *) queue_first( &srbPool );
765: while (!queue_end( &srbPool, &pSRBPool->nextPage ) )
766: {
767: pSRBPoolNext = (SRBPool *)queue_next( &pSRBPool->nextPage );
768:
769: if ( !pSRBPool->srbInUseCount )
770: {
771: if ( ++idlePageCount > kSRBPoolMaxFreePages )
772: {
773: queue_remove( &srbPool, pSRBPool, SRBPool *, nextPage );
774:
775: // kprintf("SCSI(Symbios8xx): Sym8xxShrinkSRBPool\n\r");
776:
777: kr = kmem_free(IOVmTaskSelf(), (vm_offset_t) pSRBPool, page_size );
778: if ( kr != KERN_SUCCESS )
779: {
780: IOPanic("SCSI(Symbios8xx): kmem_free failed - Help me\n\r");
781: }
782: }
783: }
784: pSRBPool = pSRBPoolNext;
785: }
786:
787: [srbPoolLock unlock];
788:
789: }
790:
791: /*-----------------------------------------------------------------------------*
792: * This routines grows the SRBPool. It runs on its own thread to avoid pager deadlocks.
793: *
794: * We need this entry thunk since the thread creation routines dont support objC
795: * interfaces directly.
796: *
797: *-----------------------------------------------------------------------------*/
798: IOThreadFunc Sym8xxGrowSRBPool( Sym8xxController *controller )
799: {
800: [controller Sym8xxGrowSRBPool];
801: return NULL;
802: }
803:
804: - (void) Sym8xxGrowSRBPool
805: {
806: SRBPool *pSRBPool;
807: SRB *pSRB;
808: kern_return_t kr;
809: u_int32_t numSRBs;
810: u_int32_t i;
811:
812: while ( 1 )
813: {
814: [srbPoolGrowLock lockWhen: kSRBGrowPoolRunning];
815:
816: // kprintf("SCSI(Symbios8xx): Sym8xxGrowSRBPool\n\r");
817:
818: kr = kmem_alloc_wired(IOVmTaskSelf(), (vm_offset_t *) &pSRBPool, page_size );
819: if ( kr != KERN_SUCCESS )
820: {
821: IOPanic("kmem_alloc_wired failed - Help me\n\r");
822: }
823:
824: IOPhysicalFromVirtual((vm_task_t)IOVmTaskSelf(), (vm_offset_t)pSRBPool, (vm_offset_t *)&pSRBPool->pagePhysAddr );
825:
826: pSRBPool->srbInUseCount = 0;
827:
828: numSRBs = (page_size - sizeof(SRBPool)) / sizeof(SRB);
829: pSRB = (SRB *) (pSRBPool+1);
830:
831: queue_init( &pSRBPool->freeSRBList );
832: for ( i=0; i < numSRBs; i++ )
833: {
834: queue_enter( &pSRBPool->freeSRBList, (pSRB+i), SRB *, srbQ );
835: }
836:
837: [srbPoolLock lock];
838: queue_enter( &srbPool, pSRBPool, SRBPool *, nextPage );
839: [srbPoolLock unlock];
840:
841: srbPoolGrow = NO;
842: [srbPoolGrowLock unlockWith: kSRBGrowPoolIdle];
843: }
844: }
845:
846:
847: /*-----------------------------------------------------------------------------*
848: * This routine interfaces between the system timer and our I/O Thread. It
849: * sends a message to the IOThread to run the -timeoutOccurred routine which
850: * does various timing functions for the driver. See Sym8xxExecuteRequest(timeoutOccurred).
851: *
852: *-----------------------------------------------------------------------------*/
853: IOThreadFunc Sym8xxTimerReq( Sym8xxController *device )
854: {
855: msg_header_t msg = { 0 };
856:
857: msg.msg_size = sizeof (msg);
858: msg.msg_remote_port = device->interruptPortKern;
859: msg.msg_id = IO_TIMEOUT_MSG;
860:
861: msg_send_from_kernel(&msg, MSG_OPTION_NONE, 0);
862:
863: return NULL;
864: }
865:
866: @end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.