![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOSCSIParallelController.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IOSCSIParallel|
Return to IOSCSIParallelController.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Families / IOSCSIParallel |
1.1 root 1: /*
2: * Copyright (c) 1998-2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * IOSCSIParallelController.cpp
24: *
25: */
26:
27: #include <IOKit/scsi/IOSCSIParallelInterface.h>
28: #include <IOKit/IOSyncer.h>
29:
30: #undef super
31: #define super IOService
32:
33: OSDefineMetaClass( IOSCSIParallelController, IOService )
34: OSDefineAbstractStructors( IOSCSIParallelController, IOService );
35:
36: #define round(x,y) (((int)(x) + (y) - 1) & ~((y)-1))
37:
38: /*
39: *
40: *
41: */
42: bool IOSCSIParallelController::start( IOService *forProvider )
43: {
44: provider = forProvider;
45:
46: if ( provider->open( this ) != true )
47: {
48: return false;
49: }
50:
51: if ( createWorkLoop() != true )
52: {
53: return false;
54: }
55:
56: if ( configureController() == false )
57: {
58: provider->close( this );
59: return false;
60: }
61:
62: initQueues();
63:
64: if ( scanSCSIBus() == false )
65: {
66: provider->close( this );
67: return false;
68: }
69:
70: return true;
71: }
72:
73: /*
74: *
75: *
76: *
77: */
78: bool IOSCSIParallelController::scanSCSIBus()
79: {
80: SCSITargetLun targetLun;
81: UInt32 i;
82:
83: targetLun.lun = 0;
84:
85: for ( i=0; i < controllerInfo.maxTargetsSupported; i++ )
86: {
87: targetLun.target = i;
88: probeTarget( targetLun );
89: }
90:
91: return true;
92: }
93:
94: /*
95: *
96: *
97: *
98: */
99: bool IOSCSIParallelController::probeTarget( SCSITargetLun targetLun )
100: {
101: IOSCSIParallelDevice *device;
102: UInt32 i;
103:
104: if ( targetLun.target == controllerInfo.initiatorId )
105: {
106: return false;
107: }
108:
109: if ( workLoopRequest( kWorkLoopInitTarget, *(UInt32 *)&targetLun ) == false )
110: {
111: releaseTarget( targetLun );
112: return false;
113: }
114:
115: for ( i=0; i < controllerInfo.maxLunsSupported; i++ )
116: {
117: targetLun.lun = i;
118:
119: device = createDevice();
120: if ( device == 0 )
121: {
122: break;
123: }
124:
125: if ( device->init( this, targetLun ) == false )
126: {
127: releaseDevice( device );
128: break;
129: }
130:
131: if ( workLoopRequest( kWorkLoopInitDevice, (UInt32)device ) == false )
132: {
133: releaseDevice( device );
134: }
135:
136: // IOLog("Target %d Lun %d - created\n\r", targetLun.target, targetLun.lun );
137:
138: if ( device->probeTargetLun() != kIOReturnSuccess )
139: {
140: // IOLog("Target %d Lun %d - no response\n\r", targetLun.target, targetLun.lun );
141:
142: releaseDevice( device );
143:
144: if ( i == 0 ) break;
145: }
146: }
147:
148: if ( i == 0 )
149: {
150: releaseTarget( targetLun );
151: return false;
152: }
153:
154: queue_iterate( &targets[targetLun.target].deviceList, device, IOSCSIParallelDevice *, nextDevice )
155: {
156: device->setupTarget();
157: device->attach( this );
158: device->registerService();
159: }
160:
161: return true;
162: }
163:
164: /*
165: *
166: *
167: *
168: */
169: bool IOSCSIParallelController::initTarget( SCSITargetLun targetLun )
170: {
171: SCSITarget *target;
172:
173: target = &targets[targetLun.target];
174:
175: assert ( target->clientSem == 0 );
176: assert ( target->targetSem == 0 );
177:
178: bzero( target, sizeof(SCSITarget) );
179:
180: queue_init( &targets[targetLun.target].deviceList );
181:
182: target->clientSem = IORWLockAlloc();
183: target->targetSem = IORWLockAlloc();
184: if( (target->targetSem == 0) || (target->clientSem == 0))
185: {
186: return false;
187: }
188: target->commandLimitSave = target->commandLimit = 1;
189:
190: target->targetParmsCurrent.transferWidth = 1;
191:
192: if ( controllerInfo.targetPrivateDataSize != 0 )
193: {
194: target->targetPrivateData = IOMallocContiguous( controllerInfo.targetPrivateDataSize, 16, 0 );
195: if ( target->targetPrivateData == 0 )
196: {
197: return false;
198: }
199: }
200:
201: if ( controllerInfo.tagAllocationMethod == kTagAllocationPerTarget )
202: {
203: target->tagArray = (UInt32 *)IOMalloc( tagArraySize );
204: if ( target->tagArray == 0 )
205: {
206: return false;
207: }
208: bzero( target->tagArray, tagArraySize );
209: }
210:
211: return true;
212: }
213:
214: /*
215: *
216: *
217: *
218: */
219: void IOSCSIParallelController::releaseTarget( SCSITargetLun targetLun )
220: {
221: SCSITarget *target;
222:
223: workLoopRequest( kWorkLoopReleaseTarget, *(UInt32 *)&targetLun );
224:
225: target = &targets[targetLun.target];
226: if ( target->tagArray != 0 )
227: {
228: IOFree( target->tagArray, tagArraySize );
229: target->tagArray = 0;
230: }
231:
232: if ( target->targetPrivateData != 0 )
233: {
234: IOFreeContiguous( target->targetPrivateData, controllerInfo.targetPrivateDataSize );
235: target->targetPrivateData = 0;
236: }
237:
238: if ( target->clientSem != 0 )
239: {
240: IORWLockFree( target->clientSem );
241: }
242: if ( target->targetSem != 0 )
243: {
244: IORWLockFree( target->targetSem );
245: }
246: }
247:
248: /*
249: *
250: *
251: *
252: */
253: void IOSCSIParallelController::releaseDevice( IOSCSIParallelDevice *device )
254: {
255: workLoopRequest( kWorkLoopReleaseDevice, (UInt32) device );
256:
257: device->release();
258: }
259:
260: /*
261: *
262: *
263: *
264: */
265: bool IOSCSIParallelController::workLoopRequest( WorkLoopReqType type, UInt32 p1, UInt32 p2, UInt32 p3 )
266: {
267: WorkLoopRequest workLoopReq;
268:
269: bzero( &workLoopReq, sizeof(WorkLoopRequest) );
270: workLoopReq.type = type;
271: workLoopReq.sync = IOSyncer::create();
272:
273: workLoopReqGate->runCommand( &workLoopReq, (void *)p1, (void *)p2, (void *)p3 );
274:
275: workLoopReq.sync->wait();
276:
277: return( workLoopReq.rc );
278: }
279:
280:
281: /*
282: *
283: *
284: *
285: */
286: void IOSCSIParallelController::workLoopProcessRequest( WorkLoopRequest *workLoopReq, void *p1, void *p2, void *p3 )
287: {
288: bool rc = true;
289: IOSCSIParallelDevice *device;
290: SCSITargetLun targetLun;
291:
292: switch ( workLoopReq->type )
293: {
294: case kWorkLoopInitTarget:
295: targetLun = *(SCSITargetLun *)&p1;
296: rc = initTarget( targetLun );
297: if ( rc == false )
298: {
299: break;
300: }
301: rc = allocateTarget( targetLun );
302: break;
303:
304: case kWorkLoopReleaseTarget:
305: targetLun = *(SCSITargetLun *) &p1;
306: if ( queue_empty( &targets[targetLun.target].deviceList ) != true )
307: {
308: IOLog("IOSCSIParallelController()::Target %d deleted with lun(s) active!\n\r",
309: targetLun.target );
310: }
311: deallocateTarget( targetLun );
312: break;
313:
314: case kWorkLoopInitDevice:
315: device = (IOSCSIParallelDevice *) p1;
316: addDevice( device );
317: rc = allocateLun( device->targetLun );
318: break;
319:
320: case kWorkLoopReleaseDevice:
321: device = (IOSCSIParallelDevice *) p1;
322: deleteDevice( device );
323: deallocateLun( device->targetLun );
324: break;
325: }
326:
327: workLoopReq->rc = rc;
328: workLoopReq->sync->signal();
329: }
330:
331: /*
332: *
333: *
334: *
335: */
336: void IOSCSIParallelController::addDevice( IOSCSIParallelDevice *forDevice )
337: {
338: UInt32 targetID;
339:
340: targetID = forDevice->targetLun.target;
341:
342: forDevice->target = &targets[targetID];
343: queue_enter( &targets[targetID].deviceList, forDevice, IOSCSIParallelDevice *, nextDevice );
344: }
345:
346: /*
347: *
348: *
349: *
350: */
351: void IOSCSIParallelController::deleteDevice( IOSCSIParallelDevice *forDevice )
352: {
353: queue_head_t *deviceList;
354: IOSCSIParallelDevice *device;
355: UInt32 targetID;
356:
357: targetID = forDevice->targetLun.target;
358:
359: deviceList = &targets[targetID].deviceList;
360:
361: queue_iterate( deviceList, device, IOSCSIParallelDevice *, nextDevice )
362: {
363: if ( device == forDevice )
364: {
365: queue_remove( &targets[targetID].deviceList, device, IOSCSIParallelDevice *, nextDevice );
366: break;
367: }
368: }
369: }
370:
371: /*
372: *
373: *
374: *
375: */
376: bool IOSCSIParallelController::allocateTarget( SCSITargetLun targetLun )
377: {
378: return true;
379: }
380:
381: /*
382: *
383: *
384: *
385: */
386: void IOSCSIParallelController::deallocateTarget( SCSITargetLun targetLun )
387: {
388: }
389:
390: /*
391: *
392: *
393: *
394: */
395: bool IOSCSIParallelController::allocateLun( SCSITargetLun targetLun )
396: {
397: return true;
398: }
399:
400: /*
401: *
402: *
403: *
404: */
405: void IOSCSIParallelController::deallocateLun( SCSITargetLun targetLun )
406: {
407: }
408:
409:
410: /*
411: *
412: *
413: *
414: */
415: void *IOSCSIParallelController::getTargetData( SCSITargetLun targetLun )
416: {
417: return targets[targetLun.target].targetPrivateData;
418: }
419:
420: /*
421: *
422: *
423: *
424: */
425: void *IOSCSIParallelController::getLunData( SCSITargetLun targetLun )
426: {
427: queue_head_t *deviceList;
428: IOSCSIParallelDevice *device;
429:
430: deviceList = &targets[targetLun.target].deviceList;
431:
432: queue_iterate( deviceList, device, IOSCSIParallelDevice *, nextDevice )
433: {
434: if ( device->targetLun.lun == targetLun.lun )
435: {
436: return device->devicePrivateData;
437: }
438: }
439: return 0;
440: }
441:
442:
443:
444: /*
445: *
446: *
447: *
448: */
449: IOSCSIParallelDevice *IOSCSIParallelController::createDevice()
450: {
451: return new IOSCSIParallelDevice;
452: }
453:
454:
455: /*
456: *
457: *
458: *
459: */
460: void IOSCSIParallelController::initQueues()
461: {
462: UInt32 i;
463:
464: for ( i=0; i < controllerInfo.maxTargetsSupported; i++ )
465: {
466: queue_init( &targets[i].deviceList );
467: }
468:
469: resetCmd = allocCommand( 0 );
470: resetCmd->cmdType = kSCSICommandBusReset;
471:
472: timer( timerEvent );
473: }
474:
475: /*
476: *
477: *
478: *
479: */
480: void IOSCSIParallelController::reset()
481: {
482: IOSCSIParallelDevice *device;
483: UInt32 i;
484:
485: if ( busResetState != kStateIssue )
486: {
487: return;
488: }
489:
490: busResetState = kStateActive;
491:
492: for (i=0; i < controllerInfo.maxTargetsSupported; i++ )
493: {
494: queue_iterate( &targets[i].deviceList, device, IOSCSIParallelDevice *, nextDevice )
495: {
496: if ( device->client != 0 )
497: {
498: device->client->message( kSCSIClientMsgBusReset, device );
499: }
500: }
501: }
502:
503: resetCommand( resetCmd );
504: }
505:
506: /*
507: *
508: *
509: *
510: */
511: bool IOSCSIParallelController::checkBusReset()
512: {
513: if ( busResetState == kStateIdle )
514: {
515: return false;
516: }
517: if ( busResetState == kStateIssue )
518: {
519: reset();
520: }
521: return true;
522: }
523:
524:
525: /*
526: *
527: *
528: *
529: */
530: void IOSCSIParallelController::resetOccurred()
531: {
532: UInt32 i;
533: IOSCSIParallelDevice *device;
534: SCSITarget *target;
535: SCSIClientMessage clientMsg;
536:
537: for (i=0; i < controllerInfo.maxTargetsSupported; i++ )
538: {
539: target = &targets[i];
540:
541: target->commandLimit = target->commandLimitSave;
542: target->reqSenseCount = 0;
543: target->reqSenseState = kStateIdle;
544: target->negotiateState = kStateIssue;
545:
546: target->targetParmsCurrent.transferPeriodpS = 0;
547: target->targetParmsCurrent.transferOffset = 0;
548: target->targetParmsCurrent.transferWidth = 1;
549:
550: noDisconnectCmd = 0;
551:
552: clientMsg = ( busResetState != kStateActive ) ? kSCSIClientMsgBusReset : kSCSIClientMsgNone;
553:
554: queue_iterate( &target->deviceList, device, IOSCSIParallelDevice *, nextDevice )
555: {
556: device->resetOccurred( clientMsg );
557: }
558: }
559:
560: resetTimer = (kSCSIResetIntervalmS / kSCSITimerIntervalmS + 1);
561: }
562:
563:
564: /*
565: *
566: *
567: */
568: void IOSCSIParallelController::timer( IOTimerEventSource * /* timer */ )
569: {
570: UInt32 i;
571: IOSCSIParallelDevice *device;
572:
573:
574: if ( disableTimer )
575: {
576: if ( !--disableTimer )
577: {
578: disableTimeoutOccurred();
579: }
580: }
581:
582: if ( resetTimer )
583: {
584: if ( !--resetTimer )
585: {
586: for (i=0; i < controllerInfo.maxTargetsSupported; i++ )
587: {
588: queue_iterate( &targets[i].deviceList, device, IOSCSIParallelDevice *, nextDevice )
589: {
590: device->resetComplete();
591: }
592: }
593:
594: }
595: }
596: else
597: {
598: for (i=0; i < controllerInfo.maxTargetsSupported; i++ )
599: {
600: queue_iterate( &targets[i].deviceList, device, IOSCSIParallelDevice *, nextDevice )
601: {
602: device->timer();
603: }
604: }
605: }
606:
607: timerEvent->setTimeoutMS(kSCSITimerIntervalmS);
608: }
609:
610:
611: /*
612: *
613: *
614: *
615: */
616: void IOSCSIParallelController::completeCommand( IOSCSIParallelCommand *scsiCmd )
617: {
618: switch ( scsiCmd->cmdType )
619: {
620: case kSCSICommandBusReset:
621: resetOccurred();
622: busResetState = kStateIdle;
623: break;
624: default:
625: ;
626: }
627: }
628:
629:
630: /*
631: *
632: *
633: *
634: */
635: bool IOSCSIParallelController::createWorkLoop()
636: {
637: workLoop = new IOWorkLoop;
638: if ( workLoop == NULL )
639: {
640: return false;
641: }
642:
643: if ( workLoop->init() != true )
644: {
645: return false;
646: }
647:
648: timerEvent = IOTimerEventSource::timerEventSource( this, (IOTimerEventSource::Action) &IOSCSIParallelController::timer );
649: if ( timerEvent == NULL )
650: {
651: return false;
652: }
653:
654: if ( workLoop->addEventSource( timerEvent ) != kIOReturnSuccess )
655: {
656: return false;
657: }
658:
659:
660: dispatchEvent = IOInterruptEventSource::interruptEventSource( this,
661: (IOInterruptEventAction) &IOSCSIParallelController::dispatch,
662: 0 );
663: if ( dispatchEvent == 0 )
664: {
665: return false;
666: }
667:
668: if ( workLoop->addEventSource( dispatchEvent ) != kIOReturnSuccess )
669: {
670: return false;
671: }
672:
673: workLoopReqGate = IOCommandGate::commandGate( this, (IOCommandGate::Action) &IOSCSIParallelController::workLoopProcessRequest );
674: if ( workLoopReqGate == NULL )
675: {
676: return false;
677: }
678:
679: if ( workLoop->addEventSource( workLoopReqGate ) != kIOReturnSuccess )
680: {
681: return false;
682: }
683:
684:
685: return true;
686: }
687:
688: /*
689: *
690: *
691: *
692: */
693: IOSCSIParallelCommand *IOSCSIParallelController::findCommandWithNexus( SCSITargetLun targetLun, UInt32 tagValue = (UInt32)-1 )
694: {
695: IOSCSIParallelDevice *device;
696:
697: device = findDeviceWithTargetLun( targetLun );
698: if ( device == 0 )
699: {
700: return NULL;
701: }
702:
703: return device->findCommandWithNexus( tagValue );
704: }
705:
706:
707: /*
708: *
709: *
710: *
711: */
712: IOSCSIParallelDevice *IOSCSIParallelController::findDeviceWithTargetLun( SCSITargetLun targetLun )
713: {
714: IOSCSIParallelDevice *device;
715:
716: if ( targetLun.target > controllerInfo.maxTargetsSupported || targetLun.lun > controllerInfo.maxLunsSupported )
717: {
718: return 0;
719: }
720:
721: queue_iterate( &targets[targetLun.target].deviceList, device, IOSCSIParallelDevice *, nextDevice )
722: {
723: if ( device->targetLun.lun == targetLun.lun )
724: {
725: return device;
726: }
727: }
728: return 0;
729: }
730:
731:
732: /*
733: *
734: *
735: *
736: */
737: bool IOSCSIParallelController::configureController()
738: {
739: UInt32 targetsSize;
740:
741: if ( configure( provider, &controllerInfo ) == false )
742: {
743: return false;
744: }
745:
746: controllerInfo.commandPrivateDataSize = round( controllerInfo.commandPrivateDataSize, 16 );
747:
748: if ( controllerInfo.maxCommandsPerController == 0 ) controllerInfo.maxCommandsPerController = (UInt32) -1;
749: if ( controllerInfo.maxCommandsPerTarget == 0 ) controllerInfo.maxCommandsPerTarget = (UInt32) -1;
750: if ( controllerInfo.maxCommandsPerLun == 0 ) controllerInfo.maxCommandsPerLun = (UInt32) -1;
751:
752: targetsSize = controllerInfo.maxTargetsSupported * sizeof(SCSITarget);
753: targets = (SCSITarget *)IOMalloc( targetsSize );
754: bzero( targets, targetsSize );
755:
756: commandLimit = commandLimitSave = controllerInfo.maxCommandsPerController;
757:
758: tagArraySize = (controllerInfo.maxTags / 32 + ((controllerInfo.maxTags % 32) ? 1 : 0)) * sizeof(UInt32);
759:
760: if ( controllerInfo.tagAllocationMethod == kTagAllocationPerController )
761: {
762: tagArray = (UInt32 *)IOMalloc( tagArraySize );
763: bzero( tagArray, tagArraySize );
764: }
765:
766: return true;
767: }
768:
769: /*
770: *
771: *
772: *
773: */
774: void IOSCSIParallelController::setCommandLimit( UInt32 newCommandLimit )
775: {
776: if ( newCommandLimit == 0 ) controllerInfo.maxCommandsPerController = (UInt32) -1;
777:
778: commandLimit = commandLimitSave = controllerInfo.maxCommandsPerController;
779: }
780:
781: /*
782: *
783: *
784: *
785: */
786: IOWorkLoop *IOSCSIParallelController::getWorkLoop() const
787: {
788: return workLoop;
789: }
790:
791: /*
792: *
793: *
794: *
795: */
796: void IOSCSIParallelController::disableCommands( UInt32 disableTimeoutmS )
797: {
798: commandDisable = true;
799:
800: disableTimer = ( disableTimeoutmS != 0 ) ? (disableTimeoutmS / kSCSITimerIntervalmS + 1) : 0;
801: }
802:
803:
804: /*
805: *
806: *
807: *
808: */
809: void IOSCSIParallelController::disableCommands()
810: {
811: UInt32 disableTimeout;
812:
813: commandDisable = true;
814:
815: disableTimeout = kSCSIDisableTimeoutmS;
816:
817: if ( noDisconnectCmd != 0 )
818: {
819: disableTimeout = noDisconnectCmd->getTimeout();
820: if ( disableTimeout != 0 ) disableTimeout += kSCSIDisableTimeoutmS;
821: }
822:
823: disableTimer = ( disableTimeout != 0 ) ? (disableTimeout / kSCSITimerIntervalmS + 1) : 0;
824: }
825:
826: /*
827: *
828: *
829: *
830: */
831: void IOSCSIParallelController::disableTimeoutOccurred()
832: {
833: busResetState = kStateIssue;
834: dispatchRequest();
835: }
836:
837:
838: /*
839: *
840: *
841: *
842: */
843: void IOSCSIParallelController::rescheduleCommand( IOSCSICommand *forSCSICmd )
844: {
845: IOSCSIParallelCommand *scsiCmd = (IOSCSIParallelCommand *)forSCSICmd;
846: IOSCSIParallelDevice *device = (IOSCSIParallelDevice *) scsiCmd->getDevice(kIOSCSIDevice);
847:
848: device->rescheduleCommand( scsiCmd );
849: }
850:
851: /*
852: *
853: *
854: *
855: */
856: void IOSCSIParallelController::enableCommands()
857: {
858: commandDisable = false;
859:
860: disableTimer = 0;
861:
862: dispatchRequest();
863: }
864:
865: /*
866: *
867: *
868: *
869: */
870: void IOSCSIParallelController::dispatchRequest()
871: {
872: dispatchEvent->interruptOccurred(0, 0, 0);
873: }
874:
875:
876: /*
877: *
878: *
879: *
880: */
881: void IOSCSIParallelController::dispatch()
882: {
883: SCSITarget *target;
884: IOSCSIParallelDevice *device;
885: UInt32 dispatchAction;
886: UInt32 lunsActive = 0;
887: UInt32 i;
888:
889: if ( checkBusReset() == true )
890: {
891: goto dispatch_Exit;
892: }
893:
894: for ( i = 0; i < controllerInfo.maxTargetsSupported; i++ )
895: {
896: target = &targets[i];
897:
898: if ( target->state == kStateActive )
899: {
900: lunsActive = 0;
901:
902: queue_iterate( &target->deviceList, device, IOSCSIParallelDevice *, nextDevice )
903: {
904: if ( device->dispatch( &dispatchAction ) == true )
905: {
906: lunsActive++;
907: }
908:
909: switch ( dispatchAction )
910: {
911: case kDispatchNextLun:
912: ;
913: case kDispatchNextTarget:
914: break;
915: case kDispatchStop:
916: goto dispatch_Exit;
917: }
918: }
919: if ( lunsActive == 0 )
920: {
921: target->state = kStateIdle;
922: }
923: }
924: }
925:
926: dispatch_Exit:
927: ;
928: }
929:
930: /*
931: *
932: *
933: *
934: */
935: IOSCSIParallelCommand *IOSCSIParallelController::allocCommand(UInt32 clientDataSize )
936: {
937: IOSCSIParallelCommand *cmd;
938: UInt32 size;
939:
940: size = controllerInfo.commandPrivateDataSize + round(clientDataSize, 16);
941:
942: cmd = new IOSCSIParallelCommand;
943: if ( !cmd )
944: {
945: return 0;
946: }
947: cmd->init();
948:
949: if ( size )
950: {
951: cmd->dataArea = (void *)IOMallocContiguous( (vm_size_t)size, 16, 0 );
952: if ( !cmd->dataArea )
953: {
954: cmd->release();
955: return 0;
956: }
957:
958: bzero( cmd->dataArea, size );
959:
960: cmd->dataSize = size;
961:
962: if ( controllerInfo.commandPrivateDataSize )
963: {
964: cmd->commandPrivateData = cmd->dataArea;
965: }
966: if ( clientDataSize )
967: {
968: cmd->clientData = (void *)((UInt8 *)cmd->dataArea + controllerInfo.commandPrivateDataSize);
969: }
970: }
971:
972: cmd->controller = this;
973:
974: return cmd;
975: }
976:
977: /*
978: *
979: *
980: *
981: */
982: void IOSCSIParallelController::free()
983: {
984: UInt32 targetsSize;
985: UInt32 i;
986:
987: if ( timerEvent != 0 ) timerEvent->release();
988:
989: if ( workLoopReqGate != 0 ) workLoopReqGate->release();
990:
991: if ( dispatchEvent != 0 ) dispatchEvent->release();
992:
993: if ( resetCmd != 0 ) resetCmd->release();
994:
995: if ( workLoop != 0 ) workLoop->release();
996:
997: if ( targets != 0 )
998: {
999: for ( i=0; i < controllerInfo.maxTargetsSupported; i++ )
1000: {
1001: if ( targets[i].targetPrivateData != 0 )
1002: {
1003: IOFreeContiguous( targets[i].targetPrivateData, controllerInfo.targetPrivateDataSize );
1004: }
1005: }
1006:
1007: targetsSize = controllerInfo.maxTargetsSupported * sizeof(SCSITarget);
1008: IOFree( targets, targetsSize );
1009: }
1010:
1011: if ( tagArray != 0 ) IOFree( tagArray, tagArraySize );
1012:
1013: super::free();
1014: }
1015:
1016: /*
1017: *
1018: *
1019: *
1020: */
1021: void IOSCSIParallelCommand::free()
1022: {
1023: if ( dataArea )
1024: {
1025: IOFreeContiguous( dataArea, dataSize );
1026: }
1027:
1028: OSObject::free();
1029: }
1030:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.