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