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