📄 power.cpp

📁 SM501基于ARMV4/ARMV4I平台
💻 CPP
📖 第 1 页 / 共 5 页
字号:
上一页 1 2 3 45
	INIT_CLOCK_INFO_MCLK  (288, 3, 1)		// 48MHz = 288 / (3 SHL 1)
	INIT_CLOCK_INFO_M2XCLK(288, 1, 2)		// 72Mhz = 288 / (1 SHL 2)


	///////////////////////////////////////////////////////////////////////////
	// Init 800x600

	// 8 bit per pixel
	INIT_CLOCK_INFO_RES(800, 600, 8)

	INIT_CLOCK_INFO_POWER (VGXPowerReduced)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 1, 2)		// 72MHz = 288 / (1 SHL 2)
	INIT_CLOCK_INFO_M2XCLK(288, 3, 0)		// 96MHz = 288 / (3 SHL 0)

	INIT_CLOCK_INFO_POWER (VGXPowerMinimal)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 3, 1)		// 48MHz = 288 / (3 SHL 1)
	INIT_CLOCK_INFO_M2XCLK(288, 1, 2)		// 72Mhz = 288 / (1 SHL 2)

	// 16 bit per pixel
	INIT_CLOCK_INFO_RES(800, 600, 16)

	INIT_CLOCK_INFO_POWER (VGXPowerReduced)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 1, 2)		// 72MHz = 288 / (1 SHL 2)
	INIT_CLOCK_INFO_M2XCLK(288, 3, 0)		// 96MHz = 288 / (3 SHL 0)

	INIT_CLOCK_INFO_POWER (VGXPowerMinimal)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 3, 1)		// 48MHz = 288 / (3 SHL 1)
	INIT_CLOCK_INFO_M2XCLK(288, 1, 2)		// 72Mhz = 288 / (1 SHL 2)

	// 32 bit per pixel
	INIT_CLOCK_INFO_RES(800, 600, 32)

	INIT_CLOCK_INFO_POWER (VGXPowerReduced)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 1, 2)		// 72MHz = 288 / (1 SHL 2)
	INIT_CLOCK_INFO_M2XCLK(288, 3, 0)		// 96MHz = 288 / (3 SHL 0)

	INIT_CLOCK_INFO_POWER (VGXPowerMinimal)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 3, 1)		// 48MHz = 288 / (3 SHL 1)
	INIT_CLOCK_INFO_M2XCLK(288, 1, 2)		// 72Mhz = 288 / (1 SHL 2)


	///////////////////////////////////////////////////////////////////////////
	// Init 1024x600

	// 8 bit per pixel
	INIT_CLOCK_INFO_RES(1024, 600, 8)

	INIT_CLOCK_INFO_POWER (VGXPowerReduced)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 1, 2)		// 72MHz = 288 / (1 SHL 2)
	INIT_CLOCK_INFO_M2XCLK(288, 3, 0)		// 96MHz = 288 / (3 SHL 0)

	INIT_CLOCK_INFO_POWER (VGXPowerMinimal)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 3, 1)		// 48MHz = 288 / (3 SHL 1)
	INIT_CLOCK_INFO_M2XCLK(288, 1, 2)		// 72Mhz = 288 / (1 SHL 2)

	// 16 bit per pixel
	INIT_CLOCK_INFO_RES(1024, 600, 16)

	INIT_CLOCK_INFO_POWER (VGXPowerReduced)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 1, 2)		// 72MHz = 288 / (1 SHL 2)
	INIT_CLOCK_INFO_M2XCLK(288, 3, 0)		// 96MHz = 288 / (3 SHL 0)

	INIT_CLOCK_INFO_POWER (VGXPowerMinimal)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 3, 1)		// 48MHz = 288 / (3 SHL 1)
	INIT_CLOCK_INFO_M2XCLK(288, 1, 2)		// 72Mhz = 288 / (1 SHL 2)

	// 32 bit per pixel
	INIT_CLOCK_INFO_RES(1024, 600, 32)

	INIT_CLOCK_INFO_POWER (VGXPowerReduced)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 1, 2)		// 72MHz = 288 / (1 SHL 2)
	INIT_CLOCK_INFO_M2XCLK(288, 3, 0)		// 96MHz = 288 / (3 SHL 0)

	INIT_CLOCK_INFO_POWER (VGXPowerMinimal)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 3, 1)		// 48MHz = 288 / (3 SHL 1)
	INIT_CLOCK_INFO_M2XCLK(288, 1, 2)		// 72Mhz = 288 / (1 SHL 2)


	///////////////////////////////////////////////////////////////////////////
	// Init 1024x768

	// 8 bit per pixel
	INIT_CLOCK_INFO_RES(1024, 768, 8)

	INIT_CLOCK_INFO_POWER (VGXPowerReduced)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 1, 2)		// 72MHz = 288 / (1 SHL 2)
	INIT_CLOCK_INFO_M2XCLK(288, 3, 0)		// 96MHz = 288 / (3 SHL 0)

	INIT_CLOCK_INFO_POWER (VGXPowerMinimal)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 3, 1)		// 48MHz = 288 / (3 SHL 1)
	INIT_CLOCK_INFO_M2XCLK(288, 1, 2)		// 72Mhz = 288 / (1 SHL 2)

	// 16 bit per pixel
	INIT_CLOCK_INFO_RES(1024, 768, 16)

	INIT_CLOCK_INFO_POWER (VGXPowerReduced)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 1, 2)		// 72MHz = 288 / (1 SHL 2)
	INIT_CLOCK_INFO_M2XCLK(288, 3, 0)		// 96MHz = 288 / (3 SHL 0)

	INIT_CLOCK_INFO_POWER (VGXPowerMinimal)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 3, 1)		// 48MHz = 288 / (3 SHL 1)
	INIT_CLOCK_INFO_M2XCLK(288, 1, 2)		// 72Mhz = 288 / (1 SHL 2)

	// 32 bit per pixel
	INIT_CLOCK_INFO_RES(1024, 768, 32)

	INIT_CLOCK_INFO_POWER (VGXPowerReduced)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 1, 2)		// 72MHz = 288 / (1 SHL 2)
	INIT_CLOCK_INFO_M2XCLK(288, 3, 0)		// 96MHz = 288 / (3 SHL 0)

	INIT_CLOCK_INFO_POWER (VGXPowerMinimal)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 1, 2)		// 72MHz = 288 / (1 SHL 2)
	INIT_CLOCK_INFO_M2XCLK(288, 3, 0)		// 96MHz = 288 / (3 SHL 0)


	///////////////////////////////////////////////////////////////////////////
	// Init 1280x960

	// 8 bit per pixel
	INIT_CLOCK_INFO_RES(1280, 960, 8)

	INIT_CLOCK_INFO_POWER (VGXPowerReduced)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 1, 2)		// 72MHz = 288 / (1 SHL 2)
	INIT_CLOCK_INFO_M2XCLK(288, 3, 0)		// 96MHz = 288 / (3 SHL 0)

	INIT_CLOCK_INFO_POWER (VGXPowerMinimal)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 3, 1)		// 48MHz = 288 / (3 SHL 1)
	INIT_CLOCK_INFO_M2XCLK(288, 1, 2)		// 72Mhz = 288 / (1 SHL 2)

	// 16 bit per pixel
	INIT_CLOCK_INFO_RES(1280, 960, 16)

	INIT_CLOCK_INFO_POWER (VGXPowerReduced)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 1, 2)		// 72MHz = 288 / (1 SHL 2)
	INIT_CLOCK_INFO_M2XCLK(288, 3, 0)		// 96MHz = 288 / (3 SHL 0)

	INIT_CLOCK_INFO_POWER (VGXPowerMinimal)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 3, 1)		// 48MHz = 288 / (3 SHL 1)
	INIT_CLOCK_INFO_M2XCLK(288, 1, 2)		// 72Mhz = 288 / (1 SHL 2)

	// 32 bit per pixel
	INIT_CLOCK_INFO_RES(1280, 960, 32)

	INIT_CLOCK_INFO_POWER (VGXPowerReduced)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 1, 2)		// 72MHz = 288 / (1 SHL 2)
	INIT_CLOCK_INFO_M2XCLK(288, 3, 0)		// 96MHz = 288 / (3 SHL 0)

	INIT_CLOCK_INFO_POWER (VGXPowerMinimal)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 1, 2)		// 72MHz = 288 / (1 SHL 2)
	INIT_CLOCK_INFO_M2XCLK(288, 3, 0)		// 96MHz = 288 / (3 SHL 0)


	///////////////////////////////////////////////////////////////////////////
	// Init 1280x1200

	// 8 bit per pixel
	INIT_CLOCK_INFO_RES(1280, 1200, 8)

	INIT_CLOCK_INFO_POWER (VGXPowerReduced)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 1, 2)		// 72MHz = 288 / (1 SHL 2)
	INIT_CLOCK_INFO_M2XCLK(288, 3, 0)		// 96MHz = 288 / (3 SHL 0)

	INIT_CLOCK_INFO_POWER (VGXPowerMinimal)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 3, 1)		// 48MHz = 288 / (3 SHL 1)
	INIT_CLOCK_INFO_M2XCLK(288, 1, 2)		// 72Mhz = 288 / (1 SHL 2)

	// 16 bit per pixel
	INIT_CLOCK_INFO_RES(1280, 1200, 16)

	INIT_CLOCK_INFO_POWER (VGXPowerReduced)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 1, 2)		// 72MHz = 288 / (1 SHL 2)
	INIT_CLOCK_INFO_M2XCLK(288, 3, 0)		// 96MHz = 288 / (3 SHL 0)

	INIT_CLOCK_INFO_POWER (VGXPowerMinimal)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 3, 1)		// 48MHz = 288 / (3 SHL 1)
	INIT_CLOCK_INFO_M2XCLK(288, 1, 2)		// 72Mhz = 288 / (1 SHL 2)

	// 32 bit per pixel
	INIT_CLOCK_INFO_RES(1280, 1200, 32)

	INIT_CLOCK_INFO_POWER (VGXPowerReduced)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 1, 2)		// 72MHz = 288 / (1 SHL 2)
	INIT_CLOCK_INFO_M2XCLK(288, 3, 0)		// 96MHz = 288 / (3 SHL 0)

	INIT_CLOCK_INFO_POWER (VGXPowerMinimal)
	INIT_CLOCK_INFO_PLL2  (288)
	INIT_CLOCK_INFO_MCLK  (288, 1, 2)		// 72MHz = 288 / (1 SHL 2)
	INIT_CLOCK_INFO_M2XCLK(288, 3, 0)		// 96MHz = 288 / (3 SHL 0)


	///////////////////////////////////////////////////////////////////////
	// Set default idle counters for the Power Monitor

