iokit/IOKit/pwr_mgt/IOPM.h

   1 /*
   2  * Copyright (c) 1998-2005 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28 #ifndef _IOKIT_IOPM_H
  29 #define _IOKIT_IOPM_H
  30
  31 #include <IOKit/IOTypes.h>
  32 #include <IOKit/IOMessage.h>
  33 #include <IOKit/IOReturn.h>
  34
  35 #ifdef __ppc__
  36 #include <IOKit/pwr_mgt/IOPMDeprecated.h>
  37 #endif
  38
  39 /*! @header IOPM.h
  40     @abstract Defines power management constants and keys used by both in-kernel and user space power management.
  41     @discussion IOPM.h defines a range of power management constants used in several in-kernel and user space APIs. Most significantly, the IOPMPowerFlags used to specify the fields of an IOPMPowerState struct are defined here.
  42
  43     Most of the constants defined in IOPM.h are deprecated or for Apple internal use only, and are not elaborated on in headerdoc.
  44 */
  45
  46 enum {
  47     kIOPMMaxPowerStates = 10,
  48     IOPMMaxPowerStates = kIOPMMaxPowerStates
  49 };
  50
  51 /*! @enum IOPMPowerFlags
  52     @abstract Bits are used in defining capabilityFlags, inputPowerRequirements, and outputPowerCharacter in the IOPMPowerState structure.
  53     @discussion These bits may be bitwise-OR'd together in the IOPMPowerState capabilityFlags field, the outputPowerCharacter field, and/or the inputPowerRequirement field.
  54
  55     The comments clearly mark whether each flag should be used in the capabilityFlags field, outputPowerCharacter field, and inputPowerRequirement field, or all three.
  56
  57     The value of capabilityFlags, inputPowerRequirement or outputPowerCharacter may be 0. Most drivers implement their 'OFF' state, used when asleep, by defininf each of the 3 fields as 0.
  58
  59     The bits listed below are only the most common bits used to define a device's power states. Your device's IO family may require that your device specify other input or output power flags to interact properly. Consult family-specific documentation to determine if your IOPower plane parents or children require other power flags; they probably don't.
  60
  61     @constant kIOPMPowerOn Indicates the device is on, requires power, and provides power. Useful as a: Capability, InputPowerRequirement, OutputPowerCharacter
  62
  63     @constant kIOPMDeviceUsable Indicates the device is usable in this state. Useful only as a Capability
  64
  65     @constant kIOPMLowPower
  66     Indicates device is in a low power state. May be bitwis-OR'd together
  67     with kIOPMDeviceUsable flag, to indicate the device is still usable.
  68
  69     A device with a capability of kIOPMLowPower may:
  70        Require either 0 or kIOPMPowerOn from its power parent
  71        Offer either kIOPMLowPower, kIOPMPowerOn, or 0 (no power at all)
  72          to its power plane children.
  73
  74     Useful only as a Capability, although USB drivers should consult USB family documentation for other valid circumstances to use the kIOPMLowPower bit.
  75
  76     @constant kIOPMPreventIdleSleep
  77     In the capability field of a power state, disallows idle system sleep while the device is in that state.
  78
  79     For example, displays and disks set this capability for their ON power state; since the system may not idle sleep while the display (and thus keyboard or mouse) or the disk is active.
  80
  81     Useful only as a Capability.
  82
  83     @constant kIOPMSleepCapability
  84     Used only by certain IOKit Families (USB). Not defined or used by generic Power Management. Read your family documentation to see if you should define a powerstate using these capabilities.
  85
  86     @constant kIOPMRestartCapability
  87     Used only by certain IOKit Families (USB). Not defined or used by generic Power Management. Read your family documentation to see if you should define a powerstate using these capabilities.
  88
  89     @constant kIOPMSleep
  90     Used only by certain IOKit Families (USB). Not defined or used by generic Power Management. Read your family documentation to see if you should define a powerstate using these capabilities.
  91
  92     @constant kIOPMRestart
  93     Used only by certain IOKit Families (USB). Not defined or used by generic Power Management. Read your family documentation to see if you should define a powerstate using these capabilities.
  94 */
  95 typedef unsigned long IOPMPowerFlags;
  96 enum {
  97     kIOPMPowerOn                    = 0x00000002,
  98     kIOPMDeviceUsable               = 0x00008000,
  99     kIOPMLowPower                   = 0x00010000,
 100     kIOPMPreventIdleSleep           = 0x00000040,
 101     kIOPMSleepCapability            = 0x00000004,
 102     kIOPMRestartCapability          = 0x00000080,
 103     kIOPMSleep                      = 0x00000001,
 104     kIOPMRestart                    = 0x00000080
 105 };
 106
 107 /*
 108  * Private IOPMPowerFlags
 109  *
 110  * For Apple use only
 111  * Not for use with non-Apple drivers
 112  * Their behavior is undefined
 113  */
 114 enum {
 115     kIOPMClockNormal                = 0x0004,
 116     kIOPMClockRunning               = 0x0008,
 117     kIOPMPreventSystemSleep         = 0x0010,
 118     kIOPMDoze                       = 0x0400,
 119     kIOPMChildClamp                 = 0x0080,
 120     kIOPMChildClamp2                = 0x0200,
 121     kIOPMNotPowerManaged            = 0x0800
 122 };
 123
 124
 125 /*
 126  * Deprecated IOPMPowerFlags
 127  * Their behavior is undefined when used in IOPMPowerState
 128  * Capability, InputPowerRequirement, or OutputPowerCharacter fields.
 129  */
 130 enum {
 131     kIOPMMaxPerformance             = 0x4000,
 132     kIOPMPassThrough                = 0x0100,
 133     kIOPMAuxPowerOn                 = 0x0020,
 134     kIOPMNotAttainable              = 0x0001,
 135     kIOPMContextRetained            = 0x2000,
 136     kIOPMConfigRetained             = 0x1000,
 137     kIOPMStaticPowerValid           = 0x0800,
 138     kIOPMSoftSleep                  = 0x0400,
 139     kIOPMCapabilitiesMask =     kIOPMPowerOn | kIOPMDeviceUsable |
 140                                 kIOPMMaxPerformance | kIOPMContextRetained |
 141                                 kIOPMConfigRetained | kIOPMSleepCapability |
 142                                 kIOPMRestartCapability
 143 };
 144
 145 /*
 146  * Support for old names of IOPMPowerFlag constants
 147  */
 148 enum {
 149     IOPMNotAttainable           = kIOPMNotAttainable,
 150     IOPMPowerOn                 = kIOPMPowerOn,
 151     IOPMClockNormal             = kIOPMClockNormal,
 152     IOPMClockRunning            = kIOPMClockRunning,
 153     IOPMAuxPowerOn              = kIOPMAuxPowerOn,
 154     IOPMDeviceUsable            = kIOPMDeviceUsable,
 155     IOPMMaxPerformance          = kIOPMMaxPerformance,
 156     IOPMContextRetained         = kIOPMContextRetained,
 157     IOPMConfigRetained          = kIOPMConfigRetained,
 158     IOPMNotPowerManaged         = kIOPMNotPowerManaged,
 159     IOPMSoftSleep               = kIOPMSoftSleep
 160 };
 161
 162
 163 enum {
 164     kIOPMNextHigherState        = 1,
 165     kIOPMHighestState           = 2,
 166     kIOPMNextLowerState         = 3,
 167     kIOPMLowestState            = 4
 168 };
 169
 170 enum {
 171     IOPMNextHigherState         = kIOPMNextHigherState,
 172     IOPMHighestState            = kIOPMHighestState,
 173     IOPMNextLowerState          = kIOPMNextLowerState,
 174     IOPMLowestState             = kIOPMLowestState
 175 };
 176
 177 // Internal commands used by power managment command queue
 178 enum {
 179     kIOPMBroadcastAggressiveness = 1,
 180     kIOPMUnidleDevice
 181 };
 182
 183 // Power consumption unknown value
 184 enum {
 185     kIOPMUnknown = 0xFFFF
 186 };
 187
 188 /*******************************************************************************
 189  *
 190  * Root Domain property keys of interest
 191  *
 192  ******************************************************************************/
 193
 194 /* AppleClamshellState
 195  * reflects the state of the clamshell (lid) on a portable.
 196  * It has a boolean value.
 197  *  true        == clamshell is closed
 198  *  false       == clamshell is open
 199  *  not present == no clamshell on this hardware
 200  */
 201 #define kAppleClamshellStateKey             "AppleClamshellState"
 202
 203 /* AppleClamshellCausesSleep
 204  * reflects the clamshell close behavior on a portable.
 205  * It has a boolean value.
 206  *  true        == system will sleep when clamshell is closed
 207  *  false       == system will not sleep on clamshell close
 208  *                  (typically external display mode)
 209  *  not present == no clamshell on this hardware
 210  */
 211 #define kAppleClamshellCausesSleepKey       "AppleClamshellCausesSleep"
 212
 213 /*******************************************************************************
 214  *
 215  * Root Domain general interest messages
 216  *
 217  ******************************************************************************/
 218
 219 /* kIOPMMessageClamshellStateChange
 220  * Delivered as a general interest notification on the IOPMrootDomain
 221  * IOPMrootDomain sends this message when state of either AppleClamshellState
 222  * or AppleClamshellCausesSleep changes. If this clamshell change results in
 223  * a sleep, the sleep will initiate soon AFTER delivery of this message.
 224  * The state of both variables is encoded in a bitfield argument sent with
 225  * the message. Check bits 0 and 1 using kClamshellStateBit & kClamshellSleepBit
 226  */
 227 enum {
 228     kClamshellStateBit = (1 << 0),
 229     kClamshellSleepBit = (1 << 1)
 230 };
 231
 232 #define kIOPMMessageClamshellStateChange   \
 233                 iokit_family_msg(sub_iokit_powermanagement, 0x100)
 234
 235 /* kIOPMMessageFeatureChange
 236  * Delivered when the set of supported features ("Supported Features" dictionary
 237  * under IOPMrootDomain registry) changes in some way. Typically addition or
 238  * removal of a supported feature.
 239  * RootDomain passes no argument with this message.
 240  */
 241 #define kIOPMMessageFeatureChange           \
 242                 iokit_family_msg(sub_iokit_powermanagement, 0x110)
 243
 244 /* kIOPMMessageInflowDisableCancelled
 245  * The battery has drained completely to its "Fully Discharged" state.
 246  * If a user process has disabled battery inflow for battery
 247  * calibration, we forcibly re-enable Inflow at this point.
 248  * If inflow HAS been forcibly re-enabled, bit 0
 249  * (kInflowForciblyEnabledBit) will be set.
 250  */
 251 enum {
 252     kInflowForciblyEnabledBit = (1 << 0)
 253 };
 254
 255 /* kIOPMMessageInternalBatteryFullyDischarged
 256  * The battery has drained completely to its "Fully Discharged" state.
 257  */
 258 #define kIOPMMessageInternalBatteryFullyDischarged  \
 259                 iokit_family_msg(sub_iokit_powermanagement, 0x120)
 260
 261 /* kIOPMMessageSystemPowerEventOccurred
 262  * Some major system thermal property has changed, and interested clients may
 263  * modify their behavior.
 264  */
 265 #define kIOPMMessageSystemPowerEventOccurred  \
 266                 iokit_family_msg(sub_iokit_powermanagement, 0x130)
 267
 268
 269 /*******************************************************************************
 270  *
 271  * Power commands issued to root domain
 272  * Use with IOPMrootDomain::receivePowerNotification()
 273  *
 274  * These commands are issued from system drivers only:
 275  *      ApplePMU, AppleSMU, IOGraphics, AppleACPIFamily
 276  *
 277  ******************************************************************************/
 278 enum {
 279   kIOPMSleepNow                 = (1<<0),  // put machine to sleep now
 280   kIOPMAllowSleep               = (1<<1),  // allow idle sleep
 281   kIOPMPreventSleep             = (1<<2),  // do not allow idle sleep
 282   kIOPMPowerButton              = (1<<3),  // power button was pressed
 283   kIOPMClamshellClosed          = (1<<4),  // clamshell was closed
 284   kIOPMPowerEmergency           = (1<<5),  // battery dangerously low
 285   kIOPMDisableClamshell         = (1<<6),  // do not sleep on clamshell closure
 286   kIOPMEnableClamshell          = (1<<7),  // sleep on clamshell closure
 287   kIOPMProcessorSpeedChange     = (1<<8),  // change the processor speed
 288   kIOPMOverTemp                 = (1<<9),  // system dangerously hot
 289   kIOPMClamshellOpened          = (1<<10)  // clamshell was opened
 290 };
 291
 292
 293 /*******************************************************************************
 294  *
 295  * Power Management Return Codes
 296  *
 297  ******************************************************************************/
 298 enum {
 299     kIOPMNoErr                  = 0,
 300     // Returned by powerStateWillChange and powerStateDidChange:
 301     // Immediate acknowledgement of power state change
 302     kIOPMAckImplied             = 0,
 303     // Acknowledgement of power state change will come later
 304     kIOPMWillAckLater           = 1,
 305
 306     // Returned by requestDomainState:
 307     // Unrecognized specification parameter
 308     kIOPMBadSpecification       = 4,
 309     // No power state matches search specification
 310     kIOPMNoSuchState            = 5,
 311
 312     // Device cannot change its power for some reason
 313     kIOPMCannotRaisePower       = 6,
 314
 315   // Returned by changeStateTo:
 316     // Requested state doesn't exist
 317     kIOPMParameterError         = 7,
 318     // Device not yet fully hooked into power management
 319     kIOPMNotYetInitialized      = 8,
 320
 321     // And the old constants; deprecated
 322     IOPMNoErr = kIOPMNoErr,
 323     IOPMAckImplied = kIOPMAckImplied,
 324     IOPMWillAckLater = kIOPMWillAckLater,
 325     IOPMBadSpecification = kIOPMBadSpecification,
 326     IOPMNoSuchState = kIOPMNoSuchState,
 327     IOPMCannotRaisePower = kIOPMCannotRaisePower,
 328     IOPMParameterError = kIOPMParameterError,
 329     IOPMNotYetInitialized = kIOPMNotYetInitialized
 330 };
 331
 332
 333 // IOPMPowerSource class descriptive strings
 334 // Power Source state is published as properties to the IORegistry under these
 335 // keys.
 336 #define kIOPMPSExternalConnectedKey                 "ExternalConnected"
 337 #define kIOPMPSExternalChargeCapableKey             "ExternalChargeCapable"
 338 #define kIOPMPSBatteryInstalledKey                  "BatteryInstalled"
 339 #define kIOPMPSIsChargingKey                        "IsCharging"
 340 #define kIOPMFullyChargedKey                        "FullyCharged"
 341 #define kIOPMPSAtWarnLevelKey                       "AtWarnLevel"
 342 #define kIOPMPSAtCriticalLevelKey                   "AtCriticalLevel"
 343 #define kIOPMPSCurrentCapacityKey                   "CurrentCapacity"
 344 #define kIOPMPSMaxCapacityKey                       "MaxCapacity"
 345 #define kIOPMPSDesignCapacityKey                    "DesignCapacity"
 346 #define kIOPMPSTimeRemainingKey                     "TimeRemaining"
 347 #define kIOPMPSAmperageKey                          "Amperage"
 348 #define kIOPMPSVoltageKey                           "Voltage"
 349 #define kIOPMPSCycleCountKey                        "CycleCount"
 350 #define kIOPMPSMaxErrKey                            "MaxErr"
 351 #define kIOPMPSAdapterInfoKey                       "AdapterInfo"
 352 #define kIOPMPSLocationKey                          "Location"
 353 #define kIOPMPSErrorConditionKey                    "ErrorCondition"
 354 #define kIOPMPSManufacturerKey                      "Manufacturer"
 355 #define kIOPMPSManufactureDateKey                   "ManufactureDate"
 356 #define kIOPMPSModelKey                             "Model"
 357 #define kIOPMPSSerialKey                            "Serial"
 358 #define kIOPMDeviceNameKey                          "DeviceName"
 359 #define kIOPMPSLegacyBatteryInfoKey                 "LegacyBatteryInfo"
 360 #define kIOPMPSBatteryHealthKey                     "BatteryHealth"
 361 #define kIOPMPSHealthConfidenceKey                  "HealthConfidence"
 362 #define kIOPMPSCapacityEstimatedKey                     "CapacityEstimated"
 363 #define kIOPMPSBatteryChargeStatusKey               "ChargeStatus"
 364 #define kIOPMPSBatteryTemperatureKey                "Temperature"
 365
 366 // kIOPMBatteryChargeStatusKey may have one of the following values, or may have
 367 // no value. If kIOPMBatteryChargeStatusKey has a NULL value (or no value) associated with it
 368 // then charge is proceeding normally. If one of these battery charge status reasons is listed,
 369 // then the charge may have been interrupted.
 370 #define kIOPMBatteryChargeStatusTooHot              "HighTemperature"
 371 #define kIOPMBatteryChargeStatusTooCold             "LowTemperature"
 372 #define kIOPMBatteryChargeStatusGradient            "BatteryTemperatureGradient"
 373
 374 // Definitions for battery location, in case of multiple batteries.
 375 // A location of 0 is unspecified
 376 // Location is undefined for single battery systems
 377 enum {
 378     kIOPMPSLocationLeft = 1001,
 379     kIOPMPSLocationRight = 1002
 380 };
 381
 382 // Battery quality health types, specified by BatteryHealth and HealthConfidence
 383 // properties in an IOPMPowerSource battery kext.
 384 enum {
 385     kIOPMUndefinedValue = 0,
 386     kIOPMPoorValue      = 1,
 387     kIOPMFairValue      = 2,
 388     kIOPMGoodValue      = 3
 389 };
 390
 391 // Battery's time remaining estimate is invalid this long (seconds) after a wake
 392 #define kIOPMPSInvalidWakeSecondsKey           "BatteryInvalidWakeSeconds"
 393
 394 // Battery must wait this long (seconds) after being completely charged before
 395 // the battery is settled.
 396 #define kIOPMPSPostChargeWaitSecondsKey        "PostChargeWaitSeconds"
 397
 398 // Battery must wait this long (seconds) after being completely discharged
 399 // before the battery is settled.
 400 #define kIOPMPSPostDishargeWaitSecondsKey      "PostDischargeWaitSeconds"
 401
 402
 403 /* CPU Power Management status keys
 404  * Pass as arguments to IOPMrootDomain::systemPowerEventOccurred
 405  * Or as arguments to IOPMSystemPowerEventOccurred()
 406  * Or to decode the dictionary obtained from IOPMCopyCPUPowerStatus()
 407  * These keys reflect restrictions placed on the CPU by the system
 408  * to bring the CPU's power consumption within allowable thermal and
 409  * power constraints.
 410  */
 411
 412
 413 /* kIOPMGraphicsPowerLimitsKey
 414  *   The key representing the dictionary of graphics power limits.
 415  *   The dictionary contains the other kIOPMCPUPower keys & their associated
 416  *   values (e.g. Speed limit, Processor Count, and Schedule limits).
 417  */
 418 #define kIOPMGraphicsPowerLimitsKey                     "Graphics_Power_Limits"
 419
 420 /* kIOPMGraphicsPowerLimitPerformanceKey
 421  *   The key representing the percent of overall performance made available
 422  *   by the graphics chip as a percentage (integer 0 - 100).
 423  */
 424 #define kIOPMGraphicsPowerLimitPerformanceKey           "Graphics_Power_Performance"
 425
 426
 427
 428 /* kIOPMCPUPowerLimitsKey
 429  *   The key representing the dictionary of CPU Power Limits.
 430  *   The dictionary contains the other kIOPMCPUPower keys & their associated
 431  *   values (e.g. Speed limit, Processor Count, and Schedule limits).
 432  */
 433 #define kIOPMCPUPowerLimitsKey                          "CPU_Power_Limits"
 434
 435 /* kIOPMCPUPowerLimitProcessorSpeedKey defines the speed & voltage limits placed
 436  *   on the CPU.
 437  *   Represented as a percentage (0-100) of maximum CPU speed.
 438  */
 439 #define kIOPMCPUPowerLimitProcessorSpeedKey             "CPU_Speed_Limit"
 440
 441 /* kIOPMCPUPowerLimitProcessorCountKey reflects how many, if any, CPUs have been
 442  *   taken offline. Represented as an integer number of CPUs (0 - Max CPUs).
 443  */
 444 #define kIOPMCPUPowerLimitProcessorCountKey             "CPU_Available_CPUs"
 445
 446 /* kIOPMCPUPowerLimitSchedulerTimeKey represents the percentage (0-100) of CPU time
 447  *   available. 100% at normal operation. The OS may limit this time for a percentage
 448  *   less than 100%.
 449  */
 450 #define kIOPMCPUPowerLimitSchedulerTimeKey              "CPU_Scheduler_Limit"
 451
 452
 453 /* Thermal Level Warning Key
 454  * Indicates the thermal constraints placed on the system. This value may
 455  * cause clients to action to consume fewer system resources.
 456  * The value associated with this warning is defined by the platform.
 457  */
 458 #define kIOPMThermalLevelWarningKey                     "Thermal_Level_Warning"
 459
 460 /* Thermal Warning Level values
 461  *      kIOPMThermalWarningLevelNormal - under normal operating conditions
 462  *      kIOPMThermalWarningLevelDanger - thermal pressure may cause system slowdown
 463  *      kIOPMThermalWarningLevelCrisis - thermal conditions may cause imminent shutdown
 464  *
 465  * The platform may define additional thermal levels if necessary.
 466  */
 467 enum {
 468   kIOPMThermalWarningLevelNormal    = 0,
 469   kIOPMThermalWarningLevelDanger    = 5,
 470   kIOPMThermalWarningLevelCrisis    = 10
 471 };
 472
 473
 474 // PM Settings Controller setting types
 475 // Settings types used primarily with:
 476 //      IOPMrootDomain::registerPMSettingController
 477 // The values are identical to the similarly named keys for use in user space
 478 // PM settings work. Those keys are defined in IOPMLibPrivate.h.
 479 #define kIOPMSettingWakeOnRingKey                   "Wake On Modem Ring"
 480 #define kIOPMSettingRestartOnPowerLossKey           "Automatic Restart On Power Loss"
 481 #define kIOPMSettingWakeOnACChangeKey               "Wake On AC Change"
 482 #define kIOPMSettingSleepOnPowerButtonKey           "Sleep On Power Button"
 483 #define kIOPMSettingWakeOnClamshellKey              "Wake On Clamshell Open"
 484 #define kIOPMSettingReduceBrightnessKey             "ReduceBrightness"
 485 #define kIOPMSettingDisplaySleepUsesDimKey          "Display Sleep Uses Dim"
 486 #define kIOPMSettingTimeZoneOffsetKey               "TimeZoneOffsetSeconds"
 487 #define kIOPMSettingMobileMotionModuleKey           "MobileMotionModule"
 488 #define kIOPMSettingGraphicsSwitchKey               "GPUSwitch"
 489
 490 // Setting controlling drivers can register to receive scheduled wake data
 491 // Either in "CF seconds" type, or structured calendar data in a formatted
 492 // IOPMCalendarStruct defined below.
 493 #define kIOPMSettingAutoWakeSecondsKey              "wake"
 494 #define kIOPMSettingAutoWakeCalendarKey             "WakeByCalendarDate"
 495 #define kIOPMSettingAutoPowerSecondsKey             "poweron"
 496 #define kIOPMSettingAutoPowerCalendarKey            "PowerByCalendarDate"
 497
 498 // Debug seconds auto wake
 499 // Used by sleep cycling debug tools
 500 #define kIOPMSettingDebugWakeRelativeKey            "WakeRelativeToSleep"
 501 #define kIOPMSettingDebugPowerRelativeKey           "PowerRelativeToShutdown"
 502
 503 struct IOPMCalendarStruct {
 504     UInt32      year;
 505     UInt8       month;
 506     UInt8       day;
 507     UInt8       hour;
 508     UInt8       minute;
 509     UInt8       second;
 510 };
 511 typedef struct IOPMCalendarStruct IOPMCalendarStruct;
 512
 513 // SetAggressiveness types
 514 enum {
 515     kPMGeneralAggressiveness = 0,
 516     kPMMinutesToDim,
 517     kPMMinutesToSpinDown,
 518     kPMMinutesToSleep,
 519     kPMEthernetWakeOnLANSettings,
 520     kPMSetProcessorSpeed,
 521     kPMPowerSource,
 522     kPMMotionSensor,
 523     kPMLastAggressivenessType
 524 };
 525 #define kMaxType (kPMLastAggressivenessType-1)
 526
 527 // SetAggressiveness values for the kPMPowerSource aggressiveness type
 528 enum {
 529     kIOPMInternalPower = 1,
 530     kIOPMExternalPower
 531 };
 532
 533 #define kIOREMSleepEnabledKey               "REMSleepEnabled"
 534
 535 // Strings for deciphering the dictionary returned from IOPMCopyBatteryInfo
 536 #define kIOBatteryInfoKey                   "IOBatteryInfo"
 537 #define kIOBatteryCurrentChargeKey          "Current"
 538 #define kIOBatteryCapacityKey               "Capacity"
 539 #define kIOBatteryFlagsKey                  "Flags"
 540 #define kIOBatteryVoltageKey                "Voltage"
 541 #define kIOBatteryAmperageKey               "Amperage"
 542 #define kIOBatteryCycleCountKey             "Cycle Count"
 543
 544 enum {
 545     kIOBatteryInstalled         = (1 << 2),
 546     kIOBatteryCharge            = (1 << 1),
 547     kIOBatteryChargerConnect    = (1 << 0)
 548 };
 549
 550
 551 // Private power management message indicating battery data has changed
 552 // Indicates new data resides in the IORegistry
 553 #define kIOPMMessageBatteryStatusHasChanged         iokit_family_msg(sub_iokit_pmu, 0x100)
 554
 555 // Apple private Legacy messages for re-routing AutoWake and AutoPower messages to the PMU
 556 // through newer user space IOPMSchedulePowerEvent API
 557 #define kIOPMUMessageLegacyAutoWake                 iokit_family_msg(sub_iokit_pmu, 0x200)
 558 #define kIOPMUMessageLegacyAutoPower                iokit_family_msg(sub_iokit_pmu, 0x210)
 559
 560 // For use with IOPMPowerSource bFlags
 561 #define IOPM_POWER_SOURCE_REV   2
 562 enum {
 563   kIOPMACInstalled      = kIOBatteryChargerConnect,
 564   kIOPMBatteryCharging  = kIOBatteryCharge,
 565   kIOPMBatteryInstalled = kIOBatteryInstalled,
 566   kIOPMUPSInstalled     = (1<<3),
 567   kIOPMBatteryAtWarn    = (1<<4),
 568   kIOPMBatteryDepleted  = (1<<5),
 569   kIOPMACnoChargeCapability = (1<<6),     // AC adapter cannot charge battery
 570   kIOPMRawLowBattery    = (1<<7),         // used only by  Platform Expert
 571   kIOPMForceLowSpeed    = (1<<8),         // set by Platfm Expert, chk'd by Pwr Plugin
 572   kIOPMClosedClamshell  = (1<<9),         // set by PMU - reflects state of the clamshell
 573   kIOPMClamshellStateOnWake = (1<<10)     // used only by Platform Expert
 574 };
 575
 576
 577 // **********************************************
 578 // Internal power management data structures
 579 // **********************************************
 580
 581 #if KERNEL && __cplusplus
 582 class IOService;
 583
 584 enum {
 585     kIOPowerEmergencyLevel = 1000
 586 };
 587
 588 enum {
 589     kIOPMSubclassPolicy,
 590     kIOPMSuperclassPolicy1
 591 };
 592
 593 struct stateChangeNote{
 594     IOPMPowerFlags    stateFlags;
 595     unsigned long    stateNum;
 596     void *         powerRef;
 597 };
 598 typedef struct stateChangeNote stateChangeNote;
 599
 600 struct IOPowerStateChangeNotification {
 601     void *        powerRef;
 602     unsigned long    returnValue;
 603     unsigned long    stateNumber;
 604     IOPMPowerFlags    stateFlags;
 605 };
 606 typedef struct IOPowerStateChangeNotification IOPowerStateChangeNotification;
 607 typedef IOPowerStateChangeNotification sleepWakeNote;
 608
 609 extern void IOPMRegisterDevice(const char *, IOService *);
 610 #endif /* KERNEL && __cplusplus */
 611
 612 #endif /* ! _IOKIT_IOPM_H */
 613