Input: touch: raydium: Update to Raydium v56.1 driver

Raydium code drop

Jump directly from v51 to v56.1

V52 Changes (Beta) (Roth only):
[1]  Add Kernel control architecturee (SlowScan/SetIdle/Start/End..)
[2]  New parameter loading architecture
[3]  Refine ESD solution for MP
[4]  Re-fine self-test procedure for MP
[5]  Load calibration file from environment variable path
[6]  Fix the LP0 2 sec delay issue
[7]  Fix finger on the screen during boot up issue
[8]  This version only support Roth platform
[9]  Refine coding style (4/16)
[10] Newer parameter modifier apk (4/16)
[11] Newer architecture for idle mode power saving has some problem,
     please ignore the idle mode verification on this trial version  (4/16)

V53 Changes (Beta) (Roth only):
[1]  Save calibration file from environment variable path
[2]  Refine selftest threshold

V54 Changes (Beta) (Roth only):
[1]  Fix the hard code file path to environment variable path
[2]  Remove the redundancy message in kernel layer

V54.1 Changes (Beta) (Roth only):
[1]  Refine environment variable path mechanism
[2]  Add test version field for debugging
[3]  Enable environment variable path debug msgs

V54.2 Changes (Beta) (Roth only):
[1] Refine coding style
[2] Add kernel command entries
[3] Using kernel command instead of hard-coded in suspend/resume routine
[4] Using lower report rate during idle mode to fix CPU ain't got into idle mode (5 Hz)

V55.0 Changes (Beta) (Roth only):
[1]  Fix idle mode issue & increase report rate
[2]  Add error handling block for kernel table loading
[3]  Refine coding style

V55.1 Changes (Beta) (Roth only):
[1]  Refine parameter for factory test
[2]  Add copy file from TOUCH_CONF_DIR in parameter loading
[3]  Turn on loading file logcat msgs

V55.2 Changes (Beta) (Roth only):
[1]  Remove unnecessary code
[2]  Add GPIO interface for future sensor select
[3]  Refine selftest procedure
[4]  Refine calibration procedure

V55.3 Changes (Beta) (Roth only):
[1]  Add support to disable power and clock when display is off
[2]  Parameter fine-tune

V55.4 Changes (Beta) (Roth only):
[1]  Fix CTS test failure in service transaction return
[2]  Fix stub command error return

V55.5 Changes (Beta):
[1]  Suppor roth/pluto/dalmore

V55.6 Changes (Beta):
[1]  Refine coding style
[2]  Parameter fine tune for pluto/dalmore

V55.7 Changes (Beta):
[1]  Parameter fine tune for pluto/dalmore

V55.8 Changes (Beta):
[1]  Parameter fine tune for pluto(Orientation setting for RM31081)

V55.9 Changes (Beta):
[1]  Refine resume control flow
[2]  Modify touch WDT function
[3]  Touch start/stop control flow modification

V55.10 Changes (Beta):
[1]  Set REST as the following
    Suspend
      1. Pull RESET low
      2. Disable clk and power
      3. Pull RESET high
    Resume
      1. Pull RESET low
      2. Enable power ,clk
      3. Pull RESET high

V56 Changes:
[1]  Fix CTS fail error

V56.1 Changes:
[1]  Fix CTS fail error
[2]  Shorten suspend/resume duration

Bug 1278869
Bug 1283619
Bug 1297187
Bug 1280093
Bug 1257642
Bug 1245549
Bug 1245404

Change-Id: I04acd5001e6ec675c3a4ddf2db892e0886d36303
Signed-off-by: Xiaohui Tao <xtao@nvidia.com>
Reviewed-on: http://git-master/r/234223
Reviewed-by: Robert Collins <rcollins@nvidia.com>
Reviewed-by: Bharat Nihalani <bnihalani@nvidia.com>

1 files changed, 89 insertions, 204 deletions