//	SetIdle(
//		MIN2TICKS(2),						// 2 minutes before Reduced Mode
//		MIN2TICKS(4));						// 4 minutes before Minimal Mode


	///////////////////////////////////////////////////////////////////////
	// Set initial state of the Power Monitor

	SetMonitorEnabled(
		m_SMISettings.m_bEnablePowerMonitor);


	///////////////////////////////////////////////////////////////////////
	// Init power info for all monitored modules

	INITPOWERINFO(2D,  MIN2TICKS(6))		// Power info for 2D Engine.
//	INITPOWERINFO(PWM, MIN2TICKS(6))		// Power info for PWM.
//	INITPOWERINFO(I2C, MIN2TICKS(6))		// Power info for I2C.


	MESSAGE(MESSAGE_ZONE, (TEXT("-SMI::InitPowerManagement\r\n")));

	return VGXPM_RET_SUCCESS;
}


///////////////////////////////////////////////////////////////////////////////
// Starts the power thread.

DWORD SMI::StartPowerManagement()
{
	MESSAGE(MESSAGE_ZONE, (TEXT("+SMI::StartPowerManagement\r\n")));

	DWORD dwResult = VGXPM_RET_SUCCESS;

	///////////////////////////////////////////////////////////////////////////
	// Set initial power states

	DWORD dwPowerMask = 0;
	DWORD dwPowerGate = 0;

	// Disable 8051
	if (!IsAudioDriverPresent())
	{
		dwPowerMask |=
			_F_MASK(CURRENT_POWER_GATE_8051);
		dwPowerGate = FIELD_SET(dwPowerGate, CURRENT_POWER_GATE, 8051, DISABLE);
	}

	// Determine whether USB driver is loaded or not
	if (!IsUSBDriverPresent())
	{
		// USB is not loaded - dsiable the gate
		dwPowerMask |=
			_F_MASK(CURRENT_POWER_GATE_USB_SLAVE) |
			_F_MASK(CURRENT_POWER_GATE_USB_HOST);
		dwPowerGate = FIELD_SET(dwPowerGate, CURRENT_POWER_GATE, USB_SLAVE, DISABLE);
		dwPowerGate = FIELD_SET(dwPowerGate, CURRENT_POWER_GATE, USB_HOST,  DISABLE);
	}

	setGate(dwPowerMask, dwPowerGate);


	///////////////////////////////////////////////////////////////////////
	// Turn all managable modules off by default

	for (INT i = 0; i < VGXPM_MODULE_COUNT; i++)
	{
		SetModulePower((VGXPM_MODULES)i, VGXPowerOff);
	}


	///////////////////////////////////////////////////////////////////////
	// Enter full power mode by default

	SetVGXPowerManagement(VGXPowerOn);


	if (m_SMISettings.m_bEnablePowerMonitor)
	{
		dwResult = StartPowerThread();
	}

	MESSAGE(MESSAGE_ZONE, (TEXT("-SMI::StartPowerManagement\r\n")));

	return dwResult;
}


