📄 power.cpp
字号:
case VGXPMCMD_INIT:
if ((cjIn == sizeof(VGXPM_STRUCT)) &&
(cjOut == 0) && (pvOut == NULL))
{
dwResult = StartPowerThread();
}
else
{
MESSAGE(MESSAGE_ZONE,
(TEXT("HandleSMIPowerManagement: invalid VGXPMCMD_INIT parameters\r\n")));
}
break;
case VGXPMCMD_SET_MONITOR:
if ((cjIn == sizeof(VGXPM_MONITOR_STRUCT)) &&
(cjOut == 0) && (pvOut == NULL))
{
PVGXPM_MONITOR_STRUCT pSetMonitor = (PVGXPM_MONITOR_STRUCT)pvIn;
SetMonitorEnabled(pSetMonitor->bMonitorEnabled);
dwResult = VGXPM_RET_SUCCESS;
}
else
{
MESSAGE(MESSAGE_ZONE,
(TEXT("HandleSMIPowerManagement: invalid VGXPMCMD_SET_MONITOR parameters\r\n")));
}
break;
case VGXPMCMD_GET_MONITOR:
if ((cjIn == sizeof(VGXPM_MONITOR_STRUCT)) &&
(cjOut == sizeof(VGXPM_MONITOR_STRUCT)) && (pvOut != NULL))
{
PVGXPM_MONITOR_STRUCT pGetMonitor = (PVGXPM_MONITOR_STRUCT)pvOut;
pGetMonitor->bMonitorEnabled = IsMonitorEnabled();
dwResult = VGXPM_RET_SUCCESS;
}
else
{
MESSAGE(MESSAGE_ZONE,
(TEXT("HandleSMIPowerManagement: invalid VGXPMCMD_GET_MONITOR parameters\r\n")));
}
break;
case VGXPMCMD_SET_POWER:
if ((cjIn == sizeof(VGXPM_POWER_STRUCT)) &&
(cjOut == 0) && (pvOut == NULL))
{
PVGXPM_POWER_STRUCT pSetPower = (PVGXPM_POWER_STRUCT)pvIn;
LockPowerState(FALSE);
dwResult = SetVGXPowerManagement(pSetPower->State);
if (pSetPower->State != VGXPowerAuto)
LockPowerState();
}
else
{
MESSAGE(MESSAGE_ZONE,
(TEXT("HandleSMIPowerManagement: invalid VGXPMCMD_SET_POWER parameters\r\n")));
}
break;
case VGXPMCMD_GET_POWER:
if ((cjIn == sizeof(VGXPM_POWER_STRUCT)) &&
(cjOut == sizeof(VGXPM_POWER_STRUCT)) && (pvOut != NULL))
{
PVGXPM_POWER_STRUCT pGetPower = (PVGXPM_POWER_STRUCT)pvOut;
pGetPower->State = GetCurrentPowerState();
dwResult = VGXPM_RET_SUCCESS;
}
else
{
MESSAGE(MESSAGE_ZONE,
(TEXT("HandleSMIPowerManagement: invalid VGXPMCMD_GET_POWER parameters\r\n")));
}
break;
case VGXPMCMD_SET_IDLE:
if ((cjIn == sizeof(VGXPM_IDLE_STRUCT)) &&
(cjOut == 0) && (pvOut == NULL))
{
PVGXPM_IDLE_STRUCT pSetIdle = (PVGXPM_IDLE_STRUCT)pvIn;
dwResult = SetIdle(pSetIdle->dwTicksToReduced, pSetIdle->dwTicksToMinimal);
}
else
{
MESSAGE(MESSAGE_ZONE,
(TEXT("HandleSMIPowerManagement: invalid VGXPMCMD_SET_IDLE parameters\r\n")));
}
break;
case VGXPMCMD_GET_IDLE:
if ((cjIn == sizeof(VGXPM_IDLE_STRUCT)) &&
(cjOut == sizeof(VGXPM_IDLE_STRUCT)) && (pvOut != NULL))
{
PVGXPM_IDLE_STRUCT pGetIdle = (PVGXPM_IDLE_STRUCT)pvOut;
pGetIdle->dwTicksToReduced = GetTicksToReduced();
pGetIdle->dwTicksToMinimal = GetTicksToMinimal();
dwResult = VGXPM_RET_SUCCESS;
}
else
{
MESSAGE(MESSAGE_ZONE,
(TEXT("HandleSMIPowerManagement: invalid VGXPMCMD_GET_IDLE parameters\r\n")));
}
break;
case VGXPMCMD_SET_MODULE_POWER:
if ((cjIn == sizeof(VGXPM_MODULE_POWER_STRUCT)) &&
(cjOut == 0) && (pvOut == NULL))
{
PVGXPM_MODULE_POWER_STRUCT pSetModulePower = (PVGXPM_MODULE_POWER_STRUCT)pvIn;
dwResult = SetModulePower(pSetModulePower->Module, pSetModulePower->State);
}
else
{
MESSAGE(MESSAGE_ZONE,
(TEXT("HandleSMIPowerManagement: invalid VGXPMCMD_SET_MODULE_POWER parameters\r\n")));
}
break;
case VGXPMCMD_GET_MODULE_POWER:
if ((cjIn == sizeof(VGXPM_MODULE_POWER_STRUCT)) &&
(cjOut == sizeof(VGXPM_MODULE_POWER_STRUCT)) && (pvOut != NULL))
{
PVGXPM_MODULE_POWER_STRUCT pGetModulePowerIn = (PVGXPM_MODULE_POWER_STRUCT)pvIn;
PVGXPM_MODULE_POWER_STRUCT pGetModulePowerOut = (PVGXPM_MODULE_POWER_STRUCT)pvOut;
dwResult = GetModulePower(pGetModulePowerIn->Module, pGetModulePowerOut->State);
}
else
{
MESSAGE(MESSAGE_ZONE,
(TEXT("HandleSMIPowerManagement: invalid VGXPMCMD_GET_MODULE_POWER parameters\r\n")));
}
break;
case VGXPMCMD_SET_MODULE_MONITOR:
if ((cjIn == sizeof(VGXPM_MODULE_MONITOR_STRUCT)) &&
(cjOut == 0) && (pvOut == NULL))
{
PVGXPM_MODULE_MONITOR_STRUCT pSetModuleMonitor = (PVGXPM_MODULE_MONITOR_STRUCT)pvIn;
dwResult = SetModuleMonitorEnabled(pSetModuleMonitor->Module, pSetModuleMonitor->bMonitorEnabled);
}
else
{
MESSAGE(MESSAGE_ZONE,
(TEXT("HandleSMIPowerManagement: invalid VGXPMCMD_SET_MODULE_MONITOR parameters\r\n")));
}
break;
case VGXPMCMD_GET_MODULE_MONITOR:
if ((cjIn == sizeof(VGXPM_MODULE_MONITOR_STRUCT)) &&
(cjOut == sizeof(VGXPM_MODULE_MONITOR_STRUCT)) && (pvOut != NULL))
{
PVGXPM_MODULE_MONITOR_STRUCT pGetModuleMonitorIn = (PVGXPM_MODULE_MONITOR_STRUCT)pvIn;
PVGXPM_MODULE_MONITOR_STRUCT pGetModuleMonitorOut = (PVGXPM_MODULE_MONITOR_STRUCT)pvOut;
dwResult = GetModuleMonitorEnabled(pGetModuleMonitorIn->Module, pGetModuleMonitorOut->bMonitorEnabled);
}
else
{
MESSAGE(MESSAGE_ZONE,
(TEXT("HandleSMIPowerManagement: invalid VGXPMCMD_GET_MODULE_MONITOR parameters\r\n")));
}
break;
case VGXPMCMD_SET_MODULE_IDLE:
if ((cjIn == sizeof(VGXPM_MODULE_IDLE_STRUCT)) &&
(cjOut == 0) && (pvOut == NULL))
{
PVGXPM_MODULE_IDLE_STRUCT pSetModuleMonitor = (PVGXPM_MODULE_IDLE_STRUCT)pvIn;
dwResult = SetTicksToPowerDown(pSetModuleMonitor->Module, pSetModuleMonitor->dwTicksToPowerDown);
}
else
{
MESSAGE(MESSAGE_ZONE,
(TEXT("HandleSMIPowerManagement: invalid VGXPMCMD_SET_MODULE_IDLE parameters\r\n")));
}
break;
case VGXPMCMD_GET_MODULE_IDLE:
if ((cjIn == sizeof(VGXPM_MODULE_IDLE_STRUCT)) &&
(cjOut == sizeof(VGXPM_MODULE_IDLE_STRUCT)) && (pvOut != NULL))
{
PVGXPM_MODULE_IDLE_STRUCT pGetModuleIdleIn = (PVGXPM_MODULE_IDLE_STRUCT)pvIn;
PVGXPM_MODULE_IDLE_STRUCT pGetModuleIdleOut = (PVGXPM_MODULE_IDLE_STRUCT)pvOut;
dwResult = GetTicksToPowerDown(pGetModuleIdleIn->Module, pGetModuleIdleOut->dwTicksToPowerDown);
}
else
{
MESSAGE(MESSAGE_ZONE,
(TEXT("HandleSMIPowerManagement: invalid VGXPMCMD_GET_MODULE_IDLE parameters\r\n")));
}
break;
case VGXPMCMD_SET_CLOCK_ARRAY:
if ((cjIn > sizeof(VGXPM_CLOCK_ARRAY_STRUCT)) &&
(cjOut == 0) && (pvOut == NULL))
{
PVGXPM_CLOCK_ARRAY_STRUCT pSetClockArray = (PVGXPM_CLOCK_ARRAY_STRUCT)pvIn;
if (cjIn == sizeof(VGXPM_CLOCK_ARRAY_STRUCT) + sizeof(CLOCK_ARRAY))
{
CLOCK_ARRAY& Array = *(PCLOCK_ARRAY)((PBYTE)pvIn + sizeof(VGXPM_CLOCK_ARRAY_STRUCT));
SetClockArray(Array);
dwResult = SetVGXPowerManagement(GetCurrentPowerState());
}
else
{
MESSAGE(MESSAGE_ZONE,
(TEXT("HandleSMIPowerManagement(VGXPMCMD_SET_CLOCK_ARRAY): invalid clock array\r\n")));
}
}
else
{
MESSAGE(MESSAGE_ZONE,
(TEXT("HandleSMIPowerManagement: invalid VGXPMCMD_SET_CLOCK_ARRAY parameters\r\n")));
}
break;
case VGXPMCMD_GET_CLOCK_ARRAY:
if (cjIn == sizeof(VGXPM_CLOCK_ARRAY_STRUCT))
{
if ((cjOut == sizeof(CLOCK_ARRAY)) && (pvOut != NULL))
{
CLOCK_ARRAY& Array = *(PCLOCK_ARRAY)pvOut;
GetClockArray(Array);
}
dwResult = sizeof(CLOCK_ARRAY);
}
else
{
MESSAGE(MESSAGE_ZONE,
(TEXT("HandleSMIPowerManagement: invalid VGXPMCMD_GET_CLOCK_ARRAY parameters\r\n")));
}
break;
default:
MESSAGE(MESSAGE_ZONE, (TEXT("HandleSMIPowerManagement: invalid command has been specified\r\n")));
}
}
else
{
MESSAGE(MESSAGE_ZONE,
(TEXT("HandleSMIPowerManagement: invalid input structure\r\n")));
}
if (dwResult == VGXPM_RET_INVALID_PARAMETER)
SetLastError (ERROR_INVALID_PARAMETER);
MESSAGE(MESSAGE_ZONE, (TEXT("-SMI::HandleSMIPowerManagement\r\n")));
return dwResult;
}
///////////////////////////////////////////////////////////////////////////////
// Power Hook is called when a 'hooked' API is called.
// APIs are hookes by POWER_HOOK macro.
void SMI::PowerHook(VGXPM_MODULES Module, VGX_POWER_STATE MinPower)
{
#ifdef USE_POWERHOOK
#ifdef ENABLE_ALL_MESSAGES
MESSAGE(MESSAGE_ZONE, (TEXT("+SMI::PowerHook\r\n")));
#endif
// Make sure the lock is off
BOOL bSaveLock = m_bPowerStateLocked;
m_bPowerStateLocked = FALSE;
// Force to FullPower if in high power consumption mode
if (IsHighPowerConsumption())
{
MinPower = VGXPowerOn;
}
// Make sure that the chip is running at least in the specified power
// mode or faster.
EnsureAtLeast(MinPower);
// Restore the lock
m_bPowerStateLocked = bSaveLock;
// Record the current tick count for the module
m_PowerInfo[Module].dwLastCallTickCount = GetTickCountSafe();
// Make sure the module is on
if (m_PowerInfo[Module].CurrentState != VGXPowerOn)
SetModulePower(Module, VGXPowerOn);
#ifdef ENABLE_ALL_MESSAGES
MESSAGE(MESSAGE_ZONE, (TEXT("-SMI::PowerHook\r\n")));
#endif
#endif
}
///////////////////////////////////////////////////////////////////////////////
// Checks whether the system is runnning in high consumption mode
BOOL SMI::IsHighPowerConsumption()
{
// Read the hw video state
BOOL bVideoOn = FIELD_GET(peekRegisterDWord(VIDEO_DISPLAY_CTRL),
VIDEO_DISPLAY_CTRL, PLANE) == VIDEO_DISPLAY_CTRL_PLANE_ENABLE;
return (
bVideoOn || // Video is playing?
m_bAlphaEnabled || // Alpha overlay is present?
m_bZoomEnabled // Video zoom is enabled?
);
}
///////////////////////////////////////////////////////////////////////////////
// Sets the requested standard WinCE video power mode.
DWORD SMI::SetPowerManagement(VIDEO_POWER_STATE PowerState)
{
MESSAGE(MESSAGE_ZONE, (TEXT("+SMI::SetPowerManagement\r\n")));
DWORD dwResult = VGXPM_RET_INVALID_PARAMETER;
switch (PowerState)
{
case VideoPowerOn:
dwResult = SetVGXPowerManagement(VGXPowerOn);
break;
case VideoPowerStandBy:
dwResult = SetVGXPowerManagement(VGXPowerStandBy);
break;
case VideoPowerSuspend:
dwResult = SetVGXPowerManagement(VGXPowerSuspend);
break;
case VideoPowerOff:
dwResult = SetVGXPowerManagement(VGXPowerOff);
break;
default:
// Unknown Powerstate
MESSAGE(MESSAGE_ZONE, (TEXT("SMI::SetPowerManagement(***UNKNOWN POWER STATE***)\r\n")));
}
MESSAGE(MESSAGE_ZONE, (TEXT("-SMI::SetPowerManagement\r\n")));
return dwResult;
}
///////////////////////////////////////////////////////////////////////////////
// Virtual API function. Can be called by WinCE.
DWORD SMI::SetVGXPowerManagement(VGX_POWER_STATE PowerState)
{
EnterCriticalSection(&m_PowerCriticalSection);
MESSAGE(MESSAGE_ZONE, (TEXT("+SMI::SetVGXPowerManagement\r\n")));
DWORD dwResult = VGXPM_RET_SUCCESS;
int j;
// Make sure the power state isn't locked
if (IsPowerStateLocked() && (PowerState != VGXPowerAuto))
{
MESSAGE(MESSAGE_ZONE, (TEXT("Can't change the power state - locked\r\n")));
dwResult = VGXPM_RET_LOCKED_STATE;
}
else
{
switch (PowerState)
{
case VGXPowerAuto:
MESSAGE(MESSAGE_ZONE, (TEXT("[SMI::SetVGXPowerManagement] VGXPowerAuto\r\n")));
LockPowerState(FALSE);
break;
case VGXPowerOn:
MESSAGE(MESSAGE_ZONE, (TEXT("[SMI::SetVGXPowerManagement] VGXPowerOn\r\n")));
// Do the restore
if (m_SMISettings.m_nSaveRestoreEnabled)
{
for (int i = 3000; i > 0; i--)
{
peekRegisterDWord(SYSTEM_DRAM_CTRL);
}
// Restore VGX registers and memory if previously saved
if (m_bVgxRegsMemorySaved)
{
SaveRestore(FALSE);
m_bVgxRegsMemorySaved = FALSE;
}
}
// Reset power management internal state
ResetPowerManagement();
// Set normal voltage
ReduceVoltage(FALSE);
// Program the clock and gates
if (g_SetPowerCEPC) //work around exception when power on on CEPC. 4/11/05
{
if ((m_dwClockSave != 0) && (m_dwGateSave != 0))
{
setPower(m_dwGateSave, m_dwClockSave);
if (!m_bProtectClockSource)
{
pokeRegisterDWord(SYSTEM_DRAM_CTRL, FIELD_VALUE(
peekRegisterDWord(SYSTEM_DRAM_CTRL),
SYSTEM_DRAM_CTRL,
PLL2_OUTPUT,
m_dwPLL2Output));
}
// Turn on CRT and panel
setDPMS(DPMS_ON);
panelPowerSequence(PANEL_ON, 4);
}
m_PowerState = VGXPowerOn;
}
else
{
if (SetClockMode(VGXPowerOn))
m_PowerState = VGXPowerOn;
if (m_bSetMode)
{//Turn on panel only after setmode is called
// Turn on CRT and panel
setDPMS(DPMS_ON);
panelPowerSequence(PANEL_ON, 4);
}
}
for (j = 0; j < 0x70; j+=4)
MESSAGE(MESSAGE_ZONE, (TEXT("PowerOn Reg[0x%08X] = 0x%08X\r\n"), j, peekRegisterDWord(j)));
break;
case VGXPowerReduced:
MESSAGE(MESSAGE_ZONE, (TEXT("[SMI::SetVGXPowerManagement] VGXPowerReduced\r\n")));
// Fail under high power consumption circumstances
if (IsHighPowerConsumption())
{
dwResult = VGXPM_RET_HIGH_CONSUMPTION;
}
else
{
// Set normal voltage
ReduceVoltage(FALSE);
// Reduce the memory and engine clocks
if (SetClockMode(VGXPowerReduced))
m_PowerState = VGXPowerReduced;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -