![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOSCSIHDDrive.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / Families / IOSCSIHDDrive|
Return to IOSCSIHDDrive.cpp CVS log | Up to [Apple XNU] / XNU / iokit / Families / IOSCSIHDDrive |
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: #include <IOKit/IOLib.h>
24: #include <IOKit/IOReturn.h>
25: #include <IOKit/scsi/IOSCSIDeviceInterface.h>
26: #include <IOKit/storage/scsi/IOSCSIHDDrive.h>
27: #include <IOKit/storage/scsi/IOSCSIHDDriveNub.h>
28:
29:
30: /* Device types that we intend to handle. */
31:
32: const UInt8 DT_DIRACCESS = 0x00; /* direct access disk */
33:
34: #define super IOBasicSCSI
35: OSDefineMetaClassAndStructors(IOSCSIHDDrive,IOBasicSCSI)
36:
37: IOReturn
38: IOSCSIHDDrive::allocateFormatBuffer(UInt8 **buf,UInt32 *len)
39: {
40: /* The default implementation uses no buffer. */
41:
42: *buf = 0;
43: *len = 0;
44: return(kIOReturnSuccess);
45: }
46:
47: UInt8
48: IOSCSIHDDrive::composeFormatBuffer(UInt8 * /* buf */,UInt32 /* buflen */)
49: {
50: return(0); /* default: no fmtdata buffer to transfer */
51: }
52:
53: OSDictionary *
54: IOSCSIHDDrive::constructDeviceProperties(void)
55: {
56: OSDictionary *propTable;
57: OSData *prop;
58: char *typeString;
59:
60: propTable = OSDictionary::withCapacity(6);
61:
62: if (propTable) {
63:
64: prop = OSData::withBytes((void *)(&_vendor),strlen(_vendor));
65: if (prop) {
66: propTable->setObject("vendor", prop);
67: }
68:
69: prop = OSData::withBytes((void *)(&_product),strlen(_product));
70: if (prop) {
71: propTable->setObject("product", prop);
72: }
73:
74: prop = OSData::withBytes((void *)(&_rev),strlen(_rev));
75: if (prop) {
76: propTable->setObject("revision", prop);
77: }
78:
79: typeString = (char *)getDeviceTypeName();
80: prop = OSData::withBytes((void *)(typeString),strlen(typeString));
81: if (prop) {
82: propTable->setObject("device-type", prop);
83: }
84:
85: #ifdef xxx
86: prop = OSData::withBytes((void *)(&_removable),sizeof(bool));
87: if (prop) {
88: propTable->setObject("removable", prop);
89: }
90:
91: prop = OSData::withBytes((void *)(&_ejectable),sizeof(bool));
92: if (prop) {
93: propTable->setObject("ejectable", prop);
94: }
95: #endif //xxx
96:
97: }
98:
99: return(propTable);
100: }
101:
102: UInt32
103: IOSCSIHDDrive::createFormatCdb(UInt64 /* byteCapacity */,
104: UInt8 *cdb,UInt32 *cdbLength,
105: UInt8 buf[],UInt32 bufLen,
106: UInt32 *maxAutoSenseLength,UInt32 *timeoutSeconds)
107: {
108: struct IOFormatcdb *c;
109: UInt8 formatControls; /* CmpLst & Defect List Format bits */
110:
111: c = (struct IOFormatcdb *)cdb;
112:
113: c->opcode = SOP_FORMAT;
114: c->lunbits = 0;
115: c->vendor = 0;
116: c->interleave_msb = 0;
117: c->interleave_lsb = 0;
118: c->ctlbyte = 0;
119:
120: *cdbLength = 6;
121:
122: /* If we are to use a format buffer, set it up: */
123:
124: if (buf != NULL) {
125: formatControls = composeFormatBuffer(buf,bufLen);
126: c->lunbits |= (formatControls | 0x10); /* data transfer will occur */
127: }
128:
129: *maxAutoSenseLength = sizeof(SCSISenseData); /* do the sense */
130: *timeoutSeconds = 15 * 60; /* a nice long time */
131:
132: return(0);
133: }
134:
135: IOService *
136: IOSCSIHDDrive::createNub(void)
137: {
138: IOService *nub;
139:
140: // IOLog("%s[IOSCSIHDDrive]::createNub\n",getName());
141:
142: /* Instantiate a nub so a generic driver can match above us. */
143:
144: nub = instantiateNub();
145: if (nub == NULL) {
146: IOLog("%s[IOSCSIHDDrive]::createNub; nub didn't instantiate\n",getName());
147: return(NULL);
148: }
149:
150: nub->init();
151:
152: if (!nub->attach(this)) {
153: IOPanic("IOSCSIHDDrive::createNub; couldn't attach IOSCSIHDDriveNub");
154: }
155:
156: nub->registerService();
157:
158: return(nub);
159: }
160:
161: void
162: IOSCSIHDDrive::deleteFormatBuffer(UInt8 * /* buf */, UInt32 /* buflen */)
163: {
164: /* The default implementation has no buffer to free. */
165: }
166:
167: bool
168: IOSCSIHDDrive::deviceTypeMatches(UInt8 inqBuf[],UInt32 inqLen)
169: {
170: if ((_inqBuf[0] & 0x1f) == DT_DIRACCESS) {
171: return(true);
172: } else {
173: return(false); /* we don't handle other devices */
174: }
175: }
176:
177: IOReturn
178: IOSCSIHDDrive::doAsyncReadWrite(IOMemoryDescriptor *buffer,
179: UInt32 block,UInt32 nblks,
180: gdCompletionFunction action,
181: IOService *target,void *param)
182: {
183: /**
184: IOLog("IOSCSIHDDrive::doAsyncReadWrite: target=%08x,action=%08x,param=%08x\n",
185: (int)target,(int)action,(int)param);
186: **/
187: return(standardAsyncReadWrite(buffer,block,nblks,action,target,param));
188: }
189:
190: IOReturn
191: IOSCSIHDDrive::doEjectMedia(void)
192: {
193: /* Spin down, eject, and leave power alone: */
194:
195: return(doStartStop(false,true,IOStartStopcdb::P_NOCHANGE));
196: }
197:
198: IOReturn
199: IOSCSIHDDrive::doFormatMedia(UInt64 byteCapacity)
200: {
201: struct context *cx;
202: UInt8 *fmtbuf;
203: IOReturn result;
204: IOSCSICommand *req;
205: SCSICDBInfo scsiCDB;
206: UInt32 transferLength;
207: UInt32 senseLength;
208: UInt32 timeoutSeconds;
209:
210: cx = allocateContext();
211: if (cx == NULL) {
212: return(kIOReturnNoMemory);
213: }
214:
215: req = cx->scsireq;
216:
217: /* Allow a subclass to construct the cdb and return an optional
218: * memory buffer address for defect lists, etc.
219: */
220:
221: result = allocateFormatBuffer(&fmtbuf,&transferLength);
222: if (result != kIOReturnSuccess) {
223: return(result);
224: }
225:
226: bzero( &scsiCDB, sizeof(scsiCDB) );
227:
228: scsiCDB.cdbFlags |= createFormatCdb(byteCapacity,(UInt8 *)&scsiCDB.cdb,&scsiCDB.cdbLength,
229: fmtbuf,transferLength,
230: &senseLength,
231: &timeoutSeconds);
232:
233: req->setCDB( &scsiCDB );
234: req->setPointers( cx->senseDataDesc, senseLength, false, true );
235: req->setTimeout( timeoutSeconds * 1000 );
236:
237: /* If we have a buffer to transfer, create a Memory Descriptor for it: */
238:
239: if ((fmtbuf != NULL) && (transferLength != 0)) {
240: cx->memory = IOMemoryDescriptor::withAddress((void *)fmtbuf,
241: transferLength,
242: kIODirectionOut);
243: }
244:
245: req->setPointers( cx->memory, transferLength, true );
246: queueCommand(cx,kSync,getFormatMediaPowerState()); /* queue the operation, sleep awaiting power */
247:
248: result = simpleSynchIO(cx); /* issue a simple command */
249:
250: /* Free the format buffer, if any: */
251:
252: deleteFormatBuffer(fmtbuf,transferLength);
253:
254: deleteContext(cx);
255:
256: return(result);
257: }
258:
259: UInt32
260: IOSCSIHDDrive::doGetFormatCapacities(UInt64 * capacities,
261: UInt32 capacitiesMaxCount) const
262: {
263: if ((capacities != NULL) && (capacitiesMaxCount > 0)) {
264: *capacities = _blockSize * (_maxBlock + 1);
265: return(1);
266: } else {
267: return(0);
268: }
269: }
270:
271: /* We issue a simple Prevent/Allow command to lock or unlock the media: */
272: IOReturn
273: IOSCSIHDDrive::doLockUnlockMedia(bool doLock)
274: {
275: struct context *cx;
276: struct IOPrevAllowcdb *c;
277: IOSCSICommand *req;
278: SCSICDBInfo scsiCDB;
279: IOReturn result;
280:
281: cx = allocateContext();
282: if (cx == NULL) {
283: return(kIOReturnNoMemory);
284: }
285:
286: req = cx->scsireq;
287:
288: bzero( &scsiCDB, sizeof(scsiCDB) );
289:
290: c = (struct IOPrevAllowcdb *)&scsiCDB.cdb;
291:
292: c->opcode = SOP_PREVALLOW;
293: c->lunbits = 0;
294: c->reserved1 = 0;
295: c->reserved2 = 0;
296:
297: if (doLock) {
298: c->prevent = 0x01; /* prevent removal from device */
299: } else {
300: c->prevent = 0x00; /* allow removal from device */
301: }
302:
303: c->ctlbyte = 0;
304:
305: scsiCDB.cdbLength = 6;
306:
307: req->setCDB( &scsiCDB );
308:
309: cx->memory = 0;
310:
311: req->setPointers( cx->memory, 0, false );
312:
313: queueCommand(cx,kSync,getLockUnlockMediaPowerState()); /* queue the operation, sleep awaiting power */
314:
315: result = simpleSynchIO(cx);
316:
317: deleteContext(cx);
318:
319: return(result);
320: }
321:
322: IOReturn
323: IOSCSIHDDrive::doStart(void)
324: {
325: return(doStartStop(true,false,IOStartStopcdb::P_ACTIVE));
326: }
327:
328: IOReturn
329: IOSCSIHDDrive::doStop(void)
330: {
331: return(doStartStop(false,false,IOStartStopcdb::P_NOCHANGE));
332: }
333:
334: IOReturn
335: IOSCSIHDDrive::doStartStop(bool start,bool loadEject,UInt8 powerCondition)
336: {
337: struct context *cx;
338: struct IOStartStopcdb *c;
339: IOSCSICommand *req;
340: SCSICDBInfo scsiCDB;
341: IOReturn result;
342: UInt32 powerLevel; /* what power level we need to be in */
343:
344: /* Issue a Start/Stop Unit command. */
345:
346: cx = allocateContext();
347: if (cx == NULL) {
348: return(kIOReturnNoMemory);
349: }
350:
351: powerLevel = getStopPowerState(); /* assume we're spinning down */
352: req = cx->scsireq;
353:
354: bzero( &scsiCDB, sizeof(SCSICDBInfo) );
355:
356: c = (struct IOStartStopcdb *)&scsiCDB.cdb;
357: c->opcode = SOP_STARTSTOP;
358: c->lunImmed = 0;
359: c->reserved1 = 0;
360: c->reserved2 = 0;
361: c->controls = powerCondition;
362: c->controls = 0; /* xxx powerCondition is a SCSI-3 thing */
363: if (loadEject) {
364: c->controls |= IOStartStopcdb::C_LOEJ;
365: powerLevel = getEjectPowerState(); /* let subclass decide what we need */
366: };
367: if (start) {
368: c->controls |= IOStartStopcdb::C_SPINUP;
369: powerLevel = getStartPowerState();
370: }
371: c->ctlbyte = 0;
372:
373: scsiCDB.cdbLength = 6;
374:
375: req->setCDB( &scsiCDB );
376: req->setTimeout( 10000 );
377:
378: cx->memory = 0;
379:
380: req->setPointers( cx->memory, 0, false );
381:
382: queueCommand(cx,kSync,powerLevel); /* queue the operation, sleep awaiting power */
383:
384: result = simpleSynchIO(cx);
385:
386: deleteContext(cx);
387: return(result);
388: }
389:
390: IOReturn
391: IOSCSIHDDrive::doSynchronizeCache(void)
392: {
393: struct context *cx;
394: struct IOSyncCachecdb *c;
395: IOSCSICommand *req;
396: SCSICDBInfo scsiCDB;
397: IOReturn result;
398:
399: cx = allocateContext();
400: if (cx == NULL) {
401: return(kIOReturnNoMemory);
402: }
403:
404: req = cx->scsireq;
405: bzero( &scsiCDB, sizeof(scsiCDB) );
406:
407: c = (struct IOSyncCachecdb *)&scsiCDB.cdb;
408:
409: c->opcode = SOP_SYNCCACHE;
410: c->lunbits = 0;
411: c->lba_3 = 0; /* if zero, start at block zero */
412: c->lba_2 = 0;
413: c->lba_1 = 0;
414: c->lba_0 = 0;
415: c->reserved = 0;
416: c->nblks_msb = 0; /* if zero, do all blocks */
417: c->nblks_lsb = 0;
418: c->ctlbyte = 0;
419:
420: scsiCDB.cdbLength = 10;
421:
422: req->setCDB( &scsiCDB );
423:
424: cx->memory = 0;
425:
426: req->setPointers( cx->memory, 0, false );
427:
428: /* We assume there will be some data in the drive's cache, so we force the
429: * drive to be running before we issue this command.
430: */
431:
432: queueCommand(cx,kSync,getSynchronizeCachePowerState()); /* queue the operation, sleep awaiting power */
433:
434: result = simpleSynchIO(cx);
435:
436: deleteContext(cx);
437:
438: return(result);
439: }
440:
441: IOReturn
442: IOSCSIHDDrive::doSyncReadWrite(IOMemoryDescriptor *buffer,UInt32 block,UInt32 nblks)
443: {
444: return(standardSyncReadWrite(buffer,block,nblks));
445: }
446:
447: const char *
448: IOSCSIHDDrive::getDeviceTypeName(void)
449: {
450: return(kDeviceTypeHardDisk);
451: }
452:
453: UInt32
454: IOSCSIHDDrive::getEjectPowerState(void)
455: {
456: return(kElectronicsOn);
457: }
458:
459: UInt32
460: IOSCSIHDDrive::getExecuteCDBPowerState(void)
461: {
462: return(kAllOn);
463: }
464:
465: UInt32
466: IOSCSIHDDrive::getFormatMediaPowerState(void)
467: {
468: return(kAllOn);
469: }
470:
471: UInt32
472: IOSCSIHDDrive::getInitialPowerState(void)
473: {
474: return(kAllOn);
475: }
476:
477: UInt32
478: IOSCSIHDDrive::getInquiryPowerState(void)
479: {
480: return(kElectronicsOn);
481: }
482:
483: UInt32
484: IOSCSIHDDrive::getLockUnlockMediaPowerState(void)
485: {
486: return(kElectronicsOn);
487: }
488:
489: UInt32
490: IOSCSIHDDrive::getReadCapacityPowerState(void)
491: {
492: return(kElectronicsOn);
493: }
494:
495: UInt32
496: IOSCSIHDDrive::getReadWritePowerState(void)
497: {
498: return(kAllOn);
499: }
500:
501: UInt32
502: IOSCSIHDDrive::getReportWriteProtectionPowerState(void)
503: {
504: return(kElectronicsOn);
505: }
506:
507: UInt32
508: IOSCSIHDDrive::getStartPowerState(void)
509: {
510: return(kElectronicsOn);
511: }
512:
513: UInt32
514: IOSCSIHDDrive::getStopPowerState(void)
515: {
516: return(kElectronicsOn); /* we don't have to be spinning to spin down */
517: }
518:
519: UInt32
520: IOSCSIHDDrive::getSynchronizeCachePowerState(void)
521: {
522: return(kAllOn);
523: }
524:
525: UInt32
526: IOSCSIHDDrive::getTestUnitReadyPowerState(void)
527: {
528: return(kElectronicsOn);
529: }
530:
531: bool
532: IOSCSIHDDrive::init(OSDictionary * properties)
533: {
534: _mediaPresent = false;
535: _startStopDisabled = false;
536:
537: return(super::init(properties));
538: }
539:
540: IOService *
541: IOSCSIHDDrive::instantiateNub(void)
542: {
543: IOService *nub;
544:
545: /* Instantiate a nub so a generic driver can match above us. */
546:
547: nub = new IOSCSIHDDriveNub;
548: return(nub);
549: }
550:
551: bool
552: IOSCSIHDDrive::powerTickle(UInt32 desiredState)
553: {
554: return(activityTickle(kIOPMSuperclassPolicy1,desiredState));
555: }
556:
557: IOReturn
558: IOSCSIHDDrive::reportMediaState(bool *mediaPresent,bool *changed)
559: {
560: struct context *cx;
561: struct IOTURcdb *c;
562: IOSCSICommand *req;
563: SCSICDBInfo scsiCDB;
564: SCSIResults scsiResults;
565: IOReturn result;
566: UInt8 status;
567: UInt8 senseKey;
568:
569: cx = allocateContext();
570: if (cx == NULL) {
571: return(kIOReturnNoMemory);
572: }
573:
574: req = cx->scsireq;
575:
576: bzero( &scsiCDB, sizeof(scsiCDB) );
577:
578: c = (struct IOTURcdb *)&scsiCDB.cdb;
579: c->opcode = SOP_TUR;
580: c->lunbits = 0;
581: c->reserved1 = 0;
582: c->reserved2 = 0;
583: c->reserved3 = 0;
584: c->ctlbyte = 0;
585:
586: scsiCDB.cdbLength = 6;
587:
588: req->setCDB( &scsiCDB );
589: req->setPointers( cx->senseDataDesc, 255, false, true );
590:
591: req->setTimeout( 2000 );
592:
593: cx->memory = 0;
594:
595: req->setPointers( cx->memory, 0, false );
596:
597: /**
598: IOLog("IOSCSIHDDrive::reportMediaState: mp=%08x,ch=%08x\n",
599: (int)mediaPresent,(int)changed);
600: IOLog("IOSCSIHDDrive::reportMediaState: doing TUR\n");
601: **/
602:
603: queueCommand(cx,kSync,getTestUnitReadyPowerState());
604: result = simpleSynchIO(cx);
605:
606: req->getResults( &scsiResults );
607:
608: status = scsiResults.scsiStatus;
609:
610: /**
611: IOLog("%s[IOSCSIHDDrive]::reportMediaState; result=%s, status=%02x,sense=%02x\n",
612: getName(),stringFromReturn(result),status,cx->senseData->senseKey
613: );
614: **/
615:
616: if (result == kIOReturnSuccess) { /* TUR succeeded; device is ready */
617:
618: *mediaPresent = true;
619: *changed = (*mediaPresent != _mediaPresent); /* report if it's changed */
620: _mediaPresent = true; /* remember current state */
621: result = kIOReturnSuccess;
622:
623: } else { /* TUR failed; check sense key */
624:
625: if ( scsiResults.requestSenseDone == true ) {
626: senseKey = cx->senseData->senseKey;
627:
628: if (senseKey == 0x02) { /* device says "not ready" */
629: *mediaPresent = false;
630: *changed = (*mediaPresent != _mediaPresent); /* report if it's changed */
631: _mediaPresent = false; /* remember current state */
632: result = kIOReturnSuccess;
633:
634: } else { /* funky sense key? forget it. */
635:
636: *mediaPresent = false;
637: *changed = (*mediaPresent != _mediaPresent); /* report if it's changed */
638: _mediaPresent = false; /* remember current state */
639: result = kIOReturnIOError;
640: }
641: }
642: }
643:
644: deleteContext(cx);
645:
646: #ifndef DISKPM
647: if (*changed && *mediaPresent)
648: doStart();
649: #endif
650:
651: return(result);
652: }
653:
654: IOReturn
655: IOSCSIHDDrive::restoreElectronicsState(void)
656: {
657: return(kIOReturnSuccess);
658: }
659:
660: /* The standard completion for a doAsyncReadWrite operation. We fire it
661: * up to our target, the generic driver.
662: */
663: void
664: IOSCSIHDDrive::RWCompletion(struct context *cx)
665: {
666: SCSIResults scsiResults;
667:
668: /** IOLog("IOSCSIHDDrive::RWCompletion: cx=%08x,target=%08x,action=%08x,param=%08x\n",
669: (int)cx,(int)cx->completion.target,(int)cx->completion.action,(int)cx->completion.param);
670: **/
671: cx->scsireq->getResults( &scsiResults );
672: (*cx->completion.action)(cx->completion.target,cx->completion.param,
673: scsiResults.bytesTransferred,
674: scsiResults.returnCode);
675:
676:
677: /* Attempt to dequeue and execute any waiting commands: */
678:
679: dequeueCommands();
680: }
681:
682: IOReturn
683: IOSCSIHDDrive::saveElectronicsState(void)
684: {
685: return(kIOReturnSuccess);
686: }
687:
688: static IOPMPowerState ourPowerStates[kNumberOfPowerStates] = {
689: {1,IOPMNotAttainable,0,0,0,0,0,0,0,0,0,0}, /* state 00 kAllOff */
690: {1,0,0,IOPMPowerOn,0,0,0,0,0,0,0,0}, /* state 01 kElectronicsOn */
691: {1,0,0,IOPMPowerOn,0,0,0,0,0,0,0,0} /* state 02 kAllOn */
692: };
693:
694:
695: bool
696: IOSCSIHDDrive::start(IOService *provider)
697: {
698: IOService *nub;
699:
700: if (!super::start(provider)) {
701: return(false);
702: }
703:
704: // IOLog("%s[IOSCSIHDDrive]::start\n",getName());
705:
706: /* Initialize and set up to perform Power Management: */
707:
708: PMinit();
709: _restoreState = false;
710: #ifdef notyet // don't register for PM yet till we handle queuing requests!
711: IOPMRegisterDevice(pm_vars->ourName,this); // join the power management tree
712: #endif
713: registerControllingDriver(this,ourPowerStates,kNumberOfPowerStates); // export power states
714:
715: nub = createNub();
716: if (nub == NULL) {
717: return(false);
718: } else {
719: return(true);
720: }
721: }
722:
723: // **********************************************************************************
724: // maxCapabilityForDomainState
725: //
726: // This simple device needs only power. If the power domain is supplying
727: // power, the disk can go to its highest state. If there is no power
728: // it can only be in its lowest state, which is off.
729: // **********************************************************************************
730:
731: unsigned long
732: IOSCSIHDDrive::maxCapabilityForDomainState(IOPMPowerFlags domainState)
733: {
734: if (domainState & IOPMPowerOn) {
735: return(kAllOn);
736: } else {
737: return(kAllOff);
738: }
739: }
740:
741: // **********************************************************************************
742: // powerStateForDomainState
743: //
744: // The power domain may be changing state. If power is ON in its new
745: // state, we will be on, too. If domain power is OFF, we are off.
746: // **********************************************************************************
747: unsigned long
748: IOSCSIHDDrive::powerStateForDomainState(IOPMPowerFlags domainState)
749: {
750: if (domainState & IOPMPowerOn) {
751: return(kAllOn); /* xxx might be kElectronicsOn if drive not spun up */
752: } else {
753: return(kAllOff);
754: }
755: }
756:
757: // **********************************************************************************
758: // initialPowerStateForDomainState
759: //
760: // Our parent wants to know what our initial power state is. If power is ON in the
761: // domain, we are in state kElectronicsOn or kAllOn. If domain power is OFF, we are off.
762: // **********************************************************************************
763: unsigned long
764: IOSCSIHDDrive::initialPowerStateForDomainState(IOPMPowerFlags domainState)
765: {
766: if (domainState & IOPMPowerOn) {
767: return(getInitialPowerState()); /* report whether it's spinning on startup */
768: } else {
769: return(kAllOff);
770: }
771: }
772:
773: // **********************************************************************************
774: // setPowerState
775: //
776: // Someone has decided to change the disk state. We perform the change here.
777: // **********************************************************************************
778: IOReturn
779: IOSCSIHDDrive::setPowerState(unsigned long powerStateOrdinal,IOService *)
780: {
781: IOReturn result;
782:
783: result = kIOReturnSuccess;
784:
785: /* All we do in the default implementation is spin up and down. If the drive reports an
786: * error to a start/stop command, we don't bother attempting to issue those commands again.
787: *
788: * xxx Question: What should we return? Success? or an error meaning "we didn't do it!"
789: */
790: switch (powerStateOrdinal) {
791:
792: case kElectronicsOn : /* spin down if necessary */
793: if (pm_vars->myCurrentState == kAllOn) {
794: if (!_startStopDisabled) {
795: result = doStop();
796: if (result != kIOReturnSuccess) {
797: _startStopDisabled = true;
798: result = kIOReturnSuccess;
799: }
800: }
801: }
802: break;
803:
804: case kAllOn : /* spin up if necessary */
805: if (pm_vars->myCurrentState == kElectronicsOn) {
806: if (!_startStopDisabled) {
807: result = doStart();
808: if (result != kIOReturnSuccess) {
809: _startStopDisabled = true;
810: result = kIOReturnSuccess;
811: }
812: }
813: }
814: break;
815:
816: default: /* we don't do other states */
817: result = kIOReturnSuccess;
818: break;
819:
820: }
821:
822: return(result);
823: }
824:
825: // **********************************************************************************
826: /* We get called here as an advisory that the power state will change. If we are coming up
827: * from the all-off state, remember to restore the electronics state when we later power up.
828: * If we are powering-down the electronics, save any required state now.
829: */
830: IOReturn
831: IOSCSIHDDrive::powerStateWillChangeTo(unsigned long,unsigned long stateOrdinal,IOService *)
832: {
833: if ((pm_vars->myCurrentState == kAllOff) &&
834: (stateOrdinal > kAllOff)) { /* we're powering up from all-off */
835: _restoreState = true;
836: }
837:
838: if ((stateOrdinal == kAllOff) &&
839: (pm_vars->myCurrentState > kAllOff)) { /* we're powering down to all-off */
840: saveElectronicsState();
841: }
842:
843: return(IOPMAckImplied);
844: }
845:
846: // **********************************************************************************
847: /* We get called here when power has successfully changed state. */
848: IOReturn
849: IOSCSIHDDrive::powerStateDidChangeTo(unsigned long,unsigned long stateOrdinal,IOService*)
850: {
851: IOReturn result;
852:
853: /* If we must restore the electronics state, do it now. */
854:
855: if (_restoreState) {
856: result = restoreElectronicsState();
857: _restoreState = false;
858: }
859:
860: /* If we have powered up into a state that can execute commands, release any queued
861: * requests that were awaiting the power change.
862: */
863:
864: if (stateOrdinal > kAllOff) {
865: dequeueCommands();
866: }
867:
868: return IOPMAckImplied;
869: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.