blc_cmn.c

针对Intel Xscale PXA255的WinCE boot loader源代码包！极具参考价值！

/******************************************************************************

Module Name:    BAK_cmn.c
Abstract:	Platform independent portion of the backlight driver.

**********************************************************************************/


#include <windows.h>
#include <windev.h>
#include <types.h>
#include "blc_cmn.h"
#include "blc_hw.h"
#include "blc_glob.h"
#include "blreg.h"
#include "xsc1.h"

#define	BLMSG_TRACE	0//1	//commented by hzh

static CRITICAL_SECTION gBLGlobalsCriticalSection;

BOOL	gBLAutoOn = FALSE;
BOOL	gBLState = BLSTATE_ON;
BOOL	gPrevBLState = BLSTATE_OFF;
ULONG	regBLTimeout = DEFAULT_BL_OFFTIMEOUT;
HANDLE	gBLEvents[NUMBER_BL_EVENT];

ULONG	gBLOffTime = INFINITE;

ULONG	gPWMValue = 0xff;

static DWORD WINAPI BacklightThread(void);
static BOOL RunningOnAC(void);
static void ResetBacklightTimeoutNoCS();


//
// Initialize the backlight driver hardware and read default settings from the registry
//
BOOL 
InitializeBacklight(void)
{
	HANDLE  hRequestThread;

	RETAILMSG(BLMSG_TRACE, (TEXT("Backlight Initializing\r\n")));

	InitializeCriticalSection(&gBLGlobalsCriticalSection);

	// Perform all one-time-only hardware initialization
	if (!InitializeBacklightHardware())
	{
		RETAILMSG(BLMSG_TRACE, (TEXT("InitializeBacklight: failed to initialize backlight hardware\r\n")));
		return FALSE;
	}

	// Create the backlight service thread that handles turning off the backlight after a period of inactivity
	hRequestThread = CreateThread((HANDLE) NULL, 0, (LPTHREAD_START_ROUTINE) BacklightThread, NULL, 0,NULL);
	if (hRequestThread == NULL) 
	{
		RETAILMSG(BLMSG_TRACE, (TEXT("InitializeBacklight: failed to create BacklightThread\r\n")));
		return FALSE;
	}
	else
	{
		RETAILMSG(BLMSG_TRACE, (TEXT("InitializeBacklight: created BacklightThread\r\n")));
		CloseHandle(hRequestThread);
	}

	RETAILMSG(BLMSG_TRACE, (TEXT("Backlight Initialized\r\n")));

	return TRUE;
}


// Read the backlight settings the user has set from the control panel
void 
ReadBacklightSettingsFromRegistry(void)
{
	HKEY	hRegKey = INVALID_HANDLE_VALUE;
	DWORD	valueLength;
	DWORD	valueType;
	BOOL	runningOnAC;
	DWORD	temp;

	RETAILMSG(BLMSG_TRACE, (TEXT("+ReadBacklightSettingsFromRegistry\r\n")));

	if (RegOpenKeyEx(HKEY_CURRENT_USER, RK_CONTROLPANEL_BACKLIGHT, 0, 0, &hRegKey) == ERROR_SUCCESS)
	{
		// Use appropriate settings depending upon whether we are using batteries
		runningOnAC = RunningOnAC();

		// Read the backlight OFF timeout value
		valueLength = sizeof(DWORD);
		if (RegQueryValueEx(hRegKey, runningOnAC ? RV_ACOFFTIME : RV_BATOFFTIME, NULL, &valueType, 
			(PBYTE) &regBLTimeout, &valueLength) == ERROR_SUCCESS)
		{
			// Convert OFF timeout to milliseconds (0 = disable)
			RETAILMSG(BLMSG_TRACE, (TEXT("ReadBacklightSettingsFromRegistry: key %s present \r\n"), runningOnAC ? RV_ACOFFTIME : RV_BATOFFTIME));
			RETAILMSG(BLMSG_TRACE, (TEXT("ReadBacklightSettingsFromRegistry: OFF timeout = %d (seconds)\r\n"), regBLTimeout));
			regBLTimeout = (regBLTimeout == 0) ? INFINITE : regBLTimeout * 1000;			
			RETAILMSG(BLMSG_TRACE, (TEXT("ReadBacklightSettingsFromRegistry: OFF timeout = %f (milliseconds)\r\n"), regBLTimeout));
		}
		else
		{
			RETAILMSG(BLMSG_TRACE, (TEXT("ReadBacklightSettingsFromRegistry: key %s not present (using defaults)\r\n"), runningOnAC ? RV_ACOFFTIME : RV_BATOFFTIME));
		}

		// Read the auto-on value
		valueLength = sizeof(DWORD);
		if (RegQueryValueEx(hRegKey, runningOnAC ? RV_ACAUTO : RV_BATAUTO, NULL, &valueType, 
			(PBYTE) &temp, &valueLength) == ERROR_SUCCESS)
		{
			gBLAutoOn = (temp != 0);
		}
		else
		{
			RETAILMSG(BLMSG_TRACE, (TEXT("ReadBacklightSettingsFromRegistry: key %s not present (using defaults)\r\n"), runningOnAC ? RV_ACAUTO : RV_BATAUTO));
		}
			gPWMValue = 0xff;
//			RETAILMSG(0, (TEXT("ReadBacklightSettingsFromRegistry: gPWMValue=0x%x!!!\r\n"), gPWMValue));


		RegCloseKey(hRegKey);
	}

}


