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