![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to IOSCSIHDDrive.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / iokit / IOKit / storage / scsi|
Return to IOSCSIHDDrive.h CVS log | Up to [Apple XNU] / XNU / iokit / IOKit / storage / scsi |
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: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 24: * ! 25: * IOSCSIHDDrive.h ! 26: * ! 27: * This class implements SCSI hard disk functionality. ! 28: * ! 29: * Subclasses may modify the operations to handle device-specific variations. ! 30: */ ! 31: ! 32: #ifndef _IOSCSIHDDRIVE_H ! 33: #define _IOSCSIHDDRIVE_H ! 34: ! 35: #include <IOKit/IOTypes.h> ! 36: //xxx#include <IOKit/storage/IOStorage.h> ! 37: #include <IOKit/scsi/IOSCSIDeviceInterface.h> ! 38: #include <IOKit/storage/scsi/IOBasicSCSI.h> ! 39: ! 40: /* SCSI operation codes: */ ! 41: ! 42: const UInt8 SOP_FORMAT = 0x04; /* format unit */ ! 43: const UInt8 SOP_STARTSTOP = 0x1b; /* start/stop unit */ ! 44: const UInt8 SOP_PREVALLOW = 0x1e; /* prevent/allow removal */ ! 45: const UInt8 SOP_SYNCCACHE = 0x35; /* synchronize cache */ ! 46: ! 47: struct IOFormatcdb { ! 48: UInt8 opcode; /* 0x12 */ ! 49: UInt8 lunbits; /* lun and control bits */ ! 50: UInt8 vendor; ! 51: UInt8 interleave_msb; ! 52: UInt8 interleave_lsb; ! 53: UInt8 ctlbyte; ! 54: }; ! 55: ! 56: struct IOPrevAllowcdb { ! 57: UInt8 opcode; ! 58: UInt8 lunbits; ! 59: UInt8 reserved1; ! 60: UInt8 reserved2; ! 61: UInt8 prevent; ! 62: UInt8 ctlbyte; ! 63: }; ! 64: ! 65: struct IOStartStopcdb { ! 66: UInt8 opcode; ! 67: UInt8 lunImmed; ! 68: UInt8 reserved1; ! 69: UInt8 reserved2; ! 70: ! 71: /* Control bits: */ ! 72: /* Power Conditions */ ! 73: static const UInt8 P_NOCHANGE = 0x00; /* 0 - no change */ ! 74: static const UInt8 P_ACTIVE = 0x10; /* 1 - change to Active */ ! 75: static const UInt8 P_IDLE = 0x20; /* 2 - change to Idle */ ! 76: static const UInt8 P_STANDBY = 0x30; /* 3 - change to Standby */ ! 77: static const UInt8 P_RESERVED4 = 0x40; /* 4 - reserved */ ! 78: static const UInt8 P_SLEEP = 0x50; /* 5 - change to Sleep */ ! 79: static const UInt8 P_RESERVED6 = 0x60; /* 6 - reserved */ ! 80: static const UInt8 P_LUNCONTROL = 0x70; /* 7 - give pwr ctl to LUN */ ! 81: static const UInt8 P_RESERVED8 = 0x80; /* 8 - reserved */ ! 82: static const UInt8 P_RESERVED9 = 0x90; /* 9 - reserved */ ! 83: static const UInt8 P_TIDLEZERO = 0xa0; /* a - force Idle Cond Timer = 0 */ ! 84: static const UInt8 P_TSTDBYZERO = 0xb0; /* b - force Stby Cond Timer = 0 */ ! 85: ! 86: static const UInt8 C_LOEJ = 0x02; /* load on start/eject on stop */ ! 87: static const UInt8 C_SPINUP = 0x01; ! 88: static const UInt8 C_SPINDOWN = 0x00; ! 89: ! 90: UInt8 controls; ! 91: UInt8 ctlbyte; ! 92: }; ! 93: ! 94: struct IOSyncCachecdb { ! 95: UInt8 opcode; ! 96: UInt8 lunbits; ! 97: UInt8 lba_3; /* msb */ ! 98: UInt8 lba_2; ! 99: UInt8 lba_1; ! 100: UInt8 lba_0; /* lsb */ ! 101: UInt8 reserved; ! 102: UInt8 nblks_msb; ! 103: UInt8 nblks_lsb; ! 104: UInt8 ctlbyte; ! 105: }; ! 106: ! 107: /*! ! 108: * @enum Power States ! 109: * @discussion ! 110: * We define and understand three basic, generic power states. A subclass may change ! 111: * the power management logic, but all power-management routines should be examined ! 112: * if anything is changed. The only routines that deal directly with these values ! 113: * are directly related to power management. All other functions merely ask for and ! 114: * pass along power state values. ! 115: * @constant kAllOff ! 116: * The power state for an all-off condition. ! 117: * @constant kElectronicsOn ! 118: * The power state for the electronics on, but the media off. ! 119: * @constant kAllOn ! 120: * The power state for the electronics and media on. ! 121: * @constant kNumberOfPowerStates ! 122: * The maximum enum value. ! 123: */ ! 124: enum { /* electronics mechanical */ ! 125: kAllOff = 0, /* OFF OFF */ ! 126: kElectronicsOn = 1, /* ON OFF */ ! 127: kAllOn = 2, /* ON ON */ ! 128: ! 129: kNumberOfPowerStates = 3 ! 130: }; ! 131: ! 132: /*! ! 133: * @class ! 134: * IOSCSIHDDrive : public IOBasicSCSI ! 135: * @abstract ! 136: * SCSI Hard Disk driver. ! 137: * @discussion ! 138: * IOSCSIHDDrive derives from IOBasicSCSI and adds all functionality ! 139: * needed to support removable or fixed hard disk drives. ! 140: */ ! 141: ! 142: class IOSCSIHDDrive : public IOBasicSCSI { ! 143: ! 144: OSDeclareDefaultStructors(IOSCSIHDDrive) ! 145: ! 146: public: ! 147: ! 148: /* Overrides from IOService: */ ! 149: ! 150: virtual bool init(OSDictionary * properties); ! 151: ! 152: /*! ! 153: * @function start ! 154: * @abstract ! 155: * Start the driver. ! 156: * @discussion ! 157: * We override IOBasicSCSI::start so we can initialize Power Management, ! 158: * then we call createNub to create an IOSCSIHDDriveNub. ! 159: */ ! 160: virtual bool start(IOService * provider); ! 161: ! 162: /* Overrides from IOBasicSCSI: */ ! 163: ! 164: /*! ! 165: * @function deviceTypeMatches ! 166: * @abstract ! 167: * Determine if device type matches expected type. ! 168: * @discussion ! 169: * We implement this function so we can return a match ! 170: * on the hard disk device type. ! 171: */ ! 172: virtual bool deviceTypeMatches(UInt8 inqBuf[],UInt32 inqLen); ! 173: ! 174: /*! ! 175: * @function constructDeviceProperties ! 176: * @abstract ! 177: * Construct a set of properties about the device. ! 178: * @discussion ! 179: * This function creates a set of properties reflecting information ! 180: * about the device. ! 181: * ! 182: * This function is presently not used. ! 183: * @result ! 184: * A pointer to an OSDictionary containing the properties. The caller ! 185: * is responsible for releasing the OSDictionary. ! 186: */ ! 187: virtual OSDictionary *constructDeviceProperties(void); ! 188: ! 189: /*! ! 190: * @function RWCompletion ! 191: * @abstract ! 192: * Asynchronous read/write completion routine. ! 193: * @discussion ! 194: * We implement this function in this class. It is called from the base ! 195: * class when an IO operation completes. ! 196: */ ! 197: virtual void RWCompletion(struct context *cx); ! 198: ! 199: /* End of IOBasicSCSI overrides */ ! 200: ! 201: /* Additional API added to IOBasicSCSI: */ ! 202: ! 203: /*! ! 204: * @function doAsyncReadWrite ! 205: * @abstract ! 206: * Start an asynchronous read or write operation. ! 207: * @discussion ! 208: * See IOHDDriveNub for details. ! 209: */ ! 210: virtual IOReturn doAsyncReadWrite(IOMemoryDescriptor *buffer, ! 211: UInt32 block,UInt32 nblks, ! 212: gdCompletionFunction action, ! 213: IOService *target,void *param); ! 214: ! 215: /*! ! 216: * @function doSyncReadWrite ! 217: * @abstract ! 218: * Perform a synchronous read or write operation. ! 219: * @discussion ! 220: * See IOHDDriveNub for details. ! 221: */ ! 222: virtual IOReturn doSyncReadWrite(IOMemoryDescriptor *buffer,UInt32 block,UInt32 nblks); ! 223: ! 224: /*! ! 225: * @function doEjectMedia ! 226: * @abstract ! 227: * Eject the media. ! 228: * @discussion ! 229: * See IOHDDriveNub for details. ! 230: */ ! 231: virtual IOReturn doEjectMedia(void); ! 232: ! 233: /*! ! 234: * @function doFormatMedia ! 235: * @abstract ! 236: * Format the media to the specified byte capacity. ! 237: * @discussion ! 238: * The default implementation ignores the byteCapacity parameter. ! 239: * See IOHDDriveNub for details. ! 240: */ ! 241: virtual IOReturn doFormatMedia(UInt64 byteCapacity); ! 242: ! 243: /*! ! 244: * @function doGetFormatCapacities ! 245: * @abstract ! 246: * Return the allowable formatting byte capacities. ! 247: * @discussion ! 248: * The default implementation of this method returns a value of block ! 249: * size * max block, and a capacities count of 1. ! 250: * See IOHDDriveNub for details. ! 251: */ ! 252: virtual UInt32 doGetFormatCapacities(UInt64 * capacities, ! 253: UInt32 capacitiesMaxCount) const; ! 254: ! 255: /*! ! 256: * @function doLockUnlockMedia ! 257: * @abstract ! 258: * Lock or unlock the (removable) media in the drive. ! 259: * @discussion ! 260: * This method issues a standard SCSI Prevent/Allow command to lock ! 261: * or unlock the media in the drive. ! 262: * See IOHDDriveNub for details. ! 263: */ ! 264: virtual IOReturn doLockUnlockMedia(bool doLock); ! 265: ! 266: /*! ! 267: * @function doSynchronizeCache ! 268: * @abstract ! 269: * Force data blocks in the drive's buffer to be flushed to the media. ! 270: * @discussion ! 271: * This method issues a SCSI Synchronize Cache command, to ensure that ! 272: * all blocks in the device cache are written to the media. ! 273: * See IOHDDriveNub for details. ! 274: */ ! 275: virtual IOReturn doSynchronizeCache(void); ! 276: ! 277: /*! ! 278: * @function reportMediaState ! 279: * @abstract ! 280: * Report the device's media state. ! 281: * @discussion ! 282: * This method reports whether media is present or not, and also ! 283: * whether the media state has changed since the last call to ! 284: * reportMediaState. The default implementation issues a SCSI Test ! 285: * Unit Ready command: depending on the result of that command, the ! 286: * following cases are reported: ! 287: * ! 288: * 1. TUR status == good completion: we report media present and return ! 289: * kIOReturnSuccess. ! 290: * ! 291: * 2. TUR status != good completion, but good autosense returned: ! 292: * ! 293: * 2a: sense key says not ready: we report media not present ! 294: * and return kIOReturnSuccess. ! 295: * ! 296: * 2b: sense key is anything else: we report media not present ! 297: * and return kIOReturnIOError. ! 298: * ! 299: * 3. TUR status != good completion, and no autosense data: we do not ! 300: * set mediaPresent or changedState, and we return whatever result ! 301: * came back from the SCSI operation. ! 302: */ ! 303: virtual IOReturn reportMediaState(bool *mediaPresent,bool *changed); ! 304: ! 305: /* --- end of additional API --- */ ! 306: ! 307: protected: ! 308: ! 309: /*! ! 310: * @function createFormatCdb ! 311: * @abstract ! 312: * Create a SCSI CDB for a format operation. ! 313: * @discussion ! 314: * Override this to control the cdb created for a format operation. ! 315: * The default implementation creates a 6-byte format command with ! 316: * no data buffer, disconnect allowed, 8-byte autosense, and a 15-minute timeout. ! 317: * ! 318: * See also: allocateFormatBuffer, deleteFormatBuffer, composeFormatBuffer. ! 319: * @param byteCapacity ! 320: * The requested byte capacity to which the media should be formatted. This value ! 321: * should have been previously validated, otherwise the device may return an error. ! 322: * @param cdb ! 323: * A pointer to the CDB bytes. ! 324: * @param cdbLength ! 325: * The length of the CDB in bytes. ! 326: * @param block ! 327: * The device block to be written. ! 328: * @param nblks ! 329: * The number of blocks to be transferred. ! 330: * @param maxAutoSenseLength ! 331: * The maximum size of the autosense data, in bytes. A value of zero ! 332: * will disable autosense. ! 333: * @param timeoutSeconds ! 334: * The command timeout in seconds. ! 335: * @result ! 336: * The IOSCSICommandOptions returned will be used to issue the command. ! 337: */ ! 338: virtual UInt32 createFormatCdb( ! 339: UInt64 byteCapacity, /* in */ ! 340: UInt8 *cdb, /* in */ ! 341: UInt32 *cdbLength, /* out */ ! 342: UInt8 buf[], /* in */ ! 343: UInt32 bufLen, /* in */ ! 344: UInt32 *maxAutoSenseLength, /* out */ ! 345: UInt32 *timeoutSeconds); /* out */ ! 346: ! 347: ! 348: /*! ! 349: * @function allocateFormatBuffer ! 350: * @abstract ! 351: * Create a data buffer to be used for formatting the media. ! 352: * @discussion ! 353: * If a format buffer is to be used, then "allocateFormatBuffer" and ! 354: * deleteFormatBuffer" must be overridden to manage the buffer. The ! 355: * buffer must be prepared for IO upon return from allocateFormatBuffer. ! 356: * The default implementations of these methods don't allocate a buffer. ! 357: * @param buf ! 358: * A pointer for the returned buffer pointer. ! 359: * @param buflen ! 360: * The desired length of the buffer, in bytes. ! 361: */ ! 362: virtual IOReturn allocateFormatBuffer(UInt8 **buf,UInt32 *buflen); ! 363: ! 364: /*! ! 365: * @function deleteFormatBuffer ! 366: * @abstract ! 367: * Delete the data buffer to be used for formatting the media. ! 368: * @discussion ! 369: * If a format buffer is to be used, then "allocateFormatBuffer" and ! 370: * deleteFormatBuffer" must be overridden to manage the buffer. ! 371: * The default implementation of this method does nothing. ! 372: * @param buf ! 373: * A pointer to the buffer to delete. ! 374: * @param buflen ! 375: * The size of the buffer, in bytes. ! 376: */ ! 377: virtual void deleteFormatBuffer(UInt8 *buf,UInt32 buflen); ! 378: ! 379: /*! ! 380: * @function composeFormatBuffer ! 381: * @abstract ! 382: * Compose the data in the buffer used for the format command. ! 383: * @discussion ! 384: * This method will be called to compose the data in the format buffer. ! 385: * ! 386: * The default implementation of this method does nothing. ! 387: * @param buf ! 388: * A pointer to the format data buffer. ! 389: * @param buflen ! 390: * The size of the format data buffer, in bytes. ! 391: * @result ! 392: * The return value should be the desired values for the "CmpLst" and Defect ! 393: * List Format bits in the CDB. The default implementation returns zero. ! 394: */ ! 395: virtual UInt8 composeFormatBuffer(UInt8 *buf,UInt32 buflen); ! 396: ! 397: /* Override these methods to save and restore the state of the device electronics ! 398: * when power is turned off and on. The defaults do nothing and return kIOReturnSuccess. ! 399: */ ! 400: ! 401: /*! ! 402: * @function restoreElectronicsState ! 403: * @abstract ! 404: * Restore the state of the device electronics when powering-up. ! 405: * @discussion ! 406: * This method is called just after the device transitions from a powered-off state. ! 407: * ! 408: * The default implementation of this method does nothing and returns kIOReturnSuccess. ! 409: */ ! 410: virtual IOReturn restoreElectronicsState(void); ! 411: ! 412: /*! ! 413: * @function saveElectronicsState ! 414: * @abstract ! 415: * Save the state of the device electronics when powering-down. ! 416: * @discussion ! 417: * This method is called just before the device transitions to a powered-off state. ! 418: * ! 419: * The default implementation of this method does nothing and returns kIOReturnSuccess. ! 420: */ ! 421: virtual IOReturn saveElectronicsState(void); ! 422: ! 423: /*! ! 424: * @function initialPowerStateForDomainState ! 425: * @abstract ! 426: * Return the initial power state for the device. ! 427: * @discussion ! 428: * This method is called to obtain the initial power state for the device, ! 429: * by calling getInitialPowerState. ! 430: * @param domainState ! 431: * Power domain state flags. ! 432: * @result ! 433: * The return value must be a valid power state value. ! 434: */ ! 435: virtual unsigned long initialPowerStateForDomainState ( IOPMPowerFlags domainState ); ! 436: ! 437: /*! ! 438: * @function maxCapabilityForDomainState ! 439: * @abstract ! 440: * Return the maximum power level obtainable for the given state. ! 441: * @discussion ! 442: * This method is called to obtain the maximum power level obtainable for the ! 443: * given state. ! 444: * @param domainState ! 445: * Power domain state flags. ! 446: * @result ! 447: * The return value must be a valid power state value. ! 448: */ ! 449: virtual unsigned long maxCapabilityForDomainState ( IOPMPowerFlags domainState ); ! 450: ! 451: /*! ! 452: * @function powerStateForDomainState ! 453: * Return the maximum power level obtainable for the given state. ! 454: * @discussion ! 455: * This method is called to obtain the maximum power level obtainable for the ! 456: * given state. ! 457: * @param domainState ! 458: * Power domain state flags. ! 459: * @result ! 460: * The return value must be a valid power state value. ! 461: */ ! 462: virtual unsigned long powerStateForDomainState ( IOPMPowerFlags domainState ); ! 463: ! 464: /*! ! 465: * @function powerStateDidChangeTo ! 466: * @abstract ! 467: * React to a change in power state. ! 468: * @discussion ! 469: * This method is called when the power state changes. We call restoreElectronicsState ! 470: * if necessary, then call dequeueCommands if we have changed to a state that has power. ! 471: * @param stateOrdinal ! 472: * The power level to which we have changed. ! 473: */ ! 474: virtual IOReturn powerStateDidChangeTo ( unsigned long, unsigned long stateOrdinal, IOService* ); ! 475: ! 476: /*! ! 477: * @function powerStateWillChangeTo ! 478: * @abstract ! 479: * Prepare for a power state change. ! 480: * @discussion ! 481: * This method is called when the power state will change. If we are powering-up from kAllOff, ! 482: * we schedule a call to restoreElectronicsState. If, instead, we are powering-down from an "on" state, ! 483: * we schedule a call to saveElectronicsState. ! 484: * @param stateOrdinal ! 485: * The power level to which we will change. ! 486: */ ! 487: virtual IOReturn powerStateWillChangeTo ( unsigned long, unsigned long stateOrdinal, IOService* ); ! 488: ! 489: /*! ! 490: * @function setPowerState ! 491: * @abstract ! 492: * Set the power state to the specified state. ! 493: * @discussion ! 494: * This method is called to cause a change in power state. We handle changes to and from ! 495: * kAllOn and kElectronicsOn, which are done by spinning up and down the media. ! 496: * @param powerStateOrdinal ! 497: * The power level to which we must change. ! 498: */ ! 499: virtual IOReturn setPowerState ( unsigned long powerStateOrdinal, IOService* ); ! 500: ! 501: /*! ! 502: * @function powerTickle ! 503: * Check for the device power state currently being in the desired state. ! 504: * @discussion ! 505: * This method simply "tickles" ! 506: * the Power Management subsystem to ensure that the device transitions to the desired ! 507: * state if necessary. ! 508: */ ! 509: virtual bool powerTickle(UInt32 desiredState); ! 510: ! 511: /* Override this method to report the initial device power state when its domain is ! 512: * powered up. The default implementation assumes the drive spins up. ! 513: */ ! 514: ! 515: /*! ! 516: * @function getInitialPowerState ! 517: * @abstract ! 518: * Report the initial power state of the device. ! 519: * @discussion ! 520: * The default implementation of this method returns kAllOn, assuming that the ! 521: * drive spindle spins up initially. ! 522: * @result ! 523: * The return value must be a valid power state value. ! 524: */ ! 525: virtual unsigned long getInitialPowerState(void); /* default = kAllOn */ ! 526: ! 527: /* Override these to change power level required to do various commands. */ ! 528: ! 529: /*! ! 530: * @function getEjectPowerState ! 531: * @abstract ! 532: * Return the required device power level to determine eject the media. ! 533: * @discussion ! 534: * The default implementation of this method returns kElectronicsOn. ! 535: * @result ! 536: * The return value must be a valid power state value. ! 537: */ ! 538: virtual UInt32 getEjectPowerState(void); /* default = kElectronicsOn */ ! 539: ! 540: /*! ! 541: * @function getExecuteCDBPowerState ! 542: * @abstract ! 543: * @discussion ! 544: * @param ! 545: * @result ! 546: * The return value must be a valid power state value. ! 547: */ ! 548: virtual UInt32 getExecuteCDBPowerState(void); /* default = kAllOn */ ! 549: ! 550: /*! ! 551: * @function getFormatMediaPowerState ! 552: * @abstract ! 553: * Return the required device power level to execute a client CDB. ! 554: * @discussion ! 555: * The default implementation of this method returns kAllOn. ! 556: * @result ! 557: * The return value must be a valid power state value. ! 558: */ ! 559: virtual UInt32 getFormatMediaPowerState(void); /* default = kAllOn */ ! 560: ! 561: /*! ! 562: * @function getInquiryPowerState ! 563: * @abstract ! 564: * Return the required device power level to execute an Inquiry command. ! 565: * @discussion ! 566: * The default implementation of this method returns kElectronicsOn. ! 567: * @result ! 568: * The return value must be a valid power state value. ! 569: */ ! 570: virtual UInt32 getInquiryPowerState(void); /* default = kElectronicsOn */ ! 571: ! 572: /*! ! 573: * @function getLockUnlockMediaPowerState ! 574: * @abstract ! 575: * Return the required device power level to lock or unlock the media. ! 576: * @discussion ! 577: * The default implementation of this method returns kElectronicsOn. ! 578: * @result ! 579: * The return value must be a valid power state value. ! 580: */ ! 581: virtual UInt32 getLockUnlockMediaPowerState(void); /* default = kElectronicsOn */ ! 582: ! 583: /*! ! 584: * @function getReadCapacityPowerState ! 585: * @abstract ! 586: * Return the required device power level to execute a Read-Capacity command. ! 587: * @discussion ! 588: * The default implementation of this method returns kElectronicsOn. ! 589: * @result ! 590: * The return value must be a valid power state value. ! 591: */ ! 592: virtual UInt32 getReadCapacityPowerState(void); /* default = kElectronicsOn */ ! 593: ! 594: /*! ! 595: * @function getReadWritePowerState ! 596: * @abstract ! 597: * Return the required device power level to execute a Read or Write command. ! 598: * @discussion ! 599: * The default implementation of this method returns kAllOn. ! 600: * @result ! 601: * The return value must be a valid power state value. ! 602: */ ! 603: virtual UInt32 getReadWritePowerState(void); /* default = kAllOn */ ! 604: ! 605: /*! ! 606: * @function getReportWriteProtectionPowerState ! 607: * @abstract ! 608: * Return the required device power level to report media write protection. ! 609: * @discussion ! 610: * The default implementation of this method returns kElectronicsOn. ! 611: * @result ! 612: * The return value must be a valid power state value. ! 613: */ ! 614: virtual UInt32 getReportWriteProtectionPowerState(void); /* default = kElectronicsOn */ ! 615: ! 616: /*! ! 617: * @function getStartPowerState ! 618: * @abstract ! 619: * Return the required device power level to start (spin up) the media. ! 620: * @discussion ! 621: * The default implementation of this method returns kElectronicsOn. ! 622: * @result ! 623: * The return value must be a valid power state value. ! 624: */ ! 625: virtual UInt32 getStartPowerState(void); /* default = kElectronicsOn */ ! 626: ! 627: /*! ! 628: * @function getStopPowerState ! 629: * @abstract ! 630: * Return the required device power level to stop (spin down) the media. ! 631: * @discussion ! 632: * The default implementation of this method returns kAllOn. ! 633: * @result ! 634: * The return value must be a valid power state value. ! 635: */ ! 636: virtual UInt32 getStopPowerState(void); /* default = kAllOn */ ! 637: ! 638: /*! ! 639: * @function getSynchronizeCachePowerState ! 640: * @abstract ! 641: * Return the required device power level to issue a Synchronize-Cache command. ! 642: * @discussion ! 643: * The default implementation of this method returns kAllOn. ! 644: * @result ! 645: * The return value must be a valid power state value. ! 646: */ ! 647: virtual UInt32 getSynchronizeCachePowerState(void); /* default = kAllOn */ ! 648: ! 649: /*! ! 650: * @function getTestUnitReadyPowerState ! 651: * @abstract ! 652: * Return the required device power level to issue a Test Unit Ready command. ! 653: * @discussion ! 654: * The default implementation of this method returns kElectronicsOn. ! 655: * @result ! 656: * The return value must be a valid power state value. ! 657: */ ! 658: virtual UInt32 getTestUnitReadyPowerState(void); /* default = kElectronicsOn */ ! 659: ! 660: /* ! 661: * @group ! 662: * Internally used methods. ! 663: */ ! 664: ! 665: /*! ! 666: * @function createNub ! 667: * @abstract ! 668: * Create, init, attach, and register the device nub. ! 669: * @discussion ! 670: * This method calls instantiateNub, then init, attach, and register. ! 671: * @result ! 672: * A pointer to the nub or NULL if something failed. ! 673: */ ! 674: virtual IOService * createNub(void); ! 675: ! 676: /*! ! 677: * @function getDeviceTypeName ! 678: * @abstract ! 679: * Return a character string for the device type. ! 680: * @discussion ! 681: * The default implementation of this method returns kDeviceTypeHardDisk. ! 682: */ ! 683: virtual const char * getDeviceTypeName(void); ! 684: ! 685: /*! ! 686: * @function instantiateNub ! 687: * @abstract ! 688: * Create the device nub. ! 689: * @discussion ! 690: * A subclass will override this method to change the type of nub created. ! 691: * A CD driver, for example, will instantiate an IOSCSICDDriveNub instead ! 692: * of the default implementation's IOSCSIHDDriveNub. ! 693: */ ! 694: virtual IOService * instantiateNub(void); ! 695: ! 696: /*! ! 697: * @function doStart ! 698: * @abstract ! 699: * Start (spin up) the media. ! 700: * @discussion ! 701: * This method calls doStartStop. ! 702: */ ! 703: virtual IOReturn doStart(void); ! 704: ! 705: /*! ! 706: * @function doStartStop ! 707: * @abstract ! 708: * Perform the actual spin up/down command. ! 709: * @discussion ! 710: * This method issues a SCSI Start Stop Unit command to start or stop ! 711: * the device. Because the powerCondition value is only for use with ! 712: * SCSI-3 devices, the current implementation ignores powerCondition. ! 713: * @param start ! 714: * True to start (spin-up) the media; False to stop (spin-down) the media. ! 715: * @param loadEject ! 716: * True to eject; False to not eject. This parameter is applicable only to a stop ! 717: * operation. ! 718: * @param powerCondition ! 719: * The power condition to which the drive should transition. This is a SCSI-3 ! 720: * capability; it is presently unused. ! 721: */ ! 722: virtual IOReturn doStartStop(bool start,bool loadEject,UInt8 powerCondition); ! 723: ! 724: /*! ! 725: * @function doStop ! 726: * @abstract ! 727: * Stop (spin down) the media. ! 728: * @discussion ! 729: * This method calls doStartStop. ! 730: */ ! 731: virtual IOReturn doStop(void); ! 732: ! 733: /* ! 734: * @endgroup ! 735: */ ! 736: ! 737: /* Device information : */ ! 738: ! 739: /*! ! 740: * @var _mediaPresent ! 741: * True if media is present; False if media is not present. ! 742: */ ! 743: bool _mediaPresent; ! 744: ! 745: /*! ! 746: * @var _startStopDisabled ! 747: * True if the start/stop commands are disabled due to an error. ! 748: */ ! 749: bool _startStopDisabled; ! 750: ! 751: /*! ! 752: * @var _restoreState ! 753: * True if we must restore the device electronics state after a power-up. ! 754: */ ! 755: bool _restoreState; /* true if we must restore after power-up */ }; ! 756: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.