Chinaunix首页 | 论坛 | 博客

edaplayer的ChinaUnix博客

首页　| 　博文目录　| 　关于我

edaplayer

  • 博客访问： 477051
  • 博文数量： 100
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 955
  • 用 户 组： 普通用户
  • 注册时间： 2014-11-21 09:30
文章分类

全部博文（100）

文章存档

2017年（1）

2016年（16）

2015年（83）

我的朋友
最近访客
推荐博文
相关博文
ft5x06驱动分析

分类： 嵌入式

2015-07-28 14:18:12

x210 kernel中的ft5x06.c：

点击(此处)折叠或打开

  1. /*
  2.  * drivers/input/touchscreen/ft5x0x_ts.c
  3.  *
  4.  * FocalTech ft5x0x TouchScreen driver.
  5.  *
  6.  * Copyright (c) 2010 Focal tech Ltd.
  7.  *
  8.  * This software is licensed under the terms of the GNU General Public
  9.  * License version 2, as published by the Free Software Foundation, and
  10.  * may be copied, distributed, and modified under those terms.
  11.  *
  12.  * This program is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15.  * GNU General Public License for more details.
  16.  *
  17.  * VERSION DATE AUTHOR Note
  18.  * 1.0 2010-01-05 WenFS only support mulititouch Wenfs 2010-10-01
  19.  * 2.0 2011-09-05 Duxx Add touch key, and project setting update, auto CLB command
  20.  *
  21.  *
  22.  */

  24. #include <linux/i2c.h>
  25. #include <linux/input.h>
  26. #include <linux/slab.h>
  27. #include "ft5x06_ts.h"
  28. #include <linux/earlysuspend.h>
  29. #include <linux/interrupt.h>
  30. #include <linux/delay.h>
  31. #include <linux/irq.h>
  32. #include <linux/io.h>
  33. #include <linux/platform_device.h>
  34. #include <mach/gpio.h>
  35. #include <plat/gpio-cfg.h>
  36. //#include <asm/jzsoc.h>

  38. extern int have_cap_touchscreen;

  40. static struct i2c_client *this_client;

  42. #define CONFIG_FT5X0X_MULTITOUCH 1
  43. #define FT5406_I2C_BUS             1

  45. struct ts_event {
  46.     u16 au16_x[CFG_MAX_TOUCH_POINTS]; //x coordinate
  47.     u16 au16_y[CFG_MAX_TOUCH_POINTS]; //y coordinate
  48.     u8 au8_touch_event[CFG_MAX_TOUCH_POINTS]; //touch event: 0 -- down; 1-- contact; 2 -- contact
  49.     u8 au8_finger_id[CFG_MAX_TOUCH_POINTS]; //touch ID
  50.     u16 pressure;
  51.     u8 touch_point;
  52. };


  55. struct ft5x0x_ts_data {
  56.     struct input_dev *input_dev;
  57.     struct ts_event event;
  58.     struct work_struct pen_event_work;
  59.     struct workqueue_struct *ts_workqueue;
  60.     struct early_suspend early_suspend;
  61. };


  64. #if CFG_SUPPORT_TOUCH_KEY
  65. int tsp_keycodes[CFG_NUMOFKEYS] ={

  67.         KEY_MENU,
  68.         KEY_HOME,
  69.         KEY_BACK,
  70.         KEY_SEARCH
  71. };

  73. char *tsp_keyname[CFG_NUMOFKEYS] ={

  75.         "Menu",
  76.         "Home",
  77.         "Back",
  78.         "Search"
  79. };

  81. static bool tsp_keystatus[CFG_NUMOFKEYS];
  82. #endif
  83. /***********************************************************************************************
  84. Name : ft5x0x_i2c_rxdata

  86. Input : *rxdata
  87.               *length

  89. Output : ret

  91. function :

  93. ***********************************************************************************************/
  94. static int ft5x0x_i2c_rxdata(char *rxdata, int length)
  95. {
  96.     int ret;

  98.     struct i2c_msg msgs[] = {
  99.         {
  100.             .addr = this_client->addr,
  101.             .flags = 0,
  102.             .len = 1,
  103.             .buf = rxdata,
  104.         },
  105.         {
  106.             .addr = this_client->addr,
  107.             .flags = I2C_M_RD,
  108.             .len = length,
  109.             .buf = rxdata,
  110.         },
  111.     };

  113.     //msleep(1);
  114.     ret = i2c_transfer(this_client->adapter, msgs, 2);
  115.     if (ret < 0)
  116.         pr_err("msg %s i2c read error: %d\n", __func__, ret);
  117.     
  118.     return ret;
  119. }
  120. /***********************************************************************************************
  121. Name :

  123. Input :

  125. Output :

  127. function :

  129. ***********************************************************************************************/
  130. static int ft5x0x_i2c_txdata(char *txdata, int length)
  131. {
  132.     int ret;

  134.     struct i2c_msg msg[] = {
  135.         {
  136.             .addr = this_client->addr,
  137.             .flags = 0,
  138.             .len = length,
  139.             .buf = txdata,
  140.         },
  141.     };

  143.        //msleep(1);
  144.     ret = i2c_transfer(this_client->adapter, msg, 1);
  145.     if (ret < 0)
  146.         pr_err("%s i2c write error: %d\n", __func__, ret);

  148.     return ret;
  149. }
  150. /***********************************************************************************************
  151. Name : ft5x0x_write_reg

  153. Input : addr -- address
  154.                      para -- parameter

  156. Output :

  158. function : write register of ft5x0x

  160. ***********************************************************************************************/
  161. static int ft5x0x_write_reg(u8 addr, u8 para)
  162. {
  163.     u8 buf[3];
  164.     int ret = -1;

  166.     buf[0] = addr;
  167.     buf[1] = para;
  168.     ret = ft5x0x_i2c_txdata(buf, 2);
  169.     if (ret < 0) {
  170.         pr_err("write reg failed! %#x ret: %d", buf[0], ret);
  171.         return -1;
  172.     }
  173.     
  174.     return 0;
  175. }


  178. /***********************************************************************************************
  179. Name : ft5x0x_read_reg

  181. Input : addr
  182.               pdata

  184. Output :

  186. function : read register of ft5x0x

  188. ***********************************************************************************************/
  189. static int ft5x0x_read_reg(u8 addr, u8 *pdata)
  190. {
  191.     int ret;
  192.     u8 buf[2];
  193.     struct i2c_msg msgs[2];

  195.     //
  196.     buf[0] = addr; //register address
  197.     
  198.     msgs[0].addr = this_client->addr;
  199.     msgs[0].flags = 0;//先写I2C设备地址，写模式
  200.     msgs[0].len = 1;
  201.     msgs[0].buf = buf;
  202.     msgs[1].addr = this_client->addr;
  203.     msgs[1].flags = I2C_M_RD;//再写I2C寄存器，读模式
  204.     msgs[1].len = 1;
  205.     msgs[1].buf = buf;

  207.     ret = i2c_transfer(this_client->adapter, msgs, 2);
  208.     if (ret < 0)
  209.         pr_err("msg %s i2c read error: %d\n", __func__, ret);

  211.     *pdata = buf[0];
  212.     return ret;
  213. }


  216. /***********************************************************************************************
  217. Name : ft5x0x_read_fw_ver

  219. Input : void

  221. Output : firmware version

  223. function : read TP firmware version

  225. ***********************************************************************************************/
  226. static unsigned char ft5x0x_read_fw_ver(void)
  227. {
  228.     unsigned char ver;
  229.     ft5x0x_read_reg(FT5X0X_REG_FIRMID, &ver);
  230.     return(ver);
  231. }

  233. #if 1 //upgrade related
  234. typedef enum
  235. {
  236.     ERR_OK,
  237.     ERR_MODE,
  238.     ERR_READID,
  239.     ERR_ERASE,
  240.     ERR_STATUS,
  241.     ERR_ECC,
  242.     ERR_DL_ERASE_FAIL,
  243.     ERR_DL_PROGRAM_FAIL,
  244.     ERR_DL_VERIFY_FAIL
  245. }E_UPGRADE_ERR_TYPE;

  247. typedef unsigned char FTS_BYTE; //8 bit
  248. typedef unsigned short FTS_WORD; //16 bit
  249. typedef unsigned int FTS_DWRD; //16 bit
  250. typedef unsigned char FTS_BOOL; //8 bit

  252. typedef struct _FTS_CTP_PROJECT_SETTING_T
  253. {
  254.     unsigned char uc_i2C_addr; //I2C slave address (8 bit address)
  255.     unsigned char uc_io_voltage; //IO Voltage 0---3.3v; 1----1.8v
  256.     unsigned char uc_panel_factory_id; //TP panel factory ID
  257. }FTS_CTP_PROJECT_SETTING_T;

  259. #define FTS_NULL 0x0
  260. #define FTS_TRUE 0x01
  261. #define FTS_FALSE 0x0

  263. #define I2C_CTPM_ADDRESS 0x70>>1
  264. //#define I2C_CTPM_ADDRESS 0x38    //lqm test


  267. void delay_qt_ms(unsigned long w_ms)
  268. {
  269.     unsigned long i;
  270.     unsigned long j;

  272.     for (i = 0; i < w_ms; i++)
  273.     {
  274.         for (j = 0; j < 1000; j++)
  275.         {
  276.             udelay(1);
  277.         }
  278.     }
  279. }


  282. /*
  283. [function]:
  284.     callback: read data from ctpm by i2c interface,implemented by special user;
  285. [parameters]:
  286.     bt_ctpm_addr[in] :the address of the ctpm;
  287.     pbt_buf[out] :data buffer;
  288.     dw_lenth[in] :the length of the data buffer;
  289. [return]:
  290.     FTS_TRUE :success;
  291.     FTS_FALSE :fail;
  292. */
  293. FTS_BOOL i2c_read_interface(FTS_BYTE bt_ctpm_addr, FTS_BYTE* pbt_buf, FTS_DWRD dw_lenth)
  294. {
  295.     int ret;
  296.     
  297.     ret=i2c_master_recv(this_client, pbt_buf, dw_lenth);

  299.     if(ret<=0)
  300.     {
  301.         printk("[FTS]i2c_read_interface error\n");
  302.         return FTS_FALSE;
  303.     }

  305.     return FTS_TRUE;
  306. }

  308. /*
  309. [function]:
  310.     callback: write data to ctpm by i2c interface,implemented by special user;
  311. [parameters]:
  312.     bt_ctpm_addr[in] :the address of the ctpm;
  313.     pbt_buf[in] :data buffer;
  314.     dw_lenth[in] :the length of the data buffer;
  315. [return]:
  316.     FTS_TRUE :success;
  317.     FTS_FALSE :fail;
  318. */
  319. FTS_BOOL i2c_write_interface(FTS_BYTE bt_ctpm_addr, FTS_BYTE* pbt_buf, FTS_DWRD dw_lenth)
  320. {
  321.     int ret;
  322.     ret=i2c_master_send(this_client, pbt_buf, dw_lenth);
  323.     if(ret<=0)
  324.     {
  325.         printk("[FTS]i2c_write_interface error line = %d, ret = %d\n", __LINE__, ret);
  326.         return FTS_FALSE;
  327.     }

  329.     return FTS_TRUE;
  330. }

  332. /*
  333. [function]:
  334.     send a command to ctpm.
  335. [parameters]:
  336.     btcmd[in] :command code;
  337.     btPara1[in] :parameter 1;
  338.     btPara2[in] :parameter 2;
  339.     btPara3[in] :parameter 3;
  340.     num[in] :the valid input parameter numbers, if only command code needed and no parameters followed,then the num is 1;
  341. [return]:
  342.     FTS_TRUE :success;
  343.     FTS_FALSE :io fail;
  344. */
  345. FTS_BOOL cmd_write(FTS_BYTE btcmd,FTS_BYTE btPara1,FTS_BYTE btPara2,FTS_BYTE btPara3,FTS_BYTE num)
  346. {
  347.     FTS_BYTE write_cmd[4] = {0};

  349.     write_cmd[0] = btcmd;
  350.     write_cmd[1] = btPara1;
  351.     write_cmd[2] = btPara2;
  352.     write_cmd[3] = btPara3;
  353.     return i2c_write_interface(I2C_CTPM_ADDRESS, write_cmd, num);
  354. }

  356. /*
  357. [function]:
  358.     write data to ctpm , the destination address is 0.
  359. [parameters]:
  360.     pbt_buf[in] :point to data buffer;
  361.     bt_len[in] :the data numbers;
  362. [return]:
  363.     FTS_TRUE :success;
  364.     FTS_FALSE :io fail;
  365. */
  366. FTS_BOOL byte_write(FTS_BYTE* pbt_buf, FTS_DWRD dw_len)
  367. {
  368.     
  369.     return i2c_write_interface(I2C_CTPM_ADDRESS, pbt_buf, dw_len);
  370. }

  372. /*
  373. [function]:
  374.     read out data from ctpm,the destination address is 0.
  375. [parameters]:
  376.     pbt_buf[out] :point to data buffer;
  377.     bt_len[in] :the data numbers;
  378. [return]:
  379.     FTS_TRUE :success;
  380.     FTS_FALSE :io fail;
  381. */
  382. FTS_BOOL byte_read(FTS_BYTE* pbt_buf, FTS_BYTE bt_len)
  383. {
  384.     return i2c_read_interface(I2C_CTPM_ADDRESS, pbt_buf, bt_len);
  385. }


  388. /*
  389. [function]:
  390.     burn the FW to ctpm.
  391. [parameters]:(ref. SPEC)
  392.     pbt_buf[in] :point to Head+FW ;
  393.     dw_lenth[in]:the length of the FW + 6(the Head length);
  394.     bt_ecc[in] :the ECC of the FW
  395. [return]:
  396.     ERR_OK :no error;
  397.     ERR_MODE :fail to switch to UPDATE mode;
  398.     ERR_READID :read id fail;
  399.     ERR_ERASE :erase chip fail;
  400.     ERR_STATUS :status error;
  401.     ERR_ECC :ecc error.
  402. */


  405. #define FTS_PACKET_LENGTH 128

  407. static unsigned char CTPM_FW[]=
  408. {
  409. #include "x210ii_app.i"    //lqm masked for test.
  410. };

  412. E_UPGRADE_ERR_TYPE fts_ctpm_fw_upgrade(FTS_BYTE* pbt_buf, FTS_DWRD dw_lenth)
  413. {
  414.     FTS_BYTE reg_val[2] = {0};
  415.     FTS_DWRD i = 0;

  417.     FTS_DWRD packet_number;
  418.     FTS_DWRD j;
  419.     FTS_DWRD temp;
  420.     FTS_DWRD lenght;
  421.     FTS_BYTE packet_buf[FTS_PACKET_LENGTH + 6];
  422.     FTS_BYTE auc_i2c_write_buf[10];
  423.     FTS_BYTE bt_ecc;
  424.     int i_ret;

  426.     /*********Step 1:Reset CTPM *****/
  427.     /*write 0xaa to register 0xfc*/
  428.     ft5x0x_write_reg(0xfc,0xaa);
  429.     delay_qt_ms(50);
  430.      /*write 0x55 to register 0xfc*/
  431.     ft5x0x_write_reg(0xfc,0x55);
  432.     printk("[FTS] Step 1: Reset CTPM test\n");

  434.     delay_qt_ms(30);


  437.     /*********Step 2:Enter upgrade mode *****/
  438.     auc_i2c_write_buf[0] = 0x55;
  439.     auc_i2c_write_buf[1] = 0xaa;
  440.     do
  441.     {
  442.         i ++;
  443.         i_ret = ft5x0x_i2c_txdata(auc_i2c_write_buf, 2);
  444.         delay_qt_ms(5);
  445.     }while(i_ret <= 0 && i < 5 );

  447.     /*********Step 3:check READ-ID***********************/
  448.     cmd_write(0x90,0x00,0x00,0x00,4);
  449.     byte_read(reg_val,2);
  450.     if (reg_val[0] == 0x79 && reg_val[1] == 0x3)
  451.     {
  452.         printk("[FTS] Step 3: CTPM ID,ID1 = 0x%x,ID2 = 0x%x\n",reg_val[0],reg_val[1]);
  453.     }
  454.     else
  455.     {
  456.         return ERR_READID;
  457.         //i_is_new_protocol = 1;
  458.     }

  460.     cmd_write(0xcd,0x0,0x00,0x00,1);
  461.     byte_read(reg_val,1);
  462.     printk("[FTS] bootloader version = 0x%x\n", reg_val[0]);

  464.      /*********Step 4:erase app and panel paramenter area ********************/
  465.     cmd_write(0x61,0x00,0x00,0x00,1); //erase app area
  466.     delay_qt_ms(1500);
  467.     cmd_write(0x63,0x00,0x00,0x00,1); //erase panel parameter area
  468.     delay_qt_ms(100);
  469.     printk("[FTS] Step 4: erase. \n");

  471.     /*********Step 5:write firmware(FW) to ctpm flash*********/
  472.     bt_ecc = 0;
  473.     printk("[FTS] Step 5: start upgrade. \n");
  474.     dw_lenth = dw_lenth - 8;
  475.     packet_number = (dw_lenth) / FTS_PACKET_LENGTH;
  476.     packet_buf[0] = 0xbf;
  477.     packet_buf[1] = 0x00;
  478.     for (j=0;j<packet_number;j++)
  479.     {
  480.         temp = j * FTS_PACKET_LENGTH;
  481.         packet_buf[2] = (FTS_BYTE)(temp>>8);
  482.         packet_buf[3] = (FTS_BYTE)temp;
  483.         lenght = FTS_PACKET_LENGTH;
  484.         packet_buf[4] = (FTS_BYTE)(lenght>>8);
  485.         packet_buf[5] = (FTS_BYTE)lenght;

  487.         for (i=0;i<FTS_PACKET_LENGTH;i++)
  488.         {
  489.             packet_buf[6+i] = pbt_buf[j*FTS_PACKET_LENGTH + i];
  490.             bt_ecc ^= packet_buf[6+i];
  491.         }
  492.         
  493.         byte_write(&packet_buf[0],FTS_PACKET_LENGTH + 6);
  494.         delay_qt_ms(FTS_PACKET_LENGTH/6 + 1);
  495.         if ((j * FTS_PACKET_LENGTH % 1024) == 0)
  496.         {
  497.               printk("[FTS] upgrade the 0x%x th byte.\n", ((unsigned int)j) * FTS_PACKET_LENGTH);
  498.         }
  499.     }

  501.     if ((dw_lenth) % FTS_PACKET_LENGTH > 0)
  502.     {
  503.         temp = packet_number * FTS_PACKET_LENGTH;
  504.         packet_buf[2] = (FTS_BYTE)(temp>>8);
  505.         packet_buf[3] = (FTS_BYTE)temp;

  507.         temp = (dw_lenth) % FTS_PACKET_LENGTH;
  508.         packet_buf[4] = (FTS_BYTE)(temp>>8);
  509.         packet_buf[5] = (FTS_BYTE)temp;

  511.         for (i=0;i<temp;i++)
  512.         {
  513.             packet_buf[6+i] = pbt_buf[ packet_number*FTS_PACKET_LENGTH + i];
  514.             bt_ecc ^= packet_buf[6+i];
  515.         }

  517.         byte_write(&packet_buf[0],temp+6);
  518.         delay_qt_ms(20);
  519.     }

  521.     //send the last six byte
  522.     for (i = 0; i<6; i++)
  523.     {
  524.         temp = 0x6ffa + i;
  525.         packet_buf[2] = (FTS_BYTE)(temp>>8);
  526.         packet_buf[3] = (FTS_BYTE)temp;
  527.         temp =1;
  528.         packet_buf[4] = (FTS_BYTE)(temp>>8);
  529.         packet_buf[5] = (FTS_BYTE)temp;
  530.         packet_buf[6] = pbt_buf[ dw_lenth + i];
  531.         bt_ecc ^= packet_buf[6];

  533.         byte_write(&packet_buf[0],7);
  534.         delay_qt_ms(20);
  535.     }


  538.     /*********Step 6: read out checksum***********************/
  539.     /*send the opration head*/
  540.     cmd_write(0xcc,0x00,0x00,0x00,1);
  541.     byte_read(reg_val,1);
  542.     printk("[FTS] Step 6: ecc read 0x%x, new firmware 0x%x. \n", reg_val[0], bt_ecc);
  543.     if(reg_val[0] != bt_ecc)
  544.     {
  545.         return ERR_ECC;
  546.     }

  548.     /*********Step 7: reset the new FW***********************/
  549.     cmd_write(0x07,0x00,0x00,0x00,1);

  551.     msleep(300); //make sure CTP startup normally
  552.     
  553.     return ERR_OK;
  554. }

  556. int fts_ctpm_auto_clb(void)
  557. {
  558.     unsigned char uc_temp;
  559.     unsigned char i ;

  561.     printk("[FTS] start auto CLB.\n");
  562.     msleep(200);
  563.     ft5x0x_write_reg(0, 0x40);
  564.     delay_qt_ms(100); //make sure already enter factory mode
  565.     ft5x0x_write_reg(2, 0x4); //write command to start calibration
  566.     delay_qt_ms(300);
  567.     for(i=0;i<100;i++)
  568.     {
  569.         ft5x0x_read_reg(0,&uc_temp);
  570.         if ( ((uc_temp&0x70)>>4) == 0x0) //return to normal mode, calibration finish
  571.         {
  572.             break;
  573.         }
  574.         delay_qt_ms(200);
  575.         printk("[FTS] waiting calibration %d\n",i);
  576.         
  577.     }
  578.     printk("[FTS] calibration OK.\n");
  579.     
  580.     msleep(300);
  581.     ft5x0x_write_reg(0, 0x40); //goto factory mode
  582.     delay_qt_ms(100); //make sure already enter factory mode
  583.     ft5x0x_write_reg(2, 0x5); //store CLB result
  584.     delay_qt_ms(300);
  585.     ft5x0x_write_reg(0, 0x0); //return to normal mode
  586.     msleep(300);
  587.     printk("[FTS] store CLB result OK.\n");
  588.     return 0;
  589. }

  591. int fts_ctpm_fw_upgrade_with_i_file(void)
  592. {
  593.    FTS_BYTE* pbt_buf = FTS_NULL;
  594.    int i_ret;
  595.     
  596.     //=========FW upgrade========================*/
  597.    pbt_buf = CTPM_FW;
  598.    /*call the upgrade function*/
  599.    i_ret = fts_ctpm_fw_upgrade(pbt_buf,sizeof(CTPM_FW));
  600.    if (i_ret != 0)
  601.    {
  602.        printk("[FTS] upgrade failed i_ret = %d.\n", i_ret);
  603.        //error handling ...
  604.        //TBD
  605.    }
  606.    else
  607.    {
  608.        printk("[FTS] upgrade successfully.\n");
  609.        fts_ctpm_auto_clb(); //start auto CLB
  610.    }

  612.    return i_ret;
  613. }

  615. unsigned char fts_ctpm_get_i_file_ver(void)
  616. {
  617.     unsigned int ui_sz;
  618.     ui_sz = sizeof(CTPM_FW);
  619.     if (ui_sz > 2)
  620.     {
  621.         return CTPM_FW[ui_sz - 2];
  622.     }
  623.     else
  624.     {
  625.         //TBD, error handling?
  626.         return 0xff; //default value
  627.     }
  628. }

  630. #define FTS_SETTING_BUF_LEN 128

  632. //update project setting
  633. //only update these settings for COB project, or for some special case
  634. int fts_ctpm_update_project_setting(void)
  635. {
  636.     unsigned char uc_i2c_addr; //I2C slave address (8 bit address)
  637.     unsigned char uc_io_voltage; //IO Voltage 0---3.3v; 1----1.8v
  638.     unsigned char uc_panel_factory_id; //TP panel factory ID

  640.     unsigned char buf[FTS_SETTING_BUF_LEN];
  641.     FTS_BYTE reg_val[2] = {0};
  642.     FTS_BYTE auc_i2c_write_buf[10];
  643.     FTS_BYTE packet_buf[FTS_SETTING_BUF_LEN + 6];
  644.     FTS_DWRD i = 0;
  645.     int i_ret;

  647.     uc_i2c_addr = 0x0;
  648.     uc_io_voltage = 0x0;
  649.     uc_panel_factory_id = 0x5a;

  651.     /*********Step 1:Reset CTPM *****/
  652.     /*write 0xaa to register 0xfc*/
  653.     ft5x0x_write_reg(0xfc,0xaa);
  654.     delay_qt_ms(50);
  655.      /*write 0x55 to register 0xfc*/
  656.     ft5x0x_write_reg(0xfc,0x55);
  657.     printk("[FTS] Step 1: Reset CTPM test\n");

  659.     delay_qt_ms(30);

  661.     /*********Step 2:Enter upgrade mode *****/
  662.     auc_i2c_write_buf[0] = 0x55;
  663.     auc_i2c_write_buf[1] = 0xaa;
  664.     do
  665.     {
  666.         i ++;
  667.         i_ret = ft5x0x_i2c_txdata(auc_i2c_write_buf, 2);
  668.         delay_qt_ms(5);
  669.     }while(i_ret <= 0 && i < 5 );

  671.     /*********Step 3:check READ-ID***********************/
  672.     cmd_write(0x90,0x00,0x00,0x00,4);
  673.     byte_read(reg_val,2);
  674.     if (reg_val[0] == 0x79 && reg_val[1] == 0x3)
  675.     {
  676.         printk("[FTS] Step 3: CTPM ID,ID1 = 0x%x,ID2 = 0x%x\n",reg_val[0],reg_val[1]);
  677.     }
  678.     else
  679.     {
  680.         return ERR_READID;
  681.     }

  683.     cmd_write(0xcd,0x0,0x00,0x00,1);
  684.     byte_read(reg_val,1);
  685.     printk("bootloader version = 0x%x\n", reg_val[0]);


  688.     /* --------- read current project setting ---------- */
  689.     //set read start address
  690.     buf[0] = 0x3;
  691.     buf[1] = 0x0;
  692.     buf[2] = 0x78;
  693.     buf[3] = 0x0;
  694.     byte_write(buf, 4);
  695.     byte_read(buf, FTS_SETTING_BUF_LEN);
  696.     
  697.     printk("[FTS] old setting: uc_i2c_addr = 0x%x, uc_io_voltage = %d, uc_panel_factory_id = 0x%x\n",
  698.         buf[0], buf[2], buf[4]);
  699.     for (i = 0; i < FTS_SETTING_BUF_LEN; i++)
  700.     {
  701.         if (i % 16 == 0) printk("\n");
  702.         printk("0x%x, ", buf[i]);
  703.         
  704.     }
  705.     printk("\n");

  707.      /*--------- Step 4:erase project setting --------------*/
  708.     cmd_write(0x62,0x00,0x00,0x00,1);
  709.     delay_qt_ms(100);
  710.    
  711.     /*---------- Set new settings ---------------*/
  712.     buf[0] = uc_i2c_addr;
  713.     buf[1] = ~uc_i2c_addr;
  714.     buf[2] = uc_io_voltage;
  715.     buf[3] = ~uc_io_voltage;
  716.     buf[4] = uc_panel_factory_id;
  717.     buf[5] = ~uc_panel_factory_id;
  718.     packet_buf[0] = 0xbf;
  719.     packet_buf[1] = 0x00;
  720.     packet_buf[2] = 0x78;
  721.     packet_buf[3] = 0x0;
  722.     packet_buf[4] = 0;
  723.     packet_buf[5] = FTS_SETTING_BUF_LEN;
  724.     for (i = 0; i < FTS_SETTING_BUF_LEN; i++)
  725.     {
  726.         packet_buf[6 + i] = buf[i];
  727.         if (i % 16 == 0) printk("\n");
  728.         printk("0x%x, ", buf[i]);
  729.     }
  730.     printk("\n");
  731.     byte_write(&packet_buf[0],FTS_SETTING_BUF_LEN + 6);
  732.     delay_qt_ms(100);

  734.     /********* reset the new FW***********************/
  735.     cmd_write(0x07,0x00,0x00,0x00,1);

  737.     msleep(200);

  739.     return 0;
  740. }



  744. int fts_ctpm_read_project_setting(void)
  745. {
  746.     unsigned char uc_i2c_addr; //I2C slave address (8 bit address)
  747.     unsigned char uc_io_voltage; //IO Voltage 0---3.3v; 1----1.8v
  748.     unsigned char uc_panel_factory_id; //TP panel factory ID

  750.     unsigned char buf[FTS_SETTING_BUF_LEN];
  751.     FTS_BYTE reg_val[2] = {0};
  752.     FTS_BYTE auc_i2c_write_buf[10];
  753.     FTS_DWRD i = 0;
  754.     int i_ret;

  756.     uc_i2c_addr = 0x70;
  757.     uc_io_voltage = 0x0;
  758.     uc_panel_factory_id = 0x5a;

  760.     /*********Step 1:Reset CTPM *****/
  761.     /*write 0xaa to register 0xfc*/
  762.     ft5x0x_write_reg(0xfc,0xaa);
  763.     delay_qt_ms(50);
  764.      /*write 0x55 to register 0xfc*/
  765.     ft5x0x_write_reg(0xfc,0x55);
  766.     printk("[FTS] Step 1: Reset CTPM test\n");
  767.    
  768.     delay_qt_ms(30);

  770.     /*********Step 2:Enter upgrade mode *****/
  771.     auc_i2c_write_buf[0] = 0x55;
  772.     auc_i2c_write_buf[1] = 0xaa;
  773.     do
  774.     {
  775.         i ++;
  776.         i_ret = ft5x0x_i2c_txdata(auc_i2c_write_buf, 2);
  777.         delay_qt_ms(5);
  778.     }while(i_ret <= 0 && i < 5 );

  780.     /*********Step 3:check READ-ID***********************/
  781.     cmd_write(0x90,0x00,0x00,0x00,4);
  782.     byte_read(reg_val,2);
  783.     if (reg_val[0] == 0x79 && reg_val[1] == 0x3)
  784.     {
  785.         printk("[FTS] Step 3: CTPM ID,ID1 = 0x%x,ID2 = 0x%x\n",reg_val[0],reg_val[1]);
  786.     }
  787.     else
  788.     {
  789.         return ERR_READID;
  790.     }

  792.     cmd_write(0xcd,0x0,0x00,0x00,1);
  793.     byte_read(reg_val,1);
  794.     printk("bootloader version = 0x%x\n", reg_val[0]);


  797.     /* --------- read current project setting ---------- */
  798.     //set read start address
  799.     buf[0] = 0x3;
  800.     buf[1] = 0x0;
  801.     buf[2] = 0x78;
  802.     buf[3] = 0x0;
  803.     byte_write(buf, 4);
  804.     byte_read(buf, FTS_SETTING_BUF_LEN);
  805.     
  806.     printk("[FTS] old setting: uc_i2c_addr = 0x%x, uc_io_voltage = %d, uc_panel_factory_id = 0x%x\n",
  807.         buf[0], buf[2], buf[4]);
  808.     for (i = 0; i < FTS_SETTING_BUF_LEN; i++)
  809.     {
  810.         if (i % 16 == 0) printk("\n");
  811.         printk("0x%x, ", buf[i]);
  812.         
  813.     }
  814.     printk("\n");

  816.     /********* reset the new FW***********************/
  817.     cmd_write(0x07,0x00,0x00,0x00,1);

  819.     msleep(200);

  821.     return 0;
  822. }



  826. #if CFG_SUPPORT_AUTO_UPG

  828. int fts_ctpm_auto_upg(void)
  829. {
  830.     unsigned char uc_host_fm_ver;
  831.     unsigned char uc_tp_fm_ver;
  832.     int i_ret;

  834.     uc_tp_fm_ver = ft5x0x_read_fw_ver();
  835.     uc_host_fm_ver = fts_ctpm_get_i_file_ver();
  836.     if ( uc_tp_fm_ver == 0xa6 || //the firmware in touch panel maybe corrupted
  837.          uc_tp_fm_ver < uc_host_fm_ver //the firmware in host flash is new, need upgrade
  838.         )
  839.     {
  840.         msleep(100);
  841.         printk("[FTS] uc_tp_fm_ver = 0x%x, uc_host_fm_ver = 0x%x\n",
  842.             uc_tp_fm_ver, uc_host_fm_ver);
  843.         i_ret = fts_ctpm_fw_upgrade_with_i_file();
  844.         if (i_ret == 0)
  845.         {
  846.             msleep(300);
  847.             uc_host_fm_ver = ft5x0x_read_fw_ver();
  848.             printk("[FTS] upgrade to new version 0x%x\n", uc_host_fm_ver);
  849.         }
  850.         else
  851.         {
  852.             printk("[FTS] upgrade failed ret=%d.\n", i_ret);
  853.         }
  854.     }

  856.     return 0;
  857. }

  859. #endif

  861. #endif




  866. #if CFG_DBG_RAW_DATA_READ
  867. #define FTS_TX_NUM 28
  868. #define FTS_RX_NUM 16
  869. static unsigned char _suc_raw_data[FTS_TX_NUM][FTS_RX_NUM * 2];


  872. int fts_read_line(unsigned char uc_row, unsigned char uc_buf[], unsigned char uc_rx_num)
  873. {
  874.     int i_ret;

  876.     //set the row address
  877.     i_ret = ft5x0x_write_reg(0x1, uc_row);
  878.     if (i_ret < 0 )
  879.     {
  880.         return -1;
  881.     }

  883.     uc_buf[0] = 0x10;
  884.     i_ret = ft5x0x_i2c_rxdata(uc_buf, uc_rx_num * 2);
  885.     if (i_ret < 0)
  886.     {
  887.         return -2;
  888.     }

  890.     return 0;
  891.     
  892. }

  894. int fts_raw_data_test(void)
  895. {
  896.     int i;
  897.     int j;
  898.     int i_test;
  899.     unsigned short uc_data;

  901.     msleep(200); //make sure the CTP already start up normally
  902.     
  903.     ft5x0x_write_reg(0, 0x40); //switch to factory mode

  905.     msleep(100); //make sure already enter factory mode

  907.     printk("[TSP] raw data test start ----------------------- \n");

  909.     for (i_test = 0; i_test < 10; i_test ++)
  910.     {
  911.         printk("frame %d *********\n", i_test + 1);
  912.         ft5x0x_write_reg(0, 0xC0); //trigger start raw data scan bit
  913.         msleep(10);
  914.         for ( i = 0; i < FTS_TX_NUM; i ++)
  915.         {
  916.             msleep(1);
  917.             fts_read_line(i, _suc_raw_data[i], FTS_RX_NUM);
  918.             for ( j = 0; j<FTS_RX_NUM; j++)
  919.             {
  920.                 uc_data = _suc_raw_data[i][2*j];
  921.                 uc_data <<= 8;
  922.                 uc_data |= _suc_raw_data[i][2*j + 1];
  923.                 printk("%5d ", uc_data);
  924.             }
  925.             printk("\n");
  926.         }
  927.         msleep(30);
  928.         
  929.     }
  930.     printk("[TSP] raw data test end ----------------------- \n");

  932.     return 0;
  933. }

  935. #endif

  937. /***********************************************************************************************
  938. Name :

  940. Input :
  941.                      

  943. Output :

  945. function :

  947. ***********************************************************************************************/
  948. static void ft5x0x_ts_release(void)
  949. {
  950.     struct ft5x0x_ts_data *data = i2c_get_clientdata(this_client);
  951.    input_report_abs(data->input_dev, ABS_PRESSURE, 0);// input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, 0);
  952.     input_sync(data->input_dev);
  953. }

  955. //read touch point information
  956. static int ft5x0x_read_data(void)
  957. {
  958.     struct ft5x0x_ts_data *data = i2c_get_clientdata(this_client);
  959.     struct ts_event *event = &data->event;
  960.     u8 buf[CFG_POINT_READ_BUF] = {0};
  961.     int ret = -1;
  962.     int i;
  963.     
  964.     ret = ft5x0x_i2c_rxdata(buf, CFG_POINT_READ_BUF);
  965.     if (ret < 0) {
  966.         printk("%s read_data i2c_rxdata failed: %d\n", __func__, ret);
  967.         return ret;
  968.     }
  969.     memset(event, 0, sizeof(struct ts_event));
  970.     //printk("[lqm] buf[2]=%d\r\n",buf[2]);
  971.     event->touch_point = buf[2] & 0x07; //lqm changed.
  972.     //event->touch_point = buf[2] >> 4;

  974.     if (event->touch_point > CFG_MAX_TOUCH_POINTS)
  975.     {
  976.         event->touch_point = CFG_MAX_TOUCH_POINTS;
  977.     }

  979.     for (i = 0; i < event->touch_point; i++)
  980.     {
  981.         event->au16_x[i] = (s16)(buf[3 + 6*i] & 0x0F)<<8 | (s16)buf[4 + 6*i];
  982.         event->au16_y[i] = (s16)(buf[5 + 6*i] & 0x0F)<<8 | (s16)buf[6 + 6*i];
  983.         event->au8_touch_event[i] = buf[0x3 + 6*i] >> 6;
  984.         event->au8_finger_id[i] = (buf[5 + 6*i])>>4;
  985.    // printk("%d, %d\n", event->au16_x[i], event->au16_y[i]);
  986.     }

  988.     event->pressure = 200;

  990. #if CFG_SUPPORT_READ_LEFT_DATA
  991.     return buf[1]; //the left touch data in the frames
  992. #else
  993.     return 0;
  994. #endif
  995. }

  997. /***********************************************************************************************
  998. Name :

  1000. Input :


  1003. Output :

  1005. function :

  1007. ***********************************************************************************************/


  1010. #if CFG_SUPPORT_TOUCH_KEY
  1011. int ft5x0x_touch_key_process(struct input_dev *dev, int x, int y, int touch_event)
  1012. {
  1013.     int i;
  1014.     int key_id;
  1015.     
  1016.     if ( y < 150 && y > 90)//103
  1017.     {
  1018.         key_id = 2;
  1019.     }
  1020.     else if ( y < 90 &&y > 60)//73
  1021.     {
  1022.         key_id = 0;
  1023.     }
  1024.     
  1025.     else if ( y < 60 && y > 30)//43
  1026.     {
  1027.         key_id = 1;
  1028.     }
  1029.     else if (y < 30)//0
  1030.     {
  1031.         key_id = 3;
  1032.     }
  1033.     else
  1034.     {
  1035.         key_id = 0xf;
  1036.     }
  1037.     
  1038.     for(i = 0; i <CFG_NUMOFKEYS; i++ )
  1039.     {
  1040.         if(tsp_keystatus[i])
  1041.         {
  1042.             input_report_key(dev, tsp_keycodes[i], 0);
  1043.             //printk("[FTS] %s key is release. Keycode : %d\n", tsp_keyname[i], tsp_keycodes[i]);
  1044.             tsp_keystatus[i] = KEY_RELEASE;
  1045.         }
  1046.         else if( key_id == i )
  1047.         {
  1048.             if( touch_event == 0) // detect
  1049.             {
  1050.                 input_report_key(dev, tsp_keycodes[i], 1);
  1051.                 //printk( "[FTS] %s key is pressed. Keycode : %d\n", tsp_keyname[i], tsp_keycodes[i]);
  1052.                 tsp_keystatus[i] = KEY_PRESS;
  1053.             }
  1054.         }
  1055.     }
  1056.     return 0;
  1057.     
  1058. }
  1059. #endif

  1061. static void ft5x0x_report_value(void)
  1062. {
  1063.     struct ft5x0x_ts_data *data = i2c_get_clientdata(this_client);
  1064.     struct ts_event *event = &data->event;
  1065.     int i;
  1066.   // printk("touchpoint = %d\n", event->touch_point);
  1067.     for (i = 0; i < event->touch_point; i++)
  1068.     {
  1069.     
  1070.      if (event->au16_x[i] < /*SCREEN_MAX_X*/800 && event->au16_y[i] < /*SCREEN_MAX_Y*/480)
  1071.         // LCD view area
  1072.         {
  1073. //#ifdef CFG_ONBOARD_FT5X06
  1074.      event->au16_y[i] = 480 - event->au16_y[i];
  1075. //#endif
  1076.              input_report_abs(data->input_dev, ABS_X, event->au16_x[i]); //input_report_abs(data->input_dev, ABS_MT_POSITION_X, event->au16_x[i]);
  1077.             input_report_abs(data->input_dev, ABS_Y, event->au16_y[i]);//input_report_abs(data->input_dev, ABS_MT_POSITION_Y, event->au16_y[i]);
  1078. input_report_abs(data->input_dev, ABS_Z, 0);
  1079. input_report_abs(data->input_dev, BTN_TOUCH, 1);
  1080.            // input_report_abs(data->input_dev, ABS_MT_WIDTH_MAJOR, 1);
  1081.            // input_report_abs(data->input_dev, ABS_MT_TRACKING_ID, event->au8_finger_id[i]);
  1082.         // if (event->au8_touch_event[i]== 0 || event->au8_touch_event[i] == 2)
  1083.          //{
  1084.                input_report_abs(data->input_dev, ABS_PRESSURE, 1);// input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, event->pressure);
  1085.         // }
  1086.         // else
  1087.         // {
  1088.         // input_report_abs(data->input_dev, ABS_PRESSURE, 0);//input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, 0);
  1089.         // }
  1090.   // printk("%d, %d\n", event->au16_x[i], event->au16_y[i]);
  1091.         }
  1092.         else //maybe the touch key area
  1093.         {
  1094. #if CFG_SUPPORT_TOUCH_KEY
  1095.             if (event->au16_x[i] >= /*SCREEN_MAX_X*/800)
  1096.             {
  1097.                 //printk("key x = %d\n", event->au16_y[i]);
  1098.                 ft5x0x_touch_key_process(data->input_dev, event->au16_x[i], event->au16_y[i], event->au8_touch_event[i]);
  1099.             }
  1100. #endif
  1101.         }
  1102.   
  1103.     //input_mt_sync(data->input_dev);
  1104.       }
  1105.      input_sync(data->input_dev);

  1107.     if (event->touch_point == 0) {
  1108.         ft5x0x_ts_release();
  1109.         return ;
  1110.     }
  1111. } /*end ft5x0x_report_value*/


  1114. /***********************************************************************************************
  1115. Name :

  1117. Input :


  1120. Output :

  1122. function :

  1124. ***********************************************************************************************/
  1125. static void ft5x0x_ts_pen_irq_work(struct work_struct *work)
  1126. {
  1127.     int ret = -1;

  1129. #if CFG_SUPPORT_READ_LEFT_DATA
  1130.     do
  1131.     {
  1132.         ret = ft5x0x_read_data();
  1133.         if (ret >= 0)
  1134.         {
  1135.             ft5x0x_report_value();
  1136.         }
  1137.     }while (ret > 0);

  1139. #else
  1140.     ret = ft5x0x_read_data();
  1141.     if (ret == 0)
  1142.     {
  1143.         ft5x0x_report_value();
  1144.     }
  1145. #endif
  1146.     enable_irq(IRQ_EINT7);
  1147. }
  1148. /***********************************************************************************************
  1149. Name :

  1151. Input :

  1153. Output :

  1155. function :

  1157. ***********************************************************************************************/
  1158. static irqreturn_t ft5x0x_ts_interrupt(int irq, void *dev_id)
  1159. {
  1160.     struct ft5x0x_ts_data *ft5x0x_ts = dev_id;

  1162.     //disable_irq(IRQ_EINT8);
  1163.     disable_irq_nosync(IRQ_EINT7);//lqm changed
  1164.     if (!work_pending(&ft5x0x_ts->pen_event_work))
  1165.     {
  1166.         queue_work(ft5x0x_ts->ts_workqueue, &ft5x0x_ts->pen_event_work);
  1167.     }

  1169.     return IRQ_HANDLED;
  1170. }

  1172. #ifdef CONFIG_HAS_EARLYSUSPEND
  1173. /***********************************************************************************************
  1174. Name :

  1176. Input :
  1177.                      

  1179. Output :

  1181. function :

  1183. ***********************************************************************************************/
  1184. static void ft5x0x_ts_suspend(struct early_suspend *handler)
  1185. {
  1186. // struct ft5x0x_ts_data *ts;
  1187. // ts = container_of(handler, struct ft5x0x_ts_data, early_suspend);

  1189.     printk("==ft5x0x_ts_suspend=\n");
  1190. // disable_irq(this_client->irq);
  1191. // disable_irq(IRQ_EINT(6));
  1192. // cancel_work_sync(&ts->pen_event_work);
  1193. // flush_workqueue(ts->ts_workqueue);
  1194.     // ==set mode ==,
  1195. // ft5x0x_set_reg(FT5X0X_REG_PMODE, PMODE_HIBERNATE);
  1196. }
  1197. /***********************************************************************************************
  1198. Name :

  1200. Input :
  1201.                      

  1203. Output :

  1205. function :

  1207. ***********************************************************************************************/
  1208. static void ft5x0x_ts_resume(struct early_suspend *handler)
  1209. {
  1210.     printk("==ft5x0x_ts_resume=\n");
  1211.     // wake the mode
  1212. // __gpio_as_output(GPIO_FT5X0X_WAKE);
  1213. // __gpio_clear_pin(GPIO_FT5X0X_WAKE); //set wake = 0,base on system
  1214. // msleep(100);
  1215. // __gpio_set_pin(GPIO_FT5X0X_WAKE); //set wake = 1,base on system
  1216. // msleep(100);
  1217. // enable_irq(this_client->irq);
  1218. // enable_irq(IRQ_EINT(6));
  1219. }
  1220. #endif //CONFIG_HAS_EARLYSUSPEND

  1222. static int
  1223. ft5x0x_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)
  1224. {
  1225.     struct ft5x0x_ts_data *ft5x0x_ts;
  1226.     struct input_dev *input_dev;
  1227.     int err = 0;
  1228.     unsigned char uc_reg_value;
  1229. #if CFG_SUPPORT_TOUCH_KEY
  1230.     int i;
  1231. #endif

  1233.     printk("[FTS] ft5x0x_ts_probe, driver version is %s.\n", CFG_FTS_CTP_DRIVER_VERSION);
  1234.     
  1235.     if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
  1236.     {
  1237.         err = -ENODEV;
  1238.         goto exit_check_functionality_failed;
  1239.     }

  1241.     ft5x0x_ts = kzalloc(sizeof(*ft5x0x_ts), GFP_KERNEL);
  1242.     if (!ft5x0x_ts)
  1243.     {
  1244.         err = -ENOMEM;
  1245.         goto exit_alloc_data_failed;
  1246.     }

  1248.     this_client = client;
  1249.     i2c_set_clientdata(client, ft5x0x_ts);

  1251.     INIT_WORK(&ft5x0x_ts->pen_event_work, ft5x0x_ts_pen_irq_work);

  1253.     ft5x0x_ts->ts_workqueue = create_singlethread_workqueue(dev_name(&client->dev));
  1254.     if (!ft5x0x_ts->ts_workqueue) {
  1255.         err = -ESRCH;
  1256.         goto exit_create_singlethread;
  1257.     }

  1259.     /* config interrupt pin
  1260.      * x210ii: INT = GPH0_7
  1261.      * */
  1262.     s3c_gpio_cfgpin(S5PV210_GPH0(7), S3C_GPIO_SFN(0xf));
  1263.     s3c_gpio_setpull(S5PV210_GPH0(7), S3C_GPIO_PULL_UP);
  1264.     set_irq_type(IRQ_EINT7, IRQF_TRIGGER_FALLING);

  1266.     err = request_irq(IRQ_EINT7, ft5x0x_ts_interrupt, IRQF_TRIGGER_FALLING, "ft5x0x_ts", ft5x0x_ts);
  1267.     if (err < 0)
  1268.     {
  1269.         dev_err(&client->dev, "ft5x0x_probe: request irq failed\n");
  1270.         goto exit_irq_request_failed;
  1271.     }

  1273.     //disable_irq(IRQ_EINT8);
  1274.     disable_irq_nosync(IRQ_EINT7);//lqm changed.

  1276.     input_dev = input_allocate_device();
  1277.     if (!input_dev) {
  1278.         err = -ENOMEM;
  1279.         dev_err(&client->dev, "failed to allocate input device\n");
  1280.         goto exit_input_dev_alloc_failed;
  1281.     }
  1282.     
  1283.     ft5x0x_ts->input_dev = input_dev;

  1285. // set_bit(ABS_PRESSURE, input_dev->absbit);
  1286. // set_bit(ABS_X, input_dev->absbit);
  1287. // set_bit(ABS_Y, input_dev->absbit);
  1288.  // set_bit(ABS_MT_WIDTH_MAJOR, input_dev->absbit);

  1290.     input_set_abs_params(input_dev, ABS_X, 0, 800, 0, 0);
  1291.     input_set_abs_params(input_dev, ABS_Y, 0, 480, 0, 0);
  1292.     input_set_abs_params(input_dev, ABS_PRESSURE, 0, 1, 0, 0);
  1293. // input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, 200, 0, 0);
  1294. // input_set_abs_params(input_dev, ABS_MT_TRACKING_ID, 0, 5, 0, 0);
  1295. /*
  1296.     set_bit(ABS_MT_TOUCH_MAJOR, input_dev->absbit);
  1297.     set_bit(ABS_MT_POSITION_X, input_dev->absbit);
  1298.     set_bit(ABS_MT_POSITION_Y, input_dev->absbit);
  1299.     set_bit(ABS_MT_WIDTH_MAJOR, input_dev->absbit);

  1301.     input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, 800, 0, 0);
  1302.     input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, 480, 0, 0);
  1303.     input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, PRESS_MAX, 0, 0);
  1304.     input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, 200, 0, 0);
  1305.     input_set_abs_params(input_dev, ABS_MT_TRACKING_ID, 0, 5, 0, 0);
  1306. */
  1307.     set_bit(EV_KEY, input_dev->evbit);
  1308.     set_bit(EV_ABS, input_dev->evbit);

  1310. #if CFG_SUPPORT_TOUCH_KEY
  1311.     //setup key code area
  1312.     set_bit(EV_SYN, input_dev->evbit);
  1313.     set_bit(BTN_TOUCH, input_dev->keybit);
  1314.     input_dev->keycode = tsp_keycodes;
  1315.     for(i = 0; i < CFG_NUMOFKEYS; i++)
  1316.     {
  1317.         input_set_capability(input_dev, EV_KEY, ((int*)input_dev->keycode)[i]);
  1318.         tsp_keystatus[i] = KEY_RELEASE;
  1319.     }
  1320. #endif

  1322.     input_dev->name = FT5X0X_NAME; //dev_name(&client->dev)
  1323.     err = input_register_device(input_dev);
  1324.     if (err)
  1325.     {
  1326.         dev_err(&client->dev,"ft5x0x_ts_probe: failed to register input device: %s\n",
  1327.                              dev_name(&client->dev));
  1328.         goto exit_input_register_device_failed;
  1329.     }

  1331. #ifdef CONFIG_HAS_EARLYSUSPEND
  1332.     printk("==register_early_suspend =\n");
  1333.     ft5x0x_ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
  1334.     ft5x0x_ts->early_suspend.suspend = ft5x0x_ts_suspend;
  1335.     ft5x0x_ts->early_suspend.resume = ft5x0x_ts_resume;
  1336.     register_early_suspend(&ft5x0x_ts->early_suspend);
  1337. #endif

  1339.     msleep(150); //make sure CTP already finish startup process

  1341.     //get some register information
  1342.     uc_reg_value = ft5x0x_read_fw_ver();
  1343.     printk("[FTS] Firmware version = 0x%x\n", uc_reg_value);

  1345.     ft5x0x_read_reg(FT5X0X_REG_PERIODACTIVE, &uc_reg_value);
  1346.     printk("[FTS] report rate is %dHz.\n", uc_reg_value * 10);
  1347.     ft5x0x_read_reg(FT5X0X_REG_THGROUP, &uc_reg_value);
  1348.     printk("[FTS] touch threshold is %d.\n", uc_reg_value * 4);

  1350. #if CFG_SUPPORT_AUTO_UPG
  1351.         fts_ctpm_auto_upg();
  1352. #endif


  1355. #if CFG_SUPPORT_UPDATE_PROJECT_SETTING
  1356.     fts_ctpm_update_project_setting();
  1357. #endif

  1359. #if CFG_DBG_RAW_DATA_READ
  1360.     fts_raw_data_test();
  1361. #endif

  1363. // msleep(300);
  1364. // fts_ctpm_read_project_setting();

  1366.     enable_irq(IRQ_EINT7);

  1368.     have_cap_touchscreen=1;

  1370.     printk("[FTS] ==probe over =\n");
  1371.     return 0;

  1373. exit_input_register_device_failed:
  1374.     input_free_device(input_dev);
  1375. exit_input_dev_alloc_failed:
  1376.     free_irq(IRQ_EINT7, ft5x0x_ts);
  1377. exit_irq_request_failed:
  1378. //exit_platform_data_null:
  1379.     cancel_work_sync(&ft5x0x_ts->pen_event_work);
  1380.     destroy_workqueue(ft5x0x_ts->ts_workqueue);
  1381. exit_create_singlethread:
  1382.     printk("==singlethread error =\n");
  1383.     i2c_set_clientdata(client, NULL);
  1384.     kfree(ft5x0x_ts);
  1385. exit_alloc_data_failed:
  1386. exit_check_functionality_failed:
  1387.     return err;
  1388. }

  1390. static int __devexit ft5x0x_ts_remove(struct i2c_client *client)
  1391. {
  1392.     struct ft5x0x_ts_data *ft5x0x_ts;
  1393.     printk("==ft5x0x_ts_remove=\n");
  1394.     ft5x0x_ts = i2c_get_clientdata(client);
  1395.     unregister_early_suspend(&ft5x0x_ts->early_suspend);
  1396.     free_irq(IRQ_EINT7, ft5x0x_ts);
  1397.     input_unregister_device(ft5x0x_ts->input_dev);
  1398.     kfree(ft5x0x_ts);
  1399.     cancel_work_sync(&ft5x0x_ts->pen_event_work);
  1400.     destroy_workqueue(ft5x0x_ts->ts_workqueue);
  1401.     i2c_set_clientdata(client, NULL);
  1402.     return 0;
  1403. }

  1405. static const struct i2c_device_id ft5x0x_ts_id[] = {
  1406.     { "ft5406-iic", 0 },{ }
  1407. };


  1410. MODULE_DEVICE_TABLE(i2c, ft5x0x_ts_id);

  1412. static struct i2c_driver ft5406_iic_driver = {
  1413.     .driver        = {
  1414.         .name    = "ft5406-iic",
  1415.         .owner = THIS_MODULE,
  1416.     },

  1418.     .probe        = ft5x0x_ts_probe,
  1419.     .remove        = __devexit_p(ft5x0x_ts_remove),
  1420.     .id_table    = ft5x0x_ts_id,
  1421. };

  1423. static int ft5406_ts_probe(struct platform_device * pdev)
  1424. {
  1425.     struct i2c_adapter * adapter;
  1426.     struct i2c_client * client;
  1427.     struct i2c_board_info info;
  1428.     int ret;

  1430.     adapter = i2c_get_adapter(FT5406_I2C_BUS);
  1431.     if(adapter == NULL)
  1432.         return -ENODEV;

  1434.     memset(&info, 0, sizeof(struct i2c_board_info));
  1435.     info.addr = I2C_CTPM_ADDRESS;
  1436.     strlcpy(info.type, "ft5406-iic", I2C_NAME_SIZE);

  1438.     client = i2c_new_device(adapter, &info);
  1439.     if(!client)
  1440.     {
  1441.         printk("Unable to add I2C device for 0x%x\n", info.addr);
  1442.         return -ENODEV;
  1443.     }
  1444.     i2c_put_adapter(adapter);

  1446.     ret = i2c_add_driver(&ft5406_iic_driver);
  1447.     if(ret)
  1448.     {
  1449.         printk("ft5406 iic add driver error!\r\n");
  1450.         return ret;
  1451.     }

  1453.     return 0;
  1454. }

  1456. static int ft5406_ts_remove(struct platform_device * pdev)
  1457. {
  1458.     i2c_del_driver(&ft5406_iic_driver);
  1459.     return 0;
  1460. }

  1462. static int ft5406_ts_suspend(struct platform_device * dev, pm_message_t state)
  1463. {
  1464.     return 0;
  1465. }

  1467. static int ft5406_ts_resume(struct platform_device * dev)
  1468. {
  1469.     return 0;
  1470. }

  1472. static struct platform_device ft5406_ts_device = {
  1473.     .name    = "ft5406-ts",
  1474.     .id        =-1,
  1475. };

  1477. static struct platform_driver ft5406_ts_driver = {
  1478.     .driver        = {
  1479.         .name    = "ft5406-ts",
  1480.     },
  1481.     .probe        = ft5406_ts_probe,
  1482.     .remove        = ft5406_ts_remove,
  1483.     .suspend    = ft5406_ts_suspend,
  1484.     .resume        = ft5406_ts_resume,
  1485. };

  1487. static int __init ft5x0x_ts_init(void)
  1488. {
  1489.     int ret;
  1490.     if(have_cap_touchscreen != 0)
  1491.         return 0;

  1493.     printk("==ft5x0x_ts_init==\n");

  1495.     /*
  1496.      * set cap touchscreen's shutdown pin to low level
  1497.      * x210ii: CAP_WAKE = GPH0_6
  1498.      */
  1499.     s3c_gpio_setpull(S5PV210_GPH0(6), S3C_GPIO_PULL_DOWN);
  1500.     s3c_gpio_cfgpin(S5PV210_GPH0(6), S3C_GPIO_SFN(1));
  1501.     gpio_set_value(S5PV210_GPH0(6), 0);
  1502.     /* wait a moment */
  1503.     mdelay(10);
  1504.     gpio_set_value(S5PV210_GPH0(6), 1);

  1506.     ret = platform_device_register(&ft5406_ts_device);
  1507.     if(ret)
  1508.     {
  1509.         printk("failed to register platform device\n");
  1510.     }

  1512.     ret = platform_driver_register(&ft5406_ts_driver);
  1513.     if(ret != 0)
  1514.     {
  1515.         printk("fail to register platform driver\n");
  1516.         return ret;
  1517.     }

  1519.     return 0;
  1520. }

  1522. static void __exit ft5x0x_ts_exit(void)
  1523. {
  1524.     printk("==ft5x0x_ts_exit==\n");
  1525.     platform_driver_unregister(&ft5406_ts_driver);
  1526. }

  1528. module_init(ft5x0x_ts_init);
  1529. module_exit(ft5x0x_ts_exit);

  1531. MODULE_AUTHOR("liuqiming");
  1532. MODULE_DESCRIPTION("FocalTech ft5x0x TouchScreen driver");
  1533. MODULE_LICENSE("GPL");

