MiTec/Common/MiTeC_PowrProf.pas

{*******************************************************}
{               MiTeC Common Routines                   }
{             Power Policy Applicator API               }
{                                                       }
{         Copyright (c) 1997-2014 Michal Mutl           }
{                                                       }
{*******************************************************}

{$INCLUDE Compilers.inc}

unit MiTeC_PowrProf;

interface

uses {$IFDEF RAD9PLUS}
     WinAPI.Windows, System.SysUtils;
     {$ELSE}
     Windows, SysUtils;
     {$ENDIF}

const
  STATUS_BUFFER_TOO_SMALL = integer($C0000023);
  STATUS_ACCESS_DENIED = integer($C0000022);
  STATUS_INVALID_PARAMETER = integer($C000000D);

type
  _SYSTEM_POWER_STATE = (
    PowerSystemUnspecified,
    PowerSystemWorking,
    PowerSystemSleeping1,
    PowerSystemSleeping2,
    PowerSystemSleeping3,
    PowerSystemHibernate,
    PowerSystemShutdown,
    PowerSystemMaximum);
  SYSTEM_POWER_STATE = _SYSTEM_POWER_STATE;
  PSYSTEM_POWER_STATE = ^SYSTEM_POWER_STATE;
  TSystemPowerState = SYSTEM_POWER_STATE;
  PSystemPowerState = PSYSTEM_POWER_STATE;

  POWER_INFORMATION_LEVEL = (
    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);
  TPowerInformationLevel = POWER_INFORMATION_LEVEL;

const
  POWER_SYSTEM_MAXIMUM = 7;

type
  POWER_ACTION = (
    PowerActionNone,
    PowerActionReserved,
    PowerActionSleep,
    PowerActionHibernate,
    PowerActionShutdown,
    PowerActionShutdownReset,
    PowerActionShutdownOff,
    PowerActionWarmEject);
  PPOWER_ACTION = ^POWER_ACTION;
  TPowerAction = POWER_ACTION;
  PPowerAction = PPOWER_ACTION;

  PPOWER_ACTION_POLICY = ^POWER_ACTION_POLICY;
  POWER_ACTION_POLICY = record
    Action: POWER_ACTION;
    Flags: DWORD;
    EventCode: DWORD;
  end;
  TPowerActionPolicy = POWER_ACTION_POLICY;
  PPowerActionPolicy = PPOWER_ACTION_POLICY;

// POWER_ACTION_POLICY->Flags:

const
  POWER_ACTION_QUERY_ALLOWED  = $00000001;
  POWER_ACTION_UI_ALLOWED     = $00000002;
  POWER_ACTION_OVERRIDE_APPS  = $00000004;
  POWER_ACTION_LIGHTEST_FIRST = $10000000;
  POWER_ACTION_LOCK_CONSOLE   = $20000000;
  POWER_ACTION_DISABLE_WAKES  = $40000000;
  POWER_ACTION_CRITICAL       = DWORD($80000000);

// POWER_ACTION_POLICY->EventCode flags

  POWER_LEVEL_USER_NOTIFY_TEXT  = $00000001;
  POWER_LEVEL_USER_NOTIFY_SOUND = $00000002;
  POWER_LEVEL_USER_NOTIFY_EXEC  = $00000004;
  POWER_USER_NOTIFY_BUTTON      = $00000008;
  POWER_USER_NOTIFY_SHUTDOWN    = $00000010;
  POWER_FORCE_TRIGGER_RESET     = DWORD($80000000);

  NUM_DISCHARGE_POLICIES    = 4;
  DISCHARGE_POLICY_CRITICAL = 0;
  DISCHARGE_POLICY_LOW      = 1;

// Throttling policies

  PO_THROTTLE_NONE     = 0;
  PO_THROTTLE_CONSTANT = 1;
  PO_THROTTLE_DEGRADE  = 2;
  PO_THROTTLE_ADAPTIVE = 3;
  PO_THROTTLE_MAXIMUM  = 4; // not a policy, just a limit

