diff options
| author | Yuval Adam <_@yuv.al> | 2017-08-30 08:25:59 +0000 |
|---|---|---|
| committer | Yuval Adam <_@yuv.al> | 2017-08-30 08:25:59 +0000 |
| commit | 8e4bff4cab0ddac6060645b0715210484d02ff40 (patch) | |
| tree | 3a5c3024371a04692a3a6d9974d001cdff8ebf84 /drivers/input/touchscreen/msg2233/mstar_drv_mutual_mp_test.c | |
Diffstat (limited to 'drivers/input/touchscreen/msg2233/mstar_drv_mutual_mp_test.c')
| -rw-r--r-- | drivers/input/touchscreen/msg2233/mstar_drv_mutual_mp_test.c | 3421 |
1 files changed, 3421 insertions, 0 deletions
diff --git a/drivers/input/touchscreen/msg2233/mstar_drv_mutual_mp_test.c b/drivers/input/touchscreen/msg2233/mstar_drv_mutual_mp_test.c new file mode 100644 index 00000000..b506ad47 --- /dev/null +++ b/drivers/input/touchscreen/msg2233/mstar_drv_mutual_mp_test.c @@ -0,0 +1,3421 @@ +////////////////////////////////////////////////////////////////////////////////
+//
+// 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_mutual_mp_test.c
+ *
+ * @brief This file defines the interface of touch screen
+ *
+ *
+ */
+
+/*=============================================================*/
+// INCLUDE FILE
+/*=============================================================*/
+
+#include "mstar_drv_mutual_mp_test.h"
+#include "mstar_drv_utility_adaption.h"
+#include "mstar_drv_mutual_fw_control.h"
+#include "mstar_drv_platform_porting_layer.h"
+
+#if defined(CONFIG_ENABLE_TOUCH_DRIVER_FOR_MUTUAL_IC)
+#ifdef CONFIG_ENABLE_ITO_MP_TEST
+
+#include "msg26xxm_open_test_X.h"
+#include "msg26xxm_short_test_X.h"
+#include "msg28xx_mp_test_X.h"
+
+/*=============================================================*/
+// EXTERN VARIABLE DECLARATION
+/*=============================================================*/
+
+extern u32 SLAVE_I2C_ID_DBBUS;
+extern u32 SLAVE_I2C_ID_DWI2C;
+
+extern u8 g_ChipType;
+
+/*=============================================================*/
+// LOCAL VARIABLE DEFINITION
+/*=============================================================*/
+
+static u32 _gIsInMpTest = 0;
+static u32 _gTestRetryCount = CTP_MP_TEST_RETRY_COUNT;
+static ItoTestMode_e _gItoTestMode = 0;
+
+static s32 _gCtpMpTestStatus = ITO_TEST_UNDER_TESTING;
+
+static u16 _gSenseLineNum = 0;
+static u16 _gDriveLineNum = 0;
+static u16 _gWaterProofNum = 0;
+
+static struct work_struct _gCtpItoTestWork;
+static struct workqueue_struct *_gCtpMpTestWorkQueue = NULL;
+
+static s32 _gDeltaC[MAX_MUTUAL_NUM] = {0};
+static s32 _gResult[MAX_MUTUAL_NUM] = {0};
+static s32 _gDeltaCWater[12] = {0};
+static s32 _gResultWater[12] = {0};
+//static u8 _gMode[MAX_MUTUAL_NUM] = {0};
+static s32 _gSenseR[MAX_CHANNEL_NUM] = {0};
+static s32 _gDriveR[MAX_CHANNEL_NUM] = {0};
+static s32 _gGRR[MAX_CHANNEL_NUM] = {0};
+static s32 _gTempDeltaC[MAX_MUTUAL_NUM] = {0};
+
+static u8 _gTestFailChannel[MAX_MUTUAL_NUM] = {0};
+static u32 _gTestFailChannelCount = 0;
+
+static u8 _gShortTestChannel[MAX_CHANNEL_NUM] = {0};
+
+TestScopeInfo_t g_TestScopeInfo = {0};
+
+static u8 _gTestAutoSwitchFlag = 1;
+static u8 _gTestSwitchMode = 0;
+
+u16 _gMuxMem_20_3E_0_Settings[16] = {0};
+u16 _gMuxMem_20_3E_1_Settings[16] = {0};
+u16 _gMuxMem_20_3E_2_Settings[16] = {0};
+u16 _gMuxMem_20_3E_3_Settings[16] = {0};
+u16 _gMuxMem_20_3E_4_Settings[16] = {0};
+u16 _gMuxMem_20_3E_5_Settings[16] = {0};
+u16 _gMuxMem_20_3E_6_Settings[16] = {0};
+
+/*=============================================================*/
+// LOCAL FUNCTION DEFINITION
+/*=============================================================*/
+
+static void _DrvMpTestItoTestMsg26xxmSetToNormalMode(void)
+{
+ u16 nRegData = 0;
+ u16 nTmpAddr = 0, nAddr = 0;
+ u16 nDriveNumGeg = 0, nSenseNumGeg = 0;
+ u16 i = 0;
+
+ DBG("*** %s() ***\n", __func__);
+
+ RegSet16BitValue(0x0FE6, 0x0001);
+
+ nRegData = RegGet16BitValue(0x110E);
+
+ if (nRegData == 0x1D08)
+ {
+ DBG("Wrong mode 0\n");
+ }
+
+ nRegData &= 0x0800;
+
+ if (nRegData > 1)
+ {
+ DBG("Wrong mode\n");
+ }
+
+ RegSet16BitValueOff(0x110E, 0x0800);
+ RegSet16BitValueOn(0x1116, 0x0005);
+ RegSet16BitValueOn(0x114A, 0x0001);
+
+ for (i = 0; i < 7; i ++)
+ {
+ nTmpAddr = 0x3C + i;
+ nTmpAddr = nTmpAddr * 2;
+ nAddr = (0x11 << 8) | nTmpAddr;
+ RegSet16BitValue(nAddr, MSG26XXM_open_ANA1_N_X[i]);
+ }
+
+ RegSet16BitValue(0x1E66, 0x0000);
+ RegSet16BitValue(0x1E67, 0x0000);
+ RegSet16BitValue(0x1E68, 0x0000);
+ RegSet16BitValue(0x1E69, 0x0000);
+ RegSet16BitValue(0x1E6A, 0x0000);
+ RegSet16BitValue(0x1E6B, 0x0000);
+
+ for (i = 0; i < 21; i ++)
+ {
+ nTmpAddr = 3 + i;
+ nTmpAddr = nTmpAddr * 2;
+ nAddr = (0x10 << 8) | nTmpAddr;
+ RegSet16BitValue(nAddr, MSG26XXM_open_ANA3_N_X[i]);
+ }
+
+ nDriveNumGeg = ((MSG26XXM_DRIVE_NUM - 1) << 8 & 0xFF00);
+ nSenseNumGeg = (MSG26XXM_SENSE_NUM & 0x00FF);
+
+ RegSet16BitValue(0x1216, nDriveNumGeg);
+ RegSet16BitValue(0x102E, nSenseNumGeg);
+
+ RegSet16BitValue(0x0FE6, 0x0001);
+
+ DBG("Wrong mode correction\n");
+}
+
+/*
+static void _DrvMpTestItoTestMsg26xxmSetToWaterProofMode(void)
+{
+ u16 nTmpAddr = 0, nAddr = 0;
+ u16 i = 0;
+ u16 nCsubWPdata = 0;
+
+ DBG("*** %s() ***\n", __func__);
+
+ nCsubWPdata = (WATERPROOF_CSUB_REF << 8) | WATERPROOF_CSUB_REF;
+
+ for (i = 0; i < 7; i ++)
+ {
+ nTmpAddr = 0x3C + i;
+ nTmpAddr = nTmpAddr * 2;
+ nAddr = (0x11 << 8) | nTmpAddr;
+ RegSet16BitValue(nAddr, MSG26XXM_WATERPROOF_ANA1_N_X[i]);
+ }
+
+ for (i = 0; i < 21; i ++)
+ {
+ nTmpAddr = 3 + i;
+ nTmpAddr = nTmpAddr * 2;
+ nAddr = (0x10 << 8) | nTmpAddr;
+ RegSet16BitValue(nAddr, MSG26XXM_WATERPROOF_ANA3_N_X[i]);
+ }
+
+ // ana2 write
+ RegSet16BitValue(0x1216, 0x0000);
+
+ for (i = 0; i < 6; i ++)
+ {
+ nTmpAddr = 0x20 + i;
+ nTmpAddr = nTmpAddr * 2;
+ nAddr = (0x10 << 8) | nTmpAddr;
+ RegSet16BitValue(nAddr, nCsubWPdata);
+ }
+
+ RegSet16BitValueOn(0x1116, 0x0005);
+ RegSet16BitValueOn(0x114A, 0x0001);
+ RegSet16BitValue(0x1208, 0x0002);
+
+ DBG("WaterProof : Wrong mode correction\n");
+}
+*/
+
+void _ItoTestDebugShowArray(void *pBuf, u16 nLen, int nDataType, int nCarry, int nChangeLine)
+{
+ u8 * pU8Buf = NULL;
+ s8 * pS8Buf = NULL;
+ u16 * pU16Buf = NULL;
+ s16 * pS16Buf = NULL;
+ u32 * pU32Buf = NULL;
+ s32 * pS32Buf = NULL;
+ int i;
+
+ if(nDataType == 8)
+ pU8Buf = (u8 *)pBuf;
+ else if(nDataType == -8)
+ pS8Buf = (s8 *)pBuf;
+ else if(nDataType == 16)
+ pU16Buf = (u16 *)pBuf;
+ else if(nDataType == -16)
+ pS16Buf = (s16 *)pBuf;
+ else if(nDataType == 32)
+ pU32Buf = (u32 *)pBuf;
+ else if(nDataType == -32)
+ pS32Buf = (s32 *)pBuf;
+
+ for(i=0; i < nLen; i++)
+ {
+ if(nCarry == 16)
+ {
+ if(nDataType == 8)
+ DBG("%02X ", pU8Buf[i]);
+ else if(nDataType == -8)
+ DBG("%02X ", pS8Buf[i]);
+ else if(nDataType == 16)
+ DBG("%04X ", pU16Buf[i]);
+ else if(nDataType == -16)
+ DBG("%04X ", pS16Buf[i]);
+ else if(nDataType == 32)
+ DBG("%08X ", pU32Buf[i]);
+ else if(nDataType == -32)
+ DBG("%08X ", pS32Buf[i]);
+ }
+ else if(nCarry == 10)
+ {
+ if(nDataType == 8)
+ DBG("%6d ", pU8Buf[i]);
+ else if(nDataType == -8)
+ DBG("%6d ", pS8Buf[i]);
+ else if(nDataType == 16)
+ DBG("%6d ", pU16Buf[i]);
+ else if(nDataType == -16)
+ DBG("%6d ", pS16Buf[i]);
+ else if(nDataType == 32)
+ DBG("%6d ", pU32Buf[i]);
+ else if(nDataType == -32)
+ DBG("%6d ", pS32Buf[i]);
+ }
+
+ if(i%nChangeLine == nChangeLine-1){
+ DBG("\n");
+ }
+ }
+ DBG("\n");
+}
+
+void _ItoTestDebugShowS32Array(s32 *pBuf, u16 nRow, u16 nCol)
+{
+ int i, j;
+
+ for(j=0; j < nRow; j++)
+ {
+ for(i=0; i < nCol; i++)
+ {
+ DBG("%4d ", pBuf[i * nRow + j]);
+ }
+ DBG("\n");
+ }
+ DBG("\n");
+}
+
+static void _DrvMpTestItoTestMsg26xxmMcuStop(void)
+{
+ DBG("*** %s() ***\n", __func__);
+
+ RegSet16BitValue(0x0FE6, 0x0001); //bank:mheg5, addr:h0073
+}
+
+static void _DrvMpTestItoTestMsg26xxmAnaSwitchToMutual(void)
+{
+ u16 nTemp = 0;
+
+ DBG("*** %s() ***\n", __func__);
+
+ nTemp = RegGet16BitValue(0x114A); //bank:ana, addr:h0025
+ nTemp |= BIT0;
+ RegSet16BitValue(0x114A, nTemp);
+ nTemp = RegGet16BitValue(0x1116); //bank:ana, addr:h000b
+ nTemp |= (BIT2 | BIT0);
+ RegSet16BitValue(0x1116, nTemp);
+}
+
+static u16 _DrvMpTestItoTestAnaGetMutualChannelNum(void)
+{
+ u16 nSenseLineNum = 0;
+ u16 nRegData = 0;
+
+ DBG("*** %s() ***\n", __func__);
+
+ nRegData = RegGet16BitValue(0x102E); //bank:ana3, addr:h0017
+ nSenseLineNum = nRegData & 0x000F;
+
+ DBG("nSenseLineNum = %d\n", nSenseLineNum);
+
+ return nSenseLineNum;
+}
+
+static u16 _DrvMpTestItoTestAnaGetMutualSubFrameNum(void)
+{
+ u16 nDriveLineNum = 0;
+ u16 nRegData = 0;
+
+ DBG("*** %s() ***\n", __func__);
+
+ nRegData = RegGet16BitValue(0x1216); //bank:ana2, addr:h000b
+ nDriveLineNum = ((nRegData & 0xFF00) >> 8) + 1; //Since we only retrieve 8th~12th bit of reg_m_sf_num, 0xFF00 shall be changed to 0x1F00.
+
+ DBG("nDriveLineNum = %d\n", nDriveLineNum);
+
+ return nDriveLineNum;
+}
+
+/*
+static void _DrvMpTestItoOpenTestMsg26xxmAnaGetMutualCSub(u8 *pMode)
+{
+ u16 i, j;
+ u16 nSenseLineNum;
+ u16 nDriveLineNum;
+ u16 nTotalNum;
+ u8 szDataAna4[3];
+ u8 szDataAna3[3];
+ u8 szDataAna41[ANA4_MUTUAL_CSUB_NUMBER]; //200 = 392 - 192
+ u8 szDataAna31[ANA3_MUTUAL_CSUB_NUMBER]; //192 = 14 * 13 + 10
+ u8 szModeTemp[MAX_MUTUAL_NUM];
+
+ DBG("*** %s() ***\n", __func__);
+
+ nTotalNum = MAX_MUTUAL_NUM;
+
+ nSenseLineNum = _DrvMpTestItoTestAnaGetMutualChannelNum();
+ nDriveLineNum = _DrvMpTestItoTestAnaGetMutualSubFrameNum();
+
+ if (ANA4_MUTUAL_CSUB_NUMBER > 0)
+ {
+ mdelay(100);
+ for (i = 0; i < ANA4_MUTUAL_CSUB_NUMBER; i ++)
+ {
+ szDataAna41[i] = 0;
+ }
+
+ szDataAna4[0] = 0x10;
+ szDataAna4[1] = 0x15; //bank:ana4, addr:h0000
+ szDataAna4[2] = 0x00;
+
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &szDataAna4[0], 3);
+ IicReadData(SLAVE_I2C_ID_DBBUS, &szDataAna41[0], ANA4_MUTUAL_CSUB_NUMBER); //200
+
+ nTotalNum -= (u16)ANA4_MUTUAL_CSUB_NUMBER;
+ }
+
+ for (i = 0; i < nTotalNum; i ++)
+ {
+ szDataAna31[i] = 0;
+ }
+
+ mdelay(100);
+
+ szDataAna3[0] = 0x10;
+ szDataAna3[1] = 0x10; //bank:ana3, addr:h0020
+ szDataAna3[2] = 0x40;
+
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &szDataAna3[0], 3);
+ IicReadData(SLAVE_I2C_ID_DBBUS, &szDataAna31[0], ANA3_MUTUAL_CSUB_NUMBER); //192
+
+ for (i = 0; i < ANA3_MUTUAL_CSUB_NUMBER; i ++)
+ {
+ szModeTemp[i] = szDataAna31[i];
+ }
+
+ for (i = ANA3_MUTUAL_CSUB_NUMBER; i < (ANA3_MUTUAL_CSUB_NUMBER + ANA4_MUTUAL_CSUB_NUMBER); i ++)
+ {
+ szModeTemp[i] = szDataAna41[i - ANA3_MUTUAL_CSUB_NUMBER];
+ }
+
+ for (i = 0; i < nDriveLineNum; i ++)
+ {
+ for (j = 0; j < nSenseLineNum; j ++)
+ {
+ _gMode[j * nDriveLineNum + i] = szModeTemp[i * MAX_CHANNEL_SEN + j];
+
+// DBG("_gMode[%d] = %d\n", j * nDriveLineNum + i, _gMode[j * nDriveLineNum + i]);
+ }
+ }
+}
+*/
+
+static void _DrvMpTestItoOpenTestMsg26xxmAnaSetMutualCSub(u16 nCSub)
+{
+ u16 i = 0;
+ u8 szDbBusTxData[256] = {0};
+
+ szDbBusTxData[0] = 0x10;
+ szDbBusTxData[1] = 0x15; //bank:ana4, addr:h0000
+ szDbBusTxData[2] = 0x00;
+
+ for (i = 3; i < (3+ANA4_MUTUAL_CSUB_NUMBER); i ++)
+ {
+ szDbBusTxData[i] = (u8)nCSub;
+ }
+
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &szDbBusTxData[0], 3+ANA4_MUTUAL_CSUB_NUMBER);
+
+ szDbBusTxData[0] = 0x10;
+ szDbBusTxData[1] = 0x10; //bank:ana3, addr:h0020
+ szDbBusTxData[2] = 0x40;
+
+ for (i = 3; i < 3+ANA3_MUTUAL_CSUB_NUMBER; i ++)
+ {
+ szDbBusTxData[i] = (u8)nCSub;
+ }
+
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &szDbBusTxData[0], 3+ANA3_MUTUAL_CSUB_NUMBER);
+}
+
+static void _DrvMpTestItoTestMsg26xxmDisableFilterNoiseDetect(void)
+{
+ u16 nTemp = 0;
+
+ DBG("*** %s() ***\n", __func__);
+
+ nTemp = RegGet16BitValue(0x1302); //bank:fir, addr:h0001
+ nTemp &= (~(BIT2 | BIT1 | BIT0));
+ RegSet16BitValue(0x1302, nTemp);
+}
+
+static void _DrvMpTestItoTestMsg26xxmAnaSwReset(void)
+{
+ DBG("*** %s() ***\n", __func__);
+
+ RegSet16BitValue(0x1100, 0xFFFF); //bank:ana, addr:h0000
+ RegSet16BitValue(0x1100, 0x0000);
+ mdelay(100);
+}
+
+static void _DrvMpTestItoTestMsg26xxmEnableAdcOneShot(void)
+{
+ DBG("*** %s() ***\n", __func__);
+
+ RegSet16BitValue(0x130C, BIT15); //bank:fir, addr:h0006
+ RegSet16BitValue(0x1214, 0x0031);
+}
+
+static void _DrvMpTestItoTestGetMutualOneShotRawIir(u16 wszResultData[][MAX_CHANNEL_DRV], u16 nDriveLineNum, u16 nSenseLineNum)
+{
+ u16 nRegData;
+ u16 i, j;
+ u16 nTemp;
+ u16 nReadSize;
+ u8 szDbBusTxData[3];
+ u8 szShotData1[FILTER1_MUTUAL_DELTA_C_NUMBER]; //190 = (6 * 14 + 11) * 2
+ u8 szShotData2[FILTER2_MUTUAL_DELTA_C_NUMBER]; //594 = (MAX_MUTUAL_NUM - (6 * 14 + 11)) * 2
+
+ DBG("*** %s() ***\n", __func__);
+
+ nTemp = RegGet16BitValue(0x3D08); //bank:intr_ctrl, addr:h0004
+ nTemp &= (~(BIT8 | BIT4));
+ RegSet16BitValue(0x3D08, nTemp);
+
+ _DrvMpTestItoTestMsg26xxmEnableAdcOneShot();
+
+ nRegData = 0;
+ while (0x0000 == (nRegData & BIT8))
+ {
+ nRegData = RegGet16BitValue(0x3D18); //bank:intr_ctrl, addr:h000c
+ }
+
+ for (i = 0; i < FILTER1_MUTUAL_DELTA_C_NUMBER; i ++)
+ {
+ szShotData1[i] = 0;
+ }
+
+ for (i = 0; i < FILTER2_MUTUAL_DELTA_C_NUMBER; i ++)
+ {
+ szShotData2[i] = 0;
+ }
+
+ mdelay(100);
+ szDbBusTxData[0] = 0x10;
+ szDbBusTxData[1] = 0x13; //bank:fir, addr:h0021
+ szDbBusTxData[2] = 0x42;
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &szDbBusTxData[0], 3);
+ IicReadData(SLAVE_I2C_ID_DBBUS, &szShotData1[0], FILTER1_MUTUAL_DELTA_C_NUMBER); //190
+
+#if defined(CONFIG_TOUCH_DRIVER_RUN_ON_QCOM_PLATFORM) || defined(CONFIG_TOUCH_DRIVER_RUN_ON_MTK_PLATFORM)
+ mdelay(100);
+ nReadSize = IicSegmentReadDataByDbBus(0x20, 0x00, &szShotData2[0], FILTER2_MUTUAL_DELTA_C_NUMBER, MAX_I2C_TRANSACTION_LENGTH_LIMIT); //594
+ DBG("*** nReadSize = %d ***\n", nReadSize); // add for debug
+#elif defined(CONFIG_TOUCH_DRIVER_RUN_ON_SPRD_PLATFORM)
+ mdelay(100);
+ szDbBusTxData[0] = 0x10;
+ szDbBusTxData[1] = 0x20; //bank:fir2, addr:h0000
+ szDbBusTxData[2] = 0x00;
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &szDbBusTxData[0], 3);
+ IicReadData(SLAVE_I2C_ID_DBBUS, &szShotData2[0], FILTER2_MUTUAL_DELTA_C_NUMBER); //594
+#endif
+
+ for (j = 0; j < nDriveLineNum; j ++)
+ {
+ for (i = 0; i < nSenseLineNum; i ++)
+ {
+ // FILTER1 : SF0~SF5, AFE0~AFE13; SF6, AFE0~AFE10
+ if ((j <= 5) || ((j == 6) && (i <= 10)))
+ {
+ nRegData = (u16)(szShotData1[(j * 14 + i) * 2] | szShotData1[(j * 14 + i) * 2 + 1] << 8);
+ wszResultData[i][ j] = (short)nRegData;
+ }
+ else
+ {
+ // FILTER2 : SF6, AFE11~AFE13
+ if ((j == 6) && (i > 10))
+ {
+ nRegData = (u16)(szShotData2[((j - 6) * 14 + (i - 11)) * 2] | szShotData2[((j - 6) * 14 + (i - 11)) * 2 + 1] << 8);
+ wszResultData[i][j] = (short)nRegData;
+ }
+ else
+ {
+ nRegData = (u16)(szShotData2[6 + ((j - 7) * 14 + i) * 2] | szShotData2[6 + ((j - 7) * 14 + i) * 2 + 1] << 8);
+ wszResultData[i][j] = (short)nRegData;
+ }
+ }
+ }
+ }
+
+ nTemp = RegGet16BitValue(0x3D08); //bank:intr_ctrl, addr:h0004
+ nTemp |= (BIT8 | BIT4);
+ RegSet16BitValue(0x3D08, nTemp);
+}
+
+static void _DrvMpTestItoTestMsg26xxmGetDeltaC(s32 *pTarget)
+{
+ s16 nTemp;
+ u16 wszRawData[MAX_CHANNEL_SEN][MAX_CHANNEL_DRV];
+ u16 i, j;
+ u16 nDriveLineNum = 0, nSenseLineNum = 0, nShift = 0;
+
+ DBG("*** %s() ***\n", __func__);
+
+ nSenseLineNum = _DrvMpTestItoTestAnaGetMutualChannelNum();
+ nDriveLineNum = _DrvMpTestItoTestAnaGetMutualSubFrameNum();
+
+ _DrvMpTestItoTestGetMutualOneShotRawIir(wszRawData, nDriveLineNum, nSenseLineNum);
+
+ for (i = 0; i < nSenseLineNum; i ++)
+ {
+ for (j = 0; j < nDriveLineNum; j ++)
+ {
+ nShift = (u16)(i * nDriveLineNum + j);
+ nTemp = (s16)wszRawData[i][j];
+ pTarget[nShift] = nTemp;
+
+// DBG("wszRawData[%d][%d] = %d\n", i, j, nTemp);
+ }
+ }
+}
+
+static s32 _DrvMpTestItoTestMsg26xxmReadTrunkFwVersion(u32* pVersion)
+{
+ u16 nMajor = 0;
+ u16 nMinor = 0;
+ u8 szDbBusTxData[3] = {0};
+ u8 szDbBusRxData[4] = {0};
+
+ DBG("*** %s() ***\n", __func__);
+
+ szDbBusTxData[0] = 0x53;
+ szDbBusTxData[1] = 0x00;
+ szDbBusTxData[2] = 0x24;
+
+ IicWriteData(SLAVE_I2C_ID_DWI2C, &szDbBusTxData[0], 3);
+ IicReadData(SLAVE_I2C_ID_DWI2C, &szDbBusRxData[0], 4);
+
+ DBG("szDbBusRxData[0] = 0x%x\n", szDbBusRxData[0]); // add for debug
+ DBG("szDbBusRxData[1] = 0x%x\n", szDbBusRxData[1]); // add for debug
+ DBG("szDbBusRxData[2] = 0x%x\n", szDbBusRxData[2]); // add for debug
+ DBG("szDbBusRxData[3] = 0x%x\n", szDbBusRxData[3]); // add for debug
+
+ nMajor = (szDbBusRxData[1]<<8) + szDbBusRxData[0];
+ nMinor = (szDbBusRxData[3]<<8) + szDbBusRxData[2];
+
+ DBG("*** major = %x ***\n", nMajor);
+ DBG("*** minor = %x ***\n", nMinor);
+
+ *pVersion = (nMajor << 16) + nMinor;
+
+ return 0;
+}
+
+static s32 _DrvMpTestItoTestMsg26xxmGetSwitchFlag(void)
+{
+ u32 nFwVersion = 0;
+
+ DBG("*** %s() ***\n", __func__);
+
+ if(_DrvMpTestItoTestMsg26xxmReadTrunkFwVersion(&nFwVersion) < 0)
+ {
+ _gTestSwitchMode = 0;
+ return 0;
+ }
+
+ if(nFwVersion >= 0x10030000)
+ _gTestSwitchMode = 1;
+ else
+ _gTestSwitchMode = 0;
+
+ return 0;
+}
+
+static s32 _DrvMpTestItoTestMsg26xxmCheckSwitchStatus(void)
+{
+ u32 nRegData = 0;
+ int nTimeOut = 100;
+ int nT = 0;
+
+ DBG("*** %s() ***\n", __func__);
+
+ do
+ {
+ nRegData = RegGet16BitValue(0x3CE4);
+ mdelay(20);
+ nT++;
+ if (nT > nTimeOut)
+ {
+ return -1;
+ }
+ DBG("*** %s() nRegData:%x***\n", __func__ , nRegData);
+
+ } while (nRegData != 0x7447);
+
+ return 0;
+}
+
+static s32 _DrvMpTestItoTestMsg26xxmSwitchFwMode(u8 nFWMode)
+{
+ DBG("*** %s() ***\n", __func__);
+
+ RegSet16BitValue(0x0FE6, 0x0001); //MCU_stop
+ mdelay(150);
+
+ RegSet16BitValue(0X3C60, 0xAA55); // disable watch dog
+
+ RegSet16BitValue(0X3D08, 0xFFFF);
+ RegSet16BitValue(0X3D18, 0xFFFF);
+
+ RegSet16BitValue(0x3CE4, 0x7474);
+
+ //RegSet16BitValue(0x1E04, 0x7D60);
+ RegSet16BitValue(0x1E04, 0x829F);
+ RegSet16BitValue(0x0FE6, 0x0000);
+ mdelay(150);
+
+ if (_DrvMpTestItoTestMsg26xxmCheckSwitchStatus() < 0)
+ {
+ DBG("*** Msg26xx MP Test# CheckSwitchStatus failed! ***\n");
+ return -1;
+ }
+
+ switch (nFWMode)
+ {
+ case MUTUAL:
+ RegSet16BitValue(0x3CE4, 0x5705);
+ break;
+
+ case SELF:
+ RegSet16BitValue(0x3CE4, 0x6278);
+ break;
+
+ case WATERPROOF:
+ RegSet16BitValue(0x3CE4, 0x7992);
+ DBG("*** Msg26xx MP Test# WATERPROOF mode***\n");
+ break;
+
+ default:
+ return -1;
+ }
+ if (_DrvMpTestItoTestMsg26xxmCheckSwitchStatus()<0)
+ {
+ DBG("*** Msg26xx MP Test# CheckSwitchStatus failed! ***\n");
+ return -1;
+ }
+
+ RegSet16BitValue(0x0FE6, 0x0001);// stop mcu
+ RegSet16BitValue(0x3D08, 0xFEFF);//open timer
+
+ return 0;
+}
+
+static s32 _DrvMpTestItoTestMsg26xxmSwitchMode(u8 nSwitchMode, u8 nFMode)
+{
+ if (_gTestSwitchMode != 0)
+ {
+ if (_DrvMpTestItoTestMsg26xxmSwitchFwMode(nFMode) < 0)
+ {
+ if (nFMode == MUTUAL)
+ {
+ _DrvMpTestItoTestMsg26xxmSetToNormalMode();
+ }
+ else
+ {
+ //_DrvMpTestItoTestMsg26xxmSetToWaterProofMode();
+ DBG("*** Msg26xx MP Test# _DrvMpTestItoTestMsg26xxmSwitchMode failed! ***\n");
+ return -1;
+ }
+ }
+ }
+ else
+ {
+ if (nFMode == MUTUAL)
+ {
+ _DrvMpTestItoTestMsg26xxmSetToNormalMode();
+ }
+ else
+ {
+ //_DrvMpTestItoTestMsg26xxmSetToWaterProofMode();
+ DBG("*** Msg26xx MP Test# _DrvMpTestItoTestMsg26xxmSwitchMode failed! ***\n");
+ return -1;
+ }
+ }
+
+ return 0;
+}
+
+s32 _DrvMpTestMsg26xxmItoOpenTestEntry(void)
+{
+ s32 nRetVal = 0;
+ s32 nPrev = 0, nDelta = 0;
+ u16 i = 0, j = 0;
+
+ DBG("*** %s() ***\n", __func__);
+
+#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
+
+ DrvPlatformLyrDisableFingerTouchReport();
+
+ DrvPlatformLyrTouchDeviceResetHw();
+
+ //auto detetc fw version to decide switch fw mode
+ if (_gTestAutoSwitchFlag != 0)
+ {
+ _DrvMpTestItoTestMsg26xxmGetSwitchFlag();
+ }
+
+ DbBusEnterSerialDebugMode();
+ DbBusStopMCU();
+ DbBusIICUseBus();
+ DbBusIICReshape();
+ mdelay(100);
+
+ _DrvMpTestItoTestMsg26xxmSwitchMode(_gTestSwitchMode, MUTUAL);
+
+ _DrvMpTestItoTestMsg26xxmMcuStop();
+ mdelay(10);
+
+ for (i = 0; i < MAX_MUTUAL_NUM; i ++)
+ {
+ _gTestFailChannel[i] = 0;
+ }
+
+ _gTestFailChannelCount = 0; // Reset _gTestFailChannelCount to 0 before test start
+
+ _gSenseLineNum = _DrvMpTestItoTestAnaGetMutualChannelNum();
+ _gDriveLineNum = _DrvMpTestItoTestAnaGetMutualSubFrameNum();
+
+ _DrvMpTestItoOpenTestMsg26xxmAnaSetMutualCSub(MSG26XXM_OPEN_CSUB_REF_X);
+ _DrvMpTestItoTestMsg26xxmDisableFilterNoiseDetect();
+
+ // Set charge&dump time
+ RegSet16BitValue(0x1224, 0xFFC0);
+ RegSet16BitValue(0x122A, 0x0C0A);
+
+ _DrvMpTestItoTestMsg26xxmAnaSwReset();
+ _DrvMpTestItoTestMsg26xxmGetDeltaC(_gDeltaC);
+
+ for (i = 0; i < _gSenseLineNum; i ++)
+ {
+ DBG("\nSense[%02d]\t", i);
+
+ for (j = 0; j < _gDriveLineNum; j ++)
+ {
+ _gResult[i * _gDriveLineNum + j] = (4464*MSG26XXM_OPEN_CSUB_REF_X - _gDeltaC[i * _gDriveLineNum + j]);
+ DBG("%d %d %d\t", _gResult[i * _gDriveLineNum + j], 4464*MSG26XXM_OPEN_CSUB_REF_X, _gDeltaC[i * _gDriveLineNum + j]);
+ }
+ }
+
+ DBG("\n\n\n");
+
+// for (j = 0; j < _gDriveLineNum; j ++)
+ for (j = 0; j < (_gDriveLineNum-1); j ++)
+ {
+ for (i = 0; i < _gSenseLineNum; i ++)
+ {
+ if (_gResult[i * _gDriveLineNum + j] < FIR_THRESHOLD)
+ {
+ _gTestFailChannel[i * _gDriveLineNum + j] = 1;
+ _gTestFailChannelCount ++;
+ nRetVal = -1;
+ DBG("\nSense%d, Drive%d, MIN_Threshold = %d\t", i, j, _gResult[i * _gDriveLineNum + j]);
+ }
+
+ if (i > 0)
+ {
+ nDelta = _gResult[i * _gDriveLineNum + j] > nPrev ? (_gResult[i * _gDriveLineNum + j] - nPrev) : (nPrev - _gResult[i * _gDriveLineNum + j]);
+ if (nDelta > nPrev*FIR_RATIO/100)
+ {
+ if (0 == _gTestFailChannel[i * _gDriveLineNum + j]) // for avoid _gTestFailChannelCount to be added twice
+ {
+ _gTestFailChannel[i * _gDriveLineNum + j] = 1;
+ _gTestFailChannelCount ++;
+ }
+ nRetVal = -1;
+ DBG("\nSense%d, Drive%d, MAX_Ratio = %d,%d\t", i, j, nDelta, nPrev);
+ }
+ }
+ nPrev = _gResult[i * _gDriveLineNum + j];
+ }
+ }
+
+ DbBusIICNotUseBus();
+ DbBusNotStopMCU();
+ DbBusExitSerialDebugMode();
+
+ DrvPlatformLyrTouchDeviceResetHw();
+ mdelay(300);
+
+ DrvPlatformLyrEnableFingerTouchReport();
+
+ return nRetVal;
+}
+
+static void _DrvMpTestItoOpenTestSetMutualCsubViaDBbus(s16 nCSub)
+{
+ u8 nBaseLen = 6;
+ u16 nFilter = 0x3F;
+ u16 nLastFilter = 0xFFF;
+ u8 nBasePattern = nCSub & nFilter;
+ u8 nPattern;
+ u16 n16BitsPattern;
+ u16 nCSub16Bits[5] = {0};
+ int i;
+
+ DBG("*** %s() ***\n", __func__);
+
+ for(i=0; i<5; i++)
+ {
+ if(i == 0)
+ {
+ nPattern = nBasePattern; //Patn => Pattern
+ }
+
+ n16BitsPattern = ((nPattern & 0xF) << nBaseLen*2) | (nPattern << nBaseLen) | nPattern;
+
+ if(i == 4)
+ {
+ nCSub16Bits[i] = n16BitsPattern & nLastFilter;
+ }
+ else
+ {
+ nCSub16Bits[i] = n16BitsPattern;
+ }
+ nPattern = (u8)((n16BitsPattern >> 4) & nFilter);
+ }
+
+ RegSet16BitValue(0x215C, 0x1FFF);
+
+ for (i = 0; i < 5; i++)
+ {
+ RegSet16BitValue(0x2148 + 2 * i, nCSub16Bits[i]);
+ RegSet16BitValue(0x2152 + 2 * i, nCSub16Bits[i]);
+ }
+}
+
+/*
+static void _DrvMpTestItoOpenTestAFEGainOne(void)
+{
+ u8 nRegData = 0;
+ u16 nAFECoef = 0;
+
+ DBG("*** %s() ***\n", __func__);
+
+ // AFE gain = 1X
+ RegSet16BitValue(0x1318, 0x4440);
+ RegSet16BitValue(0x131A, 0x4444);
+ RegSet16BitValue(0x13D6, 0x2000);
+
+ RegSet16BitValue(0x2160, 0x0040);
+ RegSet16BitValue(0x2162, 0x0040);
+ RegSet16BitValue(0x2164, 0x0040);
+ RegSet16BitValue(0x2166, 0x0040);
+ RegSet16BitValue(0x2168, 0x0040);
+ RegSet16BitValue(0x216A, 0x0040);
+ RegSet16BitValue(0x216C, 0x0040);
+ RegSet16BitValue(0x216E, 0x0040);
+ RegSet16BitValue(0x2170, 0x0040);
+ RegSet16BitValue(0x2172, 0x0040);
+ RegSet16BitValue(0x2174, 0x0040);
+ RegSet16BitValue(0x2176, 0x0040);
+ RegSet16BitValue(0x2178, 0x0040);
+ RegSet16BitValue(0x217A, 0x1FFF);
+ RegSet16BitValue(0x217C, 0x1FFF);
+
+ /// reg_hvbuf_sel_gain
+ RegSet16BitValue(0x1564, 0x0077);
+
+ /// all AFE Cfb use defalt (50p)
+ RegSet16BitValue(0x1508, 0x1FFF);// all AFE Cfb: SW control
+ RegSet16BitValue(0x1550, 0x0000);// all AFE Cfb use defalt (50p)
+
+ ///ADC: AFE Gain bypass
+ RegSet16BitValue(0x1260, 0x1FFF);
+
+ //AFE coef
+ nRegData = RegGetLByteValue(0x101A);
+ nAFECoef = (u16)(0x10000/nRegData);
+ RegSet16BitValue(0x13D6, nAFECoef);
+}
+*/
+
+static void _DrvMpTestItoOpenTestAFEGainOne(void)
+{
+ // AFE gain = 1X
+ u16 nAfeGain = 0;
+ u16 nDriOpening = 0;
+ u8 nRegData = 0;
+ u16 nAfeCoef = 0;
+ u16 i = 0;
+
+
+ //proto.MstarReadReg(loopDevice, (uint)0x1312, ref regdata); //get dri num
+ nRegData = RegGetLByteValue(0x1312);
+ nDriOpening = nRegData;
+
+ ///filter unit gain
+ if (nDriOpening == 11 || nDriOpening == 15)
+ {
+ RegSet16BitValue(0x1318, 0x4470);
+ }
+ else if (nDriOpening == 7)
+ {
+ RegSet16BitValue(0x1318, 0x4460);
+ }
+
+ //proto.MstarWriteReg_16(loopDevice, 0x131A, 0x4444);
+ RegSet16BitValue(0x131A, 0x4444);
+
+ ///AFE coef
+ //proto.MstarReadReg(loopDevice, (uint)0x101A, ref regdata);
+ nRegData = RegGetLByteValue(0x101A);
+ nAfeCoef = 0x10000 / nRegData;
+ //proto.MstarWriteReg_16(loopDevice, (uint)0x13D6, AFE_coef);
+ RegSet16BitValue(0x13D6, nAfeCoef);
+
+ ///AFE gain
+ if (nDriOpening == 7 || nDriOpening == 15)
+ {
+ nAfeGain = 0x0040;
+ }
+ else if (nDriOpening == 11)
+ {
+ nAfeGain = 0x0055;
+ }
+
+ for (i = 0; i < 13; i++)
+ {
+ RegSet16BitValue(0x2160 + 2 * i, nAfeGain);
+ }
+
+ ///AFE gain: over write enable
+ RegSet16BitValue(0x217A, 0x1FFF);
+ RegSet16BitValue(0x217C, 0x1FFF);
+
+ /// all AFE Cfb use defalt (50p)
+ RegSet16BitValue(0x1508, 0x1FFF);// all AFE Cfb: SW control
+ RegSet16BitValue(0x1550, 0x0000);// all AFE Cfb use defalt (50p)
+
+ /// reg_hvbuf_sel_gain
+ RegSet16BitValue(0x1564, 0x0077);
+
+ ///ADC: AFE Gain bypass
+ RegSet16BitValue(0x1260, 0x1FFF);
+}
+
+static void _DrvMpTestItoOpenTestCalibrateMutualCsub(s16 nCSub)
+{
+ u8 nChipVer;
+
+ DBG("*** %s() ***\n", __func__);
+
+ nChipVer = RegGetLByteValue(0x1ECE);
+ DBG("*** Msg28xx Open Test# Chip ID = %d ***\n", nChipVer);
+
+ if (nChipVer != 0)
+ RegSet16BitValue(0x10F0, 0x0004);//bit2
+
+ _DrvMpTestItoOpenTestSetMutualCsubViaDBbus(nCSub);
+ _DrvMpTestItoOpenTestAFEGainOne();
+}
+
+static void _DrvMpTestItoTestDBBusReadDQMemStart(void)
+{
+ u8 nParCmdSelUseCfg = 0x7F;
+ u8 nParCmdAdByteEn0 = 0x50;
+ u8 nParCmdAdByteEn1 = 0x51;
+ u8 nParCmdDaByteEn0 = 0x54;
+ u8 nParCmdUSetSelB0 = 0x80;
+ u8 nParCmdUSetSelB1 = 0x82;
+ u8 nParCmdSetSelB2 = 0x85;
+ u8 nParCmdIicUse = 0x35;
+ //u8 nParCmdWr = 0x10;
+
+ DBG("*** %s() ***\n", __func__);
+
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdSelUseCfg, 1);
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdAdByteEn0, 1);
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdAdByteEn1, 1);
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdDaByteEn0, 1);
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdUSetSelB0, 1);
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdUSetSelB1, 1);
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdSetSelB2, 1);
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdIicUse, 1);
+}
+
+/*
+static void _DrvMpTestItoTestDBBusReadDQMemStartAddr24(void)
+{
+ u8 nParCmdSelUseCfg = 0x7F;
+// u8 nParCmdAdByteEn0 = 0x50;
+// u8 nParCmdAdByteEn1 = 0x51;
+ u8 nParCmdAdByteEn2 = 0x52;
+// u8 nParCmdDaByteEn0 = 0x54;
+ u8 nParCmdUSetSelB0 = 0x80;
+ u8 nParCmdUSetSelB1 = 0x82;
+ u8 nParCmdSetSelB2 = 0x85;
+ u8 nParCmdIicUse = 0x35;
+ //u8 nParCmdWr = 0x10;
+
+ DBG("*** %s() ***\n", __func__);
+
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdSelUseCfg, 1);
+ //IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdAdByteEn0, 1);
+ //IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdAdByteEn1, 1);
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdAdByteEn2, 1);
+ //IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdDaByteEn0, 1);
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdUSetSelB0, 1);
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdUSetSelB1, 1);
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdSetSelB2, 1);
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdIicUse, 1);
+}
+*/
+
+static void _DrvMpTestItoTestDBBusReadDQMemEnd(void)
+{
+ u8 nParCmdNSelUseCfg = 0x7E;
+
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdNSelUseCfg, 1);
+}
+
+/*
+static void _DrvMpTestItoTestDBBusReadDQMemEndAddr24(void)
+{
+ u8 nParCmdSelUseCfg = 0x7F;
+ u8 nParCmdAdByteEn1 = 0x51;
+ u8 nParCmdSetSelB0 = 0x81;
+ u8 nParCmdSetSelB1 = 0x83;
+ u8 nParCmdNSetSelB2 = 0x84;
+ u8 nParCmdIicUse = 0x35;
+ u8 nParCmdNSelUseCfg = 0x7E;
+ u8 nParCmdNIicUse = 0x34;
+
+ DBG("*** %s() ***\n", __func__);
+ RegSetLByteValue(0, 0);
+
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdSelUseCfg, 1);
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdAdByteEn1, 1);
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdSetSelB0, 1);
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdSetSelB1, 1);
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdNSetSelB2, 1);
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdIicUse, 1);
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdNSelUseCfg, 1);
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &nParCmdNIicUse, 1);
+}
+*/
+
+static void _DrvMpTestItoTestMsg28xxEnableAdcOneShot(void)
+{
+ RegSet16BitValueOn(0x100a, BIT0);
+
+ return;
+}
+
+static s32 _DrvMpTestItoTestMsg28xxTriggerMutualOneShot(s16 * pResultData, u16 * pSenNum, u16 * pDrvNum)
+{
+ u16 nAddr = 0x5000, nAddrNextSF = 0x1A4;
+ u16 nSF = 0, nAfeOpening = 0, nDriOpening = 0;
+ u16 nMaxDataNumOfOneSF = 0;
+ u16 nDriMode = 0;
+ int nDataShift = -1;
+ u16 i, j, k;
+ u8 nRegData = 0;
+ u8 nShotData[392] = {0};//13*15*2
+ u16 nRegDataU16 = 0;
+ s16 * pShotDataAll = NULL;
+
+ DBG("*** %s() ***\n", __func__);
+
+ nRegData = RegGetLByteValue(0x130A);
+ nSF = nRegData>>4;
+ nAfeOpening = nRegData & 0x0f;
+
+ if (nSF == 0)
+ {
+ return -1;
+ }
+
+ nRegData = RegGetLByteValue(0x100B);
+ nDriMode = nRegData;
+
+ nRegData = RegGetLByteValue(0x1312);
+ nDriOpening = nRegData;
+
+ DBG("*** Msg28xx MP Test# TriggerMutualOneShot nSF=%d, nAfeOpening=%d, nDriMode=%d, nDriOpening=%d. ***\n", nSF, nAfeOpening, nDriMode, nDriOpening);
+
+ nMaxDataNumOfOneSF = nAfeOpening * nDriOpening;
+
+ pShotDataAll = kzalloc(sizeof(s16) * nSF * nMaxDataNumOfOneSF, GFP_KERNEL);
+
+ RegSet16BitValueOff(0x3D08, BIT8); ///FIQ_E_FRAME_READY_MASK
+
+ ///polling frame-ready interrupt status
+ _DrvMpTestItoTestMsg28xxEnableAdcOneShot();
+
+ while (0x0000 == (nRegDataU16 & BIT8))
+ {
+ nRegDataU16 = RegGet16BitValue(0x3D18);
+ }
+
+ if (nDriMode == 2) // for short test
+ {
+ if (nAfeOpening % 2 == 0)
+ nDataShift = -1;
+ else
+ nDataShift = 0; //special case
+ //s16 nShortResultData[nSF][nAfeOpening];
+
+ /// get ALL raw data
+ for (i = 0; i < nSF; i++)
+ {
+ _DrvMpTestItoTestDBBusReadDQMemStart();
+ RegGetXBitValue(nAddr + i * nAddrNextSF, nShotData, 28, MAX_I2C_TRANSACTION_LENGTH_LIMIT);
+ _DrvMpTestItoTestDBBusReadDQMemEnd();
+
+ //_ItoTestDebugShowArray(nShotData, 26, 8, 16, 16);
+ for (j = 0; j < nAfeOpening; j++)
+ {
+ pResultData[i*MAX_CHANNEL_DRV+j] = (s16)(nShotData[2 * j] | nShotData[2 * j + 1] << 8);
+
+ if (nDataShift == 0 && (j == nAfeOpening-1))
+ {
+ pResultData[i*MAX_CHANNEL_DRV+j] = (s16)(nShotData[2 * (j + 1)] | nShotData[2 * (j + 1) + 1] << 8);
+ }
+ }
+ }
+
+ *pSenNum = nSF;
+ *pDrvNum = nAfeOpening;
+ }
+ else // for open test
+ {
+ //s16 nOpenResultData[nSF * nAfeOpening][nDriOpening];
+
+ if (nAfeOpening % 2 == 0 || nDriOpening % 2 == 0)
+ nDataShift = -1;
+ else
+ nDataShift = 0; //special case
+
+ /// get ALL raw data, combine and handle datashift.
+ for (i = 0; i < nSF; i++)
+ {
+ _DrvMpTestItoTestDBBusReadDQMemStart();
+ RegGetXBitValue(nAddr + i * nAddrNextSF, nShotData, 392, MAX_I2C_TRANSACTION_LENGTH_LIMIT);
+ _DrvMpTestItoTestDBBusReadDQMemEnd();
+
+ //_ItoTestDebugShowArray(nShotData, 390, 8, 10, 16);
+ for (j = 0; j < nMaxDataNumOfOneSF; j++)
+ {
+ pShotDataAll[i*nMaxDataNumOfOneSF+j] = (s16)(nShotData[2 * j] | nShotData[2 * j + 1] << 8);
+
+ if (nDataShift == 0 && j == (nMaxDataNumOfOneSF - 1))
+ pShotDataAll[i*nMaxDataNumOfOneSF+j] = (s16)(nShotData[2 * (j + 1)] | nShotData[2 * (j + 1) + 1] << 8);
+ }
+ }
+
+ //problem here
+ for (k = 0; k < nSF; k++)
+ {
+ for (i = k * nAfeOpening; i < nAfeOpening * (k + 1); i++) //Sen
+ {
+ for (j = 0; j < nDriOpening; j++) //Dri
+ {
+ pResultData[i*MAX_CHANNEL_DRV+j] = pShotDataAll[k*nMaxDataNumOfOneSF + (j + (i - nAfeOpening * k) * nDriOpening)]; //resultData[Sen, Dri]
+ }
+ }
+ }
+
+ *pSenNum = nSF * nAfeOpening;
+ *pDrvNum = nDriOpening;
+ }
+ RegSet16BitValueOn(0x3D08, BIT8); ///FIQ_E_FRAME_READY_MASK
+ RegSet16BitValueOn(0x3D08, BIT4); ///FIQ_E_TIMER0_MASK
+
+ kfree(pShotDataAll);
+
+ return 0;
+}
+
+static s32 _DrvMpTestItoTestMsg28xxGetMutualOneShotRawIIR(s16 * nResultData, u16 * pSenNum, u16 * pDrvNum)
+{
+ return _DrvMpTestItoTestMsg28xxTriggerMutualOneShot(nResultData, pSenNum, pDrvNum);
+}
+
+static s32 _DrvMpTestItoTestMsg28xxGetDeltaC(s32 *pDeltaC)
+{
+ s16 * pRawData = NULL;
+ s16 nRawDataOverlapDone[SENSE_NUM][DRIVE_NUM] = {{0}};
+ //s16 nDeltaC[MAX_MUTUAL_NUM] = {0};
+ u16 nDrvPos = 0, nSenPos = 0, nShift = 0;
+ u16 nSenNumBak = 0;
+ u16 nDrvNumBak = 0;
+ s16 i, j;
+
+ DBG("*** %s() ***\n", __func__);
+
+ pRawData = kzalloc(sizeof(s16) * MAX_CHANNEL_SEN*2 * MAX_CHANNEL_DRV, GFP_KERNEL);
+
+ if(_DrvMpTestItoTestMsg28xxGetMutualOneShotRawIIR(pRawData, &nSenNumBak, &nDrvNumBak) < 0)
+ {
+ DBG("*** Msg28xx Open Test# GetMutualOneShotRawIIR failed! ***\n");
+ return -1;
+ }
+
+ DBG("*** Msg28xx Open Test# nSenNumBak=%d nDrvNumBak=%d ***\n", nSenNumBak, nDrvNumBak);
+
+ for (i = 0; i < nSenNumBak; i++)
+ {
+ for (j = 0; j < nDrvNumBak; j++)
+ {
+ nShift = (u16)(i * nDrvNumBak + j);
+ nDrvPos = g_MapVaMutual[nShift][1];
+ nSenPos = g_MapVaMutual[nShift][0];
+ if (nDrvPos != 0xFF && nSenPos != 0xFF)
+ nRawDataOverlapDone[nSenPos][nDrvPos] = pRawData[i*MAX_CHANNEL_DRV+j];
+ }
+ }
+
+ for (i = 0; i < _gSenseLineNum; i++)
+ {
+ for (j = 0; j < _gDriveLineNum; j++)
+ {
+ nShift = (u16)(i * _gDriveLineNum + j);
+ pDeltaC[nShift] = (s32)nRawDataOverlapDone[i][j];
+ }
+ }
+
+ DBG("*** Msg28xx Open Test# gDeltaC ***\n");
+ _ItoTestDebugShowArray(pDeltaC, _gSenseLineNum * _gDriveLineNum, -32, 10, _gSenseLineNum);
+
+ kfree(pRawData);
+
+ return 0;
+}
+
+static void _DrvMpTestItoTestMsg28xxAnaSwReset(void)
+{
+ DBG("*** %s() ***\n", __func__);
+
+ /// reset ANA
+ RegSet16BitValueOn(0x1002, (BIT0 | BIT1 | BIT2 | BIT3)); ///reg_tgen_soft_rst: 1 to reset
+ RegSet16BitValueOff(0x1002, (BIT0 | BIT1 | BIT2 | BIT3));
+
+ /// delay
+ mdelay(20);
+}
+
+static s32 _DrvMpTestMsg28xxItoOpenTest(void)
+{
+ DBG("*** %s() ***\n", __func__);
+
+ // Stop mcu
+ RegSet16BitValue(0x0FE6, 0x0001);
+
+ _DrvMpTestItoOpenTestCalibrateMutualCsub(CSUB_REF);
+ RegSet16BitValue(0x156A, 0x000A); ///DAC com voltage
+ _DrvMpTestItoTestMsg28xxAnaSwReset();
+
+
+ if(_DrvMpTestItoTestMsg28xxGetDeltaC(_gDeltaC) < 0)
+ {
+ DBG("*** Msg28xx Open Test# GetDeltaC failed! ***\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+static u8 _DrvMpTestItoTestCheckValueInRange(s32 nValue, s32 nMax, s32 nMin)
+{
+ if (nValue <= nMax && nValue >= nMin)
+ {
+ return 1;
+ }
+ else
+ {
+ return 0;
+ }
+}
+
+static s32 _DrvMpTestItoOpenTestMsg28xxOpenJudge(u16 nItemID, s8 pNormalTestResult[][2], u16 pNormalTestResultCheck[][13]/*, u16 nDriOpening*/)
+{
+ s32 nRetVal = 0;
+ u16 nCSub = CSUB_REF;
+ u16 nRowNum = 0, nColumnNum = 0;
+ u32 nSum=0, nAvg=0, nDelta=0, nPrev=0;
+ u16 i, j, k;
+
+ DBG("*** %s() ***\n", __func__);
+
+ for (i = 0; i < _gSenseLineNum * _gDriveLineNum; i++)
+ {
+ //deltaC_result[i] = deltaC[i];
+ //_gResult[i] = 1673 * nCSub - _gDeltaC[i] * 2 / (nDriOpening + 1);
+ if (_gDeltaC[i] > 31000)
+ {
+ return -1;
+ }
+
+ _gResult[i] = 1673 * nCSub - _gDeltaC[i];
+
+ // For mutual key, last column if not be used, show number "one".
+ if ((MUTUAL_KEY == 1 || MUTUAL_KEY == 2) && (KEY_NUM != 0))
+ {
+ if ((_gSenseLineNum < _gDriveLineNum) && ((i + 1) % _gDriveLineNum == 0))
+ {
+ _gResult[i] = -32000;
+ for (k = 0; k < KEY_NUM; k++)
+ if ((i + 1) / _gDriveLineNum == KEYSEN[k])
+ {
+ //_gResult[i] = 1673 * nCSub - _gDeltaC[i] * 2 / (nDriOpening + 1);
+ _gResult[i] = 1673 * nCSub - _gDeltaC[i];
+ }
+ }
+
+ if ((_gSenseLineNum > _gDriveLineNum) && (i > (_gSenseLineNum - 1) * _gDriveLineNum - 1))
+ {
+ _gResult[i] = -32000;
+ for (k = 0; k < KEY_NUM; k++)
+ if (((i + 1) - (_gSenseLineNum - 1) * _gDriveLineNum) == KEYSEN[k])
+ {
+ //_gResult[i] = 1673 * nCSub - _gDeltaC[i] * 2 / (nDriOpening + 1);
+ _gResult[i] = 1673 * nCSub - _gDeltaC[i];
+ }
+ }
+ }
+ }
+
+ if(_gDriveLineNum >= _gSenseLineNum)
+ {
+ nRowNum = _gDriveLineNum;
+ nColumnNum = _gSenseLineNum;
+ }
+ else
+ {
+ nRowNum = _gSenseLineNum;
+ nColumnNum = _gDriveLineNum;
+ }
+
+ DBG("*** Msg28xx Open Test# Show _gResult ***\n");
+ //_ItoTestDebugShowS32Array(_gResult, nRowNum, nColumnNum);
+ _ItoTestDebugShowArray(_gResult, nRowNum*nColumnNum, -32, 10, nColumnNum);
+
+ //for (j = 0; j < nRowNum; j ++)
+ for (j = 0; j < (nRowNum-1); j ++)
+ {
+ nSum = 0;
+ for (i = 0; i < nColumnNum; i++)
+ {
+ nSum = nSum + _gResult[i * nRowNum + j];
+ }
+
+ nAvg = nSum / nColumnNum;
+ //DBG("*** Msg28xx Open Test# OpenJudge average=%d ***\n", nAvg);
+ for (i = 0; i < nColumnNum; i ++)
+ {
+ if (0 == _DrvMpTestItoTestCheckValueInRange(_gResult[i * nRowNum + j], (s32)(nAvg + nAvg * DC_RANGE/100), (s32)(nAvg - nAvg * DC_RANGE/100)))
+ {
+ _gTestFailChannel[i * nRowNum + j] = 1;
+ _gTestFailChannelCount ++;
+ nRetVal = -1;
+ }
+
+ if (i > 0)
+ {
+ nDelta = _gResult[i * nRowNum + j] > nPrev ? (_gResult[i * nRowNum + j] - nPrev) : (nPrev - _gResult[i * nRowNum + j]);
+ if (nDelta > nPrev*FIR_RATIO/100)
+ {
+ if (0 == _gTestFailChannel[i * nRowNum + j]) // for avoid _gTestFailChannelCount to be added twice
+ {
+ _gTestFailChannel[i * nRowNum + j] = 1;
+ _gTestFailChannelCount ++;
+ }
+ nRetVal = -1;
+ DBG("\nSense%d, Drive%d, MAX_Ratio = %d,%d\t", i, j, nDelta, nPrev);
+ }
+ }
+ nPrev = _gResult[i * nRowNum + j];
+ }
+ }
+
+ //DBG("*** Msg28xx Open Test# OpenJudge _gTestFailChannelCount=%d ***\n", _gTestFailChannelCount);
+ return nRetVal;
+}
+
+static s32 _DrvMpTestItoTestCheckSwitchStatus(void)
+{
+ u32 nRegData = 0;
+ int nTimeOut = 100;
+ int nT = 0;
+
+ do
+ {
+ nRegData = RegGet16BitValue(0x1402);
+ mdelay(20);
+ nT++;
+ if (nT > nTimeOut)
+ {
+ return -1;
+ }
+
+ } while (nRegData != 0x7447);
+
+ return 0;
+}
+
+static s32 _DrvMpTestMsg28xxItoTestSwitchFwMode(u8 nFMode)
+{
+ DBG("*** %s() ***\n", __func__);
+
+ mdelay(100);
+ RegSet16BitValue(0x0FE6, 0x0001); //MCU_stop
+ RegSet16BitValue(0X3C60, 0xAA55); // disable watch dog
+
+ RegSet16BitValue(0X3D08, 0xFFFF);
+ RegSet16BitValue(0X3D18, 0xFFFF);
+
+ RegSet16BitValue(0x1402, 0x7474);
+
+ //RegSet16BitValue((uint)0x1E04, (uint)0x7D60);
+ RegSet16BitValue(0x1E04, 0x829F);
+ RegSet16BitValue(0x0FE6, 0x0000);
+ mdelay(150);
+
+ if (_DrvMpTestItoTestCheckSwitchStatus()<0)
+ {
+ DBG("*** Msg28xx MP Test# CheckSwitchStatus failed! ***\n");
+ return -1;
+ }
+
+ switch (nFMode)
+ {
+ case MUTUAL:
+ RegSet16BitValue(0x1402, 0x5705);
+ break;
+
+ case SELF:
+ RegSet16BitValue(0x1402, 0x6278);
+ break;
+
+ case WATERPROOF:
+ RegSet16BitValue(0x1402, 0x7992);
+ break;
+
+ case MUTUAL_SINGLE_DRIVE:
+ RegSet16BitValue(0x1402, 0x0158);
+ break;
+
+ default:
+ return -1;
+ }
+ if (_DrvMpTestItoTestCheckSwitchStatus()<0)
+ {
+ DBG("*** Msg28xx MP Test# CheckSwitchStatus failed! ***\n");
+ return -1;
+ }
+
+ RegSet16BitValue(0x0FE6, 0x0001);// stop mcu
+ RegSet16BitValue(0x3D08, 0xFEFF);//open timer
+
+ return 0;
+}
+
+s32 _DrvMpTestMsg28xxItoOpenTestEntry(void)
+{
+ s32 nRetVal = 0;
+// u8 nDrvOpening = 0;
+ //u16 nCheckState = 0;
+ s8 nNormalTestResult[8][2] = {{0}}; //0:golden 1:ratio
+ u16 nNormalTestResultCheck[6][13] = {{0}}; //6:max subframe 13:max afe
+
+ DBG("*** %s() ***\n", __func__);
+
+#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
+
+ _gSenseLineNum = SENSE_NUM;
+ _gDriveLineNum = DRIVE_NUM;
+
+ DrvPlatformLyrDisableFingerTouchReport();
+ DrvPlatformLyrTouchDeviceResetHw();
+
+ //reset_only
+ DbBusResetSlave();
+ DbBusEnterSerialDebugMode();
+ //DbBusWaitMCU();
+ DbBusStopMCU();
+ DbBusIICUseBus();
+ DbBusIICReshape();
+ mdelay(100);
+
+ // Stop mcu
+ RegSet16BitValue(0x0FE6, 0x0001);
+
+ if(_DrvMpTestMsg28xxItoTestSwitchFwMode(MUTUAL) < 0)
+ {
+ DBG("*** Msg28xx Open Test# SwitchFwMode failed! ***\n");
+ return -1;
+ }
+
+ //nDrvOpening = RegGetLByteValue(0x1312);
+
+ if(_DrvMpTestMsg28xxItoOpenTest() < 0)
+ {
+ DBG("*** Msg28xx Open Test# OpenTest failed! ***\n");
+ return -1;
+ }
+
+ mdelay(10);
+
+ nRetVal = _DrvMpTestItoOpenTestMsg28xxOpenJudge(0, nNormalTestResult, nNormalTestResultCheck/*, nDrvOpening*/);
+ DBG("*** Msg28xx Open Test# OpenTestOpenJudge return value = %d ***\n", nRetVal);
+
+ DbBusIICNotUseBus();
+ DbBusNotStopMCU();
+ DbBusExitSerialDebugMode();
+
+ DrvPlatformLyrTouchDeviceResetHw();
+ mdelay(300);
+
+ DrvPlatformLyrEnableFingerTouchReport();
+
+ return nRetVal;
+}
+
+s32 _DrvMpTestItoOpenTest(void)
+{
+ s32 nRetVal = -1;
+
+ DBG("*** %s() ***\n", __func__);
+
+ if (g_ChipType == CHIP_TYPE_MSG26XXM)
+ {
+ nRetVal = _DrvMpTestMsg26xxmItoOpenTestEntry();
+ }
+ else if (g_ChipType == CHIP_TYPE_MSG28XX)
+ {
+ nRetVal = _DrvMpTestMsg28xxItoOpenTestEntry();
+ }
+
+ return nRetVal;
+}
+
+static void _DrvMpTestItoTestSendDataIn(u16 nAddr, u16 nLength, u16 *data)
+{
+ u8 szDbBusTxData[256] = {0};
+ int i = 0;
+
+ szDbBusTxData[0] = 0x10;
+ szDbBusTxData[1] = (nAddr >> 8) & 0xFF;
+ szDbBusTxData[2] = (nAddr & 0xFF);
+
+ for (i = 0; i <= nLength ; i ++)
+ {
+ szDbBusTxData[3+2*i] = (data[i] & 0xFF);
+ szDbBusTxData[4+2*i] = (data[i] >> 8) & 0xFF;
+ }
+
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &szDbBusTxData[0], 3+nLength*2);
+}
+
+static void _DrvMpTestItoShortTestMsg26xxmSetPAD2GPO(u8 nItemID)
+{
+ u16 gpioSetting[MAX_CHANNEL_NUM] = {0};
+ u16 gpioEnabling[MAX_CHANNEL_NUM] = {0};
+ u16 gpioZero[MAX_CHANNEL_NUM] = {0};
+ u8 gpioNum = 0;
+ u16 *gpioPIN = NULL;
+ int i = 0;
+ int j = 0;
+
+ DBG("*** %s() ***\n", __func__);
+
+ if (nItemID == 1)
+ {
+ gpioNum = SHORT_N1_GPO_NUMBER_X;
+ gpioPIN = kzalloc(sizeof(u16) * gpioNum, GFP_KERNEL);
+
+ for (i = 0; i < gpioNum; i++)
+ {
+ gpioPIN[i] = SHORT_N1_GPO_PIN_X[i];
+ }
+ }
+ else if (nItemID == 2)
+ {
+ gpioNum = SHORT_N2_GPO_NUMBER_X;
+ gpioPIN = kzalloc(sizeof(u16) * gpioNum, GFP_KERNEL);
+
+ for (i = 0; i < gpioNum; i++)
+ {
+ gpioPIN[i] = SHORT_N2_GPO_PIN_X[i];
+ }
+ }
+ else if (nItemID == 3)
+ {
+ gpioNum = SHORT_S1_GPO_NUMBER_X;
+ gpioPIN = kzalloc(sizeof(u16) * gpioNum, GFP_KERNEL);
+
+ for (i = 0; i < gpioNum; i++)
+ {
+ gpioPIN[i] = SHORT_S1_GPO_PIN_X[i];
+ }
+ }
+ else if (nItemID == 4)
+ {
+ gpioNum = SHORT_S2_GPO_NUMBER_X;
+ gpioPIN = kzalloc(sizeof(u16) * gpioNum, GFP_KERNEL);
+
+ for (i = 0; i < gpioNum; i++)
+ {
+ gpioPIN[i] = SHORT_S2_GPO_PIN_X[i];
+ }
+ }
+ DBG("ItemID %d, gpioNum %d",nItemID, gpioNum);
+
+ for (i = 0; i < MAX_CHANNEL_NUM; i++)
+ {
+ gpioEnabling[i] = 0xFFFF;
+ }
+
+ for (i = 0; i < gpioNum; i++)
+ {
+ gpioSetting[gpioPIN[i] / 16] |= (u16)(1 << (gpioPIN[i] % 16));
+ gpioEnabling[gpioPIN[i] / 16] &= (u16)(~(1 << (gpioPIN[i] % 16)));
+ }
+
+ ///cts sw overwrite
+ {
+ _DrvMpTestItoTestSendDataIn(0x1E66, gpioNum, &gpioSetting[0]); ///who -> will be controlled
+ _DrvMpTestItoTestSendDataIn(0x1E6C, gpioNum, &gpioEnabling[0]); ///who -> enable sw overwrite
+ _DrvMpTestItoTestSendDataIn(0x1E72, gpioNum, &gpioZero[0]); ///who -> set2GPO
+ _DrvMpTestItoTestSendDataIn(0x1E78, gpioNum, &gpioZero[0]); ///who -> GPO2GND
+ }
+
+ for (j = 0; j < gpioNum; j++)
+ {
+ if (PIN_GUARD_RING == gpioPIN[j])
+ {
+ u16 u16RegData;
+ u16RegData = RegGet16BitValue(0x1E12);
+ u16RegData = ((u16RegData & 0xFFF9) | BIT0);
+ RegSet16BitValue(0x1E12, u16RegData);
+ }
+ }
+
+ kfree(gpioPIN);
+}
+
+static void _DrvMpTestItoShortTestMsg26xxmChangeANASetting(u8 nItemID)
+{
+ u16 SHORT_MAP_ANA1[7] = {0};
+ u16 SHORT_MAP_ANA2[1] = {0};
+ u16 SHORT_MAP_ANA3[21] = {0};
+ int i = 0;
+
+ DBG("*** %s() ***\n", __func__);
+
+ if (nItemID == 1)
+ {
+ for (i = 0; i < 7; i++)
+ {
+ SHORT_MAP_ANA1[i] = short_ANA1_N1_X[i];
+ }
+
+ for (i = 0; i < 21; i++)
+ {
+ SHORT_MAP_ANA3[i] = short_ANA3_N1_X[i];
+ }
+
+ SHORT_MAP_ANA2[0] = short_ANA2_N1_X[0];
+ }
+ else if (nItemID == 2)
+ {
+ for (i = 0; i < 7; i++)
+ {
+ SHORT_MAP_ANA1[i] = short_ANA1_N2_X[i];
+ }
+
+ for (i = 0; i < 21; i++)
+ {
+ SHORT_MAP_ANA3[i] = short_ANA3_N2_X[i];
+ }
+
+ SHORT_MAP_ANA2[0] = short_ANA2_N2_X[0];
+ }
+ else if (nItemID == 3)
+ {
+ for (i = 0; i < 7; i++)
+ {
+ SHORT_MAP_ANA1[i] = short_ANA1_S1_X[i];
+ }
+
+ for (i = 0; i < 21; i++)
+ {
+ SHORT_MAP_ANA3[i] = short_ANA3_S1_X[i];
+ }
+
+ SHORT_MAP_ANA2[0] = short_ANA2_S1_X[0];
+ }
+ else if (nItemID == 4)
+ {
+ for (i = 0; i < 7; i++)
+ {
+ SHORT_MAP_ANA1[i] = short_ANA1_S2_X[i];
+ }
+
+ for (i = 0; i < 21; i++)
+ {
+ SHORT_MAP_ANA3[i] = short_ANA3_S2_X[i];
+ }
+
+ SHORT_MAP_ANA2[0] = short_ANA2_S2_X[0];
+ }
+
+ ///change ANA setting
+ {
+ _DrvMpTestItoTestSendDataIn(0x1178, 7, &SHORT_MAP_ANA1[0]); ///ANA1_3C_42
+ _DrvMpTestItoTestSendDataIn(0x1216, 1, &SHORT_MAP_ANA2[0]); ///ANA2_0B
+ _DrvMpTestItoTestSendDataIn(0x1006, 21, &SHORT_MAP_ANA3[0]); ///ANA3_03_17
+ }
+}
+
+static void _DrvMpTestItoShortTestMsg26xxmAnaFixPrs(u16 nOption)
+{
+ u16 nTemp = 0;
+
+ DBG("*** %s() ***\n", __func__);
+
+ nTemp = RegGet16BitValue(0x1208); //bank:ana2, addr:h000a
+ nTemp &= 0x00F1;
+ nTemp |= (u16)((nOption << 1) & 0x000E);
+ RegSet16BitValue(0x1208, nTemp);
+}
+
+static void _DrvMpTestItoShortTestMsg26xxmSetNoiseSensorMode(u8 nEnable)
+{
+ DBG("*** %s() ***\n", __func__);
+
+ if (nEnable)
+ {
+ RegSet16BitValueOn(0x110E, BIT11);
+ RegSet16BitValueOff(0x1116, BIT2);
+ }
+ else
+ {
+ RegSet16BitValueOff(0x110E, BIT11);
+ }
+}
+
+static void _DrvMpTestItoShortTestMsg26xxmAndChangeCDtime(u16 nTime1, u16 nTime2)
+{
+ DBG("*** %s() ***\n", __func__);
+
+ RegSet16BitValue(0x1224, nTime1);
+ RegSet16BitValue(0x122A, nTime2);
+}
+
+static void _DrvMpTestMsg26xxmItoShortTest(u8 nItemID)
+{
+ int i;
+
+ DBG("*** %s() ***\n", __func__);
+
+ _DrvMpTestItoTestMsg26xxmMcuStop();
+ _DrvMpTestItoShortTestMsg26xxmSetPAD2GPO(nItemID);
+ _DrvMpTestItoShortTestMsg26xxmChangeANASetting(nItemID);
+ _DrvMpTestItoTestMsg26xxmAnaSwitchToMutual();
+ _DrvMpTestItoShortTestMsg26xxmAnaFixPrs(7);
+ _DrvMpTestItoTestMsg26xxmDisableFilterNoiseDetect();
+ _DrvMpTestItoShortTestMsg26xxmSetNoiseSensorMode(1);
+ _DrvMpTestItoShortTestMsg26xxmAndChangeCDtime(SHORT_Charge_X, SHORT_Dump1_X);
+ _DrvMpTestItoTestMsg26xxmAnaSwReset();
+ _DrvMpTestItoTestMsg26xxmGetDeltaC(_gTempDeltaC);
+
+ _DrvMpTestItoTestMsg26xxmMcuStop();
+ _DrvMpTestItoShortTestMsg26xxmSetPAD2GPO(nItemID);
+ _DrvMpTestItoShortTestMsg26xxmChangeANASetting(nItemID);
+ _DrvMpTestItoTestMsg26xxmAnaSwitchToMutual();
+ _DrvMpTestItoShortTestMsg26xxmAnaFixPrs(7);
+ _DrvMpTestItoTestMsg26xxmDisableFilterNoiseDetect();
+ _DrvMpTestItoShortTestMsg26xxmSetNoiseSensorMode(1);
+ _DrvMpTestItoShortTestMsg26xxmAndChangeCDtime(SHORT_Charge_X, SHORT_Dump2_X);
+ _DrvMpTestItoTestMsg26xxmAnaSwReset();
+ _DrvMpTestItoTestMsg26xxmGetDeltaC(_gDeltaC);
+
+ for (i = 0; i < MAX_MUTUAL_NUM ; i++)
+ {
+ if ((_gDeltaC[i] <= -(IIR_MAX)) || (_gTempDeltaC[i] <= -(IIR_MAX)) || (_gDeltaC[i] >= (IIR_MAX)) || (_gTempDeltaC[i] >= (IIR_MAX)))
+ {
+ _gDeltaC[i] = 0x7FFF;
+ }
+ else
+ {
+ _gDeltaC[i] = abs(_gDeltaC[i] - _gTempDeltaC[i]);
+ }
+ //DBG("ItemID%d, MUTUAL_NUM %d, _gDeltaC = %d\t", nItemID, i, _gDeltaC[i]);
+ }
+ DBG("\n");
+}
+
+static s32 _DrvMpTestItoShortTestCovertRValue(s32 nValue)
+{
+ if (nValue == 0)
+ {
+ nValue = 1;
+ }
+
+ if (nValue >= IIR_MAX)
+ {
+ return 0;
+ }
+
+ return ((500*11398) / (nValue));
+}
+
+static ItoTestResult_e _DrvMpTestItoShortTestMsg26xxmJudge(u8 nItemID)
+{
+ ItoTestResult_e nRetVal = ITO_TEST_OK;
+ u8 nTestPinLength = 0;
+ u16 i = 0;
+ u8 nGpioNum = 0;
+ u8* nTestGpio = NULL;
+
+ DBG("*** %s() ***\n", __func__);
+
+ if (nItemID == 1)
+ {
+ nGpioNum = SHORT_N1_TEST_NUMBER_X;
+ nTestGpio = kzalloc(sizeof(u16) * nGpioNum, GFP_KERNEL);
+
+ for (i = 0; i < nGpioNum; i++)
+ {
+ nTestGpio[i] = SHORT_N1_TEST_PIN_X[i];
+ }
+ }
+ else if (nItemID == 2)
+ {
+ nGpioNum = SHORT_N2_TEST_NUMBER_X;
+ nTestGpio = kzalloc(sizeof(u16) * nGpioNum, GFP_KERNEL);
+
+ for (i = 0; i < nGpioNum; i++)
+ {
+ nTestGpio[i] = SHORT_N2_TEST_PIN_X[i];
+ }
+ }
+ else if (nItemID == 3)
+ {
+ nGpioNum = SHORT_S1_TEST_NUMBER_X;
+ nTestGpio = kzalloc(sizeof(u16) * nGpioNum, GFP_KERNEL);
+
+ for (i = 0; i < nGpioNum; i++)
+ {
+ nTestGpio[i] = SHORT_S1_TEST_PIN_X[i];
+ }
+ }
+ else if (nItemID == 4)
+ {
+ nGpioNum = SHORT_S2_TEST_NUMBER_X;
+ nTestGpio = kzalloc(sizeof(u16) * nGpioNum, GFP_KERNEL);
+
+ for (i = 0; i < nGpioNum; i++)
+ {
+ nTestGpio[i] = SHORT_S2_TEST_PIN_X[i];
+ }
+ }
+
+ nTestPinLength = nGpioNum;
+
+ for (i = 0;i < nTestPinLength; i++)
+ {
+ _gShortTestChannel[i] = nTestGpio[i];
+
+ if (0 == _DrvMpTestItoTestCheckValueInRange(_gDeltaC[i], SHORT_VALUE, -SHORT_VALUE))
+ {
+ nRetVal = ITO_TEST_FAIL;
+ _gTestFailChannelCount++;
+ DBG("_gShortTestChannel i = %d, _gDeltaC = %d\t", i, _gDeltaC[i]);
+ }
+ }
+ kfree(nTestGpio);
+
+ return nRetVal;
+}
+
+static ItoTestResult_e _DrvMpTestMsg26xxmItoShortTestEntry(void)
+{
+ ItoTestResult_e nRetVal1 = ITO_TEST_OK, nRetVal2 = ITO_TEST_OK, nRetVal3 = ITO_TEST_OK, nRetVal4 = ITO_TEST_OK, nRetVal5 = ITO_TEST_OK;
+ u32 i = 0;
+ u32 j = 0;
+ u16 nTestPinCount = 0;
+ s32 nShortThreshold = 0;
+
+ DBG("*** %s() ***\n", __func__);
+
+#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
+
+ DrvPlatformLyrDisableFingerTouchReport();
+
+ DrvPlatformLyrTouchDeviceResetHw();
+
+ //auto detetc fw version to decide switch fw mode
+ if (_gTestAutoSwitchFlag!=0)
+ {
+ _DrvMpTestItoTestMsg26xxmGetSwitchFlag();
+ }
+
+ DbBusEnterSerialDebugMode();
+ DbBusStopMCU();
+ DbBusIICUseBus();
+ DbBusIICReshape();
+ mdelay(100);
+
+ _DrvMpTestItoTestMsg26xxmSwitchMode(_gTestSwitchMode, MUTUAL);
+
+ for (i = 0; i < MAX_CHANNEL_NUM; i ++)
+ {
+ _gShortTestChannel[i] = 0;
+ }
+
+ for (i = 0; i < MAX_MUTUAL_NUM; i ++)
+ {
+ _gDeltaC[i] = 0;
+ }
+
+ _gSenseLineNum = _DrvMpTestItoTestAnaGetMutualChannelNum();
+ _gDriveLineNum = _DrvMpTestItoTestAnaGetMutualSubFrameNum();
+
+ for (i = 0; i < MAX_CHANNEL_NUM; i ++)
+ {
+ _gShortTestChannel[i] = 0xff;
+ }
+
+ _gTestFailChannelCount = 0;
+
+ nTestPinCount = 0; // Reset nTestPinCount to 0 before test start
+
+ //N1_ShortTest
+
+ if (g_ChipType == CHIP_TYPE_MSG26XXM)
+ {
+ _DrvMpTestMsg26xxmItoShortTest(1);
+ }
+
+ nRetVal2 = _DrvMpTestItoShortTestMsg26xxmJudge(1);
+
+ for (i = 0; i < MAX_CHANNEL_NUM; i++)
+ {
+ if (_gShortTestChannel[i] != 0)
+ {
+ nTestPinCount++;
+ }
+ }
+
+ for (i = 0; i < nTestPinCount; i++)
+ {
+ for (j = 0; j < _gSenseLineNum; j++)
+ {
+ if (_gShortTestChannel[i] == SENSE_X[j])
+ {
+ _gSenseR[j] = _DrvMpTestItoShortTestCovertRValue(_gDeltaC[i]);
+
+ DBG("_gSenseR[%d] = %d\t", j , _gSenseR[j]);
+ }
+ }
+ }
+ DBG("\n");
+
+ //clear
+ for (i = 0; i < MAX_CHANNEL_NUM; i ++)
+ {
+ _gShortTestChannel[i] = 0xff;
+ }
+
+ nTestPinCount = 0;
+
+ //N2_ShortTest
+
+ if (g_ChipType == CHIP_TYPE_MSG26XXM)
+ {
+ _DrvMpTestMsg26xxmItoShortTest(2);
+ }
+
+ nRetVal3 = _DrvMpTestItoShortTestMsg26xxmJudge(2);
+
+ for (i = 0; i < MAX_CHANNEL_NUM; i++)
+ {
+ if (_gShortTestChannel[i] != 0)
+ {
+ nTestPinCount++;
+ }
+ }
+
+ for (i = 0; i < nTestPinCount; i++)
+ {
+ for (j = 0; j < _gSenseLineNum; j++)
+ {
+ if (_gShortTestChannel[i] == SENSE_X[j])
+ {
+ _gSenseR[j] = _DrvMpTestItoShortTestCovertRValue(_gDeltaC[i]);
+
+ DBG("_gSenseR[%d] = %d\t", j , _gSenseR[j]);
+ }
+ }
+ }
+ DBG("\n");
+
+ for (i = 0; i < MAX_CHANNEL_NUM; i ++)
+ {
+ _gShortTestChannel[i] = 0xff;
+ }
+ nTestPinCount = 0;
+
+ if (g_ChipType == CHIP_TYPE_MSG26XXM)
+ {
+ _DrvMpTestMsg26xxmItoShortTest(3);
+ }
+
+ nRetVal4 = _DrvMpTestItoShortTestMsg26xxmJudge(3);
+
+ for (i = 0; i < MAX_CHANNEL_NUM; i++)
+ {
+ if (_gShortTestChannel[i] != 0)
+ {
+ nTestPinCount++;
+ }
+ }
+
+ for (i = 0; i < nTestPinCount; i++)
+ {
+ for (j = 0; j < _gDriveLineNum; j++)
+ {
+ if (_gShortTestChannel[i] == DRIVE_X[j])
+ {
+ _gDriveR[j] = _DrvMpTestItoShortTestCovertRValue(_gDeltaC[i]);
+ DBG("_gDriveR[%d] = %d\t", j , _gDriveR[j]);
+ }
+ }
+ }
+ DBG("\n");
+
+ for (i = 0; i < MAX_CHANNEL_NUM; i ++)
+ {
+ _gShortTestChannel[i] = 0xff;
+ }
+ nTestPinCount = 0;
+
+ if (g_ChipType == CHIP_TYPE_MSG26XXM)
+ {
+ _DrvMpTestMsg26xxmItoShortTest(4);
+ }
+
+ nRetVal4 = _DrvMpTestItoShortTestMsg26xxmJudge(4);
+
+ for (i = 0; i < MAX_CHANNEL_NUM; i++)
+ {
+ if (_gShortTestChannel[i] != 0)
+ {
+ nTestPinCount++;
+ }
+ }
+
+ for (i = 0; i < nTestPinCount; i++)
+ {
+ for (j = 0; j < _gDriveLineNum ; j++)
+ {
+ if (_gShortTestChannel[i] == DRIVE_X[j])
+ {
+ _gDriveR[j] = _DrvMpTestItoShortTestCovertRValue(_gDeltaC[i]);
+ DBG("_gDriveR[%d] = %d\t", j , _gDriveR[j]);
+ }
+ }
+ }
+ DBG("\n");
+
+ for (i = 0; i < MAX_CHANNEL_NUM; i ++)
+ {
+ _gShortTestChannel[i] = 0xff;
+ }
+ nTestPinCount = 0;
+ nShortThreshold = _DrvMpTestItoShortTestCovertRValue(SHORT_VALUE);
+
+ for (i = 0; i < _gSenseLineNum; i++)
+ {
+ _gResult[i] = _gSenseR[i];
+ }
+
+ for (i = 0; i < _gDriveLineNum; i++)
+ {
+ _gResult[i + _gSenseLineNum] = _gDriveR[i];
+ }
+
+ for (i = 0; i < (_gSenseLineNum + _gDriveLineNum); i++)
+ {
+ if (_gResult[i] < nShortThreshold)
+ {
+ _gTestFailChannel[i] = 1;
+ }
+ else
+ {
+ _gTestFailChannel[i] = 0;
+ }
+ }
+
+ DbBusIICNotUseBus();
+ DbBusNotStopMCU();
+ DbBusExitSerialDebugMode();
+
+ DrvPlatformLyrTouchDeviceResetHw();
+ mdelay(300);
+
+ DrvPlatformLyrEnableFingerTouchReport();
+
+ DBG("short test end\n");
+
+ DBG("nRetVal1 = %d, nRetVal2 = %d, nRetVal3 = %d, nRetVal4 = %d, nRetVal5 = %d\n",nRetVal1,nRetVal2,nRetVal3,nRetVal4,nRetVal5);
+
+ if ((nRetVal1 != ITO_TEST_OK) && (nRetVal2 == ITO_TEST_OK) && (nRetVal3 == ITO_TEST_OK) && (nRetVal4 == ITO_TEST_OK) && (nRetVal5 == ITO_TEST_OK))
+ {
+ return ITO_TEST_GET_TP_TYPE_ERROR;
+ }
+ else if ((nRetVal1 == ITO_TEST_OK) && ((nRetVal2 != ITO_TEST_OK) || (nRetVal3 != ITO_TEST_OK) || (nRetVal4 != ITO_TEST_OK) || (nRetVal5 != ITO_TEST_OK)))
+ {
+ return -1;
+ }
+ else
+ {
+ return ITO_TEST_OK;
+ }
+}
+
+static void _DrvMpTestItoShortTestMsg28xxSetNoiseSensorMode(u8 nEnable)
+{
+ s16 j;
+
+ DBG("*** %s() ***\n", __func__);
+
+ if (nEnable)
+ {
+ RegSet16BitValueOn(0x1546, BIT4);
+ for (j = 0; j < 10; j++)
+ {
+ RegSet16BitValue(0x2148 + 2 * j, 0x0000);
+ }
+ RegSet16BitValue(0x215C, 0x1FFF);
+ }
+}
+
+static void _DrvMpTestItoShortTestMsg28xxAnaFixPrs(u16 nOption)
+{
+ u16 nRegData = 0;
+
+ DBG("*** %s() ***\n", __func__);
+
+ RegSet16BitValue(0x0FE6, 0x0001);
+
+ nRegData = RegGet16BitValue(0x1008);
+ nRegData &= 0x00F1;
+ nRegData |= (u16)((nOption << 1) & 0x000E);
+ RegSet16BitValue(0x1008, nRegData);
+}
+
+static void _DrvMpTestItoShortTestMsg28xxAndChangeCDtime(u16 nTime1, u16 nTime2)
+{
+ DBG("*** %s() ***\n", __func__);
+
+ RegSet16BitValue(0x1026, nTime1);
+ RegSet16BitValue(0x1030, nTime2);
+}
+
+static void _DrvMpTestItoShortTestMsg28xxChangeANASetting(void)
+{
+ int i, nMappingItem;
+ u8 nChipVer;
+
+
+ DBG("*** %s() ***\n", __func__);
+
+ // Stop mcu
+ RegSet16BitValue(0x0FE6, 0x0001); //bank:mheg5, addr:h0073
+
+ nChipVer = RegGetLByteValue(0x1ECE);
+ //uint chip_ver = Convert.ToUInt16((uint)regdata[0]); //for U01 (SF shift).
+
+ if (nChipVer != 0)
+ RegSetLByteValue(0x131E, 0x01);
+
+ for (nMappingItem = 0; nMappingItem < 6; nMappingItem++)
+ {
+ /// sensor mux sram read/write base address / write length
+ RegSetLByteValue(0x2192, 0x00);
+ RegSetLByteValue(0x2102, 0x01);
+ RegSetLByteValue(0x2102, 0x00);
+ RegSetLByteValue(0x2182, 0x08);
+ RegSetLByteValue(0x2180, 0x08 * nMappingItem);
+ RegSetLByteValue(0x2188, 0x01);
+
+ for (i = 0; i < 8; i++)
+ {
+ if (nMappingItem == 0 && nChipVer == 0x0)
+ {
+ RegSet16BitValue(0x218A, _gMuxMem_20_3E_0_Settings[2 * i]);
+ RegSet16BitValue(0x218C, _gMuxMem_20_3E_0_Settings[2 * i + 1]);
+ }
+ if ((nMappingItem == 1 && nChipVer == 0x0) || (nMappingItem == 0 && nChipVer != 0x0))
+ {
+ RegSet16BitValue(0x218A, _gMuxMem_20_3E_1_Settings[2 * i]);
+ RegSet16BitValue(0x218C, _gMuxMem_20_3E_1_Settings[2 * i + 1]);
+ }
+ if ((nMappingItem == 2 && nChipVer == 0x0) || (nMappingItem == 1 && nChipVer != 0x0))
+ {
+ RegSet16BitValue(0x218A, _gMuxMem_20_3E_2_Settings[2 * i]);
+ RegSet16BitValue(0x218C, _gMuxMem_20_3E_2_Settings[2 * i + 1]);
+ }
+ if ((nMappingItem == 3 && nChipVer == 0x0) || (nMappingItem == 2 && nChipVer != 0x0))
+ {
+ RegSet16BitValue(0x218A, _gMuxMem_20_3E_3_Settings[2 * i]);
+ RegSet16BitValue(0x218C, _gMuxMem_20_3E_3_Settings[2 * i + 1]);
+ }
+ if ((nMappingItem == 4 && nChipVer == 0x0) || (nMappingItem == 3 && nChipVer != 0x0))
+ {
+ RegSet16BitValue(0x218A, _gMuxMem_20_3E_4_Settings[2 * i]);
+ RegSet16BitValue(0x218C, _gMuxMem_20_3E_4_Settings[2 * i + 1]);
+ }
+ if ((nMappingItem == 5 && nChipVer == 0x0) || (nMappingItem == 4 && nChipVer != 0x0))
+ {
+ RegSet16BitValue(0x218A, _gMuxMem_20_3E_5_Settings[2 * i]);
+ RegSet16BitValue(0x218C, _gMuxMem_20_3E_5_Settings[2 * i + 1]);
+ }
+ if (nMappingItem == 5 && nChipVer != 0x0)
+ {
+ RegSet16BitValue(0x218A, _gMuxMem_20_3E_6_Settings[2 * i]);
+ RegSet16BitValue(0x218C, _gMuxMem_20_3E_6_Settings[2 * i + 1]);
+ }
+ }
+ }
+}
+
+static void _DrvMpTestItoReadSetting(u16 * pPad2Sense, u16 * pPad2Drive, u16 * pPad2GR)
+{
+ DBG("*** %s() ***\n", __func__);
+
+ memcpy(_gMuxMem_20_3E_1_Settings, SHORT_N1_MUX_MEM_20_3E, sizeof(u16) * 16);
+ memcpy(_gMuxMem_20_3E_2_Settings, SHORT_N2_MUX_MEM_20_3E, sizeof(u16) * 16);
+ memcpy(_gMuxMem_20_3E_3_Settings, SHORT_S1_MUX_MEM_20_3E, sizeof(u16) * 16);
+ memcpy(_gMuxMem_20_3E_4_Settings, SHORT_S2_MUX_MEM_20_3E, sizeof(u16) * 16);
+
+ if(SHORT_TEST_5_TYPE != 0)
+ {
+ memcpy(_gMuxMem_20_3E_5_Settings, SHORT_X_MUX_MEM_20_3E, sizeof(u16) * 16);
+ }
+
+ memcpy(pPad2Sense, PAD_TABLE_SENSE, sizeof(u16) * _gSenseLineNum);
+ memcpy(pPad2Drive, PAD_TABLE_DRIVE, sizeof(u16) * _gDriveLineNum);
+
+ if (GR_NUM != 0)
+ {
+ memcpy(pPad2GR, PAD_TABLE_GR, sizeof(u16) * GR_NUM);
+ }
+}
+
+static s32 _DrvMpTestItoShortTestMsg28xxGetValueR(s32 * pTarget)
+{
+ s16 * pRawData = NULL;
+ u16 nSenNumBak = 0;
+ u16 nDrvNumBak = 0;
+ u16 nShift = 0;
+ s16 i, j;
+
+ DBG("*** %s() ***\n", __func__);
+
+ pRawData = kzalloc(sizeof(s16) * MAX_CHANNEL_SEN*2 * MAX_CHANNEL_DRV, GFP_KERNEL);
+
+ if (_DrvMpTestItoTestMsg28xxGetMutualOneShotRawIIR(pRawData, &nSenNumBak, &nDrvNumBak) < 0)
+ {
+ DBG("*** Msg28xx Short Test# GetMutualOneShotRawIIR failed! ***\n");
+ return -1;
+ }
+
+ for (i = 0; i < 5; i++)
+ {
+ for (j = 0; j < 13; j++)
+ {
+ nShift = (u16)(j + 13 * i);
+ pTarget[nShift] = pRawData[i*MAX_CHANNEL_DRV+j];
+ }
+ }
+
+ kfree(pRawData);
+
+ return 0;
+}
+
+static s32 _DrvMpTestMsg28xxItoShortTest(u8 nItemID)
+{
+ s16 i;
+ u8 nRegData = 0;
+ u16 nAfeCoef = 0;
+
+ DBG("*** %s() ***\n", __func__);
+
+ // Stop mcu
+ RegSet16BitValue(0x0FE6, 0x0001); //bank:mheg5, addr:h0073
+
+ ///set Subframe = 6 ; Sensor = 13
+ RegSetLByteValue(0x130A, 0x6D);
+ RegSetLByteValue(0x1103, 0x06);
+ RegSetLByteValue(0x1016, 0x0C);
+
+ RegSetLByteValue(0x1104, 0x0C);
+ RegSetLByteValue(0x100C, 0x0C);
+ RegSetLByteValue(0x1B10, 0x0C);
+
+ /// adc analog+digital pipe delay, 60= 13 AFE.
+ RegSetLByteValue(0x102F, 0x60);
+
+ ///trim: Fout 52M & 1.2V
+ RegSet16BitValue(0x1420, 0xA55A);//password
+ RegSet16BitValue(0x1428, 0xA55A);//password
+ RegSet16BitValue(0x1422, 0xFC4C);//go
+
+ _DrvMpTestItoShortTestMsg28xxSetNoiseSensorMode(1);
+ _DrvMpTestItoShortTestMsg28xxAnaFixPrs(3);
+ _DrvMpTestItoShortTestMsg28xxAndChangeCDtime(0x007E, 0x001F);
+
+ ///DAC overwrite
+ RegSet16BitValue(0x150C, 0x80A2); //bit15 //AE:3.5v for test
+ RegSet16BitValue(0x1520, 0xFFFF);//After DAC overwrite, output DC
+ RegSet16BitValue(0x1522, 0xFFFF);
+ RegSet16BitValue(0x1524, 0xFFFF);
+ RegSet16BitValue(0x1526, 0xFFFF);
+
+ /// all AFE Cfb use defalt (50p)
+ RegSet16BitValue(0x1508, 0x1FFF);// all AFE Cfb: SW control
+ RegSet16BitValue(0x1550, 0x0000);// all AFE Cfb use defalt (50p)
+
+ /// reg_afe_icmp disenable
+ RegSet16BitValue(0x1552, 0x0000);
+
+ /// reg_hvbuf_sel_gain
+ RegSet16BitValue(0x1564, 0x0077);
+
+ ///ADC: AFE Gain bypass
+ RegSet16BitValue(0x1260, 0x1FFF);
+
+ ///reg_sel_ros disenable
+ RegSet16BitValue(0x156A, 0x0000);
+
+ ///reg_adc_desp_invert disenable
+ RegSetLByteValue(0x1221, 0x00);
+
+
+ ///AFE coef
+ //protoHandle.MstarReadReg(mdkDevice, (uint)0x101A, ref regdata);
+ nRegData = RegGetLByteValue(0x101A);
+ nAfeCoef = 0x10000 / nRegData;
+ //protoHandle.MstarWriteReg_16(mdkDevice, (uint)0x13D6, AFE_coef);
+ RegSet16BitValue(0x13D6, nAfeCoef);
+
+ /// AFE gain = 1X
+ //RegSet16BitValue(0x1318, 0x4440);
+ //RegSet16BitValue(0x131A, 0x4444);
+ //RegSet16BitValue(0x13D6, 0x2000);
+
+ _DrvMpTestItoShortTestMsg28xxChangeANASetting();
+ _DrvMpTestItoTestMsg28xxAnaSwReset();
+
+ if (_DrvMpTestItoShortTestMsg28xxGetValueR(_gDeltaC)<0)
+ {
+ DBG("*** Msg28xx Short Test# GetValueR failed! ***\n");
+ return -1;
+ }
+ _ItoTestDebugShowArray(_gDeltaC, 128, -32, 10, 8);
+
+ for (i = 0; i < 65; i++) // 13 AFE * 5 subframe
+ {
+ if (_gDeltaC[i] <= -1000 || _gDeltaC[i] >= (IIR_MAX))
+ _gDeltaC[i] = 0x7FFF;
+ else
+ _gDeltaC[i] = abs(_gDeltaC[i]);
+ }
+ return 0;
+}
+
+static s32 _DrvMpTestItoShortTestReadTestPins(u8 nItemID, u16 * pTestPins)
+{
+ u16 nCount = 0;
+ s16 i;
+
+ DBG("*** %s() ***\n", __func__);
+
+ switch (nItemID)
+ {
+ case 1:
+ case 11:
+ nCount = SHORT_N1_TEST_NUMBER;
+ memcpy(pTestPins, SHORT_N1_TEST_PIN, sizeof(u16) * nCount);
+ break;
+ case 2:
+ case 12:
+ nCount = SHORT_N2_TEST_NUMBER;
+ memcpy(pTestPins, SHORT_N2_TEST_PIN, sizeof(u16) * nCount);
+ break;
+ case 3:
+ case 13:
+ nCount = SHORT_S1_TEST_NUMBER;
+ memcpy(pTestPins, SHORT_S1_TEST_PIN, sizeof(u16) * nCount);
+ break;
+ case 4:
+ case 14:
+ nCount = SHORT_S2_TEST_NUMBER;
+ memcpy(pTestPins, SHORT_S2_TEST_PIN, sizeof(u16) * nCount);
+ break;
+
+ case 5:
+ case 15:
+ if(SHORT_TEST_5_TYPE != 0)
+ {
+ nCount = SHORT_X_TEST_NUMBER;
+ memcpy(pTestPins, SHORT_X_TEST_PIN, sizeof(u16) * nCount);
+ }
+ break;
+
+ case 0:
+ default:
+ return 0;
+ }
+
+ for (i = nCount; i < MAX_CHANNEL_NUM; i++)
+ {
+ pTestPins[i] = 0xFFFF; //PIN_NO_ERROR
+ }
+
+ return nCount;
+}
+
+static s32 _DrvMpTestItoShortTestMsg28xxJudge(u8 nItemID, /*s8 pNormalTestResult[][2],*/ u16 pTestPinMap[][13], u16 * pTestPinCount)
+{
+ s32 nRetVal = 0;
+ u16 nTestPins[MAX_CHANNEL_NUM];
+ s16 i;
+
+ DBG("*** %s() ***\n", __func__);
+
+ *pTestPinCount = _DrvMpTestItoShortTestReadTestPins(nItemID, nTestPins);
+ //_ItoTestDebugShowArray(nTestPins, *pTestPinCount, 16, 10, 8);
+ if (*pTestPinCount == 0)
+ {
+ if (nItemID == 5 && SHORT_TEST_5_TYPE == 0)
+ {
+
+ }
+ else
+ {
+ DBG("*** Msg28xx Short Test# TestPinCount = 0 ***\n");
+ return -1;
+ }
+ }
+
+ /*
+ u16 nCountTestPin = 0;
+ for (i = 0; i < testPins.Length; i++)
+ {
+ if (pTestPins[i] != 0xFFFF)
+ nCountTestPin++;
+ }
+ */
+
+ for (i = (nItemID - 1) * 13; i < (13 * nItemID); i++)
+ {
+ _gResult[i] = _gDeltaC[i];
+ }
+
+ for (i = 0; i < *pTestPinCount; i++)
+ {
+ pTestPinMap[nItemID][i] = nTestPins[i];
+ if (0 == _DrvMpTestItoTestCheckValueInRange(_gResult[i + (nItemID - 1) * 13], SHORTVALUE, -1000)) //0: false 1: true
+ {
+ //pNormalTestResult[nItemID][0] = -1; //-1: failed 0: success
+ // //0: golden 1: ratio
+ DBG("*** Msg28xx Short Test# ShortTestMsg28xxJudge failed! ***\n");
+ nRetVal = -1;
+ }
+ }
+
+ DBG("*** Msg28xx Short Test# nItemID = %d ***\n", nItemID);
+ //_ItoTestDebugShowArray(pTestPinMap[nItemID], *pTestPinCount, 16, 10, 8);
+
+ return nRetVal;
+}
+
+static s32 _DrvMpTestItoShortTestMsg28xxCovertRValue(s32 nValue)
+{
+ if (nValue >= IIR_MAX)
+ {
+ return 0;
+ }
+
+ //return ((3.53 - 1.3) * 10 / (50 * (((float)nValue - 0 ) / 32768 * 1.1)));
+ return 223 * 32768 / (nValue * 550);
+}
+
+static s32 _DrvMpTestMsg28xxItoShortTestEntry(void)
+{
+ //ItoTestResult_e nRetVal1 = ITO_TEST_OK, nRetVal2 = ITO_TEST_OK, nRetVal3 = ITO_TEST_OK, nRetVal4 = ITO_TEST_OK, nRetVal5 = ITO_TEST_OK;
+ s16 i = 0, j = 0;
+ //u16 nTestPinCount = 0;
+ //s32 nShortThreshold = 0;
+ u16 nPad2Drive[DRIVE_NUM] = {0};
+ u16 nPad2Sense[SENSE_NUM] = {0};
+ u16 nPad2GR[MAX_CHANNEL_NUM] = {0};
+ s32 nResultTemp[(MAX_CHANNEL_SEN+MAX_CHANNEL_DRV)*2] = {0};
+
+ ///short test1 to 5.
+ //u16 nTestPinCount = 0;
+ u16 nTestItemLoop = 6;
+ u16 nTestItem = 0;
+ //s8 nNormalTestResult[8][2] = {0}; //0:golden 1:ratio
+ u16 nTestPinMap[6][13] = {{0}}; //6:max subframe 13:max afe
+ u16 nTestPinNum = 0;
+// s32 nThrs = 0;
+ u32 nRetVal = 0;
+
+ DBG("*** %s() ***\n", __func__);
+
+#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
+
+ _gSenseLineNum = SENSE_NUM;
+ _gDriveLineNum = DRIVE_NUM;
+
+ DrvPlatformLyrDisableFingerTouchReport();
+ DrvPlatformLyrTouchDeviceResetHw();
+
+ //reset_only
+ DbBusResetSlave();
+ DbBusEnterSerialDebugMode();
+ DbBusWaitMCU();
+ DbBusIICUseBus();
+ DbBusIICReshape();
+ mdelay(100);
+
+ if(_DrvMpTestMsg28xxItoTestSwitchFwMode(MUTUAL_SINGLE_DRIVE) < 0)
+ {
+ DBG("*** Msg28xx Short Test# Switch FW mode failed! ***\n");
+ return -1;
+ }
+
+ _DrvMpTestItoReadSetting(nPad2Sense, nPad2Drive, nPad2GR);
+
+
+ //N1_ShortTest
+ if(_DrvMpTestMsg28xxItoShortTest(1) < 0)
+ {
+ DBG("*** Msg28xx Short Test# Get DeltaC failed! ***\n");
+ return -1;
+ }
+
+ for (nTestItem = 1; nTestItem < nTestItemLoop; nTestItem++)
+ {
+ DBG("*** Short test item %d ***\n", nTestItem);
+ if (_DrvMpTestItoShortTestMsg28xxJudge(nTestItem, /*nNormalTestResult,*/ nTestPinMap, &nTestPinNum) < 0)
+ {
+ DBG("*** Msg28xx Short Test# Item %d is failed! ***\n", nTestItem);
+ nRetVal = -1;
+ }
+
+ if (nTestItem == 1 || nTestItem == 2 || (nTestItem == 5 && SHORT_TEST_5_TYPE == 1))
+ {
+ for (i = 0; i < nTestPinNum; i++)
+ {
+ for (j = 0; j < _gSenseLineNum; j++)
+ {
+ if (nTestPinMap[nTestItem][i] == nPad2Sense[j])
+ {
+ //_gSenseR[j] = _DrvMpTestItoShortTestMsg28xxCovertRValue(_gResult[i + (nTestItem - 1) * 13]);
+ _gSenseR[j] = _gResult[i + (nTestItem - 1) * 13]; //change comparison way because float computing in driver is prohibited
+ }
+ }
+ }
+ }
+
+ if (nTestItem == 3 || nTestItem == 4 || (nTestItem == 5 && SHORT_TEST_5_TYPE == 2))
+ {
+ for (i = 0; i < nTestPinNum; i++)
+ {
+ for (j = 0; j < _gDriveLineNum; j++)
+ {
+ if (nTestPinMap[nTestItem][i] == nPad2Drive[j])
+ {
+ //_gDriveR[j] = _DrvMpTestItoShortTestMsg28xxCovertRValue(_gResult[i + (nTestItem - 1) * 13]);
+ _gDriveR[j] = _gResult[i + (nTestItem - 1) * 13]; //change comparison way because float computing in driver is prohibited
+ }
+ }
+ }
+ }
+
+ if (nTestItem == 5 && SHORT_TEST_5_TYPE == 3)
+ {
+ for (i = 0; i < nTestPinNum; i++)
+ {
+ for (j = 0; j < GR_NUM; j++)
+ {
+ if (nTestPinMap[nTestItem][i] == nPad2GR[j])
+ {
+ //_gGRR[j] = _DrvMpTestItoShortTestMsg28xxCovertRValue(_gResult[i + (nTestItem - 1) * 13]);
+ _gGRR[j] = _gResult[i + (nTestItem - 1) * 13]; //change comparison way because float computing in driver is prohibited
+ }
+ }
+ }
+ }
+ }
+
+ for (i = 0; i < _gSenseLineNum; i++)
+ {
+ nResultTemp[i] = _gSenseR[i];
+ }
+
+ //for (i = 0; i < _gDriveLineNum - 1; i++)
+ for (i = 0; i < _gDriveLineNum; i++)
+ {
+ nResultTemp[i + _gSenseLineNum] = _gDriveR[i];
+ }
+
+ //nThrs = _DrvMpTestItoShortTestMsg28xxCovertRValue(SHORTVALUE);
+ for (i = 0; i < _gSenseLineNum + _gDriveLineNum; i++)
+ {
+ if(nResultTemp[i] == 0)
+ {
+ _gResult[i] = _DrvMpTestItoShortTestMsg28xxCovertRValue(1);
+ }
+ else
+ {
+ _gResult[i] = _DrvMpTestItoShortTestMsg28xxCovertRValue(nResultTemp[i]);
+ }
+ }
+
+ _ItoTestDebugShowArray(_gResult, _gSenseLineNum + _gDriveLineNum, -32, 10, 8);
+ //for (i = 0; i < (_gSenseLineNum + _gDriveLineNum - 1); i++)
+ for (i = 0; i < (_gSenseLineNum + _gDriveLineNum); i++)
+ {
+ if (nResultTemp[i] > SHORTVALUE) //change comparison way because float computing in driver is prohibited
+ {
+ _gTestFailChannel[i] = 1;
+ _gTestFailChannelCount++;
+ nRetVal = -1;
+ }
+ else
+ {
+ _gTestFailChannel[i] = 0;
+ }
+ }
+
+ DbBusIICNotUseBus();
+ DbBusNotStopMCU();
+ DbBusExitSerialDebugMode();
+
+ DrvPlatformLyrTouchDeviceResetHw();
+ mdelay(300);
+
+ DrvPlatformLyrEnableFingerTouchReport();
+ return nRetVal;
+}
+
+static s32 _DrvMpTestItoShortTest(void)
+{
+ s32 nRetVal = -1;
+
+ DBG("*** %s() ***\n", __func__);
+
+ if (g_ChipType == CHIP_TYPE_MSG26XXM)
+ {
+ return _DrvMpTestMsg26xxmItoShortTestEntry();
+ }
+ else if(g_ChipType == CHIP_TYPE_MSG28XX)
+ {
+ return _DrvMpTestMsg28xxItoShortTestEntry();
+ }
+
+ return nRetVal;
+}
+
+static s32 _DrvMpTestItoTestMsg26xxmGetWaterProofOneShotRawIir(u16 wszResultData[])
+{
+ u16 nRegData;
+ u16 i;
+ u16 nTemp;
+ u8 szDbBusTxData[3];
+ u32 nGetdataNum = 12;
+ u8 szShotData[24] = {0}; //Get 12 FIR data
+
+ DBG("*** %s() ***\n", __func__);
+
+ nTemp = RegGet16BitValue(0x3D08); //bank:intr_ctrl, addr:h0004
+ nTemp &= (~(BIT8));
+ RegSet16BitValue(0x3D08, nTemp);
+ //RegSet16BitValueOff(0x3D08, BIT8); ///FIQ_E_FRAME_READY_MASK
+
+ _DrvMpTestItoTestMsg26xxmEnableAdcOneShot();
+
+ nRegData = 0;
+ while (0x0000 == (nRegData & BIT8))
+ {
+ nRegData = RegGet16BitValue(0x3D18); //bank:intr_ctrl, addr:h000c
+ }
+
+ for (i = 0; i < nGetdataNum * 2; i ++)
+ {
+ szShotData[i] = 0;
+ }
+
+ mdelay(200);
+ szDbBusTxData[0] = 0x10;
+ szDbBusTxData[1] = 0x13; //bank:fir, addr:h0021
+ szDbBusTxData[2] = 0x42;
+ IicWriteData(SLAVE_I2C_ID_DBBUS, &szDbBusTxData[0], 3);
+ IicReadData(SLAVE_I2C_ID_DBBUS, &szShotData[0], 24); //12
+
+ for (i = 0; i < nGetdataNum; i ++)
+ {
+ nRegData = (u16)(szShotData[i * 2] | szShotData[i * 2 + 1] << 8);
+ wszResultData[i] = (short)nRegData;
+
+ //DBG("wszResultData[%d] = %x\t", i , wszResultData[i]);
+ }
+
+ nTemp = RegGet16BitValue(0x3D08); //bank:intr_ctrl, addr:h0004
+ nTemp |= (BIT8 | BIT4);
+ RegSet16BitValue(0x3D08, nTemp);
+
+ return 0;
+}
+
+static s32 _DrvMpTestItoTestMsg26xxmGetWaterProofDeltaC(s32 *pTarget)
+{
+ u16 wszRawData[12];
+ u16 i;
+
+ DBG("*** %s() ***\n", __func__);
+
+ if (_DrvMpTestItoTestMsg26xxmGetWaterProofOneShotRawIir(wszRawData) < 0)
+ {
+ DBG("*** Msg26xxm WaterProof Test# GetMutualOneShotRawIIR failed! ***\n");
+ return -1;
+ }
+
+ for (i = 0; i < 12; i ++)
+ {
+ pTarget[i] = (s16)wszRawData[i];
+ }
+
+ return 0;
+}
+
+static s32 _DrvMpTestMsg26xxmItoWaterProofTest(void)
+{
+ DBG("*** %s() ***\n", __func__);
+
+ // Stop mcu
+ //RegSet16BitValue(0x0FE6, 0x0001);
+
+ _DrvMpTestItoTestMsg26xxmAnaSwReset();
+
+ _DrvMpTestItoShortTestMsg26xxmAndChangeCDtime(WATERPROOF_Charge_X, WATERPROOF_Dump_X);
+
+ if(_DrvMpTestItoTestMsg26xxmGetWaterProofDeltaC(_gDeltaC) < 0)
+ {
+ DBG("*** Msg26xxm WaterProof Test# GetWaterDeltaC failed! ***\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+static s32 _DrvMpTestMsg26xxmItoWaterProofTestJudge(void)
+{
+ u16 i;
+ u32 nGetdataNum = 12;
+
+ DBG("*** %s() ***\n", __func__);
+
+ for (i = 0; i < nGetdataNum; i ++)
+ {
+ _gResultWater[i] = 0;
+ }
+
+ for (i = 0; i < nGetdataNum; i++)
+ {
+ _gResultWater[i] = _gDeltaC[i];
+ }
+
+ return 0;
+}
+
+s32 _DrvMpTestMsg26xxmItoWaterProofTestEntry(void)
+{
+ s32 nRetVal = 0;
+ u32 nRegData = 0;
+ u16 i = 0;
+ s32 nResultTemp[12] = {0};
+
+ DBG("*** %s() ***\n", __func__);
+
+#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
+
+ _gWaterProofNum = 12;
+
+ DrvPlatformLyrDisableFingerTouchReport();
+
+ DrvPlatformLyrTouchDeviceResetHw();
+
+ //auto detetc fw version to decide switch fw mode
+ if (_gTestAutoSwitchFlag!=0)
+ {
+ _DrvMpTestItoTestMsg26xxmGetSwitchFlag();
+ }
+
+ DbBusResetSlave();
+ DbBusEnterSerialDebugMode();
+ DbBusStopMCU();
+ DbBusIICUseBus();
+ DbBusIICReshape();
+ mdelay(100);
+
+ if(_DrvMpTestItoTestMsg26xxmSwitchMode(_gTestSwitchMode, WATERPROOF) < 0)
+ {
+ DBG("*** Msg26xxm WaterProof Test# Switch FW mode failed! ***\n");
+ return -1;
+ }
+
+ _DrvMpTestItoTestMsg26xxmMcuStop();
+
+ nRegData = RegGet16BitValue(0x3CE4);
+
+ if (nRegData == 0x8bbd)//// if polling 0X8BBD, means the FW is NOT supporting WP.
+ {
+ DBG("*** Msg26xxm WaterProof Test# No supporting this function! ***\n");
+ return -1;
+ }
+
+ mdelay(10);
+
+ for (i = 0; i < MAX_MUTUAL_NUM; i ++)
+ {
+ _gTestFailChannel[i] = 0;
+ }
+
+ _gTestFailChannelCount = 0; // Reset _gTestFailChannelCount to 0 before test start
+
+ if(_DrvMpTestMsg26xxmItoWaterProofTest() < 0)
+ {
+ DBG("*** Msg26xxm WaterProof Test# Get DeltaC failed! ***\n");
+ return -1;
+ }
+
+ _DrvMpTestMsg26xxmItoWaterProofTestJudge();
+
+ for (i = 0; i < 12; i++)
+ {
+ nResultTemp[i] = _gResultWater[i];
+ }
+
+ _ItoTestDebugShowArray(_gResultWater, 12, -32, 10, 8);
+ for (i = 0; i < 12; i++)
+ {
+ if (nResultTemp[i] < WATERPROOFVALUE) //change comparison way because float computing in driver is prohibited
+ {
+ _gTestFailChannel[i] = 1;
+ _gTestFailChannelCount++;
+ nRetVal = -1;
+ }
+ else
+ {
+ _gTestFailChannel[i] = 0;
+ }
+ }
+
+
+ DbBusIICNotUseBus();
+ DbBusNotStopMCU();
+ DbBusExitSerialDebugMode();
+
+ DrvPlatformLyrTouchDeviceResetHw();
+ mdelay(300);
+
+ DrvPlatformLyrEnableFingerTouchReport();
+
+ return nRetVal;
+}
+
+static s32 _DrvMpTestItoWaterProofTestMsg28xxTriggerWaterProofOneShot(s16 * pResultData, u32 nDelay)
+{
+ u16 nAddr = 0x5000, nAddrNextSF = 0x1A4;
+ u16 nSF = 0, nAfeOpening = 0, nDriOpening = 0;
+ u16 nMaxDataNumOfOneSF = 0;
+ u16 nDriMode = 0;
+ u16 i;
+ u8 nRegData = 0;
+ u8 nShotData[390] = {0};//13*15*2
+ u16 nRegDataU16 = 0;
+
+ DBG("*** %s() ***\n", __func__);
+
+ nRegData = RegGetLByteValue(0x130A);
+ nSF = nRegData>>4;
+ nAfeOpening = nRegData & 0x0f;
+
+ if(nSF == 0)
+ {
+ return -1;
+ }
+
+ nRegData = RegGetLByteValue(0x100B);
+ nDriMode = nRegData;
+
+ nRegData = RegGetLByteValue(0x1312);
+ nDriOpening = nRegData;
+
+ DBG("*** Msg28xx WaterProof Test# TriggerWaterProofOneShot nSF=%d, nAfeOpening=%d, nDriMode=%d, nDriOpening=%d. ***\n", nSF, nAfeOpening, nDriMode, nDriOpening);
+
+ nMaxDataNumOfOneSF = nAfeOpening * nDriOpening;
+
+ RegSet16BitValueOff(0x3D08, BIT8); ///FIQ_E_FRAME_READY_MASK
+
+ ///polling frame-ready interrupt status
+ _DrvMpTestItoTestMsg28xxEnableAdcOneShot();
+
+ while (0x0000 == (nRegDataU16 & BIT8))
+ {
+ nRegDataU16 = RegGet16BitValue(0x3D18);
+ }
+
+ RegSet16BitValueOn(0x3D08, BIT8); ///FIQ_E_FRAME_READY_MASK
+ RegSet16BitValueOn(0x3D08, BIT4); ///FIQ_E_TIMER0_MASK
+
+ if (PATTERN_TYPE == 1) // for short test
+ {
+ //s16 nShortResultData[nSF][nAfeOpening];
+
+ /// get ALL raw data
+ _DrvMpTestItoTestDBBusReadDQMemStart();
+ RegGetXBitValue(nAddr, nShotData, 16, MAX_I2C_TRANSACTION_LENGTH_LIMIT);
+ _DrvMpTestItoTestDBBusReadDQMemEnd();
+
+ //_ItoTestDebugShowArray(nShotData, 26, 8, 16, 16);
+ for (i = 0; i < 8; i++)
+ {
+ pResultData[i] = (s16)(nShotData[2 * i] | nShotData[2 * i + 1] << 8);
+ }
+ }
+ else if(PATTERN_TYPE == 3 || PATTERN_TYPE == 4)// for open test
+ {
+ //s16 nOpenResultData[nSF * nAfeOpening][nDriOpening];
+
+ if(nSF >4)
+ nSF = 4;
+
+ /// get ALL raw data, combine and handle datashift.
+ for (i = 0; i < nSF; i++)
+ {
+ _DrvMpTestItoTestDBBusReadDQMemStart();
+ RegGetXBitValue(nAddr + i * nAddrNextSF, nShotData, 16, MAX_I2C_TRANSACTION_LENGTH_LIMIT);
+ _DrvMpTestItoTestDBBusReadDQMemEnd();
+
+ //_ItoTestDebugShowArray(nShotData, 390, 8, 10, 16);
+ pResultData[2 * i] = (s16)(nShotData[4 * i] | nShotData[4 * i + 1] << 8);
+ pResultData[2 * i + 1] = (s16)(nShotData[4 * i + 2] | nShotData[4 * i + 3] << 8);
+ }
+ }
+ else
+ {
+ return -1;
+ }
+
+ return 0;
+}
+
+static s32 _DrvMpTestItoWaterProofTesMsg28xxtGetWaterProofOneShotRawIIR(s16 * pRawDataWP, u32 nDelay)
+{
+ return _DrvMpTestItoWaterProofTestMsg28xxTriggerWaterProofOneShot(pRawDataWP, nDelay);
+}
+
+static s32 _DrvMpTestItoWaterProofTestMsg28xxGetDeltaCWP(s32 *pTarget, s8 nSwap, u32 nDelay)
+{
+ s16 nRawDataWP[12] = {0};
+ s16 i;
+
+ DBG("*** %s() ***\n", __func__);
+
+ if(_DrvMpTestItoWaterProofTesMsg28xxtGetWaterProofOneShotRawIIR(nRawDataWP, nDelay) < 0)
+ {
+ DBG("*** Msg28xx Open Test# GetMutualOneShotRawIIR failed! ***\n");
+ return -1;
+ }
+
+ for (i = 0; i < _gWaterProofNum; i++)
+ {
+ pTarget[i] = nRawDataWP[i];
+ }
+
+ return 0;
+}
+
+static s32 _DrvMpTestMsg28xxItoWaterProofTest(u32 nDelay)
+{
+ DBG("*** %s() ***\n", __func__);
+
+ // Stop mcu
+ RegSet16BitValue(0x0FE6, 0x0001); //bank:mheg5, addr:h0073
+ _DrvMpTestItoTestMsg28xxAnaSwReset();
+
+ if (_DrvMpTestItoWaterProofTestMsg28xxGetDeltaCWP(_gDeltaCWater, -1, nDelay)<0)
+ {
+ DBG("*** Msg28xx WaterProof Test# GetDeltaCWP failed! ***\n");
+ return -1;
+ }
+
+ _ItoTestDebugShowArray(_gDeltaCWater, 12, -32, 10, 16);
+
+ return 0;
+}
+
+static void _DrvMpTestMsg28xxItoWaterProofTestMsgJudge(void)
+{
+ int i;
+
+ DBG("*** %s() ***\n", __func__);
+
+ for (i = 0; i < _gWaterProofNum; i++)
+ {
+ _gResultWater[i] = abs(_gDeltaCWater[i]);
+ }
+}
+
+static s32 _DrvMpTestMsg28xxItoWaterProofTestEntry(void)
+{
+ s16 i = 0;
+ u32 nRetVal = 0;
+ u16 nRegDataWP = 0;
+ u32 nDelay = 0;
+
+ DBG("*** %s() ***\n", __func__);
+
+#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
+
+ _gWaterProofNum = 12;
+
+ DrvPlatformLyrDisableFingerTouchReport();
+ DrvPlatformLyrTouchDeviceResetHw();
+
+ //reset_only
+ DbBusResetSlave();
+ DbBusEnterSerialDebugMode();
+ DbBusWaitMCU();
+ DbBusIICUseBus();
+ DbBusIICReshape();
+ mdelay(100);
+
+ if(_DrvMpTestMsg28xxItoTestSwitchFwMode(WATERPROOF) < 0)
+ {
+ DBG("*** Msg28xx WaterProof Test# Switch FW mode failed! ***\n");
+ return -1;
+ }
+
+ nRegDataWP = RegGet16BitValue(0x1402);
+ if(nRegDataWP == 0x8BBD)
+ {
+ DBG("*** Msg28xx WaterProof Test# FW don't support waterproof! ***\n");
+ }
+
+ if(_DrvMpTestMsg28xxItoWaterProofTest(nDelay) < 0)
+ {
+ DBG("*** Msg28xx WaterProof Test# Get DeltaC failed! ***\n");
+ return -1;
+ }
+
+ _DrvMpTestMsg28xxItoWaterProofTestMsgJudge();
+
+ for (i = 0; i < _gWaterProofNum; i++)
+ {
+ if (_gResultWater[i] > WATERVALUE) //change comparison way because float computing in driver is prohibited
+ {
+ _gTestFailChannel[i] = 1;
+ _gTestFailChannelCount++;
+ nRetVal = -1;
+ }
+ else
+ {
+ _gTestFailChannel[i] = 0;
+ }
+ }
+
+ DbBusIICNotUseBus();
+ DbBusNotStopMCU();
+ DbBusExitSerialDebugMode();
+
+ DrvPlatformLyrTouchDeviceResetHw();
+ mdelay(300);
+
+ DrvPlatformLyrEnableFingerTouchReport();
+ return nRetVal;
+}
+
+static s32 _DrvMpTestItoWaterProofTest(void)
+{
+ s32 nRetVal = -1;
+
+ DBG("*** %s() ***\n", __func__);
+
+ if(g_ChipType == CHIP_TYPE_MSG26XXM)
+ {
+ return _DrvMpTestMsg26xxmItoWaterProofTestEntry();
+ }
+ else if(g_ChipType == CHIP_TYPE_MSG28XX)
+ {
+ return _DrvMpTestMsg28xxItoWaterProofTestEntry();
+ }
+
+ return nRetVal;
+}
+
+static void _DrvMpTestItoTestDoWork(struct work_struct *pWork)
+{
+ s32 nRetVal = 0;
+
+ DBG("*** %s() _gIsInMpTest = %d, _gTestRetryCount = %d ***\n", __func__, _gIsInMpTest, _gTestRetryCount);
+
+ if (_gItoTestMode == ITO_TEST_MODE_OPEN_TEST)
+ {
+ nRetVal = _DrvMpTestItoOpenTest();
+ }
+ else if (_gItoTestMode == ITO_TEST_MODE_SHORT_TEST)
+ {
+ nRetVal = _DrvMpTestItoShortTest();
+ }
+ else if (_gItoTestMode == ITO_TEST_MODE_WATERPROOF_TEST)
+ {
+ nRetVal = _DrvMpTestItoWaterProofTest();
+ }
+ else
+ {
+ DBG("*** Undefined Mp Test Mode = %d ***\n", _gItoTestMode);
+ return;
+ }
+
+ DBG("*** ctp mp test result = %d ***\n", nRetVal);
+
+ if (nRetVal == 0)
+ {
+ _gCtpMpTestStatus = ITO_TEST_OK; //PASS
+ _gIsInMpTest = 0;
+ DBG("mp test success\n");
+ }
+ else
+ {
+ _gTestRetryCount --;
+ if (_gTestRetryCount > 0)
+ {
+ DBG("_gTestRetryCount = %d\n", _gTestRetryCount);
+ queue_work(_gCtpMpTestWorkQueue, &_gCtpItoTestWork);
+ }
+ else
+ {
+ if (nRetVal == -1)
+ {
+ _gCtpMpTestStatus = ITO_TEST_FAIL;
+ }
+ else
+ {
+ _gCtpMpTestStatus = ITO_TEST_UNDEFINED_ERROR;
+ }
+
+ _gIsInMpTest = 0;
+ DBG("mp test failed\n");
+ }
+ }
+}
+
+/*=============================================================*/
+// GLOBAL FUNCTION DEFINITION
+/*=============================================================*/
+
+s32 DrvMpTestGetTestResult(void)
+{
+ DBG("*** %s() ***\n", __func__);
+ DBG("_gCtpMpTestStatus = %d\n", _gCtpMpTestStatus);
+
+ return _gCtpMpTestStatus;
+}
+
+void DrvMpTestGetTestFailChannel(ItoTestMode_e eItoTestMode, u8 *pFailChannel, u32 *pFailChannelCount)
+{
+ u32 i;
+
+ DBG("*** %s() ***\n", __func__);
+ DBG("_gTestFailChannelCount = %d\n", _gTestFailChannelCount);
+
+ for (i = 0; i < MAX_MUTUAL_NUM; i ++)
+ {
+ pFailChannel[i] = _gTestFailChannel[i];
+ }
+
+ *pFailChannelCount = MAX_MUTUAL_NUM; // Return the test result of all channels, APK will filter out the fail channels.
+}
+
+void DrvMpTestGetTestDataLog(ItoTestMode_e eItoTestMode, u8 *pDataLog, u32 *pLength)
+{
+ u32 i, j, k;
+
+ DBG("*** %s() ***\n", __func__);
+
+ if (eItoTestMode == ITO_TEST_MODE_OPEN_TEST)
+ {
+ k = 0;
+
+ for (j = 0; j < _gDriveLineNum; j ++)
+// for (j = 0; j < (_gDriveLineNum-1); j ++)
+ {
+ for (i = 0; i < _gSenseLineNum; i ++)
+ {
+// DBG("\nDrive%d, Sense%d, Value = %d\t", j, i, _gResult[i * _gDriveLineNum + j]); // add for debug
+
+ if (_gResult[i * _gDriveLineNum + j] >= 0)
+ {
+ pDataLog[k*5] = 0; // + : a positive number
+ }
+ else
+ {
+ pDataLog[k*5] = 1; // - : a negative number
+ }
+
+ pDataLog[k*5+1] = (_gResult[i * _gDriveLineNum + j] >> 24) & 0xFF;
+ pDataLog[k*5+2] = (_gResult[i * _gDriveLineNum + j] >> 16) & 0xFF;
+ pDataLog[k*5+3] = (_gResult[i * _gDriveLineNum + j] >> 8) & 0xFF;
+ pDataLog[k*5+4] = (_gResult[i * _gDriveLineNum + j]) & 0xFF;
+
+ k ++;
+ }
+ }
+
+ DBG("\nk = %d\n", k);
+
+ *pLength = k*5;
+ }
+ else if (eItoTestMode == ITO_TEST_MODE_SHORT_TEST)
+ {
+ k = 0;
+
+ for (i = 0; i < (_gDriveLineNum-1 + _gSenseLineNum); i++)
+ {
+ if (_gResult[i] >= 0)
+ {
+ pDataLog[k*5] = 0; // + : a positive number
+ }
+ else
+ {
+ pDataLog[k*5] = 1; // - : a negative number
+ }
+
+ pDataLog[k*5+1] = (_gResult[i] >> 24) & 0xFF;
+ pDataLog[k*5+2] = (_gResult[i] >> 16) & 0xFF;
+ pDataLog[k*5+3] = (_gResult[i] >> 8) & 0xFF;
+ pDataLog[k*5+4] = (_gResult[i]) & 0xFF;
+ k ++;
+ }
+
+ DBG("\nk = %d\n", k);
+
+ *pLength = k*5;
+ }
+ else if (eItoTestMode == ITO_TEST_MODE_WATERPROOF_TEST)
+ {
+ k = 0;
+
+ for (i = 0; i < _gWaterProofNum; i++)
+ {
+ if (_gResultWater[i] >= 0)
+ {
+ pDataLog[k*5] = 0; // + : a positive number
+ }
+ else
+ {
+ pDataLog[k*5] = 1; // - : a negative number
+ }
+
+ pDataLog[k*5+1] = (_gResultWater[i] >> 24) & 0xFF;
+ pDataLog[k*5+2] = (_gResultWater[i] >> 16) & 0xFF;
+ pDataLog[k*5+3] = (_gResultWater[i] >> 8) & 0xFF;
+ pDataLog[k*5+4] = (_gResultWater[i]) & 0xFF;
+ k ++;
+ }
+
+ DBG("\nk = %d\n", k);
+
+ *pLength = k*5;
+ }
+ else
+ {
+ DBG("*** Undefined MP Test Mode ***\n");
+ }
+}
+
+void DrvMpTestGetTestScope(TestScopeInfo_t *pInfo)
+{
+ DBG("*** %s() ***\n", __func__);
+
+ pInfo->nMy = _gDriveLineNum;
+ pInfo->nMx = _gSenseLineNum;
+
+ DBG("*** My = %d ***\n", pInfo->nMy);
+ DBG("*** Mx = %d ***\n", pInfo->nMx);
+}
+
+void DrvMpTestScheduleMpTestWork(ItoTestMode_e eItoTestMode)
+{
+ DBG("*** %s() ***\n", __func__);
+
+ if (_gIsInMpTest == 0)
+ {
+ DBG("ctp mp test start\n");
+
+ _gItoTestMode = eItoTestMode;
+ _gIsInMpTest = 1;
+ _gTestRetryCount = CTP_MP_TEST_RETRY_COUNT;
+ _gCtpMpTestStatus = ITO_TEST_UNDER_TESTING;
+
+ queue_work(_gCtpMpTestWorkQueue, &_gCtpItoTestWork);
+ }
+}
+
+void DrvMpTestCreateMpTestWorkQueue(void)
+{
+ DBG("*** %s() ***\n", __func__);
+
+ _gCtpMpTestWorkQueue = create_singlethread_workqueue("ctp_mp_test");
+ INIT_WORK(&_gCtpItoTestWork, _DrvMpTestItoTestDoWork);
+}
+
+#endif //CONFIG_ENABLE_ITO_MP_TEST
+#endif //CONFIG_ENABLE_TOUCH_DRIVER_FOR_MUTUAL_IC
\ No newline at end of file |