You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
695 lines
20 KiB
695 lines
20 KiB
/*++ BUILD Version: 0001 // Increment this if a change has global effects
|
|
|
|
Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
|
Module Name:
|
|
|
|
ntpoapi.h
|
|
|
|
Abstract:
|
|
|
|
This module contains the user APIs for the NT Power Management.
|
|
|
|
Author:
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#ifndef _NTPOAPI_
|
|
#define _NTPOAPI_
|
|
|
|
#if _MSC_VER > 1000
|
|
#pragma once
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
//
|
|
// Power Management user APIs
|
|
//
|
|
|
|
// begin_ntddk begin_ntifs begin_nthal begin_ntminiport begin_wdm
|
|
|
|
#ifndef _PO_DDK_
|
|
#define _PO_DDK_
|
|
|
|
// begin_winnt
|
|
|
|
typedef enum _SYSTEM_POWER_STATE {
|
|
PowerSystemUnspecified = 0,
|
|
PowerSystemWorking = 1,
|
|
PowerSystemSleeping1 = 2,
|
|
PowerSystemSleeping2 = 3,
|
|
PowerSystemSleeping3 = 4,
|
|
PowerSystemHibernate = 5,
|
|
PowerSystemShutdown = 6,
|
|
PowerSystemMaximum = 7
|
|
} SYSTEM_POWER_STATE, *PSYSTEM_POWER_STATE;
|
|
|
|
#define POWER_SYSTEM_MAXIMUM 7
|
|
|
|
typedef enum {
|
|
PowerActionNone = 0,
|
|
PowerActionReserved,
|
|
PowerActionSleep,
|
|
PowerActionHibernate,
|
|
PowerActionShutdown,
|
|
PowerActionShutdownReset,
|
|
PowerActionShutdownOff,
|
|
PowerActionWarmEject
|
|
} POWER_ACTION, *PPOWER_ACTION;
|
|
|
|
typedef enum _DEVICE_POWER_STATE {
|
|
PowerDeviceUnspecified = 0,
|
|
PowerDeviceD0,
|
|
PowerDeviceD1,
|
|
PowerDeviceD2,
|
|
PowerDeviceD3,
|
|
PowerDeviceMaximum
|
|
} DEVICE_POWER_STATE, *PDEVICE_POWER_STATE;
|
|
|
|
// end_winnt
|
|
|
|
typedef union _POWER_STATE {
|
|
SYSTEM_POWER_STATE SystemState;
|
|
DEVICE_POWER_STATE DeviceState;
|
|
} POWER_STATE, *PPOWER_STATE;
|
|
|
|
typedef enum _POWER_STATE_TYPE {
|
|
SystemPowerState = 0,
|
|
DevicePowerState
|
|
} POWER_STATE_TYPE, *PPOWER_STATE_TYPE;
|
|
|
|
//
|
|
// Generic power related IOCTLs
|
|
//
|
|
|
|
#define IOCTL_QUERY_DEVICE_POWER_STATE \
|
|
CTL_CODE(FILE_DEVICE_BATTERY, 0x0, METHOD_BUFFERED, FILE_READ_ACCESS)
|
|
|
|
#define IOCTL_SET_DEVICE_WAKE \
|
|
CTL_CODE(FILE_DEVICE_BATTERY, 0x1, METHOD_BUFFERED, FILE_WRITE_ACCESS)
|
|
|
|
#define IOCTL_CANCEL_DEVICE_WAKE \
|
|
CTL_CODE(FILE_DEVICE_BATTERY, 0x2, METHOD_BUFFERED, FILE_WRITE_ACCESS)
|
|
|
|
|
|
//
|
|
// Defines for W32 interfaces
|
|
//
|
|
|
|
// begin_winnt
|
|
|
|
#define ES_SYSTEM_REQUIRED ((ULONG)0x00000001)
|
|
#define ES_DISPLAY_REQUIRED ((ULONG)0x00000002)
|
|
#define ES_USER_PRESENT ((ULONG)0x00000004)
|
|
#define ES_CONTINUOUS ((ULONG)0x80000000)
|
|
|
|
typedef ULONG EXECUTION_STATE;
|
|
|
|
typedef enum {
|
|
LT_DONT_CARE,
|
|
LT_LOWEST_LATENCY
|
|
} LATENCY_TIME;
|
|
|
|
// end_ntminiport end_ntifs end_wdm end_ntddk
|
|
//-----------------------------------------------------------------------------
|
|
// Device Power Information
|
|
// Accessable via CM_Get_DevInst_Registry_Property_Ex(CM_DRP_DEVICE_POWER_DATA)
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#define PDCAP_D0_SUPPORTED 0x00000001
|
|
#define PDCAP_D1_SUPPORTED 0x00000002
|
|
#define PDCAP_D2_SUPPORTED 0x00000004
|
|
#define PDCAP_D3_SUPPORTED 0x00000008
|
|
#define PDCAP_WAKE_FROM_D0_SUPPORTED 0x00000010
|
|
#define PDCAP_WAKE_FROM_D1_SUPPORTED 0x00000020
|
|
#define PDCAP_WAKE_FROM_D2_SUPPORTED 0x00000040
|
|
#define PDCAP_WAKE_FROM_D3_SUPPORTED 0x00000080
|
|
#define PDCAP_WARM_EJECT_SUPPORTED 0x00000100
|
|
|
|
typedef struct CM_Power_Data_s {
|
|
ULONG PD_Size;
|
|
DEVICE_POWER_STATE PD_MostRecentPowerState;
|
|
ULONG PD_Capabilities;
|
|
ULONG PD_D1Latency;
|
|
ULONG PD_D2Latency;
|
|
ULONG PD_D3Latency;
|
|
DEVICE_POWER_STATE PD_PowerStateMapping[POWER_SYSTEM_MAXIMUM];
|
|
SYSTEM_POWER_STATE PD_DeepestSystemWake;
|
|
} CM_POWER_DATA, *PCM_POWER_DATA;
|
|
|
|
// begin_ntddk
|
|
|
|
typedef enum {
|
|
SystemPowerPolicyAc,
|
|
SystemPowerPolicyDc,
|
|
VerifySystemPolicyAc,
|
|
VerifySystemPolicyDc,
|
|
SystemPowerCapabilities,
|
|
SystemBatteryState,
|
|
SystemPowerStateHandler,
|
|
ProcessorStateHandler,
|
|
SystemPowerPolicyCurrent,
|
|
AdministratorPowerPolicy,
|
|
SystemReserveHiberFile,
|
|
ProcessorInformation,
|
|
SystemPowerInformation,
|
|
ProcessorStateHandler2,
|
|
LastWakeTime, // Compare with KeQueryInterruptTime()
|
|
LastSleepTime, // Compare with KeQueryInterruptTime()
|
|
SystemExecutionState,
|
|
SystemPowerStateNotifyHandler,
|
|
ProcessorPowerPolicyAc,
|
|
ProcessorPowerPolicyDc,
|
|
VerifyProcessorPowerPolicyAc,
|
|
VerifyProcessorPowerPolicyDc,
|
|
ProcessorPowerPolicyCurrent,
|
|
SystemPowerStateLogging,
|
|
SystemPowerLoggingEntry
|
|
} POWER_INFORMATION_LEVEL;
|
|
|
|
// begin_wdm
|
|
|
|
//
|
|
// System power manager capabilities
|
|
//
|
|
|
|
typedef struct {
|
|
ULONG Granularity;
|
|
ULONG Capacity;
|
|
} BATTERY_REPORTING_SCALE, *PBATTERY_REPORTING_SCALE;
|
|
|
|
// end_winnt
|
|
// begin_ntminiport begin_ntifs
|
|
|
|
#endif // !_PO_DDK_
|
|
|
|
// end_ntddk end_ntminiport end_wdm end_ntifs
|
|
|
|
|
|
#define POWER_PERF_SCALE 100
|
|
#define PERF_LEVEL_TO_PERCENT(_x_) ((_x_ * 1000) / (POWER_PERF_SCALE * 10))
|
|
#define PERCENT_TO_PERF_LEVEL(_x_) ((_x_ * POWER_PERF_SCALE * 10) / 1000)
|
|
|
|
//
|
|
// Policy manager state handler interfaces
|
|
//
|
|
|
|
// power state handlers
|
|
|
|
typedef enum {
|
|
PowerStateSleeping1 = 0,
|
|
PowerStateSleeping2 = 1,
|
|
PowerStateSleeping3 = 2,
|
|
PowerStateSleeping4 = 3,
|
|
PowerStateSleeping4Firmware = 4,
|
|
PowerStateShutdownReset = 5,
|
|
PowerStateShutdownOff = 6,
|
|
PowerStateMaximum = 7
|
|
} POWER_STATE_HANDLER_TYPE, *PPOWER_STATE_HANDLER_TYPE;
|
|
|
|
#define POWER_STATE_HANDLER_TYPE_MAX 8
|
|
|
|
typedef
|
|
NTSTATUS
|
|
(*PENTER_STATE_SYSTEM_HANDLER)(
|
|
IN PVOID SystemContext
|
|
);
|
|
|
|
typedef
|
|
NTSTATUS
|
|
(*PENTER_STATE_HANDLER)(
|
|
IN PVOID Context,
|
|
IN PENTER_STATE_SYSTEM_HANDLER SystemHandler OPTIONAL,
|
|
IN PVOID SystemContext,
|
|
IN LONG NumberProcessors,
|
|
IN volatile PLONG Number
|
|
);
|
|
|
|
typedef struct {
|
|
POWER_STATE_HANDLER_TYPE Type;
|
|
BOOLEAN RtcWake;
|
|
UCHAR Spare[3];
|
|
PENTER_STATE_HANDLER Handler;
|
|
PVOID Context;
|
|
} POWER_STATE_HANDLER, *PPOWER_STATE_HANDLER;
|
|
|
|
|
|
typedef
|
|
NTSTATUS
|
|
(*PENTER_STATE_NOTIFY_HANDLER)(
|
|
IN POWER_STATE_HANDLER_TYPE State,
|
|
IN PVOID Context,
|
|
IN BOOLEAN Entering
|
|
);
|
|
|
|
typedef struct {
|
|
PENTER_STATE_NOTIFY_HANDLER Handler;
|
|
PVOID Context;
|
|
} POWER_STATE_NOTIFY_HANDLER, *PPOWER_STATE_NOTIFY_HANDLER;
|
|
|
|
|
|
NTSYSCALLAPI
|
|
NTSTATUS
|
|
NTAPI
|
|
NtPowerInformation(
|
|
IN POWER_INFORMATION_LEVEL InformationLevel,
|
|
IN PVOID InputBuffer OPTIONAL,
|
|
IN ULONG InputBufferLength,
|
|
OUT PVOID OutputBuffer OPTIONAL,
|
|
IN ULONG OutputBufferLength
|
|
);
|
|
|
|
// processor idle functions
|
|
|
|
typedef struct {
|
|
ULONGLONG StartTime;
|
|
ULONGLONG EndTime;
|
|
ULONG IdleHandlerReserved[4];
|
|
} PROCESSOR_IDLE_TIMES, *PPROCESSOR_IDLE_TIMES;
|
|
|
|
typedef
|
|
BOOLEAN
|
|
(FASTCALL *PPROCESSOR_IDLE_HANDLER) (
|
|
IN OUT PPROCESSOR_IDLE_TIMES IdleTimes
|
|
);
|
|
|
|
typedef struct {
|
|
ULONG HardwareLatency;
|
|
PPROCESSOR_IDLE_HANDLER Handler;
|
|
} PROCESSOR_IDLE_HANDLER_INFO, *PPROCESSOR_IDLE_HANDLER_INFO;
|
|
|
|
typedef
|
|
VOID
|
|
(FASTCALL *PSET_PROCESSOR_THROTTLE) (
|
|
IN UCHAR Throttle
|
|
);
|
|
|
|
typedef
|
|
NTSTATUS
|
|
(FASTCALL *PSET_PROCESSOR_THROTTLE2) (
|
|
IN UCHAR Throttle
|
|
);
|
|
|
|
#define MAX_IDLE_HANDLERS 3
|
|
|
|
typedef struct {
|
|
UCHAR ThrottleScale;
|
|
BOOLEAN ThrottleOnIdle;
|
|
PSET_PROCESSOR_THROTTLE SetThrottle;
|
|
|
|
ULONG NumIdleHandlers;
|
|
PROCESSOR_IDLE_HANDLER_INFO IdleHandler[MAX_IDLE_HANDLERS];
|
|
} PROCESSOR_STATE_HANDLER, *PPROCESSOR_STATE_HANDLER;
|
|
|
|
|
|
|
|
// Processor_Perf_Level Flags
|
|
|
|
#define PROCESSOR_STATE_TYPE_PERFORMANCE 0x1
|
|
#define PROCESSOR_STATE_TYPE_THROTTLE 0x2
|
|
|
|
typedef struct {
|
|
UCHAR PercentFrequency; // max == POWER_PERF_SCALE
|
|
UCHAR Reserved;
|
|
USHORT Flags;
|
|
} PROCESSOR_PERF_LEVEL, *PPROCESSOR_PERF_LEVEL;
|
|
|
|
typedef struct {
|
|
UCHAR PercentFrequency; // max == POWER_PERF_SCALE
|
|
UCHAR MinCapacity; // battery capacity %
|
|
USHORT Power; // in milliwatts
|
|
UCHAR IncreaseLevel; // goto higher state
|
|
UCHAR DecreaseLevel; // goto lower state
|
|
USHORT Flags;
|
|
ULONG IncreaseTime; // in tick counts
|
|
ULONG DecreaseTime; // in tick counts
|
|
ULONG IncreaseCount; // goto higher state
|
|
ULONG DecreaseCount; // goto lower state
|
|
ULONGLONG PerformanceTime; // Tick count
|
|
} PROCESSOR_PERF_STATE, *PPROCESSOR_PERF_STATE;
|
|
|
|
typedef struct {
|
|
ULONG NumIdleHandlers;
|
|
PROCESSOR_IDLE_HANDLER_INFO IdleHandler[MAX_IDLE_HANDLERS];
|
|
PSET_PROCESSOR_THROTTLE2 SetPerfLevel;
|
|
ULONG HardwareLatency;
|
|
UCHAR NumPerfStates;
|
|
PROCESSOR_PERF_LEVEL PerfLevel[1]; // variable size
|
|
} PROCESSOR_STATE_HANDLER2, *PPROCESSOR_STATE_HANDLER2;
|
|
|
|
// begin_winnt
|
|
//
|
|
|
|
// Power Policy Management interfaces
|
|
//
|
|
|
|
typedef struct {
|
|
POWER_ACTION Action;
|
|
ULONG Flags;
|
|
ULONG EventCode;
|
|
} POWER_ACTION_POLICY, *PPOWER_ACTION_POLICY;
|
|
|
|
// POWER_ACTION_POLICY->Flags:
|
|
#define POWER_ACTION_QUERY_ALLOWED 0x00000001
|
|
#define POWER_ACTION_UI_ALLOWED 0x00000002
|
|
#define POWER_ACTION_OVERRIDE_APPS 0x00000004
|
|
#define POWER_ACTION_LIGHTEST_FIRST 0x10000000
|
|
#define POWER_ACTION_LOCK_CONSOLE 0x20000000
|
|
#define POWER_ACTION_DISABLE_WAKES 0x40000000
|
|
#define POWER_ACTION_CRITICAL 0x80000000
|
|
|
|
// POWER_ACTION_POLICY->EventCode flags
|
|
#define POWER_LEVEL_USER_NOTIFY_TEXT 0x00000001
|
|
#define POWER_LEVEL_USER_NOTIFY_SOUND 0x00000002
|
|
#define POWER_LEVEL_USER_NOTIFY_EXEC 0x00000004
|
|
#define POWER_USER_NOTIFY_BUTTON 0x00000008
|
|
#define POWER_USER_NOTIFY_SHUTDOWN 0x00000010
|
|
#define POWER_FORCE_TRIGGER_RESET 0x80000000
|
|
|
|
// system battery drain policies
|
|
typedef struct {
|
|
BOOLEAN Enable;
|
|
UCHAR Spare[3];
|
|
ULONG BatteryLevel;
|
|
POWER_ACTION_POLICY PowerPolicy;
|
|
SYSTEM_POWER_STATE MinSystemState;
|
|
} SYSTEM_POWER_LEVEL, *PSYSTEM_POWER_LEVEL;
|
|
|
|
// Discharge policy constants
|
|
#define NUM_DISCHARGE_POLICIES 4
|
|
#define DISCHARGE_POLICY_CRITICAL 0
|
|
#define DISCHARGE_POLICY_LOW 1
|
|
|
|
//
|
|
// Throttling policies
|
|
//
|
|
#define PO_THROTTLE_NONE 0
|
|
#define PO_THROTTLE_CONSTANT 1
|
|
#define PO_THROTTLE_DEGRADE 2
|
|
#define PO_THROTTLE_ADAPTIVE 3
|
|
#define PO_THROTTLE_MAXIMUM 4 // not a policy, just a limit
|
|
|
|
// system power policies
|
|
typedef struct _SYSTEM_POWER_POLICY {
|
|
ULONG Revision; // 1
|
|
|
|
// events
|
|
POWER_ACTION_POLICY PowerButton;
|
|
POWER_ACTION_POLICY SleepButton;
|
|
POWER_ACTION_POLICY LidClose;
|
|
SYSTEM_POWER_STATE LidOpenWake;
|
|
ULONG Reserved;
|
|
|
|
// "system idle" detection
|
|
POWER_ACTION_POLICY Idle;
|
|
ULONG IdleTimeout;
|
|
UCHAR IdleSensitivity;
|
|
|
|
// dynamic throttling policy
|
|
// PO_THROTTLE_NONE, PO_THROTTLE_CONSTANT, PO_THROTTLE_DEGRADE, or PO_THROTTLE_ADAPTIVE
|
|
UCHAR DynamicThrottle;
|
|
|
|
UCHAR Spare2[2];
|
|
|
|
// meaning of power action "sleep"
|
|
SYSTEM_POWER_STATE MinSleep;
|
|
SYSTEM_POWER_STATE MaxSleep;
|
|
SYSTEM_POWER_STATE ReducedLatencySleep;
|
|
ULONG WinLogonFlags;
|
|
|
|
// parameters for dozing
|
|
ULONG Spare3;
|
|
ULONG DozeS4Timeout;
|
|
|
|
// battery policies
|
|
ULONG BroadcastCapacityResolution;
|
|
SYSTEM_POWER_LEVEL DischargePolicy[NUM_DISCHARGE_POLICIES];
|
|
|
|
// video policies
|
|
ULONG VideoTimeout;
|
|
BOOLEAN VideoDimDisplay;
|
|
ULONG VideoReserved[3];
|
|
|
|
// hard disk policies
|
|
ULONG SpindownTimeout;
|
|
|
|
// processor policies
|
|
BOOLEAN OptimizeForPower;
|
|
UCHAR FanThrottleTolerance;
|
|
UCHAR ForcedThrottle;
|
|
UCHAR MinThrottle;
|
|
POWER_ACTION_POLICY OverThrottled;
|
|
|
|
} SYSTEM_POWER_POLICY, *PSYSTEM_POWER_POLICY;
|
|
|
|
// processor power policy state
|
|
typedef struct _PROCESSOR_POWER_POLICY_INFO {
|
|
|
|
// Time based information (will be converted to kernel units)
|
|
ULONG TimeCheck; // in US
|
|
ULONG DemoteLimit; // in US
|
|
ULONG PromoteLimit; // in US
|
|
|
|
// Percentage based information
|
|
UCHAR DemotePercent;
|
|
UCHAR PromotePercent;
|
|
UCHAR Spare[2];
|
|
|
|
// Flags
|
|
ULONG AllowDemotion:1;
|
|
ULONG AllowPromotion:1;
|
|
ULONG Reserved:30;
|
|
|
|
} PROCESSOR_POWER_POLICY_INFO, *PPROCESSOR_POWER_POLICY_INFO;
|
|
|
|
// processor power policy
|
|
typedef struct _PROCESSOR_POWER_POLICY {
|
|
ULONG Revision; // 1
|
|
|
|
// Dynamic Throttling Policy
|
|
UCHAR DynamicThrottle;
|
|
UCHAR Spare[3];
|
|
|
|
// Flags
|
|
ULONG DisableCStates:1;
|
|
ULONG Reserved:31;
|
|
|
|
// System policy information
|
|
// The Array is last, in case it needs to be grown and the structure
|
|
// revision incremented.
|
|
ULONG PolicyCount;
|
|
PROCESSOR_POWER_POLICY_INFO Policy[3];
|
|
|
|
} PROCESSOR_POWER_POLICY, *PPROCESSOR_POWER_POLICY;
|
|
|
|
// administrator power policy overrides
|
|
typedef struct _ADMINISTRATOR_POWER_POLICY {
|
|
|
|
// meaning of power action "sleep"
|
|
SYSTEM_POWER_STATE MinSleep;
|
|
SYSTEM_POWER_STATE MaxSleep;
|
|
|
|
// video policies
|
|
ULONG MinVideoTimeout;
|
|
ULONG MaxVideoTimeout;
|
|
|
|
// disk policies
|
|
ULONG MinSpindownTimeout;
|
|
ULONG MaxSpindownTimeout;
|
|
} ADMINISTRATOR_POWER_POLICY, *PADMINISTRATOR_POWER_POLICY;
|
|
|
|
// end_winnt
|
|
|
|
NTSYSCALLAPI
|
|
NTSTATUS
|
|
NTAPI
|
|
NtSetThreadExecutionState(
|
|
IN EXECUTION_STATE esFlags, // ES_xxx flags
|
|
OUT EXECUTION_STATE *PreviousFlags
|
|
);
|
|
|
|
NTSYSCALLAPI
|
|
NTSTATUS
|
|
NTAPI
|
|
NtRequestWakeupLatency(
|
|
IN LATENCY_TIME latency
|
|
);
|
|
|
|
NTSYSCALLAPI
|
|
NTSTATUS
|
|
NTAPI
|
|
NtInitiatePowerAction(
|
|
IN POWER_ACTION SystemAction,
|
|
IN SYSTEM_POWER_STATE MinSystemState,
|
|
IN ULONG Flags, // POWER_ACTION_xxx flags
|
|
IN BOOLEAN Asynchronous
|
|
);
|
|
|
|
|
|
NTSYSCALLAPI // only called by WinLogon
|
|
NTSTATUS
|
|
NTAPI
|
|
NtSetSystemPowerState(
|
|
IN POWER_ACTION SystemAction,
|
|
IN SYSTEM_POWER_STATE MinSystemState,
|
|
IN ULONG Flags // POWER_ACTION_xxx flags
|
|
);
|
|
|
|
NTSYSCALLAPI
|
|
NTSTATUS
|
|
NTAPI
|
|
NtGetDevicePowerState(
|
|
IN HANDLE Device,
|
|
OUT DEVICE_POWER_STATE *State
|
|
);
|
|
|
|
NTSYSCALLAPI
|
|
NTSTATUS
|
|
NTAPI
|
|
NtCancelDeviceWakeupRequest(
|
|
IN HANDLE Device
|
|
);
|
|
|
|
NTSYSCALLAPI
|
|
BOOLEAN
|
|
NTAPI
|
|
NtIsSystemResumeAutomatic(
|
|
VOID
|
|
);
|
|
|
|
NTSYSCALLAPI
|
|
NTSTATUS
|
|
NTAPI
|
|
NtRequestDeviceWakeup(
|
|
IN HANDLE Device
|
|
);
|
|
|
|
|
|
// WinLogonFlags:
|
|
#define WINLOGON_LOCK_ON_SLEEP 0x00000001
|
|
|
|
// begin_winnt
|
|
|
|
typedef struct {
|
|
// Misc supported system features
|
|
BOOLEAN PowerButtonPresent;
|
|
BOOLEAN SleepButtonPresent;
|
|
BOOLEAN LidPresent;
|
|
BOOLEAN SystemS1;
|
|
BOOLEAN SystemS2;
|
|
BOOLEAN SystemS3;
|
|
BOOLEAN SystemS4; // hibernate
|
|
BOOLEAN SystemS5; // off
|
|
BOOLEAN HiberFilePresent;
|
|
BOOLEAN FullWake;
|
|
BOOLEAN VideoDimPresent;
|
|
BOOLEAN ApmPresent;
|
|
BOOLEAN UpsPresent;
|
|
|
|
// Processors
|
|
BOOLEAN ThermalControl;
|
|
BOOLEAN ProcessorThrottle;
|
|
UCHAR ProcessorMinThrottle;
|
|
UCHAR ProcessorMaxThrottle;
|
|
UCHAR spare2[4];
|
|
|
|
// Disk
|
|
BOOLEAN DiskSpinDown;
|
|
UCHAR spare3[8];
|
|
|
|
// System Battery
|
|
BOOLEAN SystemBatteriesPresent;
|
|
BOOLEAN BatteriesAreShortTerm;
|
|
BATTERY_REPORTING_SCALE BatteryScale[3];
|
|
|
|
// Wake
|
|
SYSTEM_POWER_STATE AcOnLineWake;
|
|
SYSTEM_POWER_STATE SoftLidWake;
|
|
SYSTEM_POWER_STATE RtcWake;
|
|
SYSTEM_POWER_STATE MinDeviceWakeState; // note this may change on driver load
|
|
SYSTEM_POWER_STATE DefaultLowLatencyWake;
|
|
} SYSTEM_POWER_CAPABILITIES, *PSYSTEM_POWER_CAPABILITIES;
|
|
|
|
typedef struct {
|
|
BOOLEAN AcOnLine;
|
|
BOOLEAN BatteryPresent;
|
|
BOOLEAN Charging;
|
|
BOOLEAN Discharging;
|
|
BOOLEAN Spare1[4];
|
|
|
|
ULONG MaxCapacity;
|
|
ULONG RemainingCapacity;
|
|
ULONG Rate;
|
|
ULONG EstimatedTime;
|
|
|
|
ULONG DefaultAlert1;
|
|
ULONG DefaultAlert2;
|
|
} SYSTEM_BATTERY_STATE, *PSYSTEM_BATTERY_STATE;
|
|
|
|
// end_winnt
|
|
|
|
//
|
|
// valid flags for SYSTEM_POWER_STATE_DISABLE_REASON.PowerReasonCode
|
|
//
|
|
#define SPSD_REASON_NONE 0x00000000
|
|
#define SPSD_REASON_NOBIOSSUPPORT 0x00000001
|
|
#define SPSD_REASON_BIOSINCOMPATIBLE 0x00000002
|
|
#define SPSD_REASON_NOOSPM 0x00000003
|
|
#define SPSD_REASON_LEGACYDRIVER 0x00000004
|
|
#define SPSD_REASON_HIBERSTACK 0x00000005
|
|
#define SPSD_REASON_HIBERFILE 0x00000006
|
|
#define SPSD_REASON_POINTERNAL 0x00000007
|
|
#define SPSD_REASON_PAEMODE 0x00000008
|
|
#define SPSD_REASON_MPOVERRIDE 0x00000009
|
|
#define SPSD_REASON_DRIVERDOWNGRADE 0x0000000A
|
|
#define SPSD_REASON_PREVIOUSATTEMPTFAILED 0x0000000B
|
|
#define SPSD_REASON_UNKNOWN 0xFFFFFFFF
|
|
|
|
|
|
typedef struct _SYSTEM_POWER_STATE_DISABLE_REASON {
|
|
BOOLEAN AffectedState[POWER_STATE_HANDLER_TYPE_MAX];
|
|
ULONG PowerReasonCode;
|
|
ULONG PowerReasonLength;
|
|
//UCHAR PowerReasonInfo[ANYSIZE_ARRAY];
|
|
} SYSTEM_POWER_STATE_DISABLE_REASON, *PSYSTEM_POWER_STATE_DISABLE_REASON;
|
|
|
|
//
|
|
// valid flags for SYSTEM_POWER_LOGGING_ENTRY.LoggingType
|
|
//
|
|
#define LOGGING_TYPE_SPSD 0x00000001
|
|
#define LOGGING_TYPE_POWERTRANSITION 0x00000002
|
|
|
|
typedef struct _SYSTEM_POWER_LOGGING_ENTRY {
|
|
ULONG LoggingType;
|
|
PVOID LoggingEntry;
|
|
} SYSTEM_POWER_LOGGING_ENTRY, *PSYSTEM_POWER_LOGGING_ENTRY;
|
|
|
|
|
|
// end_nthal
|
|
|
|
typedef struct _PROCESSOR_POWER_INFORMATION {
|
|
ULONG Number;
|
|
ULONG MaxMhz;
|
|
ULONG CurrentMhz;
|
|
ULONG MhzLimit;
|
|
ULONG MaxIdleState;
|
|
ULONG CurrentIdleState;
|
|
} PROCESSOR_POWER_INFORMATION, *PPROCESSOR_POWER_INFORMATION;
|
|
|
|
typedef struct _SYSTEM_POWER_INFORMATION {
|
|
ULONG MaxIdlenessAllowed;
|
|
ULONG Idleness;
|
|
ULONG TimeRemaining;
|
|
UCHAR CoolingMode;
|
|
} SYSTEM_POWER_INFORMATION, *PSYSTEM_POWER_INFORMATION;
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif // _NTPOAPI_
|