kswitch.cpp

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

/* Copyright ?1999-2001 Intel Corp.  */
/*

THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.
Copyright (c) 1995-1998  Microsoft Corporation

*/

//
//

#include <windows.h>
#include <ceddk.h>
#include <nkintr.h>
#include <oalintr.h>

#include <keybddr.h>
#include <keybdpdd.h>

#include "kswitch.hpp"
#include "drv_glob.h"

#include "xsc1.h"
#include "keyswintr.h"





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



//	There is really only one physical keyboard supported by the system.
KeySwitch *v_pkeysw;

static KEY_STATE_FLAGS  v_KeyStateToggled;

volatile INTC_REGS	*v_pICReg = NULL;
volatile GPIO_REGS	*v_pGPIOReg = NULL;
volatile PMRC_REGS	*v_pPMRCReg = NULL;
HANDLE	h_intEvent;

static int keyNum=2;	// hzh
static ULONG keyList[2][2]={	
{GPIO_7, 1},
{GPIO_27, 2}
};


PVOID MapRegisterMemory(unsigned size, char *str, PVOID pVirtualAddress)
{
	PVOID ptr;
    	
	ptr = VirtualAlloc(0,size,MEM_RESERVE,PAGE_NOACCESS);
	if (ptr == NULL) {
		ERRORMSG(1,(TEXT("VirtualAlloc failed! %s : size=0x%x, (0x%x)\r\n"),str,size,GetLastError()));
		return(0);
	}

	if (!VirtualCopy((PVOID)ptr,(PVOID)pVirtualAddress,size,PAGE_READWRITE|PAGE_NOCACHE)) {
		ERRORMSG(1,(TEXT("VirtualCopy failed! \r\n")));
		return(0);
	}  
	return((PVOID)((PBYTE)ptr));
}


/***********************
KeybdPdd_PowerHandler
************************/
void 
WINAPI 
KeybdPdd_PowerHandler(BOOL bOff)
{
	//volatile unsigned char *ptmpGRERx;
	//====================================================
	
	RETAILMSG(0,(TEXT("+KeybdPdd_PowerHandler: bOff=%d\r\n"),bOff));
	//====================================================
	if (!bOff)
	{
		if (v_pICReg==NULL)
		{
			v_pICReg = (volatile INTC_REGS *) MapRegisterMemory(0x400, 
					(char *)TEXT("KeybdPdd_PowerHandler:INTC_BASE_U_VIRTUAL"),
					(PVOID)INTC_BASE_U_VIRTUAL);
		}
				
		if (v_pGPIOReg==NULL)
		{
			v_pGPIOReg = (volatile GPIO_REGS *) MapRegisterMemory(0x400, 
					(char *)TEXT("KeybdPdd_PowerHandler:GPIO_BASE_U_VIRTUAL"),
					(PVOID)GPIO_BASE_U_VIRTUAL);
		}	
		// hzh
		v_pGPIOReg->GPDR_x &= ~( GPIO_7 | GPIO_27);
		APBUTT_BTNS_RISING_EDGE_ENABLE(v_pGPIOReg);		
		
		v_pICReg->icmr |= INTC_GPIO80_2;	// enable GPIO interrupt
		
		RETAILMSG(0,(TEXT("============KeybdPdd_PowerHandler resume==================\r\n")));
		
			}	
	else
	{



		if (v_pPMRCReg==NULL)
		{
			v_pPMRCReg = (volatile PMRC_REGS *) MapRegisterMemory(0x400, 
					(char *)TEXT("KeybdPdd_PowerHandler:PWR_BASE_U_VIRTUAL"),
					(PVOID)PWR_BASE_U_VIRTUAL);
		} 
		
		// power management wakeup enable GPIO7,10,11,13,14
		v_pPMRCReg->pwer |= GPIO_7;		// hzh
		
		if (v_pPMRCReg)
		{
			VirtualFree((void *)v_pPMRCReg, 0x400, MEM_RELEASE);
			v_pPMRCReg = NULL;
		}
		if (v_pICReg)
		{
			VirtualFree((void *)v_pICReg, 0x400, MEM_RELEASE);
			v_pICReg = NULL;
		}
		if (v_pGPIOReg)
		{
			VirtualFree((void *)v_pGPIOReg, 0x400, MEM_RELEASE);
			v_pGPIOReg = NULL;
		}
		RETAILMSG(0,(TEXT("============KeybdPdd_PowerHandler suspend=======================\r\n")));
	}	
	
    	return;
}


