X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/2d21ac55c334faf3a56e5634905ed6987fc787d4..cc8bc92ae4a8e9f1a1ab61bf83d34ad8150b3405:/iokit/IOKit/pwr_mgt/IOPM.h?ds=sidebyside diff --git a/iokit/IOKit/pwr_mgt/IOPM.h b/iokit/IOKit/pwr_mgt/IOPM.h index 362c5ed31..f9ca6ed8a 100644 --- a/iokit/IOKit/pwr_mgt/IOPM.h +++ b/iokit/IOKit/pwr_mgt/IOPM.h @@ -32,10 +32,6 @@ #include #include -#ifdef __ppc__ -#include -#endif - /*! @header IOPM.h @abstract Defines power management constants and keys used by both in-kernel and user space power management. @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. @@ -80,7 +76,7 @@ enum { Useful only as a Capability. - @constant kIOPMSleepCapability + @constant kIOPMSleepCapability 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. @constant kIOPMRestartCapability @@ -91,6 +87,15 @@ enum { @constant kIOPMRestart 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. + + @constant kIOPMInitialDeviceState + Indicates the initial power state for the device. If initialPowerStateForDomainState() returns a power state with this flag set in the capability field, then the initial power change is performed without calling the driver's setPowerState(). + + @constant kIOPMRootDomainState + An indication that the power flags represent the state of the root power + domain. This bit must not be set in the IOPMPowerState structure. + Power Management may pass this bit to initialPowerStateForDomainState() + to map from a global system state to the desired device state. */ typedef unsigned long IOPMPowerFlags; enum { @@ -101,7 +106,9 @@ enum { kIOPMSleepCapability = 0x00000004, kIOPMRestartCapability = 0x00000080, kIOPMSleep = 0x00000001, - kIOPMRestart = 0x00000080 + kIOPMRestart = 0x00000080, + kIOPMInitialDeviceState = 0x00000100, + kIOPMRootDomainState = 0x00000200 }; /* @@ -121,7 +128,6 @@ enum { kIOPMNotPowerManaged = 0x0800 }; - /* * Deprecated IOPMPowerFlags * Their behavior is undefined when used in IOPMPowerState @@ -210,10 +216,177 @@ enum { */ #define kAppleClamshellCausesSleepKey "AppleClamshellCausesSleep" +/* kIOPMSleepWakeUUIDKey + * Key refers to a CFStringRef that will uniquely identify + * a sleep/wake cycle for logging & tracking. + * The key becomes valid at the beginning of a sleep cycle - before we + * initiate any sleep/wake notifications. + * The key becomes invalid at the completion of a system wakeup. The + * property will not be present in the IOPMrootDomain's registry entry + * when it is invalid. + * + * See IOPMrootDomain notification kIOPMMessageSleepWakeUUIDChange + */ + #define kIOPMSleepWakeUUIDKey "SleepWakeUUID" + +/* kIOPMBootSessionUUIDKey + * Key refers to a CFStringRef that will uniquely identify + * a boot cycle. + * The key becomes valid at boot time and remains valid + * till shutdown. The property value will remain same across + * sleep/wake/hibernate cycle. + */ +#define kIOPMBootSessionUUIDKey "BootSessionUUID" + +/* kIOPMDeepSleepEnabledKey + * Indicates the Deep Sleep enable state. + * It has a boolean value. + * true == Deep Sleep is enabled + * false == Deep Sleep is disabled + * not present == Deep Sleep is not supported on this hardware + */ +#define kIOPMDeepSleepEnabledKey "Standby Enabled" + +/* kIOPMDeepSleepDelayKey + * Key refers to a CFNumberRef that represents the delay in seconds before + * entering Deep Sleep state. The property is not present if Deep Sleep is + * unsupported. + */ +#define kIOPMDeepSleepDelayKey "Standby Delay" + +/* kIOPMDestroyFVKeyOnStandbyKey + * Specifies if FileVault key can be stored when going to standby mode + * It has a boolean value, + * true == Destroy FV key when going to standby mode + * false == Retain FV key when going to standby mode + * not present == Retain FV key when going to standby mode + */ +#define kIOPMDestroyFVKeyOnStandbyKey "DestroyFVKeyOnStandby" + +/******************************************************************************* + * + * Properties that can control power management behavior + * + ******************************************************************************/ + +/* kIOPMResetPowerStateOnWakeKey + * If an IOService publishes this key with the value of kOSBooleanTrue, + * then PM will disregard the influence from changePowerStateToPriv() or + * any activity tickles that occurred before system sleep when resolving + * the initial device power state on wake. Influences from power children + * and changePowerStateTo() are not eliminated. At the earliest opportunity + * upon system wake, PM will query the driver for a new power state to be + * installed as the initial changePowerStateToPriv() influence, by calling + * initialPowerStateForDomainState() with both kIOPMRootDomainState and + * kIOPMPowerOn flags set. The default implementation will always return + * the lowest power state. Drivers can override this default behavior to + * immediately raise the power state when there are work blocked on the + * power change, and cannot afford to wait until the next activity tickle. + * This property should be statically added to a driver's plist or set at + * runtime before calling PMinit(). + */ +#define kIOPMResetPowerStateOnWakeKey "IOPMResetPowerStateOnWake" + +/******************************************************************************* + * + * Driver PM Assertions + * + ******************************************************************************/ + +/* Driver Assertion bitfield description + * Driver PM assertions are defined by these bits. + */ +enum { + /*! kIOPMDriverAssertionCPUBit + * When set, PM kernel will prefer to leave the CPU and core hardware + * running in "Dark Wake" state, instead of sleeping. + */ + kIOPMDriverAssertionCPUBit = 0x01, + + /*! kIOPMDriverAssertionUSBExternalDeviceBit + * When set, driver is informing PM that an external USB device is attached. + */ + kIOPMDriverAssertionUSBExternalDeviceBit = 0x04, + + /*! kIOPMDriverAssertionBluetoothHIDDevicePairedBit + * When set, driver is informing PM that a Bluetooth HID device is paired. + */ + kIOPMDriverAssertionBluetoothHIDDevicePairedBit = 0x08, + + /*! kIOPMDriverAssertionExternalMediaMountedBit + * When set, driver is informing PM that an external media is mounted. + */ + kIOPMDriverAssertionExternalMediaMountedBit = 0x10, + + /*! kIOPMDriverAssertionReservedBit5 + * Reserved for Thunderbolt. + */ + kIOPMDriverAssertionReservedBit5 = 0x20, + + /*! kIOPMDriverAssertionPreventDisplaySleepBit + * When set, the display should remain powered on while the system's awake. + */ + kIOPMDriverAssertionPreventDisplaySleepBit = 0x40, + + /*! kIOPMDriverAssertionReservedBit7 + * Reserved for storage family. + */ + kIOPMDriverAssertionReservedBit7 = 0x80, + + /*! kIOPMDriverAssertionMagicPacketWakeEnabledBit + * When set, driver is informing PM that magic packet wake is enabled. + */ + kIOPMDriverAssertionMagicPacketWakeEnabledBit = 0x100, + + /*! kIOPMDriverAssertionNetworkKeepAliveActiveBit + * When set, driver is informing PM that it is holding the network + * interface up to do TCPKeepAlive + */ + kIOPMDriverAssertionNetworkKeepAliveActiveBit = 0x200 +}; + + /* kIOPMAssertionsDriverKey + * This kIOPMrootDomain key refers to a CFNumberRef property, containing + * a bitfield describing the aggregate PM assertion levels. + * Example: A value of 0 indicates that no driver has asserted anything. + * Or, a value of kIOPMDriverAssertionCPUBit + * indicates that a driver (or drivers) have asserted a need for CPU and video. + */ +#define kIOPMAssertionsDriverKey "DriverPMAssertions" + + /* kIOPMAssertionsDriverKey + * This kIOPMrootDomain key refers to a CFNumberRef property, containing + * a bitfield describing the aggregate PM assertion levels. + * Example: A value of 0 indicates that no driver has asserted anything. + * Or, a value of kIOPMDriverAssertionCPUBit + * indicates that a driver (or drivers) have asserted a need for CPU and video. + */ +#define kIOPMAssertionsDriverDetailedKey "DriverPMAssertionsDetailed" + +/******************************************************************************* + * + * Kernel Driver assertion detailed dictionary keys + * + * Keys decode the Array & dictionary data structure under IOPMrootDomain property + * kIOPMAssertionsDriverKey. + * + */ +#define kIOPMDriverAssertionIDKey "ID" +#define kIOPMDriverAssertionCreatedTimeKey "CreatedTime" +#define kIOPMDriverAssertionModifiedTimeKey "ModifiedTime" +#define kIOPMDriverAssertionOwnerStringKey "Owner" +#define kIOPMDriverAssertionOwnerServiceKey "ServicePtr" +#define kIOPMDriverAssertionRegistryEntryIDKey "RegistryEntryID" +#define kIOPMDriverAssertionLevelKey "Level" +#define kIOPMDriverAssertionAssertedKey "Assertions" + /******************************************************************************* * * Root Domain general interest messages * + * Available by registering for interest type 'gIOGeneralInterest' + * on IOPMrootDomain. + * ******************************************************************************/ /* kIOPMMessageClamshellStateChange @@ -252,17 +425,60 @@ enum { kInflowForciblyEnabledBit = (1 << 0) }; +/* kIOPMMessageInternalBatteryFullyDischarged + * The battery has drained completely to its "Fully Discharged" state. + */ #define kIOPMMessageInternalBatteryFullyDischarged \ iokit_family_msg(sub_iokit_powermanagement, 0x120) +/* kIOPMMessageSystemPowerEventOccurred + * Some major system thermal property has changed, and interested clients may + * modify their behavior. + */ +#define kIOPMMessageSystemPowerEventOccurred \ + iokit_family_msg(sub_iokit_powermanagement, 0x130) + +/* kIOPMMessageSleepWakeUUIDChange + * Either a new SleepWakeUUID has been specified at the beginning of a sleep, + * or we're removing the existing property upon completion of a wakeup. + */ +#define kIOPMMessageSleepWakeUUIDChange \ + iokit_family_msg(sub_iokit_powermanagement, 0x140) + +/* kIOPMMessageSleepWakeUUIDSet + * Argument accompanying the kIOPMMessageSleepWakeUUIDChange notification when + * a new UUID has been specified. + */ +#define kIOPMMessageSleepWakeUUIDSet ((void *)1) + +/* kIOPMMessageSleepWakeUUIDCleared + * Argument accompanying the kIOPMMessageSleepWakeUUIDChange notification when + * the current UUID has been removed. + */ +#define kIOPMMessageSleepWakeUUIDCleared ((void *)0) + +/*! kIOPMMessageDriverAssertionsChanged + * Sent when kernel PM driver assertions have changed. + */ +#define kIOPMMessageDriverAssertionsChanged \ + iokit_family_msg(sub_iokit_powermanagement, 0x150) + +/*! kIOPMMessageDarkWakeThermalEmergency + * Sent when machine becomes unsustainably warm in DarkWake. + * Kernel PM might choose to put the machine back to sleep right after. + */ +#define kIOPMMessageDarkWakeThermalEmergency \ + iokit_family_msg(sub_iokit_powermanagement, 0x160) /******************************************************************************* * * Power commands issued to root domain + * Use with IOPMrootDomain::receivePowerNotification() * * These commands are issued from system drivers only: * ApplePMU, AppleSMU, IOGraphics, AppleACPIFamily * + * TODO: deprecate kIOPMAllowSleep and kIOPMPreventSleep ******************************************************************************/ enum { kIOPMSleepNow = (1<<0), // put machine to sleep now @@ -275,9 +491,11 @@ enum { kIOPMEnableClamshell = (1<<7), // sleep on clamshell closure kIOPMProcessorSpeedChange = (1<<8), // change the processor speed kIOPMOverTemp = (1<<9), // system dangerously hot - kIOPMClamshellOpened = (1<<10) // clamshell was opened + kIOPMClamshellOpened = (1<<10), // clamshell was opened + kIOPMDWOverTemp = (1<<11) // DarkWake thermal limits exceeded. }; + /******************************************************************************* * * Power Management Return Codes @@ -285,25 +503,31 @@ enum { ******************************************************************************/ enum { kIOPMNoErr = 0, - // Returned by powerStateWillChange and powerStateDidChange: - // Immediate acknowledgement of power state change + + // Returned by driver's setPowerState(), powerStateWillChangeTo(), + // powerStateDidChangeTo(), or acknowledgeSetPowerState() to + // implicitly acknowledge power change upon function return. kIOPMAckImplied = 0, - // Acknowledgement of power state change will come later + + // Deprecated kIOPMWillAckLater = 1, - - // Returned by requestDomainState: - // Unrecognized specification parameter + + // Returned by requestPowerDomainState() to indicate + // unrecognized specification parameter. kIOPMBadSpecification = 4, - // No power state matches search specification + + // Returned by requestPowerDomainState() to indicate + // no power state matches search specification. kIOPMNoSuchState = 5, - - // Device cannot change its power for some reason + + // Deprecated kIOPMCannotRaisePower = 6, - - // Returned by changeStateTo: - // Requested state doesn't exist + + // Deprecated kIOPMParameterError = 7, - // Device not yet fully hooked into power management + + // Returned when power management state is accessed + // before driver has called PMinit(). kIOPMNotYetInitialized = 8, // And the old constants; deprecated @@ -347,7 +571,20 @@ enum { #define kIOPMPSLegacyBatteryInfoKey "LegacyBatteryInfo" #define kIOPMPSBatteryHealthKey "BatteryHealth" #define kIOPMPSHealthConfidenceKey "HealthConfidence" -#define kIOPMPSCapacityEstimatedKey "CapacityEstimated" +#define kIOPMPSCapacityEstimatedKey "CapacityEstimated" +#define kIOPMPSBatteryChargeStatusKey "ChargeStatus" +#define kIOPMPSBatteryTemperatureKey "Temperature" +#define kIOPMPSAdapterDetailsKey "AdapterDetails" +#define kIOPMPSChargerConfigurationKey "ChargerConfiguration" + +// kIOPMPSBatteryChargeStatusKey may have one of the following values, or may have +// no value. If kIOPMBatteryChargeStatusKey has a NULL value (or no value) associated with it +// then charge is proceeding normally. If one of these battery charge status reasons is listed, +// then the charge may have been interrupted. +#define kIOPMBatteryChargeStatusTooHot "HighTemperature" +#define kIOPMBatteryChargeStatusTooCold "LowTemperature" +#define kIOPMBatteryChargeStatusTooHotOrCold "HighOrLowTemperature" +#define kIOPMBatteryChargeStatusGradient "BatteryTemperatureGradient" // Definitions for battery location, in case of multiple batteries. // A location of 0 is unspecified @@ -366,6 +603,37 @@ enum { kIOPMGoodValue = 3 }; +// Keys for kIOPMPSAdapterDetailsKey dictionary +#define kIOPMPSAdapterDetailsIDKey "AdapterID" +#define kIOPMPSAdapterDetailsWattsKey "Watts" +#define kIOPMPSAdapterDetailsRevisionKey "AdapterRevision" +#define kIOPMPSAdapterDetailsSerialNumberKey "SerialNumber" +#define kIOPMPSAdapterDetailsFamilyKey "FamilyCode" +#define kIOPMPSAdapterDetailsAmperageKey "Amperage" +#define kIOPMPSAdapterDetailsDescriptionKey "Description" +#define kIOPMPSAdapterDetailsPMUConfigurationKey "PMUConfiguration" +#define kIOPMPSAdapterDetailsVoltage "AdapterVoltage" + +// values for kIOPSPowerAdapterFamilyKey +enum { + kIOPSFamilyCodeDisconnected = 0, + kIOPSFamilyCodeUnsupported = kIOReturnUnsupported, + kIOPSFamilyCodeFirewire = iokit_family_err(sub_iokit_firewire, 0), + kIOPSFamilyCodeUSBHost = iokit_family_err(sub_iokit_usb, 0), + kIOPSFamilyCodeUSBHostSuspended = iokit_family_err(sub_iokit_usb, 1), + kIOPSFamilyCodeUSBDevice = iokit_family_err(sub_iokit_usb, 2), + kIOPSFamilyCodeUSBAdapter = iokit_family_err(sub_iokit_usb, 3), + kIOPSFamilyCodeUSBChargingPortDedicated = iokit_family_err(sub_iokit_usb, 4), + kIOPSFamilyCodeUSBChargingPortDownstream = iokit_family_err(sub_iokit_usb, 5), + kIOPSFamilyCodeUSBChargingPort = iokit_family_err(sub_iokit_usb, 6), + kIOPSFamilyCodeUSBUnknown = iokit_family_err(sub_iokit_usb, 7), + kIOPSFamilyCodeAC = iokit_family_err(sub_iokit_pmu, 0), + kIOPSFamilyCodeExternal = iokit_family_err(sub_iokit_pmu, 1), + kIOPSFamilyCodeExternal2 = iokit_family_err(sub_iokit_pmu, 2), + kIOPSFamilyCodeExternal3 = iokit_family_err(sub_iokit_pmu, 3), + kIOPSFamilyCodeExternal4 = iokit_family_err(sub_iokit_pmu, 4), +}; + // Battery's time remaining estimate is invalid this long (seconds) after a wake #define kIOPMPSInvalidWakeSecondsKey "BatteryInvalidWakeSeconds" @@ -378,6 +646,85 @@ enum { #define kIOPMPSPostDishargeWaitSecondsKey "PostDischargeWaitSeconds" +/* CPU Power Management status keys + * Pass as arguments to IOPMrootDomain::systemPowerEventOccurred + * Or as arguments to IOPMSystemPowerEventOccurred() + * Or to decode the dictionary obtained from IOPMCopyCPUPowerStatus() + * These keys reflect restrictions placed on the CPU by the system + * to bring the CPU's power consumption within allowable thermal and + * power constraints. + */ + + +/* kIOPMGraphicsPowerLimitsKey + * The key representing the dictionary of graphics power limits. + * The dictionary contains the other kIOPMCPUPower keys & their associated + * values (e.g. Speed limit, Processor Count, and Schedule limits). + */ +#define kIOPMGraphicsPowerLimitsKey "Graphics_Power_Limits" + +/* kIOPMGraphicsPowerLimitPerformanceKey + * The key representing the percent of overall performance made available + * by the graphics chip as a percentage (integer 0 - 100). + */ +#define kIOPMGraphicsPowerLimitPerformanceKey "Graphics_Power_Performance" + + + +/* kIOPMCPUPowerLimitsKey + * The key representing the dictionary of CPU Power Limits. + * The dictionary contains the other kIOPMCPUPower keys & their associated + * values (e.g. Speed limit, Processor Count, and Schedule limits). + */ +#define kIOPMCPUPowerLimitsKey "CPU_Power_Limits" + +/* kIOPMCPUPowerLimitProcessorSpeedKey defines the speed & voltage limits placed + * on the CPU. + * Represented as a percentage (0-100) of maximum CPU speed. + */ +#define kIOPMCPUPowerLimitProcessorSpeedKey "CPU_Speed_Limit" + +/* kIOPMCPUPowerLimitProcessorCountKey reflects how many, if any, CPUs have been + * taken offline. Represented as an integer number of CPUs (0 - Max CPUs). + */ +#define kIOPMCPUPowerLimitProcessorCountKey "CPU_Available_CPUs" + +/* kIOPMCPUPowerLimitSchedulerTimeKey represents the percentage (0-100) of CPU time + * available. 100% at normal operation. The OS may limit this time for a percentage + * less than 100%. + */ +#define kIOPMCPUPowerLimitSchedulerTimeKey "CPU_Scheduler_Limit" + + +/* Thermal Level Warning Key + * Indicates the thermal constraints placed on the system. This value may + * cause clients to action to consume fewer system resources. + * The value associated with this warning is defined by the platform. + */ +#define kIOPMThermalLevelWarningKey "Thermal_Level_Warning" + +/* Thermal Warning Level values + * kIOPMThermalLevelNormal - under normal operating conditions + * kIOPMThermalLevelDanger - thermal pressure may cause system slowdown + * kIOPMThermalLevelCritical - thermal conditions may cause imminent shutdown + * + * The platform may define additional thermal levels if necessary. + * Platform specific values are defined from 100 and above + */ +enum { + kIOPMThermalLevelNormal = 0, + kIOPMThermalLevelDanger = 5, + kIOPMThermalLevelCritical = 10, + + kIOPMThermalLevelWarning = 100, + kIOPMThermalLevelTrap = 110, + + kIOPMThermalLevelUnknown = 255, +}; + +#define kIOPMThermalWarningLevelNormal kIOPMThermalLevelNormal +#define kIOPMThermalWarningLevelDanger kIOPMThermalLevelWarning +#define kIOPMThermalWarningLevelCrisis kIOPMThermalLevelCritical // PM Settings Controller setting types // Settings types used primarily with: @@ -393,6 +740,7 @@ enum { #define kIOPMSettingDisplaySleepUsesDimKey "Display Sleep Uses Dim" #define kIOPMSettingTimeZoneOffsetKey "TimeZoneOffsetSeconds" #define kIOPMSettingMobileMotionModuleKey "MobileMotionModule" +#define kIOPMSettingGraphicsSwitchKey "GPUSwitch" // Setting controlling drivers can register to receive scheduled wake data // Either in "CF seconds" type, or structured calendar data in a formatted @@ -407,6 +755,10 @@ enum { #define kIOPMSettingDebugWakeRelativeKey "WakeRelativeToSleep" #define kIOPMSettingDebugPowerRelativeKey "PowerRelativeToShutdown" +// Maintenance wake calendar. +#define kIOPMSettingMaintenanceWakeCalendarKey "MaintenanceWakeCalendarDate" + + struct IOPMCalendarStruct { UInt32 year; UInt8 month; @@ -414,6 +766,7 @@ struct IOPMCalendarStruct { UInt8 hour; UInt8 minute; UInt8 second; + UInt8 selector; }; typedef struct IOPMCalendarStruct IOPMCalendarStruct; @@ -454,7 +807,6 @@ enum { kIOBatteryChargerConnect = (1 << 0) }; - // Private power management message indicating battery data has changed // Indicates new data resides in the IORegistry #define kIOPMMessageBatteryStatusHasChanged iokit_family_msg(sub_iokit_pmu, 0x100) @@ -480,7 +832,6 @@ enum { kIOPMClamshellStateOnWake = (1<<10) // used only by Platform Expert }; - // ********************************************** // Internal power management data structures // ********************************************** @@ -495,15 +846,19 @@ enum { enum { kIOPMSubclassPolicy, kIOPMSuperclassPolicy1 +#ifdef KERNEL_PRIVATE + , kIOPMActivityTickleTypeAdvisory = 128 +#endif }; -struct stateChangeNote{ +struct stateChangeNote { IOPMPowerFlags stateFlags; unsigned long stateNum; void * powerRef; }; typedef struct stateChangeNote stateChangeNote; +#endif /* KERNEL && __cplusplus */ struct IOPowerStateChangeNotification { void * powerRef; unsigned long returnValue; @@ -513,8 +868,54 @@ struct IOPowerStateChangeNotification { typedef struct IOPowerStateChangeNotification IOPowerStateChangeNotification; typedef IOPowerStateChangeNotification sleepWakeNote; -extern void IOPMRegisterDevice(const char *, IOService *); -#endif /* KERNEL && __cplusplus */ +/*! @struct IOPMSystemCapabilityChangeParameters + @abstract A structure describing a system capability change. + @discussion A system capability change is a system level transition from a set + of system capabilities to a new set of system capabilities. Power management + sends a kIOMessageSystemCapabilityChange message and provides + this structure as the message data (by reference) to + gIOPriorityPowerStateInterest clients when system capability + changes. + @field notifyRef An identifier for this message notification. Clients with pending + I/O can signal completion by calling allowPowerChange() with this + value as the argument. Clients that are able to process the notification + synchronously should ignore this field. + @field maxWaitForReply A return value to the caller indicating the maximum time in + microseconds to wait for the allowPowerChange() call. The default + value is zero, which indicates the client processing has finished, and power + management should not wait for an allowPowerChange() call. + @field changeFlags Flags will be set to indicate whether the notification precedes + the capability change (kIOPMSystemCapabilityWillChange), or after + the capability change has occurred (kIOPMSystemCapabilityDidChange). + @field __reserved1 Set to zero. + @field fromCapabilities The system capabilities at the start of the transition. + @field toCapabilities The system capabilities at the end of the transition. + @field __reserved2 Set to zero. + */ +struct IOPMSystemCapabilityChangeParameters { + uint32_t notifyRef; + uint32_t maxWaitForReply; + uint32_t changeFlags; + uint32_t __reserved1; + uint32_t fromCapabilities; + uint32_t toCapabilities; + uint32_t __reserved2[4]; +}; -#endif /* ! _IOKIT_IOPM_H */ +/*! @enum IOPMSystemCapabilityChangeFlags + @constant kIOPMSystemCapabilityWillChange Indicates the system capability will change. + @constant kIOPMSystemCapabilityDidChange Indicates the system capability has changed. +*/ +enum { + kIOPMSystemCapabilityWillChange = 0x01, + kIOPMSystemCapabilityDidChange = 0x02 +}; + +enum { + kIOPMSystemCapabilityCPU = 0x01, + kIOPMSystemCapabilityGraphics = 0x02, + kIOPMSystemCapabilityAudio = 0x04, + kIOPMSystemCapabilityNetwork = 0x08 +}; +#endif /* ! _IOKIT_IOPM_H */