x210 kernel中的ft5x06.h：

点击(此处)折叠或打开

  1. #ifndef __LINUX_FT5X0X_TS_H__
  2. #define __LINUX_FT5X0X_TS_H__


  5. /* -- dirver configure -- */
  6. #define CFG_SUPPORT_AUTO_UPG 0
  7. #define CFG_SUPPORT_UPDATE_PROJECT_SETTING 0
  8. #define CFG_SUPPORT_TOUCH_KEY /*0*/1 //touch key, HOME, SEARCH, RETURN etc
  9. #define CFG_SUPPORT_READ_LEFT_DATA 0
  10. #define CFG_DBG_RAW_DATA_READ 0

  12. #define CFG_MAX_TOUCH_POINTS 1 //wangzm 5
  13. #define CFG_NUMOFKEYS 4
  14. #define CFG_FTS_CTP_DRIVER_VERSION "2.0"

  16. #define SCREEN_MAX_X 1728
  17. #define SCREEN_MAX_Y 1024
  18. #define PRESS_MAX 255

  20. #define CFG_POINT_READ_BUF (3 + 6 * (CFG_MAX_TOUCH_POINTS))

  22. #define FT5X0X_NAME    "ft5x0x_ts"//"synaptics_i2c_rmi"//"synaptics-rmi-ts"//

  24. #define KEY_PRESS 1
  25. #define KEY_RELEASE 0

  27. enum ft5x0x_ts_regs {
  28.     FT5X0X_REG_THGROUP                    = 0x80, /* touch threshold, related to sensitivity */
  29.     FT5X0X_REG_THPEAK                        = 0x81,
  30.     FT5X0X_REG_THCAL                        = 0x82,
  31.     FT5X0X_REG_THWATER                    = 0x83,
  32.     FT5X0X_REG_THTEMP                    = 0x84,
  33.     FT5X0X_REG_THDIFF                        = 0x85,                
  34.     FT5X0X_REG_CTRL                        = 0x86,
  35.     FT5X0X_REG_TIMEENTERMONITOR            = 0x87,
  36.     FT5X0X_REG_PERIODACTIVE                = 0x88, /* report rate */
  37.     FT5X0X_REG_PERIODMONITOR            = 0x89,
  38.     FT5X0X_REG_HEIGHT_B                    = 0x8a,
  39.     FT5X0X_REG_MAX_FRAME                    = 0x8b,
  40.     FT5X0X_REG_DIST_MOVE                    = 0x8c,
  41.     FT5X0X_REG_DIST_POINT                = 0x8d,
  42.     FT5X0X_REG_FEG_FRAME                    = 0x8e,
  43.     FT5X0X_REG_SINGLE_CLICK_OFFSET        = 0x8f,
  44.     FT5X0X_REG_DOUBLE_CLICK_TIME_MIN    = 0x90,
  45.     FT5X0X_REG_SINGLE_CLICK_TIME            = 0x91,
  46.     FT5X0X_REG_LEFT_RIGHT_OFFSET        = 0x92,
  47.     FT5X0X_REG_UP_DOWN_OFFSET            = 0x93,
  48.     FT5X0X_REG_DISTANCE_LEFT_RIGHT        = 0x94,
  49.     FT5X0X_REG_DISTANCE_UP_DOWN        = 0x95,
  50.     FT5X0X_REG_ZOOM_DIS_SQR                = 0x96,
  51.     FT5X0X_REG_RADIAN_VALUE                =0x97,
  52.     FT5X0X_REG_MAX_X_HIGH     = 0x98,
  53.     FT5X0X_REG_MAX_X_LOW             = 0x99,
  54.     FT5X0X_REG_MAX_Y_HIGH             = 0x9a,
  55.     FT5X0X_REG_MAX_Y_LOW             = 0x9b,
  56.     FT5X0X_REG_K_X_HIGH             = 0x9c,
  57.     FT5X0X_REG_K_X_LOW             = 0x9d,
  58.     FT5X0X_REG_K_Y_HIGH             = 0x9e,
  59.     FT5X0X_REG_K_Y_LOW             = 0x9f,
  60.     FT5X0X_REG_AUTO_CLB_MODE            = 0xa0,
  61.     FT5X0X_REG_LIB_VERSION_H                 = 0xa1,
  62.     FT5X0X_REG_LIB_VERSION_L                 = 0xa2,        
  63.     FT5X0X_REG_CIPHER                        = 0xa3,
  64.     FT5X0X_REG_MODE                        = 0xa4,
  65.     FT5X0X_REG_PMODE                        = 0xa5,     /* Power Consume Mode        */    
  66.     FT5X0X_REG_FIRMID                        = 0xa6, /* Firmware version */
  67.     FT5X0X_REG_STATE                        = 0xa7,
  68.     FT5X0X_REG_FT5201ID                    = 0xa8,
  69.     FT5X0X_REG_ERR                        = 0xa9,
  70.     FT5X0X_REG_CLB                        = 0xaa,
  71. };

  73. //FT5X0X_REG_PMODE
  74. #define PMODE_ACTIVE 0x00
  75. #define PMODE_MONITOR 0x01
  76. #define PMODE_STANDBY 0x02
  77. #define PMODE_HIBERNATE 0x03


  80.     #ifndef ABS_MT_TOUCH_MAJOR
  81.     #define ABS_MT_TOUCH_MAJOR    0x30    /* touching ellipse */
  82.     #define ABS_MT_TOUCH_MINOR    0x31    /* (omit if circular) */
  83.     #define ABS_MT_WIDTH_MAJOR    0x32    /* approaching ellipse */
  84.     #define ABS_MT_WIDTH_MINOR    0x33    /* (omit if circular) */
  85.     #define ABS_MT_ORIENTATION    0x34    /* Ellipse orientation */
  86.     #define ABS_MT_POSITION_X    0x35    /* Center X ellipse position */
  87.     #define ABS_MT_POSITION_Y    0x36    /* Center Y ellipse position */
  88.     #define ABS_MT_TOOL_TYPE    0x37    /* Type of touching device */
  89.     #define ABS_MT_BLOB_ID        0x38    /* Group set of pkts as blob */
  90.     #endif /* ABS_MT_TOUCH_MAJOR */

  92.     #ifndef ABS_MT_TRACKING_ID
  93.     #define ABS_MT_TRACKING_ID 0x39 /* Unique ID of initiated contact */
  94.     #endif

  96. #endif




阅读(4911) | 评论(0) | 转发(0) |
0

上一篇：使用vim+ctags+cscope阅读内核源码

下一篇：linux下修改MAC地址方法-大全

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6