type
  PSYSTEM_POWER_LEVEL = ^SYSTEM_POWER_LEVEL;
  SYSTEM_POWER_LEVEL = record
    Enable: BOOLEAN;
    Spare: array [0..3 - 1] of BYTE;
    BatteryLevel: DWORD;
    PowerPolicy: POWER_ACTION_POLICY;
    MinSystemState: SYSTEM_POWER_STATE;
  end;
  TSystemPowerLevel = SYSTEM_POWER_LEVEL;
  PSystemPowerLevel = PSYSTEM_POWER_LEVEL;

  PGLOBAL_MACHINE_POWER_POLICY = ^GLOBAL_MACHINE_POWER_POLICY;
  _GLOBAL_MACHINE_POWER_POLICY = record
    Revision: ULONG;
    LidOpenWakeAc: SYSTEM_POWER_STATE;
    LidOpenWakeDc: SYSTEM_POWER_STATE;
    BroadcastCapacityResolution: ULONG;
  end;
  GLOBAL_MACHINE_POWER_POLICY = _GLOBAL_MACHINE_POWER_POLICY;
  TGlobalMachinePowerPolicy = GLOBAL_MACHINE_POWER_POLICY;
  PGlobalMachinePowerPolicy = PGLOBAL_MACHINE_POWER_POLICY;

  PGLOBAL_USER_POWER_POLICY = ^GLOBAL_USER_POWER_POLICY;
  _GLOBAL_USER_POWER_POLICY = record
    Revision: ULONG;
    PowerButtonAc: POWER_ACTION_POLICY;
    PowerButtonDc: POWER_ACTION_POLICY;
    SleepButtonAc: POWER_ACTION_POLICY;
    SleepButtonDc: POWER_ACTION_POLICY;
    LidCloseAc: POWER_ACTION_POLICY;
    LidCloseDc: POWER_ACTION_POLICY;
    DischargePolicy: array [0..NUM_DISCHARGE_POLICIES - 1] of SYSTEM_POWER_LEVEL;
    GlobalFlags: ULONG;
  end;
  GLOBAL_USER_POWER_POLICY = _GLOBAL_USER_POWER_POLICY;
  TGlobalUserPowerPolicy = GLOBAL_USER_POWER_POLICY;
  PGlobalUserPowerPolicy = PGLOBAL_USER_POWER_POLICY;

// Structure to manage global power policies at the user level. This structure
// contains data which is common across all power policy profiles.

  PGLOBAL_POWER_POLICY = ^GLOBAL_POWER_POLICY;
  _GLOBAL_POWER_POLICY = record
    user: GLOBAL_USER_POWER_POLICY;
    mach: GLOBAL_MACHINE_POWER_POLICY;
  end;
  GLOBAL_POWER_POLICY = _GLOBAL_POWER_POLICY;
  TGlobalPowerPolicy = GLOBAL_POWER_POLICY;
  PGlobalPowerPolicy = PGLOBAL_POWER_POLICY;

