drivers/input/touchscreen/gt811_ts.c

   1 /* drivers/input/touchscreen/gt811.c\r
   2  *\r
   3  * Copyright (C) 2010 - 2011 Goodix, Inc.\r
   4  * \r
   5  * This program is free software; you can redistribute it and/or modify\r
   6  * it under the terms of the GNU General Public License as published by\r
   7  * the Free Software Foundation; either version 2 of the License, or\r
   8  * (at your option) any later version.\r
   9  *\r
  10  * This program is distributed in the hope that it will be useful, but WITHOUT\r
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\r
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for\r
  13  * more details.\r
  14  *\r
  15  *Any problem,please contact andrew@goodix.com,+86 755-33338828\r
  16  *\r
  17  */\r
  18  \r
  19 #include <linux/kernel.h>\r
  20 #include <linux/module.h>\r
  21 #include <linux/time.h>\r
  22 #include <linux/delay.h>\r
  23 #include <linux/device.h>\r
  24 #include <linux/earlysuspend.h>\r
  25 #include <linux/hrtimer.h>\r
  26 #include <linux/i2c.h>\r
  27 #include <linux/input.h>\r
  28 #include <linux/interrupt.h>\r
  29 #include <linux/io.h>\r
  30 #include <linux/platform_device.h>\r
  31 #include <mach/gpio.h>\r
  32 //#include <plat/gpio-cfg.h>\r
  33 //#include <plat/gpio-bank-l.h>\r
  34 //#include <plat/gpio-bank-f.h>\r
  35 #include <linux/irq.h>\r
  36 #include <linux/syscalls.h>\r
  37 #include <linux/reboot.h>\r
  38 #include <linux/proc_fs.h>\r
  39 #include "gt811_ts.h"\r
  40 #include "gt811_firmware.h"\r
  41 \r
  42 #include <linux/vmalloc.h>\r
  43 #include <linux/fs.h>\r
  44 #include <linux/string.h>\r
  45 #include <linux/completion.h>\r
  46 #include <asm/uaccess.h>\r
  47 #include <linux/input/mt.h>\r
  48 #include <plat/board.h>\r
  49 #include <mach/iomux.h>\r
  50 #ifdef CONFIG_RK_CONFIG\r
  51 #include <mach/config.h>\r
  52 #endif\r
  53 #define TP_MODULE_NAME  GOODIX_I2C_NAME\r
  54 #ifdef CONFIG_RK_CONFIG\r
  55 \r
  56 enum {\r
  57 #if defined(RK2928_SDK_DEFAULT_CONFIG)\r
  58         DEF_EN = 1,\r
  59         DEF_IRQ = 0x008003c7,\r
  60         DEF_RST = 0X000003c3,\r
  61 #elif defined(RK2926_V86_DEFAULT_CONFIG)\r
  62         DEF_EN = 1,\r
  63         DEF_IRQ = 0x008001b0,\r
  64         DEF_RST = 0X000000d3,\r
  65 #else\r
  66         DEF_EN = 0,\r
  67         DEF_IRQ = -1,\r
  68         DEF_RST = -1,\r
  69 #endif\r
  70         DEF_I2C = 2, \r
  71         DEF_ADDR = 0x5d,\r
  72         DEF_X_MAX = 800,\r
  73         DEF_Y_MAX = 480,\r
  74 };\r
  75 static int en = DEF_EN;\r
  76 module_param(en, int, 0644);\r
  77 \r
  78 static int irq = DEF_IRQ;\r
  79 module_param(irq, int, 0644);\r
  80 static int rst =DEF_RST;\r
  81 module_param(rst, int, 0644);\r
  82 \r
  83 static int i2c = DEF_I2C;            // i2c channel\r
  84 module_param(i2c, int, 0644);\r
  85 static int addr = DEF_ADDR;           // i2c addr\r
  86 module_param(addr, int, 0644);\r
  87 static int x_max = DEF_X_MAX;\r
  88 module_param(x_max, int, 0644);\r
  89 static int y_max = DEF_Y_MAX;\r
  90 module_param(y_max, int, 0644);\r
  91 \r
  92 static int tp_hw_init(void)\r
  93 {\r
  94         int ret = 0;\r
  95 \r
  96         ret = gpio_request(get_port_config(irq).gpio, "tp_irq");\r
  97         if(ret < 0){\r
  98                 printk("%s: gpio_request(irq gpio) failed\n", __func__);\r
  99                 return ret;\r
 100         }\r
 101 \r
 102         ret = port_output_init(rst, 1, "tp_rst");\r
 103         if(ret < 0){\r
 104                 printk("%s: port(rst) output init faild\n", __func__);\r
 105                 return ret;\r
 106         }\r
 107         mdelay(10);\r
 108         port_output_off(rst);\r
 109         mdelay(10);\r
 110         port_output_on(rst);\r
 111         msleep(300);\r
 112 \r
 113          return 0;\r
 114 }\r
 115 #include "rk_tp.c"\r
 116 #endif\r
 117 \r
 118 \r
 119 \r
 120 static struct workqueue_struct *goodix_wq;\r
 121 static const char *s3c_ts_name = "gt811_ts";\r
 122 //static struct point_queue finger_list;\r
 123 struct i2c_client * i2c_connect_client = NULL;\r
 124 int reset_pin = 0;\r
 125 //EXPORT_SYMBOL(i2c_connect_client);\r
 126 static struct proc_dir_entry *goodix_proc_entry;\r
 127 static short  goodix_read_version(struct gt811_ts_data *ts);    \r
 128 //static int tpd_button(struct gt811_ts_data *ts, unsigned int x, unsigned int y, unsigned int down);\r
 129 \r
 130 #ifdef CONFIG_HAS_EARLYSUSPEND\r
 131 static void goodix_ts_early_suspend(struct early_suspend *h);\r
 132 static void goodix_ts_late_resume(struct early_suspend *h);\r
 133 int  gt811_downloader( struct gt811_ts_data *ts, unsigned char * data);\r
 134 #endif\r
 135 //used by firmware update CRC\r
 136 unsigned int oldcrc32 = 0xFFFFFFFF;\r
 137 unsigned int crc32_table[256];\r
 138 unsigned int ulPolynomial = 0x04c11db7;\r
 139 \r
 140 unsigned int raw_data_ready = RAW_DATA_NON_ACTIVE;\r
 141 \r
 142 //#define DEBUG\r
 143 #ifdef DEBUG\r
 144 int sum = 0;\r
 145 int access_count = 0;\r
 146 int int_count = 0;\r
 147 #endif\r
 148 #define HAVE_TOUCH_KEY\r
 149  //#define READ_KEY_VALUE\r
 150  //#define READ_KEY_COOR\r
 151 \r
 152 #ifdef HAVE_TOUCH_KEY\r
 153     const uint16_t touch_key_array[]={\r
 154                                        KEY_MENU,             //MENU\r
 155                                        KEY_HOMEPAGE,                                    \r
 156                                        KEY_BACK,\r
 157                                        KEY_SEARCH\r
 158                                       };\r
 159 #define MAX_KEY_NUM  (sizeof(touch_key_array)/sizeof(touch_key_array[0]))\r
 160 #endif\r
 161 \r
 162 /*******************************************************        \r
 163 Function:\r
 164         Read data from the slave\r
 165         Each read operation with two i2c_msg composition, for the first message sent from the machine address,\r
 166         Article 2 reads the address used to send and retrieve data; each message sent before the start signal\r
 167 Parameters:\r
 168         client: i2c devices, including device address\r
 169         buf [0]: The first byte to read Address\r
 170         buf [1] ~ buf [len]: data buffer\r
 171         len: the length of read data\r
 172 return:\r
 173         Execution messages\r
 174 *********************************************************/\r
 175 /*Function as i2c_master_send */\r
 176 static int i2c_read_bytes(struct i2c_client *client, uint8_t *buf, int len)\r
 177 {\r
 178         struct i2c_msg msgs[2];\r
 179         int ret=-1;\r
 180         \r
 181         msgs[0].flags=!I2C_M_RD;\r
 182         msgs[0].addr=client->addr;\r
 183         msgs[0].len=2;\r
 184         msgs[0].buf=&buf[0];\r
 185         msgs[0].scl_rate=200000;\r
 186 \r
 187         msgs[1].flags=I2C_M_RD;\r
 188         msgs[1].addr=client->addr;\r
 189         msgs[1].len=len-2;\r
 190         msgs[1].buf=&buf[2];\r
 191         msgs[1].scl_rate=200000;\r
 192         \r
 193         ret=i2c_transfer(client->adapter,msgs, 2);\r
 194         return ret;\r
 195 }\r
 196 \r
 197 /*******************************************************        \r
 198 Function:\r
 199         Write data to a slave\r
 200 Parameters:\r
 201         client: i2c devices, including device address\r
 202         buf [0]: The first byte of the write address\r
 203         buf [1] ~ buf [len]: data buffer\r
 204         len: data length\r
 205 return:\r
 206         Execution messages\r
 207 *******************************************************/\r
 208 /*Function as i2c_master_send */\r
 209 static int i2c_write_bytes(struct i2c_client *client,uint8_t *data,int len)\r
 210 {\r
 211         struct i2c_msg msg;\r
 212         int ret=-1;\r
 213         //发送设备地址\r
 214         msg.flags=!I2C_M_RD;//å\86\99æ¶\88æ\81? msg.addr=client->addr;\r
 215         msg.len=len;\r
 216         msg.buf=data;   \r
 217         msg.scl_rate=200000;\r
 218     msg.addr=client->addr;\r
 219         \r
 220         ret=i2c_transfer(client->adapter,&msg, 1);\r
 221         return ret;\r
 222 }\r
 223 \r
 224 /*******************************************************\r
 225 Function:\r
 226         Send a prefix command\r
 227         \r
 228 Parameters:\r
 229         ts: client private data structure\r
 230         \r
 231 return:\r
 232         Results of the implementation code, 0 for normal execution\r
 233 *******************************************************/\r
 234 static int i2c_pre_cmd(struct gt811_ts_data *ts)\r
 235 {\r
 236         int ret;\r
 237         uint8_t pre_cmd_data[2]={0};    \r
 238         pre_cmd_data[0]=0x0f;\r
 239         pre_cmd_data[1]=0xff;\r
 240         ret=i2c_write_bytes(ts->client,pre_cmd_data,2);\r
 241         //msleep(2);\r
 242         return ret;\r
 243 }\r
 244 \r
 245 /*******************************************************\r
 246 Function:\r
 247         Send a suffix command\r
 248         \r
 249 Parameters:\r
 250         ts: client private data structure\r
 251         \r
 252 return:\r
 253         Results of the implementation code, 0 for normal execution\r
 254 *******************************************************/\r
 255 static int i2c_end_cmd(struct gt811_ts_data *ts)\r
 256 {\r
 257         int ret;\r
 258         uint8_t end_cmd_data[2]={0};    \r
 259         end_cmd_data[0]=0x80;\r
 260         end_cmd_data[1]=0x00;\r
 261         ret=i2c_write_bytes(ts->client,end_cmd_data,2);\r
 262         //msleep(2);\r
 263         return ret;\r
 264 }\r
 265 \r
 266 /********************************************************************\r
 267 \r
 268 *********************************************************************/\r
 269 #ifdef COOR_TO_KEY\r
 270 static int list_key(s32 x_value, s32 y_value, u8* key)\r
 271 {\r
 272         s32 i;\r
 273 \r
 274 #ifdef AREA_Y\r
 275         if (y_value <= AREA_Y)\r
 276 #else\r
 277         if (x_value <= AREA_X)\r
 278 #endif\r
 279         {\r
 280                 return 0;\r
 281         }\r
 282 \r
 283         for (i = 0; i < MAX_KEY_NUM; i++)\r
 284         {\r
 285                 if (abs(key_center[i][x] - x_value) < KEY_X \r
 286                 && abs(key_center[i][y] - y_value) < KEY_Y)\r
 287                 {\r
 288                         (*key) |= (0x01<<i);\r
 289                 }\r
 290          }\r
 291 \r
 292     return 1;\r
 293 }\r
 294 #endif \r
 295 \r
 296 /*******************************************************\r
 297 Function:\r
 298         Guitar initialization function, used to send configuration information, access to version information\r
 299 Parameters:\r
 300         ts: client private data structure\r
 301 return:\r
 302         Results of the implementation code, 0 for normal execution\r
 303 *******************************************************/\r
 304 static int goodix_init_panel(struct gt811_ts_data *ts)\r
 305 {\r
 306         short ret=-1;\r
 307         uint8_t config_info[] = {\r
 308         0x06,0xA2,\r
 309 /*\r
 310         0x00,0x02,0x04,0x06,0x08,0x0A,0x0C,0x0E,0x10,0x12,0x60,0x00,0x50,0x00,0x40,0x00,\r
 311         0x30,0x00,0x20,0x00,0x10,0x00,0x00,0x00,0x70,0x00,0x80,0x00,0x90,0x00,0xA0,0x00,\r
 312         0xB0,0x00,0xC0,0x00,0xD0,0x00,0xE0,0x00,0xF0,0x00,0x05,0x03,0x90,0x90,0x90,0x30,\r
 313         0x30,0x30,0x0F,0x0F,0x0A,0x50,0x3C,0x08,0x03,0x3C,0x05,0x00,0x14,0x00,0x20,0x04,\r
 314         0x04,0x64,0x5A,0x40,0x40,0x00,0x00,0x03,0x19,0x00,0x05,0x00,0x00,0x00,0x00,0x00,\r
 315         0x20,0x10,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0F,0x50,\r
 316         0x3C,0x3C,0x28,0x00,0x00,0x00,0x00,0x00,0x00,0x01\r
 317 */\r
 318 /*      0x00,0x02,0x04,0x06,0x08,0x0A,0x0C,0x0E,0x10,0x12,0x13,0x33,0x23,0x33,0x33,0x33,\r
 319         0x43,0x33,0x53,0x33,0x63,0x33,0x73,0x33,0x83,0x33,0x93,0x33,0xA3,0x33,0xB3,0x33,\r
 320         0xC3,0x33,0xD3,0x33,0xE3,0x33,0xF3,0x33,0x03,0x33,0x3B,0x03,0x88,0x88,0x88,0x1B,\r
 321         0x1B,0x1B,0x0F,0x0F,0x0A,0x40,0x30,0x0F,0x03,0x00,0x05,0x00,0x14,0x00,0x1E,0x04,\r
 322         0x04,0x64,0x5A,0x40,0x40,0x00,0x00,0x05,0x19,0x05,0x05,0x00,0x00,0x00,0x00,0x00,\r
 323         0x20,0x10,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0F,0x50,\r
 324         0x3C,0x3C,0x28,0x00,0x00,0x00,0x00,0x00,0x00,0x01\r
 325 */      \r
 326 \r
 327    /* 0x12,0x10,0x0E,0x0C,0x0A,0x08,0x06,0x04,0x02,0x00,\r
 328     0x02,0x22,0x12,0x22,0x22,0x22,0x32,0x22,0x42,0x22,\r
 329     0x52,0x22,0x62,0x22,0x72,0x22,0x82,0x22,0x92,0x22,\r
 330     0xA2,0x22,0xB2,0x22,0xC2,0x22,0xD2,0x22,0xE2,0x22,\r
 331     0xF2,0x22,0x1B,0x03,0x88,0x88,0x88,0x1D,0x1D,0x1D,\r
 332     0x10,0x0F,0x0A,0x47,0x2A,0x0D,0x03,0x00,0x05,0x00,\r
 333     0x03,0x00,0x04,0x00,0x00,0x38,0x33,0x35,0x30,0x00,\r
 334     0x00,0x07,0x20,0x05,0x05,0x00,0x00,0x00,0x00,0x00,\r
 335     0x32,0x16,0x80,0x03,0x00,0x40,0x17,0x88,0x1B,0x00,\r
 336     0x71,0x80,0x90,0xA0,0x0A,0x45,0x30,0x20,0x14,0x00,\r
 337     0x00,0x00,0x00,0x00,0x00,0x01*/\r
 338      \r
 339         /* 0x12,0x10,0x0E,0x0C,0x0A,0x08,0x06,0x04,0x02,0x00,\r
 340          0x52,0x22,0x62,0x22,0x72,0x22,0x82,0x22,0x92,0x22,\r
 341          0xA2,0x22,0xB2,0x22,0xC2,0x22,0xD2,0x22,0xE2,0x22,\r
 342          0xF2,0x22,0x02,0x22,0x12,0x22,0x22,0x22,0x32,0x22,\r
 343          0x42,0x22,0x07,0x03,0x88,0x88,0x88,0x27,0x27,0x27,\r
 344          0x0B,0x0A,0x09,0x40,0x30,0x01,0x03,0x00,0x05,0xE0,\r
 345          0x01,0x20,0x03,0x00,0x00,0xFF,0xFF,0x42,0x2B,0x00,\r
 346          0x00,0x23,0x14,0x05,0x06,0x00,0x00,0x00,0x00,0x00,\r
 347          0x14,0x10,0xC6,0x02,0x00,0x40,0x17,0x88,0x20,0x00,\r
 348          0x60,0x70,0x80,0x90,0x0D,0x40,0x30,0x25,0x20,0x00,\r
 349          0x00,0x00,0x00,0x00,0x00,0x01*/\r
 350            0x12,0x10,0x0E,0x0C,0x0A,0x08,0x06,0x04,0x02,0x00,\r
 351            0x02,0x22,0x12,0x22,0x22,0x22,0x32,0x22,0x42,0x22,\r
 352            0x52,0x22,0x62,0x22,0x72,0x22,0x83,0x22,0x92,0x22,\r
 353            0xA2,0x22,0xB2,0x22,0xC2,0x22,0xD2,0x22,0xE2,0x22,\r
 354            0xF2,0x22,0x1B,0x03,0x28,0x28,0x28,0x20,0x20,0x20,\r
 355            0x0F,0x0F,0x0A,0x45,0x30,0x04,0x03,0x00,0x05,0xE0,\r
 356            0x01,0x20,0x03,0x00,0x00,0x38,0x33,0x35,0x30,0x00,\r
 357            0x00,0x26,0x14,0x02,0x0A,0x00,0x00,0x00,0x00,0x00,\r
 358            0x14,0x10,0x30,0x02,0x00,0x00,0x00,0x00,0x00,0x00,\r
 359            0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,\r
 360            0x00,0x00,0x00,0x00,0x00,0x01\r
 361     \r
 362     };\r
 363 \r
 364         config_info[62] = TOUCH_MAX_WIDTH >> 8;\r
 365         config_info[61] = TOUCH_MAX_WIDTH & 0xff;\r
 366         config_info[64] = TOUCH_MAX_HEIGHT >> 8;\r
 367         config_info[63] = TOUCH_MAX_HEIGHT & 0xff;\r
 368         \r
 369         ret = i2c_write_bytes(ts->client, config_info, sizeof(config_info)/sizeof(config_info[0]));\r
 370         if(ret < 0)\r
 371         {\r
 372                 dev_info(&ts->client->dev, "GT811 Send config failed!\n");\r
 373                 return ret;\r
 374         }\r
 375         ts->abs_y_max = (config_info[62]<<8) + config_info[61];\r
 376         ts->abs_x_max = (config_info[64]<<8) + config_info[63];\r
 377         ts->max_touch_num = config_info[60];\r
 378         ts->int_trigger_type = ((config_info[57]>>3)&0x01);\r
 379         dev_info(&ts->client->dev, "GT811 init info:X_MAX=%d,Y_MAX=%d,TRIG_MODE=%s\n",\r
 380         ts->abs_x_max, ts->abs_y_max, ts->int_trigger_type?"RISING EDGE":"FALLING EDGE");\r
 381 \r
 382         return 0;\r
 383 }\r
 384 \r
 385 /*******************************************************\r
 386 FUNCTION:\r
 387         Read gt811 IC Version\r
 388 Argument:\r
 389         ts:     client\r
 390 return:\r
 391         0:success\r
 392        -1:error\r
 393 *******************************************************/\r
 394 static short  goodix_read_version(struct gt811_ts_data *ts)\r
 395 {\r
 396         short ret;\r
 397         uint8_t version_data[5]={0x07,0x17,0,0};        //store touchscreen version infomation\r
 398         uint8_t version_data2[5]={0x07,0x17,0,0};       //store touchscreen version infomation\r
 399 \r
 400         char i = 0;\r
 401         char cpf = 0;\r
 402         memset(version_data, 0, 5);\r
 403         version_data[0]=0x07;\r
 404         version_data[1]=0x17;   \r
 405 \r
 406         ret=i2c_read_bytes(ts->client, version_data, 4);\r
 407         if (ret < 0) \r
 408                 return ret;\r
 409         \r
 410         for(i = 0;i < 10;i++)\r
 411         {\r
 412                 i2c_read_bytes(ts->client, version_data2, 4);\r
 413                 if((version_data[2] !=version_data2[2])||(version_data[3] != version_data2[3]))\r
 414                 {\r
 415                         version_data[2] = version_data2[2];\r
 416                         version_data[3] = version_data2[3];\r
 417                         msleep(5);\r
 418                         break;\r
 419                 }\r
 420                 msleep(5);\r
 421                 cpf++;\r
 422         }\r
 423 \r
 424         if(cpf == 10)\r
 425         {\r
 426                 ts->version = (version_data[2]<<8)+version_data[3];\r
 427                 dev_info(&ts->client->dev, "GT811 Verion:0x%04x\n", ts->version);\r
 428                 ret = 0;\r
 429         }\r
 430         else\r
 431         {\r
 432                 dev_info(&ts->client->dev," Guitar Version Read Error: %d.%d\n",version_data[3],version_data[2]);\r
 433                 ts->version = 0xffff;\r
 434                 ret = -1;\r
 435         }\r
 436         \r
 437         return ret;\r
 438         \r
 439 }\r
 440 /******************start add by kuuga*******************/\r
 441 static void gt811_irq_enable(struct gt811_ts_data *ts)\r
 442 {       \r
 443         unsigned long irqflags; \r
 444         spin_lock_irqsave(&ts->irq_lock, irqflags);\r
 445         if (ts->irq_is_disable) \r
 446         {               \r
 447                 enable_irq(ts->irq);            \r
 448                 ts->irq_is_disable = 0; \r
 449         }       \r
 450         spin_unlock_irqrestore(&ts->irq_lock, irqflags);\r
 451 }\r
 452 \r
 453 static void gt811_irq_disable(struct gt811_ts_data *ts)\r
 454 {       \r
 455         unsigned long irqflags;\r
 456         spin_lock_irqsave(&ts->irq_lock, irqflags);\r
 457         if (!ts->irq_is_disable) \r
 458         {               \r
 459                 disable_irq_nosync(ts->irq);            \r
 460                 ts->irq_is_disable = 1; \r
 461         }       \r
 462         spin_unlock_irqrestore(&ts->irq_lock, irqflags);\r
 463 }\r
 464 \r
 465 /*****************end add by kuuga****************/\r
 466 \r
 467 /*******************************************************        \r
 468 Function:\r
 469         Touch-screen work function\r
 470         Triggered by the interruption, to accept a set of coordinate data,\r
 471         and then analyze the output parity\r
 472 Parameters:\r
 473         ts: client private data structure\r
 474 return:\r
 475         Results of the implementation code, 0 for normal execution\r
 476 ********************************************************/\r
 477 static void goodix_ts_work_func(struct work_struct *work)\r
 478 {       \r
 479         uint8_t  point_data[READ_BYTES_NUM] = {READ_TOUCH_ADDR_H,READ_TOUCH_ADDR_L,0};//point_data[8*MAX_FINGER_NUM+2]={ 0 };  \r
 480         uint8_t  check_sum = 0;\r
 481         uint8_t  read_position = 0;\r
 482         uint8_t  track_id[MAX_FINGER_NUM];\r
 483         uint8_t  point_index = 0;\r
 484         uint8_t  point_tmp = 0;\r
 485         uint8_t  point_count = 0;\r
 486         uint16_t input_x = 0;\r
 487         uint16_t input_y = 0;\r
 488         uint8_t  input_w = 0;\r
 489         static uint8_t  last_key = 0;\r
 490         uint8_t  finger = 0;\r
 491         uint8_t  key = 0;\r
 492         unsigned int  count = 0;\r
 493         unsigned int position = 0;      \r
 494         int ret=-1;\r
 495         int tmp = 0;\r
 496         \r
 497         struct gt811_ts_data *ts = container_of(work, struct gt811_ts_data, work);\r
 498 #ifdef DEBUG\r
 499         printk("int count :%d\n", ++int_count);\r
 500         printk("ready?:%d\n", raw_data_ready);\r
 501 #endif     \r
 502         if (RAW_DATA_ACTIVE == raw_data_ready)\r
 503         {\r
 504             raw_data_ready = RAW_DATA_READY;\r
 505 #ifdef DEBUG        \r
 506             printk("ready!\n");\r
 507 #endif\r
 508         }\r
 509         \r
 510 #ifndef INT_PORT\r
 511 COORDINATE_POLL:\r
 512 #endif\r
 513         if( tmp > 9) \r
 514         {\r
 515                 dev_info(&(ts->client->dev), "Because of transfer error,touchscreen stop working.\n");\r
 516                 goto XFER_ERROR ;\r
 517         }\r
 518         \r
 519         ret=i2c_read_bytes(ts->client, point_data, sizeof(point_data)/sizeof(point_data[0]));\r
 520         if(ret <= 0) \r
 521         {\r
 522        dev_err(&(ts->client->dev),"I2C transfer error. Number:%d\n ", ret);\r
 523        ts->bad_data = 1;\r
 524        tmp ++;\r
 525        ts->retry++;\r
 526 #ifndef INT_PORT\r
 527        goto COORDINATE_POLL;\r
 528 #else   \r
 529        goto XFER_ERROR;\r
 530 #endif  \r
 531    }\r
 532 #if 0\r
 533         for(count=0;count<(sizeof(point_data)/sizeof(point_data[0])); count++)\r
 534         {\r
 535                 printk("[%2d]:0x%2x", count, point_data[count]);\r
 536                 if((count+1)%10==0)printk("\n");\r
 537         }\r
 538         printk("\n");\r
 539 #endif  \r
 540         if(point_data[2]&0x20)\r
 541         {\r
 542                 if(point_data[3]==0xF0)\r
 543                 {\r
 544                         gpio_direction_output(reset_pin, 0);\r
 545                         msleep(1);\r
 546                 //      gpio_direction_input(reset_pin);\r
 547             gpio_set_value(reset_pin,0);\r
 548             msleep(100);\r
 549             gpio_set_value(reset_pin,1);\r
 550             msleep(100);\r
 551 \r
 552                         goodix_init_panel(ts);\r
 553                         goto WORK_FUNC_END;\r
 554                 }\r
 555         }\r
 556         switch(point_data[2]& 0x1f)\r
 557         {\r
 558                 case 0:\r
 559                 case 1:\r
 560                         for(count=2; count<9; count++)\r
 561                                 check_sum += (int)point_data[count];\r
 562                         read_position = 9;\r
 563                         break;\r
 564                 case 2:\r
 565                 case 3:\r
 566                         for(count=2; count<14;count++)\r
 567                                 check_sum += (int)point_data[count];\r
 568                         read_position = 14;\r
 569                         break;  \r
 570                 default:                //touch finger larger than 3\r
 571                         for(count=2; count<35;count++)\r
 572                                 check_sum += (int)point_data[count];\r
 573                         read_position = 35;\r
 574         }\r
 575         if(check_sum != point_data[read_position])\r
 576         {\r
 577                 dev_info(&ts->client->dev, "coor chksum error!\n");\r
 578                 goto XFER_ERROR;\r
 579         }\r
 580     \r
 581         point_index = point_data[2]&0x1f;\r
 582         point_tmp = point_index;\r
 583         for(position=0; (position<MAX_FINGER_NUM)&&point_tmp; position++)\r
 584         {\r
 585                 if(point_tmp&0x01)\r
 586                 {\r
 587                         track_id[point_count++] = position;\r
 588                 }       \r
 589                 point_tmp >>= 1;\r
 590         }       \r
 591         finger = point_count;\r
 592         if(finger)\r
 593         {\r
 594                 for(count=0; count<finger; count++)\r
 595                 {\r
 596                         if(track_id[count]!=3)\r
 597                         {\r
 598                                 if(track_id[count]<3)\r
 599                                         position = 4+track_id[count]*5;\r
 600                                 else\r
 601                                         position = 30;\r
 602                                 input_x = (uint16_t)(point_data[position]<<8)+(uint16_t)point_data[position+1];\r
 603                                 input_y = (uint16_t)(point_data[position+2]<<8)+(uint16_t)point_data[position+3];\r
 604                                 input_w = point_data[position+4];\r
 605                         }\r
 606                         else\r
 607                         {\r
 608                                 input_x = (uint16_t)(point_data[19]<<8)+(uint16_t)point_data[26];\r
 609         input_y = (uint16_t)(point_data[27]<<8)+(uint16_t)point_data[28];\r
 610         input_w = point_data[29];       \r
 611                         }\r
 612                         \r
 613                         //printk("real_input_y = %d,TOUCH_MAX_HEIGHT=%d,TOUCH_MAX_WIDTH=%d,input_x=%d,input_y=%d,input_w=%d\n",input_y, TOUCH_MAX_HEIGHT,TOUCH_MAX_WIDTH,TOUCH_MAX_HEIGHT - input_y,TOUCH_MAX_WIDTH-input_x,  input_w);\r
 614                         //if((input_y > ts->abs_x_max)||(TOUCH_MAX_WIDTH-input_x > ts->abs_y_max))continue;\r
 615                         input_mt_slot(ts->input_dev, track_id[count]);  \r
 616                         //input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, false);\r
 617                         input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, true);\r
 618                         //printk("DOWN\n")\r
 619 ; ;\r
 620                         input_report_abs(ts->input_dev, ABS_MT_POSITION_X, input_y);\r
 621                         input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, input_x);                    \r
 622                         input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, input_w);\r
 623                         //input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, input_w);\r
 624                         //input_report_abs(ts->input_dev, ABS_MT_TRACKING_ID, track_id[count]);\r
 625                         //input_mt_sync(ts->input_dev); \r
 626                 }\r
 627         }\r
 628         else\r
 629         {\r
 630                 for(tmp=0; tmp< MAX_FINGER_NUM; tmp++)\r
 631                 {\r
 632                 //printk("tmp=%d\n", tmp);\r
 633                 input_mt_slot(ts->input_dev, tmp);//æ\8c\89åº\8få\8f·ä¸\8aæ\8a?             //input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0);\r
 634                 input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, false);\r
 635                 }\r
 636                 //input_mt_sync(ts->input_dev);\r
 637         }\r
 638         \r
 639         //input_report_key(ts->input_dev, BTN_TOUCH, finger > 0);\r
 640         input_sync(ts->input_dev);\r
 641 \r
 642 #ifdef HAVE_TOUCH_KEY\r
 643         key = point_data[3]&0x0F;\r
 644         if((last_key != 0)||(key != 0))\r
 645         {\r
 646                 for(count = 0; count < MAX_KEY_NUM; count++)\r
 647                 {\r
 648       //printk("####################input_report_key++++++++++++%d\n",key);\r
 649                         input_report_key(ts->input_dev, touch_key_array[count], !!(key&(0x01<<count))); \r
 650                 }\r
 651         }               \r
 652         last_key = key; \r
 653 #endif\r
 654 \r
 655 XFER_ERROR:\r
 656 WORK_FUNC_END:\r
 657 #ifndef STOP_IRQ_TYPE\r
 658         if(ts->use_irq)\r
 659                 gt811_irq_enable(ts);     //KT ADD 1202\r
 660 #endif\r
 661 }\r
 662 \r
 663 /*******************************************************        \r
 664 Function:\r
 665         Response function timer\r
 666         Triggered by a timer, scheduling the work function of the touch screen operation; after re-timing\r
 667 Parameters:\r
 668         timer: the timer function is associated\r
 669 return:\r
 670         Timer mode, HRTIMER_NORESTART that do not automatically restart\r
 671 ********************************************************/\r
 672 static enum hrtimer_restart goodix_ts_timer_func(struct hrtimer *timer)\r
 673 {\r
 674         struct gt811_ts_data *ts = container_of(timer, struct gt811_ts_data, timer);\r
 675         queue_work(goodix_wq, &ts->work);\r
 676         hrtimer_start(&ts->timer, ktime_set(0, (POLL_TIME+6)*1000000), HRTIMER_MODE_REL);\r
 677         return HRTIMER_NORESTART;\r
 678 }\r
 679 \r
 680 /*******************************************************        \r
 681 Function:\r
 682         Interrupt response function\r
 683         Triggered by an interrupt, the scheduler runs the touch screen handler\r
 684 ********************************************************/\r
 685 static irqreturn_t goodix_ts_irq_handler(int irq, void *dev_id)\r
 686 {\r
 687         struct gt811_ts_data *ts = dev_id;\r
 688 \r
 689 #ifndef STOP_IRQ_TYPE\r
 690         gt811_irq_disable(ts);     //KT ADD 1202\r
 691 #endif\r
 692         //disable_irq_nosync(ts->client->irq);\r
 693         queue_work(goodix_wq, &ts->work);\r
 694         \r
 695         return IRQ_HANDLED;\r
 696 }\r
 697 \r
 698 /*******************************************************        \r
 699 Function:\r
 700         Power management gt811, gt811 allowed to sleep or to wake up\r
 701 Parameters:\r
 702         on: 0 that enable sleep, wake up 1\r
 703 return:\r
 704         Is set successfully, 0 for success\r
 705         Error code: -1 for the i2c error, -2 for the GPIO error;-EINVAL on error as a parameter\r
 706 ********************************************************/\r
 707 static int goodix_ts_power(struct gt811_ts_data * ts, int on)\r
 708 {\r
 709         int ret = -1;\r
 710 \r
 711         unsigned char i2c_control_buf[3] = {0x06,0x92,0x01};            //suspend cmd\r
 712         \r
 713 #ifdef INT_PORT \r
 714         if(ts != NULL && !ts->use_irq)\r
 715                 return -2;\r
 716 #endif          \r
 717         switch(on)\r
 718         {\r
 719                 case 0:\r
 720                         ret = i2c_write_bytes(ts->client, i2c_control_buf, 3);\r
 721             printk("ret++++++++++++++++= %d=\n",ret);\r
 722                         dev_info(&ts->client->dev, "Send suspend cmd\n");\r
 723                         if(ret < 0)                                             //failed\r
 724                                 ret = 0;\r
 725                         return ret;\r
 726                         \r
 727                 case 1:\r
 728                         printk("++++ reset_pin: %d \n",reset_pin);\r
 729                         if(reset_pin > 0 ){\r
 730                                 gpio_direction_output(reset_pin,0);\r
 731                                 msleep(1);\r
 732                                 gpio_set_value(reset_pin,0);\r
 733                                 msleep(100);\r
 734                                 gpio_set_value(reset_pin,1);\r
 735                                 msleep(100);\r
 736                        }else{\r
 737                                 msleep(1);\r
 738                                 gpio_direction_output(irq_to_gpio(ts->client->irq), 0);\r
 739                                 msleep(100);\r
 740                                 gpio_direction_output(irq_to_gpio(ts->client->irq), 1);\r
 741                                 msleep(100);\r
 742 \r
 743                                 unsigned int  gpio = irq_to_gpio(ts->client->irq);\r
 744                                 gpio_set_value(gpio, 0);\r
 745                                 gpio_direction_input(gpio);\r
 746                        }\r
 747                         ret = 0;\r
 748                         return ret;\r
 749                                 \r
 750                 default:\r
 751                         dev_info(&ts->client->dev, "%s: Cant't support this command.", s3c_ts_name);\r
 752                         return -EINVAL;\r
 753         }\r
 754 \r
 755 }\r
 756 /*******************************************************        \r
 757 Function:\r
 758         Touch-screen detection function\r
 759         Called when the registration drive (required for a corresponding client);\r
 760         For IO, interrupts and other resources to apply; equipment registration; touch screen initialization, etc.\r
 761 Parameters:\r
 762         client: the device structure to be driven\r
 763         id: device ID\r
 764 return:\r
 765         Results of the implementation code, 0 for normal execution\r
 766 ********************************************************/\r
 767 static int goodix_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)\r
 768 {\r
 769         int ret = 0;\r
 770         int val_ret = 1;\r
 771         int retry=0;\r
 772         char test_data = 1;\r
 773                 char buf[2]={0};   //w++\r
 774         unsigned char read_data[2] = {0,0 };        \r
 775         const char irq_table[2] = {IRQF_TRIGGER_FALLING,IRQF_TRIGGER_RISING};\r
 776         struct gt811_ts_data *ts;\r
 777  //   struct gt811_platform_data *811data = client->dev.platform_data;\r
 778         struct goodix_platform_data *pdata;\r
 779         dev_info(&client->dev,"Install gt811 driver.\n");\r
 780         dev_info(&client->dev,"Driver Release Date:2012-02-08\n");      \r
 781 \r
 782         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) \r
 783         {\r
 784                 dev_err(&client->dev, "Must have I2C_FUNC_I2C.\n");\r
 785                 ret = -ENODEV;\r
 786                 goto err_check_functionality_failed;\r
 787         }\r
 788 #if 0   \r
 789         ret=i2c_read_bytes(client, read_data, sizeof(read_data)/sizeof(read_data[0]));\r
 790         if(ret <= 0)  \r
 791                 {\r
 792         dev_err(&client->dev, "Must have GT811.\n");\r
 793         goto err_check_functionality_failed;    \r
 794                 }\r
 795 #endif  \r
 796         \r
 797         ts = kzalloc(sizeof(*ts), GFP_KERNEL);\r
 798         if (ts == NULL) {\r
 799                 ret = -ENOMEM;\r
 800                 goto err_alloc_data_failed;\r
 801         }\r
 802 \r
 803         i2c_connect_client = client;\r
 804         ts->client = client;\r
 805         i2c_set_clientdata(client, ts);\r
 806         pdata = client->dev.platform_data;\r
 807 #ifdef CONFIG_RK_CONFIG\r
 808         tp_hw_init();\r
 809         reset_pin = get_port_config(rst).gpio;\r
 810         client->irq = get_port_config(irq).gpio;\r
 811 #else\r
 812         if (pdata != NULL)\r
 813         {\r
 814                 reset_pin = pdata->rest_pin;\r
 815                 \r
 816                 if (pdata->init_platform_hw)\r
 817                 {\r
 818                         pdata->init_platform_hw();\r
 819                 }\r
 820 \r
 821         }\r
 822 #endif\r
 823 /*      \r
 824         gpio_free(SHUTDOWN_PORT);\r
 825         ret = gpio_request(SHUTDOWN_PORT, "RESET_INT");\r
 826         if (ret < 0)\r
 827         {\r
 828                 dev_err(&client->dev, "Failed to request RESET GPIO:%d, ERRNO:%d\n",(int)SHUTDOWN_PORT,ret);\r
 829                 goto err_gpio_request;\r
 830         }\r
 831         \r
 832         rk29_mux_api_set(GPIO0D3_PWM_1_NAME,GPIO0D_GPIO0D3);\r
 833          gpio_pull_updown(SHUTDOWN_PORT, 1);            //set GPIO pull-up\r
 834 */      \r
 835         for(retry=0;retry <= 10; retry++)\r
 836         {\r
 837         gpio_direction_output(reset_pin,0);\r
 838         msleep(1);\r
 839         //              gpio_direction_input(reset_pin);//setinput means not ack so set the reset high\r
 840         //              msleep(100);\r
 841         gpio_set_value(reset_pin,1);\r
 842         msleep(100);\r
 843         gpio_set_value(reset_pin,0);\r
 844         msleep(100);\r
 845         gpio_set_value(reset_pin,1);\r
 846         msleep(100);\r
 847         val_ret = gpio_get_value(reset_pin);\r
 848     ret = i2c_write_bytes(client, &test_data, 1);\r
 849         //ret =i2c_master_reg8_recv(client, 0x00, buf, 2, 200*1000);//i2c_write_bytes(client, &test_data, 1);   //Test I2C connection.\r
 850         if (ret == 1)\r
 851         break;\r
 852         dev_info(&client->dev, "GT811 I2C TEST FAILED!Please check the HARDWARE connect\n");\r
 853         }\r
 854 \r
 855         if(ret <= 0)\r
 856         {\r
 857                 dev_err(&client->dev, "Warnning: I2C communication might be ERROR!\n");\r
 858                 goto err_i2c_failed;\r
 859         }       \r
 860 \r
 861         INIT_WORK(&ts->work, goodix_ts_work_func);              //init work_struct\r
 862 \r
 863 /////////////////////////////// UPDATE STEP 1 START/////////////////////////////////////////////////////////////////\r
 864 #ifdef AUTO_UPDATE_GT811                //modify by andrew\r
 865         msleep(20);\r
 866   goodix_read_version(ts);\r
 867       \r
 868   ret = gt811_downloader( ts, goodix_gt811_firmware);\r
 869   if(ret < 0)\r
 870   {\r
 871           dev_err(&client->dev, "Warnning: gt811 update might be ERROR!\n");\r
 872           //goto err_input_dev_alloc_failed;\r
 873   }\r
 874 #endif\r
 875 ///////////////////////////////UPDATE STEP 1 END////////////////////////////////////////////////////////////////      \r
 876 /*\r
 877 #ifdef INT_PORT \r
 878         client->irq=TS_INT;             //If not defined in client\r
 879         if (client->irq)\r
 880         {\r
 881                 gpio_free(INT_PORT);\r
 882                 ret = gpio_request(INT_PORT, "TS_INT"); //Request IO\r
 883         if (ret < 0) \r
 884                 {\r
 885                         dev_err(&client->dev, "Failed to request GPIO:%d, ERRNO:%d\n",(int)INT_PORT,ret);\r
 886                         goto err_gpio_request_failed;\r
 887                 }\r
 888                 \r
 889                  gpio_pull_updown(INT_PORT, NULL);      //ret > 0 ?\r
 890                 \r
 891         \r
 892         #ifndef STOP_IRQ_TYPE\r
 893                 ts->irq = TS_INT;     //KT ADD 1202\r
 894                 ts->irq_is_disable = 0;           // enable irq\r
 895         #endif  \r
 896         }\r
 897 #endif  \r
 898 */\r
 899 err_gpio_request_failed:\r
 900         for(retry=0; retry<3; retry++)\r
 901         {\r
 902                 ret=goodix_init_panel(ts);\r
 903                 msleep(2);\r
 904                 if(ret != 0)    //Initiall failed\r
 905                         continue;\r
 906                 else\r
 907                         break;\r
 908         }\r
 909         if(ret != 0) \r
 910         {\r
 911                 ts->bad_data=1;\r
 912                 goto err_init_godix_ts;\r
 913         }\r
 914 \r
 915         ts->input_dev = input_allocate_device();\r
 916         if (ts->input_dev == NULL) \r
 917         {\r
 918                 ret = -ENOMEM;\r
 919                 dev_dbg(&client->dev,"goodix_ts_probe: Failed to allocate input device\n");\r
 920                 goto err_input_dev_alloc_failed;\r
 921         }\r
 922         \r
 923         //ts->input_dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) ;\r
 924         //ts->input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);\r
 925         //////ts->input_dev->absbit[0] = BIT(ABS_X) | BIT(ABS_Y) | BIT(ABS_PRESSURE);\r
 926 #ifdef HAVE_TOUCH_KEY\r
 927         for(retry = 0; retry < MAX_KEY_NUM; retry++)\r
 928         {\r
 929                 input_set_capability(ts->input_dev,EV_KEY,touch_key_array[retry]);      \r
 930         }\r
 931 #endif\r
 932 /*\r
 933         input_set_abs_params(ts->input_dev, ABS_X, 0,  ts->abs_x_max, 0, 0);\r
 934         input_set_abs_params(ts->input_dev, ABS_Y, 0, ts->abs_y_max, 0, 0);\r
 935         input_set_abs_params(ts->input_dev, ABS_PRESSURE, 0, 255, 0, 0);\r
 936 */      \r
 937 #ifdef GOODIX_MULTI_TOUCH\r
 938 \r
 939         __set_bit(INPUT_PROP_DIRECT, ts->input_dev->propbit);\r
 940         __set_bit(EV_ABS, ts->input_dev->evbit);\r
 941         \r
 942         input_mt_init_slots(ts->input_dev, ts->max_touch_num);\r
 943         input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);\r
 944 #ifdef CONFIG_RK_CONFIG\r
 945         input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X, 0, x_max, 0, 0);\r
 946         input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y, 0, y_max, 0, 0); \r
 947 #else\r
 948         input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X, 0, ts->abs_x_max, 0, 0);\r
 949         input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y, 0, ts->abs_y_max, 0, 0); \r
 950 #endif\r
 951         \r
 952         \r
 953 #endif  \r
 954 \r
 955         sprintf(ts->phys, "input/ts");\r
 956         ts->input_dev->name = s3c_ts_name;\r
 957         ts->input_dev->phys = ts->phys;\r
 958         ts->input_dev->id.bustype = BUS_I2C;\r
 959         ts->input_dev->id.vendor = 0xDEAD;\r
 960         ts->input_dev->id.product = 0xBEEF;\r
 961         ts->input_dev->id.version = 10427;      //screen firmware version\r
 962         \r
 963         ret = input_register_device(ts->input_dev);\r
 964         if (ret) {\r
 965                 dev_err(&client->dev,"Probe: Unable to register %s input device\n", ts->input_dev->name);\r
 966                 goto err_input_register_device_failed;\r
 967         }\r
 968         ts->bad_data = 0;\r
 969 \r
 970 #ifdef INT_PORT \r
 971         ret  = request_irq(gpio_to_irq(client->irq), goodix_ts_irq_handler ,irq_table[ts->int_trigger_type],\r
 972                         client->name, ts);\r
 973         if (ret != 0)\r
 974         {\r
 975                 dev_err(&client->dev,"Cannot allocate ts INT!ERRNO:%d\n", ret);\r
 976                 gpio_direction_input(client->irq);\r
 977                 gpio_free(client->irq);\r
 978                 goto err_init_godix_ts;\r
 979         }\r
 980         else \r
 981         {       \r
 982         #ifndef STOP_IRQ_TYPE\r
 983                 gt811_irq_disable(ts);     //KT ADD 1202\r
 984         //#define\r
 985         //      disable_irq(client->irq);\r
 986         #endif\r
 987                 ts->use_irq = 1;\r
 988                 dev_dbg(&client->dev,"Reques EIRQ %d succesd on GPIO:%d\n",client->irq,client->irq);\r
 989         }       \r
 990 #endif  \r
 991 \r
 992         \r
 993         if (!ts->use_irq) \r
 994         {\r
 995                 hrtimer_init(&ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);\r
 996                 ts->timer.function = goodix_ts_timer_func;\r
 997                 hrtimer_start(&ts->timer, ktime_set(1, 0), HRTIMER_MODE_REL);\r
 998         }\r
 999         \r
