1 /* drivers/input/touchscreen/goodix_touch.c
3 * Copyright (C) 2010 - 2011 Goodix, Inc.
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.
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
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>
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>
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>
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
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
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
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
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
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;
92 uint8_t max_touch_num;
93 uint8_t int_trigger_type;
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[]=
104 #include "gt819_fw.i"
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
118 static u8 config_info[]=
123 static int gt819_read_regs(struct i2c_client *client, u8 reg, u8 buf[], unsigned len)
126 ret = i2c_master_reg8_recv(client, reg, buf, len, GT819_IIC_SPEED);
129 ret = i2c_master_reg8_recv(client, reg, buf, len, GT819_IIC_SPEED);
132 ret = i2c_master_reg8_recv(client, reg, buf, len, GT819_IIC_SPEED);
135 ret = i2c_master_reg8_recv(client, reg, buf, len, GT819_IIC_SPEED);
138 ret = i2c_master_reg8_recv(client, reg, buf, len, GT819_IIC_SPEED);
143 static int gt819_set_regs(struct i2c_client *client, u8 reg, u8 const buf[], unsigned short len)
146 ret = i2c_master_reg8_send(client, reg, buf, (int)len, GT819_IIC_SPEED);
149 ret = i2c_master_reg8_send(client, reg, buf, (int)len, GT819_IIC_SPEED);
152 ret = i2c_master_reg8_send(client, reg, buf, (int)len, GT819_IIC_SPEED);
155 ret = i2c_master_reg8_send(client, reg, buf, (int)len, GT819_IIC_SPEED);
158 ret = i2c_master_reg8_send(client, reg, buf, (int)len, GT819_IIC_SPEED);
162 int gt819_printf(char *buf, int len)
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]);
171 for (x=0; x<mod; x++) {
172 printk("0x%02x, ",buf[row*8+x]);
178 int gt189_wait_for_slave(struct i2c_client *client, u8 status)
180 unsigned char i2c_state_buf[2];
182 while(i < MAX_I2C_RETRIES)
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]);
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];
194 return -ERROR_TIMEOUT;
197 int gt819_update_write_config(struct i2c_client *client)
199 int ret,len = sizeof(config_info)-1; //byte[0] is the reg addr in the gt819.cfg
201 u8 cfg_cmd_buf = 0x03;
205 ret = gt819_set_regs(client, 101, &config_info[1], len);
208 gt819_printf(config_info, len);
209 ret = gt819_read_regs(client, 101, cfg_rd_buf, len);
212 if(memcmp(cfg_rd_buf, &config_info[1], len))
214 dev_info(&client->dev, "config info check error!\n");
218 ret = gt819_set_regs(client, ADDR_CMD, &cfg_cmd_buf, 1);
226 ret = gt819_set_regs(client, ADDR_CMD, &cfg_cmd_buf, 1);
233 static int gt819_read_version(struct i2c_client *client,char *version)
238 ret = gt819_read_regs(client,240, version, 16);
245 if((*p > 122) || (*p < 48 && *p != 32) || (*p >57 && *p < 65)
246 ||(*p > 90 && *p < 97 && *p != '_')) //check illeqal character
248 }while(*++p != '\0' );
251 dev_info(&client->dev, "fw version is %s\n",version);
255 int gt819_update_write_fw(struct i2c_client *client, char *fw_buf, int len)
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];
264 if(!client || !fw_buf)
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;
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);
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);
291 ret = gt819_set_regs(client,ADDR_DAT, i2c_data_buf, data_len);
294 //gt819_printf(i2c_data_buf, data_len);
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);
301 //gt819_printf(i2c_data_buf, data_len);
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))
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);
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);
320 dev_info(&client->dev, "PACK[%d]:wait for slave to start next frame\n",frame_number);
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))
327 if(((ret & CHECKSUM_ERROR) || (ret & FRAME_ERROR) || (check_state == 0x01))&&(retries < 5))
329 if(check_state != 0x01)
331 printk("checksum error or miss frame error!\n");
338 printk("wait slave return state:%d\n", ret);
341 dev_info(&client->dev, "PACK[%d]:frame transfer finished\n",frame_number);
350 int gt819_update_fw(struct i2c_client *client)
352 int ret,file_len,update_need_config;
353 unsigned char i2c_control_buf[10];
355 const char version_base[17]={"GT81XNI"};
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);
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);
371 //the time include time(APROM -> LDROM) and time(LDROM init)
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);
378 if(!(ret & UPDATE_START))
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);
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);
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));
403 dev_info(&client->dev, "done!\n");
404 dev_info(&client->dev, "step 8:write config\n");
405 ret = gt819_update_write_config(client);
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);
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);
423 dev_info(&client->dev, "done!\n");
425 if(strcmp(version ,version_base)==0)
429 kernel_restart(NULL);
435 static void gt819_queue_work(struct work_struct *work)
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;
442 unsigned int count = 0;
443 uint8_t check_sum = 0;
445 ret = gt819_read_regs(ts->client,1, point_data, 2);
447 dev_err(&ts->client->dev, "i2c_read_bytes fail:%d!\n",ret);
451 check_sum =point_data[0]+point_data[1];
453 points = point_data[0] & 0x1f;
454 //dev_info(&ts->client->dev, "points = %d\n",points);
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);
461 dev_info(&ts->client->dev, "touch release\n");
472 points_chect = points;
473 ret = gt819_read_regs(ts->client,3, point_data, points*5+1);
475 dev_err(&ts->client->dev, "i2c_read_bytes fail:%d!\n",ret);
480 for(points_chect *= 5; points_chect > 0; points_chect--)
482 check_sum += point_data[count++];
484 check_sum += point_data[count];
485 if(check_sum != 0) //checksum verify error
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);
492 dev_info(&ts->client->dev, "coor checksum error!touch release\n");
496 for(i=0;i<points;i++){
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);
512 input_sync(ts->input_dev);
517 /*******************************************************
519 External interrupt service routine.
522 irq: interrupt number.
523 dev_id: private data pointer.
527 *******************************************************/
528 static irqreturn_t gt819_irq_handler(int irq, void *dev_id)
530 struct goodix_ts_data *ts = dev_id;
532 disable_irq_nosync(ts->client->irq);
533 queue_work(ts->goodix_wq, &ts->work);
537 static int gt819_suspend(struct i2c_client *client, pm_message_t mesg)
539 struct goodix_platform_data *pdata = client->dev.platform_data;
540 dev_info(&client->dev,"gt819_suspend\n");
542 if (pdata->platform_sleep)
543 pdata->platform_sleep();
544 disable_irq(client->irq);
548 static int gt819_resume(struct i2c_client *client)
550 struct goodix_platform_data *pdata = client->dev.platform_data;
551 dev_info(&client->dev,"gt819_resume\n");
553 enable_irq(client->irq);
554 if (pdata->platform_wakeup)
555 pdata->platform_wakeup();
559 static void gt819_early_suspend(struct early_suspend *h)
561 dev_info(&i2c_connect_client->dev, "gt819_early_suspend!\n");
562 gt819_suspend(i2c_connect_client,PMSG_SUSPEND);
565 static void gt819_early_resume(struct early_suspend *h)
567 dev_info(&i2c_connect_client->dev, "gt819_resume_early!\n");
568 gt819_resume(i2c_connect_client);
571 /*******************************************************
573 Goodix touchscreen driver release function.
576 client: i2c device struct.
579 Executive outcomes. 0---succeed.
580 *******************************************************/
581 static int gt819_remove(struct i2c_client *client)
583 struct goodix_ts_data *ts = i2c_get_clientdata(client);
584 #ifdef CONFIG_TOUCHSCREEN_GOODIX_IAP
585 remove_proc_entry("goodix-update", NULL);
587 //goodix_debug_sysfs_deinit();
588 gpio_direction_input(ts->irq_gpio);
589 gpio_free(ts->irq_gpio);
590 free_irq(client->irq, ts);
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(>819_power);
597 i2c_connect_client = 0;
602 static int gt819_init_panel(struct goodix_ts_data *ts)
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;
609 ret = gt819_set_regs(ts->client, 101, &config_info[1], len);
612 pdata->platform_sleep();
614 pdata->platform_wakeup();
616 printk("First IIC request failed,retry!\n");
617 ret = gt819_set_regs(ts->client, 101, &config_info[1], len);
622 ret = gt819_read_regs(ts->client, 101, rd_cfg_buf, 10);
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);
648 dev_info(&ts->client->dev,"set config\n");
653 /*******************************************************
655 Goodix touchscreen probe function.
658 client: i2c device struct.
662 Executive outcomes. 0---succeed.
663 *******************************************************/
664 static int gt819_probe(struct i2c_client *client, const struct i2c_device_id *id)
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,
674 IRQ_TYPE_LEVEL_HIGH};
676 dev_info(&client->dev,"Install goodix touch driver\n");
679 dev_err(&client->dev, "platform data is required!\n");
683 if (pdata->init_platform_hw)
684 pdata->init_platform_hw();
686 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
687 dev_err(&client->dev, "Must have I2C_FUNC_I2C.\n");
690 ts = kzalloc(sizeof(*ts), GFP_KERNEL);
695 ts->client = i2c_connect_client = client;
697 ret = gt819_init_panel(ts);
699 dev_err(&client->dev,"init panel fail,ret = %d\n",ret);
700 goto err_init_panel_fail;
703 ret = gt819_read_version(client,version);
704 if((ret>=0) && (strcmp(version ,version_base)!=0)){
705 gt819_update_fw(client);
709 dev_err(&client->dev,"no irq fail\n");
711 goto err_no_irq_fail;
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);
717 dev_err(&client->dev,"request_irq fail:%d\n", ret);
718 goto err_irq_request_fail;
721 ts->goodix_wq = create_workqueue("goodix_wq");
722 if (!ts->goodix_wq) {
723 printk(KERN_ALERT "creat workqueue failed\n");
725 goto err_create_work_queue_fail;
728 INIT_WORK(&ts->work, gt819_queue_work);
730 ts->input_dev = input_allocate_device();
731 if (ts->input_dev == NULL) {
733 dev_err(&client->dev,"Failed to allocate input device\n");
734 goto err_input_dev_alloc_failed;
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);
750 ts->input_dev->name = goodix_ts_name;
751 ret = input_register_device(ts->input_dev);
753 dev_err(&client->dev,"Probe: Unable to register %s input device\n", ts->input_dev->name);
754 goto err_input_register_device_failed;
756 i2c_set_clientdata(client, ts);
758 gt819_power.suspend = gt819_early_suspend;
759 gt819_power.resume = gt819_early_resume;
760 gt819_power.level = 0x2;
761 register_early_suspend(>819_power);
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:
774 if (pdata->exit_platform_hw)
775 pdata->exit_platform_hw();
782 static const struct i2c_device_id gt819_id[] = {
783 { GOODIX_I2C_NAME, 0 },
787 static struct i2c_driver gt819_driver = {
788 .probe = gt819_probe,
789 .remove = gt819_remove,
790 .id_table = gt819_id,
792 .name = GOODIX_I2C_NAME,
793 .owner = THIS_MODULE,
797 /*******************************************************
799 Driver Install function.
801 Executive Outcomes. 0---succeed.
802 ********************************************************/
803 static int __devinit gt819_init(void)
807 ret=i2c_add_driver(>819_driver);
811 /*******************************************************
813 Driver uninstall function.
815 Executive Outcomes. 0---succeed.
816 ********************************************************/
817 static void __exit gt819_exit(void)
819 printk(KERN_ALERT "Touchscreen driver of guitar exited.\n");
820 i2c_del_driver(>819_driver);
823 late_initcall(gt819_init);
824 module_exit(gt819_exit);
826 MODULE_DESCRIPTION("Goodix Touchscreen Driver");
827 MODULE_LICENSE("GPL");