// Registry storage structures for the POWER_POLICY data. There are three
// structures, MACHINE_POWER_POLICY, MACHINE_PROCESSOR_POWER_POLICY and USER_POWER_POLICY. the
// MACHINE_POWER_POLICY stores per machine data for which there is no UI.
// USER_POWER_POLICY stores the per user data.

  PMACHINE_POWER_POLICY = ^MACHINE_POWER_POLICY;
  _MACHINE_POWER_POLICY = record
    Revision: ULONG; // 1
    // meaning of power action "sleep"
    MinSleepAc: SYSTEM_POWER_STATE;
    MinSleepDc: SYSTEM_POWER_STATE;
    ReducedLatencySleepAc: SYSTEM_POWER_STATE;
    ReducedLatencySleepDc: SYSTEM_POWER_STATE;
    // parameters for dozing
    DozeTimeoutAc: ULONG;
    DozeTimeoutDc: ULONG;
    DozeS4TimeoutAc: ULONG;
    DozeS4TimeoutDc: ULONG;
    // processor policies
    MinThrottleAc: UCHAR;
    MinThrottleDc: UCHAR;
    pad1: array [0..1] of UCHAR;
    OverThrottledAc: POWER_ACTION_POLICY;
    OverThrottledDc: POWER_ACTION_POLICY;
  end;
  MACHINE_POWER_POLICY = _MACHINE_POWER_POLICY;
  TMachinePowerPolicy = MACHINE_POWER_POLICY;
  PMachinePowerPolicy = PMACHINE_POWER_POLICY;

  // processor power policy state

  PPROCESSOR_POWER_POLICY_INFO = ^PROCESSOR_POWER_POLICY_INFO;
  _PROCESSOR_POWER_POLICY_INFO = record
    // Time based information (will be converted to kernel units)
    TimeCheck: DWORD; // in US
    DemoteLimit: DWORD; // in US
    PromoteLimit: DWORD; // in US
    // Percentage based information
    DemotePercent: BYTE;
    PromotePercent: BYTE;
    Spare: array [0..1] of BYTE;
    // Flags
    Flags: DWORD;
    //DWORD                   AllowDemotion:1;
    //DWORD                   AllowPromotion:1;
    //DWORD                   Reserved:30;
  end;
  PROCESSOR_POWER_POLICY_INFO = _PROCESSOR_POWER_POLICY_INFO;
  TProcessorPowerPolicyInfo = PROCESSOR_POWER_POLICY_INFO;
  PProcessorPowerPolicyInfo = PPROCESSOR_POWER_POLICY_INFO;

// processor power policy

  PPROCESSOR_POWER_POLICY = ^PROCESSOR_POWER_POLICY;
  _PROCESSOR_POWER_POLICY = record
    Revision: DWORD; // 1
    // Dynamic Throttling Policy
    DynamicThrottle: BYTE;
    Spare: array [0..2] of BYTE;
    // Flags
    Reserved: DWORD;
    //DWORD                       DisableCStates:1;
    //DWORD                       Reserved:31;

    // System policy information
    // The Array is last, in case it needs to be grown and the structure
    // revision incremented.
    PolicyCount: DWORD;
    Policy: array [0..2] of PROCESSOR_POWER_POLICY_INFO;
  end;
  PROCESSOR_POWER_POLICY = _PROCESSOR_POWER_POLICY;
  TProcessorPowerPolicy = PROCESSOR_POWER_POLICY;
  PProcessorPowerPolicy = PPROCESSOR_POWER_POLICY;

  PMACHINE_PROCESSOR_POWER_POLICY = ^MACHINE_PROCESSOR_POWER_POLICY;
  _MACHINE_PROCESSOR_POWER_POLICY = record
    Revision: ULONG; // 1
    ProcessorPolicyAc: PROCESSOR_POWER_POLICY;
    ProcessorPolicyDc: PROCESSOR_POWER_POLICY;
  end;
  MACHINE_PROCESSOR_POWER_POLICY = _MACHINE_PROCESSOR_POWER_POLICY;
  TMachineProcessorPowerPolicy = MACHINE_PROCESSOR_POWER_POLICY;
  PMachineProcessorPowerPolicy = PMACHINE_PROCESSOR_POWER_POLICY;

  PUSER_POWER_POLICY = ^USER_POWER_POLICY;
  _USER_POWER_POLICY = record
    Revision: ULONG; // 1
    // "system idle" detection
    IdleAc: POWER_ACTION_POLICY;
    IdleDc: POWER_ACTION_POLICY;
    IdleTimeoutAc: ULONG;
    IdleTimeoutDc: ULONG;
    IdleSensitivityAc: UCHAR;
    IdleSensitivityDc: UCHAR;
    // Throttling Policy
    ThrottlePolicyAc: UCHAR;
    ThrottlePolicyDc: UCHAR;
    // meaning of power action "sleep"
    MaxSleepAc: SYSTEM_POWER_STATE;
    MaxSleepDc: SYSTEM_POWER_STATE;
    // For future use
    Reserved: array [0..1] of ULONG;
    // video policies
    VideoTimeoutAc: ULONG;
    VideoTimeoutDc: ULONG;
    // hard disk policies
    SpindownTimeoutAc: ULONG;
    SpindownTimeoutDc: ULONG;
    // processor policies
    OptimizeForPowerAc: ByteBool;
    OptimizeForPowerDc: ByteBool;
    FanThrottleToleranceAc: UCHAR;
    FanThrottleToleranceDc: UCHAR;
    ForcedThrottleAc: UCHAR;
    ForcedThrottleDc: UCHAR;
  end;
  USER_POWER_POLICY = _USER_POWER_POLICY;
  TUserPowerPolicy = USER_POWER_POLICY;
  PUserPowerPolicy = PUSER_POWER_POLICY;