/***********************
KeybdPdd_InitializeDriverEx
************************/
BOOL 
WINAPI 
KeybdPdd_InitializeDriverEx(PFN_KEYBD_EVENT_CALLBACK_EX	pfnKeybdEventCallbackEx)
{
   	return TRUE;
}


/***********************
KeybdPdd_GetEventEx
************************/
int 
WINAPI 
KeybdPdd_GetEventEx(UINT32 VKeyBuf[16],
                    UINT32 ScanCodeBuf[16],
                    KEY_STATE_FLAGS KeyStateFlagsBuf[16]
                    )
{
	INT	cEvents = 0;
	
	KEY_STATE_FLAGS	KeyStateFlags;

	ULONG	ulGPLR0;
	ULONG	ulGPLR0prev;

	ULONG	ulChangedBit;
	int	nCnt, i;

	//RETAILMSG(0,(TEXT("====================+wait for 15ms until PINT port become stable==================\r\n")));
	// Wait 15ms until PINT port become stable.	
	nCnt=5;		
	while(nCnt > 0)
	{
		Sleep(3);	// 3ms
		
		ulGPLR0=(v_pGPIOReg->GPLR_x & KEYSW_PINS_MASK);
		
					
		if (nCnt==5)		
		{
			ulGPLR0prev=ulGPLR0;
			nCnt--;
		}
		else
		{
			if (ulGPLR0prev==ulGPLR0)			
				nCnt--;		
			else
			{				
				//RETAILMSG(0, (TEXT("GetRequestedPINT: under debounce time, return FALSE!!! \r\n")));
				return(FALSE);
			}
		}
	}
	
	
	//RETAILMSG(0,(TEXT("====================-wait for 15ms until PINT port become stable==================\r\n")));
	
	
	ulChangedBit = ulGPLR0 & KEYSW_PINS_MASK;	// reserve b[7:19-21:23-26]
	//RETAILMSG(0, (TEXT("KeybdPdd_GetEventEx: ulGPLR0=0x%8x \r\n"), ulChangedBit));
	
	cEvents=0;
	for (i=0; i<keyNum; i++)
	{
		KeyStateFlags = (ulGPLR0 & keyList[i][0]) ? KeyStateDownFlag : 0 ;
		if (ulChangedBit & keyList[i][0])
		{			
//			RETAILMSG(0, (TEXT("KeybdPdd_GetEventEx: keyList[%d][0]=0x%8x \r\n"), i, keyList[i][0]));
				
//////////////////////////end///////////////////////////////////////////////////////

			switch(keyList[i][1])
			{	

				case 1:	// BUTT_1, refer platform.reg
				keybd_event(VK_LWIN, 0, KEYEVENTF_SILENT, 0);								
				keybd_event(0xC1, 0, KEYEVENTF_SILENT, 0);	
				keybd_event(0xC1, 0, KEYEVENTF_KEYUP | KEYEVENTF_SILENT, 0);			
				keybd_event(VK_LWIN, 0, KEYEVENTF_KEYUP | KEYEVENTF_SILENT, 0);	
				//return 0;							
//				RETAILMSG(0,(TEXT("KeybdPdd_GetEventEx: cEvents:0  ScanCodeBuf: 0, VKeyBuf: 0xc1\r\n")));
				//****************************************************************************************
				
				//RETAILMSG(0,(TEXT("$$$$$$$$$$$$$$$$$$$$$$$$---Button 1---$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\r\n")));
				//****************************************************************************************
				break;
				case 2:	// BUTT_2
				keybd_event(VK_LWIN, 0, KEYEVENTF_SILENT, 0);
				keybd_event(0xC2, 0, KEYEVENTF_SILENT, 0);
				keybd_event(0xC2, 0, KEYEVENTF_KEYUP | KEYEVENTF_SILENT, 0);
				keybd_event(VK_LWIN, 0, KEYEVENTF_KEYUP | KEYEVENTF_SILENT, 0);
				//return 0;
//				RETAILMSG(0,(TEXT("KeybdPdd_GetEventEx: cEvents:0  ScanCodeBuf: 0, VKeyBuf:0xc2\r\n")));
				//****************************************************************************************
				
				//RETAILMSG(0,(TEXT("$$$$$$$$$$$$$$$$$$$$$$$$---Button 2---$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\r\n")));
				//****************************************************************************************
				break;
				case 3:	// BUTT_3
				keybd_event(VK_LWIN, 0, KEYEVENTF_SILENT, 0);
				keybd_event(0xC3, 0, KEYEVENTF_SILENT, 0);
				keybd_event(0xC3, 0, KEYEVENTF_KEYUP | KEYEVENTF_SILENT, 0);
				keybd_event(VK_LWIN, 0, KEYEVENTF_KEYUP | KEYEVENTF_SILENT, 0);				
				//return 0;				
//				RETAILMSG(0,(TEXT("KeybdPdd_GetEventEx: cEvents:0  ScanCodeBuf: 0, VKeyBuf: 0xc3\r\n")));
				//****************************************************************************************
			
				//RETAILMSG(0,(TEXT("$$$$$$$$$$$$$$$$$$$$$$$$---Button 3---$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\r\n")));
				//****************************************************************************************
				break;
				case 4:	// BUTT_4
				keybd_event(VK_LWIN, 0, KEYEVENTF_SILENT, 0);
				keybd_event(0xC4, 0, KEYEVENTF_SILENT, 0);
				keybd_event(0xC4, 0, KEYEVENTF_KEYUP | KEYEVENTF_SILENT, 0);
				keybd_event(VK_LWIN, 0, KEYEVENTF_KEYUP | KEYEVENTF_SILENT, 0);
				break;
						
				default:
				ERRORMSG( 1, (TEXT("Error invalid PINT number.\r\n")));
				break;
			}
		}
	}
   
	return(cEvents);
}



/***********************
KeybdPdd_ToggleKeyNotification
************************/
void 
WINAPI 
KeybdPdd_ToggleKeyNotification(KEY_STATE_FLAGS	KeyStateFlags)
{
   	//	RETAILMSG(0,(TEXT("KeybdPdd_ToggleKeyNotification\r\n")));
   	v_KeyStateToggled = KeyStateFlags;
   	
   	return;
}



/***********************
KeybdPdd_KeyStateToggled
************************/
KEY_STATE_FLAGS 
WINAPI 
KeybdPdd_KeyStateToggled()
{
   	//RETAILMSG(0,(TEXT("KeybdPdd_KeyStateToggled\r\n")));
   	return v_KeyStateToggled;
}


BOOL KeybdIstLoop(HANDLE hevIntrKeybd);

/***********************
KeySwitch::IsrThreadProc
************************/
BOOL 
KeySwitch::IsrThreadProc()
{

   	KeybdIstLoop(m_hevInterrupt); 
    	return 0;
}


/***********************
KeySwitchIsrThread
************************/
DWORD 
KeySwitchIsrThread(KeySwitch	*pkeysw)
{
   	//============================================================
	
//   	RETAILMSG(0,(TEXT("+KeySwitchIsrThread:\r\n")));
   	pkeysw->IsrThreadProc();
//   	RETAILMSG(0,(TEXT("-KeySwitchIsrThread:\r\n")));
   	//================================================================
   	return 0;
}


/***********************
IsKeyPress
************************/
BOOL IsKeyPress()
{

	if(NO_BTN_PRESSED(v_pGPIOReg))
		return FALSE;
	else
		return TRUE;
		
}	  	



/***********************
KeySwitch::IsrThreadStart
************************/
BOOL 
KeySwitch::IsrThreadStart()
{
   	HANDLE	hthrd;
	
	//===============================================================

	m_hevInterrupt = CreateEvent(NULL,FALSE,FALSE,NULL);
	
	if (m_hevInterrupt != NULL) 
   	{
   		h_intEvent = m_hevInterrupt;
      		//RETAILMSG(0,(TEXT("IsrThreadStart: InterruptInitialize\r\n")));
      		if (!InterruptInitialize(SYSINTR_KEYBOARD,m_hevInterrupt,NULL,0)) 
      		{
      			RETAILMSG(0,(TEXT("IsrThreadStart: InterruptInitialize Failed!!!\r\n")));
		}
	}
	//===============================================================
   	
   	hthrd = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)KeySwitchIsrThread,this,0,NULL);

   	return TRUE;
}


/***********************
KeySwitch::Initialize
************************/
BOOL 
KeySwitch::Initialize(void)
{
	//RETAILMSG(0, (TEXT("KeySwitch::Initialize \r\n")));
	KeybdDriverPowerHandler(0);
   	return TRUE;
}