void 
ResetBacklightTimeout(void)
{
	RETAILMSG(BLMSG_TRACE, (TEXT("+ResetBacklightTimeout\r\n")));

	EnterCriticalSection(&gBLGlobalsCriticalSection);
	ResetBacklightTimeoutNoCS();
	LeaveCriticalSection(&gBLGlobalsCriticalSection);
	RETAILMSG(BLMSG_TRACE, (TEXT("-ResetBacklightTimeout\r\n")));
}


void 
SetBacklightState(DWORD newState, BOOL invert)
{
	RETAILMSG(BLMSG_TRACE, (TEXT("+SetBacklightState, newState = %s, invert = %s\r\n"), 
		(newState == BLSTATE_OFF) ? TEXT("OFF") : TEXT("ON"),
		invert ? TEXT("TRUE") : TEXT("FALSE")));

	EnterCriticalSection(&gBLGlobalsCriticalSection);
	{
		if (invert)
		{
			// toggle backlight on/off state
			gBLState = (gBLState != BLSTATE_OFF) ?
				 BLSTATE_OFF : BLSTATE_ON;
		}
		else
		{
			gBLState = newState;
		}

		// Turn the actual hardware backlight on, or off
		SetHardwareBacklightState();
		
		// Reset timeouts for turning backlight off automatically
		ResetBacklightTimeoutNoCS();

		// Cause the thread to cycle and notice new timeout settings
		
	
		#if defined(WINCEOSVER_400) || defined(WINCEOSVER_410)
			//SetInterruptEvent((DWORD)gBLEvents[BL_TIMEOUT_EVENT_INDEX]);
			pDriverGlobals->misc.uiBackLightHandle = (DWORD)gBLEvents[BL_TIMEOUT_EVENT_INDEX];
		#else
		  	SetEvent(gBLEvents[BL_TIMEOUT_EVENT_INDEX]);
		#endif  
	
		//SetEvent(gBLEvents[BL_TIMEOUT_EVENT_INDEX]);
	}
	LeaveCriticalSection(&gBLGlobalsCriticalSection);

	RETAILMSG(BLMSG_TRACE, (TEXT("-SetBacklightState\r\n")));
}