// Structure to manage power policies at the user level. This structure
// contains data which is unique across power policy profiles.

  PPOWER_POLICY = ^POWER_POLICY;
  _POWER_POLICY = record
    user: USER_POWER_POLICY;
    mach: MACHINE_POWER_POLICY;
  end;
  POWER_POLICY = _POWER_POLICY;
  TPowerPolicy = POWER_POLICY;
  PPowerPolicy = PPOWER_POLICY;

// Constants for GlobalFlags

const
  EnableSysTrayBatteryMeter = $01;
  EnableMultiBatteryDisplay = $02;
  EnablePasswordLogon       = $04;
  EnableWakeOnRing          = $08;
  EnableVideoDimDisplay     = $10;


// This constant is passed as a uiID to WritePwrScheme.

  NEWSCHEME = UINT(-1);

type

// System power manager capabilities

  BATTERY_REPORTING_SCALE = record
    Granularity: DWORD;
    Capacity: DWORD;
  end;
  PBATTERY_REPORTING_SCALE = ^BATTERY_REPORTING_SCALE;
  TBatteryReportingScale = BATTERY_REPORTING_SCALE;
  PBatteryReportingScale = PBATTERY_REPORTING_SCALE;

// administrator power policy overrides

  PSYSTEM_POWER_CAPABILITIES = ^SYSTEM_POWER_CAPABILITIES;
  SYSTEM_POWER_CAPABILITIES = record
    // Misc supported system features
    PowerButtonPresent: BOOLEAN;
    SleepButtonPresent: BOOLEAN;
    LidPresent: BOOLEAN;
    SystemS1: BOOLEAN;
    SystemS2: BOOLEAN;
    SystemS3: BOOLEAN;
    SystemS4: BOOLEAN; // hibernate
    SystemS5: BOOLEAN; // off
    HiberFilePresent: BOOLEAN;
    FullWake: BOOLEAN;
    VideoDimPresent: BOOLEAN;
    ApmPresent: BOOLEAN;
    UpsPresent: BOOLEAN;
    // Processors
    ThermalControl: BOOLEAN;
    ProcessorThrottle: BOOLEAN;
    ProcessorMinThrottle: BYTE;
    ProcessorMaxThrottle: BYTE;
    spare2: array [0..4 - 1] of BYTE;
    // Disk
    DiskSpinDown: BOOLEAN;
    spare3: array [0..8 - 1] of BYTE;
    // System Battery
    SystemBatteriesPresent: BOOLEAN;
    BatteriesAreShortTerm: BOOLEAN;
    BatteryScale: array [0..3 - 1] of BATTERY_REPORTING_SCALE;
    // Wake
    AcOnLineWake: SYSTEM_POWER_STATE;
    SoftLidWake: SYSTEM_POWER_STATE;
    RtcWake: SYSTEM_POWER_STATE;
    MinDeviceWakeState: SYSTEM_POWER_STATE; // note this may change on driver load
    DefaultLowLatencyWake: SYSTEM_POWER_STATE;
  end;
  TSystemPowerCapabilities = SYSTEM_POWER_CAPABILITIES;
  PSystemPowerCapabilities = PSYSTEM_POWER_CAPABILITIES;

  PADMINISTRATOR_POWER_POLICY = ^ADMINISTRATOR_POWER_POLICY;
  _ADMINISTRATOR_POWER_POLICY = record
    // meaning of power action "sleep"
    MinSleep: SYSTEM_POWER_STATE;
    MaxSleep: SYSTEM_POWER_STATE;
    // video policies
    MinVideoTimeout: DWORD;
    MaxVideoTimeout: DWORD;
    // disk policies
    MinSpindownTimeout: DWORD;
    MaxSpindownTimeout: DWORD;
  end;
  ADMINISTRATOR_POWER_POLICY = _ADMINISTRATOR_POWER_POLICY;
  TAdministratorPowerPolicy = ADMINISTRATOR_POWER_POLICY;
  PAdministratorPowerPolicy = PADMINISTRATOR_POWER_POLICY;

  PPROCESSOR_POWER_INFORMATION = ^PROCESSOR_POWER_INFORMATION;
  _PROCESSOR_POWER_INFORMATION = record
    Number,
    MaxMhz,
    CurrentMhz,
    MhzLimit,
    MaxIdleState,
    CurrentIdleState: ULONG;
  end;
  PROCESSOR_POWER_INFORMATION = _PROCESSOR_POWER_INFORMATION;
  TProcessorPowerInformation = PROCESSOR_POWER_INFORMATION;
  PProcessorPowerInformation = PPROCESSOR_POWER_INFORMATION;

  PSYSTEM_BATTERY_STATE = ^SYSTEM_BATTERY_STATE;
  SYSTEM_BATTERY_STATE = record
    AcOnLine: BOOLEAN;
    BatteryPresent: BOOLEAN;
    Charging: BOOLEAN;
    Discharging: BOOLEAN;
    Spare1: array [0..3] of BOOLEAN;
    MaxCapacity: DWORD;
    RemainingCapacity: DWORD;
    Rate: DWORD;
    EstimatedTime: DWORD;
    DefaultAlert1: DWORD;
    DefaultAlert2: DWORD;
  end;
  TSystemBatteryState = SYSTEM_BATTERY_STATE;
  PSystemBatteryState = PSYSTEM_BATTERY_STATE;

  // Prototype for EnumPwrSchemes callback proceedures.

