1 /* drivers/input/touchscreen/goodix_tool.c
3 * 2010 - 2012 Goodix Technology.
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 a reference
11 * to you, when you are integrating the GOODiX's CTP IC into your system,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
17 * V1.0:2012/05/01,create file.
18 * V1.2:2012/10/17,reset_guitar etc.
19 * V1.4: 2013/06/08, new proc name
20 * V2.2:2014/01/14, compatible with Linux 3.10
22 * Special edition for GT910 flashless
25 * Special edition for GT910 flashless
26 * 1. modified to support gesture wakeup module
30 #include <linux/interrupt.h>
31 #include <cust_eint.h>
32 #include <linux/i2c.h>
33 #include <linux/sched.h>
34 #include <linux/kthread.h>
35 #include <linux/rtpm_prio.h>
36 #include <linux/wait.h>
37 #include <linux/time.h>
38 #include <linux/delay.h>
39 #include "cust_gpio_usage.h"
40 #include <asm/uaccess.h>
42 #include "tpd_custom_gt9xx.h"
43 extern int gtp_autotool_setting
;
48 u8 wr
; //write read flag£¬0:R 1:W 2:PID 3:
49 u8 flag
; //0:no need flag/int 1: need flag 2:need int
50 u8 flag_addr
[2]; //flag address
51 u8 flag_val
; //flag val
52 u8 flag_relation
; //flag_val:flag 0:not equal 1:equal 2:> 3:<
53 u16 circle
; //polling cycle
54 u8 times
; //plling times
55 u8 retry
; //I2C retry times
56 u16 delay
; //delay befor read or after write
57 u16 data_len
; //data length
58 u8 addr_len
; //address length
61 u8
*data
; //data pointer
66 #define UPDATE_FUNCTIONS
67 #define DATA_LENGTH_UINT 512
68 #define CMD_HEAD_LENGTH (sizeof(st_cmd_head) - sizeof(u8*))
69 static char procname
[20] = {0};
70 extern struct i2c_client
*i2c_client_point
;
71 static struct i2c_client
*gt_client
= NULL
;
73 #ifdef UPDATE_FUNCTIONS
74 extern s32
gup_enter_update_mode(struct i2c_client
*client
);
75 extern void gup_leave_update_mode(void);
76 extern s32
gup_update_proc(void *dir
);
79 static struct proc_dir_entry
*goodix_proc_entry
;
81 static ssize_t
goodix_tool_read(struct file
*, char __user
*, size_t, loff_t
*);
82 static ssize_t
goodix_tool_write(struct file
*, const char __user
*, size_t, loff_t
*);
83 static const struct file_operations tool_ops
= {
85 .read
= goodix_tool_read
,
86 .write
= goodix_tool_write
,
89 //static s32 goodix_tool_write(struct file *filp, const char __user *buff, unsigned long len, void *data);
90 //static s32 goodix_tool_read( char *page, char **start, off_t off, int count, int *eof, void *data );
91 static s32(*tool_i2c_read
)(u8
*, u16
);
92 static s32(*tool_i2c_write
)(u8
*, u16
);
95 extern void gtp_esd_switch(struct i2c_client
*client
, s32 on
);
99 s8 IC_TYPE
[16] = "GT9XX";
100 static void tool_set_proc_name(char * procname
)
102 char *months
[12] = {"Jan", "Feb", "Mar", "Apr", "May",
103 "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
106 int i
= 0, n_month
= 1, n_day
= 0, n_year
= 0;
108 sprintf(date
, "%s", __DATE__
);
110 //GTP_DEBUG("compile date: %s", date);
112 sscanf(date
, "%s %d %d", month
, &n_day
, &n_year
);
114 for (i
= 0; i
< 12; ++i
)
116 if (!memcmp(months
[i
], month
, 3))
123 sprintf(procname
, "gmnode");
124 //sprintf(procname, "gmnode%04d%02d%02d", n_year, n_month, n_day);
125 //memset(procname, 0, 20);
126 //sprintf(procname, "goodix_tool");
127 //GTP_DEBUG("procname = %s", procname);
129 static s32
tool_i2c_read_no_extra(u8
*buf
, u16 len
)
133 ret
= gtp_i2c_read(gt_client
, buf
, len
+ GTP_ADDR_LENGTH
);
137 static s32
tool_i2c_write_no_extra(u8
*buf
, u16 len
)
141 ret
= gtp_i2c_write(gt_client
, buf
, len
);
145 static s32
tool_i2c_read_with_extra(u8
*buf
, u16 len
)
148 u8 pre
[2] = {0x0f, 0xff};
149 u8 end
[2] = {0x80, 0x00};
151 tool_i2c_write_no_extra(pre
, 2);
152 ret
= tool_i2c_read_no_extra(buf
, len
);
153 tool_i2c_write_no_extra(end
, 2);
158 static s32
tool_i2c_write_with_extra(u8
*buf
, u16 len
)
161 u8 pre
[2] = {0x0f, 0xff};
162 u8 end
[2] = {0x80, 0x00};
164 tool_i2c_write_no_extra(pre
, 2);
165 ret
= tool_i2c_write_no_extra(buf
, len
);
166 tool_i2c_write_no_extra(end
, 2);
171 static void register_i2c_func(void)
173 // if (!strncmp(IC_TYPE, "GT818", 5) || !strncmp(IC_TYPE, "GT816", 5)
174 // || !strncmp(IC_TYPE, "GT811", 5) || !strncmp(IC_TYPE, "GT818F", 6)
175 // || !strncmp(IC_TYPE, "GT827", 5) || !strncmp(IC_TYPE,"GT828", 5)
176 // || !strncmp(IC_TYPE, "GT813", 5))
177 if (strncmp(IC_TYPE
, "GT8110", 6) && strncmp(IC_TYPE
, "GT8105", 6)
178 && strncmp(IC_TYPE
, "GT801", 5) && strncmp(IC_TYPE
, "GT800", 5)
179 && strncmp(IC_TYPE
, "GT801PLUS", 9) && strncmp(IC_TYPE
, "GT811", 5)
180 && strncmp(IC_TYPE
, "GTxxx", 5) && strncmp(IC_TYPE
, "GT9XX", 5))
182 tool_i2c_read
= tool_i2c_read_with_extra
;
183 tool_i2c_write
= tool_i2c_write_with_extra
;
184 GTP_DEBUG("I2C function: with pre and end cmd!");
188 tool_i2c_read
= tool_i2c_read_no_extra
;
189 tool_i2c_write
= tool_i2c_write_no_extra
;
190 GTP_INFO("I2C function: without pre and end cmd!");
194 static void unregister_i2c_func(void)
196 tool_i2c_read
= NULL
;
197 tool_i2c_write
= NULL
;
198 GTP_INFO("I2C function: unregister i2c transfer function!");
202 s32
init_wr_node(struct i2c_client
*client
)
206 gt_client
= i2c_client_point
;
208 memset(&cmd_head
, 0, sizeof(cmd_head
));
209 cmd_head
.data
= NULL
;
213 while ((!cmd_head
.data
) && i
)
215 cmd_head
.data
= kzalloc(i
* DATA_LENGTH_UINT
, GFP_KERNEL
);
217 if (NULL
!= cmd_head
.data
)
227 DATA_LENGTH
= i
* DATA_LENGTH_UINT
+ GTP_ADDR_LENGTH
;
228 GTP_INFO("Applied memory size:%d.", DATA_LENGTH
);
232 GTP_ERROR("Apply for memory failed.");
236 cmd_head
.addr_len
= 2;
241 tool_set_proc_name(procname
);
242 //goodix_proc_entry = create_proc_entry(procname, 0666, NULL);
243 goodix_proc_entry
= proc_create(procname
, 0666, NULL
, &tool_ops
);
244 if (goodix_proc_entry
== NULL
)
246 GTP_ERROR("Couldn't create proc entry!");
251 GTP_INFO("Create proc entry success!");
252 //goodix_proc_entry->write_proc = goodix_tool_write;
253 //goodix_proc_entry->read_proc = goodix_tool_read;
259 void uninit_wr_node(void)
261 kfree(cmd_head
.data
);
262 cmd_head
.data
= NULL
;
263 unregister_i2c_func();
264 remove_proc_entry(procname
, NULL
);
267 static u8
relation(u8 src
, u8 dst
, u8 rlt
)
274 ret
= (src
!= dst
) ? true : false;
278 ret
= (src
== dst
) ? true : false;
279 GTP_DEBUG("equal:src:0x%02x dst:0x%02x ret:%d.", src
, dst
, (s32
)ret
);
283 ret
= (src
> dst
) ? true : false;
287 ret
= (src
< dst
) ? true : false;
291 ret
= (src
& dst
) ? true : false;
295 ret
= (!(src
| dst
)) ? true : false;
306 /*******************************************************
313 ********************************************************/
314 static u8
comfirm(void)
319 // memcpy(&buf[GTP_ADDR_LENGTH - cmd_head.addr_len], &cmd_head.flag_addr, cmd_head.addr_len);
320 // memcpy(buf, &cmd_head.flag_addr, cmd_head.addr_len);//Modified by Scott, 2012-02-17
321 memcpy(buf
, cmd_head
.flag_addr
, cmd_head
.addr_len
);
323 for (i
= 0; i
< cmd_head
.times
; i
++)
325 if (tool_i2c_read(buf
, 1) <= 0)
327 GTP_ERROR("Read flag data failed!");
331 if (true == relation(buf
[GTP_ADDR_LENGTH
], cmd_head
.flag_val
, cmd_head
.flag_relation
))
333 GTP_DEBUG("value at flag addr:0x%02x.", buf
[GTP_ADDR_LENGTH
]);
334 GTP_DEBUG("flag value:0x%02x.", cmd_head
.flag_val
);
338 msleep(cmd_head
.circle
);
341 if (i
>= cmd_head
.times
)
343 GTP_ERROR("Didn't get the flag to continue!");
350 /*******************************************************
352 Goodix tool write function.
354 standard proc write function param.
357 ********************************************************/
358 //static s32 goodix_tool_write(struct file *filp, const char __user *buff, unsigned long len, void *data)
359 ssize_t
goodix_tool_write(struct file
*filp
, const char __user
*buff
, size_t len
, loff_t
*off
)
363 GTP_DEBUG_ARRAY((u8
*)buff
, len
);
365 ret
= copy_from_user(&cmd_head
, buff
, CMD_HEAD_LENGTH
);
369 GTP_ERROR("copy_from_user failed.");
373 GTP_DEBUG("[Operation]wr: %02X", cmd_head
.wr
);
374 GTP_DEBUG("[Flag]flag: %02X, addr: %02X%02X, value: %02X, relation: %02X", cmd_head
.flag
, cmd_head
.flag_addr
[0],
375 cmd_head
.flag_addr
[1], cmd_head
.flag_val
, cmd_head
.flag_relation
);
376 GTP_DEBUG("[Retry]circle: %d, times: %d, retry: %d, delay: %d", (s32
)cmd_head
.circle
, (s32
)cmd_head
.times
,
377 (s32
)cmd_head
.retry
, (s32
)cmd_head
.delay
);
378 GTP_DEBUG("[Data]data len: %d, addr len: %d, addr: %02X%02X, buffer len: %d, data[0]: %02X", (s32
)cmd_head
.data_len
,
379 (s32
)cmd_head
.addr_len
, cmd_head
.addr
[0], cmd_head
.addr
[1], (s32
)len
, buff
[CMD_HEAD_LENGTH
]);
381 if (1 == cmd_head
.wr
)
383 ret
= copy_from_user(&cmd_head
.data
[GTP_ADDR_LENGTH
], &buff
[CMD_HEAD_LENGTH
], cmd_head
.data_len
);
387 GTP_ERROR("copy_from_user failed.");
391 memcpy(&cmd_head
.data
[GTP_ADDR_LENGTH
- cmd_head
.addr_len
], cmd_head
.addr
, cmd_head
.addr_len
);
393 GTP_DEBUG_ARRAY(cmd_head
.data
, cmd_head
.data_len
+ cmd_head
.addr_len
);
394 GTP_DEBUG_ARRAY((u8
*)&buff
[CMD_HEAD_LENGTH
], cmd_head
.data_len
);
396 if (1 == cmd_head
.flag
)
398 if (FAIL
== comfirm())
400 GTP_ERROR("[WRITE]Comfirm fail!");
404 else if (2 == cmd_head
.flag
)
409 if (tool_i2c_write(&cmd_head
.data
[GTP_ADDR_LENGTH
- cmd_head
.addr_len
],
410 cmd_head
.data_len
+ cmd_head
.addr_len
) <= 0)
412 GTP_ERROR("[WRITE]Write data failed!");
416 GTP_DEBUG_ARRAY(&cmd_head
.data
[GTP_ADDR_LENGTH
- cmd_head
.addr_len
], cmd_head
.data_len
+ cmd_head
.addr_len
);
420 msleep(cmd_head
.delay
);
423 else if (3 == cmd_head
.wr
) //Write ic type
425 gtp_autotool_setting
= 1;
426 ret
= copy_from_user(&cmd_head
.data
[0], &buff
[CMD_HEAD_LENGTH
], cmd_head
.data_len
);
429 GTP_ERROR("copy_from_user failed.");
432 memcpy(IC_TYPE
, cmd_head
.data
, cmd_head
.data_len
);
435 else if (5 == cmd_head
.wr
)
437 //memcpy(IC_TYPE, cmd_head.data, cmd_head.data_len);
439 else if (7 == cmd_head
.wr
)//disable irq!
441 mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM
);
443 gtp_esd_switch(i2c_client_point
, SWITCH_OFF
);
446 else if (9 == cmd_head
.wr
) //enable irq!
448 mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM
);
450 gtp_esd_switch(i2c_client_point
, SWITCH_ON
);
453 else if (17 == cmd_head
.wr
)
455 ret
= copy_from_user(&cmd_head
.data
[GTP_ADDR_LENGTH
], &buff
[CMD_HEAD_LENGTH
], cmd_head
.data_len
);
459 GTP_DEBUG("copy_from_user failed.");
463 if (cmd_head
.data
[GTP_ADDR_LENGTH
])
465 GTP_DEBUG("gtp enter rawdiff.");
466 gtp_rawdiff_mode
= true;
470 gtp_rawdiff_mode
= false;
471 GTP_DEBUG("gtp leave rawdiff.");
474 #ifdef UPDATE_FUNCTIONS
475 else if (11 == cmd_head
.wr
) //Enter update mode!
477 if (FAIL
== gup_enter_update_mode(gt_client
))
482 else if (13 == cmd_head
.wr
)//Leave update mode!
484 gup_leave_update_mode();
486 else if (15 == cmd_head
.wr
) //Update firmware!
490 memset(cmd_head
.data
, 0, cmd_head
.data_len
+ 1);
491 memcpy(cmd_head
.data
, &buff
[CMD_HEAD_LENGTH
], cmd_head
.data_len
);
492 if (FAIL
== gup_update_proc((void *)cmd_head
.data
))
503 /*******************************************************
505 Goodix tool read function.
507 standard proc read function param.
510 ********************************************************/
511 //static s32 goodix_tool_read( char *page, char **start, off_t off, int count, int *eof, void *data )
512 ssize_t
goodix_tool_read(struct file
*file
, char __user
*page
, size_t size
, loff_t
*ppos
)
518 if (*ppos
) // ADB call again
520 //GTP_DEBUG("[HEAD]wr: %d", cmd_head.wr);
521 //GTP_DEBUG("[PARAM]size: %d, *ppos: %d", size, (int)*ppos);
522 //GTP_DEBUG("[TOOL_READ]ADB call again, return it.");
530 else if (!cmd_head
.wr
)
536 if (1 == cmd_head
.flag
)
538 if (FAIL
== comfirm())
540 GTP_ERROR("[READ]Comfirm fail!");
544 else if (2 == cmd_head
.flag
)
549 memcpy(cmd_head
.data
, cmd_head
.addr
, cmd_head
.addr_len
);
551 GTP_DEBUG("[CMD HEAD DATA] ADDR:0x%02x%02x.", cmd_head
.data
[0], cmd_head
.data
[1]);
552 GTP_DEBUG("[CMD HEAD ADDR] ADDR:0x%02x%02x.", cmd_head
.addr
[0], cmd_head
.addr
[1]);
556 msleep(cmd_head
.delay
);
559 data_len
= cmd_head
.data_len
;
563 if (data_len
> DATA_LENGTH
)
574 if (tool_i2c_read(cmd_head
.data
, len
) <= 0)
576 GTP_ERROR("[READ]Read data failed!");
580 //memcpy(&page[loc], &cmd_head.data[GTP_ADDR_LENGTH], len);
581 ret
= simple_read_from_buffer(&page
[loc
], size
, ppos
, &cmd_head
.data
[GTP_ADDR_LENGTH
], len
);
588 GTP_DEBUG_ARRAY(&cmd_head
.data
[GTP_ADDR_LENGTH
], len
);
589 GTP_DEBUG_ARRAY(page
, len
);
591 return cmd_head
.data_len
;
593 else if (2 == cmd_head
.wr
)
595 ret
= simple_read_from_buffer(page
, size
, ppos
, IC_TYPE
, sizeof(IC_TYPE
));
598 else if (4 == cmd_head
.wr
)
601 progress_buf
[0] = show_len
>> 8;
602 progress_buf
[1] = show_len
& 0xff;
603 progress_buf
[2] = total_len
>> 8;
604 progress_buf
[3] = total_len
& 0xff;
606 ret
= simple_read_from_buffer(page
, size
, ppos
, progress_buf
, 4);
609 else if (6 == cmd_head
.wr
)
613 else if (8 == cmd_head
.wr
) //Read driver version
615 ret
= simple_read_from_buffer(page
, size
, ppos
, GTP_DRIVER_VERSION
, strlen(GTP_DRIVER_VERSION
));