keymatrix.cpp

来自「SAMSUNG S3C6410 CPU BSP for winmobile6」· C++ 代码 · 共 1,287 行 · 第 1/3 页

	{KCODE_TYPE_NORMAL , 0x0012 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0013 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0014 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0015 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0016 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0017 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0018 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0019 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x001a , 0, 0},
	{KCODE_TYPE_NORMAL , 0x001b , 0, 0},
	{KCODE_TYPE_NORMAL , 0x001c , 0, 0},
	{KCODE_TYPE_NORMAL , 0x001d , 0, 0},
	{KCODE_TYPE_NORMAL , 0x001e , 0, 0},
	{KCODE_TYPE_NORMAL , 0x001f , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0020 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0021 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0022 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0023 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0024 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0025 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0026 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0027 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0028 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0029 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x002a , 0, 0},
	{KCODE_TYPE_NORMAL , 0x002b , 0, 0},
	{KCODE_TYPE_NORMAL , 0x002c , 0, 0},
	{KCODE_TYPE_NORMAL , 0x002d , 0, 0},
	{KCODE_TYPE_NORMAL , 0x002e , 0, 0},
	{KCODE_TYPE_NORMAL , 0x002f , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0030 , 0, 0},	
	{KCODE_TYPE_NORMAL , 0x0031 , 0, 0},	
	{KCODE_TYPE_NORMAL , 0x0032 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0033 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0034 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0035 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0036 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0037 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0038 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0039 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x003a , 0, 0},
	{KCODE_TYPE_NORMAL , 0x003b , 0, 0},
	{KCODE_TYPE_NORMAL , 0x003c , 0, 0},
	{KCODE_TYPE_NORMAL , 0x003d , 0, 0},
	{KCODE_TYPE_NORMAL , 0x003e , 0, 0},
	{KCODE_TYPE_NORMAL , 0x003f , 0, 0},
};
#else
struct KSTATE KeyChange[SIZE_KEY];
struct KCODE KeyCode[SIZE_KEY] =
{
	{KCODE_TYPE_NORMAL , 0x0000 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0001 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0002 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0003 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0004 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0005 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0006 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0007 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0008 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x0009 , 0, 0},
	{KCODE_TYPE_NORMAL , 0x000a , 0, 0},
	{KCODE_TYPE_NORMAL , 0x000b , 0, 0},
	{KCODE_TYPE_NORMAL , 0x000c , 0, 0},
	{KCODE_TYPE_NORMAL , 0x000d , 0, 0},
	{KCODE_TYPE_NORMAL , 0x000e , 0, 0},
	{KCODE_TYPE_NORMAL , 0x000f , 0, 0}
};
#endif
#endif
/*****************************************************************************
*	Function Name : VarInit, AreAllKeysUp
*	Function Desc  : Miscellaneous Function
*
*/
void VarInit(void)
{
	int i;

	for( i=0; i<SIZE_KEY; i++)
	{
		KeyChange[i].Mask = 0;
		KeyChange[i].Cnt  = 0;
	}
}

BOOL AreAllKeysUp(void)
{
	DWORD tmp = 0, tmp1 = 0, i;

	for(i=0;i<SIZE_COLS;i++)
	{
		tmp |= KeyState[i];
		tmp1 |= ChangeState[i];
	}

	return (tmp || tmp1)? FALSE:TRUE;
}
/****************************************************************************/

/*****************************************************************************
*	Function Name : _KScan_ProcState
*	Function Desc  : Handle KeyMatrix State
*
*/
DWORD _KScan_ProcState(int kidx, int idx, PDWORD key, PBOOL press)
{
	int val, i;
	DWORD count = 0;
	int mask;

	val = ChangeState[kidx];
	for(i=0;i<SIZE_BITS;i++)
	{
		mask = 1<<i;

		if( (KeyState[kidx] & mask) && (KeyCode[idx].Type == KCODE_TYPE_SL) && (KeyCode[idx].Fin == 0) )
		{
			if( (KeyCode[idx].TimeoutCnt == CNT_LONGKEY) )
			{
				// key down
				*key++ = KeyCode[idx].Scan | SCAN_EXT;
				*press++ = FALSE;
				// key up
				*key++ = KeyCode[idx].Scan | SCAN_EXT;
				*press++ = TRUE;
				count+=2;

				KeyCode[idx].TimeoutCnt = 0;
				KeyCode[idx].Fin = TRUE;
				//RETAILMSG(1, (TEXT(">>> KSCAN:LONG[%d] - %d, key - 0x%x\r\n"), idx, KeyCode[idx].Scan,*key));
			}
			else
			{
				KeyCode[idx].TimeoutCnt++;
			}
		}

		// state chaned
		if( val & mask )
		{
			// Need to check wheater the key changed really
			if( KeyChange[idx].Cnt == 0 ) // in counting
			{
				KeyChange[idx].Cnt = CNT_VALIDKEY;
				KeyChange[idx].Mask = ( KeyState[kidx] & mask )? 0: mask;
			}
			else
			{
			// checked key state
				if( KeyChange[idx].Mask != (KeyState[kidx] & mask) )
				{
					if( --KeyChange[idx].Cnt == 0 )
					{
						if( KeyChange[idx].Mask == 0 )
						{
// Key UP
							if( KeyCode[idx].Type == KCODE_TYPE_NORMAL )
							{
								*key++ = KeyCode[idx].Scan;
								*press++ = TRUE;
								count++;

								//RETAILMSG(1, (TEXT(">>> KSCAN:UP  [%d] - %d\r\n"), idx, KeyCode[idx].Scan));
							}
							else
							{
								// KCODE_TYPE_SL
								if( KeyCode[idx].Fin == FALSE )
								{
									// key down
									*key++ = KeyCode[idx].Scan;
									*press++ = FALSE;
									// key up
									*key++ = KeyCode[idx].Scan;
									*press++ = TRUE;
									count+=2;

									KeyCode[idx].Fin = TRUE;

									//RETAILMSG(1, (TEXT(">>> KSCAN:SHORT[%d] - %d\r\n"), idx, KeyCode[idx].Scan));
								}
							}

							KeyState[kidx] &= ~mask;
						}
						else
						{
// Key Down
							if( KeyCode[idx].Type == KCODE_TYPE_NORMAL )
							{
								*key++ = KeyCode[idx].Scan;
								*press++ = FALSE;
								count++;

								//RETAILMSG(1, (TEXT(">>> KSCAN:DOWN[%d] - %d\r\n"), idx, KeyCode[idx].Scan));
							}
							else
							{
								// KCODE_TYPE_SL
								KeyCode[idx].TimeoutCnt = 0;
								KeyCode[idx].Fin = FALSE;
							}

							KeyState[kidx] |= mask;
						}
					}
			    }
			    else
				{
					KeyChange[idx].Cnt = 0;
					RETAILMSG(0, (TEXT(">>> KSCAN:Must be not occurred[%d] %x, %llx, %llx\r\n"), idx,KeyChange[idx].Mask,KeyState,mask));
				}
			}
		}
		else
		{
			if( KeyChange[idx].Cnt ) // in counting
			{
				KeyChange[idx].Cnt = 0;
				RETAILMSG(0, (TEXT(">>> KSCAN:Canceled [%d]\r\n"), idx));
			}
		}
		idx++;
	}
#if defined(project_wpc)
	if (count && v_hevtKeyPressed)
	{
		// Signal shell to disable SIP.
		SetEvent(v_hevtKeyPressed);
	}
#endif
	return count;
}
/****************************************************************************/

/*****************************************************************************
*	Function Name : KScan_ProcIO
*	Function Desc  : Scan code
*			         Read KEYIF
*
*/
void KScan_ProcIO(void)
{
	int i;

	// KBC_0 ~ KBC_7
	for(i = 0 ; i < SIZE_COLS; i++)
	{
		KEYIF_Column_Set(0x0);
		// select a column
		KEYIF_Column_Bitset(false,i);
		Sleep(1);
		ChangeState[i] = KeyState[i]^((~ KEYIF_Row_Read())&0xff);
        //RETAILMSG(1, (TEXT("[KSCAN](%d)-%x\r\n"), i, ChangeState[i]));
		Sleep(1);
	}
	KEYIF_Column_Set(0x0);
}
/****************************************************************************/

/*****************************************************************************
*	Function Name : KScan_SetINTMode
*	Function Desc  : Initialize the H/W
*
*/
void KScan_SetINTMode(void)
{
	//RETAILMSG(1,(TEXT("+Select all column\r\n")));
	// select all column - Set Keypad column GPIO to output(low)
	GPIO_CtrlHandler(ENUM_COL, ENUM_AUXFUNC);
//	GPIO_PuEnable(ENUM_COL, false);

	KEYIF_Column_Set(0x0);

	// configure - Set Keypad row GPIO to [Key PAD ROW]
	GPIO_CtrlHandler(ENUM_ROW, ENUM_AUXFUNC);
//	GPIO_PuEnable(ENUM_ROW, false);

	// unmask the key interrupt
	KEYIF_Status_Clear();
}
/****************************************************************************/

/*****************************************************************************
*	Function Name : KeybdPdd_ToggleKeyNotification
*	Function Desc  : Toggle Key
*
*/
void WINAPI KeybdPdd_ToggleKeyNotification(KEY_STATE_FLAGS  KeyStateFlags)
{
	unsigned int fLights;

	DEBUGMSG(1, (TEXT("KeybdPdd_ToggleKeyNotification\r\n")));

	fLights = 0;
	if (KeyStateFlags & KeyShiftCapitalFlag)
	{
		fLights |= 0x04;
	}

	if (KeyStateFlags & KeyShiftNumLockFlag)
	{
		fLights |= 0x2;
	}
	/*
	Keyboard lights is disabled once driver is installed because the
	PS2 controller sends back a response which goes to the IST and corrupts
	the interface.  When we figure out how to disable the PS2 response we
	can re-enable the lights routine below
	*/

	return;
}
/****************************************************************************/

/*****************************************************************************
*	Function Name : IsrThreadProc
*	Function Desc  : IST of KeyBD D/D
*		Create IST
*		Wait for Event according to the KEYPAD INT
*		KScan_SetIOMode() : Handle H/W
*		KScan_ProcIO() :
*		_KScan_ProcState() :
*
*/
extern UINT v_uiPddId;
extern PFN_KEYBD_EVENT v_pfnKeybdEvent;

BOOL KeyMatrix::IsrThreadProc()
{
	DWORD dwPriority;
	DWORD i, step;

	DWORD   rguiScanCode[SIZE_KEY];
	BOOL    rgfKeyUp[SIZE_KEY];
	UINT    cEvents;
	DWORD ret;
	DWORD timeout;
	HANDLE gEventIntr;
	DWORD irq, sysintr;

	ReadRegDWORD( TEXT("HARDWARE\\DEVICEMAP\\KEYBD"), _T("Priority256"), &dwPriority );
	if(dwPriority == 0)
	{
		dwPriority = 145;
	}

	RETAILMSG( INIT_MSG, (TEXT("+[KEYBD]IsrThreadProc\r\n")));
	// update the IST priority
	CeSetThreadPriority(GetCurrentThread(), (int)dwPriority);

	irq = IRQ_KEYPAD;
	if (!KernelIoControl(IOCTL_HAL_REQUEST_SYSINTR, &irq, sizeof(UINT32), &sysintr, sizeof(UINT32), NULL))
	{
		ERRORMSG( 1, (TEXT("ERROR: Failed to request the IRQ_KEY sysintr.\r\n")));
		sysintr = SYSINTR_UNDEFINED;
		return(FALSE);
	}

	gEventIntr = CreateEvent(NULL, FALSE, FALSE, NULL);
	if( NULL == gEventIntr )
	{
		ERRORMSG( 1, (TEXT("Event is not created\r\n")));
		return(FALSE);
	}

	if( InterruptInitialize(sysintr, gEventIntr, NULL, 0) == FALSE )
	{
		ERRORMSG( 1, (TEXT("interrupt is not initialized\n\r")));
		return(FALSE);
	}


	timeout = INFINITE;
	RETAILMSG( INIT_MSG, (TEXT("+[KEYBD]Enter Infinite Loop\r\n")));
	while(1)	// INFINITE LOOP ____________________________________________________________________
	{
		ret = WaitForSingleObject(gEventIntr, timeout); // Wait for Interrupt Event ________________________

		if( ret == WAIT_OBJECT_0 )
		{
			//RETAILMSG( 1,(TEXT("Object : WAIT_OBJECT_0\r\n")));
			timeout = TIME_KEYSCAN;
		}

		// WAIT_TIMEOUT

		if(g_bHandleWakeup)
		{
			PowerPolicyNotify(PPN_POWERBUTTONPRESSED, 0);
			g_bHandleWakeup=FALSE;
			RETAILMSG(1,(TEXT("IsrThreadProc: WakeUp\r\n")));
		}
		// Clear Pressed/Released Interrupt
		KEYIF_Status_Clear();
		// Read the Matrix
		KScan_ProcIO();

		for( i=0, step=0; i< SIZE_COLS; i++, step+=SIZE_ROWS)
		{
			cEvents = _KScan_ProcState( i, step, rguiScanCode, rgfKeyUp);

			if( cEvents )
			{
				for (UINT iEvent = 0; iEvent < cEvents; ++iEvent)
				{
					v_pfnKeybdEvent(v_uiPddId, rguiScanCode[iEvent], rgfKeyUp[iEvent]);
					//RETAILMSG(1,(TEXT("PddID : %x, ScanCode : %x, KeyUp : %d\r\n"),v_uiPddId, rguiScanCode[iEvent], rgfKeyUp[iEvent]));
				}
			}
		}

		if( TRUE == AreAllKeysUp() )
		{
			RETAILMSG(0,(TEXT("Key all up\r\n")));
			timeout = INFINITE;
		}
		InterruptDone(sysintr);
	}// INFINITE LOOP ____________________________________________________________________
}
/****************************************************************************/

/*****************************************************************************
*	Function Name : KBDISRThread
*	Function Desc  : Keybd IST Wrapper
*		Call KeyMatrix.IsrThreadProc()
*
*/