const
  BATTERY_POWER_ON_LINE = $00000001;
  BATTERY_DISCHARGING   = $00000002;
  BATTERY_CHARGING      = $00000004;
  BATTERY_CRITICAL      = $00000008;

// BATTERY_STATUS Constant
// BATTERY_UNKNOWN_CAPACITY defined above for IOCTL_BATTERY_QUERY_INFORMATION


  BATTERY_UNKNOWN_VOLTAGE = DWORD($FFFFFFFF);
  BATTERY_UNKNOWN_RATE    = DWORD($80000000);
  BATTERY_UNKNOWN_TIME    = DWORD($FFFFFFFF);

type
  PWRSCHEMESENUMPROC = function(uiIndex: UINT; dwName: DWORD; sName: LPWSTR; dwDesc: DWORD; sDesc: LPWSTR; pp: PPOWER_POLICY; lParam: LPARAM): ByteBool; stdcall;
  PFNNTINITIATEPWRACTION = function(pPowerAction: POWER_ACTION; SystemPowerState: SYSTEM_POWER_STATE; u: ULONG; b: ByteBool): ByteBool; stdcall;

  TGetPwrDiskSpindownRange = function (var RangeMax, RangeMin: UINT): ByteBool; stdcall;
  TEnumPwrSchemes = function (lpfnPwrSchemesEnumProc: PWRSCHEMESENUMPROC; lParam: LPARAM): ByteBool; stdcall;
  TReadGlobalPwrPolicy = function (var pGlobalPowerPolicy: GLOBAL_POWER_POLICY): ByteBool; stdcall;
  TReadPwrScheme = function (uiID: UINT; var pPowerPolicy: POWER_POLICY): ByteBool; stdcall;
  TWritePwrScheme = function (puiID: PUINT; lpszName, lpszDescription: LPWSTR; const pPowerPolicy: POWER_POLICY): ByteBool; stdcall;
  TWriteGlobalPwrPolicy = function (const pGlobalPowerPolicy: GLOBAL_POWER_POLICY): ByteBool; stdcall;
  TDeletePwrScheme = function (uiIndex: UINT): ByteBool; stdcall;
  TGetActivePwrScheme = function (var puiID: UINT): ByteBool; stdcall;
  TSetActivePwrScheme = function (uiID: UINT; pGlobalPowerPolicy: PGLOBAL_POWER_POLICY; pPowerPolicy: PPOWER_POLICY): ByteBool; stdcall;
  TGetPwrCapabilities = function (var lpSystemPowerCapabilities: SYSTEM_POWER_CAPABILITIES): ByteBool; stdcall;
  TIsPwrSuspendAllowed = function : ByteBool; stdcall;
  TIsPwrHibernateAllowed = function : ByteBool; stdcall;
  TIsPwrShutdownAllowed = function : ByteBool; stdcall;
  TIsAdminOverrideActive = function (pAdministratorPowerPolicy: PADMINISTRATOR_POWER_POLICY): ByteBool; stdcall;
  TSetSuspendState = function (Hibernate, ForceCritical, DisableWakeEvent: ByteBool): ByteBool; stdcall;
  TGetCurrentPowerPolicies = function (pGlobalPowerPolicy: PGLOBAL_POWER_POLICY; pPowerPolicy: PPOWER_POLICY): ByteBool; stdcall;
  TCanUserWritePwrScheme = function : ByteBool; stdcall;
  TReadProcessorPwrScheme = function (uiID: UINT; var pMachineProcessorPowerPolicy: MACHINE_PROCESSOR_POWER_POLICY): ByteBool; stdcall;
  TWriteProcessorPwrScheme = function (uiID: UINT; const pMachineProcessorPowerPolicy: MACHINE_PROCESSOR_POWER_POLICY): ByteBool; stdcall;
  TValidatePowerPolicies = function (GlobalPolicy: PGLOBAL_POWER_POLICY; Policy: PPOWER_POLICY): ByteBool; stdcall;
  TCallNtPowerInformation = function (InformationLeveL: POWER_INFORMATION_LEVEL; lpInputBuffer: Pointer; nInputBufferSize: ULONG; lpOutputBuffer: Pointer; nOutputBufferSize: ULONG): integer; stdcall;

var
  PPAHandle: THandle = 0;
  UnloadPPA: Boolean;

  GetPwrDiskSpindownRange: TGetPwrDiskSpindownRange = nil;
  EnumPwrSchemes: TEnumPwrSchemes = nil;
  ReadGlobalPwrPolicy: TReadGlobalPwrPolicy = nil;
  ReadPwrScheme: TReadPwrScheme = nil;
  WritePwrScheme: TWritePwrScheme = nil;
  DeletePwrScheme: TDeletePwrScheme = nil;
  GetActivePwrScheme: TGetActivePwrScheme = nil;
  SetActivePwrScheme: TSetActivePwrScheme = nil;
  GetPwrCapabilities: TGetPwrCapabilities = nil;
  IsPwrSuspendAllowed: TIsPwrSuspendAllowed = nil;
  IsPwrHibernateAllowed: TIsPwrHibernateAllowed = nil;
  IsPwrShutdownAllowed: TIsPwrShutdownAllowed = nil;
  IsAdminOverrideActive: TIsAdminOverrideActive = nil;
  SetSuspendState: TSetSuspendState = nil;
  GetCurrentPowerPolicies: TGetCurrentPowerPolicies = nil;
  CanUserWritePwrScheme: TCanUserWritePwrScheme = nil;
  ReadProcessorPwrScheme: TReadProcessorPwrScheme = nil;
  WriteProcessorPwrScheme: TWriteProcessorPwrScheme = nil;
  ValidatePowerPolicies: TValidatePowerPolicies = nil;
  CallNtPowerInformation: TCallNtPowerInformation = nil;