static DWORD WINAPI BacklightThread(void)
{
	ULONG timeout = INFINITE;
	ULONG now;
	ULONG threadEventIndex;

	// The backlight should never preempt more noticeable user threads
	//SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_BELOW_NORMAL);
	SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);

	// Create an event the backlight thread will normally be blocked on (backlight off timeout)
	if (!(gBLEvents[BL_TIMEOUT_EVENT_INDEX] = CreateEvent(NULL, FALSE, FALSE, NULL))) 
	{
		RETAILMSG(BLMSG_TRACE, (TEXT("BacklightThread: failed to create backlight event\r\n")));
        return 0;
    	}

	// Create an event that is signaled when the user changes the backlight registry settings via the control panel
	if (!(gBLEvents[BL_REGISTRY_EVENT_INDEX] = CreateEvent(NULL, FALSE, FALSE, EVENTNAME_BACKLIGHTCHANGEEVENT))) 
	{
		RETAILMSG(BLMSG_TRACE, (TEXT("BacklightThread: failed to create backlight registry event\r\n")));
        return 0;
    	}

	// Wait until the system has finished booting
	RETAILMSG(BLMSG_TRACE, (TEXT("BacklightThread: waiting for API ready\r\n")));
	while (!IsAPIReady(SH_WMGR))
	{
		Sleep(100);
	}

	// Force the driver to update itself to reflect the status at boot time.
	SetEvent(gBLEvents[BL_REGISTRY_EVENT_INDEX]);

	// Read the backlight default settings from the registry
	ReadBacklightSettingsFromRegistry();
	//RETAILMSG(0, (TEXT("BacklightThread: gPWMValue=0x%x\r\n"), gPWMValue));

	while (TRUE)	// The backlight thread never exits
	{
		// The backlight thread waits on two events.  One is signaled by the backlight control panel whenever the
		// the user modifies the backlight settings.  The other is set when the user explicitly turns the backlight
		// on or off via the backlight button.  A timeout occurs when it is time to disable the backlight after a
		// period of user inactivity
		
		threadEventIndex = WaitForMultipleObjects(NUMBER_BL_EVENT, gBLEvents, FALSE, timeout) - WAIT_OBJECT_0;

		if (threadEventIndex == BL_REGISTRY_EVENT_INDEX)
		{
			RETAILMSG(BLMSG_TRACE, (TEXT("BacklightThread: registry event signaled\r\n")));
			ReadBacklightSettingsFromRegistry();
			ResetBacklightTimeout();
		}
		else if (threadEventIndex == BL_TIMEOUT_EVENT_INDEX)
			RETAILMSG(BLMSG_TRACE, (TEXT("BacklightThread: off event signaled\r\n")));
		else
			RETAILMSG(BLMSG_TRACE, (TEXT("BacklightThread: timeout occurred\r\n")));

		EnterCriticalSection(&gBLGlobalsCriticalSection);
		{
			now = GetTickCount();
	
			// Figure out how long we need to sleep till our next off timeout. If no
			// new timeout is necessary (we are already in the required OFF state or
			// no timeouts are set) we'll sleep until the registry gets updated.
			timeout = INFINITE;	
			
			// When backlight off time is scheduled or expired.
			// Check if an OFF time is scheduled..
			if (gBLOffTime != INFINITE)
			{
				if (now >= gBLOffTime)	// If we have reached off time
				{
					RETAILMSG(BLMSG_TRACE, (TEXT("BacklightThread: timeout expired, turning off backlight\r\n")));
					gBLState = BLSTATE_OFF;
					SetHardwareBacklightState();	// Turn off the backlight
				}
				else
				{
					RETAILMSG(BLMSG_TRACE, (TEXT("BacklightThread: timeout has not expired, setting new timeout for %dms\r\n"),
						gBLOffTime - now));
					timeout = gBLOffTime - now;	// Next time around, sleep until time to turn off
				}
			}			
		}
		LeaveCriticalSection(&gBLGlobalsCriticalSection);

		RETAILMSG(BLMSG_TRACE, (TEXT("BacklightThread: timeout=%d, gBLOffTime=%d, gBLState=%d\r\n"),
			timeout,gBLOffTime,gBLState));
	}

	// Never reaches here
	return 0;
}

static BOOL RunningOnAC(void)
{
	BOOL			runningOnAC = TRUE;
	
	RETAILMSG(BLMSG_TRACE, (TEXT("-RunningOnAC, AC power is %sconnected\r\n"), runningOnAC ? TEXT("") : TEXT("dis")));

	return runningOnAC;
}


static void ResetBacklightTimeoutNoCS()
{
	// Reset timeout for turning backlight off automatically
	if (regBLTimeout == INFINITE)
	{
		RETAILMSG(BLMSG_TRACE, (TEXT("ResetBacklightTimeoutNoCS: regBLTimeout=INFINITE\r\n")));		
		gBLOffTime = INFINITE;	// Never turn off
	}
	else
	{
		RETAILMSG(BLMSG_TRACE, (TEXT("ResetBacklightTimeoutNoCS: regBLTimeout=%d\r\n"),	regBLTimeout));

		// Set OFF timeout in ON state
		gBLOffTime = (gBLState != BLSTATE_OFF) ?
			(GetTickCount() + regBLTimeout) : INFINITE;
	}

	RETAILMSG(BLMSG_TRACE, (TEXT("ResetBacklightTimeoutNoCS: gBLOffTime=%d\r\n"),
		gBLOffTime));
}