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.
362 lines
16 KiB
362 lines
16 KiB
/*******************************************************************************
|
|
*
|
|
* (C) COPYRIGHT MICROSOFT CORP., 1997
|
|
*
|
|
* TITLE: DEBUG.C
|
|
*
|
|
* VERSION: 2.0
|
|
*
|
|
* AUTHOR: ReedB
|
|
*
|
|
* DATE: 21 Jan, 1997
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* Private debug routines implemented here.
|
|
*
|
|
*******************************************************************************/
|
|
|
|
#include <nt.h>
|
|
#include <ntrtl.h>
|
|
#include <nturtl.h>
|
|
#include <windows.h>
|
|
#include <ntpoapi.h>
|
|
#include <stdio.h>
|
|
#include <powrprofp.h>
|
|
|
|
#ifdef DEBUG
|
|
|
|
LPTSTR lpszDebugPwrState[] = {
|
|
TEXT("PwrSysUnspecified"),
|
|
TEXT("S0, PwrSysWorking"),
|
|
TEXT("S1, PwrSysSleeping1"),
|
|
TEXT("S2, PwrSysSleeping2"),
|
|
TEXT("S3, PwrSysSleeping3"),
|
|
TEXT("S4, PwrSysHibernate"),
|
|
TEXT("S5, PwrSysShutdown"),
|
|
TEXT("PwrSysMaximum")
|
|
};
|
|
|
|
LPTSTR lpszDebugPwrAction[] = {
|
|
TEXT("PwrActionNone"),
|
|
TEXT("PwrActionDoze"),
|
|
TEXT("PwrActionSleep"),
|
|
TEXT("PwrActionHibernate"),
|
|
TEXT("PwrActionShutdown"),
|
|
TEXT("PwrActionShutdownReset"),
|
|
TEXT("PwrActionShutdownOff")
|
|
};
|
|
|
|
extern int g_iShowValidationChanges;
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* GetIndent
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
*******************************************************************************/
|
|
#define MAX_INDENT 32
|
|
|
|
void GetIndent(LPSTR lpsz, LPSTR lpszIndent)
|
|
{
|
|
UINT i;
|
|
|
|
for (i = 0; i < MAX_INDENT; i++) {
|
|
if (*lpsz != ' ') {
|
|
break;
|
|
}
|
|
lpsz++;
|
|
*lpszIndent++ = ' ';
|
|
}
|
|
*lpszIndent = '\0';
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* DumpPowerActionPolicy
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
void DumpPowerActionPolicy(
|
|
LPSTR lpszLabel,
|
|
PPOWER_ACTION_POLICY ppap
|
|
)
|
|
{
|
|
char szLabel[MAX_INDENT], szIndent[MAX_INDENT];
|
|
|
|
GetIndent(lpszLabel, szIndent);
|
|
MYDBGPRINT(("%s, POWER_ACTION_POLICY: %08X", lpszLabel, ppap));
|
|
if (ppap->Action <= PowerActionShutdownOff) {
|
|
MYDBGPRINT(("%s Action: %08X, %s", szIndent, ppap->Action, lpszDebugPwrAction[ppap->Action]));
|
|
}
|
|
else {
|
|
MYDBGPRINT(("%s Action: %08X, Invalid!", szIndent, ppap->Action));
|
|
}
|
|
MYDBGPRINT(("%s Flags: %08X", szIndent, ppap->Flags));
|
|
MYDBGPRINT(("%s EventCode: %08X", szIndent, ppap->EventCode));
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* DumpSystemPowerLevel
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
void DumpSystemPowerLevel(
|
|
LPSTR lpszLabel,
|
|
PSYSTEM_POWER_LEVEL pspl
|
|
)
|
|
{
|
|
char szLabel[MAX_INDENT], szIndent[MAX_INDENT];
|
|
|
|
GetIndent(lpszLabel, szIndent);
|
|
MYDBGPRINT(("%s, SYSTEM_POWER_LEVEL: %08X", lpszLabel, pspl));
|
|
MYDBGPRINT(("%s Enable: %08X", szIndent, pspl->Enable));
|
|
MYDBGPRINT(("%s BatteryLevel: %08X", szIndent, pspl->BatteryLevel));
|
|
wsprintfA(szLabel, "%s PowerPolicy", szIndent);
|
|
DumpPowerActionPolicy(szLabel, &pspl->PowerPolicy);
|
|
if (pspl->MinSystemState <= PowerSystemMaximum) {
|
|
MYDBGPRINT(("%s MinSystemState: %08X, %s", szIndent, pspl->MinSystemState, lpszDebugPwrState[pspl->MinSystemState]));
|
|
}
|
|
else {
|
|
MYDBGPRINT(("%s MinSystemState: %08X, Invalid!!", szIndent, pspl->MinSystemState));
|
|
}
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* DumpSystemPowerPolicy
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
void DumpSystemPowerPolicy(
|
|
LPSTR lpszLabel,
|
|
PSYSTEM_POWER_POLICY pspp
|
|
)
|
|
{
|
|
UINT i;
|
|
char szLabel[MAX_INDENT], szIndent[MAX_INDENT];
|
|
|
|
GetIndent(lpszLabel, szIndent);
|
|
MYDBGPRINT(("%s, SYSTEM_POWER_POLICY: %08X", lpszLabel, pspp));
|
|
MYDBGPRINT(("%s Revision: %08X", szIndent, pspp->Revision));
|
|
wsprintfA(szLabel, "%s PowerButton", szIndent);
|
|
DumpPowerActionPolicy( szLabel, &pspp->PowerButton);
|
|
wsprintfA(szLabel, "%s SleepButton", szIndent);
|
|
DumpPowerActionPolicy( szLabel, &pspp->SleepButton);
|
|
wsprintfA(szLabel, "%s LidClose", szIndent);
|
|
DumpPowerActionPolicy( szLabel, &pspp->LidClose);
|
|
MYDBGPRINT(("%s LidOpenWake: %08X, %s", szIndent, pspp->LidOpenWake, lpszDebugPwrState[pspp->LidOpenWake]));
|
|
wsprintfA(szLabel, "%s Idle", szIndent);
|
|
DumpPowerActionPolicy( szLabel, &pspp->Idle);
|
|
MYDBGPRINT(("%s IdleTimeout: %08X", szIndent, pspp->IdleTimeout));
|
|
MYDBGPRINT(("%s IdleSensitivity: %08X", szIndent, pspp->IdleSensitivity));
|
|
MYDBGPRINT(("%s MinSleep: %08X, %s", szIndent, pspp->MinSleep, lpszDebugPwrState[pspp->MinSleep]));
|
|
MYDBGPRINT(("%s MaxSleep: %08X, %s", szIndent, pspp->MaxSleep, lpszDebugPwrState[pspp->MaxSleep]));
|
|
MYDBGPRINT(("%s ReducedLatencySleep: %08X, %s", szIndent, pspp->ReducedLatencySleep, lpszDebugPwrState[pspp->ReducedLatencySleep]));
|
|
MYDBGPRINT(("%s WinLogonFlags: %08X", szIndent, pspp->WinLogonFlags));
|
|
MYDBGPRINT(("%s DozeS4Timeout: %08X", szIndent, pspp->DozeS4Timeout));
|
|
MYDBGPRINT(("%s BroadcastCapacityResolution: %08X", szIndent, pspp->BroadcastCapacityResolution));
|
|
for (i = 0; i < NUM_DISCHARGE_POLICIES; i++) {
|
|
wsprintfA(szLabel, "%s DischargePolicy[%d]", szIndent, i);
|
|
DumpSystemPowerLevel( szLabel, &pspp->DischargePolicy[i]);
|
|
}
|
|
MYDBGPRINT(("%s VideoTimeout: %08X", szIndent, pspp->VideoTimeout));
|
|
MYDBGPRINT(("%s VideoDimDisplay: %08X", szIndent, pspp->VideoDimDisplay));
|
|
MYDBGPRINT(("%s SpindownTimeout: %08X", szIndent, pspp->SpindownTimeout));
|
|
MYDBGPRINT(("%s OptimizeForPower: %08X", szIndent, pspp->OptimizeForPower));
|
|
MYDBGPRINT(("%s FanThrottleTolerance: %08X", szIndent, pspp->FanThrottleTolerance));
|
|
MYDBGPRINT(("%s ForcedThrottle: %08X", szIndent, pspp->ForcedThrottle));
|
|
MYDBGPRINT(("%s MinThrottle: %08X", szIndent, pspp->MinThrottle));
|
|
wsprintfA(szLabel, "%s OverThrottled", szIndent);
|
|
DumpPowerActionPolicy( szLabel, &pspp->OverThrottled);
|
|
MYDBGPRINT(("\n\n"));
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* DumpSystemPowerCapabilities
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
void DumpSystemPowerCapabilities(
|
|
LPSTR lpszLabel,
|
|
PSYSTEM_POWER_CAPABILITIES pspc
|
|
)
|
|
{
|
|
UINT i;
|
|
char szLabel[MAX_INDENT], szIndent[MAX_INDENT];
|
|
|
|
GetIndent(lpszLabel, szIndent);
|
|
MYDBGPRINT(("%s, SYSTEM_POWER_CAPABILITIES: %08X", lpszLabel, pspc));
|
|
MYDBGPRINT(("%s PowerButtonPresent: %08X", szIndent, pspc->PowerButtonPresent));
|
|
MYDBGPRINT(("%s SleepButtonPresent: %08X", szIndent, pspc->SleepButtonPresent));
|
|
MYDBGPRINT(("%s LidPresent: %08X", szIndent, pspc->LidPresent));
|
|
MYDBGPRINT(("%s SystemS1: %08X", szIndent, pspc->SystemS1));
|
|
MYDBGPRINT(("%s SystemS2: %08X", szIndent, pspc->SystemS2));
|
|
MYDBGPRINT(("%s SystemS3: %08X", szIndent, pspc->SystemS3));
|
|
MYDBGPRINT(("%s SystemS4: %08X", szIndent, pspc->SystemS4));
|
|
MYDBGPRINT(("%s SystemS5: %08X", szIndent, pspc->SystemS5));
|
|
MYDBGPRINT(("%s HiberFilePresent: %08X", szIndent, pspc->HiberFilePresent));
|
|
MYDBGPRINT(("%s ThermalControl: %08X", szIndent, pspc->ThermalControl));
|
|
MYDBGPRINT(("%s ProcessorThrottle: %08X", szIndent, pspc->ProcessorThrottle));
|
|
MYDBGPRINT(("%s ProcessorMinThrottle: %02X", szIndent, pspc->ProcessorMinThrottle));
|
|
MYDBGPRINT(("%s ProcessorMaxThrottle: %02X", szIndent, pspc->ProcessorMaxThrottle));
|
|
MYDBGPRINT(("%s VideoDimPresent: %08X", szIndent, pspc->VideoDimPresent));
|
|
MYDBGPRINT(("%s DiskSpinDown: %08X", szIndent, pspc->DiskSpinDown));
|
|
MYDBGPRINT(("%s SystemBatteriesPresent: %08X", szIndent, pspc->SystemBatteriesPresent));
|
|
MYDBGPRINT(("%s BatteriesAreShortTerm: %08X", szIndent, pspc->BatteriesAreShortTerm));
|
|
|
|
// Not implemented: BATTERY_REPORTING_SCALE BatteryScale[3];
|
|
|
|
MYDBGPRINT(("%s AcOnLineWake: %08X, %s", szIndent, pspc->AcOnLineWake, lpszDebugPwrState[pspc->AcOnLineWake]));
|
|
MYDBGPRINT(("%s SoftLidWake: %08X, %s", szIndent, pspc->SoftLidWake, lpszDebugPwrState[pspc->SoftLidWake]));
|
|
MYDBGPRINT(("%s RtcWake: %08X, %s", szIndent, pspc->RtcWake, lpszDebugPwrState[pspc->RtcWake]));
|
|
MYDBGPRINT(("%s MinDeviceWakeState: %08X, %s", szIndent, pspc->MinDeviceWakeState, lpszDebugPwrState[pspc->MinDeviceWakeState]));
|
|
MYDBGPRINT(("%s DefaultLowLatencyWake: %08X, %s", szIndent, pspc->DefaultLowLatencyWake, lpszDebugPwrState[pspc->DefaultLowLatencyWake]));
|
|
MYDBGPRINT(("\n\n"));
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* DifSystemPowerPolicies
|
|
*
|
|
* DESCRIPTION:
|
|
*
|
|
* PARAMETERS:
|
|
*
|
|
*******************************************************************************/
|
|
|
|
void DifSystemPowerPolicies(
|
|
LPSTR lpszLabel,
|
|
PSYSTEM_POWER_POLICY pspp1,
|
|
PSYSTEM_POWER_POLICY pspp2
|
|
)
|
|
{
|
|
UINT i;
|
|
char szLabel[MAX_INDENT], szIndent[MAX_INDENT];
|
|
|
|
if (!g_iShowValidationChanges) {
|
|
return;
|
|
}
|
|
|
|
if (memcmp(pspp1, pspp2, sizeof(SYSTEM_POWER_POLICY))) {
|
|
|
|
GetIndent(lpszLabel, szIndent);
|
|
MYDBGPRINT(("%s, spp1: %08X, spp2: %08X", lpszLabel, pspp1, pspp2));
|
|
if (pspp1->Revision != pspp2->Revision) {
|
|
MYDBGPRINT(("%s Revision, spp1: %08X, spp2: %08X", szIndent, pspp1->Revision, pspp2->Revision));
|
|
}
|
|
if (memcmp(&pspp1->PowerButton, &pspp2->PowerButton, sizeof(POWER_ACTION_POLICY))) {
|
|
wsprintfA(szLabel, "%s spp1, PowerButton", szIndent);
|
|
DumpPowerActionPolicy( szLabel, &pspp1->PowerButton);
|
|
wsprintfA(szLabel, "%s spp2, PowerButton", szIndent);
|
|
DumpPowerActionPolicy( szLabel, &pspp2->PowerButton);
|
|
}
|
|
if (memcmp(&pspp1->SleepButton, &pspp2->SleepButton, sizeof(POWER_ACTION_POLICY))) {
|
|
wsprintfA(szLabel, "%s spp1, SleepButton", szIndent);
|
|
DumpPowerActionPolicy( szLabel, &pspp1->SleepButton);
|
|
wsprintfA(szLabel, "%s spp2, SleepButton", szIndent);
|
|
DumpPowerActionPolicy( szLabel, &pspp2->SleepButton);
|
|
}
|
|
if (memcmp(&pspp1->LidClose, &pspp2->LidClose, sizeof(POWER_ACTION_POLICY))) {
|
|
wsprintfA(szLabel, "%s spp1, LidClose", szIndent);
|
|
DumpPowerActionPolicy( szLabel, &pspp1->LidClose);
|
|
wsprintfA(szLabel, "%s spp2, LidClose:", szIndent);
|
|
DumpPowerActionPolicy( szLabel, &pspp2->LidClose);
|
|
}
|
|
if (pspp1->LidOpenWake != pspp2->LidOpenWake) {
|
|
MYDBGPRINT(("%s spp1, LidOpenWake: %08X, %s", szIndent, pspp1->LidOpenWake, lpszDebugPwrState[pspp1->LidOpenWake]));
|
|
MYDBGPRINT(("%s spp2, LidOpenWake: %08X, %s", szIndent, pspp2->LidOpenWake, lpszDebugPwrState[pspp2->LidOpenWake]));
|
|
}
|
|
if (memcmp(&pspp1->Idle, &pspp2->Idle, sizeof(POWER_ACTION_POLICY))) {
|
|
wsprintfA(szLabel, "%s spp1, Idle", szIndent);
|
|
DumpPowerActionPolicy( szLabel, &pspp1->Idle);
|
|
wsprintfA(szLabel, "%s spp2, Idle", szIndent);
|
|
DumpPowerActionPolicy( szLabel, &pspp2->Idle);
|
|
}
|
|
if (pspp1->IdleTimeout != pspp2->IdleTimeout) {
|
|
MYDBGPRINT(("%s IdleTimeout, spp1: %08X, spp2: %08X", szIndent, pspp1->IdleTimeout, pspp2->IdleTimeout));
|
|
}
|
|
if (pspp1->IdleSensitivity != pspp2->IdleSensitivity) {
|
|
MYDBGPRINT(("%s IdleSensitivity, spp1: %08X, spp2: %08X", szIndent, pspp1->IdleSensitivity, pspp2->IdleSensitivity));
|
|
}
|
|
if (pspp1->MinSleep != pspp2->MinSleep) {
|
|
MYDBGPRINT(("%s MinSleep, spp1: %08X, %s", szIndent, pspp1->MinSleep, lpszDebugPwrState[pspp1->MinSleep]));
|
|
MYDBGPRINT(("%s MinSleep, spp2: %08X, %s", szIndent, pspp2->MinSleep, lpszDebugPwrState[pspp2->MinSleep]));
|
|
}
|
|
if (pspp1->MaxSleep != pspp2->MaxSleep) {
|
|
MYDBGPRINT(("%s MaxSleep, spp1: %08X, %s", szIndent, pspp1->MaxSleep, lpszDebugPwrState[pspp1->MaxSleep]));
|
|
MYDBGPRINT(("%s MaxSleep, spp2: %08X, %s", szIndent, pspp2->MaxSleep, lpszDebugPwrState[pspp2->MaxSleep]));
|
|
}
|
|
if (pspp1->ReducedLatencySleep != pspp2->ReducedLatencySleep) {
|
|
MYDBGPRINT(("%s ReducedLatencySleep, spp1: %08X, %s", szIndent, pspp1->ReducedLatencySleep, lpszDebugPwrState[pspp1->ReducedLatencySleep]));
|
|
MYDBGPRINT(("%s ReducedLatencySleep, spp2: %08X, %s", szIndent, pspp2->ReducedLatencySleep, lpszDebugPwrState[pspp2->ReducedLatencySleep]));
|
|
}
|
|
if (pspp1->WinLogonFlags != pspp2->WinLogonFlags) {
|
|
MYDBGPRINT(("%s WinLogonFlags, spp1: %08X, spp2: %08X", szIndent, pspp1->WinLogonFlags, pspp2->WinLogonFlags));
|
|
}
|
|
if (pspp1->DozeS4Timeout != pspp2->DozeS4Timeout) {
|
|
MYDBGPRINT(("%s DozeS4Timeout, spp1: %08X, spp2: %08X", szIndent, pspp1->DozeS4Timeout, pspp2->DozeS4Timeout));
|
|
}
|
|
if (pspp1->BroadcastCapacityResolution != pspp2->BroadcastCapacityResolution) {
|
|
MYDBGPRINT(("%s BroadcastCapacityResolution, spp1: %08X, spp2: %08X", szIndent, pspp1->BroadcastCapacityResolution, pspp2->BroadcastCapacityResolution));
|
|
}
|
|
for (i = 0; i < NUM_DISCHARGE_POLICIES; i++) {
|
|
if (memcmp(&(pspp1->DischargePolicy[i]), &(pspp2->DischargePolicy[i]), sizeof(SYSTEM_POWER_LEVEL))) {
|
|
wsprintfA(szLabel, "%s DischargePolicy[%d], spp1:", szIndent, i);
|
|
DumpSystemPowerLevel( szLabel, &pspp1->DischargePolicy[i]);
|
|
wsprintfA(szLabel, "%s DischargePolicy[%d], spp2:", szIndent, i);
|
|
DumpSystemPowerLevel( szLabel, &pspp2->DischargePolicy[i]);
|
|
}
|
|
}
|
|
if (pspp1->VideoTimeout != pspp2->VideoTimeout) {
|
|
MYDBGPRINT(("%s VideoTimeout, spp1: %08X, spp2: %08X", szIndent, pspp1->VideoTimeout, pspp2->VideoTimeout));
|
|
}
|
|
if (pspp1->VideoDimDisplay != pspp2->VideoDimDisplay) {
|
|
MYDBGPRINT(("%s VideoDimDisplay, spp1: %08X, spp2: %08X", szIndent, pspp1->VideoDimDisplay, pspp2->VideoDimDisplay));
|
|
}
|
|
if (pspp1->SpindownTimeout != pspp2->SpindownTimeout) {
|
|
MYDBGPRINT(("%s SpindownTimeout, spp1: %08X, spp2: %08X", szIndent, pspp1->SpindownTimeout, pspp2->SpindownTimeout));
|
|
}
|
|
if (pspp1->OptimizeForPower != pspp2->OptimizeForPower) {
|
|
MYDBGPRINT(("%s OptimizeForPower, spp1: %08X, spp2: %08X", szIndent, pspp1->OptimizeForPower, pspp2->OptimizeForPower));
|
|
}
|
|
if (pspp1->FanThrottleTolerance != pspp2->FanThrottleTolerance) {
|
|
MYDBGPRINT(("%s FanThrottleTolerance, spp1: %08X, spp2: %08X", szIndent, pspp1->FanThrottleTolerance, pspp2->FanThrottleTolerance));
|
|
}
|
|
if (pspp1->ForcedThrottle != pspp2->ForcedThrottle) {
|
|
MYDBGPRINT(("%s ForcedThrottle, spp1: %08X, spp2: %08X", szIndent, pspp1->ForcedThrottle, pspp2->ForcedThrottle));
|
|
}
|
|
if (pspp1->MinThrottle != pspp2->MinThrottle) {
|
|
MYDBGPRINT(("%s MinThrottle, spp1: %08X, spp2: %08X", szIndent, pspp1->MinThrottle, pspp2->MinThrottle));
|
|
}
|
|
if (memcmp(&pspp1->OverThrottled, &pspp2->OverThrottled, sizeof(POWER_ACTION_POLICY))) {
|
|
wsprintfA(szLabel, "%s spp1, OverThrottled", szIndent);
|
|
DumpPowerActionPolicy( szLabel, &pspp1->OverThrottled);
|
|
wsprintfA(szLabel, "%s spp2, OverThrottled", szIndent);
|
|
DumpPowerActionPolicy( szLabel, &pspp2->OverThrottled);
|
|
}
|
|
MYDBGPRINT(("\n\n"));
|
|
}
|
|
}
|
|
#endif
|