drivers/input/touchscreen/gt819.c

   1 /* drivers/input/touchscreen/goodix_touch.c
   2  *
   3  * Copyright (C) 2010 - 2011 Goodix, Inc.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  *
  15  */
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/time.h>
  19 #include <linux/delay.h>
  20 #include <linux/device.h>
  21 #include <linux/earlysuspend.h>
  22 #include <linux/hrtimer.h>
  23 #include <linux/i2c.h>
  24 #include <linux/input.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/io.h>
  27 #include <linux/platform_device.h>
  28 #include <mach/gpio.h>
  29 #include <linux/irq.h>
  30 #include <linux/syscalls.h>
  31 #include <linux/reboot.h>
  32 #include <linux/proc_fs.h>
  33 #include <linux/vmalloc.h>
  34 #include <linux/fs.h>
  35 #include <linux/string.h>
  36 #include <linux/completion.h>
  37 #include <asm/uaccess.h>
  38 #include <mach/board.h>
  39 #include <linux/reboot.h>
  40
  41 #define GOODIX_I2C_NAME "Goodix-TS"
  42 //define default resolution of the touchscreen
  43 #define GOODIX_MULTI_TOUCH
  44 #define GT819_IIC_SPEED              400*1000    //400*1000
  45 #define TOUCH_MAX_WIDTH              800
  46 #define TOUCH_MAX_HEIGHT             480
  47 #define TOUCH_MAJOR_MAX              200
  48 #define WIDTH_MAJOR_MAX              200
  49 #define MAX_POINT                    5
  50 #define INT_TRIGGER_EDGE_RISING      0
  51 #define INT_TRIGGER_EDGE_FALLING     1
  52 #define INT_TRIGGER_EDGE_LOW         2
  53 #define INT_TRIGGER_EDGE_HIGH        3
  54 #define INT_TRIGGER                  INT_TRIGGER_EDGE_FALLING
  55 #define I2C_DELAY                    0x0f
  56
  57 #define PACK_SIZE                    64                                 //update file package size
  58 #define MAX_TIMEOUT                  60000                              //update time out conut
  59 #define MAX_I2C_RETRIES              20                                 //i2c retry times
  60
  61 //I2C buf address
  62 #define ADDR_CMD                     80
  63 #define ADDR_STA                     81
  64 #define ADDR_DAT                     0
  65 //moudle state
  66 #define NEW_UPDATE_START                        0x01
  67 #define UPDATE_START                            0x02
  68 #define SLAVE_READY                                     0x08
  69 #define UNKNOWN_ERROR                           0x00
  70 #define FRAME_ERROR                                     0x10
  71 #define CHECKSUM_ERROR                          0x20
  72 #define TRANSLATE_ERROR                         0x40
  73 #define FLASH_ERROR                                     0X80
  74 //error no
  75 #define ERROR_NO_FILE                           2       //ENOENT
  76 #define ERROR_FILE_READ                         23      //ENFILE
  77 #define ERROR_FILE_TYPE                         21      //EISDIR
  78 #define ERROR_GPIO_REQUEST                      4       //EINTR
  79 #define ERROR_I2C_TRANSFER                      5       //EIO
  80 #define ERROR_NO_RESPONSE                       16      //EBUSY
  81 #define ERROR_TIMEOUT                           110     //ETIMEDOUT
  82
  83 struct goodix_ts_data {
  84         struct workqueue_struct *goodix_wq;
  85         struct i2c_client *client;
  86         struct input_dev *input_dev;
  87         struct work_struct  work;
  88         int irq;
  89         int irq_gpio;
  90         uint16_t abs_x_max;
  91         uint16_t abs_y_max;
  92         uint8_t max_touch_num;
  93         uint8_t int_trigger_type;
  94 };
  95
  96 static const char *goodix_ts_name = "Goodix Capacitive TouchScreen";
  97 unsigned int crc32_table[256];
  98 unsigned int oldcrc32 = 0xFFFFFFFF;
  99 unsigned int ulPolynomial = 0x04c11db7;
 100 struct i2c_client * i2c_connect_client = NULL;
 101 static struct early_suspend gt819_power;
 102 static u8 gt819_fw[]=
 103 {
 104 #include "gt819_fw.i"
 105 };
 106 #if 0
 107 uint8_t config_info[] = {
 108 0x02,(TOUCH_MAX_WIDTH>>8),(TOUCH_MAX_WIDTH&0xff),
 109 (TOUCH_MAX_HEIGHT>>8),(TOUCH_MAX_HEIGHT&0xff),MAX_POINT,(0xa0 | INT_TRIGGER),
 110 0x20,0x00,0x00,0x0f,0x20,0x08,0x14,0x00,
 111 0x00,0x20,0x00,0x00,0x88,0x88,0x88,0x00,0x37,0x00,0x00,0x00,0x01,0x02,0x03,0x04,
 112 0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0xff,0xff,0x00,0x01,0x02,0x03,0x04,
 113 0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0xff,0xff,0xff,0x00,0x00,0x3c,0x64,0x00,
 114 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 115 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40
 116 };
 117 #else
 118 static u8 config_info[]=
 119 {
 120 #include "gt819.cfg"
 121 };
 122 #endif
 123 static int gt819_read_regs(struct i2c_client *client, u8 reg, u8 buf[], unsigned len)
 124 {
 125         int ret;
 126         ret = i2c_master_reg8_recv(client, reg, buf, len, GT819_IIC_SPEED);
 127         if(ret>0)
 128                 return ret;
 129         ret = i2c_master_reg8_recv(client, reg, buf, len, GT819_IIC_SPEED);
 130         if(ret>0)
 131                 return ret;
 132         ret = i2c_master_reg8_recv(client, reg, buf, len, GT819_IIC_SPEED);
 133         if(ret>0)
 134                 return ret;
 135         ret = i2c_master_reg8_recv(client, reg, buf, len, GT819_IIC_SPEED);
 136         if(ret>0)
 137                 return ret;
 138         ret = i2c_master_reg8_recv(client, reg, buf, len, GT819_IIC_SPEED);
 139         return ret;
 140 }
 141
 142
 143 static int gt819_set_regs(struct i2c_client *client, u8 reg, u8 const buf[], unsigned short len)
 144 {
 145         int ret;
 146         ret = i2c_master_reg8_send(client, reg, buf, (int)len, GT819_IIC_SPEED);
 147         if(ret>0)
 148                 return ret;
 149         ret = i2c_master_reg8_send(client, reg, buf, (int)len, GT819_IIC_SPEED);
 150         if(ret>0)
 151                 return ret;
 152         ret = i2c_master_reg8_send(client, reg, buf, (int)len, GT819_IIC_SPEED);
 153         if(ret>0)
 154                 return ret;
 155         ret = i2c_master_reg8_send(client, reg, buf, (int)len, GT819_IIC_SPEED);
 156         if(ret>0)
 157                 return ret;
 158         ret = i2c_master_reg8_send(client, reg, buf, (int)len, GT819_IIC_SPEED);
 159         return ret;
 160 }
 161
 162 int gt819_printf(char *buf, int len)
 163 {
 164         int x, y, row = len/8,mod = len%8;
 165         for (y=0; y<row; y++) {
 166                 for (x=0; x<8; x++) {
 167                         printk("0x%02x, ",buf[y*8+x]);
 168                 }
 169                 printk("\n");
 170         }
 171         for (x=0; x<mod; x++) {
 172                 printk("0x%02x, ",buf[row*8+x]);
 173         }
 174         printk("\n");
 175         return 0;
 176 }
 177
 178 int gt189_wait_for_slave(struct i2c_client *client, u8 status)
 179 {
 180         unsigned char i2c_state_buf[2];
 181         int ret,i = 0;
 182         while(i < MAX_I2C_RETRIES)
 183         {
 184                 ret = gt819_read_regs(client,ADDR_STA, i2c_state_buf, 1);
 185                 printk("i2c read state byte:0x%x\n",i2c_state_buf[0]);
 186                 if(ret < 0)
 187                         return ERROR_I2C_TRANSFER;
 188                 if(i2c_state_buf[0]==0xff)continue;
 189                 if(i2c_state_buf[0] & status)
 190                         return i2c_state_buf[0];
 191                 msleep(10);
 192                 i++;
 193         }
 194         return -ERROR_TIMEOUT;
 195 }
 196
 197 int gt819_update_write_config(struct i2c_client *client)
 198         {
 199                 int ret,len = sizeof(config_info)-1;                    //byte[0] is the reg addr in the gt819.cfg
 200                 u8 cfg_rd_buf[len];
 201                 u8 cfg_cmd_buf = 0x03;
 202                 u8 retries = 0;
 203
 204         reconfig:
 205                 ret = gt819_set_regs(client, 101, &config_info[1], len);
 206                 if(ret < 0)
 207                         return ret;
 208                 gt819_printf(config_info, len);
 209                 ret = gt819_read_regs(client, 101, cfg_rd_buf, len);
 210                 if(ret < 0)
 211                         return ret;
 212                 if(memcmp(cfg_rd_buf, &config_info[1], len))
 213                 {
 214                         dev_info(&client->dev, "config info check error!\n");
 215                         if(retries < 5)
 216                         {
 217                                 retries++;
 218                                 ret = gt819_set_regs(client, ADDR_CMD, &cfg_cmd_buf, 1);
 219                                 if(ret < 0)
 220                                         return ret;
 221                                 goto reconfig;
 222                         }
 223                         return -1;
 224                 }
 225                 cfg_cmd_buf = 0x04;
 226                 ret = gt819_set_regs(client, ADDR_CMD, &cfg_cmd_buf, 1);
 227                 if(ret < 0)
 228                         return ret;
 229                 return 0;
 230         }
 231
 232
 233 static int  gt819_read_version(struct i2c_client *client,char *version)
 234 {
 235         int ret, count = 0;
 236         char *p;
 237
 238         ret = gt819_read_regs(client,240, version, 16);
 239         if (ret < 0)
 240                 return ret;
 241         version[16]='\0';
 242         p = version;
 243         do
 244         {
 245                 if((*p > 122) || (*p < 48 && *p != 32) || (*p >57 && *p  < 65)
 246                         ||(*p > 90 && *p < 97 && *p  != '_'))           //check illeqal character
 247                         count++;
 248         }while(*++p != '\0' );
 249         if(count > 2)
 250                 return -1;
 251         dev_info(&client->dev, "fw version is %s\n",version);
 252         return ret;
 253 }
 254
 255 int gt819_update_write_fw(struct i2c_client *client, char *fw_buf, int len)
 256 {
 257         int ret,data_len,i,check_len,frame_checksum,frame_number = 0;
 258         unsigned char *p,i2c_data_buf[PACK_SIZE+8];
 259         u8 i2c_rd_buf[PACK_SIZE+8];
 260
 261         u8 retries = 0;
 262         u8 check_state = 0;
 263
 264         if(!client || !fw_buf)
 265                 return -1;
 266
 267         while(len){
 268                 frame_checksum = 0;
 269                 retries = 0;
 270                 check_len = (len >= PACK_SIZE) ? PACK_SIZE : len;
 271                 data_len = check_len+8;
 272                 dev_info(&client->dev, "PACK[%d]:prepare data,remained len = %d\n",frame_number,len);
 273                 p = &fw_buf[frame_number*PACK_SIZE];
 274                 for(i=0; i<check_len; i++)
 275                         frame_checksum += *p++;
 276                 frame_checksum = 0 - frame_checksum;
 277                 p = i2c_data_buf;
 278                 *p++ = (frame_number>>24)&0xff;
 279                 *p++ = (frame_number>>16)&0xff;
 280                 *p++ = (frame_number>>8)&0xff;
 281                 *p++ = frame_number&0xff;
 282                 memcpy(p, &fw_buf[frame_number*PACK_SIZE],check_len);
 283                 p += check_len;
 284                 *p++ = frame_checksum&0xff;
 285                 *p++ = (frame_checksum>>8)&0xff;
 286                 *p++ = (frame_checksum>>16)&0xff;
 287                 *p++ = (frame_checksum>>24)&0xff;
 288                 //gt819_printf(i2c_data_buf, data_len);
 289                 dev_info(&client->dev, "PACK[%d]:write to slave\n",frame_number);
 290 resend:
 291                 ret = gt819_set_regs(client,ADDR_DAT, i2c_data_buf, data_len);
 292                 if(ret < 0)
 293                         return ret;
 294                 //gt819_printf(i2c_data_buf, data_len);
 295                 msleep(10);
 296                 dev_info(&client->dev, "PACK[%d]:read data\n",frame_number);
 297                 memset(i2c_rd_buf, 0, sizeof(i2c_rd_buf));
 298                 ret = gt819_read_regs(client,ADDR_DAT, i2c_rd_buf, data_len);
 299                 if(ret < 0)
 300                         return ret;
 301                 //gt819_printf(i2c_data_buf, data_len);
 302                 msleep(10);
 303                 dev_info(&client->dev, "PACK[%d]:check data\n",frame_number);
 304                 if(memcmp(&i2c_rd_buf[4],&fw_buf[frame_number*PACK_SIZE],check_len))
 305                 {
 306             dev_info(&client->dev, "PACK[%d]:File Data Frame readback check Error!\n",frame_number);
 307                     i2c_rd_buf[0] = 0x03;
 308                         ret = gt819_set_regs(client, ADDR_CMD, i2c_rd_buf, 1);
 309                         if(ret < 0)
 310                             return ret;
 311                         check_state = 0x01;
 312                 }
 313                 else
 314                 {
 315                 dev_info(&client->dev, "PACK[%d]:tell slave check data pass\n",frame_number);
 316                 i2c_rd_buf[0] = 0x04;
 317                 ret = gt819_set_regs(client,ADDR_CMD, i2c_rd_buf, 1);
 318                 if(ret < 0)
 319                         return ret;
 320                 dev_info(&client->dev, "PACK[%d]:wait for slave to start next frame\n",frame_number);
 321                 }
 322
 323                 ret = gt189_wait_for_slave(client, SLAVE_READY);
 324                 if((ret & CHECKSUM_ERROR) || (ret & FRAME_ERROR) || (ret == ERROR_I2C_TRANSFER) || (ret < 0) || (check_state == 0x01))
 325                 {
 326
 327                         if(((ret & CHECKSUM_ERROR) || (ret & FRAME_ERROR) || (check_state == 0x01))&&(retries < 5))
 328                         {
 329                                 if(check_state != 0x01)
 330                                 {
 331                                     printk("checksum error or miss frame error!\n");
 332                                 }
 333                                 check_state = 0x00;
 334                                 retries++;
 335                                 msleep(20);
 336                                 goto resend;
 337                         }
 338                         printk("wait slave return state:%d\n", ret);
 339                         return ret;
 340                 }
 341                 dev_info(&client->dev, "PACK[%d]:frame transfer finished\n",frame_number);
 342                 if(len < PACK_SIZE)
 343                         return 0;
 344                 frame_number++;
 345                 len -= check_len;
 346         }
 347         return 0;
 348 }
 349
 350 int gt819_update_fw(struct i2c_client *client)
 351 {
 352         int ret,file_len,update_need_config;
 353         unsigned char i2c_control_buf[10];
 354         char version[17];
 355         const char version_base[17]={"GT81XNI"};
 356
 357         dev_info(&client->dev, "gt819 firmware update start...\n");
 358         dev_info(&client->dev, "step 1:read version...\n");
 359         ret = gt819_read_version(client,version);
 360         if (ret < 0)
 361                 return ret;
 362         dev_info(&client->dev, "done!\n");
 363         dev_info(&client->dev, "step 2:disable irq...\n");
 364         disable_irq(client->irq);
 365         dev_info(&client->dev, "done!\n");
 366         dev_info(&client->dev, "step 3:set update start...\n");
 367         i2c_control_buf[0] = UPDATE_START;
 368         ret = gt819_set_regs(client,ADDR_CMD, i2c_control_buf, 1);
 369         if(ret < 0)
 370                 return ret;
 371         //the time include time(APROM -> LDROM) and time(LDROM init)
 372         msleep(1000);
 373         dev_info(&client->dev, "done!\n");
 374         dev_info(&client->dev, "step 4:wait for slave start...\n");
 375         ret = gt189_wait_for_slave(client, UPDATE_START);
 376         if(ret < 0)
 377                 return ret;
 378         if(!(ret & UPDATE_START))
 379                 return -1;
 380         if(!(ret & NEW_UPDATE_START))
 381                 update_need_config = 1;
 382         dev_info(&client->dev, "done!\n");
 383         dev_info(&client->dev, "step 5:write the fw length...\n");
 384         file_len = sizeof(gt819_fw) + 4;
 385         dev_info(&client->dev, "file length is:%d\n", file_len);
 386         i2c_control_buf[0] = (file_len>>24) & 0xff;
 387         i2c_control_buf[1] = (file_len>>16) & 0xff;
 388         i2c_control_buf[2] = (file_len>>8) & 0xff;
 389         i2c_control_buf[3] = file_len & 0xff;
 390         ret = gt819_set_regs(client,ADDR_DAT, i2c_control_buf, 4);
 391         if(ret < 0)
 392                 return ret;
 393         dev_info(&client->dev, "done!\n");
 394         dev_info(&client->dev, "step 6:wait for slave ready\n");
 395         ret = gt189_wait_for_slave(client, SLAVE_READY);
 396         if(ret < 0)
 397                 return ret;
 398         dev_info(&client->dev, "done!\n");
 399         dev_info(&client->dev, "step 7:write data\n");
 400         ret = gt819_update_write_fw(client, gt819_fw, sizeof(gt819_fw));
 401         if(ret < 0)
 402                 return ret;
 403         dev_info(&client->dev, "done!\n");
 404         dev_info(&client->dev, "step 8:write config\n");
 405         ret = gt819_update_write_config(client);
 406         if(ret < 0)
 407                 return ret;
 408         dev_info(&client->dev, "done!\n");
 409         dev_info(&client->dev, "step 9:wait for slave ready\n");
 410         ret = gt189_wait_for_slave(client,SLAVE_READY);
 411         if(ret < 0)
 412                 return ret;
 413         if(ret & SLAVE_READY)
 414                 dev_info(&client->dev, "The firmware updating succeed!update state:0x%x\n",ret);
 415         dev_info(&client->dev, "step 10:enable irq...\n");
 416         enable_irq(client->irq);
 417         dev_info(&client->dev, "done!\n");
 418         msleep(1000);                                           //wait slave reset
 419         dev_info(&client->dev, "step 11:read version...\n");
 420         ret = gt819_read_version(client,version);
 421         if (ret < 0)
 422                 return ret;
 423         dev_info(&client->dev, "done!\n");
 424         version[7] = '\0';
 425         if(strcmp(version ,version_base)==0)
 426         {
 427                 sys_sync();
 428                 msleep(200);
 429                 kernel_restart(NULL);
 430         }
 431         return 0;
 432 }
 433
 434
 435 static void gt819_queue_work(struct work_struct *work)
 436 {
 437         struct goodix_ts_data *ts = container_of(work, struct goodix_ts_data, work);
 438         uint8_t  point_data[53]={ 0 };
 439         int ret,i,offset,points;
 440         int points_chect;
 441         int x,y,w;
 442         unsigned int  count = 0;
 443         uint8_t  check_sum = 0;
 444
 445         ret = gt819_read_regs(ts->client,1, point_data, 2);
 446         if (ret < 0) {
 447                 dev_err(&ts->client->dev, "i2c_read_bytes fail:%d!\n",ret);
 448                 enable_irq(ts->irq);
 449                 return;
 450         }
 451         check_sum =point_data[0]+point_data[1];
 452
 453         points = point_data[0] & 0x1f;
 454         //dev_info(&ts->client->dev, "points = %d\n",points);
 455         if (points == 0) {
 456                 input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0);
 457                 input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0);
 458                 //input_mt_sync(data->input_dev);
 459                 input_sync(ts->input_dev);
 460                 enable_irq(ts->irq);
 461                 dev_info(&ts->client->dev, "touch release\n");
 462                 return;
 463         }
 464         for(i=0;0!=points;)
 465         {
 466         if(points&0x01)
 467                 i++;
 468         points>>=1;
 469         }
 470
 471         points = i;
 472         points_chect = points;
 473         ret = gt819_read_regs(ts->client,3, point_data, points*5+1);
 474         if (ret < 0) {
 475                 dev_err(&ts->client->dev, "i2c_read_bytes fail:%d!\n",ret);
 476                 enable_irq(ts->irq);
 477                 return;
 478         }
 479         //add by Nitiion
 480         for(points_chect *= 5; points_chect > 0; points_chect--)
 481                 {
 482                 check_sum += point_data[count++];
 483                 }
 484                 check_sum += point_data[count];
 485         if(check_sum  != 0)                     //checksum verify error
 486                 {
 487                         input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0);
 488                         input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0);
 489                         //input_mt_sync(data->input_dev);
 490                         input_sync(ts->input_dev);
 491                         enable_irq(ts->irq);
 492                         dev_info(&ts->client->dev, "coor checksum error!touch release\n");
 493                         return;
 494                 }
 495
 496         for(i=0;i<points;i++){
 497                 offset = i*5;
 498                 x = (((s16)(point_data[offset+0]))<<8) | ((s16)point_data[offset+1]);
 499                 y = (((s16)(point_data[offset+2]))<<8) | ((s16)point_data[offset+3]);
 500                 w = point_data[offset+4];
 501                 //dev_info(&ts->client->dev, "goodix multiple report event[%d]:x = %d,y = %d,w = %d\n",i,x,y,w);
 502                 if(x<=TOUCH_MAX_WIDTH && y<=TOUCH_MAX_HEIGHT){
 503                         //dev_info(&ts->client->dev, "goodix multiple report event[%d]:x = %d,y = %d,w = %d\n",i,x,y,w);
 504                         input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, w);
 505                         input_report_abs(ts->input_dev, ABS_MT_POSITION_X,  x);
 506                         input_report_abs(ts->input_dev, ABS_MT_POSITION_Y,  y);
 507                         input_report_abs(ts->input_dev, ABS_MT_TRACKING_ID, i);
 508                         input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, w);
 509                         input_mt_sync(ts->input_dev);
 510                 }
 511         }
 512         input_sync(ts->input_dev);
 513         enable_irq(ts->irq);
 514         return;
 515 }
 516
 517 /*******************************************************
 518 Description:
 519         External interrupt service routine.
 520
 521 Parameter:
 522         irq:    interrupt number.
 523         dev_id: private data pointer.
 524
 525 return:
 526         irq execute status.
 527 *******************************************************/
 528 static irqreturn_t gt819_irq_handler(int irq, void *dev_id)
 529 {
 530         struct goodix_ts_data *ts = dev_id;
 531
 532         disable_irq_nosync(ts->client->irq);
 533         queue_work(ts->goodix_wq, &ts->work);
 534         return IRQ_HANDLED;
 535 }
 536
 537 static int gt819_suspend(struct i2c_client *client, pm_message_t mesg)
 538 {
 539         struct goodix_platform_data *pdata = client->dev.platform_data;
 540         dev_info(&client->dev,"gt819_suspend\n");
 541
 542         if (pdata->platform_sleep)
 543                 pdata->platform_sleep();
 544         disable_irq(client->irq);
 545         return 0;
 546 }
 547
 548 static int gt819_resume(struct i2c_client *client)
 549 {
 550         struct goodix_platform_data *pdata = client->dev.platform_data;
 551         dev_info(&client->dev,"gt819_resume\n");
 552
 553         enable_irq(client->irq);
 554         if (pdata->platform_wakeup)
 555                 pdata->platform_wakeup();
 556         return 0;
 557 }
 558
 559 static void gt819_early_suspend(struct early_suspend *h)
 560 {
 561         dev_info(&i2c_connect_client->dev, "gt819_early_suspend!\n");
 562         gt819_suspend(i2c_connect_client,PMSG_SUSPEND);
 563 }
 564
 565 static void gt819_early_resume(struct early_suspend *h)
 566 {
 567         dev_info(&i2c_connect_client->dev, "gt819_resume_early!\n");
 568         gt819_resume(i2c_connect_client);
 569 }
 570
 571 /*******************************************************
 572 Description:
 573         Goodix touchscreen driver release function.
 574
 575 Parameter:
 576         client: i2c device struct.
 577
 578 return:
 579         Executive outcomes. 0---succeed.
 580 *******************************************************/
 581 static int gt819_remove(struct i2c_client *client)
 582 {
 583         struct goodix_ts_data *ts = i2c_get_clientdata(client);
 584 #ifdef CONFIG_TOUCHSCREEN_GOODIX_IAP
 585         remove_proc_entry("goodix-update", NULL);
 586 #endif
 587         //goodix_debug_sysfs_deinit();
 588         gpio_direction_input(ts->irq_gpio);
 589         gpio_free(ts->irq_gpio);
 590         free_irq(client->irq, ts);
 591         if(ts->goodix_wq)
 592                 destroy_workqueue(ts->goodix_wq);
 593         dev_notice(&client->dev,"The driver is removing...\n");
 594         i2c_set_clientdata(client, NULL);
 595         input_unregister_device(ts->input_dev);
 596     unregister_early_suspend(&gt819_power);
 597         i2c_connect_client = 0;
 598         kfree(ts);
 599         return 0;
 600 }
 601
 602 static int gt819_init_panel(struct goodix_ts_data *ts)
 603 {
 604         int ret,I2cDelay;
 605         int len = sizeof(config_info)-1;
 606         uint8_t rd_cfg_buf[10];
 607         struct goodix_platform_data *pdata = ts->client->dev.platform_data;
 608
 609         ret = gt819_set_regs(ts->client, 101, &config_info[1], len);
 610         if(ret < 0)
 611         {
 612                 pdata->platform_sleep();
 613                 msleep(10);
 614                 pdata->platform_wakeup();
 615                 msleep(100);
 616                 printk("First IIC request failed,retry!\n");
 617                 ret = gt819_set_regs(ts->client, 101, &config_info[1], len);
 618                 if(ret<0)
 619                 return ret;
 620         }
 621
 622         ret = gt819_read_regs(ts->client, 101, rd_cfg_buf, 10);
 623         if (ret < 0)
 624                 return ret;
 625         ts->abs_x_max = ((((uint16_t)rd_cfg_buf[1])<<8)|rd_cfg_buf[2]);
 626         ts->abs_y_max = ((((uint16_t)rd_cfg_buf[3])<<8)|rd_cfg_buf[4]);
 627         ts->max_touch_num = rd_cfg_buf[5];
 628         ts->int_trigger_type = rd_cfg_buf[6]&0x03;
 629         I2cDelay = rd_cfg_buf[9]&0x0f;
 630         dev_info(&ts->client->dev,"X_MAX = %d,Y_MAX = %d,MAX_TOUCH_NUM = %d,INT_TRIGGER = %d,I2cDelay = %x\n",
 631                 ts->abs_x_max,ts->abs_y_max,ts->max_touch_num,ts->int_trigger_type,I2cDelay);
 632         if((ts->abs_x_max!=TOUCH_MAX_WIDTH)||(ts->abs_y_max!=TOUCH_MAX_HEIGHT)||
 633                 (MAX_POINT!=ts->max_touch_num)||INT_TRIGGER!=ts->int_trigger_type || I2C_DELAY!=I2cDelay){
 634                 ts->abs_x_max = TOUCH_MAX_WIDTH;
 635                 ts->abs_y_max = TOUCH_MAX_HEIGHT;
 636                 ts->max_touch_num = MAX_POINT;
 637                 ts->int_trigger_type = INT_TRIGGER;
 638                 rd_cfg_buf[1] = ts->abs_x_max>>8;
 639                 rd_cfg_buf[2] = ts->abs_x_max&0xff;
 640                 rd_cfg_buf[3] = ts->abs_y_max>>8;
 641                 rd_cfg_buf[4] = ts->abs_y_max&0xff;
 642                 rd_cfg_buf[5] = ts->max_touch_num;
 643                 rd_cfg_buf[6] = ((rd_cfg_buf[6]&0xfc) | INT_TRIGGER);
 644                 rd_cfg_buf[9] = ((rd_cfg_buf[9]&0xf0) | I2C_DELAY);
 645                 ret = gt819_set_regs(ts->client, 101, rd_cfg_buf, 10);
 646                 if (ret < 0)
 647                         return ret;
 648                 dev_info(&ts->client->dev,"set config\n");
 649         }
 650         return 0;
 651 }
 652
 653 /*******************************************************
 654 Description:
 655         Goodix touchscreen probe function.
 656
 657 Parameter:
 658         client: i2c device struct.
 659         id:device id.
 660
 661 return:
 662         Executive outcomes. 0---succeed.
 663 *******************************************************/
 664 static int gt819_probe(struct i2c_client *client, const struct i2c_device_id *id)
 665 {
 666         int ret = 0;
 667         char version[17];
 668         char version_base[17]={"GT81XNI_1R05_18Q"};
 669         struct goodix_ts_data *ts;
 670         struct goodix_platform_data *pdata = client->dev.platform_data;
 671         const char irq_table[4] = {IRQ_TYPE_EDGE_RISING,
 672                                                            IRQ_TYPE_EDGE_FALLING,
 673                                                            IRQ_TYPE_LEVEL_LOW,
 674                                                            IRQ_TYPE_LEVEL_HIGH};
 675
 676         dev_info(&client->dev,"Install goodix touch driver\n");
 677
 678         if (!pdata) {
 679                 dev_err(&client->dev, "platform data is required!\n");
 680                 return -EINVAL;
 681         }
 682
 683         if (pdata->init_platform_hw)
 684                 pdata->init_platform_hw();
 685
 686         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 687                 dev_err(&client->dev, "Must have I2C_FUNC_I2C.\n");
 688                 return -ENODEV;
 689         }
 690         ts = kzalloc(sizeof(*ts), GFP_KERNEL);
 691         if (ts == NULL) {
 692                 return -ENOMEM;
 693         }
 694
 695         ts->client = i2c_connect_client = client;
 696
 697         ret = gt819_init_panel(ts);
 698         if(ret != 0){
 699           dev_err(&client->dev,"init panel fail,ret = %d\n",ret);
 700           goto err_init_panel_fail;
 701         }
 702
 703         ret = gt819_read_version(client,version);
 704         if((ret>=0) && (strcmp(version ,version_base)!=0)){
 705                 gt819_update_fw(client);
 706         }
 707
 708         if (!client->irq){
 709                 dev_err(&client->dev,"no irq fail\n");
 710                 ret = -ENODEV;
 711                 goto err_no_irq_fail;
 712         }
 713         ts->irq_gpio = client->irq;
 714         ts->irq = client->irq = gpio_to_irq(client->irq);
 715         ret  = request_irq(client->irq, gt819_irq_handler, irq_table[ts->int_trigger_type],client->name, ts);
 716         if (ret != 0) {
 717                 dev_err(&client->dev,"request_irq fail:%d\n", ret);
 718                 goto err_irq_request_fail;
 719         }
 720
 721         ts->goodix_wq = create_workqueue("goodix_wq");
 722         if (!ts->goodix_wq) {
 723                 printk(KERN_ALERT "creat workqueue failed\n");
 724                 ret = -ENOMEM;
 725                 goto err_create_work_queue_fail;
 726         }
 727
 728         INIT_WORK(&ts->work, gt819_queue_work);
 729
 730         ts->input_dev = input_allocate_device();
 731         if (ts->input_dev == NULL) {
 732                 ret = -ENOMEM;
 733                 dev_err(&client->dev,"Failed to allocate input device\n");
 734                 goto err_input_dev_alloc_failed;
 735         }
 736
 737         set_bit(ABS_MT_POSITION_X, ts->input_dev->absbit);
 738         set_bit(ABS_MT_POSITION_Y, ts->input_dev->absbit);
 739         set_bit(ABS_MT_TOUCH_MAJOR, ts->input_dev->absbit);
 740         set_bit(ABS_MT_TRACKING_ID, ts->input_dev->absbit);
 741         set_bit(ABS_MT_WIDTH_MAJOR, ts->input_dev->absbit);
 742         set_bit(EV_ABS, ts->input_dev->evbit);
 743         set_bit(EV_KEY, ts->input_dev->evbit);
 744         input_set_abs_params(ts->input_dev,ABS_MT_POSITION_X, 0, TOUCH_MAX_WIDTH, 0, 0);
 745         input_set_abs_params(ts->input_dev,ABS_MT_POSITION_Y, 0, TOUCH_MAX_HEIGHT, 0, 0);
 746         input_set_abs_params(ts->input_dev,ABS_MT_TOUCH_MAJOR, 0, TOUCH_MAJOR_MAX, 0, 0);
 747         input_set_abs_params(ts->input_dev,ABS_MT_TRACKING_ID, 0, MAX_POINT, 0, 0);
 748         input_set_abs_params(ts->input_dev,ABS_MT_WIDTH_MAJOR, 0, WIDTH_MAJOR_MAX, 0, 0);
 749
 750         ts->input_dev->name = goodix_ts_name;
 751         ret = input_register_device(ts->input_dev);
 752         if (ret) {
 753                 dev_err(&client->dev,"Probe: Unable to register %s input device\n", ts->input_dev->name);
 754                 goto err_input_register_device_failed;
 755         }
 756         i2c_set_clientdata(client, ts);
 757
 758         gt819_power.suspend = gt819_early_suspend;
 759         gt819_power.resume = gt819_early_resume;
 760         gt819_power.level = 0x2;
 761         register_early_suspend(&gt819_power);
 762         return 0;
 763         i2c_set_clientdata(client, NULL);
 764         input_unregister_device(ts->input_dev);
 765 err_input_register_device_failed:
 766         input_free_device(ts->input_dev);
 767 err_input_dev_alloc_failed:
 768         destroy_workqueue(ts->goodix_wq);
 769 err_create_work_queue_fail:
 770         free_irq(client->irq,ts);
 771 err_irq_request_fail:
 772 err_no_irq_fail:
 773 err_init_panel_fail:
 774         if (pdata->exit_platform_hw)
 775                 pdata->exit_platform_hw();
 776         kfree(ts);
 777         return ret;
 778 }
 779
 780
 781
 782 static const struct i2c_device_id gt819_id[] = {
 783         { GOODIX_I2C_NAME, 0 },
 784         { }
 785 };
 786
 787 static struct i2c_driver gt819_driver = {
 788         .probe          = gt819_probe,
 789         .remove         = gt819_remove,
 790         .id_table       = gt819_id,
 791         .driver = {
 792                 .name   = GOODIX_I2C_NAME,
 793                 .owner = THIS_MODULE,
 794         },
 795 };
 796
 797 /*******************************************************
 798 Description:
 799         Driver Install function.
 800 return:
 801         Executive Outcomes. 0---succeed.
 802 ********************************************************/
 803 static int __devinit gt819_init(void)
 804 {
 805         int ret;
 806
 807         ret=i2c_add_driver(&gt819_driver);
 808         return ret;
 809 }
 810
 811 /*******************************************************
 812 Description:
 813         Driver uninstall function.
 814 return:
 815         Executive Outcomes. 0---succeed.
 816 ********************************************************/
 817 static void __exit gt819_exit(void)
 818 {
 819         printk(KERN_ALERT "Touchscreen driver of guitar exited.\n");
 820         i2c_del_driver(&gt819_driver);
 821 }
 822
 823 late_initcall(gt819_init);
 824 module_exit(gt819_exit);
 825
 826 MODULE_DESCRIPTION("Goodix Touchscreen Driver");
 827 MODULE_LICENSE("GPL");