diff --git a/drivers/input/touchscreen/rm31080a_ctrl.c b/drivers/input/touchscreen/rm31080a_ctrl.c
index 04d13672b..04f9f70e9 100644
--- a/drivers/input/touchscreen/rm31080a_ctrl.c
+++ b/drivers/input/touchscreen/rm31080a_ctrl.c
@@ -1,8 +1,8 @@
 /*
  * Raydium RM31080 touchscreen driver
  *
- * Copyright (C) 2012 - 2013 Raydium Semiconductor Corporation
- * Copyright (C) 2012 NVIDIA Corporation, All Rights Reserved.
+ * Copyright (C) 2012-2013, Raydium Semiconductor Corporation.  All Rights Reserved.
+ * Copyright (C) 2012-2013, NVIDIA Corporation.  All Rights Reserved.
  *
  * This program is free software; you can redistribute  it and/or modify it
  * under  the terms of  the GNU General  Public License as published by the
@@ -11,185 +11,111 @@
  *
  */
 /*=============================================================================
- *INCLUDED FILES
- *=============================================================================
- */
+        INCLUDED FILES
+=============================================================================*/
 #include <linux/device.h>
-#include <linux/uaccess.h>
+#include <asm/uaccess.h>        // copy_to_user(),
 #include <linux/delay.h>
-#include <linux/module.h>
+#include <linux/module.h>       // Module definition
 
 #include <linux/spi/rm31080a_ts.h>
 #include <linux/spi/rm31080a_ctrl.h>
-/*=============================================================================
- *DEFINITIONS
- *=============================================================================
- */
-#define RM31080_RAW_DATA_LENGTH 2048
 
 /*=============================================================================
- *STRUCTURE DECLARATION
- *=============================================================================
- */
-
-/*=============================================================================
- *GLOBAL VARIABLES DECLARATION
- *=============================================================================
- */
+        GLOBAL VARIABLES DECLARATION
+=============================================================================*/
 struct rm31080a_ctrl_para g_stCtrl;
 
 /*=============================================================================
- *FUNCTION DECLARATION
- *=============================================================================
- */
+        FUNCTION DECLARATION
+=============================================================================*/
+
 /*=============================================================================
- * Description:
- *      Control functions for Touch IC
- * Input:
- *
- * Output:
- *=============================================================================
- */
-int rm31080_ctrl_clear_int(void)
+        Description:
+                        Control functions for Touch IC
+        Input:
+
+        Output:
+
+=============================================================================*/
+int rm_tch_ctrl_clear_int(void)
 {
         u8 flag;
-
-        if (g_stCtrl.bICVersion != T007A6)
-                return rm31080_spi_byte_read(RM31080B1_REG_BANK0_02H, &flag);
+        if (g_stCtrl.bICVersion >= 0xD0)
+                return rm_tch_spi_byte_read(0x72, &flag);
         else
-                return rm31080_spi_byte_read(RM31080_REG_F2, &flag);
+                return rm_tch_spi_byte_read(0x02, &flag);
 }
 
-int rm31080_ctrl_scan_start(void)
+int rm_tch_ctrl_scan_start(void)
 {
-        return rm31080_spi_byte_write(RM31080_REG_11, 0x17);
+        return rm_tch_spi_byte_write(RM31080_REG_11, 0x17);
 }
 
-void rm31080_ctrl_wait_for_scan_finish(void)
+void rm_tch_ctrl_wait_for_scan_finish(void)
 {
         u8 u8reg11;
         int i;
-        /* 50ms = 20Hz */
+        /*50ms = 20Hz*/
         for (i = 0; i < 50; i++) {
-                rm31080_spi_byte_read(RM31080_REG_11, &u8reg11);
+                rm_tch_spi_byte_read(RM31080_REG_11, &u8reg11);
                 if (u8reg11 & 0x01)
-                        usleep_range(1000, 2000);/*msleep(1); */
+                        usleep_range(1000, 2000);/* msleep(1); */
                 else
                         break;
         }
 }
 
