1 /* drivers/input/touchscreen/gt811.c
\r
3 * Copyright (C) 2010 - 2011 Goodix, Inc.
\r
5 * This program is free software; you can redistribute it and/or modify
\r
6 * it under the terms of the GNU General Public License as published by
\r
7 * the Free Software Foundation; either version 2 of the License, or
\r
8 * (at your option) any later version.
\r
10 * This program is distributed in the hope that it will be useful, but WITHOUT
\r
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
\r
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
\r
15 *Any problem,please contact andrew@goodix.com,+86 755-33338828
\r
19 #include <linux/kernel.h>
\r
20 #include <linux/module.h>
\r
21 #include <linux/time.h>
\r
22 #include <linux/delay.h>
\r
23 #include <linux/device.h>
\r
24 #include <linux/earlysuspend.h>
\r
25 #include <linux/hrtimer.h>
\r
26 #include <linux/i2c.h>
\r
27 #include <linux/input.h>
\r
28 #include <linux/interrupt.h>
\r
29 #include <linux/io.h>
\r
30 #include <linux/platform_device.h>
\r
31 #include <mach/gpio.h>
\r
32 //#include <plat/gpio-cfg.h>
\r
33 //#include <plat/gpio-bank-l.h>
\r
34 //#include <plat/gpio-bank-f.h>
\r
35 #include <linux/irq.h>
\r
36 #include <linux/syscalls.h>
\r
37 #include <linux/reboot.h>
\r
38 #include <linux/proc_fs.h>
\r
39 #include "gt811_ts.h"
\r
40 #include "gt811_firmware.h"
\r
42 #include <linux/vmalloc.h>
\r
43 #include <linux/fs.h>
\r
44 #include <linux/string.h>
\r
45 #include <linux/completion.h>
\r
46 #include <asm/uaccess.h>
\r
47 #include <linux/input/mt.h>
\r
48 #include <plat/board.h>
\r
49 #include <mach/iomux.h>
\r
50 #ifdef CONFIG_RK_CONFIG
\r
51 #include <mach/config.h>
\r
53 #define TP_MODULE_NAME GOODIX_I2C_NAME
\r
54 #ifdef CONFIG_RK_CONFIG
\r
57 #if defined(RK2928_SDK_DEFAULT_CONFIG)
\r
59 DEF_IRQ = 0x008003c7,
\r
60 DEF_RST = 0X000003c3,
\r
61 #elif defined(RK2926_V86_DEFAULT_CONFIG)
\r
63 DEF_IRQ = 0x008001b0,
\r
64 DEF_RST = 0X000000d3,
\r
75 static int en = DEF_EN;
\r
76 module_param(en, int, 0644);
\r
78 static int irq = DEF_IRQ;
\r
79 module_param(irq, int, 0644);
\r
80 static int rst =DEF_RST;
\r
81 module_param(rst, int, 0644);
\r
83 static int i2c = DEF_I2C; // i2c channel
\r
84 module_param(i2c, int, 0644);
\r
85 static int addr = DEF_ADDR; // i2c addr
\r
86 module_param(addr, int, 0644);
\r
87 static int x_max = DEF_X_MAX;
\r
88 module_param(x_max, int, 0644);
\r
89 static int y_max = DEF_Y_MAX;
\r
90 module_param(y_max, int, 0644);
\r
92 static int tp_hw_init(void)
\r
96 ret = gpio_request(get_port_config(irq).gpio, "tp_irq");
\r
98 printk("%s: gpio_request(irq gpio) failed\n", __func__);
\r
102 ret = port_output_init(rst, 1, "tp_rst");
\r
104 printk("%s: port(rst) output init faild\n", __func__);
\r
108 port_output_off(rst);
\r
110 port_output_on(rst);
\r
120 static struct workqueue_struct *goodix_wq;
\r
121 static const char *s3c_ts_name = "gt811_ts";
\r
122 //static struct point_queue finger_list;
\r
123 struct i2c_client * i2c_connect_client = NULL;
\r
125 //EXPORT_SYMBOL(i2c_connect_client);
\r
126 static struct proc_dir_entry *goodix_proc_entry;
\r
127 static short goodix_read_version(struct gt811_ts_data *ts);
\r
128 //static int tpd_button(struct gt811_ts_data *ts, unsigned int x, unsigned int y, unsigned int down);
\r
130 #ifdef CONFIG_HAS_EARLYSUSPEND
\r
131 static void goodix_ts_early_suspend(struct early_suspend *h);
\r
132 static void goodix_ts_late_resume(struct early_suspend *h);
\r
133 int gt811_downloader( struct gt811_ts_data *ts, unsigned char * data);
\r
135 //used by firmware update CRC
\r
136 unsigned int oldcrc32 = 0xFFFFFFFF;
\r
137 unsigned int crc32_table[256];
\r
138 unsigned int ulPolynomial = 0x04c11db7;
\r
140 unsigned int raw_data_ready = RAW_DATA_NON_ACTIVE;
\r
145 int access_count = 0;
\r
148 #define HAVE_TOUCH_KEY
\r
149 //#define READ_KEY_VALUE
\r
150 //#define READ_KEY_COOR
\r
152 #ifdef HAVE_TOUCH_KEY
\r
153 const uint16_t touch_key_array[]={
\r
159 #define MAX_KEY_NUM (sizeof(touch_key_array)/sizeof(touch_key_array[0]))
\r
162 /*******************************************************
\r
164 Read data from the slave
\r
165 Each read operation with two i2c_msg composition, for the first message sent from the machine address,
\r
166 Article 2 reads the address used to send and retrieve data; each message sent before the start signal
\r
168 client: i2c devices, including device address
\r
169 buf [0]: The first byte to read Address
\r
170 buf [1] ~ buf [len]: data buffer
\r
171 len: the length of read data
\r
174 *********************************************************/
\r
175 /*Function as i2c_master_send */
\r
176 static int i2c_read_bytes(struct i2c_client *client, uint8_t *buf, int len)
\r
178 struct i2c_msg msgs[2];
\r
181 msgs[0].flags=!I2C_M_RD;
\r
182 msgs[0].addr=client->addr;
\r
184 msgs[0].buf=&buf[0];
\r
185 msgs[0].scl_rate=200000;
\r
187 msgs[1].flags=I2C_M_RD;
\r
188 msgs[1].addr=client->addr;
\r
190 msgs[1].buf=&buf[2];
\r
191 msgs[1].scl_rate=200000;
\r
193 ret=i2c_transfer(client->adapter,msgs, 2);
\r
197 /*******************************************************
\r
199 Write data to a slave
\r
201 client: i2c devices, including device address
\r
202 buf [0]: The first byte of the write address
\r
203 buf [1] ~ buf [len]: data buffer
\r
207 *******************************************************/
\r
208 /*Function as i2c_master_send */
\r
209 static int i2c_write_bytes(struct i2c_client *client,uint8_t *data,int len)
\r
211 struct i2c_msg msg;
\r
214 msg.flags=!I2C_M_RD;//å
\86\99æ¶
\88æ
\81? msg.addr=client->addr;
\r
217 msg.scl_rate=200000;
\r
218 msg.addr=client->addr;
\r
220 ret=i2c_transfer(client->adapter,&msg, 1);
\r
224 /*******************************************************
\r
226 Send a prefix command
\r
229 ts: client private data structure
\r
232 Results of the implementation code, 0 for normal execution
\r
233 *******************************************************/
\r
234 static int i2c_pre_cmd(struct gt811_ts_data *ts)
\r
237 uint8_t pre_cmd_data[2]={0};
\r
238 pre_cmd_data[0]=0x0f;
\r
239 pre_cmd_data[1]=0xff;
\r
240 ret=i2c_write_bytes(ts->client,pre_cmd_data,2);
\r
245 /*******************************************************
\r
247 Send a suffix command
\r
250 ts: client private data structure
\r
253 Results of the implementation code, 0 for normal execution
\r
254 *******************************************************/
\r
255 static int i2c_end_cmd(struct gt811_ts_data *ts)
\r
258 uint8_t end_cmd_data[2]={0};
\r
259 end_cmd_data[0]=0x80;
\r
260 end_cmd_data[1]=0x00;
\r
261 ret=i2c_write_bytes(ts->client,end_cmd_data,2);
\r
266 /********************************************************************
\r
268 *********************************************************************/
\r
270 static int list_key(s32 x_value, s32 y_value, u8* key)
\r
275 if (y_value <= AREA_Y)
\r
277 if (x_value <= AREA_X)
\r
283 for (i = 0; i < MAX_KEY_NUM; i++)
\r
285 if (abs(key_center[i][x] - x_value) < KEY_X
\r
286 && abs(key_center[i][y] - y_value) < KEY_Y)
\r
288 (*key) |= (0x01<<i);
\r
296 /*******************************************************
\r
298 Guitar initialization function, used to send configuration information, access to version information
\r
300 ts: client private data structure
\r
302 Results of the implementation code, 0 for normal execution
\r
303 *******************************************************/
\r
304 static int goodix_init_panel(struct gt811_ts_data *ts)
\r
307 uint8_t config_info[] = {
\r
310 0x00,0x02,0x04,0x06,0x08,0x0A,0x0C,0x0E,0x10,0x12,0x60,0x00,0x50,0x00,0x40,0x00,
\r
311 0x30,0x00,0x20,0x00,0x10,0x00,0x00,0x00,0x70,0x00,0x80,0x00,0x90,0x00,0xA0,0x00,
\r
312 0xB0,0x00,0xC0,0x00,0xD0,0x00,0xE0,0x00,0xF0,0x00,0x05,0x03,0x90,0x90,0x90,0x30,
\r
313 0x30,0x30,0x0F,0x0F,0x0A,0x50,0x3C,0x08,0x03,0x3C,0x05,0x00,0x14,0x00,0x20,0x04,
\r
314 0x04,0x64,0x5A,0x40,0x40,0x00,0x00,0x03,0x19,0x00,0x05,0x00,0x00,0x00,0x00,0x00,
\r
315 0x20,0x10,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0F,0x50,
\r
316 0x3C,0x3C,0x28,0x00,0x00,0x00,0x00,0x00,0x00,0x01
\r
318 /* 0x00,0x02,0x04,0x06,0x08,0x0A,0x0C,0x0E,0x10,0x12,0x13,0x33,0x23,0x33,0x33,0x33,
\r
319 0x43,0x33,0x53,0x33,0x63,0x33,0x73,0x33,0x83,0x33,0x93,0x33,0xA3,0x33,0xB3,0x33,
\r
320 0xC3,0x33,0xD3,0x33,0xE3,0x33,0xF3,0x33,0x03,0x33,0x3B,0x03,0x88,0x88,0x88,0x1B,
\r
321 0x1B,0x1B,0x0F,0x0F,0x0A,0x40,0x30,0x0F,0x03,0x00,0x05,0x00,0x14,0x00,0x1E,0x04,
\r
322 0x04,0x64,0x5A,0x40,0x40,0x00,0x00,0x05,0x19,0x05,0x05,0x00,0x00,0x00,0x00,0x00,
\r
323 0x20,0x10,0x00,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0F,0x50,
\r
324 0x3C,0x3C,0x28,0x00,0x00,0x00,0x00,0x00,0x00,0x01
\r
327 /* 0x12,0x10,0x0E,0x0C,0x0A,0x08,0x06,0x04,0x02,0x00,
\r
328 0x02,0x22,0x12,0x22,0x22,0x22,0x32,0x22,0x42,0x22,
\r
329 0x52,0x22,0x62,0x22,0x72,0x22,0x82,0x22,0x92,0x22,
\r
330 0xA2,0x22,0xB2,0x22,0xC2,0x22,0xD2,0x22,0xE2,0x22,
\r
331 0xF2,0x22,0x1B,0x03,0x88,0x88,0x88,0x1D,0x1D,0x1D,
\r
332 0x10,0x0F,0x0A,0x47,0x2A,0x0D,0x03,0x00,0x05,0x00,
\r
333 0x03,0x00,0x04,0x00,0x00,0x38,0x33,0x35,0x30,0x00,
\r
334 0x00,0x07,0x20,0x05,0x05,0x00,0x00,0x00,0x00,0x00,
\r
335 0x32,0x16,0x80,0x03,0x00,0x40,0x17,0x88,0x1B,0x00,
\r
336 0x71,0x80,0x90,0xA0,0x0A,0x45,0x30,0x20,0x14,0x00,
\r
337 0x00,0x00,0x00,0x00,0x00,0x01*/
\r
339 /* 0x12,0x10,0x0E,0x0C,0x0A,0x08,0x06,0x04,0x02,0x00,
\r
340 0x52,0x22,0x62,0x22,0x72,0x22,0x82,0x22,0x92,0x22,
\r
341 0xA2,0x22,0xB2,0x22,0xC2,0x22,0xD2,0x22,0xE2,0x22,
\r
342 0xF2,0x22,0x02,0x22,0x12,0x22,0x22,0x22,0x32,0x22,
\r
343 0x42,0x22,0x07,0x03,0x88,0x88,0x88,0x27,0x27,0x27,
\r
344 0x0B,0x0A,0x09,0x40,0x30,0x01,0x03,0x00,0x05,0xE0,
\r
345 0x01,0x20,0x03,0x00,0x00,0xFF,0xFF,0x42,0x2B,0x00,
\r
346 0x00,0x23,0x14,0x05,0x06,0x00,0x00,0x00,0x00,0x00,
\r
347 0x14,0x10,0xC6,0x02,0x00,0x40,0x17,0x88,0x20,0x00,
\r
348 0x60,0x70,0x80,0x90,0x0D,0x40,0x30,0x25,0x20,0x00,
\r
349 0x00,0x00,0x00,0x00,0x00,0x01*/
\r
350 0x12,0x10,0x0E,0x0C,0x0A,0x08,0x06,0x04,0x02,0x00,
\r
351 0x02,0x22,0x12,0x22,0x22,0x22,0x32,0x22,0x42,0x22,
\r
352 0x52,0x22,0x62,0x22,0x72,0x22,0x83,0x22,0x92,0x22,
\r
353 0xA2,0x22,0xB2,0x22,0xC2,0x22,0xD2,0x22,0xE2,0x22,
\r
354 0xF2,0x22,0x1B,0x03,0x28,0x28,0x28,0x20,0x20,0x20,
\r
355 0x0F,0x0F,0x0A,0x45,0x30,0x04,0x03,0x00,0x05,0xE0,
\r
356 0x01,0x20,0x03,0x00,0x00,0x38,0x33,0x35,0x30,0x00,
\r
357 0x00,0x26,0x14,0x02,0x0A,0x00,0x00,0x00,0x00,0x00,
\r
358 0x14,0x10,0x30,0x02,0x00,0x00,0x00,0x00,0x00,0x00,
\r
359 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
\r
360 0x00,0x00,0x00,0x00,0x00,0x01
\r
364 config_info[62] = TOUCH_MAX_WIDTH >> 8;
\r
365 config_info[61] = TOUCH_MAX_WIDTH & 0xff;
\r
366 config_info[64] = TOUCH_MAX_HEIGHT >> 8;
\r
367 config_info[63] = TOUCH_MAX_HEIGHT & 0xff;
\r
369 ret = i2c_write_bytes(ts->client, config_info, sizeof(config_info)/sizeof(config_info[0]));
\r
372 dev_info(&ts->client->dev, "GT811 Send config failed!\n");
\r
375 ts->abs_y_max = (config_info[62]<<8) + config_info[61];
\r
376 ts->abs_x_max = (config_info[64]<<8) + config_info[63];
\r
377 ts->max_touch_num = config_info[60];
\r
378 ts->int_trigger_type = ((config_info[57]>>3)&0x01);
\r
379 dev_info(&ts->client->dev, "GT811 init info:X_MAX=%d,Y_MAX=%d,TRIG_MODE=%s\n",
\r
380 ts->abs_x_max, ts->abs_y_max, ts->int_trigger_type?"RISING EDGE":"FALLING EDGE");
\r
385 /*******************************************************
\r
387 Read gt811 IC Version
\r
393 *******************************************************/
\r
394 static short goodix_read_version(struct gt811_ts_data *ts)
\r
397 uint8_t version_data[5]={0x07,0x17,0,0}; //store touchscreen version infomation
\r
398 uint8_t version_data2[5]={0x07,0x17,0,0}; //store touchscreen version infomation
\r
402 memset(version_data, 0, 5);
\r
403 version_data[0]=0x07;
\r
404 version_data[1]=0x17;
\r
406 ret=i2c_read_bytes(ts->client, version_data, 4);
\r
410 for(i = 0;i < 10;i++)
\r
412 i2c_read_bytes(ts->client, version_data2, 4);
\r
413 if((version_data[2] !=version_data2[2])||(version_data[3] != version_data2[3]))
\r
415 version_data[2] = version_data2[2];
\r
416 version_data[3] = version_data2[3];
\r
426 ts->version = (version_data[2]<<8)+version_data[3];
\r
427 dev_info(&ts->client->dev, "GT811 Verion:0x%04x\n", ts->version);
\r
432 dev_info(&ts->client->dev," Guitar Version Read Error: %d.%d\n",version_data[3],version_data[2]);
\r
433 ts->version = 0xffff;
\r
440 /******************start add by kuuga*******************/
\r
441 static void gt811_irq_enable(struct gt811_ts_data *ts)
\r
443 unsigned long irqflags;
\r
444 spin_lock_irqsave(&ts->irq_lock, irqflags);
\r
445 if (ts->irq_is_disable)
\r
447 enable_irq(ts->irq);
\r
448 ts->irq_is_disable = 0;
\r
450 spin_unlock_irqrestore(&ts->irq_lock, irqflags);
\r
453 static void gt811_irq_disable(struct gt811_ts_data *ts)
\r
455 unsigned long irqflags;
\r
456 spin_lock_irqsave(&ts->irq_lock, irqflags);
\r
457 if (!ts->irq_is_disable)
\r
459 disable_irq_nosync(ts->irq);
\r
460 ts->irq_is_disable = 1;
\r
462 spin_unlock_irqrestore(&ts->irq_lock, irqflags);
\r
465 /*****************end add by kuuga****************/
\r
467 /*******************************************************
\r
469 Touch-screen work function
\r
470 Triggered by the interruption, to accept a set of coordinate data,
\r
471 and then analyze the output parity
\r
473 ts: client private data structure
\r
475 Results of the implementation code, 0 for normal execution
\r
476 ********************************************************/
\r
477 static void goodix_ts_work_func(struct work_struct *work)
\r
479 uint8_t point_data[READ_BYTES_NUM] = {READ_TOUCH_ADDR_H,READ_TOUCH_ADDR_L,0};//point_data[8*MAX_FINGER_NUM+2]={ 0 };
\r
480 uint8_t check_sum = 0;
\r
481 uint8_t read_position = 0;
\r
482 uint8_t track_id[MAX_FINGER_NUM];
\r
483 uint8_t point_index = 0;
\r
484 uint8_t point_tmp = 0;
\r
485 uint8_t point_count = 0;
\r
486 uint16_t input_x = 0;
\r
487 uint16_t input_y = 0;
\r
488 uint8_t input_w = 0;
\r
489 static uint8_t last_key = 0;
\r
490 uint8_t finger = 0;
\r
492 unsigned int count = 0;
\r
493 unsigned int position = 0;
\r
497 struct gt811_ts_data *ts = container_of(work, struct gt811_ts_data, work);
\r
499 printk("int count :%d\n", ++int_count);
\r
500 printk("ready?:%d\n", raw_data_ready);
\r
502 if (RAW_DATA_ACTIVE == raw_data_ready)
\r
504 raw_data_ready = RAW_DATA_READY;
\r
506 printk("ready!\n");
\r
515 dev_info(&(ts->client->dev), "Because of transfer error,touchscreen stop working.\n");
\r
519 ret=i2c_read_bytes(ts->client, point_data, sizeof(point_data)/sizeof(point_data[0]));
\r
522 dev_err(&(ts->client->dev),"I2C transfer error. Number:%d\n ", ret);
\r
527 goto COORDINATE_POLL;
\r
533 for(count=0;count<(sizeof(point_data)/sizeof(point_data[0])); count++)
\r
535 printk("[%2d]:0x%2x", count, point_data[count]);
\r
536 if((count+1)%10==0)printk("\n");
\r
540 if(point_data[2]&0x20)
\r
542 if(point_data[3]==0xF0)
\r
544 gpio_direction_output(reset_pin, 0);
\r
546 // gpio_direction_input(reset_pin);
\r
547 gpio_set_value(reset_pin,0);
\r
549 gpio_set_value(reset_pin,1);
\r
552 goodix_init_panel(ts);
\r
553 goto WORK_FUNC_END;
\r
556 switch(point_data[2]& 0x1f)
\r
560 for(count=2; count<9; count++)
\r
561 check_sum += (int)point_data[count];
\r
566 for(count=2; count<14;count++)
\r
567 check_sum += (int)point_data[count];
\r
568 read_position = 14;
\r
570 default: //touch finger larger than 3
\r
571 for(count=2; count<35;count++)
\r
572 check_sum += (int)point_data[count];
\r
573 read_position = 35;
\r
575 if(check_sum != point_data[read_position])
\r
577 dev_info(&ts->client->dev, "coor chksum error!\n");
\r
581 point_index = point_data[2]&0x1f;
\r
582 point_tmp = point_index;
\r
583 for(position=0; (position<MAX_FINGER_NUM)&&point_tmp; position++)
\r
587 track_id[point_count++] = position;
\r
591 finger = point_count;
\r
594 for(count=0; count<finger; count++)
\r
596 if(track_id[count]!=3)
\r
598 if(track_id[count]<3)
\r
599 position = 4+track_id[count]*5;
\r
602 input_x = (uint16_t)(point_data[position]<<8)+(uint16_t)point_data[position+1];
\r
603 input_y = (uint16_t)(point_data[position+2]<<8)+(uint16_t)point_data[position+3];
\r
604 input_w = point_data[position+4];
\r
608 input_x = (uint16_t)(point_data[19]<<8)+(uint16_t)point_data[26];
\r
609 input_y = (uint16_t)(point_data[27]<<8)+(uint16_t)point_data[28];
\r
610 input_w = point_data[29];
\r
613 //printk("real_input_y = %d,TOUCH_MAX_HEIGHT=%d,TOUCH_MAX_WIDTH=%d,input_x=%d,input_y=%d,input_w=%d\n",input_y, TOUCH_MAX_HEIGHT,TOUCH_MAX_WIDTH,TOUCH_MAX_HEIGHT - input_y,TOUCH_MAX_WIDTH-input_x, input_w);
\r
614 //if((input_y > ts->abs_x_max)||(TOUCH_MAX_WIDTH-input_x > ts->abs_y_max))continue;
\r
615 input_mt_slot(ts->input_dev, track_id[count]);
\r
616 //input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, false);
\r
617 input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, true);
\r
620 input_report_abs(ts->input_dev, ABS_MT_POSITION_X, input_y);
\r
621 input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, input_x);
\r
622 input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, input_w);
\r
623 //input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, input_w);
\r
624 //input_report_abs(ts->input_dev, ABS_MT_TRACKING_ID, track_id[count]);
\r
625 //input_mt_sync(ts->input_dev);
\r
630 for(tmp=0; tmp< MAX_FINGER_NUM; tmp++)
\r
632 //printk("tmp=%d\n", tmp);
\r
633 input_mt_slot(ts->input_dev, tmp);//æ
\8c\89åº
\8få
\8f·ä¸
\8aæ
\8a? //input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0);
\r
634 input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, false);
\r
636 //input_mt_sync(ts->input_dev);
\r
639 //input_report_key(ts->input_dev, BTN_TOUCH, finger > 0);
\r
640 input_sync(ts->input_dev);
\r
642 #ifdef HAVE_TOUCH_KEY
\r
643 key = point_data[3]&0x0F;
\r
644 if((last_key != 0)||(key != 0))
\r
646 for(count = 0; count < MAX_KEY_NUM; count++)
\r
648 //printk("####################input_report_key++++++++++++%d\n",key);
\r
649 input_report_key(ts->input_dev, touch_key_array[count], !!(key&(0x01<<count)));
\r
657 #ifndef STOP_IRQ_TYPE
\r
659 gt811_irq_enable(ts); //KT ADD 1202
\r
663 /*******************************************************
\r
665 Response function timer
\r
666 Triggered by a timer, scheduling the work function of the touch screen operation; after re-timing
\r
668 timer: the timer function is associated
\r
670 Timer mode, HRTIMER_NORESTART that do not automatically restart
\r
671 ********************************************************/
\r
672 static enum hrtimer_restart goodix_ts_timer_func(struct hrtimer *timer)
\r
674 struct gt811_ts_data *ts = container_of(timer, struct gt811_ts_data, timer);
\r
675 queue_work(goodix_wq, &ts->work);
\r
676 hrtimer_start(&ts->timer, ktime_set(0, (POLL_TIME+6)*1000000), HRTIMER_MODE_REL);
\r
677 return HRTIMER_NORESTART;
\r
680 /*******************************************************
\r
682 Interrupt response function
\r
683 Triggered by an interrupt, the scheduler runs the touch screen handler
\r
684 ********************************************************/
\r
685 static irqreturn_t goodix_ts_irq_handler(int irq, void *dev_id)
\r
687 struct gt811_ts_data *ts = dev_id;
\r
689 #ifndef STOP_IRQ_TYPE
\r
690 gt811_irq_disable(ts); //KT ADD 1202
\r
692 //disable_irq_nosync(ts->client->irq);
\r
693 queue_work(goodix_wq, &ts->work);
\r
695 return IRQ_HANDLED;
\r
698 /*******************************************************
\r
700 Power management gt811, gt811 allowed to sleep or to wake up
\r
702 on: 0 that enable sleep, wake up 1
\r
704 Is set successfully, 0 for success
\r
705 Error code: -1 for the i2c error, -2 for the GPIO error;-EINVAL on error as a parameter
\r
706 ********************************************************/
\r
707 static int goodix_ts_power(struct gt811_ts_data * ts, int on)
\r
711 unsigned char i2c_control_buf[3] = {0x06,0x92,0x01}; //suspend cmd
\r
714 if(ts != NULL && !ts->use_irq)
\r
720 ret = i2c_write_bytes(ts->client, i2c_control_buf, 3);
\r
721 printk("ret++++++++++++++++= %d=\n",ret);
\r
722 dev_info(&ts->client->dev, "Send suspend cmd\n");
\r
723 if(ret < 0) //failed
\r
728 printk("++++ reset_pin: %d \n",reset_pin);
\r
729 if(reset_pin > 0 ){
\r
730 gpio_direction_output(reset_pin,0);
\r
732 gpio_set_value(reset_pin,0);
\r
734 gpio_set_value(reset_pin,1);
\r
738 gpio_direction_output(irq_to_gpio(ts->client->irq), 0);
\r
740 gpio_direction_output(irq_to_gpio(ts->client->irq), 1);
\r
743 unsigned int gpio = irq_to_gpio(ts->client->irq);
\r
744 gpio_set_value(gpio, 0);
\r
745 gpio_direction_input(gpio);
\r
751 dev_info(&ts->client->dev, "%s: Cant't support this command.", s3c_ts_name);
\r
756 /*******************************************************
\r
758 Touch-screen detection function
\r
759 Called when the registration drive (required for a corresponding client);
\r
760 For IO, interrupts and other resources to apply; equipment registration; touch screen initialization, etc.
\r
762 client: the device structure to be driven
\r
765 Results of the implementation code, 0 for normal execution
\r
766 ********************************************************/
\r
767 static int goodix_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)
\r
772 char test_data = 1;
\r
773 char buf[2]={0}; //w++
\r
774 unsigned char read_data[2] = {0,0 };
\r
775 const char irq_table[2] = {IRQF_TRIGGER_FALLING,IRQF_TRIGGER_RISING};
\r
776 struct gt811_ts_data *ts;
\r
777 // struct gt811_platform_data *811data = client->dev.platform_data;
\r
778 struct goodix_platform_data *pdata;
\r
779 dev_info(&client->dev,"Install gt811 driver.\n");
\r
780 dev_info(&client->dev,"Driver Release Date:2012-02-08\n");
\r
782 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
\r
784 dev_err(&client->dev, "Must have I2C_FUNC_I2C.\n");
\r
786 goto err_check_functionality_failed;
\r
789 ret=i2c_read_bytes(client, read_data, sizeof(read_data)/sizeof(read_data[0]));
\r
792 dev_err(&client->dev, "Must have GT811.\n");
\r
793 goto err_check_functionality_failed;
\r
797 ts = kzalloc(sizeof(*ts), GFP_KERNEL);
\r
800 goto err_alloc_data_failed;
\r
803 i2c_connect_client = client;
\r
804 ts->client = client;
\r
805 i2c_set_clientdata(client, ts);
\r
806 pdata = client->dev.platform_data;
\r
807 #ifdef CONFIG_RK_CONFIG
\r
809 reset_pin = get_port_config(rst).gpio;
\r
810 client->irq = get_port_config(irq).gpio;
\r
814 reset_pin = pdata->rest_pin;
\r
816 if (pdata->init_platform_hw)
\r
818 pdata->init_platform_hw();
\r
824 gpio_free(SHUTDOWN_PORT);
\r
825 ret = gpio_request(SHUTDOWN_PORT, "RESET_INT");
\r
828 dev_err(&client->dev, "Failed to request RESET GPIO:%d, ERRNO:%d\n",(int)SHUTDOWN_PORT,ret);
\r
829 goto err_gpio_request;
\r
832 rk29_mux_api_set(GPIO0D3_PWM_1_NAME,GPIO0D_GPIO0D3);
\r
833 gpio_pull_updown(SHUTDOWN_PORT, 1); //set GPIO pull-up
\r
835 for(retry=0;retry <= 10; retry++)
\r
837 gpio_direction_output(reset_pin,0);
\r
839 // gpio_direction_input(reset_pin);//setinput means not ack so set the reset high
\r
841 gpio_set_value(reset_pin,1);
\r
843 gpio_set_value(reset_pin,0);
\r
845 gpio_set_value(reset_pin,1);
\r
847 val_ret = gpio_get_value(reset_pin);
\r
848 ret = i2c_write_bytes(client, &test_data, 1);
\r
849 //ret =i2c_master_reg8_recv(client, 0x00, buf, 2, 200*1000);//i2c_write_bytes(client, &test_data, 1); //Test I2C connection.
\r
852 dev_info(&client->dev, "GT811 I2C TEST FAILED!Please check the HARDWARE connect\n");
\r
857 dev_err(&client->dev, "Warnning: I2C communication might be ERROR!\n");
\r
858 goto err_i2c_failed;
\r
861 INIT_WORK(&ts->work, goodix_ts_work_func); //init work_struct
\r
863 /////////////////////////////// UPDATE STEP 1 START/////////////////////////////////////////////////////////////////
\r
864 #ifdef AUTO_UPDATE_GT811 //modify by andrew
\r
866 goodix_read_version(ts);
\r
868 ret = gt811_downloader( ts, goodix_gt811_firmware);
\r
871 dev_err(&client->dev, "Warnning: gt811 update might be ERROR!\n");
\r
872 //goto err_input_dev_alloc_failed;
\r
875 ///////////////////////////////UPDATE STEP 1 END////////////////////////////////////////////////////////////////
\r
878 client->irq=TS_INT; //If not defined in client
\r
881 gpio_free(INT_PORT);
\r
882 ret = gpio_request(INT_PORT, "TS_INT"); //Request IO
\r
885 dev_err(&client->dev, "Failed to request GPIO:%d, ERRNO:%d\n",(int)INT_PORT,ret);
\r
886 goto err_gpio_request_failed;
\r
889 gpio_pull_updown(INT_PORT, NULL); //ret > 0 ?
\r
892 #ifndef STOP_IRQ_TYPE
\r
893 ts->irq = TS_INT; //KT ADD 1202
\r
894 ts->irq_is_disable = 0; // enable irq
\r
899 err_gpio_request_failed:
\r
900 for(retry=0; retry<3; retry++)
\r
902 ret=goodix_init_panel(ts);
\r
904 if(ret != 0) //Initiall failed
\r
912 goto err_init_godix_ts;
\r
915 ts->input_dev = input_allocate_device();
\r
916 if (ts->input_dev == NULL)
\r
919 dev_dbg(&client->dev,"goodix_ts_probe: Failed to allocate input device\n");
\r
920 goto err_input_dev_alloc_failed;
\r
923 //ts->input_dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) ;
\r
924 //ts->input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
\r
925 //////ts->input_dev->absbit[0] = BIT(ABS_X) | BIT(ABS_Y) | BIT(ABS_PRESSURE);
\r
926 #ifdef HAVE_TOUCH_KEY
\r
927 for(retry = 0; retry < MAX_KEY_NUM; retry++)
\r
929 input_set_capability(ts->input_dev,EV_KEY,touch_key_array[retry]);
\r
933 input_set_abs_params(ts->input_dev, ABS_X, 0, ts->abs_x_max, 0, 0);
\r
934 input_set_abs_params(ts->input_dev, ABS_Y, 0, ts->abs_y_max, 0, 0);
\r
935 input_set_abs_params(ts->input_dev, ABS_PRESSURE, 0, 255, 0, 0);
\r
937 #ifdef GOODIX_MULTI_TOUCH
\r
939 __set_bit(INPUT_PROP_DIRECT, ts->input_dev->propbit);
\r
940 __set_bit(EV_ABS, ts->input_dev->evbit);
\r
942 input_mt_init_slots(ts->input_dev, ts->max_touch_num);
\r
943 input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
\r
944 #ifdef CONFIG_RK_CONFIG
\r
945 input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X, 0, x_max, 0, 0);
\r
946 input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y, 0, y_max, 0, 0);
\r
948 input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X, 0, ts->abs_x_max, 0, 0);
\r
949 input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y, 0, ts->abs_y_max, 0, 0);
\r
955 sprintf(ts->phys, "input/ts");
\r
956 ts->input_dev->name = s3c_ts_name;
\r
957 ts->input_dev->phys = ts->phys;
\r
958 ts->input_dev->id.bustype = BUS_I2C;
\r
959 ts->input_dev->id.vendor = 0xDEAD;
\r
960 ts->input_dev->id.product = 0xBEEF;
\r
961 ts->input_dev->id.version = 10427; //screen firmware version
\r
963 ret = input_register_device(ts->input_dev);
\r
965 dev_err(&client->dev,"Probe: Unable to register %s input device\n", ts->input_dev->name);
\r
966 goto err_input_register_device_failed;
\r
971 ret = request_irq(gpio_to_irq(client->irq), goodix_ts_irq_handler ,irq_table[ts->int_trigger_type],
\r
975 dev_err(&client->dev,"Cannot allocate ts INT!ERRNO:%d\n", ret);
\r
976 gpio_direction_input(client->irq);
\r
977 gpio_free(client->irq);
\r
978 goto err_init_godix_ts;
\r
982 #ifndef STOP_IRQ_TYPE
\r
983 gt811_irq_disable(ts); //KT ADD 1202
\r
985 // disable_irq(client->irq);
\r
988 dev_dbg(&client->dev,"Reques EIRQ %d succesd on GPIO:%d\n",client->irq,client->irq);
\r
995 hrtimer_init(&ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
\r
996 ts->timer.function = goodix_ts_timer_func;
\r
997 hrtimer_start(&ts->timer, ktime_set(1, 0), HRTIMER_MODE_REL);
\r
1001 #ifndef STOP_IRQ_TYPE
\r
1002 gt811_irq_enable(ts); //KT ADD 1202
\r
1004 // enable_irq(client->irq);
\r
1007 ts->power = goodix_ts_power;
\r
1009 goodix_read_version(ts);
\r
1011 #ifdef CONFIG_HAS_EARLYSUSPEND
\r
1012 ts->early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB;//EARLY_SUSPEND_LEVEL_BLANK_SCREEN +1;
\r
1013 ts->early_suspend.suspend = goodix_ts_early_suspend;
\r
1014 ts->early_suspend.resume = goodix_ts_late_resume;
\r
1015 register_early_suspend(&ts->early_suspend);
\r
1018 /////////////////////////////// UPDATE STEP 2 START /////////////////////////////////////////////////////////////////
\r
1019 #ifdef CONFIG_TOUCHSCREEN_GOODIX_IAP
\r
1020 goodix_proc_entry = create_proc_entry("goodix-update", 0666, NULL);
\r
1021 if(goodix_proc_entry == NULL)
\r
1023 dev_info(&client->dev, "Couldn't create proc entry!\n");
\r
1025 goto err_create_proc_entry;
\r
1029 dev_info(&client->dev, "Create proc entry success!\n");
\r
1030 goodix_proc_entry->write_proc = goodix_update_write;
\r
1031 goodix_proc_entry->read_proc = goodix_update_read;
\r
1034 ///////////////////////////////UPDATE STEP 2 END /////////////////////////////////////////////////////////////////
\r
1035 dev_info(&client->dev,"Start %s in %s mode,Driver Modify Date:2012-01-05\n",
\r
1036 ts->input_dev->name, ts->use_irq ? "interrupt" : "polling");
\r
1039 err_init_godix_ts:
\r
1044 free_irq(gpio_to_irq(client->irq),ts);
\r
1046 gpio_direction_input(client->irq);
\r
1047 gpio_free(client->irq);
\r
1051 hrtimer_cancel(&ts->timer);
\r
1053 err_input_register_device_failed:
\r
1054 input_free_device(ts->input_dev);
\r
1056 err_input_dev_alloc_failed:
\r
1057 i2c_set_clientdata(client, NULL);
\r
1059 gpio_free(reset_pin);
\r
1062 err_alloc_data_failed:
\r
1063 err_check_functionality_failed:
\r
1064 err_create_proc_entry:
\r
1069 /*******************************************************
\r
1071 Drive the release of resources
\r
1073 client: the device structure
\r
1075 Results of the implementation code, 0 for normal execution
\r
1076 ********************************************************/
\r
1077 static int goodix_ts_remove(struct i2c_client *client)
\r
1079 struct gt811_ts_data *ts = i2c_get_clientdata(client);
\r
1080 #ifdef CONFIG_HAS_EARLYSUSPEND
\r
1081 unregister_early_suspend(&ts->early_suspend);
\r
1083 /////////////////////////////// UPDATE STEP 3 START/////////////////////////////////////////////////////////////////
\r
1084 #ifdef CONFIG_TOUCHSCREEN_GOODIX_IAP
\r
1085 remove_proc_entry("goodix-update", NULL);
\r
1087 /////////////////////////////////UPDATE STEP 3 END///////////////////////////////////////////////////////////////
\r
1089 if (ts && ts->use_irq)
\r
1092 gpio_direction_input(client->irq);
\r
1093 gpio_free(client->irq);
\r
1095 free_irq(gpio_to_irq(client->irq), ts);
\r
1098 hrtimer_cancel(&ts->timer);
\r
1100 dev_notice(&client->dev,"The driver is removing...\n");
\r
1101 i2c_set_clientdata(client, NULL);
\r
1102 input_unregister_device(ts->input_dev);
\r
1108 static int goodix_ts_suspend(struct i2c_client *client, pm_message_t mesg)
\r
1111 struct gt811_ts_data *ts = i2c_get_clientdata(client);
\r
1112 disable_irq(gpio_to_irq(client->irq));
\r
1115 ret = ts->power(ts, 0);
\r
1116 printk("goodix_ts suspend >>>>>>>>>ret=%d \n",ret);
\r
1118 printk(KERN_ERR "goodix_ts_suspend power on failed\n");
\r
1122 static int goodix_ts_resume(struct i2c_client *client)
\r
1125 struct gt811_ts_data *ts = i2c_get_clientdata(client);
\r
1128 ret = ts->power(ts, 1);
\r
1129 printk("resume >>>>>>>>>ret=%d",ret);
\r
1131 printk(KERN_ERR "goodix_ts_resume power on failed\n");
\r
1133 enable_irq(gpio_to_irq(client->irq));
\r
1137 #ifdef CONFIG_HAS_EARLYSUSPEND
\r
1138 static void goodix_ts_early_suspend(struct early_suspend *h)
\r
1140 struct gt811_ts_data *ts;
\r
1141 ts = container_of(h, struct gt811_ts_data, early_suspend);
\r
1142 goodix_ts_suspend(ts->client, PMSG_SUSPEND);
\r
1145 static void goodix_ts_late_resume(struct early_suspend *h)
\r
1147 struct gt811_ts_data *ts;
\r
1148 ts = container_of(h, struct gt811_ts_data, early_suspend);
\r
1149 goodix_ts_resume(ts->client);
\r
1152 /////////////////////////////// UPDATE STEP 4 START/////////////////////////////////////////////////////////////////
\r
1153 //******************************Begin of firmware update surpport*******************************
\r
1154 #ifdef CONFIG_TOUCHSCREEN_GOODIX_IAP
\r
1155 static struct file * update_file_open(char * path, mm_segment_t * old_fs_p)
\r
1157 struct file * filp = NULL;
\r
1160 filp = filp_open(path, O_RDONLY, 0644);
\r
1162 if(!filp || IS_ERR(filp))
\r
1167 errno = PTR_ERR(filp);
\r
1168 printk(KERN_ERR "The update file for Guitar open error.\n");
\r
1171 *old_fs_p = get_fs();
\r
1174 filp->f_op->llseek(filp,0,0);
\r
1178 static void update_file_close(struct file * filp, mm_segment_t old_fs)
\r
1182 filp_close(filp, NULL);
\r
1184 static int update_get_flen(char * path)
\r
1186 struct file * file_ck = NULL;
\r
1187 mm_segment_t old_fs;
\r
1190 file_ck = update_file_open(path, &old_fs);
\r
1191 if(file_ck == NULL)
\r
1194 length = file_ck->f_op->llseek(file_ck, 0, SEEK_END);
\r
1195 //printk("File length: %d\n", length);
\r
1198 update_file_close(file_ck, old_fs);
\r
1202 static int goodix_update_write(struct file *filp, const char __user *buff, unsigned long len, void *data)
\r
1204 unsigned char cmd[120];
\r
1207 static unsigned char update_path[60];
\r
1208 struct gt811_ts_data *ts;
\r
1209 struct file * file_data = NULL;
\r
1210 mm_segment_t old_fs;
\r
1211 unsigned char *file_ptr = NULL;
\r
1212 unsigned int file_len;
\r
1214 ts = i2c_get_clientdata(i2c_connect_client);
\r
1217 printk(KERN_INFO"goodix write to kernel via proc file!@@@@@@\n");
\r
1221 //printk(KERN_INFO"goodix write to kernel via proc file!@@@@@@\n");
\r
1222 if(copy_from_user(&cmd, buff, len))
\r
1224 printk(KERN_INFO"goodix write to kernel via proc file!@@@@@@\n");
\r
1227 //printk(KERN_INFO"Write cmd is:%d,write len is:%ld\n",cmd[0], len);
\r
1230 case APK_UPDATE_TP:
\r
1231 printk(KERN_INFO"Write cmd is:%d,cmd arg is:%s,write len is:%ld\n",cmd[0], &cmd[1], len);
\r
1232 memset(update_path, 0, 60);
\r
1233 strncpy(update_path, cmd+1, 60);
\r
1235 #ifndef STOP_IRQ_TYPE
\r
1236 gt811_irq_disable(ts); //KT ADD 1202
\r
1238 // disable_irq(ts->client->irq);
\r
1240 file_data = update_file_open(update_path, &old_fs);
\r
1241 if(file_data == NULL) //file_data has been opened at the last time
\r
1243 dev_info(&ts->client->dev, "cannot open update file\n");
\r
1247 file_len = update_get_flen(update_path);
\r
1248 dev_info(&ts->client->dev, "Update file length:%d\n", file_len);
\r
1249 file_ptr = (unsigned char*)vmalloc(file_len);
\r
1250 if(file_ptr==NULL)
\r
1252 dev_info(&ts->client->dev, "cannot malloc memory!\n");
\r
1256 ret = file_data->f_op->read(file_data, file_ptr, file_len, &file_data->f_pos);
\r
1259 dev_info(&ts->client->dev, "read file data failed\n");
\r
1262 update_file_close(file_data, old_fs);
\r
1264 ret = gt811_downloader(ts, file_ptr);
\r
1268 printk(KERN_INFO"Warnning: GT811 update might be ERROR!\n");
\r
1272 // i2c_pre_cmd(ts);
\r
1274 gpio_direction_output(reset_pin, 0);
\r
1276 gpio_direction_input(reset_pin);
\r
1278 for(retry=0; retry<3; retry++)
\r
1280 ret=goodix_init_panel(ts);
\r
1282 if(ret != 0) //Initiall failed
\r
1284 dev_info(&ts->client->dev, "Init panel failed!\n");
\r
1292 // s3c_gpio_cfgpin(INT_PORT, INT_CFG); //Set IO port function
\r
1293 //gpio_direction_input(INT_PORT);
\r
1294 // s3c_gpio_setpull(INT_PORT, S3C_GPIO_PULL_UP);
\r
1295 // s3c_gpio_cfgpin(INT_PORT, INT_CFG); //Set IO port as interrupt port
\r
1296 //s3c_gpio_setpull(INT_PORT, S3C_GPIO_PULL_NONE);
\r
1298 #ifndef STOP_IRQ_TYPE
\r
1299 gt811_irq_enable(ts); //KT ADD 1202
\r
1301 // enable_irq(ts->client->irq);
\r
1303 // i2c_end_cmd(ts);
\r
1306 case APK_READ_FUN: //functional command
\r
1307 if(cmd[1] == CMD_READ_VER)
\r
1309 printk(KERN_INFO"Read version!\n");
\r
1310 ts->read_mode = MODE_RD_VER;
\r
1312 else if(cmd[1] == CMD_READ_CFG)
\r
1314 printk(KERN_INFO"Read config info!\n");
\r
1316 ts->read_mode = MODE_RD_CFG;
\r
1318 else if (cmd[1] == CMD_READ_RAW)
\r
1320 printk(KERN_INFO"Read raw data!\n");
\r
1322 ts->read_mode = MODE_RD_RAW;
\r
1324 else if (cmd[1] == CMD_READ_CHIP_TYPE)
\r
1326 printk(KERN_INFO"Read chip type!\n");
\r
1328 ts->read_mode = MODE_RD_CHIP_TYPE;
\r
1332 case APK_WRITE_CFG:
\r
1333 printk(KERN_INFO"Begin write config info!Config length:%d\n",cmd[1]);
\r
1335 ret = i2c_write_bytes(ts->client, cmd+2, cmd[1]+2);
\r
1339 printk("Write Config failed!return:%d\n",ret);
\r
1350 static int goodix_update_read( char *page, char **start, off_t off, int count, int *eof, void *data )
\r
1354 int read_times = 0;
\r
1355 struct gt811_ts_data *ts;
\r
1357 unsigned char read_data[360] = {80, };
\r
1359 ts = i2c_get_clientdata(i2c_connect_client);
\r
1363 printk("___READ__\n");
\r
1364 if(ts->read_mode == MODE_RD_VER) //read version data
\r
1367 ret = goodix_read_version(ts);
\r
1371 printk(KERN_INFO"Read version data failed!\n");
\r
1375 read_data[1] = (char)(ts->version&0xff);
\r
1376 read_data[0] = (char)((ts->version>>8)&0xff);
\r
1378 memcpy(page, read_data, 2);
\r
1382 else if (ts->read_mode == MODE_RD_CHIP_TYPE)
\r
1387 else if(ts->read_mode == MODE_RD_CFG)
\r
1390 read_data[0] = 0x06;
\r
1391 read_data[1] = 0xa2; // cfg start address
\r
1392 printk("read config addr is:%x,%x\n", read_data[0],read_data[1]);
\r
1396 ret = i2c_read_bytes(ts->client, read_data, len+2);
\r
1400 printk(KERN_INFO"Read config info failed!\n");
\r
1404 memcpy(page, read_data+2, len);
\r
1407 else if (ts->read_mode == MODE_RD_RAW)
\r
1409 #define TIMEOUT (-100)
\r
1411 if (raw_data_ready != RAW_DATA_READY)
\r
1413 raw_data_ready = RAW_DATA_ACTIVE;
\r
1417 read_data[0] = 0x07;
\r
1418 read_data[1] = 0x11;
\r
1419 read_data[2] = 0x01;
\r
1421 ret = i2c_write_bytes(ts->client, read_data, 3);
\r
1424 sum += read_times;
\r
1425 printk("count :%d\n", ++access_count);
\r
1426 printk("A total of try times:%d\n", sum);
\r
1430 while (RAW_DATA_READY != raw_data_ready)
\r
1434 if (read_times++ > 10)
\r
1444 printk("read times:%d\n", read_times);
\r
1446 read_data[0] = 0x08;
\r
1447 read_data[1] = 0x80; // raw data address
\r
1454 ret = i2c_read_bytes(ts->client, read_data, len+2);
\r
1455 // i2c_end_cmd(ts);
\r
1459 printk(KERN_INFO"Read raw data failed!\n");
\r
1462 memcpy(page, read_data+2, len);
\r
1464 read_data[0] = 0x09;
\r
1465 read_data[1] = 0xC0;
\r
1466 // i2c_pre_cmd(ts);
\r
1467 ret = i2c_read_bytes(ts->client, read_data, len+2);
\r
1472 printk(KERN_INFO"Read raw data failed!\n");
\r
1475 memcpy(&page[160], read_data+2, len);
\r
1479 for (i = 0; i < 300; i++)
\r
1481 printk("%6x", page[i]);
\r
1483 if ((i+1) % 10 == 0)
\r
1488 //********************/
\r
1490 raw_data_ready = RAW_DATA_NON_ACTIVE;
\r
1498 //********************************************************************************************
\r
1499 static u8 is_equal( u8 *src , u8 *dst , int len )
\r
1504 for( i = 0 ; i < len ; i++ )
\r
1506 printk(KERN_INFO"[%02X:%02X]", src[i], dst[i]);
\r
1507 if((i+1)%10==0)printk("\n");
\r
1511 for( i = 0 ; i < len ; i++ )
\r
1513 if ( src[i] != dst[i] )
\r
1522 static u8 gt811_nvram_store( struct gt811_ts_data *ts )
\r
1526 u8 inbuf[3] = {REG_NVRCS_H,REG_NVRCS_L,0};
\r
1527 //u8 outbuf[3] = {};
\r
1528 ret = i2c_read_bytes( ts->client, inbuf, 3 );
\r
1535 if ( ( inbuf[2] & BIT_NVRAM_LOCK ) == BIT_NVRAM_LOCK )
\r
1540 inbuf[2] = (1<<BIT_NVRAM_STROE); //store command
\r
1542 for ( i = 0 ; i < 300 ; i++ )
\r
1544 ret = i2c_write_bytes( ts->client, inbuf, 3 );
\r
1553 static u8 gt811_nvram_recall( struct gt811_ts_data *ts )
\r
1556 u8 inbuf[3] = {REG_NVRCS_H,REG_NVRCS_L,0};
\r
1558 ret = i2c_read_bytes( ts->client, inbuf, 3 );
\r
1565 if ( ( inbuf[2]&BIT_NVRAM_LOCK) == BIT_NVRAM_LOCK )
\r
1570 inbuf[2] = ( 1 << BIT_NVRAM_RECALL ); //recall command
\r
1571 ret = i2c_write_bytes( ts->client , inbuf, 3);
\r
1575 static int gt811_reset( struct gt811_ts_data *ts )
\r
1580 unsigned char outbuf[3] = {0,0xff,0};
\r
1581 unsigned char inbuf[3] = {0,0xff,0};
\r
1584 gpio_direction_output(reset_pin,0);
\r
1586 gpio_direction_input(reset_pin);
\r
1588 for(retry=0;retry < 80; retry++)
\r
1590 ret =i2c_write_bytes(ts->client, inbuf, 0); //Test I2C connection.
\r
1594 ret =i2c_read_bytes(ts->client, inbuf, 3); //Test I2C connection.
\r
1597 if(inbuf[2] == 0x55)
\r
1599 ret =i2c_write_bytes(ts->client, outbuf, 3);
\r
1607 gpio_direction_output(reset_pin,0);
\r
1609 gpio_direction_input(reset_pin);
\r
1611 dev_info(&ts->client->dev, "i2c address failed\n");
\r
1615 dev_info(&ts->client->dev, "Detect address %0X\n", ts->client->addr);
\r
1620 static int gt811_reset2( struct gt811_ts_data *ts )
\r
1625 //unsigned char outbuf[3] = {0,0xff,0};
\r
1626 unsigned char inbuf[3] = {0,0xff,0};
\r
1629 gpio_direction_output(reset_pin,0);
\r
1631 gpio_direction_input(reset_pin);
\r
1633 for(retry=0;retry < 80; retry++)
\r
1635 ret =i2c_write_bytes(ts->client, inbuf, 0); //Test I2C connection.
\r
1639 ret =i2c_read_bytes(ts->client, inbuf, 3); //Test I2C connection.
\r
1642 // if(inbuf[2] == 0x55)
\r
1644 // ret =i2c_write_bytes(ts->client, outbuf, 3);
\r
1652 dev_info(&ts->client->dev, "Detect address %0X\n", ts->client->addr);
\r
1656 static int gt811_set_address_2( struct gt811_ts_data *ts )
\r
1658 unsigned char inbuf[3] = {0,0,0};
\r
1661 for ( i = 0 ; i < 12 ; i++ )
\r
1663 if ( i2c_read_bytes( ts->client, inbuf, 3) )
\r
1665 dev_info(&ts->client->dev, "Got response\n");
\r
1668 dev_info(&ts->client->dev, "wait for retry\n");
\r
1673 static u8 gt811_update_firmware( u8 *nvram, u16 start_addr, u16 length, struct gt811_ts_data *ts)
\r
1675 u8 ret,err,retry_time,i;
\r
1676 u16 cur_code_addr;
\r
1677 u16 cur_frame_num, total_frame_num, cur_frame_len;
\r
1678 u32 gt80x_update_rate;
\r
1680 unsigned char i2c_data_buf[PACK_SIZE+2] = {0,};
\r
1681 unsigned char i2c_chk_data_buf[PACK_SIZE+2] = {0,};
\r
1683 if( length > NVRAM_LEN - NVRAM_BOOT_SECTOR_LEN )
\r
1685 dev_info(&ts->client->dev, "Fw length %d is bigger than limited length %d\n", length, NVRAM_LEN - NVRAM_BOOT_SECTOR_LEN );
\r
1689 total_frame_num = ( length + PACK_SIZE - 1) / PACK_SIZE;
\r
1691 //gt80x_update_sta = _UPDATING;
\r
1692 gt80x_update_rate = 0;
\r
1694 for( cur_frame_num = 0 ; cur_frame_num < total_frame_num ; cur_frame_num++ )
\r
1698 dev_info(&ts->client->dev, "PACK[%d]\n",cur_frame_num);
\r
1699 cur_code_addr = /*NVRAM_UPDATE_START_ADDR*/start_addr + cur_frame_num * PACK_SIZE;
\r
1700 i2c_data_buf[0] = (cur_code_addr>>8)&0xff;
\r
1701 i2c_data_buf[1] = cur_code_addr&0xff;
\r
1703 i2c_chk_data_buf[0] = i2c_data_buf[0];
\r
1704 i2c_chk_data_buf[1] = i2c_data_buf[1];
\r
1706 if( cur_frame_num == total_frame_num - 1 )
\r
1708 cur_frame_len = length - cur_frame_num * PACK_SIZE;
\r
1712 cur_frame_len = PACK_SIZE;
\r
1715 //strncpy(&i2c_data_buf[2], &nvram[cur_frame_num*PACK_SIZE], cur_frame_len);
\r
1716 for(i=0;i<cur_frame_len;i++)
\r
1718 i2c_data_buf[2+i] = nvram[cur_frame_num*PACK_SIZE+i];
\r
1724 //ret = gt811_i2c_write( guitar_i2c_address, cur_code_addr, &nvram[cur_frame_num*I2C_FRAME_MAX_LENGTH], cur_frame_len );
\r
1725 ret = i2c_write_bytes(ts->client, i2c_data_buf, (cur_frame_len+2));
\r
1728 dev_info(&ts->client->dev, "write fail\n");
\r
1732 ret = i2c_read_bytes(ts->client, i2c_chk_data_buf, (cur_frame_len+2));
\r
1733 // ret = gt811_i2c_read( guitar_i2c_address, cur_code_addr, inbuf, cur_frame_len);
\r
1736 dev_info(&ts->client->dev, "read fail\n");
\r
1740 if( is_equal( &i2c_data_buf[2], &i2c_chk_data_buf[2], cur_frame_len ) == 0 )
\r
1742 dev_info(&ts->client->dev, "not equal\n");
\r
1746 } while ( err == 1 && (--retry_time) > 0 );
\r
1753 gt80x_update_rate = ( cur_frame_num + 1 )*128/total_frame_num;
\r
1759 dev_info(&ts->client->dev, "write nvram fail\n");
\r
1763 ret = gt811_nvram_store(ts);
\r
1769 dev_info(&ts->client->dev, "nvram store fail\n");
\r
1773 ret = gt811_nvram_recall(ts);
\r
1779 dev_info(&ts->client->dev, "nvram recall fail\n");
\r
1783 for ( cur_frame_num = 0 ; cur_frame_num < total_frame_num ; cur_frame_num++ ) // read out all the code
\r
1786 cur_code_addr = NVRAM_UPDATE_START_ADDR + cur_frame_num*PACK_SIZE;
\r
1788 i2c_chk_data_buf[0] = (cur_code_addr>>8)&0xff;
\r
1789 i2c_chk_data_buf[1] = cur_code_addr&0xff;
\r
1792 if ( cur_frame_num == total_frame_num-1 )
\r
1794 cur_frame_len = length - cur_frame_num*PACK_SIZE;
\r
1798 cur_frame_len = PACK_SIZE;
\r
1804 //ret = gt811_i2c_read( guitar_i2c_address, cur_code_addr, inbuf, cur_frame_len);
\r
1805 ret = i2c_read_bytes(ts->client, i2c_chk_data_buf, (cur_frame_len+2));
\r
1812 if( is_equal( &nvram[cur_frame_num*PACK_SIZE], &i2c_chk_data_buf[2], cur_frame_len ) == 0 )
\r
1816 } while ( err == 1 && (--retry_time) > 0 );
\r
1823 gt80x_update_rate = 127 + ( cur_frame_num + 1 )*128/total_frame_num;
\r
1826 gt80x_update_rate = 255;
\r
1827 //gt80x_update_sta = _UPDATECHKCODE;
\r
1831 dev_info(&ts->client->dev, "nvram validate fail\n");
\r
1838 static u8 gt811_update_proc( u8 *nvram, u16 start_addr , u16 length, struct gt811_ts_data *ts )
\r
1842 //struct tpd_info_t tpd_info;
\r
1843 GT811_SET_INT_PIN( ts->client->irq, 0 );
\r
1845 ret = gt811_reset(ts);
\r
1849 dev_info(&ts->client->dev, "reset fail\n");
\r
1853 ret = gt811_set_address_2( ts );
\r
1857 dev_info(&ts->client->dev, "set address fail\n");
\r
1861 ret = gt811_update_firmware( nvram, start_addr, length, ts);
\r
1865 dev_info(&ts->client->dev, "firmware update fail\n");
\r
1870 GT811_SET_INT_PIN( ts->client->irq, 1 );
\r
1871 // gpio_free(INT_PORT);
\r
1872 gpio_pull_updown(ts->client->irq, 0);
\r
1875 ret = gt811_reset2(ts);
\r
1879 dev_info(&ts->client->dev, "final reset fail\n");
\r
1887 // i2c_pre_cmd(ts);
\r
1888 while(goodix_read_version(ts)<0);
\r
1890 // i2c_end_cmd(ts);
\r
1894 u16 Little2BigEndian(u16 little_endian)
\r
1897 temp = little_endian&0xff;
\r
1898 return (temp<<8)+((little_endian>>8)&0xff);
\r
1901 int gt811_downloader( struct gt811_ts_data *ts, unsigned char * data)
\r
1903 struct tpd_firmware_info_t *fw_info = (struct tpd_firmware_info_t *)data;
\r
1905 //unsigned short checksum = 0;
\r
1906 //unsigned int checksum = 0;
\r
1907 unsigned int fw_checksum = 0;
\r
1908 //unsigned char fw_chip_type;
\r
1909 unsigned short fw_version;
\r
1910 unsigned short fw_start_addr;
\r
1911 unsigned short fw_length;
\r
1912 unsigned char *data_ptr;
\r
1913 //unsigned char *file_ptr = &(fw_info->chip_type);
\r
1914 int retry = 0,ret;
\r
1916 unsigned char rd_buf[4] = {0};
\r
1917 unsigned char *mandatory_base = "GOODIX";
\r
1918 unsigned char rd_rom_version;
\r
1919 unsigned char rd_chip_type;
\r
1920 unsigned char rd_nvram_flag;
\r
1922 //struct file * file_data = NULL;
\r
1923 //mm_segment_t old_fs;
\r
1924 //unsigned int rd_len;
\r
1925 //unsigned int file_len = 0;
\r
1926 //unsigned char i2c_data_buf[PACK_SIZE] = {0,};
\r
1931 ret = i2c_write_bytes(ts->client, rd_buf, 3);
\r
1934 dev_info(&ts->client->dev, "i2c write failed\n");
\r
1935 goto exit_downloader;
\r
1939 ret = i2c_read_bytes(ts->client, rd_buf, 3);
\r
1942 dev_info(&ts->client->dev, "i2c request failed!\n");
\r
1943 goto exit_downloader;
\r
1945 rd_chip_type = rd_buf[2];
\r
1948 ret = i2c_read_bytes(ts->client, rd_buf, 3);
\r
1951 dev_info(&ts->client->dev, "i2c read failed!\n");
\r
1952 goto exit_downloader;
\r
1954 rd_rom_version = rd_buf[2];
\r
1957 ret = i2c_read_bytes(ts->client, rd_buf, 3);
\r
1960 dev_info(&ts->client->dev, "i2c read failed!\n");
\r
1961 goto exit_downloader;
\r
1963 rd_nvram_flag = rd_buf[2];
\r
1965 fw_version = Little2BigEndian(fw_info->version);
\r
1966 fw_start_addr = Little2BigEndian(fw_info->start_addr);
\r
1967 fw_length = Little2BigEndian(fw_info->length);
\r
1968 data_ptr = &(fw_info->data);
\r
1970 dev_info(&ts->client->dev,"chip_type=0x%02x\n", fw_info->chip_type);
\r
1971 dev_info(&ts->client->dev,"version=0x%04x\n", fw_version);
\r
1972 dev_info(&ts->client->dev,"rom_version=0x%02x\n",fw_info->rom_version);
\r
1973 dev_info(&ts->client->dev,"start_addr=0x%04x\n",fw_start_addr);
\r
1974 dev_info(&ts->client->dev,"file_size=0x%04x\n",fw_length);
\r
1975 fw_checksum = ((u32)fw_info->checksum[0]<<16) + ((u32)fw_info->checksum[1]<<8) + ((u32)fw_info->checksum[2]);
\r
1976 dev_info(&ts->client->dev,"fw_checksum=0x%06x\n",fw_checksum);
\r
1977 dev_info(&ts->client->dev,"%s\n", __func__ );
\r
1978 dev_info(&ts->client->dev,"current version 0x%04X, target verion 0x%04X\n", ts->version, fw_version );
\r
1981 if(rd_chip_type!=fw_info->chip_type)
\r
1983 dev_info(&ts->client->dev, "Chip type not match,exit downloader\n");
\r
1984 goto exit_downloader;
\r
1987 //chk_mask_version:
\r
1988 if(!rd_rom_version)
\r
1990 if(fw_info->rom_version!=0x45)
\r
1992 dev_info(&ts->client->dev, "Rom version not match,exit downloader\n");
\r
1993 goto exit_downloader;
\r
1995 dev_info(&ts->client->dev, "Rom version E.\n");
\r
1996 goto chk_fw_version;
\r
1998 else if(rd_rom_version!=fw_info->rom_version);
\r
2000 dev_info(&ts->client->dev, "Rom version not match,exidownloader\n");
\r
2001 goto exit_downloader;
\r
2003 dev_info(&ts->client->dev, "Rom version %c\n",rd_rom_version);
\r
2006 if(rd_nvram_flag==0x55)
\r
2008 dev_info(&ts->client->dev, "NVRAM correct!\n");
\r
2009 goto chk_fw_version;
\r
2011 else if(rd_nvram_flag==0xAA)
\r
2013 dev_info(&ts->client->dev, "NVRAM incorrect!Need update.\n");
\r
2014 goto begin_upgrade;
\r
2018 dev_info(&ts->client->dev, "NVRAM other error![0x694]=0x%02x\n", rd_nvram_flag);
\r
2019 goto begin_upgrade;
\r
2022 // ts->version -= 1; //test by andrew
\r
2023 if( ts->version >= fw_version ) // current low byte higher than back-up low byte
\r
2025 dev_info(&ts->client->dev, "Fw verison not match.\n");
\r
2026 goto chk_mandatory_upgrade;
\r
2028 dev_info(&ts->client->dev,"Need to upgrade\n");
\r
2029 goto begin_upgrade;
\r
2030 chk_mandatory_upgrade:
\r
2031 // dev_info(&ts->client->dev, "%s\n", mandatory_base);
\r
2032 // dev_info(&ts->client->dev, "%s\n", fw_info->mandatory_flag);
\r
2033 ret = memcmp(mandatory_base, fw_info->mandatory_flag, 6);
\r
2036 dev_info(&ts->client->dev,"Not meet mandatory upgrade,exit downloader!ret:%d\n", ret);
\r
2037 goto exit_downloader;
\r
2039 dev_info(&ts->client->dev, "Mandatory upgrade!\n");
\r
2041 dev_info(&ts->client->dev, "Begin upgrade!\n");
\r
2042 // goto exit_downloader;
\r
2043 dev_info(&ts->client->dev,"STEP_0:\n");
\r
2046 dev_info(&ts->client->dev, "STEP_1:\n");
\r
2048 while( retry < 3 )
\r
2050 // ret = gt811_update_proc( data_ptr,fw_start_addr, fw_length, ts);
\r
2060 //mt_set_gpio_mode(GPIO_CTP_EINT_PIN, GPIO_CTP_EINT_PIN_M_EINT);
\r
2061 // mt_set_gpio_out(GPIO_CTP_EN_PIN, GPIO_OUT_ONE);
\r
2062 // gpio_direction_output(INT_PORT,1);
\r
2064 gpio_free(ts->client->irq);
\r
2065 gpio_pull_updown(ts->client->irq, 0);
\r
2069 //******************************End of firmware update surpport*******************************
\r
2070 /////////////////////////////// UPDATE STEP 4 END /////////////////////////////////////////////////////////////////
\r
2072 //å
\8f¯ç
\94¨äº
\8e该驱å
\8a¨ç
\9a?设å¤
\87å
\90\8dâ
\80\94设å¤
\87ID å
\88\97表
\r
2074 static const struct i2c_device_id goodix_ts_id[] = {
\r
2075 { GOODIX_I2C_NAME, 0 },
\r
2079 //设å¤
\87驱å
\8a¨ç»
\93æ
\9e\84ä½?
\r
2080 static struct i2c_driver goodix_ts_driver = {
\r
2081 .probe = goodix_ts_probe,
\r
2082 .remove = goodix_ts_remove,
\r
2083 #ifndef CONFIG_HAS_EARLYSUSPEND
\r
2084 .suspend = goodix_ts_suspend,
\r
2085 .resume = goodix_ts_resume,
\r
2087 .id_table = goodix_ts_id,
\r
2089 .name = GOODIX_I2C_NAME,
\r
2090 .owner = THIS_MODULE,
\r
2094 /*******************************************************
\r
2095 å
\8a\9fè
\83½ï¼? 驱å
\8a¨å
\8a è½½å
\87½æ
\95°
\r
2096 returnï¼? æ
\89§è¡
\8cç»
\93æ
\9e\9cç
\81ï¼
\8c0表示æ£å¸¸æ
\89§è¡
\8c\r
2097 ********************************************************/
\r
2098 static int __init goodix_ts_init(void)
\r
2102 #ifdef CONFIG_RK_CONFIG
\r
2103 ret = tp_board_init();
\r
2108 goodix_wq = create_workqueue("goodix_wq"); //create a work queue and worker thread
\r
2110 printk(KERN_ALERT "creat workqueue faiked\n");
\r
2114 ret=i2c_add_driver(&goodix_ts_driver);
\r
2118 /*******************************************************
\r
2119 å
\8a\9fè
\83½ï¼? 驱å
\8a¨å
\8d¸è½½å
\87½æ
\95°
\r
2120 å
\8f\82æ
\95°ï¼? clientï¼
\9a设å¤
\87ç»
\93æ
\9e\84ä½
\93\r
2121 ********************************************************/
\r
2122 static void __exit goodix_ts_exit(void)
\r
2124 printk(KERN_ALERT "Touchscreen driver of guitar exited.\n");
\r
2125 i2c_del_driver(&goodix_ts_driver);
\r
2127 destroy_workqueue(goodix_wq); //release our work queue
\r
2130 late_initcall_sync(goodix_ts_init); //最后初始化驱动felix
\r
2131 module_exit(goodix_ts_exit);
\r
2133 MODULE_DESCRIPTION("Goodix Touchscreen Driver");
\r
2134 MODULE_LICENSE("GPL");
\r