///////////////////////////////////////////////////////////////////////////////
// Starts the thread.

DWORD SMI::StartPowerThread()
{
	MESSAGE(MESSAGE_ZONE, (TEXT("+SMI::StartPowerThread\r\n")));

	DWORD dwResult = VGXPM_RET_NOT_SUPPORTED;

#ifdef USE_WATCHDOG

	///////////////////////////////////////////////////////////////////////
	// Activity flag.

	static BOOL bStarted = FALSE;


	if (!bStarted)
	{
		///////////////////////////////////////////////////////////////////////
		// Create a message queue.

		if (m_hPMMessageQueue == NULL)
		{
			MSGQUEUEOPTIONS MsgQueueOptions;
			MsgQueueOptions.dwSize        = sizeof(MsgQueueOptions);
			MsgQueueOptions.dwFlags       = 0;		// default behaviour.
			MsgQueueOptions.dwMaxMessages = 10;		// number of messages in queue.
			MsgQueueOptions.cbMaxMessage  = MESSAGE_SIZE;
			MsgQueueOptions.bReadAccess   = TRUE;	// request read access.

			m_hPMMessageQueue = CreateMsgQueue(
				TEXT("SMI-POWER-MANAGEMENT-MESSAGE-QUEUE-534749AD-3FED-4385-9428-3DAD3ADC492B"),
				&MsgQueueOptions);

			if (m_hPMMessageQueue == NULL)
			{
				MESSAGE(MESSAGE_ZONE, (TEXT("SMI::StartPowerThread: CreateMsgQueue failed (%d)\r\n"), GetLastError()));
				return VGXPM_RET_QUEUE_FAILED;
			}
		}


		///////////////////////////////////////////////////////////////////////
		// Initialize power notification mechanism.

		if (m_hPMNotifications == NULL)
		{
			m_hPMNotifications = RequestPowerNotifications(
				m_hPMMessageQueue,			// Message queue handle.
				PBT_POWERINFOCHANGE);		// Monitor battery status changes.

			if (m_hPMNotifications == NULL)
			{
				MESSAGE(MESSAGE_ZONE, (TEXT("SMI::StartPowerThread: RequestPowerNotifications failed (%d)\r\n"), GetLastError()));
				return VGXPM_RET_NOTIFY_FAILED;
			}
		}


		///////////////////////////////////////////////////////////////////////
		// Create a thread.

		if (m_hPMThread == NULL)
		{
			m_hPMThread = CreateThread(
				NULL,					// Ignored (must be NULL).
				0,						// Stack size (use default).
				PowerManagementThread,	// Thread function.
				this,					// Parameter passed to the thread.
				0,						// Run immediately and use default stack.
				NULL);					// Thread ID is not needed.

			if (m_hPMThread == NULL)
			{
				MESSAGE(MESSAGE_ZONE, (TEXT("SMI::StartPowerThread: CreateThread failed (%d)\r\n"), GetLastError()));
				return VGXPM_RET_THREAD_FAILED;
			}
		}


		///////////////////////////////////////////////////////////////////////
		// Mark the flag as started.

		bStarted = TRUE;
	}

	dwResult = VGXPM_RET_SUCCESS;

#else
	MESSAGE(MESSAGE_ZONE, (TEXT("SMI::StartPowerThread: Watchdog is disabled\r\n")));
#endif

#ifndef USE_POWERHOOK
	MESSAGE(MESSAGE_ZONE, (TEXT("SMI::StartPowerThread: Powerhook is disabled\r\n")));
#endif

	MESSAGE(MESSAGE_ZONE, (TEXT("-SMI::StartPowerThread\r\n")));

	return dwResult;
}


///////////////////////////////////////////////////////////////////////////////
// Resets Power Management counters.

void SMI::ResetPowerManagement()
{
	EnterCriticalSection(&m_PowerCriticalSection);

	MESSAGE(MESSAGE_ZONE, (TEXT("+SMI::ResetPowerManagement\r\n")));

	DWORD dwCurrentTick = GetTickCountSafe();

	// Reset the module last call tick
	for (DWORD i = 0; i < VGXPM_MODULE_COUNT; i++)
		m_PowerInfo[i].dwLastCallTickCount = dwCurrentTick;

	// Reset generic counters
	m_dwPowerOnLastRequested = dwCurrentTick;
	m_dwReducedLastRequested = dwCurrentTick;
	m_dwMinimalLastRequested = dwCurrentTick;

	MESSAGE(MESSAGE_ZONE, (TEXT("-SMI::ResetPowerManageme
上一页 1 2 3 45
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -