473 lines
13 KiB
C
Executable File
473 lines
13 KiB
C
Executable File
/**
|
||
Copyright Novatek Microelectronics Corp. 2009. All rights reserved.
|
||
|
||
@file DetKey.c
|
||
@ingroup mIPRJAPKeyIO
|
||
|
||
@brief Scan key, modedial
|
||
Scan key, modedial
|
||
|
||
@note Nothing.
|
||
|
||
@date 2009/04/22
|
||
*/
|
||
|
||
/** \addtogroup mIPRJAPKeyIO */
|
||
//@{
|
||
|
||
#include "kwrap/type.h"
|
||
#include "KeyInLog.h"
|
||
#include "GxInput.h"
|
||
#include "DxInput.h"
|
||
#include "GxKey_int.h"
|
||
|
||
//extern volatile BOOL g_bKeyScanResetSleeping;
|
||
|
||
#define KEYSCAN_PWROFF_INIT_STATE 0
|
||
#define KEYSCAN_PWROFF_RELEASE_STATE 1
|
||
#define KEYSCAN_PWROFF_PRESS_STATE 2
|
||
|
||
#define KEYSCAN_PWRKEY_UNKNOWN 0xFFFFFFFF
|
||
#define KEYSCAN_PWRKEY_RELEASED 0
|
||
#define KEYSCAN_PWRKEY_PRESSED 1
|
||
|
||
// -------------------------------------------------------------------
|
||
// Static variables
|
||
// -------------------------------------------------------------------
|
||
static UINT32 g_uiLastKeyStatus = 0;
|
||
static UINT32 g_uiStableKeyStatus = 0;
|
||
//#NT#2010/08/02#Ben Wang -begin
|
||
static UINT32 g_uiFirstKeyInvalidPress = 0;
|
||
static UINT32 g_uiFirstKeyInvalidRelease = 0;
|
||
static UINT32 g_uiFirstKeyInvalidContinue = 0;
|
||
//#NT#2010/08/02#Ben Wang -end
|
||
static UINT32 g_uiSimKeyStatus = 0;
|
||
//#NT#2010/02/23#Ben Wang -begin
|
||
//#NT#Refine code for continue key
|
||
//static UINT32 uiLastStableKeyStatus = 0;
|
||
static UINT32 g_uiLastMDStatus[STATUS_KEY_GROUP_MAX] = {0};
|
||
static UINT32 g_uiStableMDStatus[STATUS_KEY_GROUP_MAX] = {0};
|
||
|
||
|
||
BOOL g_bDumpKey = FALSE;
|
||
|
||
|
||
#if(KEYINLOG_FUNCTION == ENABLE)
|
||
static UINT32 g_uiKeyScanTimerCnt = 0;
|
||
#endif
|
||
|
||
#define KEY_TIMER_CNT 10//10x20=200ms
|
||
#define KEY_CONTINUE_DEBOUNCE 25// 25 x 20=500ms
|
||
|
||
static GX_CALLBACK_PTR g_fpKeyCB = NULL;
|
||
static UINT32 g_uiRepeatCnt = KEY_TIMER_CNT;
|
||
static UINT32 g_uiDebounceCnt = KEY_CONTINUE_DEBOUNCE;
|
||
|
||
|
||
void GxKey_RegCB(GX_CALLBACK_PTR pFuncKeyCB)
|
||
{
|
||
g_fpKeyCB = pFuncKeyCB;
|
||
}
|
||
|
||
void GxKey_SetRepeatInterval(UINT32 RepeatCnt)
|
||
{
|
||
g_uiRepeatCnt = RepeatCnt;
|
||
}
|
||
|
||
void GxKey_SetContDebounce(UINT32 DebounceCnt)
|
||
{
|
||
g_uiDebounceCnt = DebounceCnt;
|
||
}
|
||
|
||
|
||
static void DetKey_ShowKeyName(UINT32 uiKeyCode, CHAR *pStr)
|
||
{
|
||
if (g_bDumpKey == FALSE) {
|
||
return;
|
||
}
|
||
DBG_DUMP("KeyCode 0x%x ", uiKeyCode);
|
||
#if 0
|
||
if (uiKeyCode & FLGKEY_UP) {
|
||
DBG_DUMP("DETKEY %s KEY UP\r\n", pStr);
|
||
}
|
||
if (uiKeyCode & FLGKEY_DOWN) {
|
||
DBG_DUMP("DETKEY %s KEY DOWN\r\n", pStr);
|
||
}
|
||
if (uiKeyCode & FLGKEY_LEFT) {
|
||
DBG_DUMP("DETKEY %s KEY LEFT\r\n", pStr);
|
||
}
|
||
if (uiKeyCode & FLGKEY_RIGHT) {
|
||
DBG_DUMP("DETKEY %s KEY RIGHT\r\n", pStr);
|
||
}
|
||
if (uiKeyCode & FLGKEY_ENTER) {
|
||
DBG_DUMP("DETKEY %s KEY ENTER\r\n", pStr);
|
||
}
|
||
if (uiKeyCode & FLGKEY_MENU) {
|
||
DBG_DUMP("DETKEY %s KEY MENU\r\n", pStr);
|
||
}
|
||
if (uiKeyCode & FLGKEY_DEL) {
|
||
DBG_DUMP("DETKEY %s KEY DEL\r\n", pStr);
|
||
}
|
||
if (uiKeyCode & FLGKEY_MODE) {
|
||
DBG_DUMP("DETKEY %s KEY MODE\r\n", pStr);
|
||
}
|
||
if (uiKeyCode & FLGKEY_ZOOMOUT) {
|
||
DBG_DUMP("DETKEY %s KEY ZOOMOUT\r\n", pStr);
|
||
}
|
||
if (uiKeyCode & FLGKEY_ZOOMIN) {
|
||
DBG_DUMP("DETKEY %s KEY ZOOMIN\r\n", pStr);
|
||
}
|
||
if (uiKeyCode & FLGKEY_SHUTTER1) {
|
||
DBG_DUMP("DETKEY %s KEY SHUTTER1\r\n", pStr);
|
||
}
|
||
if (uiKeyCode & FLGKEY_SHUTTER2) {
|
||
DBG_DUMP("DETKEY %s KEY SHUTTER2\r\n", pStr);
|
||
}
|
||
if (uiKeyCode & FLGKEY_FACEDETECT) {
|
||
DBG_DUMP("DETKEY %s KEY FACEDETECT\r\n", pStr);
|
||
}
|
||
if (uiKeyCode & FLGKEY_MOVIE) {
|
||
DBG_DUMP("DETKEY %s KEY FLGKEY_MOVIE\r\n", pStr);
|
||
}
|
||
if (uiKeyCode & FLGKEY_I) {
|
||
DBG_DUMP("DETKEY %s KEY FLGKEY_I\r\n", pStr);
|
||
}
|
||
#endif
|
||
}
|
||
|
||
void GxKey_RaiseSimKey(UINT32 key)
|
||
{
|
||
g_uiSimKeyStatus |= key;
|
||
}
|
||
|
||
void GxKey_Init(void)
|
||
{
|
||
DrvKey_Init();
|
||
}
|
||
|
||
void GxKey_DetNormalKey(void)
|
||
{
|
||
UINT32 uiCurKeyStatus, uiTempKeyStatus;
|
||
UINT32 uiKeyChanged;
|
||
UINT32 uiKeyPressed, uiKeyReleased, uiKeyContinue;
|
||
static UINT32 uiContineKeyDebounce = 0;
|
||
static UINT32 uiContinueKeyCount = 0 ;
|
||
//#NT#2010/08/02#Ben Wang -begin
|
||
static BOOL bIsFirstPressKey = TRUE;
|
||
static BOOL bIsFirstReleaseKey = TRUE;
|
||
//#NT#2010/08/02#Ben Wang -end
|
||
|
||
/*
|
||
<09>ϥΤ覡 :
|
||
|
||
<09><>Key:
|
||
1. <20>ק<EFBFBD> #define KEYINLOG_FUNCTION ENABLE
|
||
2. Update F/W <20><>, <20>N Log <20>s<EFBFBD>U<EFBFBD><55> (Ex:KeyLog.log)
|
||
3. <20><><EFBFBD><EFBFBD> KlTxtToHex KeyLog.log <20><><EFBFBD><EFBFBD> TransLog.hex
|
||
4. <20>H<EFBFBD><48><EFBFBD><EFBFBD><EFBFBD>R<EFBFBD>H<EFBFBD><48>
|
||
|
||
<09><>Key:
|
||
1. <20>ק<EFBFBD> #define KEYINLOG_FUNCTION ENABLE
|
||
2. <20>Ѱ<EFBFBD><D1B0>b KeyScanTsk.c <20><><EFBFBD><EFBFBD> //Keylog_EnableRuningKeyLog(); <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
3. Copy TransLog.hex <20><> SD Card <20><><EFBFBD>ڥؿ<DAA5>
|
||
4. <20>}<7D><>
|
||
*/
|
||
|
||
#if(KEYINLOG_FUNCTION == ENABLE)
|
||
/*------------------------------------------------------------*
|
||
* *
|
||
* KeyIn Log Play Section *
|
||
* *
|
||
*------------------------------------------------------------*/
|
||
g_uiKeyScanTimerCnt ++;
|
||
if (Keylog_IsRuningKeyLog()) {
|
||
uiCurKeyStatus =
|
||
uiTempKeyStatus = Keylog_Play_DetKey();
|
||
//#NT#2009/04/07#Niven Cho -begin
|
||
//#NT#Added., Stop Play Record after playing finished.
|
||
Keylog_ScanRecordEnd();
|
||
//#NT#2009/04/07#Niven Cho -end
|
||
}
|
||
/*------------------------------------------------------------*
|
||
* End Section
|
||
*------------------------------------------------------------*/
|
||
else
|
||
#endif
|
||
{
|
||
uiCurKeyStatus =
|
||
uiTempKeyStatus = DrvKey_DetNormalKey();
|
||
|
||
if(g_uiSimKeyStatus){
|
||
g_uiLastKeyStatus |= g_uiSimKeyStatus;
|
||
uiCurKeyStatus |= g_uiSimKeyStatus;
|
||
uiTempKeyStatus |= g_uiSimKeyStatus;
|
||
g_uiSimKeyStatus = 0;
|
||
}
|
||
}
|
||
|
||
uiCurKeyStatus &= g_uiLastKeyStatus;
|
||
|
||
uiKeyChanged = uiCurKeyStatus ^ g_uiStableKeyStatus;
|
||
|
||
uiKeyPressed = uiKeyChanged & uiCurKeyStatus;
|
||
uiKeyReleased = uiKeyChanged & (~uiCurKeyStatus);
|
||
//#NT#2010/02/23#Ben Wang -begin
|
||
//#NT#Refine code for continue key
|
||
//uiKeyContinue = uiCurKeyStatus & g_uiStableKeyStatus & uiLastStableKeyStatus;
|
||
//uiLastStableKeyStatus = g_uiStableKeyStatus & ~(uiKeyContinue);
|
||
//ContinueKey is equal to StableKey ?
|
||
uiKeyContinue = uiCurKeyStatus;
|
||
//#NT#2010/02/23#Ben Wang -end
|
||
g_uiStableKeyStatus = uiCurKeyStatus;
|
||
g_uiLastKeyStatus = uiTempKeyStatus;
|
||
#if(KEYINLOG_FUNCTION == ENABLE)
|
||
/*------------------------------------------------------------*
|
||
* *
|
||
* KeyIn Log Section *
|
||
* *
|
||
*------------------------------------------------------------*/
|
||
if (Keylog_IsRecordingKeyLog()) {
|
||
Keylog_Record_DetKey(uiCurKeyStatus);
|
||
}
|
||
/*------------------------------------------------------------*
|
||
* End Section
|
||
*------------------------------------------------------------*/
|
||
#endif
|
||
|
||
|
||
if (uiKeyPressed) {
|
||
DetKey_ShowKeyName(uiKeyPressed, "PRESS");
|
||
//#NT#2010/08/02#Ben Wang -begin
|
||
if (bIsFirstPressKey) {
|
||
bIsFirstPressKey = FALSE;
|
||
uiKeyPressed &= ~ g_uiFirstKeyInvalidPress;
|
||
}
|
||
//#NT#2010/08/02#Ben Wang -end
|
||
if (g_fpKeyCB) {
|
||
g_fpKeyCB(KEY_CB_NORMAL, KEY_PRESS, uiKeyPressed);
|
||
}
|
||
}
|
||
|
||
if (uiKeyReleased) {
|
||
uiContineKeyDebounce = 0;
|
||
DetKey_ShowKeyName(uiKeyReleased, "RELEASE");
|
||
//#NT#2010/08/02#Ben Wang -begin
|
||
if (bIsFirstReleaseKey) {
|
||
bIsFirstReleaseKey = FALSE;
|
||
uiKeyReleased &= ~ g_uiFirstKeyInvalidRelease;
|
||
}
|
||
//#NT#2010/08/02#Ben Wang -end
|
||
if (g_fpKeyCB) {
|
||
g_fpKeyCB(KEY_CB_NORMAL, KEY_RELEASE, uiKeyReleased);
|
||
}
|
||
}
|
||
if (uiKeyContinue) {
|
||
//#NT#2010/02/23#Ben Wang -begin
|
||
//#NT#Refine code for continue key
|
||
if (uiContineKeyDebounce < g_uiDebounceCnt) {
|
||
uiContineKeyDebounce++;
|
||
} else {
|
||
uiContinueKeyCount++;
|
||
}
|
||
if ((uiContineKeyDebounce == g_uiDebounceCnt) && (uiContinueKeyCount == g_uiRepeatCnt)) {
|
||
uiContinueKeyCount = 0;
|
||
|
||
DetKey_ShowKeyName(uiKeyContinue, "CONTINUE");
|
||
//#NT#2010/08/02#Ben Wang -begin
|
||
//it will always be "first continue" before first released key
|
||
if (bIsFirstReleaseKey) {
|
||
uiKeyContinue &= ~ g_uiFirstKeyInvalidContinue;
|
||
}
|
||
//#NT#2010/08/02#Ben Wang -end
|
||
if (g_fpKeyCB) {
|
||
g_fpKeyCB(KEY_CB_NORMAL, KEY_CONTINUE, uiKeyContinue);
|
||
}
|
||
|
||
}
|
||
//#NT#2010/02/23#Ben Wang -end
|
||
}
|
||
|
||
//-----------------------------------------------------------------------------------------------
|
||
// Start to set flag
|
||
//-----------------------------------------------------------------------------------------------
|
||
|
||
}
|
||
|
||
void GxKey_DetPwrKey(void)
|
||
{
|
||
static UINT32 uiPowerKey = KEYSCAN_PWRKEY_UNKNOWN;
|
||
static UINT32 uiPWRState = KEYSCAN_PWROFF_INIT_STATE;
|
||
static UINT32 uiDxPwrKeyFlag = 0;
|
||
UINT32 uiPwrKey = DrvKey_DetPowerKey();
|
||
//DBG_DUMP("^YPwrKey = %08x\r\n", uiPwrKey);
|
||
|
||
// Detect power off key
|
||
if (uiPwrKey) {
|
||
uiDxPwrKeyFlag = uiPwrKey;
|
||
// Debounce
|
||
if (uiPowerKey == KEYSCAN_PWRKEY_PRESSED) {
|
||
if (uiPWRState == KEYSCAN_PWROFF_RELEASE_STATE) {
|
||
uiPWRState = KEYSCAN_PWROFF_PRESS_STATE;
|
||
if (g_fpKeyCB) {
|
||
g_fpKeyCB(KEY_CB_POWER, KEY_PRESS, uiDxPwrKeyFlag);
|
||
}
|
||
} else if (uiPWRState == KEYSCAN_PWROFF_PRESS_STATE) {
|
||
if (g_fpKeyCB) {
|
||
g_fpKeyCB(KEY_CB_POWER, KEY_CONTINUE, uiDxPwrKeyFlag);
|
||
}
|
||
}
|
||
} else {
|
||
uiPowerKey = KEYSCAN_PWRKEY_PRESSED;
|
||
}
|
||
} else {
|
||
// Debounce
|
||
if (uiPowerKey == KEYSCAN_PWRKEY_RELEASED) {
|
||
if (uiPWRState == KEYSCAN_PWROFF_INIT_STATE) {
|
||
uiPWRState = KEYSCAN_PWROFF_RELEASE_STATE;
|
||
} else if (uiPWRState == KEYSCAN_PWROFF_PRESS_STATE) {
|
||
uiPWRState = KEYSCAN_PWROFF_RELEASE_STATE;
|
||
if (g_fpKeyCB) {
|
||
g_fpKeyCB(KEY_CB_POWER, KEY_RELEASE, uiDxPwrKeyFlag);
|
||
}
|
||
}
|
||
} else {
|
||
uiPowerKey = KEYSCAN_PWRKEY_RELEASED;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
void GxKey_DetStatusKey(void)
|
||
{
|
||
UINT32 uiCurMDStatus, uiTempMDStatus, uiMDChanged, uiModedial;
|
||
UINT32 Group;
|
||
|
||
|
||
for (Group = STATUS_KEY_GROUP1; Group < STATUS_KEY_GROUP_MAX; Group++) {
|
||
//#NT#2009/03/19#Elvis Chuang - begin
|
||
#if 0//(KEYINLOG_FUNCTION == ENABLE)
|
||
/*------------------------------------------------------------*
|
||
* *
|
||
* KeyIn Log Play Section *
|
||
* *
|
||
*------------------------------------------------------------*/
|
||
if (Keylog_IsRuningKeyLog()) {
|
||
uiCurMDStatus = Keylog_Play_DetModedial();
|
||
}
|
||
/*------------------------------------------------------------*
|
||
* End Section
|
||
*------------------------------------------------------------*/
|
||
else
|
||
#endif
|
||
{
|
||
uiCurMDStatus = DrvKey_DetStatusKey((STATUS_KEY_GROUP)Group);
|
||
}
|
||
//#NT#2009/03/19#Elvis Chuang - end
|
||
|
||
uiTempMDStatus = uiCurMDStatus;
|
||
uiCurMDStatus &= g_uiLastMDStatus[Group];
|
||
uiMDChanged = uiCurMDStatus ^ g_uiStableMDStatus[Group];
|
||
uiModedial = uiMDChanged & uiCurMDStatus;
|
||
|
||
g_uiStableMDStatus[Group] = uiCurMDStatus;
|
||
g_uiLastMDStatus[Group] = uiTempMDStatus;
|
||
if (uiModedial != 0) {
|
||
#if 0//(KEYINLOG_FUNCTION == ENABLE)
|
||
/*------------------------------------------------------------*
|
||
* *
|
||
* KeyIn Log Section *
|
||
* *
|
||
*------------------------------------------------------------*/
|
||
if (Keylog_IsRecordingKeyLog()) {
|
||
Keylog_Record_DetModedial(uiModedial);
|
||
}
|
||
/*------------------------------------------------------------*
|
||
* End Section
|
||
*------------------------------------------------------------*/
|
||
#endif
|
||
if (g_fpKeyCB) {
|
||
g_fpKeyCB(KEY_CB_STATUS, Group, uiModedial);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void GxKey_ForceStatusKeyDet(STATUS_KEY_GROUP Group)
|
||
{
|
||
UINT32 uiCurMDStatus;
|
||
|
||
uiCurMDStatus = DrvKey_DetStatusKey(Group);
|
||
if (uiCurMDStatus != 0) {
|
||
g_uiStableMDStatus[Group] = g_uiLastMDStatus[Group] = uiCurMDStatus;
|
||
if (g_fpKeyCB) {
|
||
g_fpKeyCB(KEY_CB_STATUS, (UINT32)Group, uiCurMDStatus);
|
||
}
|
||
}
|
||
|
||
}
|
||
//#NT#2010/08/02#Ben Wang -begin
|
||
void GxKey_SetFirstKeyInvalid(KEY_STATUS status, UINT32 uiKey)
|
||
{
|
||
switch (status) {
|
||
case KEY_PRESS:
|
||
g_uiFirstKeyInvalidPress = uiKey;
|
||
break;
|
||
|
||
case KEY_RELEASE:
|
||
g_uiFirstKeyInvalidRelease = uiKey;
|
||
break;
|
||
|
||
case KEY_CONTINUE:
|
||
g_uiFirstKeyInvalidContinue = uiKey;
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
|
||
}
|
||
//#NT#2010/08/02#Ben Wang -end
|
||
void Key_OnSystem(int cmd)
|
||
{
|
||
switch (cmd) {
|
||
case SYSTEM_CMD_POWERON:
|
||
if (g_fpKeyCB) {
|
||
(*g_fpKeyCB)(SYSTEM_CB_CONFIG, 0, 0);
|
||
}
|
||
//#NT#2010/08/02#Ben Wang -begin
|
||
GxKey_DetStatusKey();
|
||
//#NT#2010/08/02#Ben Wang -end
|
||
break;
|
||
|
||
case SYSTEM_CMD_POWEROFF:
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
|
||
UINT32 GxKey_GetData(GX_KEY_DATA attribute)
|
||
{
|
||
switch (attribute) {
|
||
case GXKEY_NORMAL_KEY:
|
||
return (DrvKey_DetPowerKey() | DrvKey_DetNormalKey());
|
||
case GXKEY_STS_KEY1:
|
||
return DrvKey_DetStatusKey(STATUS_KEY_GROUP1);
|
||
case GXKEY_STS_KEY2:
|
||
return DrvKey_DetStatusKey(STATUS_KEY_GROUP2);
|
||
case GXKEY_STS_KEY3:
|
||
return DrvKey_DetStatusKey(STATUS_KEY_GROUP3);
|
||
case GXKEY_STS_KEY4:
|
||
return DrvKey_DetStatusKey(STATUS_KEY_GROUP4);
|
||
case GXKEY_STS_KEY5:
|
||
return DrvKey_DetStatusKey(STATUS_KEY_GROUP5);
|
||
default:
|
||
DBG_ERR("[GxKey_GetData]no this attribute");
|
||
return 0;
|
||
}
|
||
|
||
}
|
||
|
||
|