-
 /*=============================================================================
- * Description:
- *
- * Input:
- *      N/A
- * Output:
- *      N/A
- *=============================================================================
- */
+        Description:
+
+        Input:
+                        N/A
+        Output:
+                        N/A
+=============================================================================*/
 void rm_set_repeat_times(u8 u8Times)
 {
         u8 bReg1_1Fh = 0x00;
         u8 u8Reg = 0x00;
 
-        if (g_stCtrl.bICVersion != T007A6) {
-                rm31080_spi_byte_read(0x0A, &u8Reg);
-                u8Reg &= 0xF0;
-                u8Reg |= (g_stCtrl.bSenseNumber - 1);
-                rm31080_spi_byte_write(0x0A, u8Reg);
-
-                rm31080_spi_byte_read(0x0E, &u8Reg);
-                u8Reg &= ~0x1F;
-                u8Reg |= u8Times;
-                rm31080_spi_byte_write(0x0E, u8Reg);
-
-                if ((g_stCtrl.bfADFC) &&
-                (g_stCtrl.bICVersion != T007_VERSION_C))
-                        bReg1_1Fh |= ADFC;
-
-                if (g_stCtrl.bfTHMode)
-                        bReg1_1Fh |= FILTER_THRESHOLD_MODE;
-                else
-                        bReg1_1Fh &= ~FILTER_NONTHRESHOLD_MODE;
-                /*bReg1_1Fh |= FILTER_NONTHRESHOLD_MODE;*/
-
-                if (u8Times != REPEAT_1)
-                        bReg1_1Fh |= 0x44;      /*Marty 20120820*/
-
-                rm31080_spi_byte_write(RM31080_REG_1F, bReg1_1Fh);
-        } else {
-                u8Reg = ((g_stCtrl.bSenseNumber - 1) << 3) | u8Times;
-
-                rm31080_spi_byte_write(RM31080_REG_0E, u8Reg);
-                if (g_stCtrl.bfADFC)
-                        bReg1_1Fh |= ADFC;
+        u8Reg = g_stCtrl.bSenseNumber - 1;
+        rm_tch_spi_byte_write(0x0A, u8Reg&0x0F);
+        rm_tch_spi_byte_write(0x0E, u8Times&0x1F);
 
-                if (g_stCtrl.bfTHMode)
-                        bReg1_1Fh |= FILTER_THRESHOLD_MODE;
-                else
-                        bReg1_1Fh &= ~FILTER_NONTHRESHOLD_MODE;
-                        /*bReg1_1Fh |= FILTER_NONTHRESHOLD_MODE;*/
+        if (g_stCtrl.bfTHMode)
+                bReg1_1Fh |= FILTER_THRESHOLD_MODE;
+        else
+                bReg1_1Fh &= ~FILTER_NONTHRESHOLD_MODE;
 
-                if (u8Times != REPEAT_1)
-                        bReg1_1Fh |= (u8Times + 3);
+        if (u8Times != REPEAT_1)
+                bReg1_1Fh |= 0x44;
 
-                rm31080_spi_byte_write(RM31080_REG_1F, bReg1_1Fh);
-        }
+        rm_tch_spi_byte_write(RM31080_REG_1F, bReg1_1Fh);
 }
 
 /*=============================================================================
- * Description:
- *
- * Input:
- *      N/A
- * Output:
- *      N/A
- *=============================================================================
- */
-void rm31080_ctrl_init(void)
+        Description:
+
+        Input:
+                        N/A
+        Output:
+                        N/A
+=============================================================================*/
+void rm_tch_ctrl_init(void)
 {
-        u8 var;
-
         memset(&g_stCtrl, 0, sizeof(struct rm31080a_ctrl_para));
-
-        g_stCtrl.bDummyRunCycle = 1;
-        g_stCtrl.u16DataLength = RM31080_RAW_DATA_LENGTH;
-
-        if (rm31080_spi_byte_read(RM31080_REG_7E, &var))
-                g_stCtrl.bICVersion = var & 0xF0;
-        else
-                g_stCtrl.bICVersion = T007A6;
 }
 
 /*=============================================================================
- * Description:
- *
- * Input:
- *      N/A
- * Output:
- *      N/A
- *=============================================================================
- */
-unsigned char rm31080_ctrl_get_noise_mode(u8 *p)
-{
-        u32 u32Ret;
-        u32Ret = copy_to_user(p, &g_stCtrl.bfNoiseModeDetector, 1);
-        if (u32Ret != 0)
-                return 0;
-        return 1;
-}
-
-/*=============================================================================
- * Description: To transfer the value to HAL layer
- *
- * Input:
- *      N/A
- * Output:
- *      N/A
- *===========================================================================*/
-unsigned char rm31080_ctrl_get_idle_mode(u8 *p)
+        Description: To transfer the value to HAL layer
+
+        Input:
+                        N/A
+        Output:
+                        N/A
+=============================================================================*/
+unsigned char rm_tch_ctrl_get_idle_mode(u8 *p)
 {
         u32 u32Ret;
         u32Ret = copy_to_user(p, &g_stCtrl.bfIdleModeCheck, 1);
@@ -199,95 +125,54 @@ unsigned char rm31080_ctrl_get_idle_mode(u8 *p)
 }
 
 /*=============================================================================
- * Description:
- *
- * Input:
- *      N/A
- * Output:
- *      N/A
- *=============================================================================
- */
-void rm31080_ctrl_get_parameter(void *arg)
+        Description:
+
+        Input:
+                        N/A
+        Output:
+                        N/A
+=============================================================================*/
+void rm_tch_ctrl_get_parameter(void *arg)
 {
 #define PARA_BASIC_LEN 4
 #define PARA_HARDWARE_LEN 28
 #define PARA_NOISE_LEN 32
 #define PARA_ALGORITHM_LEN 128
 
-        /* Marty added*/
         u8 Temp;
         u8 *pPara;
-        u8 idx;
-        idx = PARA_BASIC_LEN;
 
         pPara = (u8 *) arg;
-        Temp = pPara[idx + PARA_HARDWARE_LEN +
-                                PARA_NOISE_LEN + PARA_ALGORITHM_LEN + 3];
-        rm31080_set_autoscan(Temp);
-
-        g_stCtrl.bADCNumber = pPara[idx + 6];
-        g_stCtrl.bChannelNumberX = pPara[idx];
-        g_stCtrl.bChannelNumberY = pPara[idx + 1];
-        g_stCtrl.bfNoiseDetector = pPara[idx + PARA_HARDWARE_LEN + 13];
-        g_stCtrl.bChannelDetectorNum =  pPara[idx + PARA_HARDWARE_LEN + 19];
-        g_stCtrl.bChannelDetectorDummy = pPara[idx + PARA_HARDWARE_LEN + 20];
-        g_stCtrl.u16DataLength = (g_stCtrl.bChannelNumberX + 2 +
-                                g_stCtrl.bADCNumber) *
-                (g_stCtrl.bChannelNumberY + g_stCtrl.bfNoiseDetector *
-                (g_stCtrl.bChannelDetectorNum +
-                g_stCtrl.bChannelDetectorDummy));
-        g_stCtrl.bfNoiseMode = pPara[idx + PARA_HARDWARE_LEN + 14];
-        g_stCtrl.bNoiseRepeatTimes = pPara[idx + PARA_HARDWARE_LEN + 15];
-        /*Marty added*/
-        g_stCtrl.bNoiseThresholdMax = pPara[idx + PARA_HARDWARE_LEN + 21];
-        g_stCtrl.bNoiseThresholdMin = pPara[idx + PARA_HARDWARE_LEN + 22];
-        g_stCtrl.bNoiseThresholdLowMax = pPara[idx + PARA_HARDWARE_LEN + 23];
-        g_stCtrl.bNoiseThresholdLowMin = pPara[idx + PARA_HARDWARE_LEN + 24];
-        g_stCtrl.bNoiseDetectThd = pPara[idx + PARA_HARDWARE_LEN + 16];
-        g_stCtrl.bNoisePipelineBase = pPara[idx + PARA_HARDWARE_LEN + 17];
-        g_stCtrl.bNewNoiseRepeatTimes = pPara[idx + PARA_HARDWARE_LEN + 18];
-        g_stCtrl.bfMediumFilter = pPara[idx + PARA_HARDWARE_LEN + 25];
-        g_stCtrl.bMFBlockNumber = pPara[idx + PARA_HARDWARE_LEN + 26];
-        g_stCtrl.bRepeatTimes[0] = pPara[idx + PARA_HARDWARE_LEN + 4];
-        g_stCtrl.bRepeatTimes[1] = pPara[idx + PARA_HARDWARE_LEN + 5];
-        g_stCtrl.bIdleRepeatTimes[0] = pPara[idx + PARA_HARDWARE_LEN + 6];
-        g_stCtrl.bSenseNumber = pPara[idx + 11];
-        g_stCtrl.bfADFC = pPara[idx + 4];
-        g_stCtrl.bfTHMode = pPara[idx + PARA_HARDWARE_LEN + 10];
-        g_stCtrl.bfAnalogFilter = pPara[idx + PARA_HARDWARE_LEN + 8];
-        g_stCtrl.bYChannel[0] = pPara[280];     /* Y chan start pin */
-        g_stCtrl.bYChannel[1] = pPara[281];     /* Y chan end pin */
-        g_stCtrl.bXChannel[0] = pPara[282];     /* X chan ADC1 start pin */
-        g_stCtrl.bXChannel[1] = pPara[283];     /* X chan ADC1 end pin */
-        g_stCtrl.bXChannel[2] = pPara[284];     /* X chan ADC2 start pin */
-        g_stCtrl.bXChannel[3] = pPara[285];     /* X chan ADC2 end pin */
-        g_stCtrl.bfSuspendReset = pPara[idx + PARA_HARDWARE_LEN + 27];
-        g_stCtrl.bPressureResolution = pPara[105];
-        g_stCtrl.bSTScan = pPara[191];
-        g_stCtrl.bMTTouchThreshold = pPara[192];
+        Temp = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + PARA_NOISE_LEN + PARA_ALGORITHM_LEN + 3];
+        rm_tch_set_autoscan(Temp);
+
+        g_stCtrl.bICVersion = pPara[PARA_BASIC_LEN - 1];
+        g_stCtrl.bADCNumber = pPara[PARA_BASIC_LEN + 5];
+        g_stCtrl.bChannelNumberX = pPara[PARA_BASIC_LEN];
+        g_stCtrl.bChannelNumberY = pPara[PARA_BASIC_LEN + 1];
+        g_stCtrl.u16DataLength = (g_stCtrl.bChannelNumberX + 2 + g_stCtrl.bADCNumber) * (g_stCtrl.bChannelNumberY);
+
+        g_stCtrl.bActiveRepeatTimes[0] = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + 4];
+        g_stCtrl.bActiveRepeatTimes[1] = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + 5];
+        g_stCtrl.bIdleRepeatTimes[0] = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + 6];
+        g_stCtrl.bIdleRepeatTimes[1] = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + 7];
+        g_stCtrl.bSenseNumber = pPara[PARA_BASIC_LEN + 10];
+        g_stCtrl.bfTHMode = pPara[PARA_BASIC_LEN + PARA_HARDWARE_LEN + 10];
         g_stCtrl.bTime2Idle = pPara[194];
         g_stCtrl.bfPowerMode = pPara[195];