function InitPPAAPI: boolean;
procedure FreePPAAPI;

const
  PPA_DLL = 'powrprof.dll';

implementation

function InitPPAAPI;
begin
  PPAHandle:=GetModuleHandle(PPA_DLL);
  UnloadPPA:=PPAHandle=0;
  if PPAHandle=0 then
    PPAHandle:=LoadLibrary(PPA_DLL);
  if (PPAHandle<>0) and not Assigned(IsPwrShutdownAllowed) then begin
    @GetPwrDiskSpindownRange:=GetProcAddress(PPAHandle,'GetPwrDiskSpindownRange');
    @EnumPwrSchemes:=GetProcAddress(PPAHandle,'EnumPwrSchemes');
    @ReadGlobalPwrPolicy:=GetProcAddress(PPAHandle,'ReadGlobalPwrPolicy');
    @ReadPwrScheme:=GetProcAddress(PPAHandle,'ReadPwrScheme');
    @WritePwrScheme:=GetProcAddress(PPAHandle,'WritePwrScheme');
    @DeletePwrScheme:=GetProcAddress(PPAHandle,'DeletePwrScheme');
    @GetActivePwrScheme:=GetProcAddress(PPAHandle,'GetActivePwrScheme');
    @ReadProcessorPwrScheme:=GetProcAddress(PPAHandle,'ReadProcessorPwrScheme');
    @SetActivePwrScheme:=GetProcAddress(PPAHandle,'SetActivePwrScheme');
    @GetPwrCapabilities:=GetProcAddress(PPAHandle,'GetPwrCapabilities');
    @IsPwrHibernateAllowed:=GetProcAddress(PPAHandle,'IsPwrHibernateAllowed');
    @IsPwrSuspendAllowed:=GetProcAddress(PPAHandle,'IsPwrSuspendAllowed');
    @IsPwrShutdownAllowed:=GetProcAddress(PPAHandle,'IsPwrShutdownAllowed');
    @IsAdminOverrideActive:=GetProcAddress(PPAHandle,'IsAdminOverrideActive');
    @SetSuspendState:=GetProcAddress(PPAHandle,'SetSuspendState');
    @GetCurrentPowerPolicies:=GetProcAddress(PPAHandle,'GetCurrentPowerPolicies');
    @CanUserWritePwrScheme:=GetProcAddress(PPAHandle,'CanUserWritePwrScheme');
    @WriteProcessorPwrScheme:=GetProcAddress(PPAHandle,'WriteProcessorPwrScheme');
    @ValidatePowerPolicies:=GetProcAddress(PPAHandle,'ValidatePowerPolicies');
    @CallNtPowerInformation:=GetProcAddress(PPAHandle,'CallNtPowerInformation');
  end;
  Result:=(PPAHandle<>0) and Assigned(IsPwrShutdownAllowed);
end;

procedure FreePPAAPI;
begin
  if (PPAHandle<>0) and UnloadPPA then begin
    if not FreeLibrary(PPAHandle) then
      raise Exception.Create(Format('Unload Error: %s - 0x%x',[PPA_DLL,GetModuleHandle(PPA_DLL)]))
    else
      PPAHandle:=0;
  end;
end;


initialization
finalization
  FreePPAAPI;
end.