projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
import PULS_20160108
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / arch / arm / mach-mt8127 / ttab / touchpanel / gt9xx_driver.c
1 /* Copyright Statement:
2 *
3 * This software/firmware and related documentation ("MediaTek Software") are
4 * protected under relevant copyright laws. The information contained herein
5 * is confidential and proprietary to MediaTek Inc. and/or its licensors.
6 * Without the prior written permission of MediaTek inc. and/or its licensors,
7 * any reproduction, modification, use or disclosure of MediaTek Software,
8 * and information contained herein, in whole or in part, shall be strictly prohibited.
9 *
10 * MediaTek Inc. (C) 2012. All rights reserved.
11 *
12 * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
13 * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
14 * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER ON
15 * AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
16 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
18 * NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
19 * SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
20 * SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES TO LOOK ONLY TO SUCH
21 * THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. RECEIVER EXPRESSLY ACKNOWLEDGES
22 * THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES
23 * CONTAINED IN MEDIATEK SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK
24 * SOFTWARE RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
25 * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND
26 * CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
27 * AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
28 * OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY RECEIVER TO
29 * MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
30 *
31 * The following software/firmware and/or related documentation ("MediaTek Software")
32 * have been modified by MediaTek Inc. All revisions are subject to any receiver's
33 * applicable license agreements with MediaTek Inc.
34 */
35
36 /*
37 * Version: V2.0
38 * Release Date: 2013/08/28
39 * Contact: andrew@goodix.com, meta@goodix.com
40 * Revision Record:
41 * V1.4:
42 * 1. New Heartbeat/ESD-protect Mechanism(external watchdog)
43 * 2. doze mode, sliding wakeup
44 * 3. config length verification & 3 more config groups(GT9 Sensor_ID: 0 ~ 5)
45 * 4. charger status switch
46 * By Meta, 2013/03/11
47 * V1.6:
48 * 1. pen/stylus support
49 * 2. slide wakeup, new esd optimization
50 * By Meta, 2013/04/18
51 * V1.8:
52 * 1. read double check & fixed config support
53 * 2. other optimizations
54 * By Meta, 2013/06/08
55 * V2.0:
56 * 1. compatible with GT9XXF
57 * 2. I2C DMA support
58 * By Meta, 2013/08/28
59 * V2.2:
60 * 1. update gt9xx_config to compatible with Linux 3.10
61 * 2. gesture wakeup
62 * 3. pen separate input device, active-pen button support
63 * 4. coordinates & keys optimization
64 * 5. no longer support GT915S
65 * By Meta, 2014/01/14
66 * V2.2.6:
67 * Special edition for GT910 flashless
68 * 1. firmware check
69 * V2.2.7
70 * Special edition for GT910 flashless
71 * 1. modified to support gesture wakeup module
72 */
73
74 #include "tpd.h"
75 #include "tpd_custom_gt9xx.h"
76 #include <asm/ptrace.h>
77
78 #ifndef TPD_NO_GPIO
79 #include "cust_gpio_usage.h"
80 #endif
81 #ifdef TPD_PROXIMITY
82 #include <linux/hwmsensor.h>
83 #include <linux/hwmsen_dev.h>
84 #include <linux/sensors_io.h>
85 #endif
86
87 #if GTP_SUPPORT_I2C_DMA
88 #include <linux/dma-mapping.h>
89 #endif
90
91 extern int gesture_value;
92 extern char tpd_firmware_version_val[5];
93 extern int tpd_config_version;
94 extern int tpd_x_line;
95 extern int tpd_y_line;
96 int gtp_autotool_setting;
97 EXPORT_SYMBOL(gtp_autotool_setting);
98 extern struct tpd_device *tpd;
99
100 static int tpd_sleep_flag = 0;
101 static int tpd_flag = 0;
102 int tpd_halt = 0;
103 static struct task_struct *thread = NULL;
104 static DECLARE_WAIT_QUEUE_HEAD(waiter);
105
106 #ifdef TPD_HAVE_BUTTON
107 static int tpd_keys_local[TPD_KEY_COUNT] = TPD_KEYS;
108 static int tpd_keys_dim_local[TPD_KEY_COUNT][4] = TPD_KEYS_DIM;
109 #endif
110
111 typedef enum
112 {
113 DOZE_DISABLED = 0,
114 DOZE_ENABLED = 1,
115 DOZE_WAKEUP = 2,
116 }DOZE_T;
117 static DOZE_T doze_status = DOZE_DISABLED;
118 static s8 gtp_enter_doze(struct i2c_client *client);
119
120 #if GTP_CHARGER_SWITCH
121 #ifdef MT6573
122 #define CHR_CON0 (0xF7000000+0x2FA00)
123 #else
124 extern kal_bool upmu_is_chr_det(void);
125 #endif
126 static void gtp_charger_switch(s32 dir_update);
127 #endif
128
129 #if GTP_HAVE_TOUCH_KEY
130 const u16 touch_key_array[] = GTP_KEY_TAB;
131 #define GTP_MAX_KEY_NUM ( sizeof( touch_key_array )/sizeof( touch_key_array[0] ) )
132 #endif
133
134 #if (defined(TPD_WARP_START) && defined(TPD_WARP_END))
135 static int tpd_wb_start_local[TPD_WARP_CNT] = TPD_WARP_START;
136 static int tpd_wb_end_local[TPD_WARP_CNT] = TPD_WARP_END;
137 #endif
138
139 #if (defined(TPD_HAVE_CALIBRATION) && !defined(TPD_CUSTOM_CALIBRATION))
140 //static int tpd_calmat_local[8] = TPD_CALIBRATION_MATRIX;
141 static int tpd_def_calmat_local[8] = TPD_CALIBRATION_MATRIX;
142 #endif
143
144 #if GTP_SUPPORT_I2C_DMA
145 s32 i2c_dma_write(struct i2c_client *client, u16 addr, u8 *txbuf, s32 len);
146 s32 i2c_dma_read(struct i2c_client *client, u16 addr, u8 *rxbuf, s32 len);
147
148 static u8 *gpDMABuf_va = NULL;
149 static u32 gpDMABuf_pa = 0;
150 #endif
151
152 s32 gtp_send_cfg(struct i2c_client *client);
153 void gtp_reset_guitar(struct i2c_client *client, s32 ms);
154 static void tpd_eint_interrupt_handler(void);
155 static int touch_event_handler(void *unused);
156 static int tpd_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id);
157 static int tpd_i2c_detect(struct i2c_client *client, struct i2c_board_info *info);
158 static int tpd_i2c_remove(struct i2c_client *client);
159 s32 gtp_i2c_read_dbl_check(struct i2c_client *client, u16 addr, u8 *rxbuf, int len);
160 extern void mt_eint_unmask(unsigned int line);
161 extern void mt_eint_mask(unsigned int line);
162
163 #if GTP_CREATE_WR_NODE
164 extern s32 init_wr_node(struct i2c_client *);
165 extern void uninit_wr_node(void);
166 #endif
167
168 #if (GTP_ESD_PROTECT || GTP_COMPATIBLE_MODE)
169 static s32 force_reset_guitar(s32);
170 #endif
171
172 #if GTP_ESD_PROTECT
173 static int clk_tick_cnt = 200;
174 u8 esd_running = 0;
175 spinlock_t esd_lock;
176 extern unsigned char gtp_default_FW_fl[];
177 static struct delayed_work gtp_esd_check_work;
178 static struct workqueue_struct *gtp_esd_check_workqueue = NULL;
179 static s32 gtp_init_ext_watchdog(struct i2c_client *client);
180 static void gtp_esd_check_func(struct work_struct *);
181 void gtp_esd_switch(struct i2c_client *client, s32 on);
182 #endif
183
184 #ifdef TPD_PROXIMITY
185 #define TPD_PROXIMITY_VALID_REG 0x814E
186 #define TPD_PROXIMITY_ENABLE_REG 0x8042
187 static u8 tpd_proximity_flag = 0;
188 static u8 tpd_proximity_detect = 1;//0-->close ; 1--> far away
189 #endif
190
191 struct i2c_client *i2c_client_point = NULL;
192 static const struct i2c_device_id tpd_i2c_id[] = {{"gt9xx", 0}, {}};
193 static unsigned short force[] = {0, 0xBA, I2C_CLIENT_END, I2C_CLIENT_END};
194 static const unsigned short *const forces[] = { force, NULL };
195 //static struct i2c_client_address_data addr_data = { .forces = forces,};
196 static struct i2c_board_info __initdata i2c_tpd = { I2C_BOARD_INFO("gt9xx", (0xBA >> 1))};
197 static struct i2c_driver tpd_i2c_driver =
198 {
199 .probe = tpd_i2c_probe,
200 .remove = tpd_i2c_remove,
201 .detect = tpd_i2c_detect,
202 .driver.name = "gt9xx",
203 .id_table = tpd_i2c_id,
204 .address_list = (const unsigned short *) forces,
205 };
206
207 static u8 config[GTP_CONFIG_MAX_LENGTH + GTP_ADDR_LENGTH]
208 = {GTP_REG_CONFIG_DATA >> 8, GTP_REG_CONFIG_DATA & 0xff};
209
210 #pragma pack(1)
211 typedef struct
212 {
213 u16 pid; //product id //
214 u16 vid; //version id //
215 } st_tpd_info;
216 #pragma pack()
217
218 st_tpd_info tpd_info;
219 u8 int_type = 0;
220 u32 abs_x_max = 0;
221 u32 abs_y_max = 0;
222 u8 gtp_rawdiff_mode = 0;
223 u8 cfg_len = 0;
224 u8 grp_cfg_version = 0;
225 u8 fixed_config = 0;
226 u8 pnl_init_error = 0;
227
228 #if GTP_WITH_PEN
229 struct input_dev *pen_dev;
230 #endif
231
232 #if GTP_COMPATIBLE_MODE
233 u8 driver_num = 0;
234 u8 sensor_num = 0;
235 u8 gtp_ref_retries = 0;
236 u8 gtp_clk_retries = 0;
237 CHIP_TYPE_T gtp_chip_type = CHIP_TYPE_GT9;
238 u8 rqst_processing = 0;
239 u8 is_950 = 0;
240 u8 after_912_1020 = 0;
241
242
243 //add by caoyang for ·À¶¶
244 //static struct timer_list buttons_timer;
245 //static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
246 //end
247
248 extern u8 gup_check_fs_mounted(char *path_name);
249 extern u8 gup_clk_calibration(void);
250 extern int gup_reload_fw_dsp(void *dir, u8 dwn_mode);
251 extern s32 gup_fw_download_proc(void *dir, u8 dwn_mode);
252 void gtp_get_chip_type(struct i2c_client *client);
253 u8 gtp_fw_startup(struct i2c_client *client);
254 static u8 gtp_bak_ref_proc(struct i2c_client *client, u8 mode);
255 static u8 gtp_main_clk_proc(struct i2c_client *client);
256 static void gtp_recovery_reset(struct i2c_client *client);
257
258 #if GTP_COMPATIBLE_MODE
259 u8 gtp_hopping_buf[16] = {0};
260 #endif
261
262 #if GTP_FL_LITTLE_SYSTEM
263 u8 power_is_down = 0;
264 u8 little_fw_mode = 0;
265 u8 fw_block = 0; // 0: not started, 1 ~ 11/12 ss51 seg a/b each 2K, 13: ss51 seg b, 10K/12K
266 u8 block_section = 1; // 1 ~ 8, 2K total, 256 Bytes each
267
268 char symbolic_state1[][20] = {"OTHERS", "BUFFER_FULL", "CHECK_COMPLETE", "CHECK_ERROR", "WAIT_CHECK", "OTHERS", "OTHERS", "OTHERS"};
269 char symbolic_state2[][20] = {"OTHERS", "IS_A_SEG", "IS_B_SEG_FIRST", "IS_B_SEG_OTHER", "IS_B_SEG_LAST", "OTHERS", "OTHERS", "OTHERS"};
270
271 static void tpd_up(s32 x, s32 y, s32 id);
272 extern u8 gup_burn_ss51_block(struct i2c_client *client, s32 block_section, s32 fw_block, u16 *fw_chksum);
273 extern u8 gup_burn_ss51_seg_b(struct i2c_client *client, s32 size, u16 *fw_chksum);
274 #endif
275
276 #endif
277
278 /* proc file system */
279 s32 i2c_read_bytes(struct i2c_client *client, u16 addr, u8 *rxbuf, int len);
280 s32 i2c_write_bytes(struct i2c_client *client, u16 addr, u8 *txbuf, int len);
281
282 static ssize_t gt91xx_config_read_proc(struct file *, char __user *, size_t, loff_t *);
283 static ssize_t gt91xx_config_write_proc(struct file *, const char __user *, size_t, loff_t *);
284
285 static struct proc_dir_entry *gt91xx_config_proc = NULL;
286 static const struct file_operations config_proc_ops = {
287 .owner = THIS_MODULE,
288 .read = gt91xx_config_read_proc,
289 .write = gt91xx_config_write_proc,
290 };
291
292 #define VELOCITY_CUSTOM
293 #ifdef VELOCITY_CUSTOM
294 #include <linux/device.h>
295 #include <linux/miscdevice.h>
296 #include <asm/uaccess.h>
297
298 #ifndef TPD_VELOCITY_CUSTOM_X
299 #define TPD_VELOCITY_CUSTOM_X 10
300 #endif
301 #ifndef TPD_VELOCITY_CUSTOM_Y
302 #define TPD_VELOCITY_CUSTOM_Y 10
303 #endif
304
305 // for magnify velocity********************************************
306 #define TOUCH_IOC_MAGIC 'A'
307
308 #define TPD_GET_VELOCITY_CUSTOM_X _IO(TOUCH_IOC_MAGIC,0)
309 #define TPD_GET_VELOCITY_CUSTOM_Y _IO(TOUCH_IOC_MAGIC,1)
310
311 int g_v_magnify_x = TPD_VELOCITY_CUSTOM_X;
312 int g_v_magnify_y = TPD_VELOCITY_CUSTOM_Y;
313 static int tpd_misc_open(struct inode *inode, struct file *file)
314 {
315 return nonseekable_open(inode, file);
316 }
317
318 static int tpd_misc_release(struct inode *inode, struct file *file)
319 {
320 return 0;
321 }
322
323 static long tpd_unlocked_ioctl(struct file *file, unsigned int cmd,
324 unsigned long arg)
325 {
326 //char strbuf[256];
327 void __user *data;
328
329 long err = 0;
330
331 if (_IOC_DIR(cmd) & _IOC_READ)
332 {
333 err = !access_ok(VERIFY_WRITE, (void __user *)arg, _IOC_SIZE(cmd));
334 }
335 else if (_IOC_DIR(cmd) & _IOC_WRITE)
336 {
337 err = !access_ok(VERIFY_READ, (void __user *)arg, _IOC_SIZE(cmd));
338 }
339
340 if (err)
341 {
342 printk("tpd: access error: %08X, (%2d, %2d)\n", cmd, _IOC_DIR(cmd), _IOC_SIZE(cmd));
343 return -EFAULT;
344 }
345
346 switch (cmd)
347 {
348 case TPD_GET_VELOCITY_CUSTOM_X:
349 data = (void __user *) arg;
350
351 if (data == NULL)
352 {
353 err = -EINVAL;
354 break;
355 }
356
357 if (copy_to_user(data, &g_v_magnify_x, sizeof(g_v_magnify_x)))
358 {
359 err = -EFAULT;
360 break;
361 }
362
363 break;
364
365 case TPD_GET_VELOCITY_CUSTOM_Y:
366 data = (void __user *) arg;
367
368 if (data == NULL)
369 {
370 err = -EINVAL;
371 break;
372 }
373
374 if (copy_to_user(data, &g_v_magnify_y, sizeof(g_v_magnify_y)))
375 {
376 err = -EFAULT;
377 break;
378 }
379
380 break;
381
382 default:
383 printk("tpd: unknown IOCTL: 0x%08x\n", cmd);
384 err = -ENOIOCTLCMD;
385 break;
386
387 }
388
389 return err;
390 }
391
392
393 static struct file_operations tpd_fops =
394 {
395 // .owner = THIS_MODULE,
396 .open = tpd_misc_open,
397 .release = tpd_misc_release,
398 .unlocked_ioctl = tpd_unlocked_ioctl,
399 };
400 /*----------------------------------------------------------------------------*/
401 static struct miscdevice tpd_misc_device =
402 {
403 .minor = MISC_DYNAMIC_MINOR,
404 .name = "gt9xx_touch",
405 .fops = &tpd_fops,
406 };
407
408 //**********************************************
409 #endif
410
411 static int tpd_i2c_detect(struct i2c_client *client, struct i2c_board_info *info)
412 {
413 strcpy(info->type, "mtk-tpd");
414 return 0;
415 }
416
417 #ifdef TPD_PROXIMITY
418 static s32 tpd_get_ps_value(void)
419 {
420 return tpd_proximity_detect;
421 }
422
423 static s32 tpd_enable_ps(s32 enable)
424 {
425 u8 state;
426 s32 ret = -1;
427
428 if (enable)
429 {
430 state = 1;
431 tpd_proximity_flag = 1;
432 GTP_INFO("TPD proximity function to be on.");
433 }
434 else
435 {
436 state = 0;
437 tpd_proximity_flag = 0;
438 GTP_INFO("TPD proximity function to be off.");
439 }
440
441 ret = i2c_write_bytes(i2c_client_point, TPD_PROXIMITY_ENABLE_REG, &state, 1);
442
443 if (ret < 0)
444 {
445 GTP_ERROR("TPD %s proximity cmd failed.", state ? "enable" : "disable");
446 return ret;
447 }
448
449 GTP_INFO("TPD proximity function %s success.", state ? "enable" : "disable");
450 return 0;
451 }
452
453 s32 tpd_ps_operate(void *self, u32 command, void *buff_in, s32 size_in,
454 void *buff_out, s32 size_out, s32 *actualout)
455 {
456 s32 err = 0;
457 s32 value;
458 hwm_sensor_data *sensor_data;
459
460 switch (command)
461 {
462 case SENSOR_DELAY:
463 if ((buff_in == NULL) || (size_in < sizeof(int)))
464 {
465 GTP_ERROR("Set delay parameter error!");
466 err = -EINVAL;
467 }
468
469 // Do nothing
470 break;
471
472 case SENSOR_ENABLE:
473 if ((buff_in == NULL) || (size_in < sizeof(int)))
474 {
475 GTP_ERROR("Enable sensor parameter error!");
476 err = -EINVAL;
477 }
478 else
479 {
480 value = *(int *)buff_in;
481 err = tpd_enable_ps(value);
482 }
483
484 break;
485
486 case SENSOR_GET_DATA:
487 if ((buff_out == NULL) || (size_out < sizeof(hwm_sensor_data)))
488 {
489 GTP_ERROR("Get sensor data parameter error!");
490 err = -EINVAL;
491 }
492 else
493 {
494 sensor_data = (hwm_sensor_data *)buff_out;
495 sensor_data->values[0] = tpd_get_ps_value();
496 sensor_data->value_divide = 1;
497 sensor_data->status = SENSOR_STATUS_ACCURACY_MEDIUM;
498 }
499
500 break;
501
502 default:
503 GTP_ERROR("proxmy sensor operate function no this parameter %d!\n", command);
504 err = -1;
505 break;
506 }
507
508 return err;
509 }
510 #endif
511
512
513 static ssize_t gt91xx_config_read_proc(struct file *file, char __user *page, size_t size, loff_t *ppos)
514 {
515 char *ptr = page;
516 char temp_data[GTP_CONFIG_MAX_LENGTH + 2] = {0};
517 int i;
518
519 if (*ppos) // CMD call again
520 {
521 return 0;
522 }
523
524 ptr += sprintf(ptr, "==== GT9XX config init value====\n");
525
526 for (i = 0 ; i < GTP_CONFIG_MAX_LENGTH ; i++)
527 {
528 ptr += sprintf(ptr, "0x%02X ", config[i + 2]);
529
530 if (i % 8 == 7)
531 ptr += sprintf(ptr, "\n");
532 }
533
534 ptr += sprintf(ptr, "\n");
535
536 ptr += sprintf(ptr, "==== GT9XX config real value====\n");
537 i2c_read_bytes(i2c_client_point, GTP_REG_CONFIG_DATA, temp_data, GTP_CONFIG_MAX_LENGTH);
538
539 for (i = 0 ; i < GTP_CONFIG_MAX_LENGTH ; i++)
540 {
541 ptr += sprintf(ptr, "0x%02X ", temp_data[i]);
542
543 if (i % 8 == 7)
544 ptr += sprintf(ptr, "\n");
545 }
546 *ppos += ptr - page;
547 return (ptr - page);
548 }
549
550 static ssize_t gt91xx_config_write_proc(struct file *filp, const char __user *buffer, size_t count, loff_t *off)
551 {
552 s32 ret = 0;
553
554 GTP_DEBUG("write count %d\n", count);
555
556 if (count > GTP_CONFIG_MAX_LENGTH)
557 {
558 GTP_ERROR("size not match [%d:%d]\n", GTP_CONFIG_MAX_LENGTH, count);
559 return -EFAULT;
560 }
561
562 if (copy_from_user(&config[2], buffer, count))
563 {
564 GTP_ERROR("copy from user fail\n");
565 return -EFAULT;
566 }
567
568 ret = gtp_send_cfg(i2c_client_point);
569 abs_x_max = (config[RESOLUTION_LOC + 1] << 8) + config[RESOLUTION_LOC];
570 abs_y_max = (config[RESOLUTION_LOC + 3] << 8) + config[RESOLUTION_LOC + 2];
571 int_type = (config[TRIGGER_LOC]) & 0x03;
572
573 if (ret < 0)
574 {
575 GTP_ERROR("send config failed.");
576 }
577
578 return count;
579 }
580
581 #if GTP_SUPPORT_I2C_DMA
582 s32 i2c_dma_read(struct i2c_client *client, u16 addr, u8 *rxbuf, s32 len)
583 {
584 int ret;
585 s32 retry = 0;
586 u8 buffer[2];
587
588 struct i2c_msg msg[2] =
589 {
590 {
591 .addr = (client->addr & I2C_MASK_FLAG),
592 .flags = 0,
593 .buf = buffer,
594 .len = 2,
595 .timing = I2C_MASTER_CLOCK
596 },
597 {
598 .addr = (client->addr & I2C_MASK_FLAG),
599 .ext_flag = (client->ext_flag | I2C_ENEXT_FLAG | I2C_DMA_FLAG),
600 .flags = I2C_M_RD,
601 .buf = (u8*)gpDMABuf_pa,
602 .len = len,
603 .timing = I2C_MASTER_CLOCK
604 },
605 };
606
607 buffer[0] = (addr >> 8) & 0xFF;
608 buffer[1] = addr & 0xFF;
609
610 if (rxbuf == NULL)
611 return -1;
612
613 //GTP_DEBUG("dma i2c read: 0x%04X, %d bytes(s)", addr, len);
614 for (retry = 0; retry < 5; ++retry)
615 {
616 ret = i2c_transfer(client->adapter, &msg[0], 2);
617 if (ret < 0)
618 {
619 continue;
620 }
621 memcpy(rxbuf, gpDMABuf_va, len);
622 return 0;
623 }
624 GTP_ERROR("Dma I2C Read Error: 0x%04X, %d byte(s), err-code: %d", addr, len, ret);
625 return ret;
626 }
627
628
629 s32 i2c_dma_write(struct i2c_client *client, u16 addr, u8 *txbuf, s32 len)
630 {
631 int ret;
632 s32 retry = 0;
633 u8 *wr_buf = gpDMABuf_va;
634
635 struct i2c_msg msg =
636 {
637 .addr = (client->addr & I2C_MASK_FLAG),
638 .ext_flag = (client->ext_flag | I2C_ENEXT_FLAG | I2C_DMA_FLAG),
639 .flags = 0,
640 .buf = (u8*)gpDMABuf_pa,
641 .len = 2 + len,
642 .timing = I2C_MASTER_CLOCK
643 };
644
645 wr_buf[0] = (u8)((addr >> 8) & 0xFF);
646 wr_buf[1] = (u8)(addr & 0xFF);
647
648 if (txbuf == NULL)
649 return -1;
650
651 //GTP_DEBUG("dma i2c write: 0x%04X, %d bytes(s)", addr, len);
652 memcpy(wr_buf+2, txbuf, len);
653 for (retry = 0; retry < 5; ++retry)
654 {
655 ret = i2c_transfer(client->adapter, &msg, 1);
656 if (ret < 0)
657 {
658 continue;
659 }
660 return 0;
661 }
662 GTP_ERROR("Dma I2C Write Error: 0x%04X, %d byte(s), err-code: %d", addr, len, ret);
663 return ret;
664 }
665
666 s32 i2c_read_bytes_dma(struct i2c_client *client, u16 addr, u8 *rxbuf, s32 len)
667 {
668 s32 left = len;
669 s32 read_len = 0;
670 u8 *rd_buf = rxbuf;
671 s32 ret = 0;
672
673 //GTP_DEBUG("Read bytes dma: 0x%04X, %d byte(s)", addr, len);
674 while (left > 0)
675 {
676 if (left > GTP_DMA_MAX_TRANSACTION_LENGTH)
677 {
678 read_len = GTP_DMA_MAX_TRANSACTION_LENGTH;
679 }
680 else
681 {
682 read_len = left;
683 }
684 ret = i2c_dma_read(client, addr, rd_buf, read_len);
685 if (ret < 0)
686 {
687 GTP_ERROR("dma read failed");
688 return -1;
689 }
690
691 left -= read_len;
692 addr += read_len;
693 rd_buf += read_len;
694 }
695 return 0;
696 }
697
698 s32 i2c_write_bytes_dma(struct i2c_client *client, u16 addr, u8 *txbuf, s32 len)
699 {
700
701 s32 ret = 0;
702 s32 write_len = 0;
703 s32 left = len;
704 u8 *wr_buf = txbuf;
705
706 //GTP_DEBUG("Write bytes dma: 0x%04X, %d byte(s)", addr, len);
707 while (left > 0)
708 {
709 if (left > GTP_DMA_MAX_I2C_TRANSFER_SIZE)
710 {
711 write_len = GTP_DMA_MAX_I2C_TRANSFER_SIZE;
712 }
713 else
714 {
715 write_len = left;
716 }
717 ret = i2c_dma_write(client, addr, wr_buf, write_len);
718
719 if (ret < 0)
720 {
721 GTP_ERROR("dma i2c write failed!");
722 return -1;
723 }
724
725 left -= write_len;
726 addr += write_len;
727 wr_buf += write_len;
728 }
729 return 0;
730 }
731 #endif
732
733
734 int i2c_read_bytes_non_dma(struct i2c_client *client, u16 addr, u8 *rxbuf, int len)
735 {
736 u8 buffer[GTP_ADDR_LENGTH];
737 u8 retry;
738 u16 left = len;
739 u16 offset = 0;
740
741 struct i2c_msg msg[2] =
742 {
743 {
744 //.addr = ((client->addr &I2C_MASK_FLAG) | (I2C_ENEXT_FLAG)),
745 .addr = ((client->addr &I2C_MASK_FLAG) | (I2C_PUSHPULL_FLAG)),
746 .flags = 0,
747 .buf = buffer,
748 .len = GTP_ADDR_LENGTH,
749 .timing = I2C_MASTER_CLOCK
750 },
751 {
752 //.addr = ((client->addr &I2C_MASK_FLAG) | (I2C_ENEXT_FLAG)),
753 .addr = ((client->addr &I2C_MASK_FLAG) | (I2C_PUSHPULL_FLAG)),
754 .flags = I2C_M_RD,
755 .timing = I2C_MASTER_CLOCK
756 },
757 };
758
759 if (rxbuf == NULL)
760 return -1;
761
762 //GTP_DEBUG("i2c_read_bytes to device %02X address %04X len %d\n", client->addr, addr, len);
763
764 while (left > 0)
765 {
766 buffer[0] = ((addr + offset) >> 8) & 0xFF;
767 buffer[1] = (addr + offset) & 0xFF;
768
769 msg[1].buf = &rxbuf[offset];
770
771 if (left > MAX_TRANSACTION_LENGTH)
772 {
773 msg[1].len = MAX_TRANSACTION_LENGTH;
774 left -= MAX_TRANSACTION_LENGTH;
775 offset += MAX_TRANSACTION_LENGTH;
776 }
777 else
778 {
779 msg[1].len = left;
780 left = 0;
781 }
782
783 retry = 0;
784
785 while (i2c_transfer(client->adapter, &msg[0], 2) != 2)
786 {
787 retry++;
788
789 //if (retry == 20)
790 if (retry == 5)
791 {
792 GTP_ERROR("I2C read 0x%X length=%d failed\n", addr + offset, len);
793 return -1;
794 }
795 }
796 }
797
798 return 0;
799 }
800
801
802 int i2c_read_bytes(struct i2c_client *client, u16 addr, u8 *rxbuf, int len)
803 {
804 #if GTP_SUPPORT_I2C_DMA
805 return i2c_read_bytes_dma(client, addr, rxbuf, len);
806 #else
807 return i2c_read_bytes_non_dma(client, addr, rxbuf, len);
808 #endif
809 }
810
811 s32 gtp_i2c_read(struct i2c_client *client, u8 *buf, s32 len)
812 {
813 s32 ret = -1;
814 u16 addr = (buf[0] << 8) + buf[1];
815
816 ret = i2c_read_bytes_non_dma(client, addr, &buf[2], len - 2);
817
818 if (!ret)
819 {
820 return 2;
821 }
822 else
823 {
824 //#if GTP_GESTURE_WAKEUP
825 if(gesture_value > 0){
826 if (DOZE_ENABLED == doze_status)
827 {
828 return ret;
829 }
830 //#endif
831 }
832 #if GTP_COMPATIBLE_MODE
833 if (CHIP_TYPE_GT9F == gtp_chip_type)
834 {
835 #if GTP_FL_LITTLE_SYSTEM
836 if (little_fw_mode)
837 {
838 // do nothing
839 GTP_INFO("Little fw enabled, no esd reset.");
840 }
841 else
842 #endif
843 {
844 gtp_recovery_reset(client);
845 }
846 }
847 else
848 #endif
849 {
850 gtp_reset_guitar(client, 20);
851 }
852 return ret;
853 }
854 }
855
856
857 s32 gtp_i2c_read_dbl_check(struct i2c_client *client, u16 addr, u8 *rxbuf, int len)
858 {
859 u8 buf[16] = {0};
860 u8 confirm_buf[16] = {0};
861 u8 retry = 0;
862
863 while (retry++ < 3)
864 {
865 memset(buf, 0xAA, 16);
866 buf[0] = (u8)(addr >> 8);
867 buf[1] = (u8)(addr & 0xFF);
868 gtp_i2c_read(client, buf, len + 2);
869
870 memset(confirm_buf, 0xAB, 16);
871 confirm_buf[0] = (u8)(addr >> 8);
872 confirm_buf[1] = (u8)(addr & 0xFF);
873 gtp_i2c_read(client, confirm_buf, len + 2);
874
875 if (!memcmp(buf, confirm_buf, len+2))
876 {
877 memcpy(rxbuf, confirm_buf+2, len);
878 return SUCCESS;
879 }
880 }
881 GTP_ERROR("i2c read 0x%04X, %d bytes, double check failed!", addr, len);
882 return FAIL;
883 }
884
885 int i2c_write_bytes_non_dma(struct i2c_client *client, u16 addr, u8 *txbuf, int len)
886 {
887 u8 buffer[MAX_TRANSACTION_LENGTH];
888 u16 left = len;
889 u16 offset = 0;
890 u8 retry = 0;
891
892 struct i2c_msg msg =
893 {
894 //.addr = ((client->addr &I2C_MASK_FLAG) | (I2C_ENEXT_FLAG)),
895 .addr = ((client->addr &I2C_MASK_FLAG) | (I2C_PUSHPULL_FLAG)),
896 .flags = 0,
897 .buf = buffer,
898 .timing = I2C_MASTER_CLOCK,
899 };
900
901
902 if (txbuf == NULL)
903 return -1;
904
905 //GTP_DEBUG("i2c_write_bytes to device %02X address %04X len %d\n", client->addr, addr, len);
906
907 while (left > 0)
908 {
909 retry = 0;
910
911 buffer[0] = ((addr + offset) >> 8) & 0xFF;
912 buffer[1] = (addr + offset) & 0xFF;
913
914 if (left > MAX_I2C_TRANSFER_SIZE)
915 {
916 memcpy(&buffer[GTP_ADDR_LENGTH], &txbuf[offset], MAX_I2C_TRANSFER_SIZE);
917 msg.len = MAX_TRANSACTION_LENGTH;
918 left -= MAX_I2C_TRANSFER_SIZE;
919 offset += MAX_I2C_TRANSFER_SIZE;
920 }
921 else
922 {
923 memcpy(&buffer[GTP_ADDR_LENGTH], &txbuf[offset], left);
924 msg.len = left + GTP_ADDR_LENGTH;
925 left = 0;
926 }
927
928 //GTP_DEBUG("byte left %d offset %d\n", left, offset);
929
930 while (i2c_transfer(client->adapter, &msg, 1) != 1)
931 {
932 retry++;
933
934 //if (retry == 20)
935 if (retry == 5)
936 {
937 //dump_stack();
938 GTP_ERROR("I2C write 0x%X%X length=%d failed\n", buffer[0], buffer[1], len);
939 return -1;
940 }
941 }
942 }
943
944 return 0;
945 }
946
947 int i2c_write_bytes(struct i2c_client *client, u16 addr, u8 *txbuf, int len)
948 {
949 #if GTP_SUPPORT_I2C_DMA
950 return i2c_write_bytes_dma(client, addr, txbuf, len);
951 #else
952 return i2c_write_bytes_non_dma(client, addr, txbuf, len);
953 #endif
954 }
955
956 s32 gtp_i2c_write(struct i2c_client *client, u8 *buf, s32 len)
957 {
958 s32 ret = -1;
959 u16 addr = (buf[0] << 8) + buf[1];
960
961 ret = i2c_write_bytes_non_dma(client, addr, &buf[2], len - 2);
962
963 if (!ret)
964 {
965 return 1;
966 }
967 else
968 {
969 //#if GTP_GESTURE_WAKEUP
970 if(gesture_value > 0){
971 if (DOZE_ENABLED == doze_status)
972 {
973 return ret;
974 }
975 //#endif
976 }
977 #if GTP_COMPATIBLE_MODE
978 if (CHIP_TYPE_GT9F == gtp_chip_type)
979 {
980 #if GTP_FL_LITTLE_SYSTEM
981 if (little_fw_mode)
982 {
983 // do nothing
984 GTP_INFO("Little fw enabled, no esd reset.");
985 }
986 else
987 #endif
988 {
989 gtp_recovery_reset(client);
990 }
991 }
992 else
993 #endif
994 {
995 gtp_reset_guitar(client, 20);
996 }
997 return ret;
998 }
999 }
1000
1001
1002
1003 /*******************************************************
1004 Function:
1005 Send config Function.
1006
1007 Input:
1008 client: i2c client.
1009
1010 Output:
1011 Executive outcomes.0--success,non-0--fail.
1012 *******************************************************/
1013 s32 gtp_send_cfg(struct i2c_client *client)
1014 {
1015 s32 ret = 1;
1016
1017 #if GTP_DRIVER_SEND_CFG
1018 s32 retry = 0;
1019 if (fixed_config)
1020 {
1021 GTP_INFO("Ic fixed config, no config sent!");
1022 return 0;
1023 }
1024 else if (pnl_init_error)
1025 {
1026 GTP_INFO("Error occurred in init_panel, no config sent!");
1027 return 0;
1028 }
1029
1030 GTP_INFO("Driver Send Config");
1031 for (retry = 0; retry < 5; retry++)
1032 {
1033 ret = gtp_i2c_write(client, config, GTP_CONFIG_MAX_LENGTH + GTP_ADDR_LENGTH);
1034
1035 if (ret > 0)
1036 {
1037 break;
1038 }
1039 }
1040 #endif
1041 return ret;
1042 }
1043
1044
1045 /*******************************************************
1046 Function:
1047 Read goodix touchscreen version function.
1048
1049 Input:
1050 client: i2c client struct.
1051 version:address to store version info
1052
1053 Output:
1054 Executive outcomes.0---succeed.
1055 *******************************************************/
1056 s32 gtp_read_version(struct i2c_client *client, u16 *version)
1057 {
1058 s32 ret = -1;
1059 s32 i;
1060 u8 buf[8] = {GTP_REG_VERSION >> 8, GTP_REG_VERSION & 0xff};
1061
1062 GTP_DEBUG_FUNC();
1063
1064 ret = gtp_i2c_read(client, buf, sizeof(buf));
1065
1066 if (ret < 0)
1067 {
1068 GTP_ERROR("GTP read version failed");
1069 return ret;
1070 }
1071
1072 if (version)
1073 {
1074 *version = (buf[7] << 8) | buf[6];
1075 }
1076
1077 tpd_info.vid = *version;
1078 tpd_info.pid = 0x00;
1079
1080 for (i = 0; i < 4; i++)
1081 {
1082 if (buf[i + 2] < 0x30)break;
1083
1084 tpd_info.pid |= ((buf[i + 2] - 0x30) << ((3 - i) * 4));
1085 }
1086
1087 if (buf[5] == 0x00)
1088 {
1089 GTP_INFO("IC VERSION: %c%c%c_%02x%02x",
1090 buf[2], buf[3], buf[4], buf[7], buf[6]);
1091 }
1092 else
1093 {
1094 GTP_INFO("IC VERSION:%c%c%c%c_%02x%02x",
1095 buf[2], buf[3], buf[4], buf[5], buf[7], buf[6]);
1096 }
1097 sprintf(tpd_firmware_version_val,"%02x%02x",buf[7], buf[6]);
1098 tpd_firmware_version_val[4] = '\0';
1099 printk(KERN_ERR"caoyang test tpd_firmware_version_val:%s",tpd_firmware_version_val);
1100 return ret;
1101 }
1102
1103 #if GTP_DRIVER_SEND_CFG
1104 /*******************************************************
1105 Function:
1106 Get information from ic, such as resolution and
1107 int trigger type
1108 Input:
1109 client: i2c client private struct.
1110
1111 Output:
1112 FAIL: i2c failed, SUCCESS: i2c ok
1113 *******************************************************/
1114 static s32 gtp_get_info(struct i2c_client *client)
1115 {
1116 u8 opr_buf[6] = {0};
1117 s32 ret = 0;
1118
1119 opr_buf[0] = (u8)((GTP_REG_CONFIG_DATA+1) >> 8);
1120 opr_buf[1] = (u8)((GTP_REG_CONFIG_DATA+1) & 0xFF);
1121
1122 ret = gtp_i2c_read(client, opr_buf, 6);
1123 if (ret < 0)
1124 {
1125 return FAIL;
1126 }
1127
1128 abs_x_max = (opr_buf[3] << 8) + opr_buf[2];
1129 abs_y_max = (opr_buf[5] << 8) + opr_buf[4];
1130
1131 opr_buf[0] = (u8)((GTP_REG_CONFIG_DATA+6) >> 8);
1132 opr_buf[1] = (u8)((GTP_REG_CONFIG_DATA+6) & 0xFF);
1133
1134 ret = gtp_i2c_read(client, opr_buf, 3);
1135 if (ret < 0)
1136 {
1137 return FAIL;
1138 }
1139 int_type = opr_buf[2] & 0x03;
1140
1141 GTP_INFO("X_MAX = %d, Y_MAX = %d, TRIGGER = 0x%02x",
1142 abs_x_max,abs_y_max, int_type);
1143
1144 return SUCCESS;
1145 }
1146 #endif
1147
1148
1149 /*******************************************************
1150 Function:
1151 GTP initialize function.
1152
1153 Input:
1154 client: i2c client private struct.
1155
1156 Output:
1157 Executive outcomes.0---succeed.
1158 *******************************************************/
1159 static s32 gtp_init_panel(struct i2c_client *client)
1160 {
1161 s32 ret = 0;
1162
1163 #if GTP_DRIVER_SEND_CFG
1164 s32 i;
1165 u8 check_sum = 0;
1166 u8 opr_buf[16];
1167 u8 sensor_id = 0;
1168
1169 u8 cfg_info_group1[] = CTP_CFG_GROUP1;
1170 u8 cfg_info_group2[] = CTP_CFG_GROUP2;
1171 u8 cfg_info_group3[] = CTP_CFG_GROUP3;
1172 u8 cfg_info_group4[] = CTP_CFG_GROUP4;
1173 u8 cfg_info_group5[] = CTP_CFG_GROUP5;
1174 u8 cfg_info_group6[] = CTP_CFG_GROUP6;
1175 u8 *send_cfg_buf[] = {cfg_info_group1, cfg_info_group2, cfg_info_group3,
1176 cfg_info_group4, cfg_info_group5, cfg_info_group6};
1177 u8 cfg_info_len[] = { CFG_GROUP_LEN(cfg_info_group1),
1178 CFG_GROUP_LEN(cfg_info_group2),
1179 CFG_GROUP_LEN(cfg_info_group3),
1180 CFG_GROUP_LEN(cfg_info_group4),
1181 CFG_GROUP_LEN(cfg_info_group5),
1182 CFG_GROUP_LEN(cfg_info_group6)};
1183
1184 GTP_DEBUG("Config Groups\' Lengths: %d, %d, %d, %d, %d, %d",
1185 cfg_info_len[0], cfg_info_len[1], cfg_info_len[2], cfg_info_len[3],
1186 cfg_info_len[4], cfg_info_len[5]);
1187
1188 if ((!cfg_info_len[1]) && (!cfg_info_len[2]) &&
1189 (!cfg_info_len[3]) && (!cfg_info_len[4]) &&
1190 (!cfg_info_len[5]))
1191 {
1192 sensor_id = 0;
1193 }
1194 else
1195 {
1196 #if GTP_COMPATIBLE_MODE
1197 if (CHIP_TYPE_GT9F == gtp_chip_type)
1198 {
1199 msleep(50);
1200 }
1201 #endif
1202 ret = gtp_i2c_read_dbl_check(client, GTP_REG_SENSOR_ID, &sensor_id, 1);
1203 if (SUCCESS == ret)
1204 {
1205 if (sensor_id >= 0x06)
1206 {
1207 GTP_ERROR("Invalid sensor_id(0x%02X), No Config Sent!", sensor_id);
1208 pnl_init_error = 1;
1209 return -1;
1210 }
1211 }
1212 else
1213 {
1214 GTP_ERROR("Failed to get sensor_id, No config sent!");
1215 pnl_init_error = 1;
1216 return -1;
1217 }
1218 GTP_INFO("Sensor_ID: %d", sensor_id);
1219 }
1220
1221 cfg_len = cfg_info_len[sensor_id];
1222 tpd_config_version= send_cfg_buf[sensor_id][0];
1223 GTP_INFO("CTP_CONFIG_GROUP%d used, config length: %d", sensor_id + 1, cfg_len);
1224
1225 if (cfg_len < GTP_CONFIG_MIN_LENGTH)
1226 {
1227 GTP_ERROR("CTP_CONFIG_GROUP%d is INVALID CONFIG GROUP! NO Config Sent! You need to check you header file CFG_GROUP section!", sensor_id+1);
1228 pnl_init_error = 1;
1229 return -1;
1230 }
1231
1232 #if GTP_COMPATIBLE_MODE
1233 if (CHIP_TYPE_GT9F == gtp_chip_type)
1234 {
1235 fixed_config = 0;
1236 }
1237 else
1238 #endif
1239 {
1240 ret = gtp_i2c_read_dbl_check(client, GTP_REG_CONFIG_DATA, &opr_buf[0], 1);
1241
1242 if (ret == SUCCESS)
1243 {
1244 GTP_DEBUG("CFG_CONFIG_GROUP%d Config Version: %d, 0x%02X; IC Config Version: %d, 0x%02X", sensor_id+1,
1245 send_cfg_buf[sensor_id][0], send_cfg_buf[sensor_id][0], opr_buf[0], opr_buf[0]);
1246
1247 if (opr_buf[0] < 90)
1248 {
1249 grp_cfg_version = send_cfg_buf[sensor_id][0]; // backup group config version
1250 send_cfg_buf[sensor_id][0] = 0x00;
1251 fixed_config = 0;
1252 }
1253 else // treated as fixed config, not send config
1254 {
1255 GTP_INFO("Ic fixed config with config version(%d)", opr_buf[0]);
1256 fixed_config = 1;
1257 gtp_get_info(client);
1258 return 0;
1259 }
1260 }
1261 else
1262 {
1263 GTP_ERROR("Failed to get ic config version!No config sent!");
1264 return -1;
1265 }
1266 }
1267
1268 memset(&config[GTP_ADDR_LENGTH], 0, GTP_CONFIG_MAX_LENGTH);
1269 memcpy(&config[GTP_ADDR_LENGTH], send_cfg_buf[sensor_id], cfg_len);
1270
1271 #if GTP_CUSTOM_CFG
1272 config[RESOLUTION_LOC] = (u8)GTP_MAX_WIDTH;
1273 config[RESOLUTION_LOC + 1] = (u8)(GTP_MAX_WIDTH>>8);
1274 config[RESOLUTION_LOC + 2] = (u8)GTP_MAX_HEIGHT;
1275 config[RESOLUTION_LOC + 3] = (u8)(GTP_MAX_HEIGHT>>8);
1276
1277 if (GTP_INT_TRIGGER == 0) //RISING
1278 {
1279 config[TRIGGER_LOC] &= 0xfe;
1280 }
1281 else if (GTP_INT_TRIGGER == 1) //FALLING
1282 {
1283 config[TRIGGER_LOC] |= 0x01;
1284 }
1285 #endif // GTP_CUSTOM_CFG
1286
1287 check_sum = 0;
1288 for (i = GTP_ADDR_LENGTH; i < cfg_len; i++)
1289 {
1290 check_sum += config[i];
1291 }
1292 config[cfg_len] = (~check_sum) + 1;
1293
1294 #else // DRIVER NOT SEND CONFIG
1295 cfg_len = GTP_CONFIG_MAX_LENGTH;
1296 ret = gtp_i2c_read(client, config, cfg_len + GTP_ADDR_LENGTH);
1297 if (ret < 0)
1298 {
1299 GTP_ERROR("Read Config Failed, Using DEFAULT Resolution & INT Trigger!");
1300 abs_x_max = GTP_MAX_WIDTH;
1301 abs_y_max = GTP_MAX_HEIGHT;
1302 int_type = GTP_INT_TRIGGER;
1303 }
1304 #endif // GTP_DRIVER_SEND_CFG
1305
1306 GTP_DEBUG_FUNC();
1307 if ((abs_x_max == 0) && (abs_y_max == 0))
1308 {
1309 abs_x_max = (config[RESOLUTION_LOC + 1] << 8) + config[RESOLUTION_LOC];
1310 abs_y_max = (config[RESOLUTION_LOC + 3] << 8) + config[RESOLUTION_LOC + 2];
1311 int_type = (config[TRIGGER_LOC]) & 0x03;
1312 }
1313
1314 #if GTP_COMPATIBLE_MODE
1315 if (CHIP_TYPE_GT9F == gtp_chip_type)
1316 {
1317 u8 have_key = 0;
1318 if (is_950)
1319 {
1320 driver_num = config[GTP_REG_MATRIX_DRVNUM - GTP_REG_CONFIG_DATA + 2];
1321 sensor_num = config[GTP_REG_MATRIX_SENNUM - GTP_REG_CONFIG_DATA + 2];
1322 }
1323 else
1324 {
1325 driver_num = (config[CFG_LOC_DRVA_NUM]&0x1F) + (config[CFG_LOC_DRVB_NUM]&0x1F);
1326 sensor_num = (config[CFG_LOC_SENS_NUM]&0x0F) + ((config[CFG_LOC_SENS_NUM]>>4)&0x0F);
1327 }
1328
1329 have_key = config[GTP_REG_HAVE_KEY - GTP_REG_CONFIG_DATA + 2] & 0x01; // have key or not
1330 if (1 == have_key)
1331 {
1332 driver_num--;
1333 }
1334
1335 if ((cfg_len == 186) && after_912_1020)
1336 {
1337 GTP_DEBUG("Firmware after 912_1020, set config length to 228.");
1338
1339 cfg_len = 228;
1340
1341 config[GTP_ADDR_LENGTH + 226] = config[GTP_ADDR_LENGTH + 184];
1342
1343 memset(&config[GTP_ADDR_LENGTH + 184], 0x00, 228 - 186);
1344
1345 config[GTP_ADDR_LENGTH + 227] = 0x01;
1346
1347 }
1348 tpd_x_line = driver_num;
1349 tpd_y_line = sensor_num;
1350 GTP_INFO("Driver * Sensor: %d * %d(Key: %d), X_MAX = %d, Y_MAX = %d, TRIGGER = 0x%02x",
1351 driver_num, sensor_num, have_key, abs_x_max,abs_y_max,int_type);
1352 }
1353 else
1354 #endif
1355 {
1356 #if GTP_DRIVER_SEND_CFG
1357 ret = gtp_send_cfg(client);
1358 if (ret < 0)
1359 {
1360 GTP_ERROR("Send config error.");
1361 }
1362 // set config version to CTP_CFG_GROUP
1363 // for resume to send config
1364 config[GTP_ADDR_LENGTH] = grp_cfg_version;
1365 check_sum = 0;
1366 for (i = GTP_ADDR_LENGTH; i < cfg_len; i++)
1367 {
1368 check_sum += config[i];
1369 }
1370 config[cfg_len] = (~check_sum) + 1;
1371 #endif
1372 GTP_INFO("X_MAX = %d, Y_MAX = %d, TRIGGER = 0x%02x",
1373 abs_x_max,abs_y_max,int_type);
1374 }
1375
1376 msleep(10);
1377 return 0;
1378 }
1379
1380 static s8 gtp_i2c_test(struct i2c_client *client)
1381 {
1382
1383 u8 retry = 0;
1384 s8 ret = -1;
1385 u32 hw_info = 0;
1386
1387 GTP_DEBUG_FUNC();
1388
1389 while (retry++ < 5)
1390 {
1391 ret = i2c_read_bytes(client, GTP_REG_HW_INFO, (u8 *)&hw_info, sizeof(hw_info));
1392
1393 if ((!ret) && (hw_info == 0x00900600)) //20121212
1394 {
1395 return ret;
1396 }
1397
1398 GTP_ERROR("GTP_REG_HW_INFO : %08X", hw_info);
1399 GTP_ERROR("GTP i2c test failed time %d.", retry);
1400 msleep(10);
1401 }
1402
1403 return -1;
1404 }
1405
1406
1407
1408 /*******************************************************
1409 Function:
1410 Set INT pin as input for FW sync.
1411
1412 Note:
1413 If the INT is high, It means there is pull up resistor attached on the INT pin.
1414 Pull low the INT pin manaully for FW sync.
1415 *******************************************************/
1416 void gtp_int_sync(s32 ms)
1417 {
1418 GTP_GPIO_OUTPUT(GTP_INT_PORT, 0);
1419 msleep(ms);
1420 GTP_GPIO_AS_INT(GTP_INT_PORT);
1421 }
1422
1423 void gtp_reset_guitar(struct i2c_client *client, s32 ms)
1424 {
1425 GTP_INFO("GTP RESET!\n");
1426 GTP_GPIO_OUTPUT(GTP_RST_PORT, 0);
1427 msleep(ms);
1428 GTP_GPIO_OUTPUT(GTP_INT_PORT, client->addr == 0x14);
1429
1430 msleep(2);
1431 GTP_GPIO_OUTPUT(GTP_RST_PORT, 1);
1432
1433 msleep(6); //must >= 6ms
1434
1435 #if GTP_COMPATIBLE_MODE
1436 if (CHIP_TYPE_GT9F == gtp_chip_type)
1437 {
1438 return;
1439 }
1440 #endif
1441
1442 gtp_int_sync(50);
1443 #if GTP_ESD_PROTECT
1444 gtp_init_ext_watchdog(i2c_client_point);
1445 #endif
1446 }
1447
1448 static int tpd_power_on(struct i2c_client *client)
1449 {
1450 int ret = 0;
1451 int reset_count = 0;
1452
1453 reset_proc:
1454 GTP_GPIO_OUTPUT(GTP_RST_PORT, 0);
1455 GTP_GPIO_OUTPUT(GTP_INT_PORT, 0);
1456 msleep(10);
1457
1458 #ifdef MT6573
1459 // power on CTP
1460 mt_set_gpio_mode(GPIO_CTP_EN_PIN, GPIO_CTP_EN_PIN_M_GPIO);
1461 mt_set_gpio_dir(GPIO_CTP_EN_PIN, GPIO_DIR_OUT);
1462 mt_set_gpio_out(GPIO_CTP_EN_PIN, GPIO_OUT_ONE);
1463
1464 #else // ( defined(MT6575) || defined(MT6577) || defined(MT6589) )
1465
1466 #ifdef TPD_POWER_SOURCE_CUSTOM
1467 hwPowerOn(TPD_POWER_SOURCE_CUSTOM, VOL_2800, "TP");
1468 #else
1469 hwPowerOn(MT65XX_POWER_LDO_VGP2, VOL_2800, "TP");
1470 #endif
1471 #ifdef TPD_POWER_SOURCE_1800
1472 hwPowerOn(TPD_POWER_SOURCE_1800, VOL_1800, "TP");
1473 #endif
1474
1475 #endif
1476
1477 gtp_reset_guitar(client, 20);
1478
1479 #if GTP_COMPATIBLE_MODE
1480 gtp_get_chip_type(client);
1481
1482 if (CHIP_TYPE_GT9F == gtp_chip_type)
1483 {
1484 ret = gup_fw_download_proc(NULL, GTP_FL_FW_BURN);
1485
1486 if(FAIL == ret)
1487 {
1488 GTP_ERROR("[tpd_power_on]Download fw failed.");
1489 if(reset_count++ < TPD_MAX_RESET_COUNT)
1490 {
1491 goto reset_proc;
1492 }
1493 else
1494 {
1495 return -1;
1496 }
1497 }
1498
1499 ret = gtp_fw_startup(client);
1500 if(FAIL == ret)
1501 {
1502 GTP_ERROR("[tpd_power_on]Startup fw failed.");
1503 if(reset_count++ < TPD_MAX_RESET_COUNT)
1504 {
1505 goto reset_proc;
1506 }
1507 else
1508 {
1509 return -1;
1510 }
1511 }
1512 }
1513 else
1514 #endif
1515 {
1516 ret = gtp_i2c_test(client);
1517
1518 if (ret < 0)
1519 {
1520 GTP_ERROR("I2C communication ERROR!");
1521
1522 if (reset_count < TPD_MAX_RESET_COUNT)
1523 {
1524 reset_count++;
1525 goto reset_proc;
1526 }
1527 }
1528 }
1529 return ret;
1530 }
1531
1532 //**************** For GT9XXF Start ********************//
1533 #if GTP_COMPATIBLE_MODE
1534
1535
1536 void gtp_get_chip_type(struct i2c_client *client)
1537 {
1538 u8 opr_buf[10] = {0x00};
1539 s32 ret = 0;
1540
1541 msleep(10);
1542
1543 ret = gtp_i2c_read_dbl_check(client, GTP_REG_CHIP_TYPE, opr_buf, 10);
1544
1545 if (FAIL == ret)
1546 {
1547 GTP_ERROR("Failed to get chip-type, set chip type default: GOODIX_GT9");
1548 gtp_chip_type = CHIP_TYPE_GT9;
1549 return;
1550 }
1551
1552 if (!memcmp(opr_buf, "GOODIX_GT9", 10))
1553 {
1554 gtp_chip_type = CHIP_TYPE_GT9;
1555 }
1556 else // GT9XXF
1557 {
1558 gtp_chip_type = CHIP_TYPE_GT9F;
1559 }
1560 GTP_INFO("Chip Type: %s", (gtp_chip_type == CHIP_TYPE_GT9) ? "GOODIX_GT9" : "GOODIX_GT9F");
1561 }
1562
1563 static u8 gtp_bak_ref_proc(struct i2c_client *client, u8 mode)
1564 {
1565 s32 i = 0;
1566 s32 j = 0;
1567 s32 ret = 0;
1568 struct file *flp = NULL;
1569 u8 *refp = NULL;
1570 u32 ref_len = 0;
1571 u32 ref_seg_len = 0;
1572 s32 ref_grps = 0;
1573 s32 ref_chksum = 0;
1574 u16 tmp = 0;
1575
1576 GTP_DEBUG("[gtp_bak_ref_proc]Driver:%d,Sensor:%d.", driver_num, sensor_num);
1577
1578 //check file-system mounted
1579 GTP_DEBUG("[gtp_bak_ref_proc]Waiting for FS %d", gtp_ref_retries);
1580 if (gup_check_fs_mounted("/data") == FAIL)
1581 {
1582 GTP_DEBUG("[gtp_bak_ref_proc]/data not mounted");
1583 if(gtp_ref_retries++ < GTP_CHK_FS_MNT_MAX)
1584 {
1585 return FAIL;
1586 }
1587 }
1588 else
1589 {
1590 GTP_DEBUG("[gtp_bak_ref_proc]/data mounted !!!!");
1591 }
1592
1593 if (is_950)
1594 {
1595 ref_seg_len = (driver_num * (sensor_num - 1) + 2) * 2;
1596 ref_grps = 6;
1597 ref_len = ref_seg_len * 6; // for GT950, backup-reference for six segments
1598 }
1599 else
1600 {
1601 ref_len = driver_num*(sensor_num-2)*2 + 4;
1602 ref_seg_len = ref_len;
1603 ref_grps = 1;
1604 }
1605
1606 refp = (u8 *)kzalloc(ref_len, GFP_KERNEL);
1607 if(refp == NULL)
1608 {
1609 GTP_ERROR("Failed to allocate memory for reference buffer!");
1610 return FAIL;
1611 }
1612 memset(refp, 0, ref_len);
1613
1614 //get ref file data
1615 flp = filp_open(GTP_BAK_REF_PATH, O_RDWR | O_CREAT, 0666);
1616 if (IS_ERR(flp))
1617 {
1618 GTP_ERROR("Failed to open/create %s.", GTP_BAK_REF_PATH);
1619 if (GTP_BAK_REF_SEND == mode)
1620 {
1621 goto default_bak_ref;
1622 }
1623 else
1624 {
1625 goto exit_ref_proc;
1626 }
1627 }
1628
1629 switch (mode)
1630 {
1631 case GTP_BAK_REF_SEND:
1632 {
1633 flp->f_op->llseek(flp, 0, SEEK_SET);
1634 ret = flp->f_op->read(flp, (char *)refp, ref_len, &flp->f_pos);
1635 if(ret < 0)
1636 {
1637 GTP_ERROR("Read ref file failed, send default bak ref.");
1638 goto default_bak_ref;
1639 }
1640 //checksum ref file
1641 for (j = 0; j < ref_grps; ++j)
1642 {
1643 ref_chksum = 0;
1644 for(i=0; i<ref_seg_len-2; i+=2)
1645 {
1646 ref_chksum += ((refp[i + j * ref_seg_len]<<8) + refp[i + 1 + j * ref_seg_len]);
1647 }
1648
1649 GTP_DEBUG("Reference chksum:0x%04X", ref_chksum&0xFF);
1650 tmp = ref_chksum + (refp[ref_seg_len + j * ref_seg_len -2]<<8) + refp[ref_seg_len + j * ref_seg_len -1];
1651 if(1 != tmp)
1652 {
1653 GTP_DEBUG("Invalid checksum for reference, reset reference.");
1654 memset(&refp[j * ref_seg_len], 0, ref_seg_len);
1655 refp[ref_seg_len - 1 + j * ref_seg_len] = 0x01;
1656 }
1657 else
1658 {
1659 if (j == (ref_grps - 1))
1660 {
1661 GTP_INFO("Reference data in %s used.", GTP_BAK_REF_PATH);
1662 }
1663 }
1664
1665 }
1666 ret = i2c_write_bytes(client, GTP_REG_BAK_REF, refp, ref_len);
1667 if(-1 == ret)
1668 {
1669 GTP_ERROR("Write ref i2c error.");
1670 ret = FAIL;
1671 goto exit_ref_proc;
1672 }
1673 }
1674 break;
1675
1676 case GTP_BAK_REF_STORE:
1677 {
1678 ret = i2c_read_bytes(client, GTP_REG_BAK_REF, refp, ref_len);
1679 if(-1 == ret)
1680 {
1681 GTP_ERROR("Read ref i2c error.");
1682 ret = FAIL;
1683 goto exit_ref_proc;
1684 }
1685 flp->f_op->llseek(flp, 0, SEEK_SET);
1686 flp->f_op->write(flp, (char *)refp, ref_len, &flp->f_pos);
1687 }
1688 break;
1689
1690 default:
1691 GTP_ERROR("Invalid Argument(%d) for backup reference", mode);
1692 ret = FAIL;
1693 goto exit_ref_proc;
1694 }
1695
1696 ret = SUCCESS;
1697 goto exit_ref_proc;
1698
1699 default_bak_ref:
1700 for (j = 0; j < ref_grps; ++j)
1701 {
1702 memset(&refp[j * ref_seg_len], 0, ref_seg_len);
1703 refp[j * ref_seg_len + ref_seg_len - 1] = 0x01; // checksum = 1
1704 }
1705 ret = i2c_write_bytes(client, GTP_REG_BAK_REF, refp, ref_len);
1706 if (flp && !IS_ERR(flp))
1707 {
1708 GTP_INFO("Write backup-reference data into %s", GTP_BAK_REF_PATH);
1709 flp->f_op->llseek(flp, 0, SEEK_SET);
1710 flp->f_op->write(flp, (char*)refp, ref_len, &flp->f_pos);
1711 }
1712 if (ret < 0)
1713 {
1714 GTP_ERROR("Failed to load the default backup reference");
1715 ret = FAIL;
1716 }
1717 else
1718 {
1719 ret = SUCCESS;
1720 }
1721 exit_ref_proc:
1722 if (refp)
1723 {
1724 kfree(refp);
1725 }
1726 if (flp && !IS_ERR(flp))
1727 {
1728 filp_close(flp, NULL);
1729 }
1730 return ret;
1731 }
1732
1733 u8 gtp_fw_startup(struct i2c_client *client)
1734 {
1735 u8 wr_buf[4];
1736 s32 ret = 0;
1737
1738 //init sw WDT
1739 wr_buf[0] = 0xAA;
1740 ret = i2c_write_bytes(client, 0x8041, wr_buf, 1);
1741 if (ret < 0)
1742 {
1743 GTP_ERROR("I2C error to firmware startup.");
1744 return FAIL;
1745 }
1746 //release SS51 & DSP
1747 wr_buf[0] = 0x00;
1748 i2c_write_bytes(client, 0x4180, wr_buf, 1);
1749
1750 //int sync
1751 gtp_int_sync(25);
1752
1753 //check fw run status
1754 i2c_read_bytes(client, 0x8041, wr_buf, 1);
1755 if(0xAA == wr_buf[0])
1756 {
1757 GTP_ERROR("IC works abnormally,startup failed.");
1758 return FAIL;
1759 }
1760 else
1761 {
1762 GTP_DEBUG("IC works normally,Startup success.");
1763 wr_buf[0] = 0xAA;
1764 i2c_write_bytes(client, 0x8041, wr_buf, 1);
1765 return SUCCESS;
1766 }
1767 }
1768
1769
1770 static void gtp_recovery_reset(struct i2c_client *client)
1771 {
1772 #if GTP_ESD_PROTECT
1773 gtp_esd_switch(client, SWITCH_OFF);
1774 #endif
1775 force_reset_guitar(0);
1776 #if GTP_ESD_PROTECT
1777 gtp_esd_switch(client, SWITCH_ON);
1778 #endif
1779 }
1780
1781 static u8 gtp_check_clk_legality(u8 *p_clk_buf)
1782 {
1783 u8 i = 0;
1784 u8 clk_chksum = p_clk_buf[5];
1785
1786 for(i = 0; i < 5; i++)
1787 {
1788 if((p_clk_buf[i] < 50) || (p_clk_buf[i] > 120) ||
1789 (p_clk_buf[i] != p_clk_buf[0]))
1790 {
1791 break;
1792 }
1793 clk_chksum += p_clk_buf[i];
1794 }
1795
1796 if((i == 5) && (clk_chksum == 0))
1797 {
1798 GTP_DEBUG("Valid main clock data.");
1799 return SUCCESS;
1800 }
1801 GTP_ERROR("Invalid main clock data.");
1802 return FAIL;
1803 }
1804
1805 static u8 gtp_main_clk_proc(struct i2c_client *client)
1806 {
1807 s32 ret = 0;
1808 u8 i = 0;
1809 u8 clk_cal_result = 0;
1810 u8 clk_chksum = 0;
1811 u8 gtp_clk_buf[6] = {0};
1812 struct file *flp = NULL;
1813
1814 GTP_DEBUG("[gtp_main_clk_proc]Waiting for FS %d", gtp_ref_retries);
1815 if (gup_check_fs_mounted("/data") == FAIL)
1816 {
1817 GTP_DEBUG("[gtp_main_clk_proc]/data not mounted");
1818 if(gtp_clk_retries++ < GTP_CHK_FS_MNT_MAX)
1819 {
1820 return FAIL;
1821 }
1822 else
1823 {
1824 GTP_ERROR("[gtp_main_clk_proc]Wait for file system timeout,need cal clk");
1825 }
1826 }
1827 else
1828 {
1829 GTP_DEBUG("[gtp_main_clk_proc]/data mounted !!!!");
1830 flp = filp_open(GTP_MAIN_CLK_PATH, O_RDWR | O_CREAT, 0666);
1831 if (!IS_ERR(flp))
1832 {
1833 flp->f_op->llseek(flp, 0, SEEK_SET);
1834 ret = flp->f_op->read(flp, (char *)gtp_clk_buf, 6, &flp->f_pos);
1835 if(ret > 0)
1836 {
1837 ret = gtp_check_clk_legality(gtp_clk_buf);
1838 if(SUCCESS == ret)
1839 {
1840 GTP_DEBUG("[gtp_main_clk_proc]Open & read & check clk file success.");
1841 goto send_main_clk;
1842 }
1843 }
1844 }
1845 GTP_ERROR("[gtp_main_clk_proc]Check clk file failed,need cal clk");
1846 }
1847
1848 //cal clk
1849 #if GTP_ESD_PROTECT
1850 gtp_esd_switch(client, SWITCH_OFF);
1851 #endif
1852 clk_cal_result = gup_clk_calibration();
1853 force_reset_guitar(0);
1854 GTP_DEBUG("&&&&&&&&&&clk cal result:%d", clk_cal_result);
1855
1856 #if GTP_ESD_PROTECT
1857 gtp_esd_switch(client, SWITCH_ON);
1858 #endif
1859
1860 if(clk_cal_result < 50 || clk_cal_result > 120)
1861 {
1862 GTP_ERROR("Invalid main clock: %d", clk_cal_result);
1863 ret = FAIL;
1864 goto exit_clk_proc;
1865 }
1866
1867 for(i = 0;i < 5; i++)
1868 {
1869 gtp_clk_buf[i] = clk_cal_result;
1870 clk_chksum += gtp_clk_buf[i];
1871 }
1872 gtp_clk_buf[5] = 0 - clk_chksum;
1873
1874 send_main_clk:
1875
1876 ret = i2c_write_bytes(client, 0x8020, gtp_clk_buf, 6);
1877
1878 if (flp && !IS_ERR(flp))
1879 {
1880 flp->f_op->llseek(flp, 0, SEEK_SET);
1881 flp->f_op->write(flp, (char *)gtp_clk_buf, 6, &flp->f_pos);
1882 }
1883
1884 if(-1 == ret)
1885 {
1886 GTP_ERROR("[gtp_main_clk_proc]send main clk i2c error!");
1887 ret = FAIL;
1888 }
1889 else
1890 {
1891 ret = SUCCESS;
1892 }
1893
1894 exit_clk_proc:
1895 if (flp && !IS_ERR(flp))
1896 {
1897 filp_close(flp, NULL);
1898 }
1899 return ret;
1900 }
1901
1902 u8 gtp_verify_hopping_buf(struct i2c_client *client)
1903 {
1904 u16 checksum = 0;
1905 s32 i = 0;
1906
1907 for (i = 0; i < 6; i += 2)
1908 {
1909 checksum += (gtp_hopping_buf[i] << 8) + gtp_hopping_buf[i+1];
1910 }
1911 if ((checksum + ((u16)(gtp_hopping_buf[6] << 8) + (u16)gtp_hopping_buf[7])) & 0xFFFF)
1912 {
1913 GTP_ERROR("Wrong checksum for hopping buffer, get hopping data from config instead!");
1914 goto get_config_hopping;
1915 }
1916
1917 for (i = 0; i < 8; i++)
1918 {
1919 if (gtp_hopping_buf[i] != gtp_hopping_buf[i+8])
1920 {
1921 GTP_ERROR("Hopping buffer is not identical, get data from config instead!");
1922 goto get_config_hopping;
1923 }
1924 }
1925 GTP_DEBUG("Hopping buffer is okay");
1926 return SUCCESS;
1927
1928 get_config_hopping:
1929 memcpy(gtp_hopping_buf, &config[2 + 0x8065 - GTP_REG_CONFIG_DATA], 4);
1930 gtp_hopping_buf[4] = 0xAA;
1931 gtp_hopping_buf[5] = 0x55;
1932
1933 checksum = 0;
1934 for (i = 0; i < 6; i += 2)
1935 {
1936 checksum += (gtp_hopping_buf[i] << 8) + gtp_hopping_buf[i+1];
1937 }
1938 checksum = 0 - checksum;
1939 gtp_hopping_buf[6] = (u8)(checksum >> 8);
1940 gtp_hopping_buf[7] = (u8)(checksum & 0xFF);
1941
1942 for (i = 0; i < 8; i++)
1943 {
1944 gtp_hopping_buf[i+8] = gtp_hopping_buf[i];
1945 }
1946 return SUCCESS;
1947 }
1948
1949 u8 gtp_hopping_proc(struct i2c_client *client, s32 mode)
1950 {
1951 s32 ret = 0;
1952
1953 GTP_DEBUG("Store hopping data, wait for /data mounted.");
1954
1955 ret = gup_check_fs_mounted("/data");
1956
1957 if (FAIL == ret)
1958 {
1959 GTP_DEBUG("/data not mounted.");
1960 return FAIL;
1961 }
1962 GTP_DEBUG("/data Mounted!");
1963
1964 if (GTP_HOPPING_SEND == mode)
1965 {
1966 gtp_verify_hopping_buf(client);
1967
1968 ret = i2c_write_bytes(client, 0x8030, gtp_hopping_buf, 16);
1969 if (ret < 0)
1970 {
1971 return FAIL;
1972 }
1973 else
1974 {
1975 return SUCCESS;
1976 }
1977 }
1978 else
1979 {
1980 ret = i2c_read_bytes(client, 0x8030, gtp_hopping_buf, 16);
1981
1982 if (ret < 0)
1983 {
1984 GTP_ERROR("Failed to read hopping data from hopping buffer, get from config instead.");
1985 return FAIL;
1986 }
1987 return gtp_verify_hopping_buf(client);
1988 }
1989 }
1990
1991 #if GTP_FL_LITTLE_SYSTEM
1992 s32 gtp_resume_timeout(void *none)
1993 {
1994 s32 timeout = 0;
1995 GTP_DEBUG("Resume timeout thread kicks off.");
1996
1997 while (timeout++ < (10 * 10))
1998 {
1999 msleep(100);
2000 if (!little_fw_mode)
2001 {
2002 GTP_DEBUG("Resume timeout thread terminated while counting.");
2003 return 0;
2004 }
2005 }
2006
2007 if (little_fw_mode)
2008 {
2009 GTP_INFO("Download big ss51 firmware timeout, process esd reset.");
2010 little_fw_mode = 0;
2011 gtp_recovery_reset(i2c_client_point);
2012 }
2013
2014 return 0;
2015 }
2016
2017 u8 gtp_get_state1(struct i2c_client *client)
2018 {
2019 u8 state1 = 0;
2020 s32 ret = 0;
2021
2022 ret = i2c_read_bytes(client, GTP_REG_STATE1, &state1, 1);
2023
2024 if (ret < 0)
2025 {
2026 GTP_ERROR("Failed to get state1!");
2027 return 0xFF;
2028 }
2029 return state1;
2030 }
2031
2032 u8 gtp_get_state2(struct i2c_client *client)
2033 {
2034 u8 state2 = 0;
2035 s32 ret = 0;
2036
2037 ret = i2c_read_bytes(client, GTP_REG_STATE2, &state2, 1);
2038
2039 if (ret < 0)
2040 {
2041 GTP_ERROR("Failed to get state2!");
2042 return 0xFF;
2043 }
2044 return state2;
2045 }
2046
2047 // size: k in unit
2048 u8 gtp_send_check_info(struct i2c_client *client, u16 fw_chksum)
2049 {
2050 s32 ret = 0;
2051 u8 checksum = 0;
2052 u8 bank = 0;
2053 u8 state1 = 0x00;
2054 u8 state2 = 0x00;
2055 u16 start_addr = 0x0000;
2056 u8 checkinfo_buf[10] = {0};
2057
2058
2059 switch (fw_block)
2060 {
2061 case 1:
2062 case 2:
2063 case 3:
2064 case 4:
2065 case 5:
2066 case 6:
2067 case 7:
2068 case 8:
2069 bank = 0x01;
2070 state1 = BUFFER_FULL;
2071 state2 = IS_A_SEG;
2072 start_addr = (0xC000 + (fw_block - 1) * 1024 * 2);
2073 break;
2074
2075 case 9:
2076 bank = 0x00;
2077 state1 = BUFFER_FULL;
2078 state2 = IS_A_SEG;
2079 start_addr = 0xF800;
2080 break;
2081
2082 case 10:
2083 bank = 0x00;
2084 state1 = BUFFER_FULL;
2085 state2 = IS_A_SEG;
2086 start_addr = 0xF000;
2087 break;
2088
2089 case 11:
2090 bank = 0x00;
2091 state1 = BUFFER_FULL;
2092 state2 = IS_B_SEG_FIRST;
2093 start_addr = 0xE800;
2094 break;
2095
2096 case 12:
2097 bank = 0x00;
2098 state1 = WAIT_CHECK;
2099 state2 = IS_B_SEG_LAST;
2100 start_addr = 0xC000;
2101 break;
2102
2103 default:
2104 GTP_ERROR("Invalid firmware block(%d) for checkinfo.", fw_block);
2105 return FAIL;
2106 }
2107
2108 checkinfo_buf[3] = bank;
2109 checkinfo_buf[4] = (u8)(start_addr >> 8);
2110 checkinfo_buf[5] = (u8)(start_addr & 0xFF);
2111 checkinfo_buf[7] = state2;
2112 checkinfo_buf[8] = state1;
2113
2114 GTP_DEBUG("fw_block: %d, fw_chksum: 0x%04X", fw_block, fw_chksum);
2115 if (fw_block == 12)
2116 {
2117 checkinfo_buf[6] = 80;
2118 }
2119 else
2120 {
2121 checkinfo_buf[6] = 16;
2122 }
2123
2124 checkinfo_buf[0] = (u8)(fw_chksum >> 8);
2125 checkinfo_buf[1] = (u8)(fw_chksum & 0xFF);
2126
2127 checksum = 0;
2128 for (ret = 0; ret < 6; ret++)
2129 {
2130 checksum += checkinfo_buf[3 + ret];
2131 }
2132 checkinfo_buf[2] = 1 - checksum;
2133
2134 ret = i2c_write_bytes(client, GTP_REG_CHECKINFO, checkinfo_buf, 9);
2135 if (ret < 0)
2136 {
2137 GTP_ERROR("Failed to send checkinfo!");
2138 return FAIL;
2139 }
2140 else
2141 {
2142 GTP_DEBUG("Send checkinfo successfully!");
2143 }
2144 return SUCCESS;
2145 }
2146
2147
2148
2149 u8 gtp_resume_fw_startup(struct i2c_client *client)
2150 {
2151 u8 buf;
2152 u32 retry = 0;
2153 s32 ret = 0;
2154
2155 GTP_INFO("Big ss51 firmware startup.");
2156
2157 while (retry++ < 10)
2158 {
2159 buf = 0x0C;
2160 ret = i2c_write_bytes(client, 0x4180, &buf, 1); // hold ss51 & dsp
2161 if (ret < 0)
2162 {
2163 GTP_ERROR("Failed to hold ss51 & dsp.");
2164 return FAIL;
2165 }
2166
2167 buf = 0x00;
2168 ret = i2c_read_bytes(client, 0x4180, &buf, 1);
2169 if (ret < 0)
2170 {
2171 GTP_ERROR("Failed to get hold ss51 & dsp status.");
2172 return FAIL;
2173 }
2174
2175 if (buf == 0x0C)
2176 {
2177 GTP_DEBUG("SS51 & Dsp confirm hold!");
2178 break;
2179 }
2180 }
2181
2182 if (retry >= 10)
2183 {
2184 GTP_ERROR("Hold ss51 & dsp retry exhausted.");
2185 return FAIL;
2186 }
2187
2188 buf = 0x03;
2189 i2c_write_bytes(client, 0x4048, &buf, 1); // select bank3
2190
2191 buf = 0x00;
2192 i2c_write_bytes(client, 0x4049, &buf, 1);
2193
2194 return gtp_fw_startup(client);
2195 }
2196
2197 u8 gtp_download_seg_b(struct i2c_client *client)
2198 {
2199 s32 ret = 0;
2200 u16 fw_chksum = 0;
2201 u8 state1 = 0;
2202
2203 if (block_section != 10)
2204 {
2205 state1 = 0x00;
2206 i2c_write_bytes(client, 0x4048, &state1, 1); // select bank0
2207
2208 ret = gup_burn_ss51_seg_b(client, 10, &fw_chksum);
2209
2210 if (FAIL == ret)
2211 {
2212 GTP_ERROR("Failed to burn ss51 seg B, process reburn.");
2213 return FAIL;
2214 }
2215
2216 ret = gtp_send_check_info(i2c_client_point, fw_chksum);
2217 if (FAIL == ret)
2218 {
2219 GTP_ERROR("Send checkinfo failed, process resend.");
2220 return FAIL;
2221 }
2222 }
2223 msleep(1);
2224
2225 state1 = gtp_get_state1(client);
2226
2227 if (CHECK_COMPLETE == state1)
2228 {
2229 GTP_INFO("Burn ss51 Block12 successfully");
2230 }
2231 else if (CHECK_ERROR == state1)
2232 {
2233 GTP_DEBUG("Big SS51 Seg B check error, process reburn!");
2234 return FAIL;
2235 }
2236 else
2237 {
2238 GTP_ERROR("Big SS51 Seg B check imcomplete(state1:%s), process recheck.", symbolic_state1[state1&0x07]);
2239 block_section = 10;
2240 return FAIL;
2241 }
2242 ret = gtp_resume_fw_startup(client);
2243
2244 little_fw_mode = 0;
2245 if (FAIL == ret)
2246 {
2247 GTP_ERROR("Big ss51 firmware startup failed, process esd reset.");
2248 if (!tpd_halt)
2249 {
2250 gtp_recovery_reset(i2c_client_point);
2251 }
2252 }
2253 else
2254 {
2255 GTP_INFO("Switch to big ss51 firmware successfully!");
2256 }
2257 #if GTP_ESD_PROTECT
2258 if (!tpd_halt)
2259 {
2260 gtp_esd_switch(client, SWITCH_ON);
2261 }
2262 #endif
2263 return SUCCESS;
2264 }
2265
2266
2267 u8 gtp_download_big_ss51(struct i2c_client *client)
2268 {
2269 u8 state1, state2;
2270 s32 ret = 0;
2271 s32 i = 0;
2272 static u16 fw_chksum = 0x0000;
2273
2274 //GTP_DEBUG("Block: %d, Block Section: %d", fw_block, block_section);
2275 if (!little_fw_mode)
2276 {
2277 GTP_ERROR("Download big ss51 timeout!");
2278 return FAIL;
2279 }
2280
2281 if (block_section == 10) // one firmware block burned
2282 {
2283 if (fw_block == 11)
2284 {
2285 mdelay(3);
2286 }
2287
2288 state1 = gtp_get_state1(i2c_client_point);
2289 state2 = gtp_get_state2(i2c_client_point);
2290
2291 GTP_DEBUG("state1: %02X (%s), state2: %02X (%s)", state1, symbolic_state1[state1&0x07], state2, symbolic_state2[state2&0x07]);
2292
2293 if (CHECK_COMPLETE == state1)
2294 {
2295 block_section = 1;
2296 GTP_DEBUG("Burn ss51 Block%d successfully!", fw_block);
2297 if (fw_block == 11)
2298 {
2299 #if GTP_ESD_PROTECT
2300 gtp_esd_switch(client, SWITCH_OFF);
2301 #endif
2302 tpd_up(0, 0, 0); // release all
2303 input_sync(tpd->dev);
2304 GTP_DEBUG("Release touch manually.");
2305 fw_block = 12;
2306 for (i = 0; i < 5; i++)
2307 {
2308 if (!little_fw_mode || (fw_block != 12))
2309 {
2310 GTP_ERROR("Download big ss51 timeout!");
2311 return FAIL;
2312 }
2313 ret = gtp_download_seg_b(client);
2314
2315 if (SUCCESS == ret)
2316 {
2317 break;
2318 }
2319 }
2320 return SUCCESS;
2321 }
2322 }
2323 else if (CHECK_ERROR == state1)
2324 {
2325 GTP_ERROR("Block%d check error, process reburn.", fw_block);
2326 block_section = 1;
2327 fw_block--;
2328 }
2329 else
2330 {
2331 GTP_DEBUG("Block%d check incomplete, process recheck.", fw_block);
2332 block_section = 10;
2333 }
2334 }
2335 if (block_section < 9)
2336 {
2337 ret = gup_burn_ss51_block(i2c_client_point, block_section, fw_block+1, &fw_chksum);
2338 if (FAIL == ret)
2339 {
2340 GTP_ERROR("Burn block%d section%d failed, reburn block%d", fw_block+1, block_section, fw_block+1);
2341 }
2342 else
2343 {
2344 block_section++;
2345 }
2346 if (block_section == 9) // one firmware block downloaded
2347 {
2348 fw_block++;
2349 block_section = 10;
2350 ret = gtp_send_check_info(i2c_client_point, fw_chksum);
2351 }
2352 }
2353 return ret;
2354 }
2355 #endif
2356
2357 #endif
2358 //************* For GT9XXF End **********************//
2359
2360 #if GTP_WITH_PEN
2361 static void gtp_pen_init(void)
2362 {
2363 s32 ret = 0;
2364
2365 pen_dev = input_allocate_device();
2366 if (pen_dev == NULL)
2367 {
2368 GTP_ERROR("Failed to allocate input device for pen/stylus.");
2369 return;
2370 }
2371
2372 pen_dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) ;
2373 pen_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
2374
2375 set_bit(BTN_TOOL_PEN, pen_dev->keybit);
2376 set_bit(INPUT_PROP_DIRECT, pen_dev->propbit);
2377 //set_bit(INPUT_PROP_POINTER, pen_dev->propbit);
2378
2379 #if GTP_PEN_HAVE_BUTTON
2380 input_set_capability(pen_dev, EV_KEY, BTN_STYLUS);
2381 input_set_capability(pen_dev, EV_KEY, BTN_STYLUS2);
2382 #endif
2383
2384 input_set_abs_params(pen_dev, ABS_MT_POSITION_X, 0, TPD_RES_X, 0, 0);
2385 input_set_abs_params(pen_dev, ABS_MT_POSITION_Y, 0, TPD_RES_Y, 0, 0);
2386 input_set_abs_params(pen_dev, ABS_MT_PRESSURE, 0, 255, 0, 0);
2387 input_set_abs_params(pen_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
2388 input_set_abs_params(pen_dev, ABS_MT_TRACKING_ID, 0, 255, 0, 0);
2389
2390 pen_dev->name = "mtk-pen";
2391 pen_dev->phys = "input/ts";
2392 pen_dev->id.bustype = BUS_I2C;
2393
2394 ret = input_register_device(pen_dev);
2395 if (ret)
2396 {
2397 GTP_ERROR("Register %s input device failed", pen_dev->name);
2398 return;
2399 }
2400 }
2401
2402 static void gtp_pen_down(s32 x, s32 y, s32 size, s32 id)
2403 {
2404 input_report_key(pen_dev, BTN_TOOL_PEN, 1);
2405 input_report_key(pen_dev, BTN_TOUCH, 1);
2406 input_report_abs(pen_dev, ABS_MT_POSITION_X, x);
2407 input_report_abs(pen_dev, ABS_MT_POSITION_Y, y);
2408 if ((!size) && (!id))
2409 {
2410 input_report_abs(pen_dev, ABS_MT_PRESSURE, 100);
2411 input_report_abs(pen_dev, ABS_MT_TOUCH_MAJOR, 100);
2412 }
2413 else
2414 {
2415 input_report_abs(pen_dev, ABS_MT_PRESSURE, size);
2416 input_report_abs(pen_dev, ABS_MT_TOUCH_MAJOR, size);
2417 input_report_abs(pen_dev, ABS_MT_TRACKING_ID, id);
2418 }
2419 input_mt_sync(pen_dev);
2420 }
2421
2422 static void gtp_pen_up(void)
2423 {
2424 input_report_key(pen_dev, BTN_TOOL_PEN, 0);
2425 input_report_key(pen_dev, BTN_TOUCH, 0);
2426 }
2427 #endif
2428
2429
2430 static s32 tpd_i2c_probe_next(struct i2c_client *client)
2431 {
2432 s32 err = 0;
2433 s32 ret = 0;
2434
2435 u16 version_info;
2436
2437
2438 ret = tpd_power_on(client);
2439
2440 if (ret < 0)
2441 {
2442 GTP_ERROR("I2C communication ERROR!");
2443 }
2444
2445 ret = gtp_read_version(client, &version_info);
2446
2447 if (ret < 0)
2448 {
2449 GTP_ERROR("Read version failed.");
2450 }
2451
2452 ret = gtp_init_panel(client);
2453
2454 if (ret < 0)
2455 {
2456 GTP_ERROR("GTP init panel failed.");
2457 }
2458
2459 #if GTP_CREATE_WR_NODE
2460 init_wr_node(client);
2461 #endif
2462 thread = kthread_run(touch_event_handler, 0, TPD_DEVICE);
2463
2464
2465 if (IS_ERR(thread))
2466 {
2467 err = PTR_ERR(thread);
2468 GTP_ERROR(TPD_DEVICE " failed to create kernel thread: %d\n", err);
2469 }
2470
2471 mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
2472
2473 #if GTP_AUTO_UPDATE
2474 ret = gup_init_update_proc(client);
2475
2476 if (ret < 0)
2477 {
2478 GTP_ERROR("Create update thread error.");
2479 }
2480 #endif
2481
2482 #if GTP_ESD_PROTECT
2483 gtp_esd_switch(client, SWITCH_ON);
2484 #endif
2485
2486
2487 return 0;
2488 }
2489
2490 static ssize_t cfg_load_enable_store(struct device *dev,
2491 struct device_attribute *attr,
2492 const char *buf, size_t count)
2493 {
2494 tpd_i2c_probe_next(i2c_client_point);
2495 return count;
2496 }
2497 static ssize_t cfg_load_enable_show(struct device *dev,
2498 struct device_attribute *attr,
2499 const char *buf, size_t count)
2500 {
2501 return count;
2502 }
2503 static DEVICE_ATTR(cfg_load_enable, S_IRUGO|S_IWUSR, cfg_load_enable_show, cfg_load_enable_store);
2504
2505 static struct miscdevice cfg_misc_device =
2506 {
2507 .minor = MISC_DYNAMIC_MINOR,
2508 .name = "tp_cfg",
2509 // .fops = &tpd_fops,
2510 };
2511
2512 #if 0
2513 static void buttons_timer_function(unsigned long data)
2514 {
2515 printk(KERN_ERR"caoyang1\n");
2516 input_report_key(tpd->dev, KEY_POWER, 1);
2517 input_sync(tpd->dev);
2518 input_report_key(tpd->dev, KEY_POWER, 0);
2519 input_sync(tpd->dev);
2520 tpd_sleep_flag = 1;
2521
2522 }
2523 #endif
2524
2525 static s32 tpd_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id)
2526 {
2527 s32 err = 0;
2528 s32 ret = 0;
2529
2530 u16 version_info;
2531 #if GTP_HAVE_TOUCH_KEY
2532 s32 idx = 0;
2533 #endif
2534 #ifdef TPD_PROXIMITY
2535 struct hwmsen_object obj_ps;
2536 #endif
2537
2538 i2c_client_point = client;
2539 //add by caoyang for ·À¶¶
2540 //do not use the timer because it cause bug
2541 #if 0
2542 init_timer(&buttons_timer);
2543 buttons_timer.function = buttons_timer_function;
2544 add_timer(&buttons_timer);
2545 #endif
2546 #if 0
2547 ret = tpd_power_on(client);
2548
2549 if (ret < 0)
2550 {
2551 GTP_ERROR("I2C communication ERROR!");
2552 }
2553 #endif
2554 #ifdef VELOCITY_CUSTOM
2555
2556 if ((err = misc_register(&tpd_misc_device)))
2557 {
2558 printk("mtk_tpd: tpd_misc_device register failed\n");
2559 }
2560
2561 #endif
2562 #if 0
2563 ret = gtp_read_version(client, &version_info);
2564
2565 if (ret < 0)
2566 {
2567 GTP_ERROR("Read version failed.");
2568 }
2569
2570 ret = gtp_init_panel(client);
2571
2572 if (ret < 0)
2573 {
2574 GTP_ERROR("GTP init panel failed.");
2575 }
2576 #endif
2577 // Create proc file system
2578 gt91xx_config_proc = proc_create(GT91XX_CONFIG_PROC_FILE, 0666, NULL, &config_proc_ops);
2579 if (gt91xx_config_proc == NULL)
2580 {
2581 GTP_ERROR("create_proc_entry %s failed\n", GT91XX_CONFIG_PROC_FILE);
2582 }
2583 else
2584 {
2585 GTP_INFO("create proc entry %s success", GT91XX_CONFIG_PROC_FILE);
2586 }
2587 #if 0
2588 #if GTP_CREATE_WR_NODE
2589 init_wr_node(client);
2590 #endif
2591
2592 thread = kthread_run(touch_event_handler, 0, TPD_DEVICE);
2593
2594
2595 if (IS_ERR(thread))
2596 {
2597 err = PTR_ERR(thread);
2598 GTP_ERROR(TPD_DEVICE " failed to create kernel thread: %d\n", err);
2599 }
2600 #endif
2601
2602
2603 #if GTP_HAVE_TOUCH_KEY
2604
2605 for (idx = 0; idx < GTP_MAX_KEY_NUM; idx++)
2606 {
2607 input_set_capability(tpd->dev, EV_KEY, touch_key_array[idx]);
2608 }
2609
2610 #endif
2611 input_set_capability(tpd->dev, EV_KEY, KEY_POWER);
2612
2613 #if GTP_WITH_PEN
2614 gtp_pen_init();
2615 #endif
2616 // set INT mode
2617 mt_set_gpio_mode(GPIO_CTP_EINT_PIN, GPIO_CTP_EINT_PIN_M_EINT);
2618 mt_set_gpio_dir(GPIO_CTP_EINT_PIN, GPIO_DIR_IN);
2619 mt_set_gpio_pull_enable(GPIO_CTP_EINT_PIN, GPIO_PULL_DISABLE);
2620
2621 msleep(50);
2622
2623 #if 1
2624 if (!int_type) //EINTF_TRIGGER
2625 {
2626 mt_eint_registration(CUST_EINT_TOUCH_PANEL_NUM, EINTF_TRIGGER_RISING, tpd_eint_interrupt_handler, 1);
2627 }
2628 else
2629 {
2630 mt_eint_registration(CUST_EINT_TOUCH_PANEL_NUM, EINTF_TRIGGER_FALLING, tpd_eint_interrupt_handler, 1);
2631 }
2632
2633 #endif
2634
2635 #if 0
2636 mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
2637
2638 #if GTP_AUTO_UPDATE
2639 ret = gup_init_update_proc(client);
2640
2641 if (ret < 0)
2642 {
2643 GTP_ERROR("Create update thread error.");
2644 }
2645 #endif
2646 #endif
2647 #ifdef TPD_PROXIMITY
2648 //obj_ps.self = cm3623_obj;
2649 obj_ps.polling = 0; //0--interrupt mode;1--polling mode;
2650 obj_ps.sensor_operate = tpd_ps_operate;
2651
2652 if ((err = hwmsen_attach(ID_PROXIMITY, &obj_ps)))
2653 {
2654 GTP_ERROR("hwmsen attach fail, return:%d.", err);
2655 }
2656
2657 #endif
2658 #if 0
2659 #if GTP_ESD_PROTECT
2660 gtp_esd_switch(client, SWITCH_ON);
2661 #endif
2662
2663 tpd_load_status = 1;
2664 #endif
2665 misc_register(&cfg_misc_device);
2666 device_create_file(cfg_misc_device.this_device, &dev_attr_cfg_load_enable);
2667 tpd_load_status = 1;
2668 return 0;
2669 }
2670
2671
2672 static void tpd_eint_interrupt_handler(void)
2673 {
2674 TPD_DEBUG_PRINT_INT;
2675
2676 tpd_flag = 1;
2677
2678 wake_up_interruptible(&waiter);
2679 }
2680 static int tpd_i2c_remove(struct i2c_client *client)
2681 {
2682 #if GTP_CREATE_WR_NODE
2683 uninit_wr_node();
2684 #endif
2685
2686 #if GTP_ESD_PROTECT
2687 destroy_workqueue(gtp_esd_check_workqueue);
2688 #endif
2689
2690 return 0;
2691 }
2692 #if (GTP_ESD_PROTECT || GTP_COMPATIBLE_MODE)
2693 static s32 force_reset_guitar(s32 resume)
2694 {
2695 s32 i = 0;
2696 s32 ret = 0;
2697
2698 if (!resume)
2699 {
2700 GTP_INFO("Force_reset_guitar");
2701 }
2702 else
2703 {
2704 GTP_INFO("Download little system.");
2705 }
2706
2707 mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
2708
2709 GTP_GPIO_OUTPUT(GTP_RST_PORT, 0);
2710 GTP_GPIO_OUTPUT(GTP_INT_PORT, 0);
2711 #ifdef MT6573
2712 //Power off TP
2713 mt_set_gpio_mode(GPIO_CTP_EN_PIN, GPIO_CTP_EN_PIN_M_GPIO);
2714 mt_set_gpio_dir(GPIO_CTP_EN_PIN, GPIO_DIR_OUT);
2715 mt_set_gpio_out(GPIO_CTP_EN_PIN, GPIO_OUT_ZERO);
2716 msleep(30);
2717 //Power on TP
2718 mt_set_gpio_out(GPIO_CTP_EN_PIN, GPIO_OUT_ONE);
2719 msleep(30);
2720 #else // ( defined(MT6575) || defined(MT6577) || defined(MT6589) )
2721 // Power off TP
2722 #ifdef TPD_POWER_SOURCE_CUSTOM
2723 hwPowerDown(TPD_POWER_SOURCE_CUSTOM, "TP");
2724 #else
2725 hwPowerDown(MT65XX_POWER_LDO_VGP2, "TP");
2726 #endif
2727 msleep(30);
2728
2729 // Power on TP
2730 #ifdef TPD_POWER_SOURCE_CUSTOM
2731 hwPowerOn(TPD_POWER_SOURCE_CUSTOM, VOL_2800, "TP");
2732 #else
2733 hwPowerOn(MT65XX_POWER_LDO_VGP2, VOL_2800, "TP");
2734 #endif
2735 msleep(30);
2736
2737 #endif
2738
2739 for (i = 0; i < 5; i++)
2740 {
2741 #if GTP_COMPATIBLE_MODE
2742 if (CHIP_TYPE_GT9F == gtp_chip_type)
2743 {
2744 #if GTP_FL_LITTLE_SYSTEM
2745 //check code ram
2746 if (resume) // poweroff resume
2747 {
2748 ret = gup_fw_download_proc(NULL, GTP_FL_PWR_RESUME_BURN);
2749 if (FAIL == ret)
2750 {
2751 GTP_ERROR("Failed to download little system.");
2752 continue;
2753 }
2754 }
2755 else
2756 #endif
2757 {
2758 ret = gup_fw_download_proc(NULL, GTP_FL_ESD_RECOVERY);
2759 }
2760 if(FAIL == ret)
2761 {
2762 GTP_ERROR("[force_reset_guitar]Check & repair fw failed.");
2763 continue;
2764 }
2765 //startup fw
2766 ret = gtp_fw_startup(i2c_client_point);
2767 if(FAIL == ret)
2768 {
2769 if (resume)
2770 {
2771 GTP_ERROR("Failed to startup little system.");
2772 }
2773 else
2774 {
2775 GTP_ERROR("GT9XXF start up failed.");
2776 }
2777 continue;
2778 }
2779 break;
2780 }
2781 else
2782 #endif
2783 {
2784 //Reset Guitar
2785 gtp_reset_guitar(i2c_client_point, 20);
2786 msleep(50);
2787 //Send config
2788 ret = gtp_send_cfg(i2c_client_point);
2789
2790 if (ret < 0)
2791 {
2792 continue;
2793 }
2794 }
2795 break;
2796 }
2797
2798 if (i >= 5)
2799 {
2800 if (resume)
2801 {
2802 GTP_ERROR("Failed to download little system.");
2803 }
2804 else
2805 {
2806 GTP_ERROR("Failed to reset guitar.");
2807 }
2808 mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
2809 return FAIL;
2810 }
2811 #if (GTP_COMPATIBLE_MODE && GTP_FL_LITTLE_SYSTEM)
2812 if (CHIP_TYPE_GT9F == gtp_chip_type)
2813 {
2814 if (resume)
2815 {
2816 little_fw_mode = 1;
2817 fw_block = 0;
2818 block_section = 1;
2819
2820 msleep(1);
2821 gtp_main_clk_proc(i2c_client_point);
2822 gtp_hopping_proc(i2c_client_point, GTP_HOPPING_SEND);
2823 gtp_bak_ref_proc(i2c_client_point, GTP_BAK_REF_SEND);
2824 }
2825 else
2826 {
2827 little_fw_mode = 0;
2828 fw_block = 0;
2829 block_section = 0;
2830 }
2831 }
2832 #endif
2833
2834 mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
2835 return SUCCESS;
2836 }
2837 #endif
2838
2839 #if GTP_ESD_PROTECT
2840 static s32 gtp_init_ext_watchdog(struct i2c_client *client)
2841 {
2842 u8 opr_buffer[2] = {0xAA};
2843 GTP_DEBUG("Init external watchdog.");
2844 return i2c_write_bytes(client, 0x8041, opr_buffer, 1);
2845 }
2846
2847 void gtp_esd_switch(struct i2c_client *client, s32 on)
2848 {
2849 spin_lock(&esd_lock);
2850 if (SWITCH_ON == on) // switch on esd
2851 {
2852 if (!esd_running)
2853 {
2854 esd_running = 1;
2855 spin_unlock(&esd_lock);
2856 GTP_INFO("Esd started");
2857 queue_delayed_work(gtp_esd_check_workqueue, &gtp_esd_check_work, clk_tick_cnt);
2858 }
2859 else
2860 {
2861 spin_unlock(&esd_lock);
2862 }
2863 }
2864 else // switch off esd
2865 {
2866 if (esd_running)
2867 {
2868 esd_running = 0;
2869 spin_unlock(&esd_lock);
2870 GTP_INFO("Esd cancelled");
2871 cancel_delayed_work_sync(&gtp_esd_check_work);
2872 }
2873 else
2874 {
2875 spin_unlock(&esd_lock);
2876 }
2877 }
2878 }
2879
2880 static s32 gtp_check_fw(void)
2881 {
2882 u8 versionBuff[4] = {0};
2883 s32 ret,retry = 0;
2884
2885 while(retry++ < 3)
2886 {
2887 ret = i2c_read_bytes_non_dma(i2c_client_point, 0x8140, versionBuff, sizeof(versionBuff));
2888 if(ret < 0)
2889 {
2890 continue;
2891 }
2892 if( memcmp(versionBuff, &gtp_default_FW_fl[4], 4) !=0 )
2893 {
2894 continue;
2895 }
2896
2897 return 1;
2898 }
2899
2900 GTP_ERROR("Check running fw version error!");
2901 return 0;
2902 }
2903
2904 static void gtp_esd_check_func(struct work_struct *work)
2905 {
2906 s32 i = 0;
2907 s32 ret = -1;
2908 u8 esd_buf[3] = {0x00};
2909
2910 if (tpd_halt)
2911 {
2912 GTP_INFO("Esd suspended!");
2913 return;
2914 }
2915 for (i = 0; i < 3; i++)
2916 {
2917 ret = i2c_read_bytes_non_dma(i2c_client_point, 0x8040, esd_buf, 2);
2918
2919 GTP_DEBUG("[Esd]0x8040 = 0x%02X, 0x8041 = 0x%02X", esd_buf[0], esd_buf[1]);
2920 if (ret < 0)
2921 {
2922 // IIC communication problem
2923 continue;
2924 }
2925 else
2926 {
2927 if ((esd_buf[0] == 0xAA) || (esd_buf[1] != 0xAA))
2928 {
2929 u8 chk_buf[2] = {0x00};
2930 i2c_read_bytes_non_dma(i2c_client_point, 0x8040, chk_buf, 2);
2931
2932 GTP_DEBUG("[Check]0x8040 = 0x%02X, 0x8041 = 0x%02X", chk_buf[0], chk_buf[1]);
2933
2934 if ( (chk_buf[0] == 0xAA) || (chk_buf[1] != 0xAA) )
2935 {
2936 i = 3; // jump to reset guitar
2937 break;
2938 }
2939 else
2940 {
2941 continue;
2942 }
2943 }
2944 else
2945 {
2946 // IC works normally, Write 0x8040 0xAA, feed the watchdog
2947 esd_buf[0] = 0xAA;
2948 i2c_write_bytes_non_dma(i2c_client_point, 0x8040, esd_buf, 1);
2949
2950 break;
2951 }
2952 }
2953 }
2954
2955 if (i >= 3 || !gtp_check_fw())
2956 {
2957 #if GTP_COMPATIBLE_MODE
2958 if ((CHIP_TYPE_GT9F == gtp_chip_type) && (1 == rqst_processing))
2959 {
2960 GTP_INFO("Request Processing, no reset guitar.");
2961 }
2962 else
2963 #endif
2964 {
2965 GTP_INFO("IC works abnormally! Process reset guitar.");
2966 esd_buf[0] = 0x01;
2967 esd_buf[1] = 0x01;
2968 esd_buf[2] = 0x01;
2969 i2c_write_bytes(i2c_client_point, 0x4226, esd_buf, 3);
2970 msleep(50);
2971 force_reset_guitar(0);
2972 }
2973 }
2974
2975 if (!tpd_halt)
2976 {
2977 queue_delayed_work(gtp_esd_check_workqueue, &gtp_esd_check_work, clk_tick_cnt);
2978 }
2979 else
2980 {
2981 GTP_INFO("Esd suspended!");
2982 }
2983
2984 return;
2985 }
2986 #endif
2987
2988 static void tpd_down(s32 x, s32 y, s32 size, s32 id)
2989 {
2990 if ((!size) && (!id))
2991 {
2992 input_report_abs(tpd->dev, ABS_MT_PRESSURE, 100);
2993 input_report_abs(tpd->dev, ABS_MT_TOUCH_MAJOR, 100);
2994 }
2995 else
2996 {
2997 input_report_abs(tpd->dev, ABS_MT_PRESSURE, size);
2998 input_report_abs(tpd->dev, ABS_MT_TOUCH_MAJOR, size);
2999 /* track id Start 0 */
3000 input_report_abs(tpd->dev, ABS_MT_TRACKING_ID, id);
3001 }
3002
3003 input_report_key(tpd->dev, BTN_TOUCH, 1);
3004 input_report_abs(tpd->dev, ABS_MT_POSITION_X, x);
3005 input_report_abs(tpd->dev, ABS_MT_POSITION_Y, y);
3006 input_mt_sync(tpd->dev);
3007 TPD_EM_PRINT(x, y, x, y, id, 1);
3008
3009 #if (defined(MT6575)||defined(MT6577))
3010
3011 if (FACTORY_BOOT == get_boot_mode() || RECOVERY_BOOT == get_boot_mode())
3012 {
3013 tpd_button(x, y, 1);
3014 }
3015
3016 #endif
3017 }
3018
3019 static void tpd_up(s32 x, s32 y, s32 id)
3020 {
3021 input_report_key(tpd->dev, BTN_TOUCH, 0);
3022 input_mt_sync(tpd->dev);
3023 TPD_EM_PRINT(x, y, x, y, id, 0);
3024
3025 #if (defined(MT6575) || defined(MT6577))
3026
3027 if (FACTORY_BOOT == get_boot_mode() || RECOVERY_BOOT == get_boot_mode())
3028 {
3029 tpd_button(x, y, 0);
3030 }
3031
3032 #endif
3033 }
3034 #if GTP_CHARGER_SWITCH
3035 static void gtp_charger_switch(s32 dir_update)
3036 {
3037 u32 chr_status = 0;
3038 u8 chr_cmd[3] = {0x80, 0x40};
3039 static u8 chr_pluggedin = 0;
3040 int ret = 0;
3041
3042 #ifdef MT6573
3043 chr_status = *(volatile u32 *)CHR_CON0;
3044 chr_status &= (1 << 13);
3045 #else // ( defined(MT6575) || defined(MT6577) || defined(MT6589) )
3046 chr_status = upmu_is_chr_det();
3047 #endif
3048
3049 if (chr_status) // charger plugged in
3050 {
3051 if (!chr_pluggedin || dir_update)
3052 {
3053 chr_cmd[2] = 6;
3054 ret = gtp_i2c_write(i2c_client_point, chr_cmd, 3);
3055 if (ret > 0)
3056 {
3057 GTP_INFO("Update status for Charger Plugin");
3058 }
3059 chr_pluggedin = 1;
3060 }
3061 }
3062 else // charger plugged out
3063 {
3064 if (chr_pluggedin || dir_update)
3065 {
3066 chr_cmd[2] = 7;
3067 ret = gtp_i2c_write(i2c_client_point, chr_cmd, 3);
3068 if (ret > 0)
3069 {
3070 GTP_INFO("Update status for Charger Plugout");
3071 }
3072 chr_pluggedin = 0;
3073 }
3074 }
3075 }
3076 #endif
3077
3078 static int touch_event_handler(void *unused)
3079 {
3080 struct sched_param param = { .sched_priority = RTPM_PRIO_TPD };
3081 u8 end_cmd[3] = {GTP_READ_COOR_ADDR >> 8, GTP_READ_COOR_ADDR & 0xFF, 0};
3082 u8 point_data[2 + 1 + 8 * GTP_MAX_TOUCH + 1] = {GTP_READ_COOR_ADDR >> 8, GTP_READ_COOR_ADDR & 0xFF};
3083 u8 touch_num = 0;
3084 u8 finger = 0;
3085 static u8 pre_touch = 0;
3086 static u8 pre_key = 0;
3087 #if GTP_WITH_PEN
3088 u8 pen_active = 0;
3089 static u8 pre_pen = 0;
3090 #endif
3091 u8 key_value = 0;
3092 u8 *coor_data = NULL;
3093 s32 input_x = 0;
3094 s32 input_y = 0;
3095 s32 input_w = 0;
3096 s32 id = 0;
3097 s32 i = 0;
3098 s32 ret = -1;
3099
3100 #if GTP_COMPATIBLE_MODE
3101 u8 rqst_data[3] = {(u8)(GTP_REG_RQST >> 8), (u8)(GTP_REG_RQST & 0xFF), 0};
3102 #endif
3103
3104 #ifdef TPD_PROXIMITY
3105 s32 err = 0;
3106 hwm_sensor_data sensor_data;
3107 u8 proximity_status;
3108 #endif
3109 u8 proximity_status; //add by caoyang
3110 u8 doze_buf[3] = {0x81, 0x4B};
3111
3112 sched_setscheduler(current, SCHED_RR, &param);
3113 do
3114 {
3115 set_current_state(TASK_INTERRUPTIBLE);
3116
3117 while (tpd_halt)
3118 {
3119 //#if GTP_GESTURE_WAKEUP
3120 if(gesture_value > 0){
3121 if (DOZE_ENABLED == doze_status)
3122 {
3123 break;
3124 }
3125 //#endif
3126 }
3127 tpd_flag = 0;
3128 msleep(20);
3129 }
3130
3131 wait_event_interruptible(waiter, tpd_flag != 0);
3132 tpd_flag = 0;
3133 TPD_DEBUG_SET_TIME;
3134 set_current_state(TASK_RUNNING);
3135
3136 #if GTP_CHARGER_SWITCH
3137 gtp_charger_switch(0);
3138 #endif
3139
3140 if(gesture_value > 0){
3141 //#if GTP_GESTURE_WAKEUP
3142 if (DOZE_ENABLED == doze_status)
3143 {
3144 ret = gtp_i2c_read(i2c_client_point, doze_buf, 3);
3145 GTP_DEBUG("0x814B = 0x%02X", doze_buf[2]);
3146 if (ret > 0)
3147 {
3148 if ((doze_buf[2] == 'a') || (doze_buf[2] == 'b') || (doze_buf[2] == 'c') ||
3149 (doze_buf[2] == 'd') || (doze_buf[2] == 'e') || (doze_buf[2] == 'g') ||
3150 (doze_buf[2] == 'h') || (doze_buf[2] == 'm') || (doze_buf[2] == 'o') ||
3151 (doze_buf[2] == 'q') || (doze_buf[2] == 's') || (doze_buf[2] == 'v') ||
3152 (doze_buf[2] == 'w') || (doze_buf[2] == 'y') || (doze_buf[2] == 'z') ||
3153 (doze_buf[2] == 0x5E) /* ^ */
3154 )
3155 {
3156 if (doze_buf[2] != 0x5E)
3157 {
3158 GTP_INFO("Wakeup by gesture(%c), light up the screen!", doze_buf[2]);
3159 }
3160 else
3161 {
3162 GTP_INFO("Wakeup by gesture(^), light up the screen!");
3163 }
3164
3165 doze_status = DOZE_WAKEUP;
3166 input_report_key(tpd->dev, KEY_POWER, 1);
3167 input_sync(tpd->dev);
3168 input_report_key(tpd->dev, KEY_POWER, 0);
3169 input_sync(tpd->dev);
3170 // clear 0x814B
3171 doze_buf[2] = 0x00;
3172 gtp_i2c_write(i2c_client_point, doze_buf, 3);
3173 }
3174 else if ( (doze_buf[2] == 0xAA) || (doze_buf[2] == 0xBB) ||
3175 (doze_buf[2] == 0xAB) || (doze_buf[2] == 0xBA) )
3176 {
3177 char *direction[4] = {"Right", "Down", "Up", "Left"};
3178 u8 type = ((doze_buf[2] & 0x0F) - 0x0A) + (((doze_buf[2] >> 4) & 0x0F) - 0x0A) * 2;
3179
3180 GTP_INFO("%s slide to light up the screen!", direction[type]);
3181 doze_status = DOZE_WAKEUP;
3182 input_report_key(tpd->dev, KEY_POWER, 1);
3183 input_sync(tpd->dev);
3184 input_report_key(tpd->dev, KEY_POWER, 0);
3185 input_sync(tpd->dev);
3186 // clear 0x814B
3187 doze_buf[2] = 0x00;
3188 gtp_i2c_write(i2c_client_point, doze_buf, 3);
3189 }
3190 else if (0xCC == doze_buf[2])
3191 {
3192 GTP_INFO("Double click to light up the screen!");
3193 doze_status = DOZE_WAKEUP;
3194 input_report_key(tpd->dev, KEY_POWER, 1);
3195 input_sync(tpd->dev);
3196 input_report_key(tpd->dev, KEY_POWER, 0);
3197 input_sync(tpd->dev);
3198 // clear 0x814B
3199 doze_buf[2] = 0x00;
3200 gtp_i2c_write(i2c_client_point, doze_buf, 3);
3201 }
3202 else
3203 {
3204 // clear 0x814B
3205 doze_buf[2] = 0x00;
3206 gtp_i2c_write(i2c_client_point, doze_buf, 3);
3207 gtp_enter_doze(i2c_client_point);
3208 }
3209 }
3210 continue;
3211 }
3212 //#endif
3213 }
3214 ret = gtp_i2c_read(i2c_client_point, point_data, 12);
3215 if (ret < 0)
3216 {
3217 GTP_ERROR("I2C transfer error. errno:%d\n ", ret);
3218 continue;
3219 }
3220 finger = point_data[GTP_ADDR_LENGTH];
3221
3222 #if GTP_COMPATIBLE_MODE
3223 if ((finger == 0x00) && (CHIP_TYPE_GT9F == gtp_chip_type))
3224 {
3225 ret = gtp_i2c_read(i2c_client_point, rqst_data, 3);
3226
3227 if(ret < 0)
3228 {
3229 GTP_ERROR("I2C transfer error. errno:%d\n ", ret);
3230 continue;
3231 }
3232 switch (rqst_data[2])
3233 {
3234 case GTP_RQST_BAK_REF:
3235 GTP_INFO("Request Ref.");
3236 rqst_processing = 1;
3237 ret = gtp_bak_ref_proc(i2c_client_point, GTP_BAK_REF_SEND);
3238 if(SUCCESS == ret)
3239 {
3240 GTP_INFO("Send ref success.");
3241 rqst_data[2] = GTP_RQST_RESPONDED;
3242 gtp_i2c_write(i2c_client_point, rqst_data, 3);
3243 rqst_processing = 0;
3244 }
3245 goto exit_work_func;
3246
3247 case GTP_RQST_CONFIG:
3248 GTP_INFO("Request Config.");
3249 ret = gtp_send_cfg(i2c_client_point);
3250 if (ret < 0)
3251 {
3252 GTP_ERROR("Send config error.");
3253 }
3254 else
3255 {
3256 GTP_INFO("Send config success.");
3257 rqst_data[2] = GTP_RQST_RESPONDED;
3258 gtp_i2c_write(i2c_client_point, rqst_data, 3);
3259 }
3260 goto exit_work_func;
3261
3262 case GTP_RQST_MAIN_CLOCK:
3263 GTP_INFO("Request main clock.");
3264 rqst_processing = 1;
3265 ret = gtp_main_clk_proc(i2c_client_point);
3266 if(SUCCESS == ret)
3267 {
3268 GTP_INFO("Send main clk success.");
3269 #if GTP_POWER_CTRL_SLEEP
3270 {
3271 ret = gtp_hopping_proc(i2c_client_point, GTP_HOPPING_SEND);
3272 if (FAIL == ret)
3273 {
3274 GTP_ERROR("Failed to send hopping data.");
3275 goto exit_work_func;
3276 }
3277 else
3278 {
3279 GTP_INFO("Send hopping data success.");
3280 }
3281 }
3282 #endif
3283 rqst_data[2] = GTP_RQST_RESPONDED;
3284 gtp_i2c_write(i2c_client_point, rqst_data, 3);
3285 rqst_processing = 0;
3286 }
3287 goto exit_work_func;
3288
3289 case GTP_RQST_RESET:
3290 //#if GTP_GESTURE_WAKEUP
3291 if(gesture_value > 0){
3292 if (DOZE_ENABLED == doze_status) {
3293 u8 reg_data[3] = {(u8)(0x801F >> 8), (u8)(0x801F & 0xFF), 0};
3294 gtp_i2c_write(i2c_client_point, reg_data, 3);
3295 gtp_recovery_reset(i2c_client_point);
3296 gtp_enter_doze(i2c_client_point);
3297 }
3298 }else
3299 //#endif
3300 {
3301 gtp_recovery_reset(i2c_client_point);
3302 }
3303 GTP_INFO("Request Reset.");
3304 goto exit_work_func;
3305
3306 #if GTP_POWER_CTRL_SLEEP
3307 case GTP_RQST_STORE_HOPPING:
3308 GTP_INFO("Request store hopping data.");
3309 ret = gtp_hopping_proc(i2c_client_point, GTP_HOPPING_STORE);
3310 if (FAIL == ret)
3311 {
3312 GTP_ERROR("Failed to store hopping data.");
3313 }
3314 else
3315 {
3316 GTP_INFO("Hopping data stored.");
3317 rqst_data[2] = GTP_RQST_RESPONDED;
3318 gtp_i2c_write(i2c_client_point, rqst_data, 3);
3319 }
3320 goto exit_work_func;
3321
3322 case GTP_RQST_STORE_BAK_REF:
3323 GTP_INFO("Request store backup reference.");
3324 ret = gtp_bak_ref_proc(i2c_client_point, GTP_BAK_REF_STORE);
3325 if (FAIL == ret)
3326 {
3327 GTP_ERROR("Failed to store backup reference data.");
3328 }
3329 else
3330 {
3331 GTP_INFO("Backup reference data stored.");
3332 rqst_data[2] = GTP_RQST_RESPONDED;
3333 gtp_i2c_write(i2c_client_point, rqst_data, 3);
3334 }
3335 goto exit_work_func;
3336 #endif
3337
3338 default:
3339 GTP_INFO("Undefined request code: 0x%02X", rqst_data[2]);
3340 rqst_data[2] = GTP_RQST_RESPONDED;
3341 gtp_i2c_write(i2c_client_point, rqst_data, 3);
3342 break;
3343 }
3344 }
3345 #endif
3346
3347 if (finger == 0x00)
3348 {
3349 continue;
3350 }
3351
3352 if ((finger & 0x80) == 0)
3353 {
3354 goto exit_work_func;
3355 }
3356 if((gtp_autotool_setting == 1) && !(point_data[GTP_ADDR_LENGTH] & 0x40)){
3357 gtp_autotool_setting = 0;
3358 }
3359 //add by caoyang
3360 if(gesture_value > 0){
3361 proximity_status = point_data[GTP_ADDR_LENGTH];
3362 GTP_DEBUG("REG INDEX[0x814E]:0x%02X\n", proximity_status);
3363 if(tpd_sleep_flag == 1){
3364 goto exit_work_func;
3365 }
3366 if (proximity_status & 0x40) //proximity or large touch detect,enable hwm_sensor.
3367 {
3368 printk(KERN_ERR"caoyang0 test for xipin\n");
3369 //mod_timer(&buttons_timer, jiffies+HZ/50);
3370 if(gtp_autotool_setting == 1){
3371 gtp_autotool_setting = 0;
3372 goto exit_work_func;
3373 }
3374 #if 1
3375 input_report_key(tpd->dev, KEY_POWER, 1);
3376 input_sync(tpd->dev);
3377 input_report_key(tpd->dev, KEY_POWER, 0);
3378 input_sync(tpd->dev);
3379 tpd_sleep_flag = 1;
3380 #endif
3381 goto exit_work_func;
3382 }
3383 //end
3384 }
3385 #ifdef TPD_PROXIMITY
3386 if (tpd_proximity_flag == 1)
3387 {
3388 proximity_status = point_data[GTP_ADDR_LENGTH];
3389 GTP_DEBUG("REG INDEX[0x814E]:0x%02X\n", proximity_status);
3390
3391 if (proximity_status & 0x60) //proximity or large touch detect,enable hwm_sensor.
3392 {
3393 tpd_proximity_detect = 0;
3394 //sensor_data.values[0] = 0;
3395 }
3396 else
3397 {
3398 tpd_proximity_detect = 1;
3399 //sensor_data.values[0] = 1;
3400 }
3401
3402 //get raw data
3403 GTP_DEBUG(" ps change\n");
3404 GTP_DEBUG("PROXIMITY STATUS:0x%02X\n", tpd_proximity_detect);
3405 //map and store data to hwm_sensor_data
3406 sensor_data.values[0] = tpd_get_ps_value();
3407 sensor_data.value_divide = 1;
3408 sensor_data.status = SENSOR_STATUS_ACCURACY_MEDIUM;
3409 //report to the up-layer
3410 ret = hwmsen_get_interrupt_data(ID_PROXIMITY, &sensor_data);
3411
3412 if (ret)
3413 {
3414 GTP_ERROR("Call hwmsen_get_interrupt_data fail = %d\n", err);
3415 }
3416 }
3417
3418 #endif
3419
3420 touch_num = finger & 0x0f;
3421
3422 if (touch_num > GTP_MAX_TOUCH)
3423 {
3424 goto exit_work_func;
3425 }
3426
3427 if (touch_num > 1)
3428 {
3429 u8 buf[8 * GTP_MAX_TOUCH] = {(GTP_READ_COOR_ADDR + 10) >> 8, (GTP_READ_COOR_ADDR + 10) & 0xff};
3430
3431 ret = gtp_i2c_read(i2c_client_point, buf, 2 + 8 * (touch_num - 1));
3432 memcpy(&point_data[12], &buf[2], 8 * (touch_num - 1));
3433 }
3434
3435 #if (GTP_HAVE_TOUCH_KEY || GTP_PEN_HAVE_BUTTON)
3436 key_value = point_data[3 + 8 * touch_num];
3437
3438 if (key_value || pre_key)
3439 {
3440 #if GTP_PEN_HAVE_BUTTON
3441 if (key_value == 0x40)
3442 {
3443 GTP_DEBUG("BTN_STYLUS & BTN_STYLUS2 Down.");
3444 input_report_key(pen_dev, BTN_STYLUS, 1);
3445 input_report_key(pen_dev, BTN_STYLUS2, 1);
3446 pen_active = 1;
3447 }
3448 else if (key_value == 0x10)
3449 {
3450 GTP_DEBUG("BTN_STYLUS Down, BTN_STYLUS2 Up.");
3451 input_report_key(pen_dev, BTN_STYLUS, 1);
3452 input_report_key(pen_dev, BTN_STYLUS2, 0);
3453 pen_active = 1;
3454 }
3455 else if (key_value == 0x20)
3456 {
3457 GTP_DEBUG("BTN_STYLUS Up, BTN_STYLUS2 Down.");
3458 input_report_key(pen_dev, BTN_STYLUS, 0);
3459 input_report_key(pen_dev, BTN_STYLUS2, 1);
3460 pen_active = 1;
3461 }
3462 else
3463 {
3464 GTP_DEBUG("BTN_STYLUS & BTN_STYLUS2 Up.");
3465 input_report_key(pen_dev, BTN_STYLUS, 0);
3466 input_report_key(pen_dev, BTN_STYLUS2, 0);
3467 if ( (pre_key == 0x40) || (pre_key == 0x20) ||
3468 (pre_key == 0x10)
3469 )
3470 {
3471 pen_active = 1;
3472 }
3473 }
3474 if (pen_active)
3475 {
3476 touch_num = 0; // shield pen point
3477 //pre_touch = 0; // clear last pen status
3478 }
3479 #endif
3480 #if GTP_HAVE_TOUCH_KEY
3481 if (!pre_touch)
3482 {
3483 for (i = 0; i < GTP_MAX_KEY_NUM; i++)
3484 {
3485 input_report_key(tpd->dev, touch_key_array[i], key_value & (0x01 << i));
3486 }
3487 touch_num = 0; // shiled fingers
3488 }
3489 #endif
3490 }
3491 #endif
3492 pre_key = key_value;
3493
3494 GTP_DEBUG("pre_touch:%02x, finger:%02x.", pre_touch, finger);
3495
3496 if (touch_num)
3497 {
3498 for (i = 0; i < touch_num; i++)
3499 {
3500 coor_data = &point_data[i * 8 + 3];
3501
3502 id = coor_data[0] & 0x0F;
3503 input_x = coor_data[1] | coor_data[2] << 8;
3504 input_y = coor_data[3] | coor_data[4] << 8;
3505 input_w = coor_data[5] | coor_data[6] << 8;
3506
3507 #if GTP_WITH_PEN
3508 id = coor_data[0];
3509 if ((id & 0x80)) // pen/stylus is activated
3510 {
3511 GTP_DEBUG("Pen touch DOWN!");
3512 pre_pen = 1;
3513 //id &= 0x7F;
3514 id = 0;
3515 GTP_DEBUG("(%d)(%d, %d)[%d]", id, input_x, input_y, input_w);
3516 gtp_pen_down(input_x, input_y, input_w, id);
3517 pen_active = 1;
3518 }
3519 else
3520 #endif
3521 {
3522 GTP_DEBUG(" (%d)(%d, %d)[%d]", id, input_x, input_y, input_w);
3523 tpd_down(input_x, input_y, input_w, id);
3524 }
3525 }
3526 }
3527 else
3528 {
3529 if (pre_touch)
3530 {
3531 #if GTP_WITH_PEN
3532 if (pre_pen)
3533 {
3534 GTP_DEBUG("Pen touch UP!");
3535 gtp_pen_up();
3536 pre_pen = 0;
3537 pen_active = 1;
3538 }
3539 else
3540 #endif
3541 {
3542 GTP_DEBUG("Touch Release!");
3543 tpd_up(0, 0, 0);
3544 }
3545 }
3546 }
3547 pre_touch = touch_num;
3548
3549 #if GTP_WITH_PEN
3550 if (pen_active)
3551 {
3552 pen_active = 0;
3553 input_sync(pen_dev);
3554 }
3555 else
3556 #endif
3557 {
3558 input_sync(tpd->dev);
3559 }
3560
3561 exit_work_func:
3562
3563 if (!gtp_rawdiff_mode)
3564 {
3565 ret = gtp_i2c_write(i2c_client_point, end_cmd, 3);
3566
3567 if (ret < 0)
3568 {
3569 GTP_ERROR("I2C write end_cmd error!");
3570 }
3571 }
3572 #if (GTP_COMPATIBLE_MODE && GTP_FL_LITTLE_SYSTEM)
3573 if (CHIP_TYPE_GT9F == gtp_chip_type)
3574 {
3575 if (little_fw_mode)
3576 {
3577 if ((fw_block == 0) && (block_section == 1))
3578 {
3579 GTP_INFO("Begin downloading big ss51 firmware");
3580 }
3581 gtp_download_big_ss51(i2c_client_point);
3582 }
3583 }
3584 #endif
3585 } while (!kthread_should_stop());
3586
3587 return 0;
3588 }
3589
3590 static int tpd_local_init(void)
3591 {
3592 #if GTP_ESD_PROTECT
3593 clk_tick_cnt = 2 * HZ; // HZ: clock ticks in 1 second generated by system
3594 GTP_DEBUG("Clock ticks for an esd cycle: %d", clk_tick_cnt);
3595 INIT_DELAYED_WORK(&gtp_esd_check_work, gtp_esd_check_func);
3596 gtp_esd_check_workqueue = create_workqueue("gtp_esd_check");
3597 spin_lock_init(&esd_lock); // 2.6.39 & later
3598 // esd_lock = SPIN_LOCK_UNLOCKED; // 2.6.39 & before
3599 #endif
3600
3601 #if GTP_SUPPORT_I2C_DMA
3602 gpDMABuf_va = (u8 *)dma_alloc_coherent(NULL, GTP_DMA_MAX_TRANSACTION_LENGTH, &gpDMABuf_pa, GFP_KERNEL);
3603 if(!gpDMABuf_va){
3604 GTP_ERROR("[Error] Allocate DMA I2C Buffer failed!\n");
3605 }
3606 memset(gpDMABuf_va, 0, GTP_DMA_MAX_TRANSACTION_LENGTH);
3607 #endif
3608 if (i2c_add_driver(&tpd_i2c_driver) != 0)
3609 {
3610 GTP_ERROR("unable to add i2c driver.\n");
3611 return -1;
3612 }
3613
3614 if (tpd_load_status == 0) //if(tpd_load_status == 0) // disable auto load touch driver for linux3.0 porting
3615 {
3616 GTP_ERROR("add error touch panel driver.\n");
3617 i2c_del_driver(&tpd_i2c_driver);
3618 return -1;
3619 }
3620
3621 input_set_abs_params(tpd->dev, ABS_MT_TRACKING_ID, 0, (GTP_MAX_TOUCH - 1), 0, 0);
3622 #ifdef TPD_HAVE_BUTTON
3623 tpd_button_setting(TPD_KEY_COUNT, tpd_keys_local, tpd_keys_dim_local);// initialize tpd button data
3624 #endif
3625
3626 #if (defined(TPD_WARP_START) && defined(TPD_WARP_END))
3627 TPD_DO_WARP = 1;
3628 memcpy(tpd_wb_start, tpd_wb_start_local, TPD_WARP_CNT * 4);
3629 memcpy(tpd_wb_end, tpd_wb_start_local, TPD_WARP_CNT * 4);
3630 #endif
3631
3632 #if (defined(TPD_HAVE_CALIBRATION) && !defined(TPD_CUSTOM_CALIBRATION))
3633 memcpy(tpd_calmat, tpd_def_calmat_local, 8 * 4);
3634 memcpy(tpd_def_calmat, tpd_def_calmat_local, 8 * 4);
3635 #endif
3636
3637 // set vendor string
3638 tpd->dev->id.vendor = 0x00;
3639 tpd->dev->id.product = tpd_info.pid;
3640 tpd->dev->id.version = tpd_info.vid;
3641
3642 GTP_DEBUG("end %s, %d\n", __FUNCTION__, __LINE__);
3643 tpd_type_cap = 1;
3644
3645 return 0;
3646 }
3647
3648 static s8 gtp_enter_doze(struct i2c_client *client)
3649 {
3650 s8 ret = -1;
3651 s8 retry = 0;
3652 u8 i2c_control_buf[3] = {(u8)(GTP_REG_SLEEP >> 8), (u8)GTP_REG_SLEEP, 8};
3653
3654 GTP_DEBUG_FUNC();
3655
3656 GTP_DEBUG("Entering gesture mode...");
3657 while(retry++ < 5)
3658 {
3659 i2c_control_buf[0] = 0x80;
3660 i2c_control_buf[1] = 0x46;
3661 ret = gtp_i2c_write(client, i2c_control_buf, 3);
3662 if (ret < 0)
3663 {
3664 GTP_DEBUG("Failed to set gesture flag into 0x8046, %d", retry);
3665 continue;
3666 }
3667 i2c_control_buf[0] = 0x80;
3668 i2c_control_buf[1] = 0x40;
3669 ret = gtp_i2c_write(client, i2c_control_buf, 3);
3670 if (ret > 0)
3671 {
3672 doze_status = DOZE_ENABLED;
3673 GTP_INFO("Gesture mode enabled.");
3674 return ret;
3675 }
3676 msleep(10);
3677 }
3678 GTP_ERROR("GTP send gesture cmd failed.");
3679 return ret;
3680 }
3681
3682 /*******************************************************
3683 Function:
3684 Eter sleep function.
3685
3686 Input:
3687 client:i2c_client.
3688
3689 Output:
3690 Executive outcomes.0--success,non-0--fail.
3691 *******************************************************/
3692 static s8 gtp_enter_sleep(struct i2c_client *client)
3693 {
3694 #if (GTP_COMPATIBLE_MODE && !GTP_POWER_CTRL_SLEEP)
3695 if (CHIP_TYPE_GT9F == gtp_chip_type)
3696 {
3697 u8 i2c_status_buf[3] = {0x80, 0x44, 0x00};
3698 s32 ret = 0;
3699
3700 ret = gtp_i2c_read(client, i2c_status_buf, 3);
3701 if(ret <= 0)
3702 {
3703 GTP_ERROR("[gtp_enter_sleep]Read ref status reg error.");
3704 }
3705
3706 if (i2c_status_buf[2] & 0x80)
3707 {
3708 //Store bak ref
3709 ret = gtp_bak_ref_proc(client, GTP_BAK_REF_STORE);
3710 if(FAIL == ret)
3711 {
3712 GTP_ERROR("[gtp_enter_sleep]Store bak ref failed.");
3713 }
3714 }
3715 }
3716 #endif
3717 #if GTP_POWER_CTRL_SLEEP
3718
3719 GTP_GPIO_OUTPUT(GTP_RST_PORT, 0);
3720 GTP_GPIO_OUTPUT(GTP_INT_PORT, 0);
3721 msleep(10);
3722
3723 #ifdef MT6573
3724 mt_set_gpio_mode(GPIO_CTP_EN_PIN, GPIO_CTP_EN_PIN_M_GPIO);
3725 mt_set_gpio_dir(GPIO_CTP_EN_PIN, GPIO_DIR_OUT);
3726 mt_set_gpio_out(GPIO_CTP_EN_PIN, GPIO_OUT_ZERO);
3727 msleep(30);
3728 #else // ( defined(MT6575) || defined(MT6577) || defined(MT6589) )
3729
3730 #ifdef TPD_POWER_SOURCE_1800
3731 hwPowerDown(TPD_POWER_SOURCE_1800, "TP");
3732 #endif
3733
3734 #ifdef TPD_POWER_SOURCE_CUSTOM
3735 hwPowerDown(TPD_POWER_SOURCE_CUSTOM, "TP");
3736 #else
3737 hwPowerDown(MT65XX_POWER_LDO_VGP2, "TP");
3738 #endif
3739 #endif
3740
3741 GTP_INFO("GTP enter sleep by poweroff!");
3742 return 0;
3743
3744 #else
3745 {
3746 s8 ret = -1;
3747 s8 retry = 0;
3748 u8 i2c_control_buf[3] = {(u8)(GTP_REG_SLEEP >> 8), (u8)GTP_REG_SLEEP, 5};
3749
3750
3751 GTP_GPIO_OUTPUT(GTP_INT_PORT, 0);
3752 msleep(5);
3753
3754 while (retry++ < 5)
3755 {
3756 ret = gtp_i2c_write(client, i2c_control_buf, 3);
3757
3758 if (ret > 0)
3759 {
3760 GTP_INFO("GTP enter sleep!");
3761
3762 return ret;
3763 }
3764
3765 msleep(10);
3766 }
3767
3768 GTP_ERROR("GTP send sleep cmd failed.");
3769 return ret;
3770 }
3771 #endif
3772 }
3773
3774 /*******************************************************
3775 Function:
3776 Wakeup from sleep mode Function.
3777
3778 Input:
3779 client:i2c_client.
3780
3781 Output:
3782 Executive outcomes.0--success,non-0--fail.
3783 *******************************************************/
3784 static s8 gtp_wakeup_sleep(struct i2c_client *client)
3785 {
3786 u8 retry = 0;
3787 s8 ret = -1;
3788
3789 GTP_DEBUG("GTP wakeup begin.");
3790
3791 #if GTP_POWER_CTRL_SLEEP
3792 #if (GTP_COMPATIBLE_MODE && GTP_FL_LITTLE_SYSTEM)
3793 if (CHIP_TYPE_GT9F == gtp_chip_type)
3794 {
3795 power_is_down = 0;
3796 little_fw_mode = 1;
3797 kthread_run(gtp_resume_timeout, (void*)NULL, "resume_timeout");
3798
3799 ret = force_reset_guitar(1);
3800 if (FAIL == ret)
3801 {
3802 little_fw_mode = 0;
3803 gtp_recovery_reset(client);
3804 }
3805 if (!gtp_check_fw()) {
3806 little_fw_mode = 0;
3807 gtp_recovery_reset(client);
3808 }
3809 return 0;
3810 }
3811 #endif // end compatible mode & fl little system
3812
3813 while (retry++ < 5)
3814 {
3815 ret = tpd_power_on(client);
3816
3817 if (ret < 0)
3818 {
3819 GTP_ERROR("I2C Power on ERROR!");
3820 continue;
3821 }
3822 GTP_INFO("Ic wakeup by poweron");
3823 return 0;
3824 }
3825 #else // esle PowerCtrlSleep
3826 while (retry++ < 5) {
3827 //#if GTP_GESTURE_WAKEUP
3828 if(gesture_value > 0){
3829 if (DOZE_WAKEUP != doze_status)
3830 {
3831 GTP_INFO("Powerkey wakeup.");
3832 }
3833 else
3834 {
3835 GTP_INFO("Gesture wakeup.");
3836 }
3837 doze_status = DOZE_DISABLED;
3838
3839 mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
3840 gtp_reset_guitar(client, 20);
3841 ret = gup_reload_fw_dsp(NULL, GTP_FL_READ_REPAIR);
3842 mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
3843 if (ret == FAIL) {
3844 GTP_ERROR("[gtp_wakeup_sleep]Reload dsp code failed.");
3845 continue;
3846 }
3847 ret = gtp_fw_startup(client);
3848 if (ret == FAIL) {
3849 GTP_ERROR("[gtp_wakeup_sleep]Startup fw failed.");
3850 continue;
3851 }
3852 if (!gtp_check_fw()) {
3853 gtp_recovery_reset(client);
3854 }
3855 return 0; // succeed
3856 //#else // else gesture wakeup
3857 }else{
3858 GTP_GPIO_OUTPUT(GTP_INT_PORT, 1); //wake up by int gpio
3859 msleep(5);
3860
3861 #if GTP_COMPATIBLE_MODE
3862 if (CHIP_TYPE_GT9F == gtp_chip_type) {
3863 u8 opr_buf[2] = {0};
3864
3865 ret = gtp_i2c_test(client);
3866 if (ret >= 0) {
3867 // Hold ss51 & dsp
3868 opr_buf[0] = 0x0C;
3869 ret = i2c_write_bytes(client, 0x4180, opr_buf, 1);
3870 if (ret < 0) {
3871 GTP_DEBUG("Hold ss51 & dsp I2C error,retry:%d", retry);
3872 continue;
3873 }
3874
3875 // Confirm hold
3876 opr_buf[0] = 0x00;
3877 ret = i2c_read_bytes(client, 0x4180, opr_buf, 1);
3878 if (ret < 0) {
3879 GTP_DEBUG("confirm ss51 & dsp hold, I2C error,retry:%d", retry);
3880 continue;
3881 }
3882 if (0x0C != opr_buf[0]) {
3883 GTP_DEBUG("ss51 & dsp not hold, val: %d, retry: %d", opr_buf[0], retry);
3884 continue;
3885 }
3886 GTP_DEBUG("ss51 & dsp has been hold");
3887
3888 ret = gtp_fw_startup(client);
3889 if (FAIL == ret) {
3890 GTP_ERROR("[gtp_wakeup_sleep]Startup fw failed.");
3891 continue;
3892 }
3893 GTP_INFO("flashless wakeup sleep success");
3894 return ret;
3895 }
3896 force_reset_guitar(0);
3897 retry = 0;
3898 break;
3899 }
3900 //#endif // end compatible mode
3901 }
3902 ret = gtp_i2c_test(client);
3903 if (ret >= 0)
3904 {
3905 GTP_INFO("GTP wakeup sleep.");
3906 //#if (!GTP_GESTURE_WAKEUP)
3907 if(!(gesture_value > 0))
3908 {
3909 gtp_int_sync(25);
3910 }
3911 //#endif
3912 return ret;
3913 }
3914 gtp_reset_guitar(client, 20);
3915 #endif // end gesture wakeup
3916 }
3917
3918 if (retry >= 5) {
3919 GTP_ERROR("wakeup retry timeout, process esd reset");
3920 force_reset_guitar(0);
3921 }
3922 #endif // end PowerCtrlSleep
3923 GTP_ERROR("GTP wakeup sleep failed.");
3924 return ret;
3925 }
3926
3927 /* Function to manage low power suspend */
3928 static void tpd_suspend(struct early_suspend *h)
3929 {
3930 s32 ret = -1;
3931
3932 GTP_INFO("System suspend.");
3933
3934 #ifdef TPD_PROXIMITY
3935
3936 if (tpd_proximity_flag == 1)
3937 {
3938 return ;
3939 }
3940
3941 #endif
3942 #if (GTP_COMPATIBLE_MODE && GTP_FL_LITTLE_SYSTEM)
3943 little_fw_mode = 0;
3944 power_is_down = 1;
3945 #endif
3946
3947 tpd_halt = 1;
3948 #if GTP_ESD_PROTECT
3949 gtp_esd_switch(i2c_client_point, SWITCH_OFF);
3950 #endif
3951 //#if GTP_GESTURE_WAKEUP
3952 if(gesture_value > 0){
3953 ret = gtp_enter_doze(i2c_client_point);
3954 //#else
3955 }else{
3956 mt_eint_mask(CUST_EINT_TOUCH_PANEL_NUM);
3957 ret = gtp_enter_sleep(i2c_client_point);
3958 //#endif
3959 }
3960 if (ret < 0)
3961 {
3962 GTP_ERROR("GTP early suspend failed.");
3963 }
3964 // to avoid waking up while not sleeping, delay 48 + 10ms to ensure reliability
3965 msleep(58);
3966 }
3967
3968 /* Function to manage power-on resume */
3969 static void tpd_resume(struct early_suspend *h)
3970 {
3971 s32 ret = -1;
3972
3973 GTP_INFO("System resume.");
3974
3975 #ifdef TPD_PROXIMITY
3976
3977 if (tpd_proximity_flag == 1)
3978 {
3979 return ;
3980 }
3981
3982 #endif
3983 tpd_sleep_flag = 0;
3984 ret = gtp_wakeup_sleep(i2c_client_point);
3985
3986 if (ret < 0)
3987 {
3988 GTP_ERROR("GTP later resume failed.");
3989 }
3990
3991 #if GTP_COMPATIBLE_MODE
3992 if (CHIP_TYPE_GT9F == gtp_chip_type)
3993 {
3994 // do nothing
3995 }
3996 else
3997 #endif
3998 {
3999 gtp_send_cfg(i2c_client_point);
4000 }
4001
4002 #if GTP_CHARGER_SWITCH
4003 gtp_charger_switch(1); // force update
4004 #endif
4005
4006 tpd_halt = 0;
4007 //#if GTP_GESTURE_WAKEUP
4008 if(gesture_value > 0){
4009 doze_status = DOZE_DISABLED;
4010 //#else
4011 }else{
4012 mt_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
4013 //#endif
4014 }
4015
4016 #if GTP_ESD_PROTECT
4017 gtp_init_ext_watchdog(i2c_client_point);
4018 gtp_esd_switch(i2c_client_point, SWITCH_ON);
4019 #endif
4020
4021 }
4022
4023 static struct tpd_driver_t tpd_device_driver =
4024 {
4025 .tpd_device_name = "gt9xx",
4026 .tpd_local_init = tpd_local_init,
4027 .suspend = tpd_suspend,
4028 .resume = tpd_resume,
4029 #ifdef TPD_HAVE_BUTTON
4030 .tpd_have_button = 1,
4031 #else
4032 .tpd_have_button = 0,
4033 #endif
4034 };
4035
4036 /* called when loaded into kernel */
4037 static int __init tpd_driver_init(void)
4038 {
4039 if(g_boot_mode == KERNEL_POWER_OFF_CHARGING_BOOT || g_boot_mode == LOW_POWER_OFF_CHARGING_BOOT) //add by zero
4040 return 0;
4041 GTP_INFO("MediaTek gt91xx touch panel driver init\n");
4042 #ifdef I2C_BUS_NUMBER
4043 i2c_register_board_info(I2C_BUS_NUMBER, &i2c_tpd, 1);
4044 #else
4045 i2c_register_board_info(0, &i2c_tpd, 1);
4046 #endif
4047 if (tpd_driver_add(&tpd_device_driver) < 0)
4048 GTP_INFO("add generic driver failed\n");
4049
4050 return 0;
4051 }
4052
4053 /* should never be called */
4054 static void __exit tpd_driver_exit(void)
4055 {
4056 GTP_INFO("MediaTek gt91xx touch panel driver exit\n");
4057 tpd_driver_remove(&tpd_device_driver);
4058 }
4059
4060 module_init(tpd_driver_init);
4061 module_exit(tpd_driver_exit);
4062
kernel source for telekom puls (alcatel/mediatek)