-        g_stCtrl.bfIdleMessage = pPara[207];
-        g_stCtrl.bDummyRunCycle = pPara[31];
-
-        /* Store dummy channel to skip it, data sequence:*/
-        /* Dummy[0](single end) | raw_data |
-                dummy[1](single end) dummy[2](single end) | raw_data |
-                dummy[3](single end)*/
+        g_stCtrl.bDebugMessage = pPara[204];
+        g_stCtrl.bTimerTriggerScale = pPara[205];
 
-        g_stCtrl.u16ResolutionX = ((u16) pPara[PARA_BASIC_LEN + 13]) << 8 |
-                ((u16)pPara[PARA_BASIC_LEN + 12]);
-        g_stCtrl.u16ResolutionY = ((u16) pPara[PARA_BASIC_LEN + 15]) << 8 |
-                ((u16)pPara[PARA_BASIC_LEN + 14]);
+        g_stCtrl.u16ResolutionX = ((u16) pPara[PARA_BASIC_LEN + 12]) << 8 | ((u16)pPara[PARA_BASIC_LEN + 11]);
+        g_stCtrl.u16ResolutionY = ((u16) pPara[PARA_BASIC_LEN + 14]) << 8 | ((u16)pPara[PARA_BASIC_LEN + 13]);
 
         if ((g_stCtrl.u16ResolutionX == 0) || (g_stCtrl.u16ResolutionY == 0)) {
                 g_stCtrl.u16ResolutionX = RM_INPUT_RESOLUTION_X;
                 g_stCtrl.u16ResolutionY = RM_INPUT_RESOLUTION_Y;
         }
-
 }
 
-/*===========================================================================*/
+/*=============================================================================*/
 MODULE_AUTHOR("xxxxxxxxxx <xxxxxxxx@rad-ic.com>");
 MODULE_DESCRIPTION("Raydium touchscreen control functions");
 MODULE_LICENSE("GPL");