1 /* drivers/input/touchscreen/goodix_tool.c
2 *
3 * 2010 - 2012 Goodix Technology.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be 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.
15 *
16 * Version:2.2
17 * V1.0:2012/05/01,create file.
18 * V1.2:2012/06/08,modify some warning.
19 * V1.4:2012/08/28,modified to support GT9XX
20 * V1.6:new proc name
21 * V2.2: compatible with Linux 3.10, 2014/01/14
22 */
23
24 #include "gt9xx.h"
25
26 #define DATA_LENGTH_UINT 512
27 #define CMD_HEAD_LENGTH (sizeof(st_cmd_head) - sizeof(u8*))
28 static char procname[20] = {0};
29
30 #define UPDATE_FUNCTIONS
31
32 #ifdef UPDATE_FUNCTIONS
33 extern s32 gup_enter_update_mode(struct i2c_client *client);
34 extern void gup_leave_update_mode(void);
35 extern s32 gup_update_proc(void *dir);
36 #endif
37
38 extern void gtp_irq_disable(struct goodix_ts_data *);
39 extern void gtp_irq_enable(struct goodix_ts_data *);
40
41 #pragma pack(1)
42 typedef struct{
43 u8 wr; //write read flag��0:R 1:W 2:PID 3:
44 u8 flag; //0:no need flag/int 1: need flag 2:need int
45 u8 flag_addr[2]; //flag address
46 u8 flag_val; //flag val
47 u8 flag_relation; //flag_val:flag 0:not equal 1:equal 2:> 3:<
48 u16 circle; //polling cycle
49 u8 times; //plling times
50 u8 retry; //I2C retry times
51 u16 delay; //delay befor read or after write
52 u16 data_len; //data length
53 u8 addr_len; //address length
54 u8 addr[2]; //address
55 u8 res[3]; //reserved
56 u8* data; //data pointer
57 }st_cmd_head;
58 #pragma pack()
59 st_cmd_head cmd_head;
60
61 static struct i2c_client *gt_client = NULL;
62
63 static struct proc_dir_entry *goodix_proc_entry;
64
65 static ssize_t goodix_tool_read(struct file *, char __user *, size_t, loff_t *);
66 static ssize_t goodix_tool_write(struct file *, const char __user *, size_t, loff_t *);
67 static const struct file_operations tool_ops = {
68 .owner = THIS_MODULE,
69 .read = goodix_tool_read,
70 .write = goodix_tool_write,
71 };
72
73 //static s32 goodix_tool_write(struct file *filp, const char __user *buff, unsigned long len, void *data);
74 //static s32 goodix_tool_read( char *page, char **start, off_t off, int count, int *eof, void *data );
75 static s32 (*tool_i2c_read)(u8 *, u16);
76 static s32 (*tool_i2c_write)(u8 *, u16);
77
78 #if GTP_ESD_PROTECT
79 extern void gtp_esd_switch(struct i2c_client *, s32);
80 #endif
81 s32 DATA_LENGTH = 0;
82 s8 IC_TYPE[16] = "GT9XX";
83
tool_set_proc_name(char * procname)84 static void tool_set_proc_name(char * procname)
85 {
86 char *months[12] = {"Jan", "Feb", "Mar", "Apr", "May",
87 "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
88 char date[20] = {0};
89 char month[4] = {0};
90 int i = 0, n_month = 1, n_day = 0, n_year = 0;
91
92 sprintf(date, "%s", __DATE__);
93
94 //GTP_DEBUG("compile date: %s", date);
95
96 sscanf(date, "%s %d %d", month, &n_day, &n_year);
97
98 for (i = 0; i < 12; ++i)
99 {
100 if (!memcmp(months[i], month, 3))
101 {
102 n_month = i+1;
103 break;
104 }
105 }
106
107 sprintf(procname, "gmnode%04d%02d%02d", n_year, n_month, n_day);
108 //sprintf(procname, "goodix_tool");
109 //GTP_DEBUG("procname = %s", procname);
110 }
111
112
tool_i2c_read_no_extra(u8 * buf,u16 len)113 static s32 tool_i2c_read_no_extra(u8* buf, u16 len)
114 {
115 s32 ret = -1;
116 s32 i = 0;
117 struct i2c_msg msgs[2];
118
119 msgs[0].flags = !I2C_M_RD;
120 msgs[0].addr = gt_client->addr;
121 msgs[0].len = cmd_head.addr_len;
122 msgs[0].buf = &buf[0];
123
124 msgs[1].flags = I2C_M_RD;
125 msgs[1].addr = gt_client->addr;
126 msgs[1].len = len;
127 msgs[1].buf = &buf[GTP_ADDR_LENGTH];
128
129 for (i = 0; i < cmd_head.retry; i++)
130 {
131 ret=i2c_transfer(gt_client->adapter, msgs, 2);
132 if (ret > 0)
133 {
134 break;
135 }
136 }
137 return ret;
138 }
139
tool_i2c_write_no_extra(u8 * buf,u16 len)140 static s32 tool_i2c_write_no_extra(u8* buf, u16 len)
141 {
142 s32 ret = -1;
143 s32 i = 0;
144 struct i2c_msg msg;
145
146 msg.flags = !I2C_M_RD;
147 msg.addr = gt_client->addr;
148 msg.len = len;
149 msg.buf = buf;
150
151 for (i = 0; i < cmd_head.retry; i++)
152 {
153 ret=i2c_transfer(gt_client->adapter, &msg, 1);
154 if (ret > 0)
155 {
156 break;
157 }
158 }
159 return ret;
160 }
161
tool_i2c_read_with_extra(u8 * buf,u16 len)162 static s32 tool_i2c_read_with_extra(u8* buf, u16 len)
163 {
164 s32 ret = -1;
165 u8 pre[2] = {0x0f, 0xff};
166 u8 end[2] = {0x80, 0x00};
167
168 tool_i2c_write_no_extra(pre, 2);
169 ret = tool_i2c_read_no_extra(buf, len);
170 tool_i2c_write_no_extra(end, 2);
171
172 return ret;
173 }
174
tool_i2c_write_with_extra(u8 * buf,u16 len)175 static s32 tool_i2c_write_with_extra(u8* buf, u16 len)
176 {
177 s32 ret = -1;
178 u8 pre[2] = {0x0f, 0xff};
179 u8 end[2] = {0x80, 0x00};
180
181 tool_i2c_write_no_extra(pre, 2);
182 ret = tool_i2c_write_no_extra(buf, len);
183 tool_i2c_write_no_extra(end, 2);
184
185 return ret;
186 }
187
register_i2c_func(void)188 static void register_i2c_func(void)
189 {
190 // if (!strncmp(IC_TYPE, "GT818", 5) || !strncmp(IC_TYPE, "GT816", 5)
191 // || !strncmp(IC_TYPE, "GT811", 5) || !strncmp(IC_TYPE, "GT818F", 6)
192 // || !strncmp(IC_TYPE, "GT827", 5) || !strncmp(IC_TYPE,"GT828", 5)
193 // || !strncmp(IC_TYPE, "GT813", 5))
194 if (strncmp(IC_TYPE, "GT8110", 6) && strncmp(IC_TYPE, "GT8105", 6)
195 && strncmp(IC_TYPE, "GT801", 5) && strncmp(IC_TYPE, "GT800", 5)
196 && strncmp(IC_TYPE, "GT801PLUS", 9) && strncmp(IC_TYPE, "GT811", 5)
197 && strncmp(IC_TYPE, "GTxxx", 5) && strncmp(IC_TYPE, "GT9XX", 5))
198 {
199 tool_i2c_read = tool_i2c_read_with_extra;
200 tool_i2c_write = tool_i2c_write_with_extra;
201 GTP_DEBUG("I2C function: with pre and end cmd!");
202 }
203 else
204 {
205 tool_i2c_read = tool_i2c_read_no_extra;
206 tool_i2c_write = tool_i2c_write_no_extra;
207 GTP_INFO("I2C function: without pre and end cmd!");
208 }
209 }
210
unregister_i2c_func(void)211 static void unregister_i2c_func(void)
212 {
213 tool_i2c_read = NULL;
214 tool_i2c_write = NULL;
215 GTP_INFO("I2C function: unregister i2c transfer function!");
216 }
217
init_wr_node(struct i2c_client * client)218 s32 init_wr_node(struct i2c_client *client)
219 {
220 s32 i;
221
222 gt_client = client;
223 memset(&cmd_head, 0, sizeof(cmd_head));
224 cmd_head.data = NULL;
225
226 i = 5;
227 while ((!cmd_head.data) && i)
228 {
229 cmd_head.data = kzalloc(i * DATA_LENGTH_UINT, GFP_KERNEL);
230 if (NULL != cmd_head.data)
231 {
232 break;
233 }
234 i--;
235 }
236 if (i)
237 {
238 DATA_LENGTH = i * DATA_LENGTH_UINT + GTP_ADDR_LENGTH;
239 GTP_INFO("Applied memory size:%d.", DATA_LENGTH);
240 }
241 else
242 {
243 GTP_ERROR("Apply for memory failed.");
244 return FAIL;
245 }
246
247 cmd_head.addr_len = 2;
248 cmd_head.retry = 5;
249
250 register_i2c_func();
251
252 tool_set_proc_name(procname);
253 //goodix_proc_entry = create_proc_entry(procname, 0666, NULL);
254 goodix_proc_entry = proc_create(procname, 0666, NULL, &tool_ops);
255 if (goodix_proc_entry == NULL)
256 {
257 GTP_ERROR("Couldn't create proc entry!");
258 return FAIL;
259 }
260 else
261 {
262 GTP_INFO("Create proc entry success!");
263 //goodix_proc_entry->write_proc = goodix_tool_write;
264 //goodix_proc_entry->read_proc = goodix_tool_read;
265 }
266
267 return SUCCESS;
268 }
269
uninit_wr_node(void)270 void uninit_wr_node(void)
271 {
272 kfree(cmd_head.data);
273 cmd_head.data = NULL;
274 unregister_i2c_func();
275 remove_proc_entry(procname, NULL);
276 }
277
relation(u8 src,u8 dst,u8 rlt)278 static u8 relation(u8 src, u8 dst, u8 rlt)
279 {
280 u8 ret = 0;
281
282 switch (rlt)
283 {
284 case 0:
285 ret = (src != dst) ? true : false;
286 break;
287
288 case 1:
289 ret = (src == dst) ? true : false;
290 GTP_DEBUG("equal:src:0x%02x dst:0x%02x ret:%d.", src, dst, (s32)ret);
291 break;
292
293 case 2:
294 ret = (src > dst) ? true : false;
295 break;
296
297 case 3:
298 ret = (src < dst) ? true : false;
299 break;
300
301 case 4:
302 ret = (src & dst) ? true : false;
303 break;
304
305 case 5:
306 ret = (!(src | dst)) ? true : false;
307 break;
308
309 default:
310 ret = false;
311 break;
312 }
313
314 return ret;
315 }
316
317 /*******************************************************
318 Function:
319 Comfirm function.
320 Input:
321 None.
322 Output:
323 Return write length.
324 ********************************************************/
comfirm(void)325 static u8 comfirm(void)
326 {
327 s32 i = 0;
328 u8 buf[32];
329
330 // memcpy(&buf[GTP_ADDR_LENGTH - cmd_head.addr_len], &cmd_head.flag_addr, cmd_head.addr_len);
331 // memcpy(buf, &cmd_head.flag_addr, cmd_head.addr_len);//Modified by Scott, 2012-02-17
332 memcpy(buf, cmd_head.flag_addr, cmd_head.addr_len);
333
334 for (i = 0; i < cmd_head.times; i++)
335 {
336 if (tool_i2c_read(buf, 1) <= 0)
337 {
338 GTP_ERROR("Read flag data failed!");
339 return FAIL;
340 }
341 if (true == relation(buf[GTP_ADDR_LENGTH], cmd_head.flag_val, cmd_head.flag_relation))
342 {
343 GTP_DEBUG("value at flag addr:0x%02x.", buf[GTP_ADDR_LENGTH]);
344 GTP_DEBUG("flag value:0x%02x.", cmd_head.flag_val);
345 break;
346 }
347
348 msleep(cmd_head.circle);
349 }
350
351 if (i >= cmd_head.times)
352 {
353 GTP_ERROR("Didn't get the flag to continue!");
354 return FAIL;
355 }
356
357 return SUCCESS;
358 }
359
360 /*******************************************************
361 Function:
362 Goodix tool write function.
363 Input:
364 standard proc write function param.
365 Output:
366 Return write length.
367 ********************************************************/
368 //static s32 goodix_tool_write(struct file *filp, const char __user *buff, unsigned long len, void *data)
goodix_tool_write(struct file * filp,const char __user * buff,size_t len,loff_t * off)369 ssize_t goodix_tool_write(struct file *filp, const char __user *buff, size_t len, loff_t *off)
370 {
371 s32 ret = 0;
372
373 GTP_DEBUG_FUNC();
374 GTP_DEBUG_ARRAY((u8*)buff, len);
375
376 ret = copy_from_user(&cmd_head, buff, CMD_HEAD_LENGTH);
377 if(ret)
378 {
379 GTP_ERROR("copy_from_user failed.");
380 return -EPERM;
381 }
382
383
384 GTP_DEBUG("[Operation]wr: %02X", cmd_head.wr);
385 GTP_DEBUG("[Flag]flag: %02X, addr: %02X%02X, value: %02X, relation: %02X", cmd_head.flag, cmd_head.flag_addr[0],
386 cmd_head.flag_addr[1], cmd_head.flag_val, cmd_head.flag_relation);
387 GTP_DEBUG("[Retry]circle: %d, times: %d, retry: %d, delay: %d", (s32)cmd_head.circle, (s32)cmd_head.times,
388 (s32)cmd_head.retry, (s32)cmd_head.delay);
389 GTP_DEBUG("[Data]data len: %d, addr len: %d, addr: %02X%02X, buffer len: %d, data[0]: %02X", (s32)cmd_head.data_len,
390 (s32)cmd_head.addr_len, cmd_head.addr[0], cmd_head.addr[1], (s32)len, buff[CMD_HEAD_LENGTH]);
391
392 if (1 == cmd_head.wr)
393 {
394 ret = copy_from_user(&cmd_head.data[GTP_ADDR_LENGTH], &buff[CMD_HEAD_LENGTH], cmd_head.data_len);
395 if(ret)
396 {
397 GTP_ERROR("copy_from_user failed.");
398 return -EPERM;
399 }
400 memcpy(&cmd_head.data[GTP_ADDR_LENGTH - cmd_head.addr_len], cmd_head.addr, cmd_head.addr_len);
401
402 GTP_DEBUG_ARRAY(cmd_head.data, cmd_head.data_len + cmd_head.addr_len);
403 GTP_DEBUG_ARRAY((u8*)&buff[CMD_HEAD_LENGTH], cmd_head.data_len);
404
405 if (1 == cmd_head.flag)
406 {
407 if (FAIL == comfirm())
408 {
409 GTP_ERROR("[WRITE]Comfirm fail!");
410 return -EPERM;
411 }
412 }
413 else if (2 == cmd_head.flag)
414 {
415 //Need interrupt!
416 }
417 if (tool_i2c_write(&cmd_head.data[GTP_ADDR_LENGTH - cmd_head.addr_len],
418 cmd_head.data_len + cmd_head.addr_len) <= 0)
419 {
420 GTP_ERROR("[WRITE]Write data failed!");
421 return -EPERM;
422 }
423
424 GTP_DEBUG_ARRAY(&cmd_head.data[GTP_ADDR_LENGTH - cmd_head.addr_len],cmd_head.data_len + cmd_head.addr_len);
425 if (cmd_head.delay)
426 {
427 msleep(cmd_head.delay);
428 }
429 }
430 else if (3 == cmd_head.wr) //Write ic type
431 {
432 ret = copy_from_user(&cmd_head.data[0], &buff[CMD_HEAD_LENGTH], cmd_head.data_len);
433 if(ret)
434 {
435 GTP_ERROR("copy_from_user failed.");
436 return -EPERM;
437 }
438 memcpy(IC_TYPE, cmd_head.data, cmd_head.data_len);
439
440 register_i2c_func();
441 }
442 else if (5 == cmd_head.wr)
443 {
444 //memcpy(IC_TYPE, cmd_head.data, cmd_head.data_len);
445 }
446 else if (7 == cmd_head.wr)//disable irq!
447 {
448 gtp_irq_disable(i2c_get_clientdata(gt_client));
449
450 #if GTP_ESD_PROTECT
451 gtp_esd_switch(gt_client, SWITCH_OFF);
452 #endif
453 }
454 else if (9 == cmd_head.wr) //enable irq!
455 {
456 gtp_irq_enable(i2c_get_clientdata(gt_client));
457
458 #if GTP_ESD_PROTECT
459 gtp_esd_switch(gt_client, SWITCH_ON);
460 #endif
461 }
462 else if(17 == cmd_head.wr)
463 {
464 struct goodix_ts_data *ts = i2c_get_clientdata(gt_client);
465 ret = copy_from_user(&cmd_head.data[GTP_ADDR_LENGTH], &buff[CMD_HEAD_LENGTH], cmd_head.data_len);
466 if(ret)
467 {
468 GTP_DEBUG("copy_from_user failed.");
469 return -EPERM;
470 }
471 if(cmd_head.data[GTP_ADDR_LENGTH])
472 {
473 GTP_INFO("gtp enter rawdiff.");
474 ts->gtp_rawdiff_mode = true;
475 }
476 else
477 {
478 ts->gtp_rawdiff_mode = false;
479 GTP_INFO("gtp leave rawdiff.");
480 }
481 }
482 #ifdef UPDATE_FUNCTIONS
483 else if (11 == cmd_head.wr)//Enter update mode!
484 {
485 if (FAIL == gup_enter_update_mode(gt_client))
486 {
487 return -EPERM;
488 }
489 }
490 else if (13 == cmd_head.wr)//Leave update mode!
491 {
492 gup_leave_update_mode();
493 }
494 else if (15 == cmd_head.wr) //Update firmware!
495 {
496 show_len = 0;
497 total_len = 0;
498 memset(cmd_head.data, 0, cmd_head.data_len + 1);
499 memcpy(cmd_head.data, &buff[CMD_HEAD_LENGTH], cmd_head.data_len);
500
501 if (FAIL == gup_update_proc((void*)cmd_head.data))
502 {
503 return -EPERM;
504 }
505 }
506
507 #endif
508
509 return len;
510 }
511
512 /*******************************************************
513 Function:
514 Goodix tool read function.
515 Input:
516 standard proc read function param.
517 Output:
518 Return read length.
519 ********************************************************/
520 //static s32 goodix_tool_read( char *page, char **start, off_t off, int count, int *eof, void *data )
goodix_tool_read(struct file * file,char __user * page,size_t size,loff_t * ppos)521 ssize_t goodix_tool_read(struct file *file, char __user *page, size_t size, loff_t *ppos)
522 {
523 s32 ret = 0;
524
525 GTP_DEBUG_FUNC();
526
527 if (*ppos) // ADB call again
528 {
529 //GTP_DEBUG("[HEAD]wr: %d", cmd_head.wr);
530 //GTP_DEBUG("[PARAM]size: %d, *ppos: %d", size, (int)*ppos);
531 //GTP_DEBUG("[TOOL_READ]ADB call again, return it.");
532 return 0;
533 }
534
535 if (cmd_head.wr % 2)
536 {
537 return -EPERM;
538 }
539 else if (!cmd_head.wr)
540 {
541 u16 len = 0;
542 s16 data_len = 0;
543 u16 loc = 0;
544
545 if (1 == cmd_head.flag)
546 {
547 if (FAIL == comfirm())
548 {
549 GTP_ERROR("[READ]Comfirm fail!");
550 return -EPERM;
551 }
552 }
553 else if (2 == cmd_head.flag)
554 {
555 //Need interrupt!
556 }
557
558 memcpy(cmd_head.data, cmd_head.addr, cmd_head.addr_len);
559
560 GTP_DEBUG("[CMD HEAD DATA] ADDR:0x%02x%02x.", cmd_head.data[0], cmd_head.data[1]);
561 GTP_DEBUG("[CMD HEAD ADDR] ADDR:0x%02x%02x.", cmd_head.addr[0], cmd_head.addr[1]);
562
563 if (cmd_head.delay)
564 {
565 msleep(cmd_head.delay);
566 }
567
568 data_len = cmd_head.data_len;
569
570 while(data_len > 0)
571 {
572 if (data_len > DATA_LENGTH)
573 {
574 len = DATA_LENGTH;
575 }
576 else
577 {
578 len = data_len;
579 }
580 data_len -= len;
581
582 if (tool_i2c_read(cmd_head.data, len) <= 0)
583 {
584 GTP_ERROR("[READ]Read data failed!");
585 return -EPERM;
586 }
587
588 //memcpy(&page[loc], &cmd_head.data[GTP_ADDR_LENGTH], len);
589 ret = simple_read_from_buffer(&page[loc], size, ppos, &cmd_head.data[GTP_ADDR_LENGTH], len);
590 if (ret < 0)
591 {
592 return ret;
593 }
594 loc += len;
595
596 GTP_DEBUG_ARRAY(&cmd_head.data[GTP_ADDR_LENGTH], len);
597 GTP_DEBUG_ARRAY(page, len);
598 }
599 return cmd_head.data_len;
600 }
601 else if (2 == cmd_head.wr)
602 {
603 ret = simple_read_from_buffer(page, size, ppos, IC_TYPE, sizeof(IC_TYPE));
604 return ret;
605 }
606 else if (4 == cmd_head.wr)
607 {
608 u8 progress_buf[4];
609 progress_buf[0] = show_len >> 8;
610 progress_buf[1] = show_len & 0xff;
611 progress_buf[2] = total_len >> 8;
612 progress_buf[3] = total_len & 0xff;
613
614 ret = simple_read_from_buffer(page, size, ppos, progress_buf, 4);
615 return ret;
616 }
617 else if (6 == cmd_head.wr)
618 {
619 //Read error code!
620 }
621 else if (8 == cmd_head.wr) //Read driver version
622 {
623 ret = simple_read_from_buffer(page, size, ppos, GTP_DRIVER_VERSION, strlen(GTP_DRIVER_VERSION));
624 return ret;
625 }
626 return -EPERM;
627 }
628