From 8e4bff4cab0ddac6060645b0715210484d02ff40 Mon Sep 17 00:00:00 2001 From: Yuval Adam <_@yuv.al> Date: Wed, 30 Aug 2017 08:25:59 +0000 Subject: Initial file dump from open source release --- drivers/input/touchscreen/msg2233/mstar_drv_main.c | 3379 ++++++++++++++++++++ 1 file changed, 3379 insertions(+) create mode 100644 drivers/input/touchscreen/msg2233/mstar_drv_main.c (limited to 'drivers/input/touchscreen/msg2233/mstar_drv_main.c') diff --git a/drivers/input/touchscreen/msg2233/mstar_drv_main.c b/drivers/input/touchscreen/msg2233/mstar_drv_main.c new file mode 100644 index 00000000..c67dddd6 --- /dev/null +++ b/drivers/input/touchscreen/msg2233/mstar_drv_main.c @@ -0,0 +1,3379 @@ +//////////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) 2006-2014 MStar Semiconductor, Inc. +// All rights reserved. +// +// Unless otherwise stipulated in writing, any and all information contained +// herein regardless in any format shall remain the sole proprietary of +// MStar Semiconductor Inc. and be kept in strict confidence +// (??MStar Confidential Information??) by the recipient. +// Any unauthorized act including without limitation unauthorized disclosure, +// copying, use, reproduction, sale, distribution, modification, disassembling, +// reverse engineering and compiling of the contents of MStar Confidential +// Information is unlawful and strictly prohibited. MStar hereby reserves the +// rights to any and all damages, losses, costs and expenses resulting therefrom. +// +//////////////////////////////////////////////////////////////////////////////// + +/** + * + * @file mstar_drv_main.c + * + * @brief This file defines the interface of touch screen + * + * + */ + +/*=============================================================*/ +// INCLUDE FILE +/*=============================================================*/ + +#include "mstar_drv_main.h" +#include "mstar_drv_utility_adaption.h" +#include "mstar_drv_platform_porting_layer.h" +#include "mstar_drv_ic_fw_porting_layer.h" + +#ifdef CONFIG_ENABLE_HOTKNOT +#include "mstar_drv_hotknot.h" +#include "mstar_drv_hotknot_queue.h" +#endif //CONFIG_ENABLE_HOTKNOT + +#ifdef CONFIG_ENABLE_JNI_INTERFACE +#include "mstar_drv_jni_interface.h" +#endif //CONFIG_ENABLE_JNI_INTERFACE + +/*=============================================================*/ +// CONSTANT VALUE DEFINITION +/*=============================================================*/ + + +/*=============================================================*/ +// EXTERN VARIABLE DECLARATION +/*=============================================================*/ + +extern FirmwareInfo_t g_FirmwareInfo; +extern u8 g_LogModePacket[DEBUG_MODE_PACKET_LENGTH]; +extern u16 g_FirmwareMode; + +#ifdef CONFIG_ENABLE_GESTURE_WAKEUP +extern u32 g_GestureWakeupMode[2]; + +#ifdef CONFIG_ENABLE_GESTURE_DEBUG_MODE +extern u8 g_LogGestureDebug[128]; +extern u8 g_GestureDebugFlag; +extern u8 g_GestureDebugMode; + +extern struct input_dev *g_InputDevice; +#endif //CONFIG_ENABLE_GESTURE_DEBUG_MODE + +#ifdef CONFIG_ENABLE_GESTURE_INFORMATION_MODE +extern u32 g_LogGestureInfor[GESTURE_WAKEUP_INFORMATION_PACKET_LENGTH]; +#endif //CONFIG_ENABLE_GESTURE_INFORMATION_MODE +#endif //CONFIG_ENABLE_GESTURE_WAKEUP + +extern u8 g_ChipType; + +#ifdef CONFIG_ENABLE_ITO_MP_TEST +#if defined(CONFIG_ENABLE_TOUCH_DRIVER_FOR_MUTUAL_IC) +extern TestScopeInfo_t g_TestScopeInfo; +#endif //CONFIG_ENABLE_TOUCH_DRIVER_FOR_MUTUAL_IC +#endif //CONFIG_ENABLE_ITO_MP_TEST + +/*=============================================================*/ +// LOCAL VARIABLE DEFINITION +/*=============================================================*/ + +static u16 _gDebugReg[MAX_DEBUG_REGISTER_NUM] = {0}; +static u16 _gDebugRegValue[MAX_DEBUG_REGISTER_NUM] = {0}; +static u32 _gDebugRegCount = 0; + +static u8 _gDebugCmdArgu[MAX_DEBUG_COMMAND_ARGUMENT_NUM] = {0}; +static u16 _gDebugCmdArguCount = 0; +static u32 _gDebugReadDataSize = 0; + +static u8 *_gPlatformFwVersion = NULL; // internal use firmware version for MStar + +#ifdef CONFIG_ENABLE_ITO_MP_TEST +static ItoTestMode_e _gItoTestMode = 0; +#endif //CONFIG_ENABLE_ITO_MP_TEST + +#ifdef CONFIG_ENABLE_GESTURE_WAKEUP + +#ifdef CONFIG_ENABLE_GESTURE_INFORMATION_MODE +static u32 _gLogGestureCount = 0; +static u8 _gLogGestureInforType = 0; +#endif //CONFIG_ENABLE_GESTURE_INFORMATION_MODE + +#endif //CONFIG_ENABLE_GESTURE_WAKEUP + +static u32 _gIsUpdateComplete = 0; + +u8 *_gFwVersion = NULL; // customer firmware version + +static u32 _gFeatureSupportStatus = 0; + +static struct proc_dir_entry *_gProcClass = NULL; +static struct proc_dir_entry *_gProcMsTouchScreenMsg20xx = NULL; +static struct proc_dir_entry *_gProcDevice = NULL; + +static const struct file_operations _gProcChipType = { + .read = DrvMainProcfsChipTypeRead, + .write = DrvMainProcfsChipTypeWrite, +}; + +static const struct file_operations _gProcFirmwareData = { + .read = DrvMainProcfsFirmwareDataRead, + .write = DrvMainProcfsFirmwareDataWrite, +}; + +static const struct file_operations _gProcApkFirmwareUpdate = { + .read = DrvMainProcfsFirmwareUpdateRead, + .write = DrvMainProcfsFirmwareUpdateWrite, +}; + +static const struct file_operations _gProcCustomerFirmwareVersion = { + .read = DrvMainProcfsCustomerFirmwareVersionRead, + .write = DrvMainProcfsCustomerFirmwareVersionWrite, +}; + +static const struct file_operations _gProcPlatformFirmwareVersion = { + .read = DrvMainProcfsPlatformFirmwareVersionRead, + .write = DrvMainProcfsPlatformFirmwareVersionWrite, +}; + +static const struct file_operations _gProcDeviceDriverVersion = { + .read = DrvMainProcfsDeviceDriverVersionRead, + .write = DrvMainProcfsDeviceDriverVersionWrite, +}; + +static const struct file_operations _gProcSdCardFirmwareUpdate = { + .read = DrvMainProcfsSdCardFirmwareUpdateRead, + .write = DrvMainProcfsSdCardFirmwareUpdateWrite, +}; + +static const struct file_operations _gProcFirmwareDebug = { + .read = DrvMainProcfsFirmwareDebugRead, + .write = DrvMainProcfsFirmwareDebugWrite, +}; + +static const struct file_operations _gProcFirmwareSetDebugValue = { + .read = DrvMainProcfsFirmwareSetDebugValueRead, + .write = DrvMainProcfsFirmwareSetDebugValueWrite, +}; + +static const struct file_operations _gProcFirmwareSmBusDebug = { + .read = DrvMainProcfsFirmwareSmBusDebugRead, + .write = DrvMainProcfsFirmwareSmBusDebugWrite, +}; + +static const struct file_operations _gProcFirmwareSetDQMemValue = { + .read = DrvMainProcfsFirmwareSetDQMemValueRead, + .write = DrvMainProcfsFirmwareSetDQMemValueWrite, +}; + +#ifdef CONFIG_ENABLE_ITO_MP_TEST +static const struct file_operations _gProcMpTest = { + .read = DrvMainProcfsMpTestRead, + .write = DrvMainProcfsMpTestWrite, +}; + +static const struct file_operations _gProcMpTestLog = { + .read = DrvMainProcfsMpTestLogRead, + .write = DrvMainProcfsMpTestLogWrite, +}; + +static const struct file_operations _gProcMpTestFailChannel = { + .read = DrvMainProcfsMpTestFailChannelRead, + .write = DrvMainProcfsMpTestFailChannelWrite, +}; + +static const struct file_operations _gProcMpTestScope = { + .read = DrvMainProcfsMpTestScopeRead, + .write = DrvMainProcfsMpTestScopeWrite, +}; +#endif //CONFIG_ENABLE_ITO_MP_TEST + + +static const struct file_operations _gProcFirmwareMode = { + .read = DrvMainProcfsFirmwareModeRead, + .write = DrvMainProcfsFirmwareModeWrite, +}; + +static const struct file_operations _gProcFirmwareSensor = { + .read = DrvMainProcfsFirmwareSensorRead, + .write = DrvMainProcfsFirmwareSensorWrite, +}; + +static const struct file_operations _gProcFirmwarePacketHeader = { + .read = DrvMainProcfsFirmwarePacketHeaderRead, + .write = DrvMainProcfsFirmwarePacketHeaderWrite, +}; + + +static const struct file_operations _gProcQueryFeatureSupportStatus = { + .read = DrvMainProcfsQueryFeatureSupportStatusRead, + .write = DrvMainProcfsQueryFeatureSupportStatusWrite, +}; + +static const struct file_operations _gProcChangeFeatureSupportStatus = { + .read = DrvMainProcfsChangeFeatureSupportStatusRead, + .write = DrvMainProcfsChangeFeatureSupportStatusWrite, +}; + +#ifdef CONFIG_ENABLE_GESTURE_WAKEUP +static const struct file_operations _gProcGestureWakeupMode = { + .read = DrvMainProcfsGestureWakeupModeRead, + .write = DrvMainProcfsGestureWakeupModeWrite, +}; +#ifdef CONFIG_ENABLE_GESTURE_DEBUG_MODE +static const struct file_operations _gProcGestureDebugMode = { + .read = DrvMainProcfsGestureDebugModeRead, + .write = DrvMainProcfsGestureDebugModeWrite, +}; +#endif //CONFIG_ENABLE_GESTURE_DEBUG_MODE +#ifdef CONFIG_ENABLE_GESTURE_INFORMATION_MODE +static const struct file_operations _gProcGestureInforMode = { + .read = DrvMainProcfsGestureInforModeRead, + .write = DrvMainProcfsGestureInforModeWrite, +}; +#endif //CONFIG_ENABLE_GESTURE_INFORMATION_MODE +#endif //CONFIG_ENABLE_GESTURE_WAKEUP + +#ifdef CONFIG_ENABLE_COUNT_REPORT_RATE +static const struct file_operations _gProcReportRate = { + .read = DrvMainProcfsReportRateRead, + .write = DrvMainProcfsReportRateWrite, +}; +#endif //CONFIG_ENABLE_COUNT_REPORT_RATE + +#ifdef CONFIG_ENABLE_GLOVE_MODE +static const struct file_operations _gProcGloveMode= { + .read = DrvMainProcfsGloveModeRead, + .write = DrvMainProcfsGloveModeWrite, +}; + +static const struct file_operations _gProcOpenGloveMode= { + .read = DrvMainProcfsOpenGloveModeRead, +// .write = DrvMainProcfsOpenGloveModeWrite, +}; + +static const struct file_operations _gProcCloseGloveMode= { + .read = DrvMainProcfsCloseGloveModeRead, +// .write = DrvMainProcfsCloseGloveModeWrite, +}; +#endif //CONFIG_ENABLE_GLOVE_MODE + +#ifdef CONFIG_ENABLE_JNI_INTERFACE +static const struct file_operations _gProcJniMethod = { + .read = MsgToolRead, + .write = MsgToolWrite, + .unlocked_ioctl = MsgToolIoctl, + .compat_ioctl = MsgToolIoctl, +}; +#endif //CONFIG_ENABLE_JNI_INTERFACE + + +#ifdef CONFIG_ENABLE_HOTKNOT +struct mutex g_HKMutex; +extern struct mutex g_QMutex; +#endif //CONFIG_ENABLE_HOTKNOT + +/*=============================================================*/ +// GLOBAL VARIABLE DEFINITION +/*=============================================================*/ + +//u32 SLAVE_I2C_ID_DBBUS = (0xC4>>1); //0x62 // for MSG21XX/MSG21XXA/MSG26XXM/MSG28XX +u32 SLAVE_I2C_ID_DBBUS = (0xB2>>1); //0x59 // for MSG22XX +u32 SLAVE_I2C_ID_DWI2C = (0x4C>>1); //0x26 + + +u16 FIRMWARE_MODE_UNKNOWN_MODE = 0xFFFF; +u16 FIRMWARE_MODE_DEMO_MODE = 0xFFFF; +u16 FIRMWARE_MODE_DEBUG_MODE = 0xFFFF; +u16 FIRMWARE_MODE_RAW_DATA_MODE = 0xFFFF; + +struct kset *g_TouchKSet = NULL; +struct kobject *g_TouchKObj = NULL; +u8 g_IsSwitchModeByAPK = 0; + + +u8 IS_GESTURE_WAKEUP_ENABLED = 0; +u8 IS_GESTURE_DEBUG_MODE_ENABLED = 0; +u8 IS_GESTURE_INFORMATION_MODE_ENABLED = 0; +u8 IS_GESTURE_WAKEUP_MODE_SUPPORT_64_TYPES_ENABLED = 0; + +u8 IS_TOUCH_DRIVER_DEBUG_LOG_ENABLED = CONFIG_ENABLE_TOUCH_DRIVER_DEBUG_LOG; +u8 IS_FIRMWARE_DATA_LOG_ENABLED = CONFIG_ENABLE_FIRMWARE_DATA_LOG; + + +#ifdef CONFIG_ENABLE_GESTURE_WAKEUP +#ifdef CONFIG_ENABLE_GESTURE_DEBUG_MODE +struct kset *g_GestureKSet = NULL; +struct kobject *g_GestureKObj = NULL; +#endif //CONFIG_ENABLE_GESTURE_DEBUG_MODE +#endif //CONFIG_ENABLE_GESTURE_WAKEUP + +#ifdef CONFIG_ENABLE_SEGMENT_READ_FINGER_TOUCH_DATA +u16 g_FwPacketDataAddress = 0; +u16 g_FwPacketFlagAddress = 0; +u8 g_FwSupportSegment = 0; +#endif //CONFIG_ENABLE_SEGMENT_READ_FINGER_TOUCH_DATA + +#ifdef CONFIG_ENABLE_COUNT_REPORT_RATE +u32 g_IsEnableReportRate = 0; +u32 g_InterruptCount = 0; +u32 g_ValidTouchCount = 0; +u32 g_InterruptReportRate = 0; +u32 g_ValidTouchReportRate = 0; + +struct timeval g_StartTime; +#endif //CONFIG_ENABLE_COUNT_REPORT_RATE + +#ifdef CONFIG_ENABLE_GLOVE_MODE +u8 g_IsEnableGloveMode = 0; +#endif //CONFIG_ENABLE_GLOVE_MODE + +u8 g_FwData[MAX_UPDATE_FIRMWARE_BUFFER_SIZE][1024]; +u32 g_FwDataCount = 0; + +u8 g_IsHotknotEnabled = 0; +u8 g_IsBypassHotknot = 0; +u8 g_IsHotknotAlive = 0; + + +/*=============================================================*/ +// LOCAL FUNCTION DEFINITION +/*=============================================================*/ + +static s32 _DrvMainCreateProcfsDirEntry(void); +#ifdef CONFIG_ENABLE_HOTKNOT +static s32 _DrvMainHotknotRegistry(void); +#endif //CONFIG_ENABLE_HOTKNOT + +/*=============================================================*/ +// GLOBAL FUNCTION DEFINITION +/*=============================================================*/ + +//------------------------------------------------------------------------------// + +ssize_t DrvMainProcfsChipTypeRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nLength = 0; + + DBG("*** %s() ***\n", __func__); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + + nLength = sprintf(pBuffer, "%d", g_ChipType); + + *pPos += nLength; + + return nLength; +} + +ssize_t DrvMainProcfsChipTypeWrite(struct file *pFile, const char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + DBG("*** %s() ***\n", __func__); + +// g_ChipType = DrvIcFwLyrGetChipType(); + + return nCount; +} + +ssize_t DrvMainProcfsFirmwareDataRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + DBG("*** %s() g_FwDataCount = %d ***\n", __func__, g_FwDataCount); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + + *pPos += g_FwDataCount; + + return g_FwDataCount; +} + +ssize_t DrvMainProcfsFirmwareDataWrite(struct file *pFile, const char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nNum = nCount / 1024; + u32 nRemainder = nCount % 1024; + u32 i; + + DBG("*** %s() ***\n", __func__); + + if (nNum > 0) // nCount >= 1024 + { + for (i = 0; i < nNum; i ++) + { + memcpy(g_FwData[g_FwDataCount], pBuffer+(i*1024), 1024); + + g_FwDataCount ++; + } + + if (nRemainder > 0) // Handle special firmware size like MSG22XX(48.5KB) + { + DBG("nRemainder = %d\n", nRemainder); + + memcpy(g_FwData[g_FwDataCount], pBuffer+(i*1024), nRemainder); + + g_FwDataCount ++; + } + } + else // nCount < 1024 + { + if (nCount > 0) + { + memcpy(g_FwData[g_FwDataCount], pBuffer, nCount); + + g_FwDataCount ++; + } + } + + DBG("*** g_FwDataCount = %d ***\n", g_FwDataCount); + + if (pBuffer != NULL) + { + DBG("*** buf[0] = %c ***\n", pBuffer[0]); + } + + return nCount; +} + +ssize_t DrvMainProcfsFirmwareUpdateRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nLength = 0; + + DBG("*** %s() ***\n", __func__); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + + nLength = sprintf(pBuffer, "%d", _gIsUpdateComplete); + + DBG("*** _gIsUpdateComplete = %d ***\n", _gIsUpdateComplete); + + *pPos += nLength; + + return nLength; +} + +ssize_t DrvMainProcfsFirmwareUpdateWrite(struct file *pFile, const char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + DrvPlatformLyrDisableFingerTouchReport(); + + DBG("*** %s() g_FwDataCount = %d ***\n", __func__, g_FwDataCount); + + if (0 != DrvIcFwLyrUpdateFirmware(g_FwData, EMEM_ALL)) + { + _gIsUpdateComplete = 0; + DBG("Update FAILED\n"); + } + else + { + _gIsUpdateComplete = 1; + DBG("Update SUCCESS\n"); + } + + DrvPlatformLyrEnableFingerTouchReport(); + + return nCount; +} + +ssize_t DrvMainProcfsCustomerFirmwareVersionRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nLength = 0; + + u16 nMajor = 0, nMinor = 0; + + DrvIcFwLyrGetCustomerFirmwareVersion(&nMajor, &nMinor, &_gFwVersion); + + DBG("*** %s() _gFwVersion = %s ***\n", __func__, _gFwVersion); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + + nLength = sprintf(pBuffer, "%s\n", _gFwVersion); + + *pPos += nLength; + + return nLength; +} + +ssize_t DrvMainProcfsCustomerFirmwareVersionWrite(struct file *pFile, const char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u16 nMajor = 0, nMinor = 0; + + DrvIcFwLyrGetCustomerFirmwareVersion(&nMajor, &nMinor, &_gFwVersion); + + DBG("*** %s() _gFwVersion = %s ***\n", __func__, _gFwVersion); + + return nCount; +} + +ssize_t DrvMainProcfsPlatformFirmwareVersionRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nLength = 0; + + DBG("*** %s() _gPlatformFwVersion = %s ***\n", __func__, _gPlatformFwVersion); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + + nLength = sprintf(pBuffer, "%s\n", _gPlatformFwVersion); + + *pPos += nLength; + + return nLength; +} + +ssize_t DrvMainProcfsPlatformFirmwareVersionWrite(struct file *pFile, const char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + DrvIcFwLyrGetPlatformFirmwareVersion(&_gPlatformFwVersion); + + DBG("*** %s() _gPlatformFwVersion = %s ***\n", __func__, _gPlatformFwVersion); + + return nCount; +} + +ssize_t DrvMainProcfsDeviceDriverVersionRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nLength = 0; + + DBG("*** %s() ***\n", __func__); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + + nLength = sprintf(pBuffer, "%s", DEVICE_DRIVER_RELEASE_VERSION); + + *pPos += nLength; + + return nLength; +} + +ssize_t DrvMainProcfsDeviceDriverVersionWrite(struct file *pFile, const char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + DBG("*** %s() ***\n", __func__); + + return nCount; +} + +ssize_t DrvMainProcfsSdCardFirmwareUpdateRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u16 nMajor = 0, nMinor = 0; + u32 nLength = 0; + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + + DrvIcFwLyrGetCustomerFirmwareVersion(&nMajor, &nMinor, &_gFwVersion); + + DBG("*** %s() _gFwVersion = %s ***\n", __func__, _gFwVersion); + + nLength = sprintf(pBuffer, "%s\n", _gFwVersion); + + *pPos += nLength; + + return nLength; +} + +ssize_t DrvMainProcfsSdCardFirmwareUpdateWrite(struct file *pFile, const char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + char *pValid = NULL; + char *pTmpFilePath = NULL; + char szFilePath[100] = {0}; + + DBG("*** %s() ***\n", __func__); + DBG("pBuffer = %s\n", pBuffer); + + if (pBuffer != NULL) + { + pValid = strstr(pBuffer, ".bin"); + + if (pValid) + { + pTmpFilePath = strsep((char **)&pBuffer, "."); + + DBG("pTmpFilePath = %s\n", pTmpFilePath); + + strcat(szFilePath, pTmpFilePath); + strcat(szFilePath, ".bin"); + + DBG("szFilePath = %s\n", szFilePath); + + if (0 != DrvFwCtrlUpdateFirmwareBySdCard(szFilePath)) + { + DBG("Update FAILED\n"); + } + else + { + DBG("Update SUCCESS\n"); + } + } + else + { + DBG("The file type of the update firmware bin file is not a .bin file.\n"); + } + } + else + { + DBG("The file path of the update firmware bin file is NULL.\n"); + } + + return nCount; +} + +ssize_t DrvMainProcfsFirmwareDebugRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 i, nLength = 0; + u8 nBank, nAddr; + u16 szRegData[MAX_DEBUG_REGISTER_NUM] = {0}; + u8 szOut[MAX_DEBUG_REGISTER_NUM*25] = {0}, szValue[10] = {0}; + + DBG("*** %s() ***\n", __func__); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + + DbBusEnterSerialDebugMode(); + DbBusStopMCU(); + DbBusIICUseBus(); + DbBusIICReshape(); + mdelay(100); + + for (i = 0; i < _gDebugRegCount; i ++) + { + szRegData[i] = RegGet16BitValue(_gDebugReg[i]); + } + + DbBusIICNotUseBus(); + DbBusNotStopMCU(); + DbBusExitSerialDebugMode(); + + for (i = 0; i < _gDebugRegCount; i ++) + { + nBank = (_gDebugReg[i] >> 8) & 0xFF; + nAddr = _gDebugReg[i] & 0xFF; + + DBG("reg(0x%02X,0x%02X)=0x%04X\n", nBank, nAddr, szRegData[i]); + + strcat(szOut, "reg("); + sprintf(szValue, "0x%02X", nBank); + strcat(szOut, szValue); + strcat(szOut, ","); + sprintf(szValue, "0x%02X", nAddr); + strcat(szOut, szValue); + strcat(szOut, ")="); + sprintf(szValue, "0x%04X", szRegData[i]); + strcat(szOut, szValue); + strcat(szOut, "\n"); + } + + nLength = sprintf(pBuffer, "%s\n", szOut); + + *pPos += nLength; + + return nLength; +} + +ssize_t DrvMainProcfsFirmwareDebugWrite(struct file *pFile, const char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 i; + char *pCh; + char *pData = NULL; + + DBG("*** %s() ***\n", __func__); + + if (pBuffer != NULL) + { + DBG("*** pBuffer[0] = %c ***\n", pBuffer[0]); + DBG("*** pBuffer[1] = %c ***\n", pBuffer[1]); + DBG("*** pBuffer[2] = %c ***\n", pBuffer[2]); + DBG("*** pBuffer[3] = %c ***\n", pBuffer[3]); + DBG("*** pBuffer[4] = %c ***\n", pBuffer[4]); + DBG("*** pBuffer[5] = %c ***\n", pBuffer[5]); + + DBG("nCount = %d\n", (int)nCount); + + pData = kmalloc(nCount, GFP_KERNEL); + if (!pData) + { + return -ENOMEM; + } + + if (copy_from_user(pData, pBuffer, nCount)) + { + DBG("copy_from_user() failed\n"); + + kfree(pData); + return -EFAULT; + } + + i = 0; + + while ((pCh = strsep((char **)&pData, " ,")) && (i < MAX_DEBUG_REGISTER_NUM)) + { + DBG("pCh = %s\n", pCh); + + _gDebugReg[i] = DrvCommonConvertCharToHexDigit(pCh, strlen(pCh)); + + DBG("_gDebugReg[%d] = 0x%04X\n", i, _gDebugReg[i]); + i ++; + } + _gDebugRegCount = i; + + DBG("_gDebugRegCount = %d\n", _gDebugRegCount); + + kfree(pData); + } + + return nCount; +} + +ssize_t DrvMainProcfsFirmwareSetDebugValueRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 i, nLength = 0; + u8 nBank, nAddr; + u16 szRegData[MAX_DEBUG_REGISTER_NUM] = {0}; + u8 szOut[MAX_DEBUG_REGISTER_NUM*25] = {0}, szValue[10] = {0}; + + DBG("*** %s() ***\n", __func__); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + + DbBusEnterSerialDebugMode(); + DbBusStopMCU(); + DbBusIICUseBus(); + DbBusIICReshape(); + mdelay(100); + + for (i = 0; i < _gDebugRegCount; i ++) + { + szRegData[i] = RegGet16BitValue(_gDebugReg[i]); + } + + DbBusIICNotUseBus(); + DbBusNotStopMCU(); + DbBusExitSerialDebugMode(); + + for (i = 0; i < _gDebugRegCount; i ++) + { + nBank = (_gDebugReg[i] >> 8) & 0xFF; + nAddr = _gDebugReg[i] & 0xFF; + + DBG("reg(0x%02X,0x%02X)=0x%04X\n", nBank, nAddr, szRegData[i]); + + strcat(szOut, "reg("); + sprintf(szValue, "0x%02X", nBank); + strcat(szOut, szValue); + strcat(szOut, ","); + sprintf(szValue, "0x%02X", nAddr); + strcat(szOut, szValue); + strcat(szOut, ")="); + sprintf(szValue, "0x%04X", szRegData[i]); + strcat(szOut, szValue); + strcat(szOut, "\n"); + } + + nLength = sprintf(pBuffer, "%s\n", szOut); + + *pPos += nLength; + + return nLength; +} + +ssize_t DrvMainProcfsFirmwareSetDebugValueWrite(struct file *pFile, const char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 i, j, k; + char *pCh; + char *pData = NULL; + + DBG("*** %s() ***\n", __func__); + + if (pBuffer != NULL) + { + DBG("*** pBuffer[0] = %c ***\n", pBuffer[0]); + DBG("*** pBuffer[1] = %c ***\n", pBuffer[1]); + + DBG("nCount = %d\n", (int)nCount); + + pData = kmalloc(nCount, GFP_KERNEL); + if (!pData) + { + return -ENOMEM; + } + + if (copy_from_user(pData, pBuffer, nCount)) + { + DBG("copy_from_user() failed\n"); + + kfree(pData); + return -EFAULT; + } + + i = 0; + j = 0; + k = 0; + + while ((pCh = strsep((char **)&pData, " ,")) && (i < 2)) + { + DBG("pCh = %s\n", pCh); + + if ((i%2) == 0) + { + _gDebugReg[j] = DrvCommonConvertCharToHexDigit(pCh, strlen(pCh)); + DBG("_gDebugReg[%d] = 0x%04X\n", j, _gDebugReg[j]); + j ++; + } + else // (i%2) == 1 + { + _gDebugRegValue[k] = DrvCommonConvertCharToHexDigit(pCh, strlen(pCh)); + DBG("_gDebugRegValue[%d] = 0x%04X\n", k, _gDebugRegValue[k]); + k ++; + } + + i ++; + } + _gDebugRegCount = j; + + DBG("_gDebugRegCount = %d\n", _gDebugRegCount); + + DbBusEnterSerialDebugMode(); + DbBusStopMCU(); + DbBusIICUseBus(); + DbBusIICReshape(); + mdelay(100); + + for (i = 0; i < _gDebugRegCount; i ++) + { + RegSet16BitValue(_gDebugReg[i], _gDebugRegValue[i]); + DBG("_gDebugReg[%d] = 0x%04X, _gDebugRegValue[%d] = 0x%04X\n", i, _gDebugReg[i], i , _gDebugRegValue[i]); // add for debug + } + + DbBusIICNotUseBus(); + DbBusNotStopMCU(); + DbBusExitSerialDebugMode(); + + kfree(pData); + } + + return nCount; +} + +ssize_t DrvMainProcfsFirmwareSmBusDebugRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 i, nLength = 0; + u8 szSmBusRxData[MAX_I2C_TRANSACTION_LENGTH_LIMIT] = {0}; + u8 szOut[MAX_I2C_TRANSACTION_LENGTH_LIMIT*2] = {0}; + u8 szValue[10] = {0}; + + DBG("*** %s() ***\n", __func__); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + +#ifdef CONFIG_TOUCH_DRIVER_RUN_ON_MTK_PLATFORM +#ifdef CONFIG_ENABLE_DMA_IIC + DmaReset(); +#endif //CONFIG_ENABLE_DMA_IIC +#endif //CONFIG_TOUCH_DRIVER_RUN_ON_MTK_PLATFORM + + if (_gDebugCmdArguCount > 0) // Send write command + { + DBG("Execute I2C SMBUS write command\n"); + + IicWriteData(SLAVE_I2C_ID_DWI2C, &_gDebugCmdArgu[0], _gDebugCmdArguCount); + } + + if (_gDebugReadDataSize > 0) // Send read command + { + DBG("Execute I2C SMBUS read command\n"); + + IicReadData(SLAVE_I2C_ID_DWI2C, &szSmBusRxData[0], _gDebugReadDataSize); + } + + for (i = 0; i < _gDebugReadDataSize; i ++) + { + DBG("szSmBusRxData[%d] = 0x%x\n", i, szSmBusRxData[i]); + + sprintf(szValue, "0x%02X", szSmBusRxData[i]); + strcat(szOut, szValue); + strcat(szOut, "\n"); + } + + nLength = sprintf(pBuffer, "%s\n", szOut); + + *pPos += nLength; + + return nLength; +} + +ssize_t DrvMainProcfsFirmwareSmBusDebugWrite(struct file *pFile, const char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 i, j; + char szCmdType[5] = {0}; + char *pCh = NULL; + char *pData = NULL; + + DBG("*** %s() ***\n", __func__); + + if (pBuffer != NULL) + { + DBG("*** pBuffer[0] = %c ***\n", pBuffer[0]); + DBG("*** pBuffer[1] = %c ***\n", pBuffer[1]); + DBG("*** pBuffer[2] = %c ***\n", pBuffer[2]); + DBG("*** pBuffer[3] = %c ***\n", pBuffer[3]); + DBG("*** pBuffer[4] = %c ***\n", pBuffer[4]); + DBG("*** pBuffer[5] = %c ***\n", pBuffer[5]); + + DBG("nCount = %d\n", (int)nCount); + + pData = kmalloc(nCount, GFP_KERNEL); + if (!pData) + { + return -ENOMEM; + } + + if (copy_from_user(pData, pBuffer, nCount)) + { + DBG("copy_from_user() failed\n"); + + kfree(pData); + return -EFAULT; + } + + // Reset to 0 before parsing the adb command + _gDebugCmdArguCount = 0; + _gDebugReadDataSize = 0; + + i = 0; + j = 0; + + while ((pCh = strsep((char **)&pData, " ,")) && (j < MAX_DEBUG_COMMAND_ARGUMENT_NUM)) + { + DBG("pCh = %s\n", pCh); + + if (strcmp(pCh, "w") == 0 || strcmp(pCh, "r") == 0) + { + memcpy(szCmdType, pCh, strlen(pCh)); + } + else if (strcmp(szCmdType, "w") == 0) + { + _gDebugCmdArgu[j] = DrvCommonConvertCharToHexDigit(pCh, strlen(pCh)); + DBG("_gDebugCmdArgu[%d] = 0x%02X\n", j, _gDebugCmdArgu[j]); + + j ++; + + _gDebugCmdArguCount = j; + DBG("_gDebugCmdArguCount = %d\n", _gDebugCmdArguCount); + } + else if (strcmp(szCmdType, "r") == 0) + { + sscanf(pCh, "%d", &_gDebugReadDataSize); + DBG("_gDebugReadDataSize = %d\n", _gDebugReadDataSize); + } + else + { + DBG("Un-supported adb command format!\n"); + } + + i ++; + } + + kfree(pData); + } + + return nCount; +} + +ssize_t DrvMainProcfsFirmwareSetDQMemValueRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 i, nLength = 0; + u8 nBank, nAddr; + u32 szRegData[MAX_DEBUG_REGISTER_NUM] = {0}; + u8 szOut[MAX_DEBUG_REGISTER_NUM*25] = {0}, szValue[10] = {0}; + + DBG("*** %s() ***\n", __func__); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + + for (i = 0; i < _gDebugRegCount; i ++) + { + szRegData[i] = DrvIcFwLyrReadDQMemValue(_gDebugReg[i]); + } + + for (i = 0; i < _gDebugRegCount; i ++) + { + nBank = (_gDebugReg[i] >> 8) & 0xFF; + nAddr = _gDebugReg[i] & 0xFF; + + DBG("reg(0x%02X,0x%02X)=0x%08X\n", nBank, nAddr, szRegData[i]); + + strcat(szOut, "reg("); + sprintf(szValue, "0x%02X", nBank); + strcat(szOut, szValue); + strcat(szOut, ","); + sprintf(szValue, "0x%02X", nAddr); + strcat(szOut, szValue); + strcat(szOut, ")="); + sprintf(szValue, "0x%04X", szRegData[i]); + strcat(szOut, szValue); + strcat(szOut, "\n"); + } + + nLength = sprintf(pBuffer, "%s\n", szOut); + + *pPos += nLength; + + return nLength; +} + +ssize_t DrvMainProcfsFirmwareSetDQMemValueWrite(struct file *pFile, const char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 i, j, k; + char *pCh; + char *pData = NULL; + u16 nRealDQMemAddr = 0; + u32 nRealDQMemValue = 0; + + DBG("*** %s() ***\n", __func__); + + if (pBuffer != NULL) + { + DBG("*** pBuffer[0] = %c ***\n", pBuffer[0]); + DBG("*** pBuffer[1] = %c ***\n", pBuffer[1]); + + DBG("nCount = %d\n", (int)nCount); + + pData = kmalloc(nCount, GFP_KERNEL); + if (!pData) + { + return -ENOMEM; + } + + if (copy_from_user(pData, pBuffer, nCount)) + { + DBG("copy_from_user() failed\n"); + + kfree(pData); + return -EFAULT; + } + + i = 0; + j = 0; + k = 0; + + while ((pCh = strsep((char **)&pData, " ,")) && (i < 2)) + { + DBG("pCh = %s\n", pCh); + + if ((i%2) == 0) + { + _gDebugReg[j] = DrvCommonConvertCharToHexDigit(pCh, strlen(pCh)); + DBG("_gDebugReg[%d] = 0x%04X\n", j, _gDebugReg[j]); + j ++; + } + else // (i%2) == 1 + { + _gDebugRegValue[k] = DrvCommonConvertCharToHexDigit(pCh, strlen(pCh)); + DBG("_gDebugRegValue[%d] = 0x%04X\n", k, _gDebugRegValue[k]); + k ++; + } + + i ++; + } + _gDebugRegCount = j; + + DBG("_gDebugRegCount = %d\n", _gDebugRegCount); + + if ((_gDebugReg[0] % 4) == 0) + { + nRealDQMemAddr = _gDebugReg[0]; + nRealDQMemValue = DrvIcFwLyrReadDQMemValue(nRealDQMemAddr); + _gDebugReg[0] = nRealDQMemAddr; + DBG("nRealDQMemValue Raw = %X\n", nRealDQMemValue); + nRealDQMemValue &= 0xFFFF0000; + nRealDQMemValue |= _gDebugRegValue[0]; + DBG("nRealDQMemValue Modify = %X\n", nRealDQMemValue); + DrvIcFwLyrWriteDQMemValue(nRealDQMemAddr, nRealDQMemValue); + } + else if ((_gDebugReg[0] % 4) == 2) + { + nRealDQMemAddr = _gDebugReg[0] - 2; + nRealDQMemValue = DrvIcFwLyrReadDQMemValue(nRealDQMemAddr); + _gDebugReg[0] = nRealDQMemAddr; + DBG("nRealDQMemValue Raw = %X\n", nRealDQMemValue); + + nRealDQMemValue &= 0x0000FFFF; + nRealDQMemValue |= (_gDebugRegValue[0] << 16); + DBG("nRealDQMemValue Modify = %X\n", nRealDQMemValue); + DrvIcFwLyrWriteDQMemValue(nRealDQMemAddr, nRealDQMemValue); + } + + kfree(pData); + } + + return nCount; +} + +/*--------------------------------------------------------------------------*/ + +#ifdef CONFIG_ENABLE_ITO_MP_TEST + +ssize_t DrvMainProcfsMpTestRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nLength = 0; + + DBG("*** %s() ***\n", __func__); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + + DBG("*** ctp mp test status = %d ***\n", DrvIcFwLyrGetMpTestResult()); + + nLength = sprintf(pBuffer, "%d", DrvIcFwLyrGetMpTestResult()); + + *pPos += nLength; + + return nLength; +} + +ssize_t DrvMainProcfsMpTestWrite(struct file *pFile, const char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nMode = 0; + + DBG("*** %s() ***\n", __func__); + + if (pBuffer != NULL) + { + sscanf(pBuffer, "%x", &nMode); + + DBG("Mp Test Mode = 0x%x\n", nMode); + + if (nMode == ITO_TEST_MODE_OPEN_TEST) //open test + { + _gItoTestMode = ITO_TEST_MODE_OPEN_TEST; + DrvIcFwLyrScheduleMpTestWork(ITO_TEST_MODE_OPEN_TEST); + } + else if (nMode == ITO_TEST_MODE_SHORT_TEST) //short test + { + _gItoTestMode = ITO_TEST_MODE_SHORT_TEST; + DrvIcFwLyrScheduleMpTestWork(ITO_TEST_MODE_SHORT_TEST); + } + else if (nMode == ITO_TEST_MODE_WATERPROOF_TEST) //waterproof test + { + _gItoTestMode = ITO_TEST_MODE_WATERPROOF_TEST; + DrvIcFwLyrScheduleMpTestWork(ITO_TEST_MODE_WATERPROOF_TEST); + } + else + { + DBG("*** Undefined MP Test Mode ***\n"); + } + } + + return nCount; +} + +ssize_t DrvMainProcfsMpTestLogRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nLength = 0; + + DBG("*** %s() ***\n", __func__); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + + DrvIcFwLyrGetMpTestDataLog(_gItoTestMode, pBuffer, &nLength); + + *pPos += nLength; + + return nLength; +} + +ssize_t DrvMainProcfsMpTestLogWrite(struct file *pFile, const char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + DBG("*** %s() ***\n", __func__); + + return nCount; +} + +ssize_t DrvMainProcfsMpTestFailChannelRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nLength = 0; + + DBG("*** %s() ***\n", __func__); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + + DrvIcFwLyrGetMpTestFailChannel(_gItoTestMode, pBuffer, &nLength); + + *pPos += nLength; + + return nLength; +} + +ssize_t DrvMainProcfsMpTestFailChannelWrite(struct file *pFile, const char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + DBG("*** %s() ***\n", __func__); + + return nCount; +} + +ssize_t DrvMainProcfsMpTestScopeRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nLength = 0; + + DBG("*** %s() ***\n", __func__); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + +#if defined(CONFIG_ENABLE_TOUCH_DRIVER_FOR_MUTUAL_IC) + DrvIcFwLyrGetMpTestScope(&g_TestScopeInfo); + + nLength = sprintf(pBuffer, "%d,%d", g_TestScopeInfo.nMx, g_TestScopeInfo.nMy); +#endif //CONFIG_ENABLE_TOUCH_DRIVER_FOR_MUTUAL_IC + + *pPos += nLength; + + return nLength; +} + +ssize_t DrvMainProcfsMpTestScopeWrite(struct file *pFile, const char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + DBG("*** %s() ***\n", __func__); + + return nCount; +} + +#endif //CONFIG_ENABLE_ITO_MP_TEST + +/*--------------------------------------------------------------------------*/ + +ssize_t DrvMainProcfsFirmwareModeRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nLength = 0; + + DBG("*** %s() ***\n", __func__); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + +#if defined(CONFIG_ENABLE_TOUCH_DRIVER_FOR_MUTUAL_IC) + if (g_ChipType == CHIP_TYPE_MSG26XXM) + { + g_FirmwareMode = DrvIcFwLyrGetFirmwareMode(); + + DBG("%s() firmware mode = 0x%x\n", __func__, g_FirmwareMode); + + nLength = sprintf(pBuffer, "%x", g_FirmwareMode); + } + else if (g_ChipType == CHIP_TYPE_MSG28XX) + { + DrvIcFwLyrGetFirmwareInfo(&g_FirmwareInfo); + g_FirmwareMode = g_FirmwareInfo.nFirmwareMode; + + DBG("%s() firmware mode = 0x%x\n", __func__, g_FirmwareInfo.nFirmwareMode); + + nLength = sprintf(pBuffer, "%x", g_FirmwareInfo.nFirmwareMode); + } +#elif defined(CONFIG_ENABLE_TOUCH_DRIVER_FOR_SELF_IC) + if (g_ChipType == CHIP_TYPE_MSG21XXA || g_ChipType == CHIP_TYPE_MSG22XX) + { + DrvIcFwLyrGetFirmwareInfo(&g_FirmwareInfo); + g_FirmwareMode = g_FirmwareInfo.nFirmwareMode; + + DBG("%s() firmware mode = 0x%x, can change firmware mode = %d\n", __func__, g_FirmwareInfo.nFirmwareMode, g_FirmwareInfo.nIsCanChangeFirmwareMode); + + nLength = sprintf(pBuffer, "%x,%d", g_FirmwareInfo.nFirmwareMode, g_FirmwareInfo.nIsCanChangeFirmwareMode); + } +#endif + + *pPos += nLength; + + return nLength; +} + +ssize_t DrvMainProcfsFirmwareModeWrite(struct file *pFile, const char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nMode; + + DBG("*** %s() ***\n", __func__); + + if (pBuffer != NULL) + { + sscanf(pBuffer, "%x", &nMode); + DBG("firmware mode = 0x%x\n", nMode); + + g_IsSwitchModeByAPK = 0; + + if (nMode == FIRMWARE_MODE_DEMO_MODE) //demo mode + { + g_FirmwareMode = DrvIcFwLyrChangeFirmwareMode(FIRMWARE_MODE_DEMO_MODE); + } + else if (nMode == FIRMWARE_MODE_DEBUG_MODE) //debug mode + { + g_FirmwareMode = DrvIcFwLyrChangeFirmwareMode(FIRMWARE_MODE_DEBUG_MODE); + g_IsSwitchModeByAPK = 1; + } +#if defined(CONFIG_ENABLE_TOUCH_DRIVER_FOR_SELF_IC) + else if (nMode == FIRMWARE_MODE_RAW_DATA_MODE) //raw data mode + { + g_FirmwareMode = DrvIcFwLyrChangeFirmwareMode(FIRMWARE_MODE_RAW_DATA_MODE); + g_IsSwitchModeByAPK = 1; + } +#endif //CONFIG_ENABLE_TOUCH_DRIVER_FOR_SELF_IC + else + { + DBG("*** Undefined Firmware Mode ***\n"); + } + } + + DBG("*** g_FirmwareMode = 0x%x ***\n", g_FirmwareMode); + + return nCount; +} + +ssize_t DrvMainProcfsFirmwareSensorRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nLength = 0; + + DBG("*** %s() ***\n", __func__); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + +#if defined(CONFIG_ENABLE_TOUCH_DRIVER_FOR_MUTUAL_IC) + if (g_FirmwareInfo.nLogModePacketHeader == 0xA5 || g_FirmwareInfo.nLogModePacketHeader == 0xAB) + { + nLength = sprintf(pBuffer, "%d,%d", g_FirmwareInfo.nMx, g_FirmwareInfo.nMy); + } + else if (g_FirmwareInfo.nLogModePacketHeader == 0xA7) + { + nLength = sprintf(pBuffer, "%d,%d,%d,%d", g_FirmwareInfo.nMx, g_FirmwareInfo.nMy, g_FirmwareInfo.nSs, g_FirmwareInfo.nSd); + } + else + { + DBG("Undefined debug mode packet format : 0x%x\n", g_FirmwareInfo.nLogModePacketHeader); + nLength = 0; + } +#elif defined(CONFIG_ENABLE_TOUCH_DRIVER_FOR_SELF_IC) + nLength = sprintf(pBuffer, "%d", g_FirmwareInfo.nLogModePacketLength); +#endif + + *pPos += nLength; + + return nLength; +} + +ssize_t DrvMainProcfsFirmwareSensorWrite(struct file *pFile, const char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + DBG("*** %s() ***\n", __func__); + +// DrvIcFwLyrGetFirmwareInfo(&g_FirmwareInfo); +// if (g_ChipType == CHIP_TYPE_MSG21XXA || g_ChipType == CHIP_TYPE_MSG22XX || g_ChipType == CHIP_TYPE_MSG28XX) +// { +// g_FirmwareMode = g_FirmwareInfo.nFirmwareMode; +// } + + return nCount; +} + +ssize_t DrvMainProcfsFirmwarePacketHeaderRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nLength = 0; + + DBG("*** %s() ***\n", __func__); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + + nLength = sprintf(pBuffer, "%d", g_FirmwareInfo.nLogModePacketHeader); + + *pPos += nLength; + + return nLength; +} + +ssize_t DrvMainProcfsFirmwarePacketHeaderWrite(struct file *pFile, const char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + DBG("*** %s() ***\n", __func__); + +// DrvIcFwLyrGetFirmwareInfo(&g_FirmwareInfo); +// if (g_ChipType == CHIP_TYPE_MSG21XXA || g_ChipType == CHIP_TYPE_MSG22XX || g_ChipType == CHIP_TYPE_MSG28XX) +// { +// g_FirmwareMode = g_FirmwareInfo.nFirmwareMode; +// } + + return nCount; +} + +ssize_t DrvMainKObjectPacketShow(struct kobject *pKObj, struct kobj_attribute *pAttr, char *pBuf) +{ + u32 i = 0; + u32 nLength = 0; + + DBG("*** %s() ***\n", __func__); + + if (strcmp(pAttr->attr.name, "packet") == 0) + { + if (g_LogModePacket != NULL) + { + DBG("g_FirmwareMode=%x, g_LogModePacket[0]=%x, g_LogModePacket[1]=%x\n", g_FirmwareMode, g_LogModePacket[0], g_LogModePacket[1]); + DBG("g_LogModePacket[2]=%x, g_LogModePacket[3]=%x\n", g_LogModePacket[2], g_LogModePacket[3]); + DBG("g_LogModePacket[4]=%x, g_LogModePacket[5]=%x\n", g_LogModePacket[4], g_LogModePacket[5]); + +#if defined(CONFIG_ENABLE_TOUCH_DRIVER_FOR_MUTUAL_IC) + if ((g_FirmwareMode == FIRMWARE_MODE_DEBUG_MODE) && (g_LogModePacket[0] == 0xA5 || g_LogModePacket[0] == 0xAB || g_LogModePacket[0] == 0xA7)) +#elif defined(CONFIG_ENABLE_TOUCH_DRIVER_FOR_SELF_IC) + if ((g_FirmwareMode == FIRMWARE_MODE_DEBUG_MODE || g_FirmwareMode == FIRMWARE_MODE_RAW_DATA_MODE) && (g_LogModePacket[0] == 0x62)) +#endif + { + for (i = 0; i < g_FirmwareInfo.nLogModePacketLength; i ++) + { + pBuf[i] = g_LogModePacket[i]; + } + + nLength = g_FirmwareInfo.nLogModePacketLength; + DBG("nLength = %d\n", nLength); + } + else + { + DBG("CURRENT MODE IS NOT DEBUG MODE/WRONG DEBUG MODE HEADER\n"); + } + } + else + { + DBG("g_LogModePacket is NULL\n"); + } + } + else + { + DBG("pAttr->attr.name = %s \n", pAttr->attr.name); + } + + return nLength; +} + +ssize_t DrvMainKObjectPacketStore(struct kobject *pKObj, struct kobj_attribute *pAttr, const char *pBuf, size_t nCount) +{ + DBG("*** %s() ***\n", __func__); +/* + if (strcmp(pAttr->attr.name, "packet") == 0) + { + + } +*/ + return nCount; +} + +static struct kobj_attribute packet_attr = __ATTR(packet, 0666, DrvMainKObjectPacketShow, DrvMainKObjectPacketStore); + +/* Create a group of attributes so that we can create and destroy them all at once. */ +static struct attribute *attrs[] = { + &packet_attr.attr, + NULL, /* need to NULL terminate the list of attributes */ +}; + +/* + * An unnamed attribute group will put all of the attributes directly in + * the kobject directory. If we specify a name, a subdirectory will be + * created for the attributes with the directory being the name of the + * attribute group. + */ +struct attribute_group attr_group = { + .attrs = attrs, +}; + + +//------------------------------------------------------------------------------// + +ssize_t DrvMainProcfsQueryFeatureSupportStatusRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nLength = 0; + + DBG("*** %s() ***\n", __func__); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + + nLength = sprintf(pBuffer, "%d", _gFeatureSupportStatus); + + DBG("*** _gFeatureSupportStatus = %d ***\n", _gFeatureSupportStatus); + + *pPos += nLength; + + return nLength; +} + +ssize_t DrvMainProcfsQueryFeatureSupportStatusWrite(struct file *pFile, const char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nFeature; + + DBG("*** %s() ***\n", __func__); + + if (pBuffer != NULL) + { + sscanf(pBuffer, "%x", &nFeature); + DBG("nFeature = 0x%x\n", nFeature); + + if (nFeature == FEATURE_GESTURE_WAKEUP_MODE) + { + _gFeatureSupportStatus = IS_GESTURE_WAKEUP_ENABLED; + } + else if (nFeature == FEATURE_GESTURE_DEBUG_MODE) + { + _gFeatureSupportStatus = IS_GESTURE_DEBUG_MODE_ENABLED; + } + else if (nFeature == FEATURE_GESTURE_INFORMATION_MODE) + { + _gFeatureSupportStatus = IS_GESTURE_INFORMATION_MODE_ENABLED; + } + else if (nFeature == FEATURE_TOUCH_DRIVER_DEBUG_LOG) + { + _gFeatureSupportStatus = IS_TOUCH_DRIVER_DEBUG_LOG_ENABLED; + } + else if (nFeature == FEATURE_FIRMWARE_DATA_LOG) + { + _gFeatureSupportStatus = IS_FIRMWARE_DATA_LOG_ENABLED; + } + else + { + DBG("*** Undefined Feature ***\n"); + } + } + + DBG("*** _gFeatureSupportStatus = %d ***\n", _gFeatureSupportStatus); + + return nCount; +} + +ssize_t DrvMainProcfsChangeFeatureSupportStatusRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nLength = 0; + + DBG("*** %s() ***\n", __func__); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + + nLength = sprintf(pBuffer, "%d", _gFeatureSupportStatus); + + DBG("*** _gFeatureSupportStatus = %d ***\n", _gFeatureSupportStatus); + + *pPos += nLength; + + return nLength; +} + +ssize_t DrvMainProcfsChangeFeatureSupportStatusWrite(struct file *pFile, const char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 i; + u32 nFeature = 0, nNewValue = 0; + char *pCh; + char *pData = NULL; + + DBG("*** %s() ***\n", __func__); + + if (pBuffer != NULL) + { + DBG("nCount = %d\n", (int)nCount); + + pData = kmalloc(nCount, GFP_KERNEL); + if (!pData) + { + return -ENOMEM; + } + + if (copy_from_user(pData, pBuffer, nCount)) + { + DBG("copy_from_user() failed\n"); + + kfree(pData); + return -EFAULT; + } + + i = 0; + + while ((pCh = strsep((char **)&pData, " ,")) && (i < 3)) + { + DBG("pCh = %s\n", pCh); + + if (i == 0) + { + nFeature = DrvCommonConvertCharToHexDigit(pCh, strlen(pCh)); + DBG("nFeature = 0x%04X\n", nFeature); + } + else if (i == 1) + { + nNewValue = DrvCommonConvertCharToHexDigit(pCh, strlen(pCh)); + DBG("nNewValue = %d\n", nNewValue); + } + else + { + DBG("End of parsing adb command.\n"); + } + + i ++; + } + + if (nFeature == FEATURE_GESTURE_WAKEUP_MODE) + { + IS_GESTURE_WAKEUP_ENABLED = nNewValue; + _gFeatureSupportStatus = IS_GESTURE_WAKEUP_ENABLED; + } + else if (nFeature == FEATURE_GESTURE_DEBUG_MODE) + { + IS_GESTURE_DEBUG_MODE_ENABLED = nNewValue; + _gFeatureSupportStatus = IS_GESTURE_DEBUG_MODE_ENABLED; + } + else if (nFeature == FEATURE_GESTURE_INFORMATION_MODE) + { + IS_GESTURE_INFORMATION_MODE_ENABLED = nNewValue; + _gFeatureSupportStatus = IS_GESTURE_INFORMATION_MODE_ENABLED; + } + else if (nFeature == FEATURE_TOUCH_DRIVER_DEBUG_LOG) + { + IS_TOUCH_DRIVER_DEBUG_LOG_ENABLED = nNewValue; + _gFeatureSupportStatus = IS_TOUCH_DRIVER_DEBUG_LOG_ENABLED; + } + else if (nFeature == FEATURE_FIRMWARE_DATA_LOG) + { + IS_FIRMWARE_DATA_LOG_ENABLED = nNewValue; + _gFeatureSupportStatus = IS_FIRMWARE_DATA_LOG_ENABLED; + } + else + { + DBG("*** Undefined Feature ***\n"); + } + + DBG("*** _gFeatureSupportStatus = %d ***\n", _gFeatureSupportStatus); + + kfree(pData); + } + + return nCount; +} + +//------------------------------------------------------------------------------// + +#ifdef CONFIG_ENABLE_GESTURE_WAKEUP + +ssize_t DrvMainProcfsGestureWakeupModeRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nLength = 0; + + DBG("*** %s() ***\n", __func__); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + +#ifdef CONFIG_SUPPORT_64_TYPES_GESTURE_WAKEUP_MODE + DBG("g_GestureWakeupMode = 0x%x, 0x%x\n", g_GestureWakeupMode[0], g_GestureWakeupMode[1]); + + nLength = sprintf(pBuffer, "%x,%x", g_GestureWakeupMode[0], g_GestureWakeupMode[1]); +#else + DBG("g_GestureWakeupMode = 0x%x\n", g_GestureWakeupMode[0]); + + nLength = sprintf(pBuffer, "%x", g_GestureWakeupMode[0]); +#endif //CONFIG_SUPPORT_64_TYPES_GESTURE_WAKEUP_MODE + + *pPos += nLength; + + return nLength; +} + +ssize_t DrvMainProcfsGestureWakeupModeWrite(struct file *pFile, const char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nLength; + u32 nWakeupMode[2] = {0}; + + DBG("*** %s() ***\n", __func__); + + if (pBuffer != NULL) + { +#ifdef CONFIG_SUPPORT_64_TYPES_GESTURE_WAKEUP_MODE + u32 i; + char *pCh; + + i = 0; + while ((pCh = strsep((char **)&pBuffer, " ,")) && (i < 2)) + { + DBG("pCh = %s\n", pCh); + + nWakeupMode[i] = DrvCommonConvertCharToHexDigit(pCh, strlen(pCh)); + + DBG("nWakeupMode[%d] = 0x%04X\n", i, nWakeupMode[i]); + i ++; + } +#else + sscanf(pBuffer, "%x", &nWakeupMode[0]); + DBG("nWakeupMode = 0x%x\n", nWakeupMode[0]); +#endif //CONFIG_SUPPORT_64_TYPES_GESTURE_WAKEUP_MODE + + nLength = nCount; + DBG("nLength = %d\n", nLength); + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_DOUBLE_CLICK_FLAG) == GESTURE_WAKEUP_MODE_DOUBLE_CLICK_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_DOUBLE_CLICK_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_DOUBLE_CLICK_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_UP_DIRECT_FLAG) == GESTURE_WAKEUP_MODE_UP_DIRECT_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_UP_DIRECT_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_UP_DIRECT_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_DOWN_DIRECT_FLAG) == GESTURE_WAKEUP_MODE_DOWN_DIRECT_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_DOWN_DIRECT_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_DOWN_DIRECT_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_LEFT_DIRECT_FLAG) == GESTURE_WAKEUP_MODE_LEFT_DIRECT_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_LEFT_DIRECT_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_LEFT_DIRECT_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_RIGHT_DIRECT_FLAG) == GESTURE_WAKEUP_MODE_RIGHT_DIRECT_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_RIGHT_DIRECT_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_RIGHT_DIRECT_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_m_CHARACTER_FLAG) == GESTURE_WAKEUP_MODE_m_CHARACTER_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_m_CHARACTER_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_m_CHARACTER_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_W_CHARACTER_FLAG) == GESTURE_WAKEUP_MODE_W_CHARACTER_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_W_CHARACTER_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_W_CHARACTER_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_C_CHARACTER_FLAG) == GESTURE_WAKEUP_MODE_C_CHARACTER_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_C_CHARACTER_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_C_CHARACTER_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_e_CHARACTER_FLAG) == GESTURE_WAKEUP_MODE_e_CHARACTER_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_e_CHARACTER_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_e_CHARACTER_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_V_CHARACTER_FLAG) == GESTURE_WAKEUP_MODE_V_CHARACTER_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_V_CHARACTER_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_V_CHARACTER_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_O_CHARACTER_FLAG) == GESTURE_WAKEUP_MODE_O_CHARACTER_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_O_CHARACTER_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_O_CHARACTER_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_S_CHARACTER_FLAG) == GESTURE_WAKEUP_MODE_S_CHARACTER_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_S_CHARACTER_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_S_CHARACTER_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_Z_CHARACTER_FLAG) == GESTURE_WAKEUP_MODE_Z_CHARACTER_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_Z_CHARACTER_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_Z_CHARACTER_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_RESERVE1_FLAG) == GESTURE_WAKEUP_MODE_RESERVE1_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_RESERVE1_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_RESERVE1_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_RESERVE2_FLAG) == GESTURE_WAKEUP_MODE_RESERVE2_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_RESERVE2_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_RESERVE2_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_RESERVE3_FLAG) == GESTURE_WAKEUP_MODE_RESERVE3_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_RESERVE3_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_RESERVE3_FLAG); + } + +#ifdef CONFIG_SUPPORT_64_TYPES_GESTURE_WAKEUP_MODE + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_RESERVE4_FLAG) == GESTURE_WAKEUP_MODE_RESERVE4_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_RESERVE4_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_RESERVE4_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_RESERVE5_FLAG) == GESTURE_WAKEUP_MODE_RESERVE5_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_RESERVE5_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_RESERVE5_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_RESERVE6_FLAG) == GESTURE_WAKEUP_MODE_RESERVE6_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_RESERVE6_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_RESERVE6_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_RESERVE7_FLAG) == GESTURE_WAKEUP_MODE_RESERVE7_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_RESERVE7_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_RESERVE7_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_RESERVE8_FLAG) == GESTURE_WAKEUP_MODE_RESERVE8_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_RESERVE8_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_RESERVE8_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_RESERVE9_FLAG) == GESTURE_WAKEUP_MODE_RESERVE9_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_RESERVE9_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_RESERVE9_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_RESERVE10_FLAG) == GESTURE_WAKEUP_MODE_RESERVE10_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_RESERVE10_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_RESERVE10_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_RESERVE11_FLAG) == GESTURE_WAKEUP_MODE_RESERVE11_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_RESERVE11_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_RESERVE11_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_RESERVE12_FLAG) == GESTURE_WAKEUP_MODE_RESERVE12_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_RESERVE12_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_RESERVE12_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_RESERVE13_FLAG) == GESTURE_WAKEUP_MODE_RESERVE13_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_RESERVE13_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_RESERVE13_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_RESERVE14_FLAG) == GESTURE_WAKEUP_MODE_RESERVE14_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_RESERVE14_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_RESERVE14_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_RESERVE15_FLAG) == GESTURE_WAKEUP_MODE_RESERVE15_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_RESERVE15_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_RESERVE15_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_RESERVE16_FLAG) == GESTURE_WAKEUP_MODE_RESERVE16_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_RESERVE16_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_RESERVE16_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_RESERVE17_FLAG) == GESTURE_WAKEUP_MODE_RESERVE17_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_RESERVE17_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_RESERVE17_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_RESERVE18_FLAG) == GESTURE_WAKEUP_MODE_RESERVE18_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_RESERVE18_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_RESERVE18_FLAG); + } + + if ((nWakeupMode[0] & GESTURE_WAKEUP_MODE_RESERVE19_FLAG) == GESTURE_WAKEUP_MODE_RESERVE19_FLAG) + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] | GESTURE_WAKEUP_MODE_RESERVE19_FLAG; + } + else + { + g_GestureWakeupMode[0] = g_GestureWakeupMode[0] & (~GESTURE_WAKEUP_MODE_RESERVE19_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE20_FLAG) == GESTURE_WAKEUP_MODE_RESERVE20_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE20_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE20_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE21_FLAG) == GESTURE_WAKEUP_MODE_RESERVE21_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE21_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE21_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE22_FLAG) == GESTURE_WAKEUP_MODE_RESERVE22_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE22_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE22_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE23_FLAG) == GESTURE_WAKEUP_MODE_RESERVE23_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE23_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE23_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE24_FLAG) == GESTURE_WAKEUP_MODE_RESERVE24_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE24_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE24_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE25_FLAG) == GESTURE_WAKEUP_MODE_RESERVE25_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE25_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE25_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE26_FLAG) == GESTURE_WAKEUP_MODE_RESERVE26_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE26_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE26_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE27_FLAG) == GESTURE_WAKEUP_MODE_RESERVE27_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE27_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE27_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE28_FLAG) == GESTURE_WAKEUP_MODE_RESERVE28_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE28_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE28_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE29_FLAG) == GESTURE_WAKEUP_MODE_RESERVE29_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE29_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE29_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE30_FLAG) == GESTURE_WAKEUP_MODE_RESERVE30_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE30_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE30_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE31_FLAG) == GESTURE_WAKEUP_MODE_RESERVE31_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE31_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE31_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE32_FLAG) == GESTURE_WAKEUP_MODE_RESERVE32_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE32_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE32_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE33_FLAG) == GESTURE_WAKEUP_MODE_RESERVE33_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE33_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE33_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE34_FLAG) == GESTURE_WAKEUP_MODE_RESERVE34_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE34_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE34_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE35_FLAG) == GESTURE_WAKEUP_MODE_RESERVE35_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE35_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE35_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE36_FLAG) == GESTURE_WAKEUP_MODE_RESERVE36_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE36_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE36_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE37_FLAG) == GESTURE_WAKEUP_MODE_RESERVE37_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE37_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE37_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE38_FLAG) == GESTURE_WAKEUP_MODE_RESERVE38_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE38_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE38_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE39_FLAG) == GESTURE_WAKEUP_MODE_RESERVE39_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE39_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE39_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE40_FLAG) == GESTURE_WAKEUP_MODE_RESERVE40_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE40_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE40_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE41_FLAG) == GESTURE_WAKEUP_MODE_RESERVE41_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE41_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE41_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE42_FLAG) == GESTURE_WAKEUP_MODE_RESERVE42_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE42_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE42_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE43_FLAG) == GESTURE_WAKEUP_MODE_RESERVE43_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE43_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE43_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE44_FLAG) == GESTURE_WAKEUP_MODE_RESERVE44_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE44_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE44_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE45_FLAG) == GESTURE_WAKEUP_MODE_RESERVE45_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE45_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE45_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE46_FLAG) == GESTURE_WAKEUP_MODE_RESERVE46_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE46_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE46_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE47_FLAG) == GESTURE_WAKEUP_MODE_RESERVE47_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE47_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE47_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE48_FLAG) == GESTURE_WAKEUP_MODE_RESERVE48_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE48_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE48_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE49_FLAG) == GESTURE_WAKEUP_MODE_RESERVE49_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE49_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE49_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE50_FLAG) == GESTURE_WAKEUP_MODE_RESERVE50_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE50_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE50_FLAG); + } + + if ((nWakeupMode[1] & GESTURE_WAKEUP_MODE_RESERVE51_FLAG) == GESTURE_WAKEUP_MODE_RESERVE51_FLAG) + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] | GESTURE_WAKEUP_MODE_RESERVE51_FLAG; + } + else + { + g_GestureWakeupMode[1] = g_GestureWakeupMode[1] & (~GESTURE_WAKEUP_MODE_RESERVE51_FLAG); + } +#endif //CONFIG_SUPPORT_64_TYPES_GESTURE_WAKEUP_MODE + + DBG("g_GestureWakeupMode = 0x%x, 0x%x\n", g_GestureWakeupMode[0], g_GestureWakeupMode[1]); + } + + return nCount; +} + +#ifdef CONFIG_ENABLE_GESTURE_DEBUG_MODE + +ssize_t DrvMainProcfsGestureDebugModeRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nLength = 0; + + DBG("*** %s() ***\n", __func__); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + + DBG("g_GestureDebugMode = 0x%x\n", g_GestureDebugMode); // add for debug + + nLength = sprintf(pBuffer, "%d", g_GestureDebugMode); + + *pPos += nLength; + + return nLength; +} + +ssize_t DrvMainProcfsGestureDebugModeWrite(struct file *pFile, const char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u8 ucGestureMode[2]; + u8 i; + char *pCh; + + if (pBuffer != NULL) + { + i = 0; + while ((pCh = strsep((char **)&pBuffer, " ,")) && (i < 2)) + { + DBG("pCh = %s\n", pCh); + + ucGestureMode[i] = DrvCommonConvertCharToHexDigit(pCh, strlen(pCh)); + + DBG("ucGestureMode[%d] = 0x%04X\n", i, ucGestureMode[i]); + i ++; + } + + g_GestureDebugMode = ucGestureMode[0]; + g_GestureDebugFlag = ucGestureMode[1]; + + DBG("Gesture flag = 0x%x\n", g_GestureDebugFlag); + + if (g_GestureDebugMode == 0x01) //open gesture debug mode + { + DrvIcFwLyrOpenGestureDebugMode(g_GestureDebugFlag); + +// input_report_key(g_InputDevice, RESERVER42, 1); + input_report_key(g_InputDevice, KEY_POWER, 1); + input_sync(g_InputDevice); +// input_report_key(g_InputDevice, RESERVER42, 0); + input_report_key(g_InputDevice, KEY_POWER, 0); + input_sync(g_InputDevice); + } + else if (g_GestureDebugMode == 0x00) //close gesture debug mode + { + DrvIcFwLyrCloseGestureDebugMode(); + } + else + { + DBG("*** Undefined Gesture Debug Mode ***\n"); + } + } + + return nCount; +} + +ssize_t DrvMainKObjectGestureDebugShow(struct kobject *pKObj, struct kobj_attribute *pAttr, char *pBuf) +{ + u32 i = 0; + u32 nLength = 0; + + DBG("*** %s() ***\n", __func__); + + if (strcmp(pAttr->attr.name, "gesture_debug") == 0) + { + if (g_LogGestureDebug != NULL) + { + DBG("g_LogGestureDebug[0]=%x, g_LogGestureDebug[1]=%x\n", g_LogGestureDebug[0], g_LogGestureDebug[1]); + DBG("g_LogGestureDebug[2]=%x, g_LogGestureDebug[3]=%x\n", g_LogGestureDebug[2], g_LogGestureDebug[3]); + DBG("g_LogGestureDebug[4]=%x, g_LogGestureDebug[5]=%x\n", g_LogGestureDebug[4], g_LogGestureDebug[5]); + + if (g_LogGestureDebug[0] == 0xA7 && g_LogGestureDebug[3] == 0x51) + { + for (i = 0; i < 0x80; i ++) + { + pBuf[i] = g_LogGestureDebug[i]; + } + + nLength = 0x80; + DBG("nLength = %d\n", nLength); + } + else + { + DBG("CURRENT MODE IS NOT GESTURE DEBUG MODE/WRONG GESTURE DEBUG MODE HEADER\n"); + } + } + else + { + DBG("g_LogGestureDebug is NULL\n"); + } + } + else + { + DBG("pAttr->attr.name = %s \n", pAttr->attr.name); + } + + return nLength; +} + +ssize_t DrvMainKObjectGestureDebugStore(struct kobject *pKObj, struct kobj_attribute *pAttr, const char *pBuf, size_t nCount) +{ + DBG("*** %s() ***\n", __func__); +/* + if (strcmp(pAttr->attr.name, "packet") == 0) + { + + } +*/ + return nCount; +} + +static struct kobj_attribute gesture_attr = __ATTR(gesture_debug, 0666, DrvMainKObjectGestureDebugShow, DrvMainKObjectGestureDebugStore); + +/* Create a group of attributes so that we can create and destroy them all at once. */ +static struct attribute *gestureattrs[] = { + &gesture_attr.attr, + NULL, /* need to NULL terminate the list of attributes */ +}; + +/* + * An unnamed attribute group will put all of the attributes directly in + * the kobject directory. If we specify a name, a subdirectory will be + * created for the attributes with the directory being the name of the + * attribute group. + */ +struct attribute_group gestureattr_group = { + .attrs = gestureattrs, +}; + +#endif //CONFIG_ENABLE_GESTURE_DEBUG_MODE + +#ifdef CONFIG_ENABLE_GESTURE_INFORMATION_MODE + +ssize_t DrvMainProcfsGestureInforModeRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u8 szOut[GESTURE_WAKEUP_INFORMATION_PACKET_LENGTH*5] = {0}, szValue[10] = {0}; + u32 szLogGestureInfo[GESTURE_WAKEUP_INFORMATION_PACKET_LENGTH] = {0}; + u32 i = 0; + u32 nLength = 0; + + DBG("*** %s() ***\n", __func__); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + + _gLogGestureCount = 0; + if (_gLogGestureInforType == FIRMWARE_GESTURE_INFORMATION_MODE_A) //FIRMWARE_GESTURE_INFORMATION_MODE_A + { + for (i = 0; i < 2; i ++)//0 EventFlag; 1 RecordNum + { + szLogGestureInfo[_gLogGestureCount] = g_LogGestureInfor[4 + i]; + _gLogGestureCount ++; + } + + for (i = 2; i < 8; i ++)//2~3 Xst Yst; 4~5 Xend Yend; 6~7 char_width char_height + { + szLogGestureInfo[_gLogGestureCount] = g_LogGestureInfor[4 + i]; + _gLogGestureCount ++; + } + } + else if (_gLogGestureInforType == FIRMWARE_GESTURE_INFORMATION_MODE_B) //FIRMWARE_GESTURE_INFORMATION_MODE_B + { + for (i = 0; i < 2; i ++)//0 EventFlag; 1 RecordNum + { + szLogGestureInfo[_gLogGestureCount] = g_LogGestureInfor[4 + i]; + _gLogGestureCount ++; + } + + for (i = 0; i< g_LogGestureInfor[5]*2 ; i ++)//(X and Y)*RecordNum + { + szLogGestureInfo[_gLogGestureCount] = g_LogGestureInfor[12 + i]; + _gLogGestureCount ++; + } + } + else if (_gLogGestureInforType == FIRMWARE_GESTURE_INFORMATION_MODE_C) //FIRMWARE_GESTURE_INFORMATION_MODE_C + { + for (i = 0; i < 6; i ++)//header + { + szLogGestureInfo[_gLogGestureCount] = g_LogGestureInfor[i]; + _gLogGestureCount ++; + } + + for (i = 6; i < 86; i ++) + { + szLogGestureInfo[_gLogGestureCount] = g_LogGestureInfor[i]; + _gLogGestureCount ++; + } + + szLogGestureInfo[_gLogGestureCount] = g_LogGestureInfor[86];//dummy + _gLogGestureCount ++; + szLogGestureInfo[_gLogGestureCount] = g_LogGestureInfor[87];//checksum + _gLogGestureCount++; + } + else + { + DBG("*** Undefined GESTURE INFORMATION MODE ***\n"); + } + + for (i = 0; i < _gLogGestureCount; i ++) + { + sprintf(szValue, "%d", szLogGestureInfo[i]); + strcat(szOut, szValue); + strcat(szOut, ","); + } + + nLength = sprintf(pBuffer, "%s\n", szOut); + + *pPos += nLength; + + return nLength; +} + +ssize_t DrvMainProcfsGestureInforModeWrite(struct file *pFile, const char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nMode; + + DBG("*** %s() ***\n", __func__); + + if (pBuffer != NULL) + { + sscanf(pBuffer, "%x", &nMode); + _gLogGestureInforType = nMode; + } + + DBG("*** _gLogGestureInforType type = 0x%x ***\n", _gLogGestureInforType); + + return nCount; +} + +#endif //CONFIG_ENABLE_GESTURE_INFORMATION_MODE + +#endif //CONFIG_ENABLE_GESTURE_WAKEUP + +/*--------------------------------------------------------------------------*/ + +#ifdef CONFIG_ENABLE_COUNT_REPORT_RATE +ssize_t DrvMainProcfsReportRateRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + struct timeval tEndTime; + suseconds_t nStartTime, nEndTime, nElapsedTime; + u32 nLength = 0; + + DBG("*** %s() ***\n", __func__); + + DBG("g_InterruptCount = %d, g_ValidTouchCount = %d\n", g_InterruptCount, g_ValidTouchCount); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + + // Get end time + do_gettimeofday(&tEndTime); + + nStartTime = g_StartTime.tv_sec + g_StartTime.tv_usec/1000000; + nEndTime = tEndTime.tv_sec + tEndTime.tv_usec/1000000; + + nElapsedTime = nEndTime - nStartTime; + + DBG("Start time : %lu sec, %lu msec\n", g_StartTime.tv_sec, g_StartTime.tv_usec); + DBG("End time : %lu sec, %lu msec\n", tEndTime.tv_sec, tEndTime.tv_usec); + + DBG("Elapsed time : %lu sec\n", nElapsedTime); + + // Calculate report rate + if (nElapsedTime != 0) + { + g_InterruptReportRate = g_InterruptCount / nElapsedTime; + g_ValidTouchReportRate = g_ValidTouchCount / nElapsedTime; + } + else + { + g_InterruptReportRate = 0; + g_ValidTouchReportRate = 0; + } + + DBG("g_InterruptReportRate = %d, g_ValidTouchReportRate = %d\n", g_InterruptReportRate, g_ValidTouchReportRate); + + g_InterruptCount = 0; // Reset count + g_ValidTouchCount = 0; + + nLength = sprintf(pBuffer, "%d,%d", g_InterruptReportRate, g_ValidTouchReportRate); + + *pPos += nLength; + + return nLength; +} + +ssize_t DrvMainProcfsReportRateWrite(struct file *pFile, const char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + DBG("*** %s() ***\n", __func__); + + if (pBuffer != NULL) + { + sscanf(pBuffer, "%d", &g_IsEnableReportRate); + + DBG("g_IsEnableReportRate = %d\n", g_IsEnableReportRate); // 1 : enable report rate calculation, 0 : disable report rate calculation, 2 : reset count + + g_InterruptCount = 0; // Reset count + g_ValidTouchCount = 0; + } + + return nCount; +} +#endif //CONFIG_ENABLE_COUNT_REPORT_RATE + +/*--------------------------------------------------------------------------*/ + +#ifdef CONFIG_ENABLE_GLOVE_MODE +ssize_t DrvMainProcfsGloveModeRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nLength = 0; + u8 ucGloveMode = 0; + + DBG("*** %s() ***\n", __func__); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + + if (g_ChipType == CHIP_TYPE_MSG28XX) + { + DrvPlatformLyrDisableFingerTouchReport(); + + DrvIcFwLyrGetGloveInfo(&ucGloveMode); + + DrvPlatformLyrEnableFingerTouchReport(); + + DBG("Glove Mode = 0x%x\n", ucGloveMode); + + nLength = sprintf(pBuffer, "%x", ucGloveMode); + } + + *pPos += nLength; + + return nLength; +} + +ssize_t DrvMainProcfsGloveModeWrite(struct file *pFile, const char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nGloveMode = 0; + u32 i = 0; + char *pCh = NULL; + + DBG("*** %s() ***\n", __func__); + + if (pBuffer != NULL) + { + i = 0; + while ((pCh = strsep((char **)&pBuffer, ",")) && (i < 1)) + { + DBG("pCh = %s\n", pCh); + + nGloveMode = DrvCommonConvertCharToHexDigit(pCh, strlen(pCh)); + + i ++; + } + + DBG("Glove Mode = 0x%x\n", nGloveMode); + + DrvPlatformLyrDisableFingerTouchReport(); + + if (nGloveMode == 0x01) //open glove mode + { + DrvIcFwLyrOpenGloveMode(); + g_IsEnableGloveMode = 1; + } + else if (nGloveMode == 0x00) //close glove mode + { + DrvIcFwLyrCloseGloveMode(); + g_IsEnableGloveMode = 0; + } + else + { + DBG("*** Undefined Glove Mode ***\n"); + } + DBG("g_IsEnableGloveMode = 0x%x\n", g_IsEnableGloveMode); + + DrvPlatformLyrEnableFingerTouchReport(); + } + + return nCount; +} + +ssize_t DrvMainProcfsOpenGloveModeRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nLength = 0; + + DBG("*** %s() ***\n", __func__); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + + if (g_ChipType == CHIP_TYPE_MSG28XX) + { + DrvPlatformLyrDisableFingerTouchReport(); + + DrvIcFwLyrOpenGloveMode(); + g_IsEnableGloveMode = 1; + + DrvPlatformLyrEnableFingerTouchReport(); + } + DBG("g_IsEnableGloveMode = 0x%x\n", g_IsEnableGloveMode); + + *pPos += nLength; + + return nLength; +} + +ssize_t DrvMainProcfsCloseGloveModeRead(struct file *pFile, char __user *pBuffer, size_t nCount, loff_t *pPos) +{ + u32 nLength = 0; + + DBG("*** %s() ***\n", __func__); + + // If file position is non-zero, then assume the string has been read and indicate there is no more data to be read. + if (*pPos != 0) + { + return 0; + } + + if (g_ChipType == CHIP_TYPE_MSG28XX) + { + DrvPlatformLyrDisableFingerTouchReport(); + + DrvIcFwLyrCloseGloveMode(); + g_IsEnableGloveMode = 0; + + DrvPlatformLyrEnableFingerTouchReport(); + } + DBG("g_IsEnableGloveMode = 0x%x\n", g_IsEnableGloveMode); + + *pPos += nLength; + + return nLength; +} +#endif //CONFIG_ENABLE_GLOVE_MODE + + +#ifdef CONFIG_ENABLE_HOTKNOT +static long hotknot_ioctl( struct file *file, unsigned int cmd, unsigned long arg ) +{ + long nRet = 0; + + DBG("*** %s ***\n", __FUNCTION__); + + if (g_IsBypassHotknot == 0) + { + mutex_lock(&g_HKMutex); + g_IsHotknotAlive = 1; + nRet = HotKnotIoctl(file, cmd, arg); + g_IsHotknotAlive = 0; + mutex_unlock(&g_HKMutex); + } + + return nRet; +} + +static int hotknot_value; + +static ssize_t hotknot_value_show( struct kobject *kobj, struct kobj_attribute *attr, char *buf ) +{ + return sprintf( buf, "%d\n", hotknot_value ); +} + +static ssize_t hotknot_value_store( struct kobject *kobj, struct kobj_attribute *attr, const char *buf, size_t count ) +{ + sscanf( buf, "%d", &hotknot_value ); + + return count; +} + +static struct kobj_attribute hotknot_value_attr = __ATTR( hotknot_value, 0666, hotknot_value_show, hotknot_value_store ); +static struct attribute *hotknot_attrs[] = +{ + &hotknot_value_attr.attr, 0 +}; + +static struct attribute_group hotknot_attr_group = +{ + .attrs = hotknot_attrs +}; + +static const struct file_operations hotknot_fops = +{ + .owner = THIS_MODULE, + .unlocked_ioctl = hotknot_ioctl +}; + +//static struct miscdevice hotknot_miscdevice = +struct miscdevice hotknot_miscdevice = +{ + .minor = MISC_DYNAMIC_MINOR, + .name = "hotknot", + .nodename = "hotknot", + .mode = 0666, + .fops = &hotknot_fops +}; +#endif //CONFIG_ENABLE_HOTKNOT + +//------------------------------------------------------------------------------// + +s32 DrvMainTouchDeviceInitialize(void) +{ + s32 nRetVal = 0; +#ifdef CONFIG_ENABLE_PROXIMITY_DETECTION +#if defined(CONFIG_TOUCH_DRIVER_RUN_ON_MTK_PLATFORM) + int nErr; + struct hwmsen_object tObjPs; +#endif //CONFIG_TOUCH_DRIVER_RUN_ON_MTK_PLATFORM +#endif //CONFIG_ENABLE_PROXIMITY_DETECTION + + DBG("*** %s() ***\n", __func__); + + _DrvMainCreateProcfsDirEntry(); // Create procfs directory entry + +#ifdef CONFIG_ENABLE_HOTKNOT + _DrvMainHotknotRegistry(); //register hotknot here... +#endif //CONFIG_ENABLE_HOTKNOT + +#ifdef CONFIG_ENABLE_JNI_INTERFACE + CreateMsgToolMem(); +#endif //CONFIG_ENABLE_JNI_INTERFACE + +#ifdef CONFIG_ENABLE_ITO_MP_TEST + DrvIcFwLyrCreateMpTestWorkQueue(); +#endif //CONFIG_ENABLE_ITO_MP_TEST + + g_ChipType = DrvIcFwLyrGetChipType(); // Try to get chip type by SLAVE_I2C_ID_DBBUS(0x62) firstly. + + if (g_ChipType == 0) // If failed, try to get chip type by SLAVE_I2C_ID_DBBUS(0x59) again. + { + SLAVE_I2C_ID_DBBUS = (0xB2>>1); //0x59 + + g_ChipType = DrvIcFwLyrGetChipType(); + } + + DrvPlatformLyrTouchDeviceResetHw(); + + if (g_ChipType != 0) // To make sure TP is attached on cell phone. + { + memset(&g_FirmwareInfo, 0x0, sizeof(FirmwareInfo_t)); + + DrvIcFwLyrVariableInitialize(); + +#ifdef CONFIG_ENABLE_SEGMENT_READ_FINGER_TOUCH_DATA +#if defined(CONFIG_ENABLE_TOUCH_DRIVER_FOR_MUTUAL_IC) + DrvIcFwLyrGetTouchPacketAddress(&g_FwPacketDataAddress, &g_FwPacketFlagAddress); +#endif //CONFIG_ENABLE_TOUCH_DRIVER_FOR_MUTUAL_IC +#endif //CONFIG_ENABLE_SEGMENT_READ_FINGER_TOUCH_DATA + +#ifdef CONFIG_ENABLE_PROXIMITY_DETECTION +#if defined(CONFIG_TOUCH_DRIVER_RUN_ON_SPRD_PLATFORM) || defined(CONFIG_TOUCH_DRIVER_RUN_ON_QCOM_PLATFORM) + tsps_assist_register_callback("msg2xxx", &DrvPlatformLyrTpPsEnable, &DrvPlatformLyrGetTpPsData); +#elif defined(CONFIG_TOUCH_DRIVER_RUN_ON_MTK_PLATFORM) + tObjPs.polling = 0; //interrupt mode + tObjPs.sensor_operate = DrvPlatformLyrTpPsOperate; + + if ((nErr = hwmsen_attach(ID_PROXIMITY, &tObjPs))) + { + DBG("call hwmsen_attach() failed = %d\n", nErr); + } +#endif +#endif //CONFIG_ENABLE_PROXIMITY_DETECTION + } + else + { + nRetVal = -ENODEV; + } + + return nRetVal; +} + +/*=============================================================*/ +// LOCAL FUNCTION DEFINITION +/*=============================================================*/ + +static s32 _DrvMainCreateProcfsDirEntry(void) +{ + s32 nRetVal = 0; + +#ifdef CONFIG_ENABLE_GESTURE_WAKEUP +#ifdef CONFIG_ENABLE_GESTURE_DEBUG_MODE + u8 *pGesturePath = NULL; +#endif //CONFIG_ENABLE_GESTURE_DEBUG_MODE +#endif //CONFIG_ENABLE_GESTURE_WAKEUP + u8 *pDevicePath = NULL; + + DBG("*** %s() ***\n", __func__); + + _gProcClass = proc_mkdir(PROC_NODE_CLASS, NULL); + + _gProcMsTouchScreenMsg20xx = proc_mkdir(PROC_NODE_MS_TOUCHSCREEN_MSG20XX, _gProcClass); + + _gProcDevice = proc_mkdir(PROC_NODE_DEVICE, _gProcMsTouchScreenMsg20xx); + + if (NULL == proc_create(PROC_NODE_CHIP_TYPE, PROCFS_AUTHORITY, _gProcDevice, &_gProcChipType)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_CHIP_TYPE); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_CHIP_TYPE); + } + + if (NULL == proc_create(PROC_NODE_FIRMWARE_DATA, PROCFS_AUTHORITY, _gProcDevice, &_gProcFirmwareData)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_FIRMWARE_DATA); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_FIRMWARE_DATA); + } + + if (NULL == proc_create(PROC_NODE_FIRMWARE_UPDATE, PROCFS_AUTHORITY, _gProcDevice, &_gProcApkFirmwareUpdate)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_FIRMWARE_UPDATE); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_FIRMWARE_UPDATE); + } + + if (NULL == proc_create(PROC_NODE_CUSTOMER_FIRMWARE_VERSION, PROCFS_AUTHORITY, _gProcDevice, &_gProcCustomerFirmwareVersion)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_CUSTOMER_FIRMWARE_VERSION); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_CUSTOMER_FIRMWARE_VERSION); + } + + if (NULL == proc_create(PROC_NODE_PLATFORM_FIRMWARE_VERSION, PROCFS_AUTHORITY, _gProcDevice, &_gProcPlatformFirmwareVersion)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_PLATFORM_FIRMWARE_VERSION); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_PLATFORM_FIRMWARE_VERSION); + } + + if (NULL == proc_create(PROC_NODE_DEVICE_DRIVER_VERSION, PROCFS_AUTHORITY, _gProcDevice, &_gProcDeviceDriverVersion)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_DEVICE_DRIVER_VERSION); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_DEVICE_DRIVER_VERSION); + } + + if (NULL == proc_create(PROC_NODE_SDCARD_FIRMWARE_UPDATE, PROCFS_AUTHORITY, _gProcDevice, &_gProcSdCardFirmwareUpdate)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_SDCARD_FIRMWARE_UPDATE); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_SDCARD_FIRMWARE_UPDATE); + } + + if (NULL == proc_create(PROC_NODE_FIRMWARE_DEBUG, PROCFS_AUTHORITY, _gProcDevice, &_gProcFirmwareDebug)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_FIRMWARE_DEBUG); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_FIRMWARE_DEBUG); + } + + if (NULL == proc_create(PROC_NODE_FIRMWARE_SET_DEBUG_VALUE, PROCFS_AUTHORITY, _gProcDevice, &_gProcFirmwareSetDebugValue)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_FIRMWARE_SET_DEBUG_VALUE); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_FIRMWARE_SET_DEBUG_VALUE); + } + + if (NULL == proc_create(PROC_NODE_FIRMWARE_SMBUS_DEBUG, PROCFS_AUTHORITY, _gProcDevice, &_gProcFirmwareSmBusDebug)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_FIRMWARE_SMBUS_DEBUG); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_FIRMWARE_SMBUS_DEBUG); + } + + if (NULL == proc_create(PROC_NODE_FIRMWARE_SET_DQMEM_VALUE, PROCFS_AUTHORITY, _gProcDevice, &_gProcFirmwareSetDQMemValue)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_FIRMWARE_SET_DQMEM_VALUE); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_FIRMWARE_SET_DQMEM_VALUE); + } + +#ifdef CONFIG_ENABLE_ITO_MP_TEST + if (NULL == proc_create(PROC_NODE_MP_TEST, PROCFS_AUTHORITY, _gProcDevice, &_gProcMpTest)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_MP_TEST); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_MP_TEST); + } + + if (NULL == proc_create(PROC_NODE_MP_TEST_LOG, PROCFS_AUTHORITY, _gProcDevice, &_gProcMpTestLog)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_MP_TEST_LOG); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_MP_TEST_LOG); + } + + if (NULL == proc_create(PROC_NODE_MP_TEST_FAIL_CHANNEL, PROCFS_AUTHORITY, _gProcDevice, &_gProcMpTestFailChannel)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_MP_TEST_FAIL_CHANNEL); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_MP_TEST_FAIL_CHANNEL); + } + + if (NULL == proc_create(PROC_NODE_MP_TEST_SCOPE, PROCFS_AUTHORITY, _gProcDevice, &_gProcMpTestScope)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_MP_TEST_SCOPE); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_MP_TEST_SCOPE); + } +#endif //CONFIG_ENABLE_ITO_MP_TEST + + + if (NULL == proc_create(PROC_NODE_FIRMWARE_MODE, PROCFS_AUTHORITY, _gProcDevice, &_gProcFirmwareMode)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_FIRMWARE_MODE); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_FIRMWARE_MODE); + } + + if (NULL == proc_create(PROC_NODE_FIRMWARE_SENSOR, PROCFS_AUTHORITY, _gProcDevice, &_gProcFirmwareSensor)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_FIRMWARE_SENSOR); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_FIRMWARE_SENSOR); + } + + if (NULL == proc_create(PROC_NODE_FIRMWARE_PACKET_HEADER, PROCFS_AUTHORITY, _gProcDevice, &_gProcFirmwarePacketHeader)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_FIRMWARE_PACKET_HEADER); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_FIRMWARE_PACKET_HEADER); + } + + /* create a kset with the name of "kset_example" which is located under /sys/kernel/ */ + g_TouchKSet = kset_create_and_add("kset_example", NULL, kernel_kobj); + if (!g_TouchKSet) + { + DBG("*** kset_create_and_add() failed, nRetVal = %d ***\n", nRetVal); + + nRetVal = -ENOMEM; + } + + g_TouchKObj = kobject_create(); + if (!g_TouchKObj) + { + DBG("*** kobject_create() failed, nRetVal = %d ***\n", nRetVal); + + nRetVal = -ENOMEM; + kset_unregister(g_TouchKSet); + g_TouchKSet = NULL; + } + + g_TouchKObj->kset = g_TouchKSet; + + nRetVal = kobject_add(g_TouchKObj, NULL, "%s", "kobject_example"); + if (nRetVal != 0) + { + DBG("*** kobject_add() failed, nRetVal = %d ***\n", nRetVal); + + kobject_put(g_TouchKObj); + g_TouchKObj = NULL; + kset_unregister(g_TouchKSet); + g_TouchKSet = NULL; + } + + /* create the files associated with this kobject */ + nRetVal = sysfs_create_group(g_TouchKObj, &attr_group); + if (nRetVal != 0) + { + DBG("*** sysfs_create_file() failed, nRetVal = %d ***\n", nRetVal); + + kobject_put(g_TouchKObj); + g_TouchKObj = NULL; + kset_unregister(g_TouchKSet); + g_TouchKSet = NULL; + } + + pDevicePath = kobject_get_path(g_TouchKObj, GFP_KERNEL); + DBG("DEVPATH = %s\n", pDevicePath); + + + if (NULL == proc_create(PROC_NODE_QUERY_FEATURE_SUPPORT_STATUS, PROCFS_AUTHORITY, _gProcDevice, &_gProcQueryFeatureSupportStatus)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_QUERY_FEATURE_SUPPORT_STATUS); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_QUERY_FEATURE_SUPPORT_STATUS); + } + + if (NULL == proc_create(PROC_NODE_CHANGE_FEATURE_SUPPORT_STATUS, PROCFS_AUTHORITY, _gProcDevice, &_gProcChangeFeatureSupportStatus)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_CHANGE_FEATURE_SUPPORT_STATUS); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_CHANGE_FEATURE_SUPPORT_STATUS); + } + +#ifdef CONFIG_ENABLE_GESTURE_WAKEUP + if (NULL == proc_create(PROC_NODE_GESTURE_WAKEUP_MODE, PROCFS_AUTHORITY, _gProcDevice, &_gProcGestureWakeupMode)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_GESTURE_WAKEUP_MODE); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_GESTURE_WAKEUP_MODE); + } + +#ifdef CONFIG_ENABLE_GESTURE_DEBUG_MODE + if (NULL == proc_create(PROC_NODE_GESTURE_DEBUG_MODE, PROCFS_AUTHORITY, _gProcDevice, &_gProcGestureDebugMode)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_GESTURE_DEBUG_MODE); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_GESTURE_DEBUG_MODE); + } + + /* create a kset with the name of "kset_gesture" which is located under /sys/kernel/ */ + g_GestureKSet = kset_create_and_add("kset_gesture", NULL, kernel_kobj); + if (!g_GestureKSet) + { + DBG("*** kset_create_and_add() failed, nRetVal = %d ***\n", nRetVal); + nRetVal = -ENOMEM; + } + + g_GestureKObj = kobject_create(); + if (!g_GestureKObj) + { + DBG("*** kobject_create() failed, nRetVal = %d ***\n", nRetVal); + + nRetVal = -ENOMEM; + kset_unregister(g_GestureKSet); + g_GestureKSet = NULL; + } + + g_GestureKObj->kset = g_GestureKSet; + + nRetVal = kobject_add(g_GestureKObj, NULL, "%s", "kobject_gesture"); + if (nRetVal != 0) + { + DBG("*** kobject_add() failed, nRetVal = %d ***\n", nRetVal); + + kobject_put(g_GestureKObj); + g_GestureKObj = NULL; + kset_unregister(g_GestureKSet); + g_GestureKSet = NULL; + } + + /* create the files associated with this g_GestureKObj */ + nRetVal = sysfs_create_group(g_GestureKObj, &gestureattr_group); + if (nRetVal != 0) + { + DBG("*** sysfs_create_file() failed, nRetVal = %d ***\n", nRetVal); + + kobject_put(g_GestureKObj); + g_GestureKObj = NULL; + kset_unregister(g_GestureKSet); + g_GestureKSet = NULL; + } + + pGesturePath = kobject_get_path(g_GestureKObj, GFP_KERNEL); + DBG("DEVPATH = %s\n", pGesturePath); +#endif //CONFIG_ENABLE_GESTURE_DEBUG_MODE + +#ifdef CONFIG_ENABLE_GESTURE_INFORMATION_MODE + if (NULL == proc_create(PROC_NODE_GESTURE_INFORMATION_MODE, PROCFS_AUTHORITY, _gProcDevice, &_gProcGestureInforMode)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_GESTURE_INFORMATION_MODE); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_GESTURE_INFORMATION_MODE); + } +#endif //CONFIG_ENABLE_GESTURE_INFORMATION_MODE +#endif //CONFIG_ENABLE_GESTURE_WAKEUP + +#ifdef CONFIG_ENABLE_COUNT_REPORT_RATE + if (NULL == proc_create(PROC_NODE_REPORT_RATE, PROCFS_AUTHORITY, _gProcDevice, &_gProcReportRate)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_REPORT_RATE); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_REPORT_RATE); + } +#endif //CONFIG_ENABLE_COUNT_REPORT_RATE + +#ifdef CONFIG_ENABLE_GLOVE_MODE + if (NULL == proc_create(PROC_NODE_GLOVE_MODE, PROCFS_AUTHORITY, _gProcDevice, &_gProcGloveMode)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_GLOVE_MODE); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_GLOVE_MODE); + } + + if (NULL == proc_create(PROC_NODE_OPEN_GLOVE_MODE, PROCFS_AUTHORITY, _gProcDevice, &_gProcOpenGloveMode)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_OPEN_GLOVE_MODE); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_OPEN_GLOVE_MODE); + } + + if (NULL == proc_create(PROC_NODE_CLOSE_GLOVE_MODE, PROCFS_AUTHORITY, _gProcDevice, &_gProcCloseGloveMode)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_CLOSE_GLOVE_MODE); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_CLOSE_GLOVE_MODE); + } +#endif //CONFIG_ENABLE_GLOVE_MODE + +#ifdef CONFIG_ENABLE_JNI_INTERFACE + if (NULL == proc_create(PROC_NODE_JNI_NODE, PROCFS_AUTHORITY, _gProcDevice, &_gProcJniMethod)) + { + DBG("Failed to create procfs file node(%s)!\n", PROC_NODE_JNI_NODE); + } + else + { + DBG("Create procfs file node(%s) OK!\n", PROC_NODE_JNI_NODE); + } +#endif //CONFIG_ENABLE_JNI_INTERFACE + + return nRetVal; +} + +#ifdef CONFIG_ENABLE_HOTKNOT +//register hotknot ioctl handler +static s32 _DrvMainHotknotRegistry(void) +{ + s32 nRetVal = 0; + + nRetVal = misc_register( &hotknot_miscdevice ); + if ( nRetVal < 0 ) + { + DBG( "Failed to register misc device. Err:%d\n", nRetVal ); + } + DBG( "*** Misc device registered ***\n" ); + + nRetVal = sysfs_create_group( &hotknot_miscdevice.this_device->kobj, &hotknot_attr_group ); + if ( nRetVal < 0 ) + { + DBG( "Failed to create attribute group. Err:%d\n", nRetVal ); + //misc_deregister( &hotknot_miscdevice ); + } + DBG( "*** Attribute group created ***\n" ); + + mutex_init(&g_HKMutex); + mutex_init(&g_QMutex); + CreateQueue(); + CreateHotKnotMem(); + + return nRetVal; +} +#endif //CONFIG_ENABLE_HOTKNOT -- cgit v1.3.1