641 lines
19 KiB
C
641 lines
19 KiB
C
/*++
|
||
|
||
Copyright (c) 1995 Microsoft Corporation
|
||
|
||
Module Name:
|
||
|
||
podata.c
|
||
|
||
Abstract:
|
||
|
||
This module contains the global read/write data for the I/O system.
|
||
|
||
Author:
|
||
|
||
N. Yoshiyama [IBM Corp] 07-April-1994 ( Depends on Microsoft's design )
|
||
|
||
Revision History:
|
||
|
||
|
||
--*/
|
||
|
||
#include "pop.h"
|
||
|
||
#ifdef ALLOC_DATA_PRAGMA
|
||
#pragma const_seg("PAGECONST")
|
||
#endif // ALLOC_DATA_PRAGMA
|
||
#include "initguid.h" // define PO guids
|
||
#include "poclass.h"
|
||
#ifdef ALLOC_DATA_PRAGMA
|
||
#pragma const_seg()
|
||
#endif // ALLOC_DATA_PRAGMA
|
||
|
||
|
||
|
||
//
|
||
// Define the global data for the Power Management.
|
||
//
|
||
|
||
//
|
||
// Power Locks
|
||
//
|
||
|
||
//
|
||
// Protects the IRP serial list.
|
||
//
|
||
KSPIN_LOCK PopIrpSerialLock;
|
||
|
||
//
|
||
// Protects all Dope structures and dependents,
|
||
// including all Notify and Idle operations.
|
||
//
|
||
KSPIN_LOCK PopDopeGlobalLock;
|
||
|
||
//
|
||
// Must be held during creation or
|
||
// destruction of power notify channel
|
||
// structures.
|
||
ERESOURCE PopNotifyLock;
|
||
|
||
|
||
//
|
||
// PoPowerSequence - The current power sequence value. Forever counts
|
||
// up each time the machine is resumed from a suspend or hibernate
|
||
//
|
||
ULONG PoPowerSequence;
|
||
|
||
//
|
||
// PopInvalidNotifyBlockCount is the number of power notify blocks which
|
||
// have been invalidated but not fully closed up and freed. Should be 0
|
||
// most of the time. Non-0 indicates callers have failed to clean up
|
||
// in response to an Invalidate notify.
|
||
//
|
||
ULONG PopInvalidNotifyBlockCount;
|
||
|
||
//
|
||
// Irp serializtion and Inrush serialization - pocall.c and related
|
||
//
|
||
LIST_ENTRY PopIrpSerialList;
|
||
ULONG PopIrpSerialListLength;
|
||
BOOLEAN PopInrushPending;
|
||
PIRP PopInrushIrpPointer;
|
||
LONG PopInrushIrpReferenceCount;
|
||
|
||
//
|
||
// PopSystemIrpDisptachWorker control, etc
|
||
//
|
||
KSPIN_LOCK PopWorkerLock;
|
||
ULONG PopCallSystemState;
|
||
|
||
|
||
//
|
||
// For debugging, a list of all the outstanding PoRequestPowerIrps
|
||
//
|
||
LIST_ENTRY PopRequestedIrps;
|
||
|
||
//
|
||
// For logging supported power states, a list of reason structures.
|
||
//
|
||
LIST_ENTRY PowerStateDisableReasonListHead;
|
||
|
||
//
|
||
// Idle detection service - see idle.c
|
||
//
|
||
// When adding to, removing from, or scanning the IdleDetectList, code
|
||
// must be at DPC_LEVEL and must hold the PopGlobalDopeLock
|
||
//
|
||
LIST_ENTRY PopIdleDetectList;
|
||
|
||
//
|
||
// A timer & defered procedure call to process idle scans
|
||
//
|
||
KTIMER PopIdleScanTimer;
|
||
KDPC PopIdleScanDpc;
|
||
LARGE_INTEGER PopIdleScanTime;
|
||
|
||
//
|
||
// Two scan modes, performance, conservation...
|
||
//
|
||
BOOLEAN PopIdleDetectionMode = PO_IDLE_PERFORMANCE;
|
||
|
||
//
|
||
// This value holds all Power Management Simulation Flags
|
||
//
|
||
ULONG PopSimulate = POP_ENABLE_HIBER_PERF;
|
||
|
||
//
|
||
// These defines are only used to initialize these global variables,
|
||
// so it makes sense to pair them all up. The global variables are
|
||
// all used for idle state transition calculations
|
||
//
|
||
|
||
//
|
||
// When throttling down an idle processor, keep it at least 30% active
|
||
//
|
||
#define IDLE_DEFAULT_MIN_THROTTLE 30
|
||
ULONG PopIdleDefaultMinThrottle = IDLE_DEFAULT_MIN_THROTTLE;
|
||
|
||
//
|
||
// When a processor is throttled down, queue a timer to verify that a
|
||
// processor does not go significantly "busy" and never returns to
|
||
// the idle loop for a throttle adjustment
|
||
// N.B idle values are in microseconds
|
||
//
|
||
#define IDLE_THROTTLE_CHECK_RATE 30000 // 30ms
|
||
ULONG PopIdleThrottleCheckRate = IDLE_THROTTLE_CHECK_RATE;
|
||
|
||
//
|
||
// If the throttle check timer noticies a processor has not returned
|
||
// to the idle loop for at least 100ms, then abort it's throttle
|
||
//
|
||
#define IDLE_THROTTLE_CHECK_TIMEOUT 100000 // 100ms
|
||
ULONG PopIdleThrottleCheckTimeout = IDLE_THROTTLE_CHECK_TIMEOUT;
|
||
|
||
//
|
||
// To promote from Idle 0 the processor must be more then 90% idle over
|
||
// the last 10 seconds
|
||
//
|
||
#define IDLE_FROM_0_DELAY 10000000 // 10 seconds
|
||
#define IDLE_FROM_0_IDLE_PERCENT 90 // > 90% to promote from idle 0
|
||
ULONG PopIdleFrom0Delay = IDLE_FROM_0_DELAY;
|
||
ULONG PopIdleFrom0IdlePercent = IDLE_FROM_0_IDLE_PERCENT;
|
||
|
||
//
|
||
// First idle handler checks no more then every 100ms
|
||
// idle below 20%
|
||
//
|
||
#define IDLE_0_TIME_CHECK 500000 // 500ms
|
||
ULONG PopIdle0TimeCheck = IDLE_0_TIME_CHECK;
|
||
|
||
//
|
||
// When in other idle state check every 100ms
|
||
//
|
||
#define IDLE_TIME_CHECK 100000 // 100ms
|
||
ULONG PopIdleTimeCheck = IDLE_TIME_CHECK;
|
||
|
||
//
|
||
// To demote to Idle 0 the processor must be less then 80% idle in a 100ms window
|
||
//
|
||
#define IDLE_TO_0_PERCENT 80
|
||
ULONG PopIdleTo0Percent = IDLE_TO_0_PERCENT;
|
||
|
||
//
|
||
// The default demotion occurs at less then 50% idle for 100ms
|
||
// N.B. The implementation assumes that IDLE_DEFAULT_DEMOTE_TIME divides
|
||
// into IDLE_DEFAULT_PROMOTE_TIME evenly
|
||
//
|
||
#define IDLE_DEFAULT_DEMOTE_PERCENT 50
|
||
#define IDLE_DEFAULT_DEMOTE_TIME 100000
|
||
ULONG PopIdleDefaultDemotePercent = IDLE_DEFAULT_DEMOTE_PERCENT;
|
||
ULONG PopIdleDefaultDemoteTime = IDLE_DEFAULT_DEMOTE_TIME;
|
||
|
||
//
|
||
// The default promotion occurs at more then 70% idle for 500ms
|
||
//
|
||
#define IDLE_DEFAULT_PROMOTE_TIME 500000 // 500ms
|
||
#define IDLE_DEFAULT_PROMOTE_PERCENT 70
|
||
ULONG PopIdleDefaultPromotePercent = IDLE_DEFAULT_PROMOTE_PERCENT;
|
||
ULONG PopIdleDefaultPromoteTime = IDLE_DEFAULT_PROMOTE_TIME;
|
||
|
||
//
|
||
// We define special extra global variables to handle promotion to/from
|
||
// C1. The reason that we do this is so that we can more finely tune these
|
||
// values.
|
||
//
|
||
ULONG PopIdleDefaultDemoteToC1Percent = IDLE_DEFAULT_DEMOTE_PERCENT;
|
||
ULONG PopIdleDefaultDemoteToC1Time = IDLE_DEFAULT_DEMOTE_TIME;
|
||
ULONG PopIdleDefaultPromoteFromC1Percent = IDLE_DEFAULT_PROMOTE_PERCENT;
|
||
ULONG PopIdleDefaultPromoteFromC1Time = IDLE_DEFAULT_PROMOTE_TIME;
|
||
|
||
//
|
||
// We convert PopIdleFrom0Delay (which is in ms) over to KeTimeIncrement
|
||
// intervals. This is the number of ticks needed for processor to be idle before
|
||
// we consider a promotion out of the Idle0 state
|
||
//
|
||
ULONG PopIdle0PromoteTicks;
|
||
|
||
//
|
||
// We convert PopIdleFrom0Delay and PopIdleFrom0IdlePercent percent into
|
||
// KeTimeIncrement inverals. This is the number of ticks allowed to acculate the
|
||
// the PromoteTicks time
|
||
//
|
||
ULONG PopIdle0PromoteLimit;
|
||
|
||
|
||
//
|
||
// These global variables and definitions all relate to CPU throttle management
|
||
//
|
||
|
||
//
|
||
// A value that defines the period of time, in microseconds (us) between
|
||
// intervals to check the processor busyness for the purposes of processor
|
||
// throttling by the idle thread. Note that we need to convert this value
|
||
// to KeTimeIncrement intervals. We store the converted number in
|
||
// PopPerfTimeTicks
|
||
//
|
||
#define PROC_PERF_TIME_DELTA 50000 // 50ms
|
||
ULONG PopPerfTimeDelta = PROC_PERF_TIME_DELTA;
|
||
ULONG PopPerfTimeTicks = 0;
|
||
|
||
//
|
||
// A value that defines the period of time, in microseconds (us) between
|
||
// intervals to check the processor busyness for the purposes of processor
|
||
// throttling by a DPC routine. Note that we need to convert this value
|
||
// to KeTimeIncrement intervals. We store the converted number in
|
||
// PopPerfCriticalTimeTicks.
|
||
//
|
||
#define PROC_PERF_CRITICAL_TIME_DELTA 300000 // 300ms
|
||
ULONG PopPerfCriticalTimeDelta = PROC_PERF_CRITICAL_TIME_DELTA;
|
||
ULONG PopPerfCriticalTimeTicks = 0;
|
||
|
||
//
|
||
// A percentage value that is added to the current CPU busyness percentage
|
||
// to determine if the processor is too busy for the current performance
|
||
// state and must be promoted. The closer the value is to zero, the harder it
|
||
// is for the processor to promote itself during times of extreme workloads
|
||
//
|
||
#define PROC_PERF_CRITICAL_FREQUENCY_DELTA 0 // 0%
|
||
ULONG PopPerfCriticalFrequencyDelta = PROC_PERF_CRITICAL_FREQUENCY_DELTA;
|
||
|
||
//
|
||
// A percentage value where lower means that the overall IncreaseLevel will
|
||
// actually be higher (and thus promotions won't occur as frequently) that
|
||
// indicates what percentage of the delta betwene the current state and the
|
||
// state to promote to should be used to set the promote level. A suggested
|
||
// value would be 20%
|
||
//
|
||
#define PROC_PERF_INCREASE_PERC_MOD 20 // 20%
|
||
ULONG PopPerfIncreasePercentModifier = PROC_PERF_INCREASE_PERC_MOD;
|
||
|
||
//
|
||
// A percentage value where lower means that the overall IncreaseLevel will
|
||
// actually be higher (and thus promotions won't occur as frequently) that
|
||
// indicates how many extra percentage points to remove from the promote level.
|
||
// It should be noted that if this value is particularly high, confusion migh
|
||
// result due to overlapping windows. A suggested value would be 1%
|
||
//
|
||
#define PROC_PERF_INCREASE_ABS_MOD 1 // 1%
|
||
ULONG PopPerfIncreaseAbsoluteModifier = PROC_PERF_INCREASE_ABS_MOD;
|
||
|
||
//
|
||
// A percentage value where higher means that the overall DecreaseLevel will
|
||
// actually be lower (and thus demotions won't occur as frequently) that
|
||
// indicates what percentage of the delta between the current state and the
|
||
// state to demote to should be used to set the demote level. A suggested
|
||
// value is 30%
|
||
//
|
||
#define PROC_PERF_DECREASE_PERC_MOD 30 // 50%
|
||
ULONG PopPerfDecreasePercentModifier = PROC_PERF_DECREASE_PERC_MOD;
|
||
|
||
//
|
||
// A percentage value where higher means that the overall DecreaseLevel will
|
||
// actually be lower (and thus demotions won't occur as frequently) that
|
||
// indicates how many extra percentage points to subtract from the demote
|
||
// level. It should be noted that if the value is particularly high, then it
|
||
// might not be possible to demote from this state. A suggested value would be
|
||
// 1%
|
||
//
|
||
#define PROC_PERF_DECREASE_ABS_MOD 1 // 1%
|
||
ULONG PopPerfDecreaseAbsoluteModifier = PROC_PERF_DECREASE_ABS_MOD;
|
||
|
||
//
|
||
// A value that defines the period of time, in microseconds (us) that must
|
||
// have occured before a throttle increase can be considered. This value is
|
||
// used as the basis for calculating the promotion time for each throttle
|
||
// step
|
||
//
|
||
#define PROC_PERF_INCREASE_TIME 10000 // 10 ms
|
||
#define PROC_PERF_INCREASE_MINIMUM_TIME 150000 // 150 ms
|
||
ULONG PopPerfIncreaseTimeValue = PROC_PERF_INCREASE_TIME;
|
||
ULONG PopPerfIncreaseMinimumTime = PROC_PERF_INCREASE_MINIMUM_TIME;
|
||
//
|
||
// A value that defines the period of time, in microseconds (us) that must
|
||
// have occured before a throttle decrease can be considered. This value is
|
||
// used as the basis for calculating the demotion time for each throttle
|
||
// step
|
||
//
|
||
#define PROC_PERF_DECREASE_TIME 10000 // 10 ms
|
||
#define PROC_PERF_DECREASE_MINIMUM_TIME 500000 // 500 ms
|
||
ULONG PopPerfDecreaseTimeValue = PROC_PERF_DECREASE_TIME;
|
||
ULONG PopPerfDecreaseMinimumTime = PROC_PERF_DECREASE_MINIMUM_TIME;
|
||
|
||
//
|
||
// A percentage value that represents at what point of battery capacity we
|
||
// will start forcing down the throttle when we are in Degraded Throttling
|
||
// mode. For example, a value of 50% means that we will start throttling
|
||
// down the CPU when the battery reaches 50%
|
||
//
|
||
#define PROC_PERF_DEGRADE_MIN_CAP 50 // 50%
|
||
ULONG PopPerfDegradeThrottleMinCapacity = PROC_PERF_DEGRADE_MIN_CAP;
|
||
|
||
//
|
||
// A percentage value that represents the lowest frequency we can force the
|
||
// throttle down to when we are in the Degraded Throttling mode. For example,
|
||
// a value of 30% means that we will never force the CPU below 30%
|
||
//
|
||
#define PROC_PERF_DEGRADE_MIN_FREQ 30 // 30%
|
||
ULONG PopPerfDegradeThrottleMinFrequency = PROC_PERF_DEGRADE_MIN_FREQ;
|
||
|
||
//
|
||
// A percentage value that represents the maximum amount of time that was
|
||
// spent in C3 for the last quanta before the idle loop will deside that
|
||
// it should optimize power for C3 usage. A sample value would be 50%
|
||
//
|
||
#define PROC_PERF_MAX_C3_FREQUENCY 50 // 50%
|
||
ULONG PopPerfMaxC3Frequency = PROC_PERF_MAX_C3_FREQUENCY;
|
||
|
||
|
||
#if DBG
|
||
|
||
//
|
||
// PoDebug - Debug level
|
||
//
|
||
|
||
ULONG PoDebug = PO_ERROR;
|
||
|
||
#endif
|
||
|
||
//
|
||
// PopPolicyLock - Protects policy data structures
|
||
//
|
||
ERESOURCE PopPolicyLock;
|
||
|
||
//
|
||
// PopWorkerSpinLock - Protects worker dispatch data
|
||
// PopWorkerPending - A set bit for each worker cataogry which is pending
|
||
// PopWorkerStatus - A clear bit for each worker catagory being serived
|
||
//
|
||
KSPIN_LOCK PopWorkerSpinLock;
|
||
ULONG PopWorkerPending;
|
||
ULONG PopWorkerStatus;
|
||
|
||
//
|
||
// PopNotifyEvents - PO_NOTIFY_xxx events which have fired.
|
||
//
|
||
LONG PopNotifyEvents;
|
||
|
||
//
|
||
// PopVolumeLock - protects PopVolumeDevices from insertion. (removal is
|
||
// protected by the policy lock
|
||
//
|
||
KGUARDED_MUTEX PopVolumeLock;
|
||
KGUARDED_MUTEX PopRequestWakeLock;
|
||
|
||
//
|
||
// PopVolumeDevices - a list of off device objects which have had a VPBs attached
|
||
//
|
||
LIST_ENTRY PopVolumeDevices = {0};
|
||
|
||
//
|
||
// PopRequestWakeLock - synchronizes NtRequest/CancelDeviceWakeup
|
||
//
|
||
|
||
|
||
//
|
||
// PopPolicyWorker - Work queue item to get another worker thread
|
||
//
|
||
WORK_QUEUE_ITEM PopPolicyWorker;
|
||
|
||
//
|
||
// PopIdle - Pointer to Array of idle handlers.
|
||
//
|
||
PPOP_IDLE_HANDLER PopIdle;
|
||
|
||
//
|
||
// PopIdleHandlerLookAsideList - List to allocate storage from for idle
|
||
// handlers.
|
||
//
|
||
NPAGED_LOOKASIDE_LIST PopIdleHandlerLookAsideList;
|
||
|
||
//
|
||
// PopAttribute - Book keeping
|
||
//
|
||
POP_STATE_ATTRIBUTE PopAttributes[POP_NUMBER_ATTRIBUTES] = {
|
||
0, PopSystemRequiredSet, FALSE, 0,
|
||
0, PopDisplayRequired, TRUE, 0, // 0, PopSetNotificationWork, TRUE, PO_NOTIFY_DISPLAY_REQUIRED,
|
||
0, PopUserPresentSet, FALSE, 0,
|
||
0, PopAttribNop, FALSE, 0,
|
||
0, PopSetNotificationWork, TRUE, PO_NOTIFY_CAPABILITIES
|
||
};
|
||
|
||
//
|
||
// PopFullWake - Flag to indicate the system has transistioned from
|
||
// a quite wake to a full wake
|
||
//
|
||
LONG PopFullWake;
|
||
|
||
//
|
||
// PoHiberInProgress - True when in the critical hibernation section
|
||
//
|
||
BOOLEAN PoHiberInProgress;
|
||
|
||
//
|
||
// PopShutdownCleanly - Controls whether clean shutdown sequence should
|
||
// be used.
|
||
//
|
||
ULONG PopShutdownCleanly = 0;
|
||
|
||
//
|
||
// PopDispatchPolicyIrps - Used to prevent policy irps from dispatching
|
||
// until the base drivers are loaded
|
||
//
|
||
BOOLEAN PopDispatchPolicyIrps;
|
||
|
||
//
|
||
// PopSystemIdleTimer - Timer used to get idle system detection worker
|
||
//
|
||
KTIMER PoSystemIdleTimer;
|
||
|
||
//
|
||
// PopSIdle - tracks the idle state of the system
|
||
//
|
||
POP_SYSTEM_IDLE PopSIdle;
|
||
|
||
//
|
||
// PopPolicyLockThread - Conains the current owning thread of the
|
||
// policy mutex.
|
||
//
|
||
PKTHREAD PopPolicyLockThread = NULL;
|
||
|
||
//
|
||
// PopAcPolicy - current power policy being implemented while on AC
|
||
// PopDcPolicy - current power policy being implemented while not on AC
|
||
// PopPolicy - current active policy
|
||
//
|
||
SYSTEM_POWER_POLICY PopAcPolicy = {0};
|
||
SYSTEM_POWER_POLICY PopDcPolicy = {0};
|
||
PSYSTEM_POWER_POLICY PopPolicy = NULL;
|
||
|
||
//
|
||
// PopAcProcessorPolicy - current processor power policy being implemented on AC
|
||
// PopDcProcessorPolicy - current processor power policy being implemented on DC
|
||
// PopProcessorPolicy - current active policy
|
||
//
|
||
PROCESSOR_POWER_POLICY PopAcProcessorPolicy = {0};
|
||
PROCESSOR_POWER_POLICY PopDcProcessorPolicy = {0};
|
||
PPROCESSOR_POWER_POLICY PopProcessorPolicy = NULL;
|
||
|
||
//
|
||
// PopAction - Current power action being taken
|
||
//
|
||
POP_POWER_ACTION PopAction = {0};
|
||
|
||
//
|
||
// Spinlock that protects the thermal zones
|
||
//
|
||
KSPIN_LOCK PopThermalLock;
|
||
|
||
//
|
||
// PopSwitches - list of button and lid devices currently opened
|
||
//
|
||
LIST_ENTRY PopSwitches = {0};
|
||
|
||
//
|
||
// User-present work item
|
||
//
|
||
WORK_QUEUE_ITEM PopUserPresentWorkItem = {0};
|
||
|
||
//
|
||
// Performance counter frequency used by throttle.c
|
||
//
|
||
LARGE_INTEGER PopPerfCounterFrequency;
|
||
|
||
#ifdef ALLOC_DATA_PRAGMA
|
||
#pragma data_seg("PAGEDATA")
|
||
#pragma const_seg("PAGECONST")
|
||
#endif
|
||
|
||
//
|
||
// Notify worker dispatch
|
||
//
|
||
const POP_NOTIFY_WORK PopNotifyWork[PO_NUMBER_NOTIFY] = {
|
||
PopDispatchCallback, PO_CB_BUTTON_COLLISION,
|
||
PopDispatchFullWake, 0,
|
||
PopDispatchCallback, PO_CB_SYSTEM_POWER_POLICY,
|
||
PopDispatchAcDcCallback, 0,
|
||
PopDispatchPolicyCallout, 0,
|
||
PopDispatchDisplayRequired, 0,
|
||
PopDispatchCallout, PsW32SystemPowerState,
|
||
PopDispatchEventCodes, 0,
|
||
PopDispatchCallout, PsW32CapabilitiesChanged,
|
||
PopDispatchSetStateFailure, 0,
|
||
PopDispatchCallback, PO_CB_PROCESSOR_POWER_POLICY,
|
||
PopDispatchProcessorPolicyCallout, 0
|
||
};
|
||
|
||
//
|
||
// PopAcRegName
|
||
// PopDcRegName - registry location under current control set to store
|
||
// and retrieve current policy settings from
|
||
//
|
||
const WCHAR PopRegKey[] = L"Control\\Session Manager\\Power";
|
||
const WCHAR PopAcRegName[] = L"AcPolicy";
|
||
const WCHAR PopDcRegName[] = L"DcPolicy";
|
||
const WCHAR PopUndockPolicyRegName[] = L"UndockPowerPolicy";
|
||
const WCHAR PopAdminRegName[] = L"PolicyOverrides";
|
||
const WCHAR PopHeuristicsRegName[] = L"Heuristics";
|
||
const WCHAR PopCompositeBatteryName[] = L"\\Device\\CompositeBattery";
|
||
const WCHAR PopSimulateRegKey[] = L"Control\\Session Manager";
|
||
const WCHAR PopSimulateRegName[] = L"PowerPolicySimulate";
|
||
const WCHAR PopHiberFileName[] = L"\\hiberfil.sys";
|
||
const WCHAR PopDebugHiberFileName[] = L"\\hiberfil.dbg";
|
||
const WCHAR PopDumpStackPrefix[] = L"hiber_";
|
||
const WCHAR PopApmActiveFlag[] = L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\ApmActive";
|
||
const WCHAR PopApmFlag[] = L"Active";
|
||
const WCHAR PopAcProcessorRegName[] = L"AcProcessorPolicy";
|
||
const WCHAR PopDcProcessorRegName[] = L"DcProcessorPolicy";
|
||
|
||
//
|
||
// PopAdminPolcy - Administrator overrides to apply to the current policy
|
||
//
|
||
ADMINISTRATOR_POWER_POLICY PopAdminPolicy = {0};
|
||
|
||
//
|
||
// PopCapabilities - Misc information on how the systems actual functions
|
||
//
|
||
SYSTEM_POWER_CAPABILITIES PopCapabilities; // nonpaged
|
||
|
||
//
|
||
// PopEventCallout - callout to USER for power events
|
||
//
|
||
PKWIN32_POWEREVENT_CALLOUT PopEventCallout; // nonpaged
|
||
|
||
//
|
||
// PopStateCallout - callout to USER for power state changes
|
||
//
|
||
PKWIN32_POWERSTATE_CALLOUT PopStateCallout = NULL;
|
||
|
||
//
|
||
// PopThermal - list of thermal zones currently opened
|
||
//
|
||
LIST_ENTRY PopThermal; // nonpaged
|
||
|
||
//
|
||
// PopCoolingMode - system is in active or passive cooling mode
|
||
//
|
||
ULONG PopCoolingMode = 0;
|
||
|
||
//
|
||
// PopCB - composite battery
|
||
//
|
||
POP_COMPOSITE_BATTERY PopCB; // nonpaged
|
||
|
||
//
|
||
// PopPolicyIrpQueue - Policy irps which have completed are put onto
|
||
// this queue for processingby the worker thread
|
||
//
|
||
LIST_ENTRY PopPolicyIrpQueue; // nonpaged
|
||
|
||
//
|
||
// PopEventCode - Queued event codes
|
||
//
|
||
ULONG PopEventCode[POP_MAX_EVENT_CODES] = {0};
|
||
|
||
//
|
||
// PopWorkerTypes - Worker functions for each policy worker type
|
||
//
|
||
const POP_WORKER_TYPES PopWorkerTypes[] = {
|
||
PopPolicyWorkerMain,
|
||
PopPolicyWorkerActionPromote,
|
||
PopPolicyWorkerAction,
|
||
PopPolicyWorkerNotify,
|
||
PopPolicySystemIdle,
|
||
PopPolicyTimeChange
|
||
};
|
||
|
||
//
|
||
// PopActionWaiters - Queue of synchronous action requests
|
||
//
|
||
LIST_ENTRY PopActionWaiters = {0};
|
||
|
||
|
||
//
|
||
// PopHeuristics - Presistant settings are heuristics which are not part
|
||
// of the saved policy structures
|
||
//
|
||
POP_HEURISTICS PopHeuristics = {0};
|
||
|
||
#ifdef ALLOC_DATA_PRAGMA
|
||
#pragma const_seg()
|
||
#pragma data_seg()
|
||
#endif
|
||
|
||
//
|
||
// PopPowerStateHandler - Handlers for the various supported power states
|
||
//
|
||
POWER_STATE_HANDLER PopPowerStateHandlers[PowerStateMaximum] = {0};
|
||
|
||
//
|
||
// PopPowerStateNotifyHandler - Handler to be notify before and after invoking
|
||
// PopPowerStateHandlers
|
||
//
|
||
|
||
POWER_STATE_NOTIFY_HANDLER PopPowerStateNotifyHandler = {0};
|
||
|
||
//
|
||
// PopHiberFile - information on the hibernation file
|
||
// PopHiberFileDebug - a second hibernation file for debugging
|
||
//
|
||
POP_HIBER_FILE PopHiberFile = { NULL };
|
||
POP_HIBER_FILE PopHiberFileDebug = { NULL };
|