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 46enum { 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*/ 95typedef unsigned long IOPMPowerFlags; 96enum { 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 */ 114enum { 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 */ 130enum { 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 */ 148enum { 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 163enum { 164 kIOPMNextHigherState = 1, 165 kIOPMHighestState = 2, 166 kIOPMNextLowerState = 3, 167 kIOPMLowestState = 4 168}; 169 170enum { 171 IOPMNextHigherState = kIOPMNextHigherState, 172 IOPMHighestState = kIOPMHighestState, 173 IOPMNextLowerState = kIOPMNextLowerState, 174 IOPMLowestState = kIOPMLowestState 175}; 176 177// Internal commands used by power managment command queue 178enum { 179 kIOPMBroadcastAggressiveness = 1, 180 kIOPMUnidleDevice 181}; 182 183// Power consumption unknown value 184enum { 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 */ 227enum { 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 */ 251enum { 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 ******************************************************************************/ 278enum { 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 ******************************************************************************/ 298enum { 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 377enum { 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. 384enum { 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 */ 467enum { 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 503struct IOPMCalendarStruct { 504 UInt32 year; 505 UInt8 month; 506 UInt8 day; 507 UInt8 hour; 508 UInt8 minute; 509 UInt8 second; 510}; 511typedef struct IOPMCalendarStruct IOPMCalendarStruct; 512 513// SetAggressiveness types 514enum { 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 528enum { 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 544enum { 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 562enum { 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 582class IOService; 583 584enum { 585 kIOPowerEmergencyLevel = 1000 586}; 587 588enum { 589 kIOPMSubclassPolicy, 590 kIOPMSuperclassPolicy1 591}; 592 593struct stateChangeNote{ 594 IOPMPowerFlags stateFlags; 595 unsigned long stateNum; 596 void * powerRef; 597}; 598typedef struct stateChangeNote stateChangeNote; 599 600struct IOPowerStateChangeNotification { 601 void * powerRef; 602 unsigned long returnValue; 603 unsigned long stateNumber; 604 IOPMPowerFlags stateFlags; 605}; 606typedef struct IOPowerStateChangeNotification IOPowerStateChangeNotification; 607typedef IOPowerStateChangeNotification sleepWakeNote; 608 609extern void IOPMRegisterDevice(const char *, IOService *); 610#endif /* KERNEL && __cplusplus */ 611 612#endif /* ! _IOKIT_IOPM_H */ 613 614