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