drivers/input/touchscreen/gt818_ts.c

   1 /* drivers/input/touchscreen/gt818_ts.c\r
   2  *\r
   3  * Copyright (C) 2011 Rockcip, Inc.\r
   4  * \r
   5  * This software is licensed under the terms of the GNU General Public\r
   6  * License version 2, as published by the Free Software Foundation, and\r
   7  * may be copied, distributed, and modified under those terms.\r
   8  *\r
   9  * This program is distributed in the hope that it will be useful,\r
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  12  * GNU General Public License for more details.\r
  13  *\r
  14  * Author: hhb@rock-chips.com\r
  15  * Date: 2011.06.20\r
  16  */\r
  17 #include <linux/kernel.h>\r
  18 #include <linux/module.h>\r
  19 #include <linux/time.h>\r
  20 #include <linux/delay.h>\r
  21 #include <linux/device.h>\r
  22 #include <linux/earlysuspend.h>\r
  23 #include <linux/hrtimer.h>\r
  24 #include <linux/i2c.h>\r
  25 #include <linux/input.h>\r
  26 #include <linux/interrupt.h>\r
  27 #include <linux/io.h>\r
  28 #include <linux/platform_device.h>\r
  29 \r
  30 #include <linux/gpio.h>\r
  31 #include <mach/iomux.h>\r
  32 \r
  33 #include <linux/irq.h>\r
  34 #include <linux/syscalls.h>\r
  35 #include <linux/reboot.h>\r
  36 #include <linux/proc_fs.h>\r
  37 \r
  38 #include <linux/vmalloc.h>\r
  39 #include <linux/fs.h>\r
  40 #include <linux/string.h>\r
  41 #include <linux/completion.h>\r
  42 #include <asm/uaccess.h>\r
  43 #include <linux/input/mt.h>\r
  44 \r
  45 #include "gt818_ts.h"\r
  46 \r
  47 \r
  48 \r
  49 #if !defined(GT801_PLUS) && !defined(GT801_NUVOTON)\r
  50 #error The code does not match this touchscreen.\r
  51 #endif\r
  52 \r
  53 static struct workqueue_struct *goodix_wq;\r
  54 \r
  55 static const char *gt818_ts_name = "Goodix Capacitive TouchScreen";\r
  56 \r
  57 static struct point_queue finger_list;\r
  58 \r
  59 struct i2c_client * i2c_connect_client = NULL;\r
  60 \r
  61 //EXPORT_SYMBOL(i2c_connect_client);\r
  62 \r
  63 static struct proc_dir_entry *goodix_proc_entry;\r
  64         \r
  65 #ifdef CONFIG_HAS_EARLYSUSPEND\r
  66 static void goodix_ts_early_suspend(struct early_suspend *h);\r
  67 static void goodix_ts_late_resume(struct early_suspend *h);\r
  68 #endif\r
  69 \r
  70 #ifdef HAVE_TOUCH_KEY\r
  71         const uint16_t gt818_key_array[]={\r
  72                                                                           KEY_MENU,\r
  73                                                                           KEY_HOME,\r
  74                                                                           KEY_BACK,\r
  75                                                                           KEY_SEARCH\r
  76                                                                          };\r
  77         #define MAX_KEY_NUM      (sizeof(gt818_key_array)/sizeof(gt818_key_array[0]))\r
  78 #endif\r
  79 \r
  80 unsigned int last_x[MAX_FINGER_NUM + 1]= {0};\r
  81 unsigned int last_y[MAX_FINGER_NUM + 1]= {0};\r
  82 \r
  83 \r
  84 /*Function as i2c_master_send */\r
  85 static int i2c_read_bytes(struct i2c_client *client, u8 *buf, int len)\r
  86 {\r
  87         struct i2c_msg msgs[2];\r
  88         int ret = -1;\r
  89 \r
  90         msgs[0].addr = client->addr;\r
  91         msgs[0].flags = client->flags;\r
  92         msgs[0].len = 2;\r
  93         msgs[0].buf = &buf[0];\r
  94         msgs[0].scl_rate = GT818_I2C_SCL;\r
  95         msgs[0].udelay = client->udelay;\r
  96 \r
  97         msgs[1].addr = client->addr;\r
  98         msgs[1].flags = client->flags | I2C_M_RD;\r
  99         msgs[1].len = len-2;\r
 100         msgs[1].buf = &buf[2];\r
 101         msgs[1].scl_rate = GT818_I2C_SCL;\r
 102         msgs[1].udelay = client->udelay;\r
 103 \r
 104         ret = i2c_transfer(client->adapter, msgs, 2);\r
 105         if(ret < 0)\r
 106                 printk("%s:i2c_transfer fail =%d\n",__func__, ret);\r
 107 \r
 108         return ret;\r
 109 }\r
 110 \r
 111 /*Function as i2c_master_send */\r
 112 static int i2c_write_bytes(struct i2c_client *client,u8 *data,int len)\r
 113 {\r
 114         struct i2c_msg msg;\r
 115         int ret = -1;\r
 116 \r
 117         msg.addr = client->addr;\r
 118         msg.flags = client->flags;\r
 119         msg.len = len;\r
 120         msg.buf = data;\r
 121         msg.scl_rate = GT818_I2C_SCL;\r
 122         msg.udelay = client->udelay;\r
 123 \r
 124         ret = i2c_transfer(client->adapter, &msg, 1);\r
 125         if(ret < 0)\r
 126                 printk("%s:i2c_transfer fail =%d\n",__func__, ret);\r
 127 \r
 128         return ret;\r
 129 }\r
 130 \r
 131 \r
 132 static int i2c_pre_cmd(struct gt818_ts_data *ts)\r
 133 {\r
 134         int ret;\r
 135         u8 pre_cmd_data[2] = {0};\r
 136         pre_cmd_data[0] = 0x0f;\r
 137         pre_cmd_data[1] = 0xff;\r
 138         ret = i2c_write_bytes(ts->client,pre_cmd_data,2);\r
 139         udelay(20);\r
 140         return ret;\r
 141 }\r
 142 \r
 143 \r
 144 static int i2c_end_cmd(struct gt818_ts_data *ts)\r
 145 {\r
 146         int ret;\r
 147         u8 end_cmd_data[2] = {0};\r
 148         end_cmd_data[0] = 0x80;\r
 149         end_cmd_data[1] = 0x00;\r
 150         ret = i2c_write_bytes(ts->client,end_cmd_data,2);\r
 151         udelay(20);\r
 152         return ret;\r
 153 }\r
 154 \r
 155 \r
 156 \r
 157 static int goodix_init_panel(struct gt818_ts_data *ts)\r
 158 {\r
 159         int ret = -1;\r
 160         int i = 0;\r
 161 #if 1\r
 162         u8 config_info[] = {\r
 163         0x06,0xA2,\r
 164         0x00,0x02,0x04,0x06,0x08,0x0A,0x0C,0x0E,\r
 165         0x10,0x12,0x00,0x00,0x10,0x00,0x20,0x00,\r
 166         0x30,0x00,0x40,0x00,0x50,0x00,0x60,0x00,\r
 167         0xE0,0x00,0xD0,0x00,0xC0,0x00,0xB0,0x00,\r
 168         0xA0,0x00,0x90,0x00,0x80,0x00,0x70,0x00,\r
 169         0xF0,0x00,0x13,0x13,0x90,0x90,0x90,0x27,\r
 170         0x27,0x27,0x0F,0x0E,0x0A,0x40,0x30,0x01,\r
 171         0x03,0x00,MAX_FINGER_NUM,0x00,0x14,0xFA,0x1B,0x00,\r
 172         0x00,0x66,0x5A,0x6A,0x5E,0x00,0x00,0x05,\r
 173         0x14,0x00,0x00,0x00,0x00,0x00,0x00,0x00,\r
 174         0x14,0x10,0xEF,0x03,0x00,0x00,0x00,0x00,\r
 175         0x00,0x00,0x20,0x40,0x70,0x90,0x0F,0x40,\r
 176         0x30,0x3C,0x28,0x00,0x00,0x00,0x00,0x00,\r
 177         0x00,0x01\r
 178         };\r
 179 #endif\r
 180         u8 read_config_info[sizeof(config_info)] = {0};\r
 181         read_config_info[0] = 0x06;\r
 182         read_config_info[1] = 0xa2;\r
 183 \r
 184         ret = i2c_write_bytes(ts->client, config_info, (sizeof(config_info)/sizeof(config_info[0])));\r
 185         if (ret < 0) {\r
 186                 printk("config gt818 fail\n");\r
 187                 return ret;\r
 188         }\r
 189 \r
 190         ret = i2c_read_bytes(ts->client, read_config_info, (sizeof(config_info)/sizeof(config_info[0])));\r
 191         if (ret < 0){\r
 192                 printk("read gt818 config fail\n");\r
 193                 return ret;\r
 194         }\r
 195 \r
 196         for(i = 2; i < 106; i++){\r
 197                 if(read_config_info[i] != config_info[i]){\r
 198                         printk("write gt818 config error\n");\r
 199                         ret = -1;\r
 200                         return ret;\r
 201                 }\r
 202         }\r
 203         msleep(10);\r
 204         return 0;\r
 205 \r
 206 }\r
 207 \r
 208 static int  goodix_read_version(struct gt818_ts_data *ts)\r
 209 {\r
 210         int ret;\r
 211         u8 version_data[5] = {0};       //store touchscreen version infomation\r
 212         memset(version_data, 0, 5);\r
 213         version_data[0] = 0x07;\r
 214         version_data[1] = 0x17;\r
 215         msleep(2);\r
 216         ret = i2c_read_bytes(ts->client, version_data, 4);\r
 217         if (ret < 0) \r
 218                 return ret;\r
 219         dev_info(&ts->client->dev," Guitar Version: %d.%d\n",version_data[3],version_data[2]);\r
 220         return 0;\r
 221         \r
 222 }\r
 223 \r
 224 \r
 225 \r
 226 static void goodix_ts_work_func(struct work_struct *work)\r
 227 {       \r
 228         u8  touch_status[8*MAX_FINGER_NUM + 18] = {READ_TOUCH_ADDR_H, READ_TOUCH_ADDR_L, 0};\r
 229         u8  *key_value = NULL;\r
 230         u8  *point_data = NULL;\r
 231         static u8 finger_last[MAX_FINGER_NUM + 1]={0};\r
 232         u8  finger_current[MAX_FINGER_NUM + 1] = {0};\r
 233         u8  coor_data[6*MAX_FINGER_NUM] = {0};\r
 234         static u8  last_key = 0;\r
 235 \r
 236         u8  finger = 0;\r
 237         u8  key = 0;\r
 238         u8 retry = 0;\r
 239         unsigned int  count = 0;\r
 240         unsigned int position = 0;      \r
 241         int temp = 0;\r
 242         int x = 0, y = 0 , pressure;\r
 243 \r
 244         u16 *coor_point;\r
 245 \r
 246         int syn_flag = 0;\r
 247 \r
 248         struct gt818_ts_data *ts = container_of(work, struct gt818_ts_data, work);\r
 249 \r
 250         i2c_pre_cmd(ts);\r
 251         i2c_read_bytes(ts->client, touch_status, sizeof(touch_status)/sizeof(touch_status[0]));\r
 252         i2c_end_cmd(ts);\r
 253 \r
 254         //judge whether the data is ready\r
 255         if((touch_status[2] & 0x30) != 0x20)\r
 256         {\r
 257                 printk("%s:DATA_NO_READY\n", __func__);\r
 258                 goto DATA_NO_READY;\r
 259         }\r
 260         //judge whether it is large area touch\r
 261         if(touch_status[13] & 0x0f)\r
 262         {\r
 263                 goto DATA_NO_READY;\r
 264         }\r
 265 \r
 266         ts->bad_data = 0;\r
 267         finger = touch_status[2] & 0x07;\r
 268         key_value = touch_status + 15;\r
 269         key = key_value[2] & 0x0f;\r
 270 \r
 271         if(finger > 0)\r
 272         {\r
 273                 point_data = key_value + 3;\r
 274 \r
 275                 for(position = 0; position < (finger*8); position += 8)\r
 276                 {\r
 277                         temp = point_data[position];\r
 278                         //printk("track:%d\n", temp);\r
 279                         if(temp < (MAX_FINGER_NUM + 1))\r
 280                         {\r
 281                                 finger_current[temp] = 1;\r
 282                                 for(count = 0; count < 6; count++)\r
 283                                 {\r
 284                                         coor_data[(temp - 1) * 6 + count] = point_data[position+1+count];\r
 285                                 }\r
 286                         }\r
 287                         else\r
 288                         {\r
 289                                 //dev_err(&(ts->client->dev),"Track Id error:%d\n ",);\r
 290                                 ts->bad_data = 1;\r
 291                                 ts->retry++;\r
 292                                 goto XFER_ERROR;\r
 293                         }               \r
 294                 }\r
 295         \r
 296         }\r
 297         \r
 298         else\r
 299         {\r
 300                 for(position = 1; position < MAX_FINGER_NUM+1; position++)\r
 301                 {\r
 302                         finger_current[position] = 0;\r
 303                 }\r
 304         }\r
 305 \r
 306         coor_point = (u16 *)coor_data;\r
 307 \r
 308         for(position = 1; position < MAX_FINGER_NUM + 1; position++)\r
 309         {\r
 310                 if((finger_current[position] == 0) && (finger_last[position] != 0))\r
 311                 {\r
 312                         //printk("<<<<<<<<<<<<<<<<<<<%s:positon:%d (%d,%d)\n", __func__, position,last_x,last_y);\r
 313                         //printk("<<<%d , %d ",finger_current[position],finger_last[position]);\r
 314                         //input_mt_slot(ts->input_dev, position);\r
 315                         //input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, true);\r
 316                         //input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0);\r
 317                         //input_report_abs(ts->input_dev, ABS_MT_POSITION_X, last_x[position]);\r
 318                         //input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, last_y[position]);\r
 319                         //input_report_abs(ts->input_dev, ABS_MT_PRESSURE, 100);\r
 320                         //input_mt_sync(ts->input_dev);\r
 321                         input_mt_slot(ts->input_dev, position);\r
 322                         input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, false);\r
 323                         syn_flag = 1;\r
 324                 }\r
 325                 else if(finger_current[position])\r
 326                 {\r
 327                         x = (*(coor_point+3*(position-1)))*SCREEN_MAX_WIDTH/(TOUCH_MAX_WIDTH);\r
 328                         y = (*(coor_point+3*(position-1)+1))*SCREEN_MAX_HEIGHT/(TOUCH_MAX_HEIGHT);\r
 329                         pressure = (*(coor_point+3*(position-1)+2));\r
 330                         if(x < SCREEN_MAX_WIDTH){\r
 331                                 x = SCREEN_MAX_WIDTH - x;\r
 332                         }\r
 333 \r
 334                         if(y < SCREEN_MAX_HEIGHT){\r
 335                         //      y = SCREEN_MAX_HEIGHT-y;\r
 336                         }\r
 337 \r
 338                         //printk(">>>>>>>>>>>>>>>>>%s:positon:%d (%d,%d)\n", __func__, position,x,y);\r
 339                         input_mt_slot(ts->input_dev, position);\r
 340                         input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, true);\r
 341                         input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, 1);\r
 342                         input_report_abs(ts->input_dev, ABS_MT_PRESSURE, pressure);\r
 343                         input_report_abs(ts->input_dev, ABS_MT_POSITION_X, x);\r
 344                         input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, y);\r
 345 \r
 346                         last_x[position] = x;\r
 347                         last_y[position] = y;\r
 348                         //input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, pressure);\r
 349                         //input_mt_sync(ts->input_dev);\r
 350                         syn_flag = 1;\r
 351                 }\r
 352 \r
 353                 input_sync(ts->input_dev);\r
 354         }\r
 355 \r
 356 \r
 357 #ifdef HAVE_TOUCH_KEY\r
 358         if((last_key == 0) && (key == 0)){\r
 359                 goto NO_KEY_PRESS;\r
 360         }\r
 361         else{\r
 362                 syn_flag = 1;\r
 363                 switch(key){\r
 364                         case 1:\r
 365                                 key = 4;\r
 366                                 break;\r
 367                         case 2:\r
 368                                 key = 3;\r
 369                                 break;\r
 370                         case 4:\r
 371                                 key = 2;\r
 372                                 break;\r
 373                         case 8:\r
 374                                 key = 1;\r
 375                                 break;\r
 376                         default:\r
 377                                 key = 0;\r
 378                                 break;\r
 379                 }\r
 380                 if(key != 0){\r
 381                         input_report_key(ts->input_dev, gt818_key_array[key - 1], 1);\r
 382                 }\r
 383                 else{\r
 384                         input_report_key(ts->input_dev, gt818_key_array[last_key - 1], 0);\r
 385                 }\r
 386                 last_key = key;\r
 387         }               \r
 388 \r
 389 #endif\r
 390 \r
 391 \r
 392 NO_KEY_PRESS:\r
 393         if(syn_flag){\r
 394                 input_sync(ts->input_dev);\r
 395         }\r
 396 \r
 397         for(position = 1; position < MAX_FINGER_NUM + 1; position++)\r
 398         {\r
 399                 finger_last[position] = finger_current[position];\r
 400         }\r
 401 \r
 402 DATA_NO_READY:\r
 403 XFER_ERROR:\r
 404 //      i2c_end_cmd(ts);\r
 405         if(ts->use_irq)\r
 406                 enable_irq(ts->client->irq);\r
 407 \r
 408 }\r
 409 \r
 410 static int test_suspend_resume(struct gt818_ts_data *ts){\r
 411         while(1){\r
 412                 ts->power(ts, 0);\r
 413                 msleep(5000);\r
 414                 ts->power(ts, 1);\r
 415                 msleep(5000);\r
 416         }\r
 417         return 0;\r
 418 }\r
 419 \r
 420 \r
 421 static enum hrtimer_restart goodix_ts_timer_func(struct hrtimer *timer)\r
 422 {\r
 423         struct gt818_ts_data *ts = container_of(timer, struct gt818_ts_data, timer);\r
 424         queue_work(goodix_wq, &ts->work);\r
 425         hrtimer_start(&ts->timer, ktime_set(0, (POLL_TIME+6)*1000000), HRTIMER_MODE_REL);\r
 426         return HRTIMER_NORESTART;\r
 427 }\r
 428 \r
 429 \r
 430 static irqreturn_t goodix_ts_irq_handler(int irq, void *dev_id)\r
 431 {\r
 432         struct gt818_ts_data *ts = dev_id;\r
 433         disable_irq_nosync(ts->client->irq);\r
 434         queue_work(goodix_wq, &ts->work);\r
 435         return IRQ_HANDLED;\r
 436 }\r
 437 \r
 438 static int goodix_ts_power(struct gt818_ts_data * ts, int on)\r
 439 {\r
 440         int ret = -1;\r
 441         struct gt818_platform_data      *pdata = ts->client->dev.platform_data;\r
 442         unsigned char i2c_control_buf[3] = {0x06,0x92,0x01};            //suspend cmd\r
 443         if(ts != NULL && !ts->use_irq)\r
 444                 return -2;\r
 445         switch(on)\r
 446         {\r
 447                 case 0:\r
 448                         i2c_pre_cmd(ts);\r
 449                         // set the io port high level to avoid level change which might stop gt818 from sleeping\r
 450                         gpio_direction_output(pdata->gpio_reset, 1);\r
 451                         gpio_direction_output(pdata->gpio_pendown, 1);\r
 452                         msleep(5);\r
 453                         ret = i2c_write_bytes(ts->client, i2c_control_buf, 3);\r
 454                         if(ret < 0)\r
 455                         {\r
 456                                 printk(KERN_INFO"**gt818 suspend fail**\n");\r
 457                         }\r
 458                         else\r
 459                         {\r
 460                                 //printk(KERN_INFO"**gt818 suspend**\n");\r
 461                                 ret = 0;\r
 462                         }\r
 463 //                      i2c_end_cmd(ts);\r
 464                         return ret;\r
 465                         \r
 466                 case 1:\r
 467 \r
 468                         gpio_pull_updown(pdata->gpio_pendown, 1);\r
 469                         gpio_direction_output(pdata->gpio_pendown, 0);\r
 470                         msleep(1);\r
 471                         gpio_direction_output(pdata->gpio_pendown, 1);\r
 472                         msleep(1);\r
 473                         gpio_direction_input(pdata->gpio_pendown);\r
 474                         gpio_pull_updown(pdata->gpio_pendown, 0);\r
 475 \r
 476 /*\r
 477                         msleep(2);\r
 478                         gpio_pull_updown(pdata->gpio_reset, 1);\r
 479                         gpio_direction_output(pdata->gpio_reset, 0);\r
 480                         msleep(2);\r
 481                         gpio_direction_input(pdata->gpio_reset);\r
 482                         gpio_pull_updown(pdata->gpio_reset, 0);\r
 483                         msleep(30);\r
 484 */\r
 485                         msleep(1);\r
 486                         ret = i2c_pre_cmd(ts);\r
 487                         //printk(KERN_INFO"**gt818 reusme**\n");\r
 488                         ret = i2c_end_cmd(ts);\r
 489 \r
 490                         return ret;\r
 491                                 \r
 492                 default:\r
 493                         printk(KERN_DEBUG "%s: Cant't support this command.", gt818_ts_name);\r
 494                         return -EINVAL;\r
 495         }\r
 496 \r
 497 }\r
 498 \r
 499 \r
 500 static int goodix_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)\r
 501 {\r
 502         int ret = 0;\r
 503         int retry=0;\r
 504         u8 goodix_id[3] = {0,0xff,0};\r
 505         struct gt818_ts_data *ts;\r
 506 \r
 507         struct gt818_platform_data *pdata;\r
 508         dev_info(&client->dev,"Install touch driver.\n");\r
 509         printk("gt818: Install touch driver.\n");\r
 510         //Check I2C function\r
 511         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) \r
 512         {\r
 513                 dev_err(&client->dev, "Must have I2C_FUNC_I2C.\n");\r
 514                 ret = -ENODEV;\r
 515                 goto err_check_functionality_failed;\r
 516         }\r
 517 \r
 518         ts = kzalloc(sizeof(*ts), GFP_KERNEL);\r
 519         if (ts == NULL) {\r
 520                 ret = -ENOMEM;\r
 521                 goto err_alloc_data_failed;\r
 522         }\r
 523 \r
 524         i2c_connect_client = client;    //used by Guitar_Update\r
 525         pdata = client->dev.platform_data;\r
 526         ts->client = client;\r
 527         i2c_set_clientdata(client, ts);\r
 528 \r
 529         //init int and reset ports\r
 530         ret = gpio_request(pdata->gpio_pendown, "TS_INT");      //Request IO\r
 531         if (ret){\r
 532                 dev_err(&client->dev, "Failed to request GPIO:%d, ERRNO:%d\n",(int)pdata->gpio_pendown, ret);\r
 533                 goto err_gpio_request_failed;\r
 534         }\r
 535         rk29_mux_api_set(pdata->pendown_iomux_name, pdata->pendown_iomux_mode);\r
 536         gpio_direction_input(pdata->gpio_pendown);\r
 537         gpio_pull_updown(pdata->gpio_pendown, 0);\r
 538 \r
 539         ret = gpio_request(pdata->gpio_reset, "gt818_resetPin");\r
 540         if(ret){\r
 541                 dev_err(&client->dev, "failed to request resetPin GPIO%d\n", pdata->gpio_reset);\r
 542                 goto err_gpio_request_failed;\r
 543         }\r
 544         rk29_mux_api_set(pdata->resetpin_iomux_name, pdata->resetpin_iomux_mode);\r
 545 \r
 546 #if 1\r
 547         for(retry = 0; retry < 4; retry++)\r
 548         {\r
 549                 gpio_pull_updown(pdata->gpio_reset, 1);\r
 550                 gpio_direction_output(pdata->gpio_reset, 0);\r
 551                 msleep(1);     //delay at least 1ms\r
 552                 gpio_direction_input(pdata->gpio_reset);\r
 553                 gpio_pull_updown(pdata->gpio_reset, 0);\r
 554                 msleep(25);   //delay at least 20ms\r
 555                 ret = i2c_pre_cmd(ts);\r
 556                 if (ret > 0)\r
 557                         break;\r
 558                 msleep(50);\r
 559         }\r
 560 \r
 561         if(ret <= 0)\r
 562         {\r
 563                 dev_err(&client->dev, "Warnning: I2C communication might be ERROR!\n");\r
 564                 goto err_i2c_failed;\r
 565         }       \r
 566 #endif\r
 567 \r
 568         for(retry = 0; retry < 3; retry++)\r
 569         {\r
 570                 ret = goodix_init_panel(ts);\r
 571 \r
 572                 dev_info(&client->dev,"the config ret is :%d\n", ret);\r
 573                 msleep(20);\r
 574                 if(ret < 0)     //Initiall failed\r
 575                         continue;\r
 576                 else\r
 577                         break;\r
 578         }\r
 579 \r
 580         if(ret < 0) {\r
 581                 ts->bad_data = 1;\r
 582                 goto err_init_godix_ts;\r
 583         }\r
 584 \r
 585         goodix_read_version(ts);\r
 586 \r
 587 \r
 588         INIT_WORK(&ts->work, goodix_ts_work_func);              //init work_struct\r
 589         ts->input_dev = input_allocate_device();\r
 590         if (ts->input_dev == NULL) {\r
 591                 ret = -ENOMEM;\r
 592                 dev_dbg(&client->dev,"goodix_ts_probe: Failed to allocate input device\n");\r
 593                 goto err_input_dev_alloc_failed;\r
 594         }\r
 595 \r
 596         //ts->input_dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) ;\r
 597         //ts->input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);\r
 598         //ts->input_dev->absbit[0] = BIT_MASK(ABS_MT_POSITION_X) | BIT_MASK(ABS_MT_POSITION_Y) |\r
 599         //              BIT_MASK(ABS_MT_TOUCH_MAJOR) | BIT_MASK(ABS_MT_WIDTH_MAJOR);  // for android\r
 600 \r
 601 \r
 602 #ifdef HAVE_TOUCH_KEY\r
 603         for(retry = 0; retry < MAX_KEY_NUM; retry++)\r
 604         {\r
 605                 input_set_capability(ts->input_dev, EV_KEY, gt818_key_array[retry]);\r
 606         }\r
 607 #endif\r
 608 \r
 609         snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(&client->dev));\r
 610         snprintf(ts->name, sizeof(ts->name), "gt818-touchscreen");\r
 611 \r
 612         ts->input_dev->name = "gt818_ts";//ts->name;\r
 613         ts->input_dev->phys = ts->phys;\r
 614         ts->input_dev->dev.parent = &client->dev;\r
 615         ts->input_dev->id.bustype = BUS_I2C;\r
 616         ts->input_dev->id.vendor = 0xDEAD;\r
 617         ts->input_dev->id.product = 0xBEEF;\r
 618         ts->input_dev->id.version = 10427;      //screen firmware version\r
 619 \r
 620         __set_bit(INPUT_PROP_DIRECT, ts->input_dev->propbit);\r
 621         __set_bit(EV_ABS, ts->input_dev->evbit);\r
 622 #ifdef GOODIX_MULTI_TOUCH\r
 623         input_mt_init_slots(ts->input_dev, MAX_FINGER_NUM);\r
 624         //input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);\r
 625         input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);\r
 626         input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X, 0, SCREEN_MAX_WIDTH, 0, 0);\r
 627         input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y, 0, SCREEN_MAX_HEIGHT, 0, 0);\r
 628         //input_set_abs_params(ts->input_dev, ABS_MT_TRACKING_ID, 0, MAX_FINGER_NUM, 0, 0);\r
 629         input_set_abs_params(ts->input_dev, ABS_MT_PRESSURE, 0, 255, 0, 0);\r
 630 #else\r
 631         input_set_abs_params(ts->input_dev, ABS_X, 0, SCREEN_MAX_HEIGHT, 0, 0);\r
 632         input_set_abs_params(ts->input_dev, ABS_Y, 0, SCREEN_MAX_WIDTH, 0, 0);\r
 633         input_set_abs_params(ts->input_dev, ABS_PRESSURE, 0, 255, 0, 0);\r
 634 #endif  \r
 635         \r
 636         ret = input_register_device(ts->input_dev);\r
 637         if (ret) {\r
 638                 dev_err(&client->dev,"Probe: Unable to register %s input device\n", ts->input_dev->name);\r
 639                 goto err_input_register_device_failed;\r
 640         }\r
 641         ts->bad_data = 0;\r
 642 //      16finger_list.length = 0;\r
 643 \r
 644         client->irq = gpio_to_irq(pdata->gpio_pendown);         //If not defined in client\r
 645         if (client->irq)\r
 646         {\r
 647 \r
 648         #if INT_TRIGGER==0\r
 649                 #define GT801_PLUS_IRQ_TYPE IRQ_TYPE_EDGE_RISING\r
 650         #elif INT_TRIGGER==1\r
 651                 #define GT801_PLUS_IRQ_TYPE IRQ_TYPE_EDGE_FALLING\r
 652         #elif INT_TRIGGER==2\r
 653                 #define GT801_PLUS_IRQ_TYPE IRQ_TYPE_LEVEL_LOW\r
 654         #elif INT_TRIGGER==3\r
 655                 #define GT801_PLUS_IRQ_TYPE IRQ_TYPE_LEVEL_HIGH\r
 656         #endif\r
 657 \r
 658                 ret = request_irq(client->irq, goodix_ts_irq_handler, GT801_PLUS_IRQ_TYPE,\r
 659                         client->name, ts);\r
 660                 if (ret != 0) {\r
 661                         dev_err(&client->dev,"Cannot allocate ts INT!ERRNO:%d\n", ret);\r
 662                         gpio_direction_input(pdata->gpio_pendown);\r
 663                         gpio_free(pdata->gpio_pendown);\r
 664                         goto err_gpio_request_failed;\r
 665                 }\r
 666                 else \r
 667                 {       \r
 668                         disable_irq(client->irq);\r
 669                         ts->use_irq = 1;\r
 670                         dev_dbg(&client->dev,"Reques EIRQ %d succesd on GPIO:%d\n", client->irq, pdata->gpio_pendown);\r
 671                 }       \r
 672         }\r
 673 \r
 674 err_gpio_request_failed:\r
 675         ts->power = goodix_ts_power;\r
 676 #ifdef CONFIG_HAS_EARLYSUSPEND\r
 677         ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;\r
 678         ts->early_suspend.suspend = goodix_ts_early_suspend;\r
 679         ts->early_suspend.resume = goodix_ts_late_resume;\r
 680         register_early_suspend(&ts->early_suspend);\r
 681 #endif\r
 682         dev_info(&client->dev,"Start %s in %s mode\n",\r
 683                 ts->input_dev->name, ts->use_irq ? "interrupt" : "polling");\r
 684 \r
 685         if (ts->use_irq)\r
 686         {\r
 687                 enable_irq(client->irq);\r
 688         }\r
 689         else\r
 690         {\r
 691                 hrtimer_init(&ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);\r
 692                 ts->timer.function = goodix_ts_timer_func;\r
 693                 hrtimer_start(&ts->timer, ktime_set(1, 0), HRTIMER_MODE_REL);\r
 694         }\r
 695 \r
 696         i2c_end_cmd(ts);\r
 697         return 0;\r
 698 \r
 699 err_init_godix_ts:\r
 700         i2c_end_cmd(ts);\r
 701         if(ts->use_irq)\r
 702         {\r
 703                 ts->use_irq = 0;\r
 704                 free_irq(client->irq,ts);\r
 705                 gpio_direction_input(pdata->gpio_pendown);\r
 706                 gpio_free(pdata->gpio_pendown);\r
 707         }\r
 708         else \r
 709                 hrtimer_cancel(&ts->timer);\r
 710 \r
 711 err_input_register_device_failed:\r
 712         input_free_device(ts->input_dev);\r
 713 \r
 714 err_input_dev_alloc_failed:\r
 715         i2c_set_clientdata(client, NULL);\r
 716 err_i2c_failed: \r
 717         kfree(ts);\r
 718 err_alloc_data_failed:\r
 719 err_check_functionality_failed:\r
 720 err_create_proc_entry:\r
 721         return ret;\r
 722 }\r
 723 \r
 724 \r
 725 static int goodix_ts_remove(struct i2c_client *client)\r
 726 {\r
 727         struct gt818_ts_data *ts = i2c_get_clientdata(client);\r
 728         struct gt818_platform_data      *pdata = client->dev.platform_data;\r
 729 \r
 730 #ifdef CONFIG_HAS_EARLYSUSPEND\r
 731         unregister_early_suspend(&ts->early_suspend);\r
 732 #endif\r
 733 #ifdef CONFIG_TOUCHSCREEN_GOODIX_IAP\r
 734         remove_proc_entry("goodix-update", NULL);\r
 735 #endif\r
 736         if (ts && ts->use_irq) \r
 737         {\r
 738                 gpio_direction_input(pdata->gpio_pendown);\r
 739                 gpio_free(pdata->gpio_pendown);\r
 740                 free_irq(client->irq, ts);\r
 741         }       \r
 742         else if(ts)\r
 743                 hrtimer_cancel(&ts->timer);\r
 744         \r
 745         dev_notice(&client->dev,"The driver is removing...\n");\r
 746         i2c_set_clientdata(client, NULL);\r
 747         input_unregister_device(ts->input_dev);\r
 748         kfree(ts);\r
 749         return 0;\r
 750 }\r
 751 \r
 752 \r
 753 static int goodix_ts_suspend(struct i2c_client *client, pm_message_t mesg)\r
 754 {\r
 755         int ret;\r
 756         struct gt818_ts_data *ts = i2c_get_clientdata(client);\r
 757 \r
 758         if (ts->use_irq)\r
 759                 disable_irq(client->irq);\r
 760         else\r
 761                 hrtimer_cancel(&ts->timer);\r
 762         //ret = cancel_work_sync(&ts->work);\r
 763         //if(ret && ts->use_irq)        \r
 764                 //enable_irq(client->irq);\r
 765         if (ts->power) {\r
 766                 ret = ts->power(ts, 0);\r
 767                 if (ret < 0)\r
 768                         printk(KERN_ERR "goodix_ts_resume power off failed\n");\r
 769         }\r
 770         return 0;\r
 771 }\r
 772 \r
 773 \r
 774 static int goodix_ts_resume(struct i2c_client *client)\r
 775 {\r
 776         int ret;\r
 777         struct gt818_ts_data *ts = i2c_get_clientdata(client);\r
 778 \r
 779         if (ts->power) {\r
 780                 ret = ts->power(ts, 1);\r
 781                 if (ret < 0)\r
 782                         printk(KERN_ERR "goodix_ts_resume power on failed\n");\r
 783         }\r
 784 \r
 785         if (ts->use_irq)\r
 786                 enable_irq(client->irq);\r
 787         else\r
 788                 hrtimer_start(&ts->timer, ktime_set(1, 0), HRTIMER_MODE_REL);\r
 789 \r
 790         return 0;\r
 791 }\r
 792 \r
 793 #ifdef CONFIG_HAS_EARLYSUSPEND\r
 794 static void goodix_ts_early_suspend(struct early_suspend *h)\r
 795 {\r
 796         struct gt818_ts_data *ts;\r
 797         ts = container_of(h, struct gt818_ts_data, early_suspend);\r
 798         goodix_ts_suspend(ts->client, PMSG_SUSPEND);\r
 799 }\r
 800 \r
 801 static void goodix_ts_late_resume(struct early_suspend *h)\r
 802 {\r
 803         struct gt818_ts_data *ts;\r
 804         ts = container_of(h, struct gt818_ts_data, early_suspend);\r
 805         goodix_ts_resume(ts->client);\r
 806 }\r
 807 #endif\r
 808 \r
 809 \r
 810 //only one client\r
 811 static const struct i2c_device_id goodix_ts_id[] = {\r
 812         { GOODIX_I2C_NAME, 0 },\r
 813         { }\r
 814 };\r
 815 \r
 816 \r
 817 static struct i2c_driver goodix_ts_driver = {\r
 818         .probe          = goodix_ts_probe,\r
 819         .remove         = goodix_ts_remove,\r
 820 #ifndef CONFIG_HAS_EARLYSUSPEND\r
 821         .suspend        = goodix_ts_suspend,\r
 822         .resume         = goodix_ts_resume,\r
 823 #endif\r
 824         .id_table       = goodix_ts_id,\r
 825         .driver = {\r
 826                 .name   = GOODIX_I2C_NAME,\r
 827                 .owner = THIS_MODULE,\r
 828         },\r
 829 };\r
 830 \r
 831 \r
 832 static int __devinit goodix_ts_init(void)\r
 833 {\r
 834         int ret;\r
 835         goodix_wq = create_singlethread_workqueue("goodix_wq");         //create a work queue and worker thread\r
 836         if (!goodix_wq) {\r
 837                 printk(KERN_ALERT "creat workqueue faiked\n");\r
 838                 return -ENOMEM;\r
 839         }\r
 840         ret = i2c_add_driver(&goodix_ts_driver);\r
 841         return ret; \r
 842 }\r
 843 \r
 844 \r
 845 static void __exit goodix_ts_exit(void)\r
 846 {\r
 847         printk(KERN_ALERT "Touchscreen driver of guitar exited.\n");\r
 848         i2c_del_driver(&goodix_ts_driver);\r
 849         if (goodix_wq)\r
 850                 destroy_workqueue(goodix_wq);           //release our work queue\r
 851 }\r
 852 \r
 853 late_initcall(goodix_ts_init);\r
 854 module_exit(goodix_ts_exit);\r
 855 \r
 856 MODULE_DESCRIPTION("Goodix Touchscreen Driver");\r
 857 MODULE_AUTHOR("hhb@rock-chips.com");\r
 858 MODULE_LICENSE("GPL");\r
 859 \r