1000         if(ts->use_irq)\r
1001         #ifndef STOP_IRQ_TYPE\r
1002                 gt811_irq_enable(ts);     //KT ADD 1202\r
1003         //#elif\r
1004         //      enable_irq(client->irq);\r
1005         #endif\r
1006                 \r
1007         ts->power = goodix_ts_power;\r
1008 \r
1009         goodix_read_version(ts);\r
1010         \r
1011 #ifdef CONFIG_HAS_EARLYSUSPEND\r
1012         ts->early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;//EARLY_SUSPEND_LEVEL_BLANK_SCREEN +1;\r
1013         ts->early_suspend.suspend = goodix_ts_early_suspend;\r
1014         ts->early_suspend.resume = goodix_ts_late_resume;\r
1015         register_early_suspend(&ts->early_suspend);\r
1016 #endif\r
1017 \r
1018 /////////////////////////////// UPDATE STEP 2 START /////////////////////////////////////////////////////////////////\r
1019 #ifdef CONFIG_TOUCHSCREEN_GOODIX_IAP\r
1020         goodix_proc_entry = create_proc_entry("goodix-update", 0666, NULL);\r
1021         if(goodix_proc_entry == NULL)\r
1022         {\r
1023                 dev_info(&client->dev, "Couldn't create proc entry!\n");\r
1024                 ret = -ENOMEM;\r
1025                 goto err_create_proc_entry;\r
1026         }\r
1027         else\r
1028         {\r
1029                 dev_info(&client->dev, "Create proc entry success!\n");\r
1030                 goodix_proc_entry->write_proc = goodix_update_write;\r
1031                 goodix_proc_entry->read_proc = goodix_update_read;\r
1032         }\r
1033 #endif\r
1034 ///////////////////////////////UPDATE STEP 2 END /////////////////////////////////////////////////////////////////\r
1035         dev_info(&client->dev,"Start %s in %s mode,Driver Modify Date:2012-01-05\n", \r
1036                 ts->input_dev->name, ts->use_irq ? "interrupt" : "polling");\r
1037         return 0;\r
1038 \r
1039 err_init_godix_ts:\r
1040         i2c_end_cmd(ts);\r
1041         if(ts->use_irq)\r
1042         {\r
1043                 ts->use_irq = 0;\r
1044                 free_irq(gpio_to_irq(client->irq),ts);\r
1045         #ifdef INT_PORT \r
1046                 gpio_direction_input(client->irq);\r
1047                 gpio_free(client->irq);\r
1048         #endif  \r
1049         }\r
1050         else \r
1051                 hrtimer_cancel(&ts->timer);\r
1052 \r
1053 err_input_register_device_failed:\r
1054         input_free_device(ts->input_dev);\r
1055 \r
1056 err_input_dev_alloc_failed:\r
1057         i2c_set_clientdata(client, NULL);\r
1058 err_gpio_request:\r
1059         gpio_free(reset_pin);\r
1060 err_i2c_failed: \r
1061         kfree(ts);      \r
1062 err_alloc_data_failed:\r
1063 err_check_functionality_failed:\r
1064 err_create_proc_entry:\r
1065         return ret;\r
1066 }\r
1067 \r
1068 \r
1069 /*******************************************************        \r
1070 Function:\r
1071         Drive the release of resources\r
1072 Parameters:\r
1073         client: the device structure\r
1074 return:\r
1075         Results of the implementation code, 0 for normal execution\r
1076 ********************************************************/\r
1077 static int goodix_ts_remove(struct i2c_client *client)\r
1078 {\r
1079         struct gt811_ts_data *ts = i2c_get_clientdata(client);\r
1080 #ifdef CONFIG_HAS_EARLYSUSPEND\r
1081         unregister_early_suspend(&ts->early_suspend);\r
1082 #endif\r
1083 /////////////////////////////// UPDATE STEP 3 START/////////////////////////////////////////////////////////////////\r
1084 #ifdef CONFIG_TOUCHSCREEN_GOODIX_IAP\r
1085         remove_proc_entry("goodix-update", NULL);\r
1086 #endif\r
1087 /////////////////////////////////UPDATE STEP 3 END///////////////////////////////////////////////////////////////\r
1088 \r
1089         if (ts && ts->use_irq) \r
1090         {\r
1091         #ifdef INT_PORT\r
1092                 gpio_direction_input(client->irq);\r
1093                 gpio_free(client->irq);\r
1094         #endif  \r
1095                 free_irq(gpio_to_irq(client->irq), ts);\r
1096         }       \r
1097         else if(ts)\r
1098                 hrtimer_cancel(&ts->timer);\r
1099         \r
1100         dev_notice(&client->dev,"The driver is removing...\n");\r
1101         i2c_set_clientdata(client, NULL);\r
1102         input_unregister_device(ts->input_dev);\r
1103         kfree(ts);\r
1104         return 0;\r
1105 }\r
1106 \r
1107 //停用设备\r
1108 static int goodix_ts_suspend(struct i2c_client *client, pm_message_t mesg)\r
1109 {\r
1110         int ret;\r
1111         struct gt811_ts_data *ts = i2c_get_clientdata(client);\r
1112         disable_irq(gpio_to_irq(client->irq));\r
1113         if (ts->power) \r
1114         {\r
1115                ret = ts->power(ts, 0);\r
1116                printk("goodix_ts suspend >>>>>>>>>ret=%d \n",ret);\r
1117                if (ret < 0)\r
1118                        printk(KERN_ERR "goodix_ts_suspend power on failed\n");  \r
1119         }\r
1120         return 0;\r
1121 }\r
1122 static int goodix_ts_resume(struct i2c_client *client)\r
1123 {\r
1124         int ret;\r
1125         struct gt811_ts_data *ts = i2c_get_clientdata(client);\r
1126 \r
1127         if (ts->power) {\r
1128                 ret = ts->power(ts, 1);\r
1129                 printk("resume >>>>>>>>>ret=%d",ret);\r
1130                 if (ret < 0)\r
1131                 printk(KERN_ERR "goodix_ts_resume power on failed\n");\r
1132         }\r
1133         enable_irq(gpio_to_irq(client->irq));\r
1134         return 0;\r
1135 }\r
1136 \r
1137 #ifdef CONFIG_HAS_EARLYSUSPEND\r
1138 static void goodix_ts_early_suspend(struct early_suspend *h)\r
1139 {\r
1140         struct gt811_ts_data *ts;\r
1141         ts = container_of(h, struct gt811_ts_data, early_suspend);\r
1142         goodix_ts_suspend(ts->client, PMSG_SUSPEND);\r
1143 }\r
1144 \r
1145 static void goodix_ts_late_resume(struct early_suspend *h)\r
1146 {\r
1147         struct gt811_ts_data *ts;\r
1148         ts = container_of(h, struct gt811_ts_data, early_suspend);\r
1149         goodix_ts_resume(ts->client);\r
1150 }\r
1151 #endif\r
1152 /////////////////////////////// UPDATE STEP 4 START/////////////////////////////////////////////////////////////////\r
1153 //******************************Begin of firmware update surpport*******************************\r
1154 #ifdef CONFIG_TOUCHSCREEN_GOODIX_IAP\r
1155 static struct file * update_file_open(char * path, mm_segment_t * old_fs_p)\r
1156 {\r
1157         struct file * filp = NULL;\r
1158         int errno = -1;\r
1159                 \r
1160         filp = filp_open(path, O_RDONLY, 0644);\r
1161         \r
1162         if(!filp || IS_ERR(filp))\r
1163         {\r
1164                 if(!filp)\r
1165                         errno = -ENOENT;\r
1166                 else \r
1167                         errno = PTR_ERR(filp);                                  \r
1168                 printk(KERN_ERR "The update file for Guitar open error.\n");\r
1169                 return NULL;\r
1170         }\r
1171         *old_fs_p = get_fs();\r
1172         set_fs(get_ds());\r
1173 \r
1174         filp->f_op->llseek(filp,0,0);\r
1175         return filp ;\r
1176 }\r
1177 \r
1178 static void update_file_close(struct file * filp, mm_segment_t old_fs)\r
1179 {\r
1180         set_fs(old_fs);\r
1181         if(filp)\r
1182                 filp_close(filp, NULL);\r
1183 }\r
1184 static int update_get_flen(char * path)\r
1185 {\r
1186         struct file * file_ck = NULL;\r
1187         mm_segment_t old_fs;\r
1188         int length ;\r
1189         \r
1190         file_ck = update_file_open(path, &old_fs);\r
1191         if(file_ck == NULL)\r
1192                 return 0;\r
1193 \r
1194         length = file_ck->f_op->llseek(file_ck, 0, SEEK_END);\r
1195         //printk("File length: %d\n", length);\r
1196         if(length < 0)\r
1197                 length = 0;\r
1198         update_file_close(file_ck, old_fs);\r
1199         return length;  \r
1200 }\r
1201 \r
1202 static int goodix_update_write(struct file *filp, const char __user *buff, unsigned long len, void *data)\r
1203 {\r
1204         unsigned char cmd[120];\r
1205         int ret = -1;\r
1206         int retry = 0;\r
1207         static unsigned char update_path[60];\r
1208         struct gt811_ts_data *ts;\r
1209         struct file * file_data = NULL;\r
1210         mm_segment_t old_fs;\r
1211         unsigned char *file_ptr = NULL;\r
1212         unsigned int file_len;\r
1213         \r
1214         ts = i2c_get_clientdata(i2c_connect_client);\r
1215         if(ts==NULL)\r
1216         {\r
1217             printk(KERN_INFO"goodix write to kernel via proc file!@@@@@@\n");\r
1218                 return 0;\r
1219         }\r
1220         \r
1221         //printk(KERN_INFO"goodix write to kernel via proc file!@@@@@@\n");\r
1222         if(copy_from_user(&cmd, buff, len))\r
1223         {\r
1224             printk(KERN_INFO"goodix write to kernel via proc file!@@@@@@\n");\r
1225                 return -EFAULT;\r
1226         }\r
1227         //printk(KERN_INFO"Write cmd is:%d,write len is:%ld\n",cmd[0], len);\r
1228         switch(cmd[0])\r
1229         {\r
1230             case APK_UPDATE_TP:\r
1231             printk(KERN_INFO"Write cmd is:%d,cmd arg is:%s,write len is:%ld\n",cmd[0], &cmd[1], len);\r
1232             memset(update_path, 0, 60);\r
1233             strncpy(update_path, cmd+1, 60);\r
1234                         \r
1235 #ifndef STOP_IRQ_TYPE\r
1236                 gt811_irq_disable(ts);     //KT ADD 1202\r
1237 //#elif\r
1238 //              disable_irq(ts->client->irq);\r
1239 #endif\r
1240         file_data = update_file_open(update_path, &old_fs);\r
1241         if(file_data == NULL)   //file_data has been opened at the last time\r
1242         {\r
1243                 dev_info(&ts->client->dev, "cannot open update file\n");\r
1244                 return 0;\r
1245         }\r
1246 \r
1247         file_len = update_get_flen(update_path);\r
1248         dev_info(&ts->client->dev, "Update file length:%d\n", file_len);\r
1249         file_ptr = (unsigned char*)vmalloc(file_len);\r
1250         if(file_ptr==NULL)\r
1251         {\r
1252                 dev_info(&ts->client->dev, "cannot malloc memory!\n");\r
1253                 return 0;\r
1254         }       \r
1255 \r
1256         ret = file_data->f_op->read(file_data, file_ptr, file_len, &file_data->f_pos);\r
1257         if(ret <= 0)\r
1258         {\r
1259                 dev_info(&ts->client->dev, "read file data failed\n");\r
1260                 return 0;\r
1261         }\r
1262         update_file_close(file_data, old_fs);   \r
1263 \r
1264         ret = gt811_downloader(ts, file_ptr);\r
1265         vfree(file_ptr);\r
1266         if(ret < 0)\r
1267         {\r
1268                 printk(KERN_INFO"Warnning: GT811 update might be ERROR!\n");\r
1269                 return 0;\r
1270         }\r
1271              \r
1272  //       i2c_pre_cmd(ts);\r
1273         \r
1274         gpio_direction_output(reset_pin, 0);\r
1275         msleep(5);\r
1276         gpio_direction_input(reset_pin);\r
1277         msleep(20);\r
1278         for(retry=0; retry<3; retry++)\r
1279         {\r
1280                 ret=goodix_init_panel(ts);\r
1281                 msleep(2);\r
1282                 if(ret != 0)    //Initiall failed\r
1283                 {\r
1284                         dev_info(&ts->client->dev, "Init panel failed!\n");\r
1285                         continue;\r
1286                 }\r
1287                 else\r
1288                         break;\r
1289                 \r
1290         }\r
1291 \r
1292    //     s3c_gpio_cfgpin(INT_PORT, INT_CFG);     //Set IO port function \r
1293         //gpio_direction_input(INT_PORT);\r
1294 //      s3c_gpio_setpull(INT_PORT, S3C_GPIO_PULL_UP); \r
1295 //        s3c_gpio_cfgpin(INT_PORT, INT_CFG);   //Set IO port as interrupt port \r
1296         //s3c_gpio_setpull(INT_PORT, S3C_GPIO_PULL_NONE);\r
1297 //      while(1);               \r
1298 #ifndef STOP_IRQ_TYPE\r
1299         gt811_irq_enable(ts);     //KT ADD 1202\r
1300 //#elif\r
1301 //      enable_irq(ts->client->irq);\r
1302 #endif   \r
1303 //        i2c_end_cmd(ts);\r
1304         return 1;\r
1305     \r
1306     case APK_READ_FUN:                                                  //functional command\r
1307                 if(cmd[1] == CMD_READ_VER)\r
1308                 {\r
1309                         printk(KERN_INFO"Read version!\n");\r
1310                         ts->read_mode = MODE_RD_VER;\r
1311                 }\r
1312         else if(cmd[1] == CMD_READ_CFG)\r
1313                 {\r
1314                         printk(KERN_INFO"Read config info!\n");\r
1315 \r
1316                         ts->read_mode = MODE_RD_CFG;\r
1317                 }\r
1318                 else if (cmd[1] == CMD_READ_RAW)\r
1319                 {\r
1320                     printk(KERN_INFO"Read raw data!\n");\r
1321 \r
1322                         ts->read_mode = MODE_RD_RAW;\r
1323                 }\r
1324         else if (cmd[1] == CMD_READ_CHIP_TYPE)\r
1325                 {\r
1326                     printk(KERN_INFO"Read chip type!\n");\r
1327 \r
1328                         ts->read_mode = MODE_RD_CHIP_TYPE;\r
1329                 }\r
1330         return 1;\r
1331         \r
1332     case APK_WRITE_CFG:                 \r
1333                 printk(KERN_INFO"Begin write config info!Config length:%d\n",cmd[1]);\r
1334                 i2c_pre_cmd(ts);\r
1335         ret = i2c_write_bytes(ts->client, cmd+2, cmd[1]+2); \r
1336         i2c_end_cmd(ts);\r
1337         if(ret != 1)\r
1338         {\r
1339             printk("Write Config failed!return:%d\n",ret);\r
1340             return -1;\r
1341         }\r
1342         return 1;\r
1343             \r
1344     default:\r
1345             return 0;\r
1346         }\r
1347         return 0;\r
1348 }\r
1349 \r
1350 static int goodix_update_read( char *page, char **start, off_t off, int count, int *eof, void *data )\r
1351 {\r
1352         int ret = -1;\r
1353         int len = 0;\r
1354         int read_times = 0;\r
1355         struct gt811_ts_data *ts;\r
1356 \r
1357         unsigned char read_data[360] = {80, };\r
1358 \r
1359         ts = i2c_get_clientdata(i2c_connect_client);\r
1360         if(ts==NULL)\r
1361                 return 0;\r
1362     \r
1363         printk("___READ__\n");\r
1364         if(ts->read_mode == MODE_RD_VER)                //read version data\r
1365         {\r
1366                 i2c_pre_cmd(ts);\r
1367                 ret = goodix_read_version(ts);\r
1368                 i2c_end_cmd(ts);\r
1369                 if(ret < 0)\r
1370                 {\r
1371                         printk(KERN_INFO"Read version data failed!\n");\r
1372                         return 0;\r
1373                 }\r
1374         \r
1375                 read_data[1] = (char)(ts->version&0xff);\r
1376                 read_data[0] = (char)((ts->version>>8)&0xff);\r
1377 \r
1378                 memcpy(page, read_data, 2);\r
1379                 //*eof = 1;\r
1380                 return 2;\r
1381         }\r
1382     else if (ts->read_mode == MODE_RD_CHIP_TYPE)\r
1383     {\r
1384         page[0] = GT811;\r
1385         return 1;\r
1386     }\r
1387     else if(ts->read_mode == MODE_RD_CFG)\r
1388         {\r
1389 \r
1390             read_data[0] = 0x06;\r
1391             read_data[1] = 0xa2;       // cfg start address\r
1392             printk("read config addr is:%x,%x\n", read_data[0],read_data[1]);\r
1393 \r
1394              len = 106;\r
1395            i2c_pre_cmd(ts);\r
1396              ret = i2c_read_bytes(ts->client, read_data, len+2);\r
1397             i2c_end_cmd(ts);\r
1398             if(ret <= 0)\r
1399                 {\r
1400                         printk(KERN_INFO"Read config info failed!\n");\r
1401                         return 0;\r
1402                 }\r
1403               \r
1404                 memcpy(page, read_data+2, len);\r
1405                 return len;\r
1406         }\r
1407         else if (ts->read_mode == MODE_RD_RAW)\r
1408         {\r
1409 #define TIMEOUT (-100)\r
1410             int retry = 0;\r
1411         if (raw_data_ready != RAW_DATA_READY)\r
1412         {\r
1413             raw_data_ready = RAW_DATA_ACTIVE;\r
1414         }\r
1415 \r
1416 RETRY:\r
1417         read_data[0] = 0x07;\r
1418         read_data[1] = 0x11;\r
1419         read_data[2] = 0x01;\r
1420         \r
1421         ret = i2c_write_bytes(ts->client, read_data, 3);\r
1422         \r
1423 #ifdef DEBUG\r
1424         sum += read_times;\r
1425         printk("count :%d\n", ++access_count);\r
1426         printk("A total of try times:%d\n", sum);\r
1427 #endif\r
1428                \r
1429         read_times = 0;\r
1430             while (RAW_DATA_READY != raw_data_ready)\r
1431             {\r
1432                 msleep(4);\r
1433 \r
1434                 if (read_times++ > 10)\r
1435                 {\r
1436                 if (retry++ > 5)\r
1437                 {\r
1438                     return TIMEOUT;\r
1439                 }\r
1440                 goto RETRY;\r
1441                 }\r
1442             }\r
1443 #ifdef DEBUG        \r
1444         printk("read times:%d\n", read_times);\r
1445 #endif      \r
1446         read_data[0] = 0x08;\r
1447         read_data[1] = 0x80;       // raw data address\r
1448         \r
1449             len = 160;\r
1450 \r
1451            // msleep(4);\r
1452 \r
1453         i2c_pre_cmd(ts);\r
1454             ret = i2c_read_bytes(ts->client, read_data, len+2);             \r
1455   //      i2c_end_cmd(ts);\r
1456         \r
1457         if(ret <= 0)\r
1458                 {\r
1459                         printk(KERN_INFO"Read raw data failed!\n");\r
1460                         return 0;\r
1461                 }\r
1462                 memcpy(page, read_data+2, len);\r
1463 \r
1464                 read_data[0] = 0x09;\r
1465         read_data[1] = 0xC0;\r
1466         //      i2c_pre_cmd(ts);\r
1467             ret = i2c_read_bytes(ts->client, read_data, len+2);             \r
1468         i2c_end_cmd(ts);\r
1469         \r
1470         if(ret <= 0)\r
1471                 {\r
1472                         printk(KERN_INFO"Read raw data failed!\n");\r
1473                         return 0;\r
1474                 }\r
1475                 memcpy(&page[160], read_data+2, len);\r
1476 \r
1477 #ifdef DEBUG\r
1478 //**************\r
1479         for (i = 0; i < 300; i++)\r
1480         {\r
1481             printk("%6x", page[i]);\r
1482 \r
1483             if ((i+1) % 10 == 0)\r
1484             {\r
1485                 printk("\n");\r
1486             }\r
1487         }\r
1488 //********************/  \r
1489 #endif\r
1490         raw_data_ready = RAW_DATA_NON_ACTIVE;\r
1491     \r
1492                 return (2*len);   \r
1493                 \r
1494     }\r
1495         return 0;\r
1496 #endif\r
1497 }             \r
1498 //********************************************************************************************\r
1499 static u8  is_equal( u8 *src , u8 *dst , int len )\r
1500 {\r
1501     int i;\r
1502 \r
1503 #if 0    \r
1504     for( i = 0 ; i < len ; i++ )\r
1505     {\r
1506         printk(KERN_INFO"[%02X:%02X]", src[i], dst[i]);\r
1507        if((i+1)%10==0)printk("\n");\r
1508     }\r
1509 #endif\r
1510 \r
1511     for( i = 0 ; i < len ; i++ )\r
1512     {\r
1513         if ( src[i] != dst[i] )\r
1514         {\r
1515             return 0;\r
1516         }\r
1517     }\r
1518     \r
1519     return 1;\r
1520 }\r
1521 \r
1522 static  u8 gt811_nvram_store( struct gt811_ts_data *ts )\r
1523 {\r
1524     int ret;\r
1525     int i;\r
1526     u8 inbuf[3] = {REG_NVRCS_H,REG_NVRCS_L,0};\r
1527     //u8 outbuf[3] = {};\r
1528     ret = i2c_read_bytes( ts->client, inbuf, 3 );\r
1529     \r
1530     if ( ret < 0 )\r
1531     {\r
1532         return 0;\r
1533     }\r
1534     \r
1535     if ( ( inbuf[2] & BIT_NVRAM_LOCK ) == BIT_NVRAM_LOCK )\r
1536     {\r
1537         return 0;\r
1538     }\r
1539     \r
1540     inbuf[2] = (1<<BIT_NVRAM_STROE);            //store command\r
1541             \r
1542     for ( i = 0 ; i < 300 ; i++ )\r
1543     {\r
1544         ret = i2c_write_bytes( ts->client, inbuf, 3 );\r
1545         \r
1546         if ( ret < 0 )\r
1547             break;\r
1548     }\r
1549     \r
1550     return ret;\r
1551 }\r
1552 \r
1553 static u8  gt811_nvram_recall( struct gt811_ts_data *ts )\r
1554 {\r
1555     int ret;\r
1556     u8 inbuf[3] = {REG_NVRCS_H,REG_NVRCS_L,0};\r
1557     \r
1558     ret = i2c_read_bytes( ts->client, inbuf, 3 );\r
1559     \r
1560     if ( ret < 0 )\r
1561     {\r
1562         return 0;\r
1563     }\r
1564     \r
1565     if ( ( inbuf[2]&BIT_NVRAM_LOCK) == BIT_NVRAM_LOCK )\r
1566     {\r
1567         return 0;\r
1568     }\r
1569     \r
1570     inbuf[2] = ( 1 << BIT_NVRAM_RECALL );               //recall command\r
1571     ret = i2c_write_bytes( ts->client , inbuf, 3);\r
1572     return ret;\r
1573 }\r
1574 \r
1575 static  int gt811_reset( struct gt811_ts_data *ts )\r
1576 {\r
1577     int ret = 1;\r
1578     u8 retry;\r
1579     \r
1580     unsigned char outbuf[3] = {0,0xff,0};\r
1581     unsigned char inbuf[3] = {0,0xff,0};\r
1582     //outbuf[1] = 1;\r
1583 \r
1584     gpio_direction_output(reset_pin,0);\r
1585     msleep(20);\r
1586     gpio_direction_input(reset_pin);\r
1587     msleep(100);\r
1588     for(retry=0;retry < 80; retry++)\r
1589     {\r
1590         ret =i2c_write_bytes(ts->client, inbuf, 0);     //Test I2C connection.\r
1591         if (ret > 0)\r
1592         {\r
1593             msleep(10);\r
1594             ret =i2c_read_bytes(ts->client, inbuf, 3);  //Test I2C connection.\r
1595             if (ret > 0)\r
1596             {\r
1597                 if(inbuf[2] == 0x55)\r
1598                 {\r
1599                         ret =i2c_write_bytes(ts->client, outbuf, 3);\r
1600                         msleep(10);\r
1601                         break;                                          \r
1602                 }\r
1603             }                   \r
1604         }\r
1605         else\r
1606         {\r
1607                 gpio_direction_output(reset_pin,0);\r
1608                 msleep(20);\r
1609                 gpio_direction_input(reset_pin);\r
1610                 msleep(20);\r
1611                 dev_info(&ts->client->dev, "i2c address failed\n");\r
1612         }       \r
1613                 \r
1614     }\r
1615     dev_info(&ts->client->dev, "Detect address %0X\n", ts->client->addr);\r
1616     //msleep(500);\r
1617     return ret; \r
1618 }\r
1619 \r
1620 static  int gt811_reset2( struct gt811_ts_data *ts )\r
1621 {\r
1622     int ret = 1;\r
1623     u8 retry;\r
1624     \r
1625     //unsigned char outbuf[3] = {0,0xff,0};\r
1626     unsigned char inbuf[3] = {0,0xff,0};\r
1627     //outbuf[1] = 1;\r
1628 \r
1629     gpio_direction_output(reset_pin,0);\r
1630     msleep(20);\r
1631     gpio_direction_input(reset_pin);\r
1632     msleep(100);\r
1633     for(retry=0;retry < 80; retry++)\r
1634     {\r
1635         ret =i2c_write_bytes(ts->client, inbuf, 0);     //Test I2C connection.\r
1636         if (ret > 0)\r
1637         {\r
1638             msleep(10);\r
1639             ret =i2c_read_bytes(ts->client, inbuf, 3);  //Test I2C connection.\r
1640             if (ret > 0)\r
1641             {\r
1642              //   if(inbuf[2] == 0x55)\r
1643              //       {\r
1644                 //          ret =i2c_write_bytes(ts->client, outbuf, 3);\r
1645                 //          msleep(10);\r
1646                             break;                                              \r
1647         //              }\r
1648                                 }                       \r
1649                         }       \r
1650                 \r
1651                 }\r
1652     dev_info(&ts->client->dev, "Detect address %0X\n", ts->client->addr);\r
1653     //msleep(500);\r
1654     return ret; \r
1655 }\r
1656 static  int gt811_set_address_2( struct gt811_ts_data *ts )\r
1657 {\r
1658     unsigned char inbuf[3] = {0,0,0};\r
1659     int i;\r
1660 \r
1661     for ( i = 0 ; i < 12 ; i++ )\r
1662     {\r
1663         if ( i2c_read_bytes( ts->client, inbuf, 3) )\r
1664         {\r
1665             dev_info(&ts->client->dev, "Got response\n");\r
1666             return 1;\r
1667         }\r
1668         dev_info(&ts->client->dev, "wait for retry\n");\r
1669         msleep(50);\r
1670     } \r
1671     return 0;\r
1672 }\r
1673 static u8  gt811_update_firmware( u8 *nvram, u16 start_addr, u16 length, struct gt811_ts_data *ts)\r
1674 {\r
1675     u8 ret,err,retry_time,i;\r
1676     u16 cur_code_addr;\r
1677     u16 cur_frame_num, total_frame_num, cur_frame_len;\r
1678     u32 gt80x_update_rate;\r
1679 \r
1680     unsigned char i2c_data_buf[PACK_SIZE+2] = {0,};\r
1681     unsigned char i2c_chk_data_buf[PACK_SIZE+2] = {0,};\r
1682     \r
1683     if( length > NVRAM_LEN - NVRAM_BOOT_SECTOR_LEN )\r
1684     {\r
1685         dev_info(&ts->client->dev, "Fw length %d is bigger than limited length %d\n", length, NVRAM_LEN - NVRAM_BOOT_SECTOR_LEN );\r
1686         return 0;\r
1687     }\r
1688         \r
1689     total_frame_num = ( length + PACK_SIZE - 1) / PACK_SIZE;  \r
1690 \r
1691     //gt80x_update_sta = _UPDATING;\r
1692     gt80x_update_rate = 0;\r
1693 \r
1694     for( cur_frame_num = 0 ; cur_frame_num < total_frame_num ; cur_frame_num++ )          \r
1695     {\r
1696         retry_time = 5;\r
1697        \r
1698         dev_info(&ts->client->dev, "PACK[%d]\n",cur_frame_num); \r
1699         cur_code_addr = /*NVRAM_UPDATE_START_ADDR*/start_addr + cur_frame_num * PACK_SIZE;      \r
1700         i2c_data_buf[0] = (cur_code_addr>>8)&0xff;\r
1701         i2c_data_buf[1] = cur_code_addr&0xff;\r
1702         \r
1703         i2c_chk_data_buf[0] = i2c_data_buf[0];\r
1704         i2c_chk_data_buf[1] = i2c_data_buf[1];\r
1705         \r
1706         if( cur_frame_num == total_frame_num - 1 )\r
1707         {\r
1708             cur_frame_len = length - cur_frame_num * PACK_SIZE;\r
1709         }\r
1710         else\r
1711         {\r
1712             cur_frame_len = PACK_SIZE;\r
1713         }\r
1714         \r
1715         //strncpy(&i2c_data_buf[2], &nvram[cur_frame_num*PACK_SIZE], cur_frame_len);\r
1716         for(i=0;i<cur_frame_len;i++)\r
1717         {\r
1718             i2c_data_buf[2+i] = nvram[cur_frame_num*PACK_SIZE+i];\r
1719         }\r
1720         do\r
1721         {\r
1722             err = 0;\r
1723 \r
1724             //ret = gt811_i2c_write( guitar_i2c_address, cur_code_addr, &nvram[cur_frame_num*I2C_FRAME_MAX_LENGTH], cur_frame_len );            \r
1725             ret = i2c_write_bytes(ts->client, i2c_data_buf, (cur_frame_len+2));\r
1726             if ( ret <= 0 )\r
1727             {\r
1728                 dev_info(&ts->client->dev, "write fail\n");\r
1729                 err = 1;\r
1730             }\r
1731             \r
1732             ret = i2c_read_bytes(ts->client, i2c_chk_data_buf, (cur_frame_len+2));\r
1733             // ret = gt811_i2c_read( guitar_i2c_address, cur_code_addr, inbuf, cur_frame_len);\r
1734             if ( ret <= 0 )\r
1735             {\r
1736                 dev_info(&ts->client->dev, "read fail\n");\r
1737                 err = 1;\r
1738             }\r
1739             \r
1740             if( is_equal( &i2c_data_buf[2], &i2c_chk_data_buf[2], cur_frame_len ) == 0 )\r
1741             {\r
1742                 dev_info(&ts->client->dev, "not equal\n");\r
1743                 err = 1;\r
1744             }\r
1745                         \r
1746         } while ( err == 1 && (--retry_time) > 0 );\r
1747         \r
1748         if( err == 1 )\r
1749         {\r
1750             break;\r
1751         }\r
1752                 \r
1753         gt80x_update_rate = ( cur_frame_num + 1 )*128/total_frame_num;\r
1754     \r
1755     }\r
1756 \r
1757     if( err == 1 )\r
1758     {\r
1759         dev_info(&ts->client->dev, "write nvram fail\n");\r
1760         return 0;\r
1761     }\r
1762     \r
1763     ret = gt811_nvram_store(ts);\r
1764     \r
1765     msleep( 20 );\r
1766 \r
1767     if( ret == 0 )\r
1768     {\r
1769         dev_info(&ts->client->dev, "nvram store fail\n");\r
1770         return 0;\r
1771     }\r
1772     \r
1773     ret = gt811_nvram_recall(ts);\r
1774 \r
1775     msleep( 20 );\r
1776     \r
1777     if( ret == 0 )\r
1778     {\r
1779         dev_info(&ts->client->dev, "nvram recall fail\n");\r
1780         return 0;\r
1781     }\r
1782 \r
1783     for ( cur_frame_num = 0 ; cur_frame_num < total_frame_num ; cur_frame_num++ )                //     read out all the code\r
1784     {\r
1785 \r
1786         cur_code_addr = NVRAM_UPDATE_START_ADDR + cur_frame_num*PACK_SIZE;\r
1787         retry_time=5;\r
1788         i2c_chk_data_buf[0] = (cur_code_addr>>8)&0xff;\r
1789         i2c_chk_data_buf[1] = cur_code_addr&0xff;\r
1790         \r
1791         \r
1792         if ( cur_frame_num == total_frame_num-1 )\r
1793         {\r
1794             cur_frame_len = length - cur_frame_num*PACK_SIZE;\r
1795         }\r
1796         else\r
1797         {\r
1798             cur_frame_len = PACK_SIZE;\r
1799         }\r
1800         \r
1801         do\r
1802         {\r
1803             err = 0;\r
1804             //ret = gt811_i2c_read( guitar_i2c_address, cur_code_addr, inbuf, cur_frame_len);\r
1805             ret = i2c_read_bytes(ts->client, i2c_chk_data_buf, (cur_frame_len+2));\r
1806 \r
1807             if ( ret == 0 )\r
1808             {\r
1809                 err = 1;\r
1810             }\r
1811             \r
1812             if( is_equal( &nvram[cur_frame_num*PACK_SIZE], &i2c_chk_data_buf[2], cur_frame_len ) == 0 )\r
1813             {\r
1814                 err = 1;\r
1815             }\r
1816         } while ( err == 1 && (--retry_time) > 0 );\r
1817         \r
1818         if( err == 1 )\r
1819         {\r
1820             break;\r
1821         }\r
1822         \r
1823         gt80x_update_rate = 127 + ( cur_frame_num + 1 )*128/total_frame_num;\r
1824     }\r
1825     \r
1826     gt80x_update_rate = 255;\r
1827     //gt80x_update_sta = _UPDATECHKCODE;\r
1828 \r
1829     if( err == 1 )\r
1830     {\r
1831         dev_info(&ts->client->dev, "nvram validate fail\n");\r
1832         return 0;\r
1833     }\r
1834     \r
1835     return 1;\r
1836 }\r
1837 \r
1838 static u8  gt811_update_proc( u8 *nvram, u16 start_addr , u16 length, struct gt811_ts_data *ts )\r
1839 {\r
1840     u8 ret;\r
1841     u8 error = 0;\r
1842     //struct tpd_info_t tpd_info;\r
1843     GT811_SET_INT_PIN( ts->client->irq, 0 );\r
1844     msleep( 20 );\r
1845     ret = gt811_reset(ts);\r
1846     if ( ret < 0 )\r
1847     {\r
1848         error = 1;\r
1849         dev_info(&ts->client->dev, "reset fail\n");\r
1850         goto end;\r
1851     }\r
1852 \r
1853     ret = gt811_set_address_2( ts );\r
1854     if ( ret == 0 )\r
1855     {\r
1856         error = 1;\r
1857         dev_info(&ts->client->dev, "set address fail\n");\r
1858         goto end;\r
1859     }\r
1860 \r
1861     ret = gt811_update_firmware( nvram, start_addr, length, ts);\r
1862     if ( ret == 0 )\r
1863     {\r
1864         error=1;\r
1865         dev_info(&ts->client->dev, "firmware update fail\n");\r
1866         goto end;\r
1867     }\r
1868 \r
1869 end:\r
1870     GT811_SET_INT_PIN( ts->client->irq, 1 );\r
1871 //    gpio_free(INT_PORT);\r
1872     gpio_pull_updown(ts->client->irq, 0);\r
1873     \r
1874     msleep( 500 );\r
1875     ret = gt811_reset2(ts);\r
1876     if ( ret < 0 )\r
1877     {\r
1878         error=1;\r
1879         dev_info(&ts->client->dev, "final reset fail\n");\r
1880         goto end;\r
1881     }\r
1882     if ( error == 1 )\r
1883     {\r
1884         return 0; \r
1885     }\r
1886         \r
1887 //    i2c_pre_cmd(ts);\r
1888     while(goodix_read_version(ts)<0);\r
1889     \r
1890 //    i2c_end_cmd(ts);\r
1891     return 1;\r
1892 }\r
1893 \r
1894 u16 Little2BigEndian(u16 little_endian)\r
1895 {\r
1896         u16 temp = 0;\r
1897         temp = little_endian&0xff;\r
1898         return (temp<<8)+((little_endian>>8)&0xff);\r
1899 }\r
1900 \r
1901 int  gt811_downloader( struct gt811_ts_data *ts,  unsigned char * data)\r
1902 {\r
1903     struct tpd_firmware_info_t *fw_info = (struct tpd_firmware_info_t *)data;\r
1904     //int i;\r
1905     //unsigned short checksum = 0;\r
1906     //unsigned int  checksum = 0;\r
1907     unsigned int  fw_checksum = 0;\r
1908     //unsigned char fw_chip_type;\r
1909     unsigned short fw_version;\r
1910     unsigned short fw_start_addr;\r
1911     unsigned short fw_length;\r
1912     unsigned char *data_ptr;\r
1913     //unsigned char *file_ptr = &(fw_info->chip_type);\r
1914     int retry = 0,ret;\r
1915     int err = 0;\r
1916     unsigned char rd_buf[4] = {0};\r
1917     unsigned char *mandatory_base = "GOODIX";\r
1918     unsigned char rd_rom_version;\r
1919     unsigned char rd_chip_type;\r
1920     unsigned char rd_nvram_flag;\r
1921 \r
1922     //struct file * file_data = NULL;\r
1923     //mm_segment_t old_fs;\r
1924     //unsigned int rd_len;\r
1925     //unsigned int file_len = 0;\r
1926     //unsigned char i2c_data_buf[PACK_SIZE] = {0,};\r
1927     \r
1928     rd_buf[0]=0x14;\r
1929     rd_buf[1]=0x00;\r
1930     rd_buf[2]=0x80;\r
1931     ret = i2c_write_bytes(ts->client, rd_buf, 3);\r
1932     if(ret<0)\r
1933     {\r
1934             dev_info(&ts->client->dev, "i2c write failed\n");\r
1935             goto exit_downloader;\r
1936     }\r
1937     rd_buf[0]=0x40;\r
1938     rd_buf[1]=0x11;\r
1939     ret = i2c_read_bytes(ts->client, rd_buf, 3);\r
1940     if(ret<=0)\r
1941     {\r
1942             dev_info(&ts->client->dev, "i2c request failed!\n");\r
1943             goto exit_downloader;\r
1944     }\r
1945     rd_chip_type = rd_buf[2];\r
1946     rd_buf[0]=0xFB;\r
1947     rd_buf[1]=0xED;\r
1948     ret = i2c_read_bytes(ts->client, rd_buf, 3);\r
1949     if(ret<=0)\r
1950     {\r
1951             dev_info(&ts->client->dev, "i2c read failed!\n");\r
1952             goto exit_downloader;\r
1953     }\r
1954     rd_rom_version = rd_buf[2];\r
1955     rd_buf[0]=0x06;\r
1956     rd_buf[1]=0x94;\r
1957     ret = i2c_read_bytes(ts->client, rd_buf, 3);\r
1958     if(ret<=0)\r
1959     {\r
1960             dev_info(&ts->client->dev, "i2c read failed!\n");\r
1961             goto exit_downloader;\r
1962     }\r
1963     rd_nvram_flag = rd_buf[2];\r
1964 \r
1965     fw_version = Little2BigEndian(fw_info->version);\r
1966     fw_start_addr = Little2BigEndian(fw_info->start_addr);\r
1967     fw_length = Little2BigEndian(fw_info->length);      \r
1968     data_ptr = &(fw_info->data);        \r
1969 \r
1970     dev_info(&ts->client->dev,"chip_type=0x%02x\n", fw_info->chip_type);\r
1971     dev_info(&ts->client->dev,"version=0x%04x\n", fw_version);\r
1972     dev_info(&ts->client->dev,"rom_version=0x%02x\n",fw_info->rom_version);\r
1973     dev_info(&ts->client->dev,"start_addr=0x%04x\n",fw_start_addr);\r
1974     dev_info(&ts->client->dev,"file_size=0x%04x\n",fw_length);\r
1975     fw_checksum = ((u32)fw_info->checksum[0]<<16) + ((u32)fw_info->checksum[1]<<8) + ((u32)fw_info->checksum[2]);\r
1976     dev_info(&ts->client->dev,"fw_checksum=0x%06x\n",fw_checksum);\r
1977     dev_info(&ts->client->dev,"%s\n", __func__ );\r
1978     dev_info(&ts->client->dev,"current version 0x%04X, target verion 0x%04X\n", ts->version, fw_version );\r
1979 \r
1980 //chk_chip_type:\r
1981     if(rd_chip_type!=fw_info->chip_type)\r
1982     {\r
1983         dev_info(&ts->client->dev, "Chip type not match,exit downloader\n");\r
1984         goto exit_downloader;\r
1985     }\r
1986         \r
1987 //chk_mask_version:     \r
1988     if(!rd_rom_version)\r
1989     {\r
1990         if(fw_info->rom_version!=0x45)\r
1991         {\r
1992                 dev_info(&ts->client->dev, "Rom version not match,exit downloader\n");\r
1993                 goto exit_downloader;\r
1994         }\r
1995         dev_info(&ts->client->dev, "Rom version E.\n");\r
1996         goto chk_fw_version;\r
1997     }\r
1998     else if(rd_rom_version!=fw_info->rom_version);\r
1999     {\r
2000         dev_info(&ts->client->dev, "Rom version not match,exidownloader\n");\r
2001         goto exit_downloader;\r
2002     }\r
2003     dev_info(&ts->client->dev, "Rom version %c\n",rd_rom_version);\r
2004 \r
2005 //chk_nvram:    \r
2006     if(rd_nvram_flag==0x55)\r
2007     {\r
2008         dev_info(&ts->client->dev, "NVRAM correct!\n");\r
2009         goto chk_fw_version;\r
2010     }\r
2011     else if(rd_nvram_flag==0xAA)\r
2012     {\r
2013         dev_info(&ts->client->dev, "NVRAM incorrect!Need update.\n");\r
2014         goto begin_upgrade;\r
2015     }\r
2016     else\r
2017     {\r
2018         dev_info(&ts->client->dev, "NVRAM other error![0x694]=0x%02x\n", rd_nvram_flag);\r
2019         goto begin_upgrade;\r
2020     }\r
2021 chk_fw_version:\r
2022 //      ts->version -= 1;               //test by andrew        \r
2023     if( ts->version >= fw_version )   // current low byte higher than back-up low byte\r
2024     {\r
2025             dev_info(&ts->client->dev, "Fw verison not match.\n");\r
2026             goto chk_mandatory_upgrade;\r
2027     }\r
2028     dev_info(&ts->client->dev,"Need to upgrade\n");\r
2029     goto begin_upgrade;\r
2030 chk_mandatory_upgrade:\r
2031 //      dev_info(&ts->client->dev, "%s\n", mandatory_base);\r
2032 //      dev_info(&ts->client->dev, "%s\n", fw_info->mandatory_flag);\r
2033     ret = memcmp(mandatory_base, fw_info->mandatory_flag, 6);\r
2034     if(ret)\r
2035     {\r
2036         dev_info(&ts->client->dev,"Not meet mandatory upgrade,exit downloader!ret:%d\n", ret);\r
2037         goto exit_downloader;\r
2038     }\r
2039     dev_info(&ts->client->dev, "Mandatory upgrade!\n");\r
2040 begin_upgrade:\r
2041     dev_info(&ts->client->dev, "Begin upgrade!\n");\r
2042  //   goto exit_downloader;\r
2043     dev_info(&ts->client->dev,"STEP_0:\n");\r
2044 \r
2045    \r
2046     dev_info(&ts->client->dev, "STEP_1:\n");\r
2047     err = -1;\r
2048     while( retry < 3 ) \r
2049     {\r
2050 //        ret = gt811_update_proc( data_ptr,fw_start_addr, fw_length, ts);\r
2051         if(ret == 1)\r
2052         {\r
2053             err = 1;\r
2054             break;\r
2055         }\r
2056         retry++;\r
2057     }\r
2058     \r
2059 exit_downloader:\r
2060     //mt_set_gpio_mode(GPIO_CTP_EINT_PIN, GPIO_CTP_EINT_PIN_M_EINT);\r
2061    // mt_set_gpio_out(GPIO_CTP_EN_PIN, GPIO_OUT_ONE);\r
2062        // gpio_direction_output(INT_PORT,1);\r
2063        // msleep(1);\r
2064     gpio_free(ts->client->irq);\r
2065     gpio_pull_updown(ts->client->irq, 0);\r
2066     return err;\r
2067 \r
2068 }\r
2069 //******************************End of firmware update surpport*******************************\r
2070 /////////////////////////////// UPDATE STEP 4 END /////////////////////////////////////////////////////////////////\r
2071 \r
2072 //å\8f¯ç\94¨äº\8eè¯¥é©±å\8a¨ç\9a?è®¾å¤\87å\90\8dâ\80\94è®¾å¤\87ID å\88\97è¡¨\r
2073 //only one client\r
2074 static const struct i2c_device_id goodix_ts_id[] = {\r
2075         { GOODIX_I2C_NAME, 0 },\r
2076         { }\r
2077 };\r
2078 \r
2079 //è®¾å¤\87é©±å\8a¨ç»\93æ\9e\84ä½?\r
2080 static struct i2c_driver goodix_ts_driver = {\r
2081         .probe          = goodix_ts_probe,\r
2082         .remove         = goodix_ts_remove,\r
2083 #ifndef CONFIG_HAS_EARLYSUSPEND\r
2084         .suspend        = goodix_ts_suspend,\r
2085         .resume         = goodix_ts_resume,\r
2086 #endif\r
2087         .id_table       = goodix_ts_id,\r
2088         .driver = {\r
2089                 .name   = GOODIX_I2C_NAME,\r
2090                 .owner = THIS_MODULE,\r
2091         },\r
2092 };\r
2093 \r
2094 /*******************************************************        \r
2095 å\8a\9fè\83½ï¼?       é©±å\8a¨å\8a è½½å\87½æ\95°\r
2096 returnï¼?       æ\89§è¡\8cç»\93æ\9e\9cç \81ï¼\8c0è¡¨ç¤ºæ£å¸¸æ\89§è¡\8c\r
2097 ********************************************************/\r
2098 static int __init goodix_ts_init(void)\r
2099 {\r
2100         int ret;\r
2101         \r
2102 #ifdef CONFIG_RK_CONFIG\r
2103         ret = tp_board_init();\r
2104 \r
2105         if(ret < 0)\r
2106                 return ret;\r
2107 #endif\r
2108         goodix_wq = create_workqueue("goodix_wq");              //create a work queue and worker thread\r
2109         if (!goodix_wq) {\r
2110                 printk(KERN_ALERT "creat workqueue faiked\n");\r
2111                 return -ENOMEM;\r
2112                 \r
2113         }\r
2114         ret=i2c_add_driver(&goodix_ts_driver);\r
2115         return ret; \r
2116 }\r
2117 \r
2118 /*******************************************************        \r
2119 å\8a\9fè\83½ï¼?       é©±å\8a¨å\8d¸è½½å\87½æ\95°\r
2120 å\8f\82æ\95°ï¼?       clientï¼\9aè®¾å¤\87ç»\93æ\9e\84ä½\93\r
2121 ********************************************************/\r
2122 static void __exit goodix_ts_exit(void)\r
2123 {\r
2124         printk(KERN_ALERT "Touchscreen driver of guitar exited.\n");\r
2125         i2c_del_driver(&goodix_ts_driver);\r
2126         if (goodix_wq)\r
2127                 destroy_workqueue(goodix_wq);           //release our work queue\r
2128 }\r
2129 \r
2130 late_initcall_sync(goodix_ts_init);                             //最后初始化驱动felix\r
2131 module_exit(goodix_ts_exit);\r
2132 \r
2133 MODULE_DESCRIPTION("Goodix Touchscreen Driver");\r
2134 MODULE_LICENSE("GPL");\r
2135                \r