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