drivers/input/touchscreen/rk29_i2c_goodix.c

   1 /* drivers/input/touchscreen/goodix_touch.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  */\r
  16 #include <linux/kernel.h>\r
  17 #include <linux/module.h>\r
  18 #include <linux/time.h>\r
  19 #include <linux/delay.h>\r
  20 #include <linux/device.h>\r
  21 #include <linux/hrtimer.h>\r
  22 #include <linux/i2c.h>\r
  23 #include <linux/input.h>\r
  24 #include <linux/input/mt.h>\r
  25 \r
  26 #include <linux/interrupt.h>\r
  27 #include <linux/io.h>\r
  28 #include <linux/platform_device.h>\r
  29 #include <linux/gpio.h>\r
  30 #include <linux/version.h>\r
  31 #include <linux/slab.h>\r
  32 #include <linux/of_gpio.h>\r
  33 \r
  34 #include <linux/irq.h>\r
  35 #include <linux/syscalls.h>\r
  36 #include <linux/reboot.h>\r
  37 #include <linux/proc_fs.h>\r
  38 #include <linux/async.h>\r
  39 #include <linux/vmalloc.h>\r
  40 #include <linux/fs.h>\r
  41 #include <linux/string.h>\r
  42 #include <linux/completion.h>\r
  43 #include <asm/uaccess.h>\r
  44 \r
  45 #include "rk29_i2c_goodix.h"\r
  46 \r
  47 #define PEN_DOWN 1\r
  48 #define PEN_RELEASE 0\r
  49 #define PEN_DOWN_UP 2 //fjp\r
  50 \r
  51 static int dbg_thresd = 0;\r
  52 #define DBG(x...) do { if(unlikely(dbg_thresd)) printk(KERN_INFO x); } while (0)\r
  53 \r
  54 \r
  55 /*******************************************************        \r
  56 Description:\r
  57         Read data from the i2c slave device;\r
  58         This operation consisted of 2 i2c_msgs,the first msg used\r
  59         to write the operate address,the second msg used to read data.\r
  60 \r
  61 Parameter:\r
  62         client: i2c device.\r
  63         buf[0]:operate address.\r
  64         buf[1]~buf[len]:read data buffer.\r
  65         len:operate length.\r
  66         \r
  67 return:\r
  68         numbers of i2c_msgs to transfer\r
  69 *********************************************************/\r
  70 static int goodix_i2c_read_bytes(struct i2c_client *client, uint8_t *buf, int len)\r
  71 {\r
  72         struct i2c_msg msgs[2];\r
  73         int ret=-1;\r
  74         int retries = 0;\r
  75 \r
  76         msgs[0].flags = client->flags;\r
  77         msgs[0].addr=client->addr;\r
  78         msgs[0].len=1;\r
  79         msgs[0].buf=&buf[0];\r
  80         msgs[0].scl_rate=200 * 1000;\r
  81 \r
  82         msgs[1].flags = client->flags | I2C_M_RD;\r
  83         msgs[1].addr=client->addr;\r
  84         msgs[1].len=len-1;\r
  85         msgs[1].buf=&buf[1];\r
  86         msgs[1].scl_rate=200 * 1000;\r
  87 \r
  88         //disable_irq(client->irq);\r
  89         while(retries<5)\r
  90         {\r
  91                 ret=i2c_transfer(client->adapter,msgs, 2);\r
  92                 if(ret == 2)break;\r
  93                 retries++;\r
  94         }\r
  95         //enable_irq(client->irq);\r
  96         return ret;\r
  97 }\r
  98 \r
  99 /*******************************************************        \r
 100 Description:\r
 101         write data to the i2c slave device.\r
 102 \r
 103 Parameter:\r
 104         client: i2c device.\r
 105         buf[0]:operate address.\r
 106         buf[1]~buf[len]:write data buffer.\r
 107         len:operate length.\r
 108         \r
 109 return:\r
 110         numbers of i2c_msgs to transfer.\r
 111 *********************************************************/\r
 112 static int goodix_i2c_write_bytes(struct i2c_client *client,uint8_t *data,int len)\r
 113 {\r
 114         struct i2c_msg msg;\r
 115         int ret=-1;\r
 116         int retries = 0;\r
 117 \r
 118         msg.flags=!I2C_M_RD;\r
 119         msg.addr=client->addr;\r
 120         msg.len=len;\r
 121         msg.buf=data;           \r
 122         msg.scl_rate=200 * 1000;\r
 123         \r
 124         //disable_irq(client->irq);\r
 125         while(retries<5)\r
 126         {\r
 127                 ret=i2c_transfer(client->adapter,&msg, 1);\r
 128                 if(ret == 1)break;\r
 129                 retries++;\r
 130         }\r
 131         //enable_irq(client->irq);\r
 132         return ret;\r
 133 }\r
 134 \r
 135 static int goodix_config_ok(struct rk_ts_data *ts)\r
 136 {\r
 137         int ret = 0;\r
 138         unsigned int w,h, n;\r
 139         uint8_t rd_cfg_buf[7] = {0x66,};\r
 140         \r
 141         ret = goodix_i2c_read_bytes(ts->client, rd_cfg_buf, 7);\r
 142 \r
 143         w = (rd_cfg_buf[1]<<8) + rd_cfg_buf[2];\r
 144         h = (rd_cfg_buf[3]<<8) + rd_cfg_buf[4];\r
 145         n = rd_cfg_buf[5];\r
 146 \r
 147 #ifdef CONFIG_ARCH_RK29\r
 148         if((ret < 0) || (w != TS_MAX_X) || (h != TS_MAX_Y) || (n != 10))\r
 149 #else\r
 150         if((ret < 0) || (w != ts->abs_x_max) || (h != ts->abs_y_max) || (n != 170))\r
 151 #endif\r
 152                 return -1;\r
 153 \r
 154         ts->abs_x_max = w;\r
 155         ts->abs_y_max = h;\r
 156         ts->max_touch_num = n;\r
 157         \r
 158         printk("goodix_ts_init: X_MAX = %d,Y_MAX = %d,MAX_TOUCH_NUM = %d\n",ts->abs_x_max,ts->abs_y_max,ts->max_touch_num);\r
 159 \r
 160         return 0;\r
 161 }\r
 162 /*******************************************************\r
 163 Description:\r
 164         Goodix touchscreen initialize function.\r
 165 \r
 166 Parameter:\r
 167         ts:     i2c client private struct.\r
 168         \r
 169 return:\r
 170         Executive outcomes.0---succeed.\r
 171 *******************************************************/\r
 172 static int goodix_init_panel(struct rk_ts_data *ts)\r
 173 {\r
 174         int ret=-1, retry = 10;\r
 175         uint8_t rd_cfg_buf[7] = {0x66,};\r
 176         uint8_t *config_info;\r
 177         int config_len;\r
 178 \r
 179         //for malata 10.1\r
 180         uint8_t config_info_1024_768[] = {\r
 181                 0x65,0x02,0x04,0x00,0x03,0x00,0x0A,0x22,0x1E,0xE7,0x32,0x05,0x08,0x10,0x4C,\r
 182                 0x41,0x41,0x20,0x09,0x00,0xA0,0xA0,0x3C,0x64,0x0E,0x0D,0x0C,0x0B,0x0A,0x09,\r
 183                 0x08,0x07,0x06,0x05,0x04,0x03,0x02,0x01,0x00,0x1D,0x1C,0x1B,0x1A,0x19,0x18,\r
 184                 0x17,0x16,0x15,0x14,0x13,0x12,0x11,0x10,0x0F,0x00,0x00,0x00,0x00,0x00,0x00,\r
 185                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x2B,0x00,0x00,0x00,0x00,0x00,0x00,0x00,\r
 186                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00\r
 187         };\r
 188              \r
 189 #ifdef CONFIG_ARCH_RK29\r
 190         uint8_t config_info_1280_800[] = {\r
 191                 0x65,0x02,0x05,0x00,0x03,0x20,0x0A,0x22,0x1E,0xE7,0x32,0x05,0x08,0x10,0x4C,\r
 192                 0x41,0x41,0x20,0x07,0x00,0xA0,0xA0,0x46,0x64,0x0E,0x0D,0x0C,0x0B,0x0A,0x09,\r
 193                 0x08,0x07,0x06,0x05,0x04,0x03,0x02,0x01,0x00,0x1D,0x1C,0x1B,0x1A,0x19,0x18,\r
 194                 0x17,0x16,0x15,0x14,0x13,0x12,0x11,0x10,0x0F,0x00,0x00,0x00,0x00,0x00,0x00,\r
 195                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0B,0x00,0x00,0x00,0x00,0x00,0x00,0x00,\r
 196                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00\r
 197         };\r
 198 #else\r
 199         uint8_t config_info_1280_800[] = {\r
 200                 0x65,0xA2,0x05,0x00,0x03,0x20,0xAA,0x22,0x1E,0xE7,0x32,0x05,0x08,0x10,0x4C,\r
 201                 0x42,0x42,0x20,0x00,0x09,0x80,0x80,0x32,0x46,0x0E,0x0D,0x0C,0x0B,0x0A,0x09,\r
 202                 0x08,0x07,0x06,0x05,0x04,0x03,0x02,0x01,0x00,0x1D,0x1C,0x1B,0x1A,0x19,0x18,\r
 203                 0x17,0x16,0x15,0x14,0x13,0x12,0x11,0x10,0x0F,0x00,0x00,0x00,0x00,0x00,0x00,\r
 204                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,\r
 205                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00\r
 206         };\r
 207 #endif\r
 208         uint8_t config_info_default[] = {\r
 209                 0x65,0x02,0x05,0x00,0x03,0x20,0x0A,0x22,0x1E,0xE7,0x32,0x05,0x08,0x10,0x4C,\r
 210                 0x42,0x42,0x20,0x00,0x00,0x89,0x89,0x3C,0x64,0x0E,0x0D,0x0C,0x0B,\r
 211                 0x0A,0x09,0x08,0x07,0x06,0x05,0x04,0x03,0x02,0x01,0x00,0x1D,0x1C,\r
 212                 0x1B,0x1A,0x19,0x18,0x17,0x16,0x15,0x14,0x13,0x12,0x11,0x10,0x0F,\r
 213                 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,\r
 214                 0x2B,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,\r
 215                 0x00,0x00,0x00,0x00\r
 216         };\r
 217 \r
 218         if (ts->abs_x_max == 1280 && ts->abs_y_max == 800) {\r
 219                 config_info = config_info_1280_800;\r
 220                 config_len = ARRAY_SIZE(config_info_1280_800);\r
 221         } else if (ts->abs_x_max == 1024 && ts->abs_y_max == 786) {\r
 222                 config_info = config_info_1024_768;\r
 223                 config_len = ARRAY_SIZE(config_info_1024_768);\r
 224         } else {\r
 225                 config_info = config_info_default;\r
 226                 config_len = ARRAY_SIZE(config_info_default);\r
 227         }\r
 228         while(--retry && (goodix_config_ok(ts) < 0)){\r
 229                 ret = goodix_i2c_write_bytes(ts->client, config_info, config_len);\r
 230                 if (ret < 0) {\r
 231                         printk("goodix write cfg info err, retry %d\n", retry);\r
 232                         msleep(100);\r
 233                 }\r
 234         }\r
 235 \r
 236         if(retry <= 0){\r
 237                 printk("goodix write cfg info err\n");\r
 238                 return -1;\r
 239         }\r
 240 \r
 241         \r
 242         rd_cfg_buf[0] = 0x6e;\r
 243         rd_cfg_buf[1] = 0x00;\r
 244         goodix_i2c_read_bytes(ts->client, rd_cfg_buf, 2);\r
 245         if((rd_cfg_buf[1]&0x0f)==0x0f)\r
 246         {\r
 247                 dev_info(&ts->client->dev, "Need int wake up from green mode!\n");\r
 248         }\r
 249 \r
 250         return 0;\r
 251 \r
 252 }\r
 253 \r
 254 //fjp add ===============================\r
 255 static bool goodix_get_status(char *p1,int*p2)\r
 256 {\r
 257         bool status = PEN_DOWN;\r
 258         if((*p2==PEN_DOWN) && (*p1==PEN_RELEASE))\r
 259                 {\r
 260                         *p2 = PEN_DOWN_UP; //¸Õ¸Õµ¯Æð\r
 261                          status = PEN_RELEASE; \r
 262                 }\r
 263         else if((*p2==PEN_RELEASE) && (*p1==PEN_RELEASE))\r
 264                 {\r
 265                    *p2 = PEN_RELEASE;\r
 266                         status = PEN_RELEASE; \r
 267                 }\r
 268         else\r
 269                 {\r
 270                         *p2 = PEN_DOWN;\r
 271                 }\r
 272         return status;\r
 273 }\r
 274 \r
 275 //===================================\r
 276 /*******************************************************\r
 277 Description:\r
 278         Read goodix touchscreen version function.\r
 279 \r
 280 Parameter:\r
 281         ts:     i2c client private struct.\r
 282         \r
 283 return:\r
 284         Executive outcomes.0---succeed.\r
 285 *******************************************************/\r
 286 static int  goodix_read_version(struct rk_ts_data *ts, char **version)\r
 287 {\r
 288         int ret = -1, count = 0;\r
 289         char *version_data;\r
 290         char *p;\r
 291 \r
 292         *version = (char *)vmalloc(18);\r
 293         version_data = *version;\r
 294         if(!version_data)\r
 295                 return -ENOMEM;\r
 296         p = version_data;\r
 297         memset(version_data, 0, sizeof(version_data));\r
 298         version_data[0]=240;    \r
 299         ret=goodix_i2c_read_bytes(ts->client,version_data, 17);\r
 300         if (ret < 0) \r
 301                 return ret;\r
 302         version_data[17]='\0';\r
 303         \r
 304         if(*p == '\0')\r
 305                 return 0;       \r
 306         do                                      \r
 307         {\r
 308                 if((*p > 122) || (*p < 48 && *p != 32) || (*p >57 && *p  < 65) \r
 309                         ||(*p > 90 && *p < 97 && *p  != '_'))           //check illeqal character\r
 310                         count++;\r
 311         }while(*++p != '\0' );\r
 312         if(count > 2)\r
 313                 return 0;\r
 314         else \r
 315                 return 1;       \r
 316 }\r
 317 \r
 318 static int last_touch_num = -1;\r
 319 static void goodix_get_touch_info(struct rk_ts_data *ts,char *point_num,struct rk_touch_info* info_buf)\r
 320 {\r
 321         uint8_t  point_data[(1-READ_COOR_ADDR)+1+2+5*MAX_FINGER_NUM+1]={ 0 };  //read address(1byte)+key index(1byte)+point mask(2bytes)+5bytes*MAX_FINGER_NUM+coor checksum(1byte)\r
 322         uint8_t  check_sum = 0;\r
 323         int ret ;\r
 324         uint16_t  finger_current = 0;\r
 325         uint16_t  finger_bit = 0;\r
 326         unsigned int  count = 0, point_count = 0;\r
 327         unsigned char touch_num = 0;\r
 328         uint8_t chksum_err = 0;\r
 329         unsigned int position = 0;      \r
 330         uint8_t track_id[MAX_FINGER_NUM] = {0};\r
 331         u8 index;\r
 332         u8 temp =0;\r
 333         point_data[0] = READ_COOR_ADDR;         //read coor address\r
 334         \r
 335         if(!ts||!info_buf)\r
 336         {\r
 337                 printk("goodix ts or info_buf is null\n");\r
 338                 return;\r
 339         }\r
 340 \r
 341         ret=goodix_i2c_read_bytes(ts->client, point_data, sizeof(point_data)/sizeof(point_data[0]));\r
 342         if(ret != 2)    \r
 343         {\r
 344             printk("goodix read error\n");\r
 345         }       \r
 346         finger_current =  (point_data[3 - READ_COOR_ADDR]<<8) + point_data[2 - READ_COOR_ADDR];\r
 347         \r
 348         DBG("finger_current:%d ==== max_touch_num:%d\n", finger_current,ts->max_touch_num);//add by fjp 2010-9-28\r
 349         \r
 350 \r
 351         if(finger_current)\r
 352         {       \r
 353                 point_count = 0;\r
 354                 finger_bit = finger_current;\r
 355                 for(count = 0; (finger_bit != 0) && (count < ts->max_touch_num); count++)//cal how many point touch currntly\r
 356                 {\r
 357                         if(finger_bit & 0x01)\r
 358                         {\r
 359                                 track_id[count] = PEN_DOWN;\r
 360                                 point_count++;\r
 361                         }\r
 362                         finger_bit >>= 1;\r
 363                 }\r
 364                 touch_num = point_count;\r
 365 \r
 366                 check_sum = point_data[2 - READ_COOR_ADDR] + point_data[3 - READ_COOR_ADDR];                    //cal coor checksum\r
 367                 count = 4 - READ_COOR_ADDR;\r
 368                 for(point_count *= 5; point_count > 0; point_count--)\r
 369                         check_sum += point_data[count++];\r
 370                 check_sum += point_data[count];\r
 371                 if(check_sum  != 0)                     //checksum verify error\r
 372                 {\r
 373                         printk("coor checksum error!\n");\r
 374                 }\r
 375                 else\r
 376                 {\r
 377                         chksum_err = 0;\r
 378                 }\r
 379         }\r
 380 \r
 381         //printk("current point num:%d\n",touch_num);\r
 382         *point_num = touch_num;\r
 383         if(touch_num < last_touch_num)  //some flinger release\r
 384         {\r
 385                 //printk("%d flinger release\n",last_touch_num-touch_num);\r
 386                 /*for(index = touch_num; index < last_touch_num; index++)\r
 387                         info_buf[index].status = 0;*/\r
 388                 *point_num = last_touch_num;\r
 389                  touch_num = last_touch_num;\r
 390         }\r
 391         last_touch_num = touch_num;\r
 392         for(index = 0; index < touch_num; index++)\r
 393         {\r
 394              if(goodix_get_status(&track_id[index],&info_buf[index].status))\r
 395                 {\r
 396                 position = 4 - READ_COOR_ADDR + 5*(temp++);\r
 397                 info_buf[index].x = (unsigned int) (point_data[position]<<8) + (unsigned int)( point_data[position+1]);\r
 398                 info_buf[index].y  = (unsigned int)(point_data[position+2]<<8) + (unsigned int) (point_data[position+3]);\r
 399                 info_buf[index].press = (unsigned int) (point_data[position+4]);        \r
 400                 }\r
 401         }\r
 402         \r
 403 }\r
 404 \r
 405 /*******************************************************\r
 406 Description:\r
 407         External interrupt service routine.\r
 408 \r
 409 Parameter:\r
 410         irq:    interrupt number.\r
 411         dev_id: private data pointer.\r
 412         \r
 413 return:\r
 414         irq execute status.\r
 415 *******************************************************/\r
 416 static irqreturn_t rk_ts_irq_handler(int irq, void *dev_id)\r
 417 {\r
 418         struct rk_ts_data *ts = (struct rk_ts_data*)dev_id;\r
 419         int i =0;\r
 420         char point_num;\r
 421         bool touch_down;\r
 422 \r
 423         do {\r
 424                 if(ts->get_touch_info)\r
 425                 {\r
 426                         ts->get_touch_info(ts,&point_num,ts->info_buf);\r
 427                 }\r
 428                 for(i=0; i< point_num; i++)\r
 429                 {\r
 430                         DBG("info_buf[i].status =====%d\n",ts->info_buf[i].status);\r
 431                         if (ts->info_buf[i].status==PEN_DOWN_UP)\r
 432                         {\r
 433                                 ts->info_buf[i].status=PEN_RELEASE;\r
 434                                 DBG("the key %d is up------\n",i);\r
 435                                 input_mt_slot(ts->input_dev, i);\r
 436                                 input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, false);\r
 437                                 continue;\r
 438                         }\r
 439                         if (ts->info_buf[i].status==PEN_DOWN)\r
 440                         {\r
 441                                 input_mt_slot(ts->input_dev, i);\r
 442                                 input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, true);\r
 443                                 input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, ts->info_buf[i].press);\r
 444                                 input_report_abs(ts->input_dev, ABS_MT_POSITION_X, ts->info_buf[i].x);\r
 445                                 input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, ts->info_buf[i].y);\r
 446                                 DBG("touch point %d %d >>x:%d>>y:%d\n",i,ts->info_buf[i].status,ts->info_buf[i].x,ts->info_buf[i].y);//add by fjp 2010-9-28\r
 447                         }\r
 448                 }\r
 449                 input_sync(ts->input_dev);\r
 450                 touch_down = gpio_get_value(ts->irq_pin) == 0;\r
 451                 if (touch_down)\r
 452                 {\r
 453                         DBG("touch down .............\n");//add by fjp 2010-9-28\r
 454                         usleep_range(10000, 10000);\r
 455                 }\r
 456         } while (touch_down);\r
 457 \r
 458         DBG("touch up>>x:%d>>y:%d\n",ts->info_buf[0].x,ts->info_buf[0].y);//add by fjp 2010-9-28\r
 459         /*input_mt_slot(ts->input_dev, 0);\r
 460           input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, true);\r
 461           input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0);\r
 462 \r
 463           input_mt_slot(ts->input_dev, 0);\r
 464           input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, false);*/\r
 465 \r
 466         DBG("point_num+++++++++++ = %d\n", point_num);//add by fjp 2010-9-28\r
 467         for(i=0; i< point_num; i++)\r
 468         {\r
 469                 //        printk("info_buf[i].status +++++++%d\n",ts->info_buf[i].status);\r
 470                 if(ts->info_buf[i].status)\r
 471                 {\r
 472                         input_mt_slot(ts->input_dev, i);//°´ÐòºÅÉÏ±¨\r
 473                         input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, false);               \r
 474                         //input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0);\r
 475                         ts->info_buf[i].status= PEN_RELEASE;\r
 476 \r
 477                         DBG("release+++++++++++ = %d\n", i);//add by fjp 2010-9-28\r
 478                 }\r
 479         }\r
 480         input_sync(ts->input_dev);\r
 481         ts->pendown =PEN_RELEASE;\r
 482         last_touch_num = 0;\r
 483 \r
 484         return IRQ_HANDLED;\r
 485 }\r
 486 \r
 487 static int rk_ts_suspend(struct i2c_client *client, pm_message_t mesg)\r
 488 {\r
 489         int ret;\r
 490         struct rk_ts_data *ts = i2c_get_clientdata(client);       \r
 491 \r
 492         disable_irq(ts->irq);   \r
 493 \r
 494         if (ts->power) {\r
 495                 DBG("%s.....line=%d\n",__func__,__LINE__);\r
 496                 ret = ts->power(ts, 0);\r
 497                 if (ret < 0)\r
 498                         printk(KERN_ERR "goodix_ts_resume power off failed\n");\r
 499         }\r
 500 \r
 501         return 0;\r
 502 }\r
 503 \r
 504 static int rk_ts_resume(struct i2c_client *client)\r
 505 {\r
 506         int ret;\r
 507         struct rk_ts_data *ts = i2c_get_clientdata(client);\r
 508 \r
 509         if (ts->power) {\r
 510                 DBG("%s.....line=%d\n",__func__,__LINE__);\r
 511                 ret = ts->power(ts, 1);\r
 512                 if (ret < 0)\r
 513                         printk(KERN_ERR "goodix_ts_resume power on failed\n");\r
 514         }\r
 515 \r
 516         enable_irq(ts->irq);\r
 517         return 0;\r
 518 }\r
 519 \r
 520 \r
 521 \r
 522 static int rk_ts_early_suspend(struct tp_device *tp_d)\r
 523 {\r
 524         struct rk_ts_data *ts;\r
 525         ts = container_of(tp_d, struct rk_ts_data, tp);\r
 526         rk_ts_suspend(ts->client, PMSG_SUSPEND);\r
 527         return 0;\r
 528 }\r
 529 \r
 530 static int rk_ts_early_resume(struct tp_device *tp_d)\r
 531 {\r
 532         struct rk_ts_data *ts;\r
 533         ts = container_of(tp_d, struct rk_ts_data, tp);\r
 534         rk_ts_resume(ts->client);\r
 535         return 0;\r
 536 }\r
 537 \r
 538 \r
 539 /*******************************************************\r
 540 Description:\r
 541         Goodix touchscreen power manage function.\r
 542 \r
 543 Parameter:\r
 544         on:     power status.0---suspend;1---resume.\r
 545         \r
 546 return:\r
 547         Executive outcomes.-1---i2c transfer error;0---succeed.\r
 548 *******************************************************/\r
 549 static int goodix_ts_power(struct rk_ts_data * ts, int on)\r
 550 {\r
 551         int ret = -1;\r
 552         unsigned char i2c_control_buf[2] = {80,  1};            //suspend cmd\r
 553         int retry = 0;\r
 554 \r
 555         if(on != 0 && on !=1)\r
 556         {\r
 557                 printk("%s: Cant't support this command.", rk_ts_name);\r
 558                 return -EINVAL;\r
 559         }\r
 560                 \r
 561         if(on == 0)//suspend\r
 562         { \r
 563         while(retry<5)\r
 564                 {\r
 565                         ret = goodix_i2c_write_bytes(ts->client, i2c_control_buf, 2);\r
 566                         if(ret == 1)\r
 567                         {\r
 568                                 printk("touch goodix Send suspend cmd successed \n");\r
 569                                 break;\r
 570                         }\r
 571                        retry++;\r
 572                         msleep(10);\r
 573                 }\r
 574                 if(ret > 0)\r
 575                   ret = 0;\r
 576         }\r
 577         else if(on == 1)//resume\r
 578         {\r
 579                 printk("touch goodix int resume\n");\r
 580                 gpio_set_value(ts->rst_pin, ts->rst_val);\r
 581                 msleep(20);\r
 582                 gpio_set_value(ts->rst_pin, !ts->rst_val);\r
 583                 ret = 0;\r
 584         }        \r
 585         return ret;\r
 586 }\r
 587 \r
 588 \r
 589 static int goodix_input_params_init(struct rk_ts_data *ts)\r
 590 {\r
 591         int ret ;\r
 592         ts->input_dev = devm_input_allocate_device(&ts->client->dev);\r
 593         if (ts->input_dev == NULL) {\r
 594                 ret = -ENOMEM;\r
 595                 printk(KERN_ALERT "Failed to allocate input device\n");\r
 596                 return ret;\r
 597         }\r
 598 \r
 599 \r
 600         __set_bit(INPUT_PROP_DIRECT, ts->input_dev->propbit);\r
 601         __set_bit(EV_ABS, ts->input_dev->evbit);\r
 602 \r
 603         input_mt_init_slots(ts->input_dev, ts->max_touch_num, 0);\r
 604         input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);\r
 605         input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X, 0, ts->abs_x_max, 0, 0);\r
 606         input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y, 0, ts->abs_y_max, 0, 0);\r
 607         sprintf(ts->phys, "input/rkts");\r
 608         ts->input_dev->name = rk_ts_name;\r
 609         ts->input_dev->phys = ts->phys;\r
 610         ts->input_dev->id.bustype = BUS_I2C;\r
 611         ts->input_dev->id.vendor = 0xDEAD;\r
 612         ts->input_dev->id.product = 0xBEEF;\r
 613         ts->input_dev->id.version = 10427;      //screen firmware version\r
 614         \r
 615         ret = input_register_device(ts->input_dev);\r
 616         if (ret) {\r
 617                 printk(KERN_ALERT "Probe: Unable to register %s input device\n", ts->input_dev->name);\r
 618                 return -1;\r
 619         }\r
 620 \r
 621         return 0 ;\r
 622         \r
 623 }\r
 624 \r
 625 #ifdef CONFIG_TOUCHSCREEN_GOODIX_IAP\r
 626 static const struct file_operations goodix_proc_fops = {\r
 627         .read   = goodix_update_read,\r
 628         .write  = goodix_update_write,\r
 629 };\r
 630 #endif\r
 631 \r
 632 static int goodix_ts_init(struct rk_ts_data *ts)\r
 633 {\r
 634         char ret ;\r
 635         char *version_info = NULL;\r
 636 #if 0\r
 637         char test_data = 1;\r
 638         char retry;\r
 639         for(retry=0;retry < 30; retry++)    //test goodix\r
 640         {\r
 641                 ret =goodix_i2c_write_bytes(ts->client, &test_data, 1);\r
 642                 if (ret > 0)\r
 643                         break;\r
 644         }\r
 645         if(ret <= 0)\r
 646         {\r
 647                 printk(KERN_INFO "I2C communication ERROR!Goodix touchscreen driver become invalid\n");\r
 648                 return -1;\r
 649         }       \r
 650 #endif  \r
 651         \r
 652         ret=goodix_init_panel(ts);\r
 653         if(ret != 0) {\r
 654                 printk("goodix panel init fail\n");\r
 655                 return -1;\r
 656         }\r
 657         ret = goodix_read_version(ts, &version_info);\r
 658         if(ret <= 0)\r
 659         {\r
 660                 printk(KERN_INFO"Read version data failed!\n");\r
 661         }\r
 662         else\r
 663         {\r
 664                 printk("goodix_ts_init: version %s\n", (version_info+1));\r
 665         }\r
 666         vfree(version_info);\r
 667         #ifdef CONFIG_TOUCHSCREEN_GOODIX_IAP\r
 668         goodix_proc_entry = proc_create("goodix-update", 0666, NULL, &goodix_proc_fops);\r
 669         if(goodix_proc_entry == NULL)\r
 670         {\r
 671                 printk("Couldn't create proc entry!\n");\r
 672                 ret = -ENOMEM;\r
 673                 return ret ;\r
 674         }\r
 675         else\r
 676         {\r
 677                 printk("goodix_ts_init: create proc entry success!\n");\r
 678                 goodix_proc_entry->write_proc = goodix_update_write;\r
 679                 goodix_proc_entry->read_proc = goodix_update_read;\r
 680                 //goodix_proc_entry->owner = THIS_MODULE;\r
 681         }\r
 682 #endif\r
 683 \r
 684         return 0;\r
 685 }\r
 686 /*******************************************************\r
 687 Description:\r
 688         Goodix touchscreen probe function.\r
 689 \r
 690 Parameter:\r
 691         client: i2c device struct.\r
 692         id:device id.\r
 693         \r
 694 return:\r
 695         Executive outcomes. 0---succeed.\r
 696 *******************************************************/\r
 697 static int rk_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)\r
 698 {\r
 699         int ret = 0;\r
 700         struct rk_ts_data *ts;\r
 701         struct device_node *np = client->dev.of_node;\r
 702         enum of_gpio_flags rst_flags, pwr_flags;\r
 703         unsigned long irq_flags;\r
 704         u32 val;\r
 705         \r
 706         printk(KERN_INFO "Install touch driver.\n");\r
 707         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) \r
 708         {\r
 709                 dev_err(&client->dev, "Must have I2C_FUNC_I2C.\n");\r
 710                 return -ENODEV;\r
 711         }\r
 712 \r
 713         ts = devm_kzalloc(&client->dev, sizeof(struct rk_ts_data), GFP_KERNEL);\r
 714         if (ts == NULL) {\r
 715                 dev_err(&client->dev, "alloc for struct rk_ts_data fail\n");\r
 716                 return -ENOMEM;\r
 717         }\r
 718 \r
 719         if (!np) {\r
 720                 dev_err(&client->dev, "no device tree\n");\r
 721                 return -EINVAL;\r
 722         }\r
 723         ts->irq_pin = of_get_named_gpio_flags(np, "touch-gpio", 0, (enum of_gpio_flags *)&irq_flags);\r
 724         ts->rst_pin = of_get_named_gpio_flags(np, "reset-gpio", 0, &rst_flags);\r
 725         ts->pwr_pin = of_get_named_gpio_flags(np, "power-gpio", 0, &pwr_flags);\r
 726         if (of_property_read_u32(np, "max-x", &val)) {\r
 727                 dev_err(&client->dev, "no max-x defined\n");\r
 728                 return -EINVAL;\r
 729         }\r
 730         ts->abs_x_max = val;\r
 731         if (of_property_read_u32(np, "max-y", &val)) {\r
 732                 dev_err(&client->dev, "no max-y defined\n");\r
 733                 return -EINVAL;\r
 734         }\r
 735         ts->abs_y_max = val;\r
 736         ts->pendown =PEN_RELEASE;\r
 737         ts->client = client;\r
 738         ts->ts_init = goodix_ts_init;   \r
 739         ts->power = goodix_ts_power;\r
 740         ts->get_touch_info = goodix_get_touch_info;\r
 741         ts->input_parms_init = goodix_input_params_init;\r
 742         \r
 743         if (gpio_is_valid(ts->pwr_pin)) {\r
 744                 ret = devm_gpio_request_one(&client->dev, ts->pwr_pin, (pwr_flags & OF_GPIO_ACTIVE_LOW) ? GPIOF_OUT_INIT_LOW : GPIOF_OUT_INIT_HIGH, "goodix power pin");\r
 745                 if (ret != 0) {\r
 746                         dev_err(&client->dev, "goodix power error\n");\r
 747                         return -EIO;\r
 748                 }\r
 749                 //msleep(100);\r
 750         } else {\r
 751                 dev_info(&client->dev, "power pin invalid\n");\r
 752         }\r
 753 \r
 754         if (gpio_is_valid(ts->rst_pin)) {\r
 755                 ts->rst_val = (rst_flags & OF_GPIO_ACTIVE_LOW) ? 0 : 1;\r
 756                 ret = devm_gpio_request_one(&client->dev, ts->rst_pin, (rst_flags & OF_GPIO_ACTIVE_LOW) ? GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW, "goodix reset pin");\r
 757                 if (ret != 0) {\r
 758                         dev_err(&client->dev, "goodix gpio_request error\n");\r
 759                         return -EIO;\r
 760                 }\r
 761              //  msleep(100);\r
 762         } else {\r
 763                 dev_info(&client->dev, "reset pin invalid\n");\r
 764         }\r
 765 \r
 766         if(ts->ts_init)\r
 767         {\r
 768                 ret = ts->ts_init(ts);\r
 769                 if(ret < 0)\r
 770                 {\r
 771                         printk(KERN_ALERT "rk ts init fail\n");\r
 772                         return ret;\r
 773                 }\r
 774         }\r
 775 \r
 776         ts->info_buf= devm_kzalloc(&client->dev, ts->max_touch_num*sizeof(struct rk_touch_info), GFP_KERNEL);\r
 777         if(!ts->info_buf)\r
 778         {\r
 779                 dev_err(&client->dev, "alloc for rk_touch_info fail\n");\r
 780                 return -ENOMEM;\r
 781         }\r
 782 \r
 783         if(ts->input_parms_init)\r
 784         {\r
 785                 ts->input_parms_init(ts);\r
 786         }\r
 787 \r
 788         i2c_connect_client = client;\r
 789 \r
 790         ts->tp.tp_resume = rk_ts_early_resume;\r
 791         ts->tp.tp_suspend = rk_ts_early_suspend;\r
 792         tp_register_fb(&ts->tp);\r
 793 \r
 794         i2c_set_clientdata(client, ts);\r
 795 \r
 796         ts->irq=gpio_to_irq(ts->irq_pin);               //If not defined in client\r
 797         if (ts->irq)\r
 798         {\r
 799                 ret = devm_request_threaded_irq(&client->dev, ts->irq, NULL, rk_ts_irq_handler, irq_flags | IRQF_ONESHOT, client->name, ts);\r
 800                 if (ret != 0) {\r
 801                         printk(KERN_ALERT "Cannot allocate ts INT!ERRNO:%d\n", ret);\r
 802                         goto err;\r
 803                 }\r
 804                 //disable_irq(ts->irq);\r
 805         }\r
 806         printk("goodix_ts_init: probe successfully!\n");\r
 807         return 0;\r
 808 \r
 809         \r
 810 err:\r
 811         tp_unregister_fb(&ts->tp);\r
 812         i2c_set_clientdata(client, NULL);       \r
 813         return ret;\r
 814 }\r
 815 \r
 816 \r
 817 /*******************************************************\r
 818 Description:\r
 819         Goodix touchscreen driver release function.\r
 820 \r
 821 Parameter:\r
 822         client: i2c device struct.\r
 823         \r
 824 return:\r
 825         Executive outcomes. 0---succeed.\r
 826 *******************************************************/\r
 827 static int rk_ts_remove(struct i2c_client *client)\r
 828 {\r
 829         struct rk_ts_data *ts = i2c_get_clientdata(client);\r
 830         tp_unregister_fb(&ts->tp);\r
 831 \r
 832 #ifdef CONFIG_TOUCHSCREEN_GOODIX_IAP\r
 833         remove_proc_entry("goodix-update", NULL);\r
 834 #endif\r
 835         \r
 836         dev_notice(&client->dev,"The driver is removing...\n");\r
 837         i2c_set_clientdata(client, NULL);\r
 838         return 0;\r
 839 }\r
 840 \r
 841 static void rk_ts_shutdown(struct i2c_client *client)\r
 842 {\r
 843         struct rk_ts_data *ts = i2c_get_clientdata(client);\r
 844         if (ts)\r
 845                 tp_unregister_fb(&ts->tp);\r
 846 \r
 847 }\r
 848 \r
 849 //******************************Begin of firmware update surpport*******************************\r
 850 #ifdef CONFIG_TOUCHSCREEN_GOODIX_IAP\r
 851 /**\r
 852 @brief CRC cal proc,include : Reflect,init_crc32_table,GenerateCRC32\r
 853 @param global var oldcrc32\r
 854 @return states\r
 855 */\r
 856 static unsigned int Reflect(unsigned long int ref, char ch)\r
 857 {\r
 858         unsigned int value=0;\r
 859         int i;\r
 860         for(i = 1; i < (ch + 1); i++)\r
 861         {\r
 862                 if(ref & 1)\r
 863                         value |= 1 << (ch - i);\r
 864                 ref >>= 1;\r
 865         }\r
 866         return value;\r
 867 }\r
 868 /*---------------------------------------------------------------------------------------------------------*/\r
 869 /*  CRC Check Program INIT                                                                                                                         */\r
 870 /*---------------------------------------------------------------------------------------------------------*/\r
 871 static void init_crc32_table(void)\r
 872 {\r
 873         unsigned int temp;\r
 874         unsigned int t1,t2;\r
 875         unsigned int flag;\r
 876         int i,j;\r
 877         for(i = 0; i <= 0xFF; i++)\r
 878         {\r
 879                 temp=Reflect(i, 8);\r
 880                 crc32_table[i]= temp<< 24;\r
 881                 for (j = 0; j < 8; j++)\r
 882                 {\r
 883 \r
 884                         flag=crc32_table[i]&0x80000000;\r
 885                         t1=(crc32_table[i] << 1);\r
 886                         if(flag==0)\r
 887                                 t2=0;\r
 888                         else\r
 889                                 t2=ulPolynomial;\r
 890                         crc32_table[i] =t1^t2 ;\r
 891 \r
 892                 }\r
 893                 crc32_table[i] = Reflect(crc32_table[i], 32);\r
 894         }\r
 895 }\r
 896 /*---------------------------------------------------------------------------------------------------------*/\r
 897 /*  CRC main Program                                                                                                                               */\r
 898 /*---------------------------------------------------------------------------------------------------------*/\r
 899 static void GenerateCRC32(unsigned char * buf, unsigned int len)\r
 900 {\r
 901         unsigned int i;\r
 902         unsigned int t;\r
 903 \r
 904         for (i = 0; i != len; ++i)\r
 905         {\r
 906                 t = (oldcrc32 ^ buf[i]) & 0xFF;\r
 907                 oldcrc32 = ((oldcrc32 >> 8) & 0xFFFFFF) ^ crc32_table[t];\r
 908         }\r
 909 }\r
 910 \r
 911 static struct file * update_file_open(char * path, mm_segment_t * old_fs_p)\r
 912 {\r
 913         struct file * filp = NULL;\r
 914         int errno = -1;\r
 915                 \r
 916         filp = filp_open(path, O_RDONLY, 0644);\r
 917         \r
 918         if(!filp || IS_ERR(filp))\r
 919         {\r
 920                 if(!filp)\r
 921                         errno = -ENOENT;\r
 922                 else \r
 923                         errno = PTR_ERR(filp);                                  \r
 924                 printk(KERN_ERR "The update file for Guitar open error.\n");\r
 925                 return NULL;\r
 926         }\r
 927         *old_fs_p = get_fs();\r
 928         set_fs(get_ds());\r
 929 \r
 930         filp->f_op->llseek(filp,0,0);\r
 931         return filp ;\r
 932 }\r
 933 \r
 934 static void update_file_close(struct file * filp, mm_segment_t old_fs)\r
 935 {\r
 936         set_fs(old_fs);\r
 937         if(filp)\r
 938                 filp_close(filp, NULL);\r
 939 }\r
 940 static int update_get_flen(char * path)\r
 941 {\r
 942         struct file * file_ck = NULL;\r
 943         mm_segment_t old_fs;\r
 944         int length ;\r
 945         \r
 946         file_ck = update_file_open(path, &old_fs);\r
 947         if(file_ck == NULL)\r
 948                 return 0;\r
 949 \r
 950         length = file_ck->f_op->llseek(file_ck, 0, SEEK_END);\r
 951         //printk("File length: %d\n", length);\r
 952         if(length < 0)\r
 953                 length = 0;\r
 954         update_file_close(file_ck, old_fs);\r
 955         return length;  \r
 956 }\r
 957 static int update_file_check(char * path)\r
 958 {\r
 959         unsigned char buffer[64] = { 0 } ;\r
 960         struct file * file_ck = NULL;\r
 961         mm_segment_t old_fs;\r
 962         int count, ret, length ;\r
 963         \r
 964         file_ck = update_file_open(path, &old_fs);\r
 965         \r
 966         if(path != NULL)\r
 967                 printk("File Path:%s\n", path);\r
 968         \r
 969         if(file_ck == NULL)\r
 970                 return -ERROR_NO_FILE;\r
 971 \r
 972         length = file_ck->f_op->llseek(file_ck, 0, SEEK_END);\r
 973 #ifdef GUITAR_MESSAGE\r
 974         printk(KERN_INFO "gt801 update: File length: %d\n",length);\r
 975 #endif  \r
 976         if(length <= 0 || (length%4) != 0)\r
 977         {\r
 978                 update_file_close(file_ck, old_fs);\r
 979                 return -ERROR_FILE_TYPE;\r
 980         }\r
 981         \r
 982         //set file point to the begining of the file\r
 983         file_ck->f_op->llseek(file_ck, 0, SEEK_SET);    \r
 984         oldcrc32 = 0xFFFFFFFF;\r
 985         init_crc32_table();\r
 986         while(length > 0)\r
 987         {\r
 988                 ret = file_ck->f_op->read(file_ck, buffer, sizeof(buffer), &file_ck->f_pos);\r
 989                 if(ret > 0)\r
 990                 {\r
 991                         for(count = 0; count < ret;  count++)   \r
 992                                 GenerateCRC32(&buffer[count],1);                        \r
 993                 }\r
 994                 else \r
 995                 {\r
 996                         update_file_close(file_ck, old_fs);\r
 997                         return -ERROR_FILE_READ;\r
 998                 }\r
 999                 length -= ret;\r
1000         }\r
1001         oldcrc32 = ~oldcrc32;\r
1002 #ifdef GUITAR_MESSAGE   \r
1003         printk("CRC_Check: %u\n", oldcrc32);\r
1004 #endif  \r
1005         update_file_close(file_ck, old_fs);\r
1006         return 1;       \r
1007 }\r
1008 \r
1009 unsigned char wait_slave_ready(struct rk_ts_data *ts, unsigned short *timeout)\r
1010 {\r
1011         unsigned char i2c_state_buf[2] = {ADDR_STA, UNKNOWN_ERROR};\r
1012         int ret;\r
1013         while(*timeout < MAX_TIMEOUT)\r
1014         {\r
1015                 ret = goodix_i2c_read_bytes(ts->client, i2c_state_buf, 2);\r
1016                 if(ret <= 0)\r
1017                         return ERROR_I2C_TRANSFER;\r
1018                 if(i2c_state_buf[1] & SLAVE_READY)\r
1019                 {\r
1020                         return i2c_state_buf[1];\r
1021                         //return 1;\r
1022                 }\r
1023                 msleep(10);\r
1024                 *timeout += 5;\r
1025         }\r
1026         return 0;\r
1027 }\r
1028 \r
1029 static int goodix_update_write(struct file *filp, const char __user *buff, unsigned long len, void *data)\r
1030 {\r
1031         unsigned char cmd[220];\r
1032         int ret = -1;\r
1033 \r
1034         static unsigned char update_path[100];\r
1035         static unsigned short time_count = 0;\r
1036         static unsigned int file_len = 0;\r
1037         \r
1038         unsigned char i2c_control_buf[2] = {ADDR_CMD, 0};\r
1039         unsigned char i2c_states_buf[2] = {ADDR_STA, 0};\r
1040         unsigned char i2c_data_buf[PACK_SIZE+1+8] = {ADDR_DAT,};\r
1041         //unsigned char i2c_rd_buf[1+4+PACK_SIZE+4];\r
1042         unsigned char i2c_rd_buf[160];\r
1043         unsigned char retries = 0;\r
1044         unsigned int rd_len;\r
1045         unsigned char i = 0;\r
1046         static unsigned char update_need_config = 0;\r
1047 \r
1048         unsigned char checksum_error_times = 0;\r
1049 #ifdef UPDATE_NEW_PROTOCOL\r
1050         unsigned int frame_checksum = 0;\r
1051         unsigned int frame_number = 0;\r
1052 #else\r
1053         unsigned char send_crc = 0;\r
1054 #endif\r
1055 \r
1056         struct file * file_data = NULL;\r
1057         mm_segment_t old_fs;\r
1058         struct rk_ts_data *ts;\r
1059         \r
1060         ts = i2c_get_clientdata(i2c_connect_client);\r
1061         if(ts==NULL)\r
1062                 return 0;\r
1063         \r
1064         if(copy_from_user(&cmd, buff, len))\r
1065         {\r
1066                 return -EFAULT;\r
1067         }\r
1068         switch(cmd[0])\r
1069         {\r
1070                 case STEP_SET_PATH:\r
1071                         printk(KERN_INFO"Write cmd is:%d,cmd arg is:%s,write len is:%ld\n",cmd[0], &cmd[1], len);\r
1072                         memset(update_path, 0, 100);\r
1073                         strncpy(update_path, cmd+1, 100);\r
1074                         if(update_path[0] == 0)\r
1075                                 return 0;\r
1076                         else\r
1077                                 return 1;\r
1078                 case STEP_CHECK_FILE:\r
1079                         printk(KERN_INFO"Begin to firmware update ......\n");\r
1080                         ret = update_file_check(update_path);\r
1081                         if(ret <= 0)\r
1082                         {\r
1083                                 printk(KERN_INFO"fialed to check update file!\n");\r
1084                                 return ret;\r
1085                         }\r
1086                         msleep(500);\r
1087                         printk(KERN_INFO"Update check file success!\n");\r
1088                         return 1;\r
1089                 case STEP_WRITE_SYN:\r
1090                         printk(KERN_INFO"STEP1:Write synchronization signal!\n");\r
1091                         i2c_control_buf[1] = UPDATE_START;\r
1092                         ret = goodix_i2c_write_bytes(ts->client, i2c_control_buf, 2);\r
1093                         if(ret <= 0)\r
1094                         {\r
1095                                 ret = ERROR_I2C_TRANSFER;\r
1096                                 return ret;\r
1097                         }\r
1098                         //the time include time(APROM -> LDROM) and time(LDROM init)\r
1099                         msleep(1000);\r
1100                         return 1;\r
1101                 case STEP_WAIT_SYN:\r
1102                         printk(KERN_INFO"STEP2:Wait synchronization signal!\n");\r
1103                         while(retries < MAX_I2C_RETRIES)\r
1104                         {\r
1105                                 i2c_states_buf[1] = UNKNOWN_ERROR;\r
1106                                 ret = goodix_i2c_read_bytes(ts->client, i2c_states_buf, 2);\r
1107                                 printk(KERN_INFO"The read byte is:%d\n", i2c_states_buf[1]);\r
1108                                 if(i2c_states_buf[1] & UPDATE_START)\r
1109                                 {\r
1110                                         if(i2c_states_buf[1] & NEW_UPDATE_START)\r
1111                                         {\r
1112                                         #ifdef UPDATE_NEW_PROTOCOL\r
1113                                                 update_need_config = 1;\r
1114                                                 return 2;\r
1115                                         #else\r
1116                                                 return 1;\r
1117                                         #endif\r
1118                                         }\r
1119                                         break;\r
1120                                 }\r
1121                                 msleep(5);\r
1122                                 retries++;\r
1123                                 time_count += 10;\r
1124                         }\r
1125                         if((retries >= MAX_I2C_RETRIES) && (!(i2c_states_buf[1] & UPDATE_START)))\r
1126                         {\r
1127                                 if(ret <= 0)\r
1128                                         return 0;\r
1129                                 else\r
1130                                         return -1;\r
1131                         }\r
1132                         return 1;\r
1133                 case STEP_WRITE_LENGTH:\r
1134                         printk(KERN_INFO"STEP3:Write total update file length!\n");\r
1135                         file_len = update_get_flen(update_path);\r
1136                         if(file_len <= 0)\r
1137                         {\r
1138                                 printk(KERN_INFO"get update file length failed!\n");\r
1139                                 return -1;\r
1140                         }\r
1141                         file_len += 4;\r
1142                         i2c_data_buf[1] = (file_len>>24) & 0xff;\r
1143                         i2c_data_buf[2] = (file_len>>16) & 0xff;\r
1144                         i2c_data_buf[3] = (file_len>>8) & 0xff;\r
1145                         i2c_data_buf[4] = file_len & 0xff;\r
1146                         file_len -= 4;\r
1147                         ret = goodix_i2c_write_bytes(ts->client, i2c_data_buf, 5);\r
1148                         if(ret <= 0)\r
1149                         {\r
1150                                 ret = ERROR_I2C_TRANSFER;\r
1151                                 return 0;\r
1152                         }\r
1153                         return 1;\r
1154                 case STEP_WAIT_READY:\r
1155                         printk(KERN_INFO"STEP4:Wait slave ready!\n");\r
1156                         ret = wait_slave_ready(ts, &time_count);\r
1157                         if(ret == ERROR_I2C_TRANSFER)\r
1158                                 return 0;\r
1159                         if(!ret)\r
1160                         {\r
1161                                 return -1;\r
1162                         }\r
1163                         printk(KERN_INFO"Slave ready!\n");\r
1164                         return 1;\r
1165                 case STEP_WRITE_DATA:\r
1166 #ifdef UPDATE_NEW_PROTOCOL\r
1167                         printk(KERN_INFO"STEP5:Begin to send file data use NEW protocol!\n");\r
1168                         file_data = update_file_open(update_path, &old_fs);\r
1169                         if(file_data == NULL)\r
1170                         {\r
1171                                 return -1;\r
1172                         }\r
1173                         frame_number = 0;\r
1174                         while(file_len >= 0)\r
1175                         {\r
1176                                 i2c_data_buf[0] = ADDR_DAT;\r
1177                                 rd_len = (file_len >= PACK_SIZE) ? PACK_SIZE : file_len;\r
1178                                 frame_checksum = 0;\r
1179                                 if(file_len)\r
1180                                 {\r
1181                                         ret = file_data->f_op->read(file_data, i2c_data_buf+1+4, rd_len, &file_data->f_pos);\r
1182                                         if(ret <= 0)\r
1183                                         {\r
1184                                                 printk("[GOODiX_ISP_NEW]:Read File Data Failed!\n");\r
1185                                                 return -1;\r
1186                                         }\r
1187                                         i2c_data_buf[1] = (frame_number>>24)&0xff;\r
1188                                         i2c_data_buf[2] = (frame_number>>16)&0xff;\r
1189                                         i2c_data_buf[3] = (frame_number>>8)&0xff;\r
1190                                         i2c_data_buf[4] = frame_number&0xff;\r
1191                                         frame_number++;\r
1192                                         frame_checksum = 0;\r
1193                                         for(i=0; i<rd_len; i++)\r
1194                                         {\r
1195                                                 frame_checksum += i2c_data_buf[5+i];\r
1196                                         }\r
1197                                         frame_checksum = 0 - frame_checksum;\r
1198                                         i2c_data_buf[5+rd_len+0] = frame_checksum&0xff;\r
1199                                         i2c_data_buf[5+rd_len+1] = (frame_checksum>>8)&0xff;\r
1200                                         i2c_data_buf[5+rd_len+2] = (frame_checksum>>16)&0xff;\r
1201                                         i2c_data_buf[5+rd_len+3] = (frame_checksum>>24)&0xff;\r
1202                                 }\r
1203 rewrite:\r
1204                                 printk(KERN_INFO"[GOODiX_ISP_NEW]:%d\n", file_len);                             \r
1205                                 ret = goodix_i2c_write_bytes(ts->client, i2c_data_buf, 1+4+rd_len+4);\r
1206                                         //if(ret <= 0)\r
1207                                 if(ret != 1)\r
1208                                 {\r
1209                                         printk("[GOODiX_ISP_NEW]:Write File Data Failed!Return:%d\n", ret);\r
1210                                         return 0;\r
1211                                 }\r
1212 \r
1213                                 memset(i2c_rd_buf, 0x00, 1+4+rd_len+4);\r
1214                                 ret = goodix_i2c_read_bytes(ts->client, i2c_rd_buf, 1+4+rd_len+4);\r
1215                                 if(ret != 2)\r
1216                                 {\r
1217                                         printk("[GOODiX_ISP_NEW]:Read File Data Failed!Return:%d\n", ret);\r
1218                                         return 0;\r
1219                                 }\r
1220                                 for(i=1; i<(1+4+rd_len+4); i++)                                         //check communication\r
1221                                 {\r
1222                                         if(i2c_rd_buf[i] != i2c_data_buf[i])\r
1223                                         {\r
1224                                                 i = 0;\r
1225                                                 break;\r
1226                                         }\r
1227                                 }\r
1228                                 if(!i)\r
1229                                 {\r
1230                                         i2c_control_buf[0] = ADDR_CMD;\r
1231                                         i2c_control_buf[1] = 0x03;\r
1232                                         goodix_i2c_write_bytes(ts->client, i2c_control_buf, 2);         //communication error\r
1233                                         printk("[GOODiX_ISP_NEW]:File Data Frame readback check Error!\n");\r
1234                                 }\r
1235                                 else\r
1236                                 {\r
1237                                         i2c_control_buf[1] = 0x04;                                                                                                      //let LDROM write flash\r
1238                                         goodix_i2c_write_bytes(ts->client, i2c_control_buf, 2);\r
1239                                 }\r
1240                                 \r
1241                                 //Wait for slave ready signal.and read the checksum\r
1242                                 ret = wait_slave_ready(ts, &time_count);\r
1243                                 if((ret & CHECKSUM_ERROR)||(!i))\r
1244                                 {\r
1245                                         if(i)\r
1246                                         {\r
1247                                                 printk("[GOODiX_ISP_NEW]:File Data Frame checksum Error!\n");\r
1248                                         }\r
1249                                         checksum_error_times++;\r
1250                                         msleep(20);\r
1251                                         if(checksum_error_times > 20)                           //max retry times.\r
1252                                                 return 0;\r
1253                                         goto rewrite;\r
1254                                 }\r
1255                                 checksum_error_times = 0;\r
1256                                 if(ret & (FRAME_ERROR))\r
1257                                 {\r
1258                                         printk("[GOODiX_ISP_NEW]:File Data Frame Miss!\n");\r
1259                                         return 0;\r
1260                                 }\r
1261                                 if(ret == ERROR_I2C_TRANSFER)\r
1262                                         return 0;\r
1263                                 if(!ret)\r
1264                                 {\r
1265                                         return -1;\r
1266                                 }\r
1267                                 if(file_len < PACK_SIZE)\r
1268                                 {\r
1269                                         update_file_close(file_data, old_fs);\r
1270                                         break;\r
1271                                 }\r
1272                                 file_len -= rd_len;\r
1273                         }//end of while((file_len >= 0))\r
1274                         return 1;\r
1275 #else\r
1276                         printk(KERN_INFO"STEP5:Begin to send file data use OLD protocol!\n");\r
1277                         file_data = update_file_open(update_path, &old_fs);\r
1278                         if(file_data == NULL)   //file_data has been opened at the last time\r
1279                         {\r
1280                                 return -1;\r
1281                         }\r
1282                         while((file_len >= 0) && (!send_crc))\r
1283                         {\r
1284                                 printk(KERN_INFO"[GOODiX_ISP_OLD]:%d\n", file_len);\r
1285                                 i2c_data_buf[0] = ADDR_DAT;\r
1286                                 rd_len = (file_len >= PACK_SIZE) ? PACK_SIZE : file_len;\r
1287                                 if(file_len)\r
1288                                 {\r
1289                                         ret = file_data->f_op->read(file_data, i2c_data_buf+1, rd_len, &file_data->f_pos);\r
1290                                         if(ret <= 0)\r
1291                                         {\r
1292                                                 return -1;\r
1293                                         }\r
1294                                 }\r
1295                                 if(file_len < PACK_SIZE)\r
1296                                 {\r
1297                                         send_crc = 1;\r
1298                                         update_file_close(file_data, old_fs);\r
1299                                         i2c_data_buf[file_len+1] = oldcrc32&0xff;\r
1300                                         i2c_data_buf[file_len+2] = (oldcrc32>>8)&0xff;\r
1301                                         i2c_data_buf[file_len+3] = (oldcrc32>>16)&0xff;\r
1302                                         i2c_data_buf[file_len+4] = (oldcrc32>>24)&0xff;\r
1303                                         ret = goodix_i2c_write_bytes(ts->client, i2c_data_buf, (file_len+1+4));\r
1304                                         //if(ret <= 0)\r
1305                                         if(ret != 1)\r
1306                                         {\r
1307                                                 printk("[GOODiX_ISP_OLD]:Write File Data Failed!Return:%d\n", ret);\r
1308                                                 return 0;\r
1309                                         }\r
1310                                         break;\r
1311                                 }\r
1312                                 else\r
1313                                 {\r
1314                                         ret = goodix_i2c_write_bytes(ts->client, i2c_data_buf, PACK_SIZE+1);\r
1315                                         //if(ret <= 0)\r
1316                                         if(ret != 1)\r
1317                                         {\r
1318                                                 printk("[GOODiX_ISP_OLD]:Write File Data Failed!Return:%d\n", ret);\r
1319                                                 return 0;\r
1320                                         }\r
1321                                 }\r
1322                                 file_len -= rd_len;\r
1323                         \r
1324                                 //Wait for slave ready signal.\r
1325                                 ret = wait_slave_ready(ts, &time_count);\r
1326                                 if(ret == ERROR_I2C_TRANSFER)\r
1327                                         return 0;\r
1328                                 if(!ret)\r
1329                                 {\r
1330                                         return -1;\r
1331                                 }\r
1332                                 //Slave is ready.\r
1333                         }//end of while((file_len >= 0) && (!send_crc))\r
1334                         return 1;\r
1335 #endif\r
1336                 case STEP_READ_STATUS:\r
1337                         printk(KERN_INFO"STEP6:Read update status!\n");\r
1338                         while(time_count < MAX_TIMEOUT)\r
1339                         {\r
1340                                 ret = goodix_i2c_read_bytes(ts->client, i2c_states_buf, 2);\r
1341                                 if(ret <= 0)\r
1342                                 {\r
1343                                         return 0;\r
1344                                 }\r
1345                                 if(i2c_states_buf[1] & SLAVE_READY)\r
1346                                 {\r
1347                                         if(!(i2c_states_buf[1] &0xf0))\r
1348                                         {\r
1349                                                 printk(KERN_INFO"The firmware updating succeed!update state:0x%x\n",i2c_states_buf[1]);\r
1350                                                 return 1;\r
1351                                         }\r
1352                                         else\r
1353                                         {\r
1354                                                 printk(KERN_INFO"The firmware updating failed!update state:0x%x\n",i2c_states_buf[1]);\r
1355                                                 return 0;\r
1356 \r
1357                                         }\r
1358                                 }\r
1359                                 msleep(1);\r
1360                                 time_count += 5;\r
1361                         }\r
1362                         return -1;\r
1363                 case FUN_CLR_VAL:                                                               //clear the static val\r
1364                         time_count = 0;\r
1365                         file_len = 0;\r
1366                         update_need_config = 0;\r
1367                         return 1;\r
1368                 case FUN_CMD:                                                   //functional command\r
1369                         if(cmd[1] == CMD_DISABLE_TP)\r
1370                         {\r
1371                                 printk(KERN_INFO"Disable TS int!\n");\r
1372                                 g_enter_isp = 1;\r
1373                                 disable_irq(ts->irq);\r
1374                         }\r
1375                         else if(cmd[1] == CMD_ENABLE_TP)\r
1376                         {\r
1377                                 printk(KERN_INFO"Enable TS int!\n");\r
1378                                 g_enter_isp = 0;\r
1379                                 enable_irq(ts->irq);\r
1380                         }\r
1381                         else if(cmd[1] == CMD_READ_VER)\r
1382                         {\r
1383                                 printk(KERN_INFO"Read version!\n");\r
1384                                 ts->read_mode = MODE_RD_VER;\r
1385                         }\r
1386                         else if(cmd[1] == CMD_READ_RAW)\r
1387                         {\r
1388                                 printk(KERN_INFO"Read raw data!\n");\r
1389                                 ts->read_mode = MODE_RD_RAW;\r
1390                                 i2c_control_buf[1] = 201;\r
1391                                 ret = goodix_i2c_write_bytes(ts->client, i2c_control_buf, 2);                   //read raw data cmd\r
1392                                 if(ret <= 0)\r
1393                                 {\r
1394                                         printk(KERN_INFO"Write read raw data cmd failed!\n");\r
1395                                         return 0;\r
1396                                 }\r
1397                                 msleep(200);\r
1398                         }\r
1399                         else if(cmd[1] == CMD_READ_DIF)\r
1400                         {\r
1401                                 printk(KERN_INFO"Read diff data!\n");\r
1402                                 ts->read_mode = MODE_RD_DIF;\r
1403                                 i2c_control_buf[1] = 202;\r
1404                                 ret = goodix_i2c_write_bytes(ts->client, i2c_control_buf, 2);                   //read diff data cmd\r
1405                                 if(ret <= 0)\r
1406                                 {\r
1407                                         printk(KERN_INFO"Write read raw data cmd failed!\n");\r
1408                                         return 0;\r
1409                                 }\r
1410                                 msleep(200);\r
1411                         }\r
1412                         else if(cmd[1] == CMD_READ_CFG)\r
1413                         {\r
1414                                 printk(KERN_INFO"Read config info!\n");\r
1415                                 ts->read_mode = MODE_RD_CFG;\r
1416                                 rd_cfg_addr = cmd[2];\r
1417                                 rd_cfg_len = cmd[3];\r
1418                         }\r
1419                         else if(cmd[1] == CMD_SYS_REBOOT)\r
1420                         {\r
1421                                 printk(KERN_INFO"System reboot!\n");\r
1422                                 sys_sync();\r
1423                                 msleep(200);\r
1424                                 kernel_restart(NULL);\r
1425                         }\r
1426                         return 1;\r
1427                 case FUN_WRITE_CONFIG:\r
1428                         \r
1429                         printk(KERN_INFO"Begin write config info!Config length:%d\n",cmd[1]);\r
1430                         for(i=3; i<cmd[1];i++)\r
1431                         {\r
1432                                 //if((i-3)%5 == 0)printk("\n");\r
1433                                 printk("(%d):0x%x ", i-3, cmd[i]);\r
1434                         }\r
1435                         printk("\n");\r
1436 \r
1437                         if((cmd[2]>83)&&(cmd[2]<240)&&cmd[1])\r
1438                         {\r
1439                                 checksum_error_times = 0;\r
1440 reconfig:\r
1441                                 ret = goodix_i2c_write_bytes(ts->client, cmd+2, cmd[1]); \r
1442                                 if(ret != 1)\r
1443                                 {\r
1444                                         printk("Write Config failed!return:%d\n",ret);\r
1445                                         return -1;\r
1446                                 }\r
1447                                 if(!update_need_config)return 1;\r
1448                                 \r
1449                                 i2c_rd_buf[0] = cmd[2];\r
1450                                 ret = goodix_i2c_read_bytes(ts->client, i2c_rd_buf, cmd[1]);\r
1451                                 if(ret != 2)\r
1452                                 {\r
1453                                         printk("Read Config failed!return:%d\n",ret);\r
1454                                         return -1;\r
1455                                 }\r
1456                                 for(i=0; i<cmd[1]; i++)\r
1457                                 {\r
1458                                         if(i2c_rd_buf[i] != cmd[i+2])\r
1459                                         {\r
1460                                                 printk("Config readback check failed!\n");\r
1461                                                 i = 0;\r
1462                                                 break;\r
1463                                         }\r
1464                                 }\r
1465                                 if(!i)\r
1466                                 {\r
1467                                         i2c_control_buf[0] = ADDR_CMD;\r
1468                                         i2c_control_buf[1] = 0x03;\r
1469                                         goodix_i2c_write_bytes(ts->client, i2c_control_buf, 2);         //communication error\r
1470                                         checksum_error_times++;\r
1471                                         msleep(20);\r
1472                                         if(checksum_error_times > 20)                           //max retry times.\r
1473                                                 return 0;\r
1474                                         goto reconfig;\r
1475                                 }\r
1476                                 else\r
1477                                 {\r
1478                                         i2c_control_buf[0] = ADDR_CMD;\r
1479                                         i2c_control_buf[1] = 0x04;                                      //let LDROM write flash\r
1480                                         goodix_i2c_write_bytes(ts->client, i2c_control_buf, 2);\r
1481                                         return 1;\r
1482                                 }\r
1483                                 \r
1484                         }\r
1485                         else\r
1486                         {\r
1487                                 printk(KERN_INFO"Invalid config addr!\n");\r
1488                                 return -1;\r
1489                         }\r
1490                 default:\r
1491                         return -ENOSYS;\r
1492         }\r
1493         return 0;\r
1494 }\r
1495 \r
1496 static int goodix_update_read( char *page, char **start, off_t off, int count, int *eof, void *data )\r
1497 {\r
1498         int ret = -1;\r
1499         struct rk_ts_data *ts;\r
1500         int len = 0;\r
1501         char *version_info = NULL;\r
1502         static unsigned char read_data[1201] = {80, };\r
1503 \r
1504         ts = i2c_get_clientdata(i2c_connect_client);\r
1505         if(ts==NULL)\r
1506                 return 0;\r
1507 \r
1508         if(ts->read_mode == MODE_RD_VER)                //read version data\r
1509         {\r
1510                 ret = goodix_read_version(ts, &version_info);\r
1511                 if(ret <= 0)\r
1512                 {\r
1513                         printk(KERN_INFO"Read version data failed!\n");\r
1514                         vfree(version_info);\r
1515                         return 0;\r
1516                 }\r
1517 \r
1518                 for(len=0;len<100;len++)\r
1519                 {\r
1520                         if(*(version_info + len) == '\0')\r
1521                                 break;\r
1522                 }\r
1523                 printk(KERN_INFO"GOODiX Touchscreen Version is:%s\n", (version_info+1));\r
1524                 strncpy(page, version_info+1, len + 1);\r
1525                 vfree(version_info);\r
1526                 *eof = 1;\r
1527                 return len+1;\r
1528         }\r
1529         else if((ts->read_mode == MODE_RD_RAW)||(ts->read_mode == MODE_RD_DIF))         //read raw data or diff\r
1530         {\r
1531                 //printk(KERN_INFO"Read raw data\n");\r
1532                 ret = goodix_i2c_read_bytes(ts->client, read_data, 1201);\r
1533                 if(ret <= 0)\r
1534                 {\r
1535                         if(ts->read_mode == 2)\r
1536                                 printk(KERN_INFO"Read raw data failed!\n");\r
1537                         if(ts->read_mode == 3)\r
1538                                 printk(KERN_INFO"Read diff data failed!\n");\r
1539                         return 0;\r
1540                 }\r
1541                 memcpy(page, read_data+1, 1200);\r
1542                 *eof = 1;\r
1543                 *start = NULL;\r
1544                 return 1200;\r
1545         }\r
1546         else if(ts->read_mode == MODE_RD_CFG)\r
1547         {\r
1548                 if((rd_cfg_addr>83)&&(rd_cfg_addr<240))\r
1549                 {\r
1550                         read_data[0] = rd_cfg_addr;\r
1551                         printk("read config addr is:%d\n", rd_cfg_addr);\r
1552                 }\r
1553                 else\r
1554                 {\r
1555                         read_data[0] = 101;\r
1556                         printk("invalid read config addr,use default!\n");\r
1557                 }\r
1558                 if((rd_cfg_len<0)||(rd_cfg_len>156))\r
1559                 {\r
1560                         printk("invalid read config length,use default!\n");\r
1561                         rd_cfg_len = 239 - read_data[0];\r
1562                 }\r
1563                 printk("read config length is:%d\n", rd_cfg_len);\r
1564                 ret = goodix_i2c_read_bytes(ts->client, read_data, rd_cfg_len);\r
1565                 if(ret <= 0)\r
1566                 {\r
1567                         printk(KERN_INFO"Read config info failed!\n");\r
1568                         return 0;\r
1569                 }\r
1570                 memcpy(page, read_data+1, rd_cfg_len);\r
1571                 return rd_cfg_len;\r
1572         }\r
1573         return len;\r
1574 }\r
1575               \r
1576 #endif\r
1577 //******************************End of firmware update surpport*******************************\r
1578 static const struct i2c_device_id goodix_ts_id[] = {\r
1579         { "Goodix-TS", 0 },\r
1580         { }\r
1581 };\r
1582 \r
1583 static struct of_device_id goodix_ts_dt_ids[] = {\r
1584         { .compatible = "goodix,gt8xx" },\r
1585         { }\r
1586 };\r
1587 \r
1588 static struct i2c_driver rk_ts_driver = {\r
1589         .probe          = rk_ts_probe,\r
1590         .remove         = rk_ts_remove,\r
1591         .shutdown       = rk_ts_shutdown,\r
1592         .id_table       = goodix_ts_id,\r
1593         .driver = {\r
1594                 .name   = "Goodix-TS",\r
1595                 .owner = THIS_MODULE,\r
1596                 .of_match_table = of_match_ptr(goodix_ts_dt_ids),\r
1597         },\r
1598 };\r
1599 \r
1600 \r
1601 static struct class *ts_debug_class = NULL;\r
1602 static ssize_t dbg_mode_show(struct class *cls,struct class_attribute *attr, char *_buf)\r
1603 {\r
1604        printk("%s>>>>>>>>\n",__func__);\r
1605        return 0;\r
1606 }\r
1607 \r
1608 static ssize_t dbg_mode_store(struct class *cls,struct class_attribute *attr, const char *buf, size_t _count)\r
1609 {\r
1610         dbg_thresd = simple_strtol(buf,NULL,10);\r
1611         if(dbg_thresd)\r
1612         {\r
1613                 printk(KERN_INFO "ts debug open\n");\r
1614         }\r
1615         else\r
1616         {\r
1617                 printk(KERN_INFO "ts debug close");\r
1618         }\r
1619       \r
1620     return _count;\r
1621 }\r
1622 static CLASS_ATTR(debug, 0664, dbg_mode_show, dbg_mode_store);\r
1623 \r
1624 static int dbg_sys_init(void)\r
1625 {\r
1626         int ret ;\r
1627         ts_debug_class = class_create(THIS_MODULE, "ts_debug");\r
1628         ret =  class_create_file(ts_debug_class, &class_attr_debug);\r
1629     if (ret)\r
1630     {\r
1631        printk("Fail to creat class hkrkfb.\n");\r
1632     }\r
1633    return 0;\r
1634 }\r
1635 \r
1636 \r
1637 /*******************************************************        \r
1638 Description:\r
1639         Driver Install function.\r
1640 return:\r
1641         Executive Outcomes. 0---succeed.\r
1642 ********************************************************/\r
1643 \r
1644 static void __init rk_ts_init_async(void *unused, async_cookie_t cookie)\r
1645 {\r
1646         i2c_add_driver(&rk_ts_driver);\r
1647         dbg_sys_init();  //for debug\r
1648 }\r
1649 \r
1650 static int __init rk_ts_init(void)\r
1651 {\r
1652         async_schedule(rk_ts_init_async, NULL);\r
1653         return 0;\r
1654 }\r
1655 \r
1656 /*******************************************************        \r
1657 Description:\r
1658         Driver uninstall function.\r
1659 return:\r
1660         Executive Outcomes. 0---succeed.\r
1661 ********************************************************/\r
1662 static void __exit rk_ts_exit(void)\r
1663 {\r
1664         printk(KERN_ALERT "Touchscreen driver of guitar exited.\n");\r
1665         i2c_del_driver(&rk_ts_driver);\r
1666 }\r
1667 \r
1668 module_init(rk_ts_init);\r
1669 module_exit(rk_ts_exit);\r
1670 \r
1671 MODULE_DESCRIPTION("Goodix Touchscreen Driver");\r
1672 MODULE_LICENSE("GPL");\r