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 / synaptics_2202 / synaptics_ts.c
1 /*
2 * Copyright (C) 2013 LG Electironics, Inc.
3 *
4 * This software is licensed under the terms of the GNU General Public
5 * License version 2, as published by the Free Software Foundation, and
6 * may be copied, distributed, and modified under those terms.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 */
14
15 #include <linux/module.h>
16 #include <linux/delay.h>
17 #include <linux/earlysuspend.h>
18 #include <linux/hrtimer.h>
19 #include <linux/i2c.h>
20 #include <linux/input.h>
21 #include <linux/input/mt.h>
22 #include <linux/interrupt.h>
23 #include <linux/io.h>
24 #include <linux/platform_device.h>
25 #include <linux/gpio.h>
26 #include <linux/rtpm_prio.h>
27 #include <linux/time.h>
28 #include <linux/slab.h>
29 #include <linux/gpio.h>
30 #include <linux/sched.h>
31 #include <linux/kthread.h>
32 #include <linux/bitops.h>
33 #include <linux/kernel.h>
34 #include <linux/delay.h>
35 #include <linux/byteorder/generic.h>
36 #include <linux/spinlock.h>
37 #include <linux/workqueue.h>
38 #include <linux/wakelock.h>
39 #ifdef CONFIG_HAS_EARLYSUSPEND
40 #include <linux/earlysuspend.h>
41 #endif
42
43 #include <mach/mt_pm_ldo.h>
44 #include <mach/mt_typedefs.h>
45 #include <mach/mt_boot.h>
46 #include <mach/mt_wdt.h>
47 #include <mach/mt_gpt.h>
48 #include <mach/mt_reg_base.h>
49 #include <mach/eint.h>
50 #ifndef TPD_NO_GPIO
51 #include <cust_gpio_usage.h>
52 #endif
53 #include <tpd.h>
54 #include <cust_eint.h>
55
56 #include "synaptics_ts.h"
57
58 #define LGE_USE_SYNAPTICS_FW_UPGRADE
59 #if defined(LGE_USE_SYNAPTICS_FW_UPGRADE)
60 #include "SynaImage.h"
61 #endif
62
63 //#define LGE_USE_SYNAPTICS_RED_ON_MTK
64
65 #define LGE_USE_SYNAPTICS_F54
66 #if defined(LGE_USE_SYNAPTICS_F54)
67 #include "RefCode.h"
68 #include "RefCode_PDTScan.h"
69 #endif
70
71
72 //ticklewind.kim@lge.com_S:
73 #define CUST_G2_TOUCH_WAKEUP_GESTURE
74
75 #ifdef CUST_G2_TOUCH_WAKEUP_GESTURE
76 #include <linux/wakelock.h>
77 #include <linux/mutex.h>
78 #include <linux/pm_wakeup.h>
79 #include <linux/pm_runtime.h>
80 #include <linux/irq.h>
81 #if 0
82 #include <mach/mpm.h>
83
84 #define REPORT_MODE_REG 0x0056
85 static int touch_gesture_enable = 0;
86 static struct wake_lock touch_wake_lock;
87 static struct mutex i2c_suspend_lock;
88 static spinlock_t touch_spin_lock;
89 #endif
90
91
92 static int __attribute__ ((unused)) ts_suspend = 0;
93 static int __attribute__ ((unused)) ts_force_update_chk = 0;
94 #endif
95 //ticklewind.kim@lge.com_E:
96
97 /* RMI4 spec from (RMI4 spec)511-000136-01_revD
98 * Function Purpose See page
99 * $01 RMI Device Control 29
100 * $08 BIST(Built-in Self Test) 38
101 * $09 BIST(Built-in Self Test) 42
102 * $11 2-D TouchPad sensors 46
103 * $19 0-D capacitive button sensors 69
104 * $30 GPIO/LEDs (includes mechanical buttons) 76
105 * $32 Timer 89
106 * $34 Flash Memory Management 93k
107 */
108 #define RMI_DEVICE_CONTROL 0x01
109 #define TOUCHPAD_SENSORS 0x11
110 #define CAPACITIVE_BUTTON_SENSORS 0x1A
111 #define GPIO_LEDS 0x31
112 //#define GPIO_LEDS 0x30
113 #define TIMER 0x32
114 #define FLASH_MEMORY_MANAGEMENT 0x34
115 #define ANALOG_CONTROL 0x54
116
117 /* Register Map & Register bit mask
118 * - Please check "One time" this map before using this device driver
119 */
120 #define DEVICE_STATUS_REG (ts->common_dsc.data_base) /* Device Status */
121 #define INTERRUPT_STATUS_REG (ts->common_dsc.data_base+1) /* Interrupt Status */
122 #define DEVICE_STATUS_REG_UNCONFIGURED 0x80
123 #define DEVICE_STATUS_FLASH_PROG 0x40
124 #define DEVICE_CRC_ERROR_MASK 0x04
125 #define DEVICE_FAILURE_MASK 0x03
126
127 #define DEVICE_CONTROL_REG (ts->common_dsc.control_base) /* Device Control */
128 #define INTERRUPT_ENABLE_REG (ts->common_dsc.control_base+1) /* Interrupt Enable */
129 #define DEVICE_CONTROL_REG_SLEEP 0x01
130 #define DEVICE_CONTROL_REG_NOSLEEP 0x04
131 #define DEVICE_CONTROL_REG_CONFIGURED 0x80
132
133 #define MANUFACTURER_ID_REG (ts->common_dsc.query_base) /* Manufacturer ID */
134 #define FW_REVISION_REG (ts->common_dsc.query_base+3) /* FW revision */
135 #define PRODUCT_ID_REG (ts->common_dsc.query_base+11) /* Product ID */
136
137 #define FINGER_STATE_REG (ts->finger_dsc.data_base) /* Finger State */
138 #define FINGER_STATE_MASK 0x03
139
140 #define TWO_D_EXTEND_STATUS (ts->finger_dsc.data_base+27)
141 #define TWO_D_REPORTING_MODE (ts->finger_dsc.control_base+0) /* 2D Reporting Mode */
142 #define CONTINUOUS_REPORT_MODE 0x0
143 #define REDUCED_REPORT_MODE 0x1
144 #define ABS_MODE 0x8
145 #define REPORT_BEYOND_CLIP 0x80
146
147 #define PALM_DETECT_REG (ts->finger_dsc.control_base+1) /* Palm Detect */
148 #define DELTA_X_THRESH_REG (ts->finger_dsc.control_base+2) /* Delta-X Thresh */
149 #define DELTA_Y_THRESH_REG (ts->finger_dsc.control_base+3) /* Delta-Y Thresh */
150 #define SENSOR_MAX_X_POS (ts->finger_dsc.control_base+6) /* SensorMaxXPos */
151 #define SENSOR_MAX_Y_POS (ts->finger_dsc.control_base+8) /* SensorMaxYPos */
152 //#define GESTURE_ENABLE_1_REG (ts->finger_dsc.control_base+10) /* Gesture Enables 1 */
153 //#define GESTURE_ENABLE_2_REG (ts->finger_dsc.control_base+11) /* Gesture Enables 2 */
154 #define SMALL_OBJECT_DETECTION_TUNNING_REG (ts->finger_dsc.control_base+7)
155 #define SMALL_OBJECT_DETECTION 0x04
156
157 #define FINGER_COMMAND_REG (ts->finger_dsc.command_base)
158 #define BUTTON_DATA_REG (ts->button_dsc.data_base) /* Button Data */
159
160 #define FLASH_CONFIG_ID_REG (ts->flash_dsc.control_base) /* Flash Control */
161 #define FLASH_CONTROL_REG (ts->flash_dsc.data_base+18)
162 #define FLASH_STATUS_MASK 0xF0
163 #define ANALOG_CONTROL_REG (ts->analog_dsc.control_base)
164 #define FORCE_FAST_RELAXATION 0x04
165
166 #define ANALOG_COMMAND_REG (ts->analog_dsc.command_base)
167 #define FORCE_UPDATE 0x04
168
169 #define COMMON_PAGE (ts->common_page)
170 #define FINGER_PAGE (ts->finger_page)
171 #define BUTTON_PAGE (ts->button_page)
172 #define ANALOG_PAGE (ts->analog_page)
173 #define FLASH_PAGE (ts->flash_page)
174 #define DEFAULT_PAGE 0x00
175
176
177 /* General define */
178 #define TOUCH_PRESSED 1
179 #define TOUCH_RELEASED 0
180 #define BUTTON_CANCLED 0xff
181
182 /* Macro */
183 #define GET_X_POSITION(high, low) ((int)(high<<4)|(int)(low&0x0F))
184 #define GET_Y_POSITION(high, low) ((int)(high<<4)|(int)((low&0xF0)>>4))
185
186
187 #define get_time_interval(a,b) a>=b ? a-b : 1000000+a-b
188 #define jitter_abs(x) (x > 0 ? x : -x)
189 #define jitter_sub(x, y) (x > y ? x - y : y - x)
190
191 static unsigned int synaptics_rmi4_i2c_debug_mask = SYNAPTICS_RMI4_I2C_DEBUG_BUTTON_STATUS;
192
193 static struct workqueue_struct *synaptics_wq;
194 static struct synaptics_ts_data *ts_hub = NULL;
195
196
197 static int pressure_zero = 0;
198 static int resume_flag = 0;
199 static int ts_rebase_count =0;
200 static int ghost_detection = 0;
201 static int ghost_detection_count = 0;
202 static int finger_subtraction_check_count = 0;
203 static int force_continuous_mode = 0;
204 static int long_press_check = 0;
205 static int long_press_check_count = 0;
206 static int button_check = 0;
207 static unsigned int button_press_count =0;
208 static unsigned int old_pos_x = 0;
209 static unsigned int old_pos_y = 0;
210 char finger_oldstate[MAX_NUM_OF_FINGER];
211 char button_oldstate[MAX_NUM_OF_BUTTON];
212 ts_finger_data old_ts_data;
213 struct timeval t_ex_debug[TIME_EX_PROFILE_MAX];
214
215
216 struct class *touch_class;
217 struct device *touch_debug_dev;
218
219 static int synaptics_tpd_flag = 0;
220 static int synaptics_tpd_keylock_flag=0;
221 static DECLARE_WAIT_QUEUE_HEAD(synaptics_waiter);
222
223 #if defined(LGE_USE_SYNAPTICS_FW_UPGRADE)
224 struct device *touch_fw_dev;
225 struct wake_lock fw_suspend_lock;
226 extern int FirmwareUpgrade(struct synaptics_ts_data *ts, const char* fw_path);
227 #endif
228
229 #if defined(LGE_USE_SYNAPTICS_RED_ON_MTK)
230 extern void red_i2c_device_setup(void);
231 #endif
232
233 #if defined(LGE_USE_SYNAPTICS_F54)
234 struct i2c_client *ds4_i2c_client;
235 static int f54_fullrawcap_mode = 0;
236 #endif
237
238 #define BUFFER_SIZE 128
239 struct st_i2c_msgs
240 {
241 struct i2c_msg *msg;
242 int count;
243 } i2c_msgs;
244
245 #if 1
246 #include <linux/dma-mapping.h>
247
248 static u8* I2CDMABuf_va = NULL;
249 static dma_addr_t I2CDMABuf_pa = 0;
250
251 int i2c_dma_write(struct i2c_client *client, const uint8_t *buf, int len)
252 {
253 int i = 0;
254 for(i = 0 ; i < len; i++) {
255 I2CDMABuf_va[i] = buf[i];
256 }
257
258 if(len < 8) {
259 client->addr = (client->addr & I2C_MASK_FLAG) | I2C_ENEXT_FLAG;
260 return i2c_master_send(client, buf, len);
261 }
262 else {
263 client->addr = (client->addr & I2C_MASK_FLAG) | I2C_DMA_FLAG | I2C_ENEXT_FLAG;
264 return i2c_master_send(client, (const char*)I2CDMABuf_pa, len);
265 }
266 }
267
268 int i2c_dma_read(struct i2c_client *client, uint8_t *buf, int len)
269 {
270 int i = 0, ret = 0;
271 if(len < 8) {
272 client->addr = (client->addr & I2C_MASK_FLAG) | I2C_ENEXT_FLAG;
273 return i2c_master_recv(client, buf, len);
274 }
275 else {
276 client->addr = (client->addr & I2C_MASK_FLAG) | I2C_DMA_FLAG | I2C_ENEXT_FLAG;
277 ret = i2c_master_recv(client, (char*)I2CDMABuf_pa, len);
278 if(ret < 0) {
279 return ret;
280 }
281 for(i = 0; i < len; i++) {
282 buf[i] = I2CDMABuf_va[i];
283 }
284 }
285 return ret;
286 }
287
288
289
290 static int i2c_msg_transfer(struct i2c_client *client, struct i2c_msg *msgs, int count)
291 {
292 int i = 0, ret = 0;
293 for(i = 0; i < count; i++) {
294 if(msgs[i].flags & I2C_M_RD) {
295 ret = i2c_dma_read(client, msgs[i].buf, msgs[i].len);
296 }
297 else {
298 ret = i2c_dma_write(client, msgs[i].buf, msgs[i].len);
299 }
300 if(ret < 0)return ret;
301 }
302 return 0;
303 }
304
305 #endif // 1
306 int synaptics_ts_read_f54(struct i2c_client *client, u8 reg, int num, u8 *buf)
307 {
308 int message_count = ((num - 1) / BUFFER_SIZE) + 2;
309 int message_rest_count = num % BUFFER_SIZE;
310 int i, data_len;
311
312 if (i2c_msgs.msg == NULL || i2c_msgs.count < message_count) {
313 if (i2c_msgs.msg != NULL)
314 kfree(i2c_msgs.msg);
315 i2c_msgs.msg = (struct i2c_msg*)kcalloc(message_count, sizeof(struct i2c_msg), GFP_KERNEL);
316 i2c_msgs.count = message_count;
317 //dev_dbg(&client->dev, "%s: Update message count %d(%d)\n", __func__, i2c_msgs.count, message_count);
318 }
319
320 i2c_msgs.msg[0].addr = client->addr;
321 i2c_msgs.msg[0].flags = 0;
322 i2c_msgs.msg[0].len = 1;
323 i2c_msgs.msg[0].buf = &reg;
324
325 if (!message_rest_count)
326 message_rest_count = BUFFER_SIZE;
327 for (i = 0; i < message_count -1 ;i++) {
328 if (i == message_count - 1)
329 data_len = message_rest_count;
330 else
331 data_len = BUFFER_SIZE;
332 i2c_msgs.msg[i + 1].addr = client->addr;
333 i2c_msgs.msg[i + 1].flags = I2C_M_RD;
334 i2c_msgs.msg[i + 1].len = data_len;
335 i2c_msgs.msg[i + 1].buf = buf + BUFFER_SIZE * i;
336 }
337
338 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FUNC_TRACE)
339 SYNAPTICS_DEBUG_MSG(":%x\n", reg);
340
341 #if 1
342 if (i2c_msg_transfer(client, i2c_msgs.msg, message_count) < 0) {
343 #else
344 if (i2c_transfer(client->adapter, i2c_msgs.msg, message_count) < 0) {
345 #endif // 1
346 if (printk_ratelimit())
347 SYNAPTICS_ERR_MSG("transfer error\n");
348 return -EIO;
349 } else
350 return 0;
351 }
352
353
354 int synaptics_ts_read(struct i2c_client *client, u8 reg, int num, u8 *buf)
355 {
356
357 struct i2c_msg msgs[] = {
358 {
359 .addr = client->addr,
360 .flags = 0,
361 .len = 1,
362 .buf = &reg,
363 },
364 {
365 .addr = client->addr,
366 .flags = I2C_M_RD,
367 .len = num,
368 .buf = buf,
369 },
370 };
371
372
373 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FUNC_TRACE)
374 SYNAPTICS_DEBUG_MSG(":%x\n", reg);
375
376 #if 1
377 if (i2c_msg_transfer(client, msgs, 2) < 0) {
378 #else
379 if (i2c_transfer(client->adapter, msgs, 2) < 0) {
380 #endif // 1
381 if (printk_ratelimit())
382 SYNAPTICS_ERR_MSG("transfer error\n");
383 return -EIO;
384 } else
385 return 0;
386
387 }
388 EXPORT_SYMBOL(synaptics_ts_read);
389
390 int synaptics_ts_write(struct i2c_client *client, u8 reg, u8 * buf, int len)
391 {
392
393 unsigned char send_buf[len + 1];
394 struct i2c_msg msgs[] = {
395 {
396 .addr = client->addr,
397 .flags = client->flags,
398 .len = len+1,
399 .buf = send_buf,
400 },
401 };
402
403
404 send_buf[0] = (unsigned char)reg;
405 memcpy(&send_buf[1], buf, len);
406
407
408
409
410 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FUNC_TRACE)
411 SYNAPTICS_DEBUG_MSG(":%x\n", reg);
412
413 #if 1
414 if (i2c_msg_transfer(client, msgs, 1) < 0) {
415 #else
416
417
418 if (i2c_transfer(client->adapter, msgs, 1) < 0) {
419 #endif // 1
420 if (printk_ratelimit())
421 SYNAPTICS_ERR_MSG("transfer error\n");
422 return -EIO;
423 } else
424 return 0;
425
426 }
427 EXPORT_SYMBOL(synaptics_ts_write);
428
429 int synaptics_ts_page_data_read(struct i2c_client *client, u8 page, u8 reg, int size, u8 *data)
430 {
431 int ret = 0;
432
433 ret = i2c_smbus_write_byte_data(client, PAGE_SELECT_REG, page);
434 if (ret < 0)
435 SYNAPTICS_ERR_MSG("PAGE_SELECT_REG write fail\n");
436
437 ret = synaptics_ts_read(client, reg, size, data);
438 if (ret < 0)
439 SYNAPTICS_ERR_MSG("synaptics_ts_read read fail\n");
440
441 ret = i2c_smbus_write_byte_data(client, PAGE_SELECT_REG, 0x00);
442 if (ret < 0)
443 SYNAPTICS_ERR_MSG("PAGE_SELECT_REG write fail\n");
444
445 return 0;
446 }
447
448 int synaptics_ts_page_data_write(struct i2c_client *client, u8 page, u8 reg, int size, u8 *data)
449 {
450 int ret = 0;
451
452 ret = i2c_smbus_write_byte_data(client, PAGE_SELECT_REG, page);
453 if (ret < 0)
454 SYNAPTICS_ERR_MSG("PAGE_SELECT_REG write fail\n");
455
456 ret = synaptics_ts_write(client, reg, data, size);
457 if (ret < 0)
458 SYNAPTICS_ERR_MSG("synaptics_ts_write read fail\n");
459
460 ret = i2c_smbus_write_byte_data(client, PAGE_SELECT_REG, 0x00);
461 if (ret < 0)
462 SYNAPTICS_ERR_MSG("PAGE_SELECT_REG write fail\n");
463
464 return 0;
465 }
466
467 void touch_keylock_enable(int key_lock)
468 {
469 struct synaptics_ts_data *ts = ts_hub;
470
471 if(ts == NULL) {
472 SYNAPTICS_ERR_MSG("ts is NULL\n");
473 return;
474 }
475
476 if(!key_lock) {
477 if(ts->pdata->use_irq)
478 mt65xx_eint_unmask(ts->pdata->irq_num);
479 else
480 hrtimer_start(&ts->timer, ktime_set(0, ts->pdata->report_period+(ts->pdata->ic_booting_delay*1000000)), HRTIMER_MODE_REL);
481 synaptics_tpd_keylock_flag=0;
482 }
483 else {
484 if(ts->pdata->use_irq)
485 mt65xx_eint_mask(ts->pdata->irq_num);
486 else
487 hrtimer_cancel(&ts->timer);
488 synaptics_tpd_keylock_flag=1;
489 }
490 }
491 EXPORT_SYMBOL(touch_keylock_enable);
492
493 static void synaptics_ts_reset(int reset_pin)
494 {
495 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FUNC_TRACE)
496 SYNAPTICS_DEBUG_MSG("\n");
497
498 mt_set_gpio_mode(reset_pin, GPIO_MODE_00);
499 mt_set_gpio_dir(reset_pin, GPIO_DIR_OUT);
500 mt_set_gpio_out(reset_pin, GPIO_OUT_ZERO);
501 msleep(10);
502 mt_set_gpio_mode(reset_pin, GPIO_MODE_00);
503 mt_set_gpio_dir(reset_pin, GPIO_DIR_OUT);
504 mt_set_gpio_out(reset_pin, GPIO_OUT_ONE);
505 msleep(50);
506 }
507
508 static void synaptics_ts_hard_reset(struct synaptics_ts_data *ts)
509 {
510 int ret = 0;
511
512 /* 1. VIO off
513 * 2. VDD off
514 * 3. Wait more than 10ms
515 * 4. VDD on
516 * 5. VIO on
517 * 6. Initialization
518 */
519 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FUNC_TRACE)
520 SYNAPTICS_DEBUG_MSG("\n");
521
522 if (ts->pdata->power) {
523 ret = ts->pdata->power(0);
524
525 if (ret < 0)
526 SYNAPTICS_ERR_MSG("power on failed\n");
527
528 mdelay(20);
529
530 synaptics_ts_reset(ts->pdata->reset_gpio);
531
532 ret = ts->pdata->power(1);
533
534 if (ret < 0)
535 SYNAPTICS_ERR_MSG("power on failed\n");
536 }
537
538 queue_delayed_work(synaptics_wq, &ts->work,msecs_to_jiffies(ts->pdata->ic_booting_delay));
539 }
540
541 int synaptics_ts_ic_ctrl(struct i2c_client *client, u8 code, u16 value)
542 {
543 struct synaptics_ts_data* ts;
544 u8 buf = 0;
545
546 ts = ts_hub;
547
548 if(ts == NULL) {
549 SYNAPTICS_ERR_MSG("ts is NULL\n");
550 return 0;
551 }
552
553 SYNAPTICS_INFO_MSG("synaptics_ts_ic_ctrl: %d, %d\n", code, value);
554
555 switch (code)
556 {
557 case IC_CTRL_BASELINE:
558 switch (value)
559 {
560 case BASELINE_OPEN:
561 #if 0
562 if (unlikely(synaptics_ts_page_data_write(client, ANALOG_PAGE, ANALOG_CONTROL_REG, 1, FORCE_FAST_RELAXATION) < 0)) {
563 SYNAPTICS_ERR_MSG("ANALOG_CONTROL_REG write fail\n");
564 return -EIO;
565 }
566
567 msleep(10);
568
569 if (unlikely(synaptics_ts_page_data_write(client, ANALOG_PAGE, ANALOG_COMMAND_REG, 1, FORCE_UPDATE) < 0)) {
570 SYNAPTICS_ERR_MSG("ANALOG_COMMAND_REG write fail\n");
571 return -EIO;
572 }
573
574 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FINGER_STATUS)
575 SYNAPTICS_INFO_MSG("BASELINE_OPEN\n");
576 #endif
577 break;
578
579 case BASELINE_FIX:
580 #if 0
581 if (unlikely(synaptics_ts_page_data_write(client, ANALOG_PAGE, ANALOG_CONTROL_REG, 1, 0x00) < 0)) {
582 TOUCH_ERR_MSG("ANALOG_CONTROL_REG write fail\n");
583 return -EIO;
584 }
585
586 msleep(10);
587
588 if (unlikely(synaptics_ts_page_data_write(client, ANALOG_PAGE, ANALOG_COMMAND_REG, 1, FORCE_UPDATE) < 0)) {
589 TOUCH_ERR_MSG("ANALOG_COMMAND_REG write fail\n");
590 return -EIO;
591 }
592
593 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FINGER_STATUS)
594 TOUCH_INFO_MSG("BASELINE_FIX\n");
595 #endif
596 break;
597
598 case BASELINE_REBASE:
599 /* rebase base line */
600 if (likely(ts->finger_dsc.id != 0)) {
601 if (unlikely(i2c_smbus_write_byte_data(client, FINGER_COMMAND_REG, 0x1) < 0)) {
602 SYNAPTICS_ERR_MSG("finger baseline reset command write fail\n");
603 return -EIO;
604 }
605 }
606 break;
607
608 default:
609 break;
610 }
611 break;
612
613 case IC_CTRL_REPORT_MODE:
614 switch (value)
615 {
616 case 0: // continuous mode
617 if (unlikely(i2c_smbus_write_byte_data(client, TWO_D_REPORTING_MODE, REPORT_BEYOND_CLIP | ABS_MODE | CONTINUOUS_REPORT_MODE) < 0)) {
618 SYNAPTICS_ERR_MSG("TWO_D_REPORTING_MODE write fail\n");
619 return -EIO;
620 }
621 break;
622
623 case 1: // reduced mode
624 if (unlikely(i2c_smbus_write_byte_data(client, TWO_D_REPORTING_MODE, REPORT_BEYOND_CLIP | ABS_MODE | REDUCED_REPORT_MODE) < 0)) {
625 SYNAPTICS_ERR_MSG("TWO_D_REPORTING_MODE write fail\n");
626 return -EIO;
627 }
628 break;
629
630 default:
631 break;
632 }
633 break;
634
635 default:
636 break;
637 }
638
639 return buf;
640 }
641
642 void release_all_ts_event(void)
643 {
644 struct synaptics_ts_data *ts;
645 unsigned int f_counter = 0;
646 unsigned int b_counter = 0;
647 char report_enable = 0;
648
649 ts = ts_hub;
650
651 if(ts == NULL) {
652 SYNAPTICS_ERR_MSG("ts is NULL\n");
653 return;
654 }
655
656 /* Finger check */
657 for(f_counter = 0; f_counter < ts->pdata->num_of_finger; f_counter++) {
658 if (ts->finger_prestate[f_counter] == TOUCH_PRESSED) {
659 #if defined(MT_PROTOCOL_A)
660 input_report_abs(ts->input_dev, ABS_MT_POSITION_X, ts->pre_ts_data.pos_x[f_counter]);
661 input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, ts->pre_ts_data.pos_y[f_counter]);
662 input_report_abs(ts->input_dev, ABS_MT_PRESSURE, TOUCH_RELEASED);
663 input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, TOUCH_RELEASED);
664 #else
665 input_mt_slot(ts->input_dev, f_counter);
666 input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, false);
667 #endif
668 report_enable = 1;
669 }
670 }
671
672 /* Button check */
673 for(b_counter = 0; b_counter < ts->pdata->num_of_button; b_counter++) {
674 if (ts->button_prestate[b_counter] == TOUCH_PRESSED) {
675 report_enable = 1;
676 input_report_key(ts->input_dev, ts->pdata->button[b_counter], TOUCH_RELEASED);
677 }
678 }
679
680 /* Reset finger position data */
681 memset(&old_ts_data, 0x0, sizeof(ts_finger_data));
682 memset(&ts->pre_ts_data, 0x0, sizeof(ts_finger_data));
683
684 if (report_enable) {
685 SYNAPTICS_INFO_MSG("Release all pressed event before touch power off\n");
686 input_sync(ts->input_dev);
687
688 /* Reset finger & button status data */
689 memset(finger_oldstate, 0x0, sizeof(char) * ts->pdata->num_of_finger);
690 memset(button_oldstate, 0x0, sizeof(char) * ts->pdata->num_of_button);
691 memset(ts->finger_prestate, 0x0, sizeof(char) * ts->pdata->num_of_finger);
692 memset(ts->button_prestate, 0x0, sizeof(char) * ts->pdata->num_of_button);
693 }
694 }
695
696 bool chk_time_interval(struct timeval t_aft, struct timeval t_bef, int t_val)
697 {
698 if( t_aft.tv_sec - t_bef.tv_sec == 0 ) {
699 if((get_time_interval(t_aft.tv_usec, t_bef.tv_usec)) <= t_val)
700 return true;
701 } else if( t_aft.tv_sec - t_bef.tv_sec == 1 ) {
702 if( t_aft.tv_usec + 1000000 - t_bef.tv_usec <= t_val)
703 return true;
704 }
705
706 return false;
707 }
708
709 int ghost_detect_solution(void)
710 {
711 int first_int_detection = 0;
712 int cnt = 0, id = 0;
713 struct synaptics_ts_data *ts;
714
715 ts = ts_hub;
716
717 if(ts == NULL) {
718 SYNAPTICS_ERR_MSG("ts is NULL\n");
719 return 0;
720 }
721
722 if (resume_flag) {
723 resume_flag = 0;
724 do_gettimeofday(&t_ex_debug[TIME_EX_FIRST_INT_TIME]);
725
726 if (t_ex_debug[TIME_EX_FIRST_INT_TIME].tv_sec - t_ex_debug[TIME_EX_INIT_TIME].tv_sec == 0 ) {
727 if((get_time_interval(t_ex_debug[TIME_EX_FIRST_INT_TIME].tv_usec, t_ex_debug[TIME_EX_INIT_TIME].tv_usec)) <= 200000)
728 first_int_detection = 1;
729 }
730 else if (t_ex_debug[TIME_EX_FIRST_INT_TIME].tv_sec - t_ex_debug[TIME_EX_INIT_TIME].tv_sec == 1) {
731 if(t_ex_debug[TIME_EX_FIRST_INT_TIME].tv_usec + 1000000 - t_ex_debug[TIME_EX_INIT_TIME].tv_usec <= 200000) {
732 first_int_detection = 1;
733 }
734 }
735 }
736
737 if (first_int_detection) {
738 for (cnt = 0; cnt < ts->pdata->num_of_finger; cnt++) {
739 if (ts->finger_prestate[cnt] == TOUCH_PRESSED) {
740 SYNAPTICS_INFO_MSG("ghost detected within first input time 200ms\n");
741 ghost_detection = 1;
742 }
743 }
744 }
745
746 if (pressure_zero == 1) {
747 SYNAPTICS_INFO_MSG("ghost detected on pressure\n");
748 ghost_detection = 1;
749 }
750
751 if (ts->pre_ts_data.total_num) {
752 if (old_ts_data.total_num != ts->pre_ts_data.total_num) {
753 if (old_ts_data.total_num <= ts->pre_ts_data.total_num) {
754 for(id = 0; id < ts->pdata->num_of_finger; id++) {
755 if (ts->finger_prestate[id] == TOUCH_PRESSED && finger_oldstate[id] == TOUCH_RELEASED) {
756 break;
757 }
758 }
759
760 if (id < ts->pdata->num_of_finger) {
761 memcpy(&t_ex_debug[TIME_EX_PREV_PRESS_TIME], &t_ex_debug[TIME_EX_CURR_PRESS_TIME], sizeof(struct timeval));
762 do_gettimeofday(&t_ex_debug[TIME_EX_CURR_PRESS_TIME]);
763
764 if ((ts->pre_ts_data.pos_x[id] > 0) && (ts->pre_ts_data.pos_x[id] < ts->pdata->x_max)
765 && (1 <= old_ts_data.total_num) && (1 <= ts->pre_ts_data.total_num)
766 && (jitter_sub(old_pos_x, ts->pre_ts_data.pos_x[id]) <= 10) && (jitter_sub(old_pos_y, ts->pre_ts_data.pos_y[id]) <= 10)) {
767 if (chk_time_interval(t_ex_debug[TIME_EX_CURR_PRESS_TIME], t_ex_debug[TIME_EX_PREV_PRESS_TIME], 50000)) {
768 ghost_detection = 1;
769 ghost_detection_count++;
770 }
771 }
772 else if ((ts->pre_ts_data.pos_x[id] > 0) && (ts->pre_ts_data.pos_x[id] < ts->pdata->x_max)
773 && (old_ts_data.total_num == 0) && (ts->pre_ts_data.total_num == 1)
774 && (jitter_sub(old_pos_x, ts->pre_ts_data.pos_x[id]) <= 10) && (jitter_sub(old_pos_y, ts->pre_ts_data.pos_y[id]) <= 10)) {
775 if (chk_time_interval(t_ex_debug[TIME_EX_CURR_PRESS_TIME], t_ex_debug[TIME_EX_PREV_PRESS_TIME], 50000)) {
776 ghost_detection = 1;
777 }
778 }
779 else if (5 < jitter_sub(old_ts_data.total_num, ts->pre_ts_data.total_num)) {
780 ghost_detection = 1;
781 }
782 else
783 ; //do not anything
784
785 old_pos_x = ts->pre_ts_data.pos_x[id];
786 old_pos_y = ts->pre_ts_data.pos_y[id];
787 }
788 }
789 else {
790 memcpy(&t_ex_debug[TIME_EX_PREV_PRESS_TIME], &t_ex_debug[TIME_EX_CURR_PRESS_TIME], sizeof(struct timeval));
791 do_gettimeofday(&t_ex_debug[TIME_EX_CURR_INT_TIME]);
792
793 if (chk_time_interval(t_ex_debug[TIME_EX_CURR_INT_TIME], t_ex_debug[TIME_EX_PREV_PRESS_TIME], 10999)) {
794 finger_subtraction_check_count++;
795 }
796 else {
797 finger_subtraction_check_count = 0;
798 }
799
800 if (4 < finger_subtraction_check_count) {
801 finger_subtraction_check_count = 0;
802 SYNAPTICS_INFO_MSG("need_to_rebase finger_subtraction!!!\n");
803 /* rebase is disabled. see TD 41871*/
804 //goto out_need_to_rebase;
805 }
806 }
807 }
808
809 if (force_continuous_mode) {
810 do_gettimeofday(&t_ex_debug[TIME_EX_CURR_INT_TIME]);
811 // if 20 sec have passed since resume, then return to the original report mode.
812 if(t_ex_debug[TIME_EX_CURR_INT_TIME].tv_sec - t_ex_debug[TIME_EX_INIT_TIME].tv_sec >= 10) {
813 if(synaptics_ts_ic_ctrl(ts->client, IC_CTRL_REPORT_MODE, ts->pdata->report_mode) < 0) {
814 SYNAPTICS_ERR_MSG("IC_CTRL_BASELINE(1) handling fail\n");
815 goto out_need_to_init;
816 }
817 force_continuous_mode = 0;
818 }
819
820 long_press_check = 0;
821
822 for(cnt = 0; cnt < MAX_NUM_OF_FINGER; cnt++) {
823 if (ts->finger_prestate[cnt] == TOUCH_PRESSED) {
824 if ((finger_oldstate[cnt] == TOUCH_PRESSED) && (jitter_sub(old_ts_data.pos_x[cnt], ts->pre_ts_data.pos_x[cnt]) < 10) && (jitter_sub(old_ts_data.pos_y[cnt], ts->pre_ts_data.pos_y[cnt]) < 10)) {
825 long_press_check = 1;
826 }
827 }
828 }
829
830 if (long_press_check) {
831 long_press_check_count++;
832 }
833 else {
834 long_press_check_count = 0;
835 }
836
837 if (500 < long_press_check_count) {
838 long_press_check_count = 0;
839 SYNAPTICS_INFO_MSG("need_to_rebase long press!!!\n");
840 goto out_need_to_rebase;
841 }
842 }
843 }
844 else if (!ts->pre_ts_data.total_num) {
845 long_press_check_count = 0;
846 finger_subtraction_check_count = 0;
847 }
848
849 button_check = 0;
850 for(id = 0; id < ts->pdata->num_of_button; id++) {
851 if (ts->button_prestate[id] == TOUCH_PRESSED && button_oldstate[id] == TOUCH_RELEASED) {
852 button_check = 1;
853 break;
854 }
855 }
856 if (button_check) {
857 if (button_press_count == 0)
858 do_gettimeofday(&t_ex_debug[TIME_EX_BUTTON_PRESS_START_TIME]);
859 else
860 do_gettimeofday(&t_ex_debug[TIME_EX_BUTTON_PRESS_END_TIME]);
861
862 button_press_count++;
863
864 if (6 <= button_press_count) {
865 if (chk_time_interval(t_ex_debug[TIME_EX_BUTTON_PRESS_END_TIME], t_ex_debug[TIME_EX_BUTTON_PRESS_START_TIME], 100000)) {
866 SYNAPTICS_INFO_MSG("need_to_rebase button zero\n");
867 goto out_need_to_rebase;
868 }
869 else {
870 button_press_count = 0;
871 }
872 }
873 else {
874 if (!chk_time_interval(t_ex_debug[TIME_EX_BUTTON_PRESS_END_TIME], t_ex_debug[TIME_EX_BUTTON_PRESS_START_TIME], 100000)) {
875 button_press_count = 0;
876 }
877 }
878 }
879
880 if ((ghost_detection == 1) && (ts->pre_ts_data.total_num == 0) && (ts->pre_ts_data.palm == 0)) {
881 SYNAPTICS_INFO_MSG("need_to_rebase zero\n");
882 goto out_need_to_rebase;
883 }
884 else if ((ghost_detection == 1) && (3 <= ghost_detection_count) && (ts->pre_ts_data.palm == 0)) {
885 SYNAPTICS_INFO_MSG("need_to_rebase zero 3\n");
886 goto out_need_to_rebase;
887 }
888
889 return 0;
890
891 out_need_to_rebase:
892 {
893 ghost_detection = 0;
894 ghost_detection_count = 0;
895 old_pos_x = 0;
896 old_pos_y = 0;
897 ts_rebase_count++;
898
899 if (ts_rebase_count == 1) {
900 do_gettimeofday(&t_ex_debug[TIME_EX_FIRST_GHOST_DETECT_TIME]);
901
902 if ((t_ex_debug[TIME_EX_FIRST_GHOST_DETECT_TIME].tv_sec - t_ex_debug[TIME_EX_INIT_TIME].tv_sec) <= 3) {
903 ts_rebase_count = 0;
904 SYNAPTICS_INFO_MSG("need_to_init in 3 sec\n");
905 goto out_need_to_init;
906 }
907 }
908 else {
909 do_gettimeofday(&t_ex_debug[TIME_EX_SECOND_GHOST_DETECT_TIME]);
910
911 if (((t_ex_debug[TIME_EX_SECOND_GHOST_DETECT_TIME].tv_sec - t_ex_debug[TIME_EX_FIRST_GHOST_DETECT_TIME].tv_sec) <= 5)) {
912 ts_rebase_count = 0;
913 SYNAPTICS_INFO_MSG("need_to_init\n");
914 goto out_need_to_init;
915 }
916 else {
917 ts_rebase_count = 1;
918 memcpy(&t_ex_debug[TIME_EX_FIRST_GHOST_DETECT_TIME], &t_ex_debug[TIME_EX_SECOND_GHOST_DETECT_TIME], sizeof(struct timeval));
919 }
920 }
921
922 release_all_ts_event();
923 if (synaptics_ts_ic_ctrl(ts->client, IC_CTRL_BASELINE, BASELINE_REBASE) < 0) {
924 SYNAPTICS_ERR_MSG("IC_CTRL_REBASE(2) handling fail\n");
925 }
926 SYNAPTICS_INFO_MSG("need_to_rebase\n");
927 }
928 return NEED_TO_OUT;
929
930 out_need_to_init:
931 return NEED_TO_INIT;
932 }
933
934 #if defined(LGE_USE_SYNAPTICS_FW_UPGRADE)
935 static int synaptics_ts_need_fw_upgrade(void)
936 {
937 int ret = 0;
938 int cur_ver = 0;
939 int fw_ver = 0;
940 int product_check = 0;
941 struct synaptics_ts_data *ts;
942
943 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FUNC_TRACE)
944 SYNAPTICS_DEBUG_MSG("\n");
945
946 ts = ts_hub;
947
948 if(ts == NULL) {
949 SYNAPTICS_ERR_MSG("ts is NULL\n");
950 return 0;
951 }
952
953 if(!strcmp(ts->product_id, ts->fw_product_id)) {
954 product_check = 1;
955 }
956 cur_ver = (int)simple_strtol(&ts->config_id[1], NULL, 10);
957 fw_ver = (int)simple_strtol(&ts->fw_config_id[1], NULL, 10);
958
959
960
961 SYNAPTICS_INFO_MSG("FW n: %d, %d\n", fw_ver, cur_ver);
962
963 if(ts->fw_path[0] != 0)
964 ret = 2; /* FW exist in file */
965 else if(ts->fw_force_upgrade == 1)
966 ret = 1; /* FW exist in buffer */
967 else if(product_check && (fw_ver > cur_ver))
968 ret = 1; /* FW exist in buffer */
969 else
970 ret = 0; /* No need to upgrade FW */
971
972
973 if( !ts_force_update_chk ) {
974 ret = 1;
975 ts_force_update_chk = 1;
976 }
977
978 SYNAPTICS_INFO_MSG("FW upgrade check: %d\n", ret);
979
980
981
982 return ret;
983 }
984
985 static void synaptics_ts_fw_upgrade(struct synaptics_ts_data *ts, const char* fw_path)
986 {
987 int ret = 0;
988 struct synaptics_ts_timestamp time_debug;
989
990 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FUNC_TRACE)
991 SYNAPTICS_DEBUG_MSG("\n");
992
993 if (likely(!ts->is_downloading)) {
994 ts->is_downloading = 1;
995 ts->is_probed = 0;
996 wake_lock(&fw_suspend_lock);
997
998 if (likely(!ts->is_suspended)) {
999 ts->ic_init = 0;
1000
1001 if (ts->pdata->use_irq)
1002 mt65xx_eint_mask(ts->pdata->irq_num);
1003 else
1004 hrtimer_cancel(&ts->timer);
1005 } else {
1006 if (ts->pdata->power) {
1007 ret = ts->pdata->power(1);
1008
1009 if (ret < 0) {
1010 SYNAPTICS_ERR_MSG("power on failed\n");
1011 } else {
1012 msleep(ts->pdata->ic_booting_delay);
1013 }
1014 }
1015 }
1016
1017 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_UPGRADE_DELAY) {
1018 memset(&time_debug, 0x0, sizeof(struct synaptics_ts_timestamp));
1019 atomic_set(&time_debug.ready, 1);
1020 time_debug.start = cpu_clock(smp_processor_id());
1021 }
1022
1023 ret = FirmwareUpgrade(ts, fw_path);
1024 if(ret < 0) {
1025 SYNAPTICS_ERR_MSG("Firmware upgrade Fail!!!\n");
1026 } else {
1027 SYNAPTICS_INFO_MSG("Firmware upgrade Complete\n");
1028 }
1029
1030 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_UPGRADE_DELAY) {
1031 if (atomic_read(&time_debug.ready) == 1) {
1032 time_debug.end = cpu_clock(smp_processor_id());
1033 time_debug.result_t = time_debug.end - time_debug.start;
1034 time_debug.rem = do_div(time_debug.result_t , 1000000000);
1035 SYNAPTICS_DEBUG_MSG("FW upgrade time < %2lu.%06lu\n", (unsigned long)time_debug.result_t, time_debug.rem/1000);
1036 atomic_set(&time_debug.ready, 0);
1037 }
1038 }
1039
1040 if (likely(!ts->is_suspended)) {
1041 if (ts->pdata->use_irq)
1042 mt65xx_eint_unmask(ts->pdata->irq_num);
1043 else
1044 hrtimer_start(&ts->timer, ktime_set(0, ts->pdata->report_period+(ts->pdata->ic_booting_delay*1000000)), HRTIMER_MODE_REL);
1045 }
1046
1047 memset(ts->fw_path, 0x00, sizeof(ts->fw_path));
1048 ts->fw_force_upgrade = 0;
1049
1050 if (likely(!ts->is_suspended)) {
1051 synaptics_ts_hard_reset(ts);
1052 } else {
1053 if (ts->pdata->power) {
1054 ret = ts->pdata->power(0);
1055
1056 if (ret < 0)
1057 SYNAPTICS_ERR_MSG("power on failed\n");
1058 }
1059 }
1060
1061 wake_unlock(&fw_suspend_lock);
1062 ts->is_downloading = 0;
1063 } else {
1064 SYNAPTICS_ERR_MSG("Firmware Upgrade process is aready working on\n");
1065 }
1066 }
1067
1068 static ssize_t show_version(struct device *dev, struct device_attribute *attr, char *buf)
1069 {
1070 struct synaptics_ts_data *ts;
1071
1072 ts = ts_hub;
1073
1074 if(ts == NULL) {
1075 SYNAPTICS_ERR_MSG("ts is NULL\n");
1076 return 0;
1077 }
1078
1079 return sprintf(buf, "%s : FW_VERSION, %s : HW_VERSION \n", ts->config_id, ts->product_id);
1080 }
1081 static DEVICE_ATTR(version, 0664, show_version, NULL);
1082
1083 static ssize_t store_firmware(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
1084 {
1085 struct synaptics_ts_data *ts;
1086 char path[256] = {0};
1087
1088 sscanf(buf, "%s", path);
1089
1090 ts = ts_hub;
1091
1092 if(ts == NULL) {
1093 SYNAPTICS_ERR_MSG("ts is NULL\n");
1094 return size;
1095 }
1096
1097 if(ts->pdata->use_irq)
1098 mt65xx_eint_mask(ts->pdata->irq_num);
1099 else
1100 hrtimer_cancel(&ts->timer);
1101
1102 ts->ic_init = 0;
1103 ts->is_probed = 0;
1104
1105 SYNAPTICS_DEBUG_MSG("Firmware image upgrade: %s\n", path);
1106
1107 if(!strncmp(path, "1", 1)) {
1108 ts->fw_force_upgrade = 1;
1109 }
1110 else {
1111 memcpy(ts->fw_path, path, sizeof(ts->fw_path));
1112 }
1113
1114 if(ts->is_suspended) {
1115 if(ts->pdata->power)
1116 ts->pdata->power(1);
1117 }
1118
1119 queue_delayed_work(synaptics_wq, &ts->work, msecs_to_jiffies(ts->pdata->ic_booting_delay));
1120
1121 while(ts->is_downloading);
1122
1123 return size;
1124 }
1125 static DEVICE_ATTR(firmware, 0664, NULL, store_firmware);
1126 #endif
1127
1128 static ssize_t show_log(struct device *dev, struct device_attribute *attr, char *buf)
1129 {
1130 return sprintf(buf, "0x%x\n", synaptics_rmi4_i2c_debug_mask);
1131 }
1132
1133 static ssize_t store_log(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
1134 {
1135 unsigned int mask;
1136
1137 sscanf(buf, "%x", &mask);
1138
1139 SYNAPTICS_DEBUG_MSG("debug mask: 0x%x\n", mask);
1140
1141 synaptics_rmi4_i2c_debug_mask = mask;
1142
1143 return size;
1144 }
1145 static DEVICE_ATTR(log, 0664, show_log, store_log);
1146
1147 #if defined(LGE_USE_SYNAPTICS_F54)
1148 static ssize_t show_f54(struct device *dev, struct device_attribute *attr, char *buf)
1149 {
1150 int ret = 0;
1151 struct synaptics_ts_data *ts;
1152
1153 ts = ts_hub;
1154
1155 if(ts == NULL) {
1156 SYNAPTICS_ERR_MSG("ts is NULL\n");
1157 return ret;
1158 }
1159
1160 if (ts->is_suspended == 0) {
1161 SYNA_PDTScan();
1162 SYNA_ConstructRMI_F54();
1163 SYNA_ConstructRMI_F1A();
1164
1165 ret = sprintf(buf, "====== F54 Function Info ======\n");
1166
1167 switch(f54_fullrawcap_mode)
1168 {
1169 case 0: ret += sprintf(buf+ret, "fullrawcap_mode = For sensor\n");
1170 break;
1171 case 1: ret += sprintf(buf+ret, "fullrawcap_mode = For FPC\n");
1172 break;
1173 case 2: ret += sprintf(buf+ret, "fullrawcap_mode = CheckTSPConnection\n");
1174 break;
1175 case 3: ret += sprintf(buf+ret, "fullrawcap_mode = Baseline\n");
1176 break;
1177 case 4: ret += sprintf(buf+ret, "fullrawcap_mode = Delta image\n");
1178 break;
1179 }
1180
1181 if(ts->pdata->use_irq)
1182 mt65xx_eint_mask(ts->pdata->irq_num);
1183 else
1184 hrtimer_cancel(&ts->timer);
1185
1186 ret += sprintf(buf+ret, "F54_FullRawCap(%d) Test Result: %s", f54_fullrawcap_mode, (F54_FullRawCap(f54_fullrawcap_mode) > 0) ? "Pass\n" : "Fail\n" );
1187 ret += sprintf(buf+ret, "F54_TxToTxReport() Test Result: %s", (F54_TxToTxReport() > 0) ? "Pass\n" : "Fail\n" );
1188 ret += sprintf(buf+ret, "F54_RxToRxReport() Test Result: %s", (F54_RxToRxReport() > 0) ? "Pass\n" : "Fail\n" );
1189 ret += sprintf(buf+ret, "F54_TxToGndReport() Test Result: %s", (F54_TxToGndReport() > 0) ? "Pass\n" : "Fail\n" );
1190 ret += sprintf(buf+ret, "F54_HighResistance() Test Result: %s", (F54_HighResistance() > 0) ? "Pass\n" : "Fail\n" );
1191
1192 if (ts->pdata->use_irq)
1193 mt65xx_eint_unmask(ts->pdata->irq_num);
1194 else
1195 hrtimer_start(&ts->timer, ktime_set(0, ts->pdata->report_period+(ts->pdata->ic_booting_delay*1000000)), HRTIMER_MODE_REL);
1196 } else {
1197 ret = sprintf(buf+ret, "state=[suspend]. we cannot use I2C, now. Test Result: Fail\n");
1198 }
1199
1200 return ret;
1201 }
1202
1203 static ssize_t store_f54(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
1204 {
1205 int ret = 0;
1206
1207 ret = sscanf(buf, "%d", &f54_fullrawcap_mode);
1208
1209 return size;
1210 }
1211 static DEVICE_ATTR(f54, 0664, show_f54, store_f54);
1212 #endif
1213
1214 void synaptics_ts_init_sysfs(void)
1215 {
1216 touch_class = class_create(THIS_MODULE, "touch");
1217 touch_debug_dev = device_create(touch_class, NULL, 0, NULL, "debug");
1218
1219 if(device_create_file(touch_debug_dev, &dev_attr_log) < 0) {
1220 SYNAPTICS_ERR_MSG("log device_create_file failed\n");
1221 }
1222
1223 #if defined(LGE_USE_SYNAPTICS_F54)
1224 if(device_create_file(touch_debug_dev, &dev_attr_f54) < 0) {
1225 SYNAPTICS_ERR_MSG("log device_create_file failed\n");
1226 }
1227 #endif
1228
1229 #if defined(LGE_USE_SYNAPTICS_FW_UPGRADE)
1230 touch_fw_dev = device_create(touch_class, NULL, 0, NULL, "firmware");
1231
1232 if(device_create_file(touch_fw_dev, &dev_attr_firmware) < 0) {
1233 SYNAPTICS_ERR_MSG("firmware device_create_file failed\n");
1234 }
1235
1236 if(device_create_file(touch_fw_dev, &dev_attr_version) < 0) {
1237 SYNAPTICS_ERR_MSG("version device_create_file failed\n");
1238 }
1239 #endif
1240 }
1241
1242 static enum hrtimer_restart synaptics_ts_timer_func(struct hrtimer *timer)
1243 {
1244 struct synaptics_ts_data *ts = container_of(timer, struct synaptics_ts_data, timer);
1245
1246 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FUNC_TRACE)
1247 SYNAPTICS_DEBUG_MSG("\n");
1248
1249 /* ignore irrelevant timer interrupt during IC power on */
1250 if (likely(ts->ic_init)) {
1251 queue_delayed_work(synaptics_wq, &ts->work, 0);
1252 hrtimer_start(&ts->timer, ktime_set(0, ts->pdata->report_period), HRTIMER_MODE_REL);
1253 }
1254
1255 return HRTIMER_NORESTART;
1256 }
1257
1258 static void read_page_description_table(struct synaptics_ts_data *ts)
1259 {
1260 /* Read config data */
1261 int ret = 0;
1262 ts_function_descriptor buffer;
1263 unsigned short u_address;
1264 u8 page_num;
1265
1266 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FUNC_TRACE)
1267 SYNAPTICS_DEBUG_MSG("\n");
1268
1269 memset(&buffer, 0x0, sizeof(ts_function_descriptor));
1270
1271 ts->common_dsc.id = 0;
1272 ts->finger_dsc.id = 0;
1273 ts->button_dsc.id = 0;
1274 ts->analog_dsc.id = 0;
1275 ts->flash_dsc.id = 0;
1276
1277 for(page_num = 0; page_num < PAGE_MAX_NUM; page_num++) {
1278 ret = i2c_smbus_write_byte_data(ts->client, PAGE_SELECT_REG, page_num);
1279 if (ret < 0)
1280 SYNAPTICS_ERR_MSG("PAGE_SELECT_REG write fail\n");
1281
1282 for(u_address = DESCRIPTION_TABLE_START; u_address > 10; u_address -= sizeof(ts_function_descriptor)) {
1283 ret = synaptics_ts_read(ts->client, u_address, sizeof(buffer), (unsigned char *)&buffer);
1284 if (ret < 0) {
1285 SYNAPTICS_ERR_MSG("ts_function_descriptor read fail\n");
1286 return;
1287 }
1288
1289 if (buffer.id == 0)
1290 break;
1291
1292 switch (buffer.id) {
1293 case RMI_DEVICE_CONTROL:
1294 ts->common_dsc = buffer;
1295 ts->common_page = page_num;
1296 break;
1297 case TOUCHPAD_SENSORS:
1298 ts->finger_dsc = buffer;
1299 ts->finger_page= page_num;
1300 break;
1301 case CAPACITIVE_BUTTON_SENSORS:
1302 ts->button_dsc = buffer;
1303 ts->button_page= page_num;
1304 break;
1305 case ANALOG_CONTROL:
1306 ts->analog_dsc = buffer;
1307 ts->analog_page = page_num;
1308 break;
1309 case FLASH_MEMORY_MANAGEMENT:
1310 ts->flash_dsc = buffer;
1311 ts->flash_page = page_num;
1312 break;
1313 }
1314 }
1315 }
1316
1317 ret = i2c_smbus_write_byte_data(ts->client, PAGE_SELECT_REG, 0x00);
1318 if (ret < 0)
1319 SYNAPTICS_ERR_MSG("PAGE_SELECT_REG write fail\n");
1320 }
1321
1322 static void synaptics_ts_button_lock_work_func(struct work_struct *button_lock_work)
1323 {
1324 struct synaptics_ts_data *ts = container_of(to_delayed_work(button_lock_work), struct synaptics_ts_data, button_lock_work);
1325 int ret;
1326
1327 ts->curr_int_mask = 0xFF;
1328 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_INT_STATUS)
1329 SYNAPTICS_DEBUG_MSG("Interrupt mask 0x%x\n", ts->curr_int_mask);
1330 ret = i2c_smbus_write_byte_data(ts->client, INTERRUPT_ENABLE_REG, ts->curr_int_mask);
1331 }
1332
1333 static void synaptics_ts_work_func(struct work_struct *work)
1334 {
1335 struct synaptics_ts_data *ts = container_of(to_delayed_work(work), struct synaptics_ts_data, work);
1336 int ret = 0;
1337 int width_max = 0, width_min = 0;
1338 int width_orientation = 0;
1339 unsigned int f_counter = 0;
1340 unsigned int b_counter = 0;
1341 unsigned int reg_num = 0;
1342 unsigned int finger_order = 0;
1343 u8 temp;
1344 char report_enable = 0;
1345 ts_sensor_ctrl ts_reg_ctrl;
1346 ts_sensor_data ts_reg_data;
1347 ts_finger_data curr_ts_data;
1348 u8 resolution[2] = {0};
1349 int index = 0;
1350 #if defined(LGE_USE_SYNAPTICS_FW_UPGRADE)
1351 u8 device_status = 0;
1352 u8 flash_control = 0;
1353 #endif
1354
1355 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FUNC_TRACE)
1356 SYNAPTICS_DEBUG_MSG("\n");
1357
1358 memset(&ts_reg_ctrl, 0x0, sizeof(ts_sensor_ctrl));
1359 memset(&ts_reg_data, 0x0, sizeof(ts_sensor_data));
1360 memset(&curr_ts_data, 0x0, sizeof(ts_finger_data));
1361 pressure_zero = 0;
1362
1363 if (ts->ic_init) {
1364 /* read device status */
1365 ret = synaptics_ts_read(ts->client, DEVICE_STATUS_REG, sizeof(unsigned char), (u8 *) &ts_reg_ctrl.device_status_reg);
1366 if (ret < 0) {
1367 SYNAPTICS_ERR_MSG("DEVICE_STATUS_REG read fail\n");
1368 goto exit_work;
1369 }
1370
1371 /* read interrupt status */
1372 ret = synaptics_ts_read(ts->client, INTERRUPT_STATUS_REG, sizeof(unsigned char), (u8 *) &ts_reg_ctrl.interrupt_status_reg);
1373 if (ret < 0) {
1374 SYNAPTICS_ERR_MSG("INTERRUPT_STATUS_REG read fail\n");
1375 goto exit_work;
1376 } else {
1377 if (!(synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_INT_INTERVAL)
1378 && (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_INT_ISR_DELAY)
1379 && !(synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FINGER_HANDLE_TIME)
1380 && !(synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_BUTTON_HANDLE_TIME)
1381 && (atomic_read(&ts->int_delay.ready) == 1)) {
1382 ts->int_delay.end = cpu_clock(smp_processor_id());
1383 ts->int_delay.result_t = ts->int_delay.end -ts->int_delay.start;
1384 ts->int_delay.rem = do_div(ts->int_delay.result_t , 1000000);
1385 SYNAPTICS_DEBUG_MSG("Touch IC interrupt line clear time < %3lu.%03lu\n", (unsigned long)ts->int_delay.result_t, ts->int_delay.rem/1000);
1386 }
1387 }
1388
1389 /* read button data */
1390 if (likely(ts->button_dsc.id != 0)) {
1391 ret = synaptics_ts_page_data_read(ts->client, BUTTON_PAGE, BUTTON_DATA_REG, sizeof(ts_reg_ctrl.button_data_reg), (u8 *)&ts_reg_ctrl.button_data_reg);
1392 if (ret < 0) {
1393 SYNAPTICS_ERR_MSG("BUTTON_DATA_REG read fail\n");
1394 goto exit_work;
1395 }
1396 }
1397
1398 /* read finger state & finger data register */
1399 ret = synaptics_ts_read(ts->client, FINGER_STATE_REG, sizeof(ts_reg_data) - ((MAX_NUM_OF_FINGER - ts->pdata->num_of_finger) * NUM_OF_EACH_FINGER_DATA_REG), (u8 *) &ts_reg_data.finger_state_reg[0]);
1400
1401 if (ret < 0) {
1402 SYNAPTICS_ERR_MSG("FINGER_STATE_REG read fail\n");
1403 goto exit_work;
1404 }
1405
1406 /* Palm check */
1407 ret = synaptics_ts_read(ts->client, TWO_D_EXTEND_STATUS, 1, &temp);
1408 if (ret < 0) {
1409 SYNAPTICS_ERR_MSG("TWO_D_EXTEND_STATUS read fail\n");
1410 goto exit_work;
1411 }
1412 old_ts_data.palm = ts->pre_ts_data.palm;
1413 ts->pre_ts_data.palm = temp & 0x2;
1414 /* ESD damage check */
1415 if ((ts_reg_ctrl.device_status_reg & DEVICE_FAILURE_MASK)== DEVICE_FAILURE_MASK) {
1416 SYNAPTICS_ERR_MSG("ESD damage occured. Reset Touch IC\n");
1417 ts->ic_init = 0;
1418 synaptics_ts_hard_reset(ts);
1419 return;
1420 }
1421
1422 /* Internal reset check */
1423 if (((ts_reg_ctrl.device_status_reg & DEVICE_STATUS_REG_UNCONFIGURED) >> 7) == 1) {
1424 SYNAPTICS_ERR_MSG("Touch IC resetted internally. Reconfigure register setting\n");
1425 ts->ic_init = 0;
1426 queue_delayed_work(synaptics_wq, &ts->work, 0);
1427 return;
1428 }
1429
1430 /* finger & button interrupt has no correlation */
1431 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_INT_STATUS)
1432 SYNAPTICS_DEBUG_MSG("Interrupt status register: 0x%x\n", ts_reg_ctrl.interrupt_status_reg);
1433
1434 ret = synaptics_ts_read(ts->client, INTERRUPT_ENABLE_REG, sizeof(ts->curr_int_mask), (u8 *) &ts->curr_int_mask);
1435
1436 if (ts_reg_ctrl.interrupt_status_reg & ts->int_status_reg_asb0_bit
1437 && ts->curr_int_mask & ts->int_status_reg_asb0_bit) { /* Finger */
1438 for(f_counter = 0; f_counter < ts->pdata->num_of_finger; f_counter++) {
1439 reg_num = f_counter/4;
1440 finger_order = f_counter%4;
1441
1442 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FINGER_REG) {
1443 if (finger_order == 0)
1444 SYNAPTICS_DEBUG_MSG("Finger status register%d: 0x%x\n",
1445 reg_num, ts_reg_data.finger_state_reg[reg_num]);
1446 }
1447
1448 if (((ts_reg_data.finger_state_reg[reg_num]>>(finger_order*2))
1449 & FINGER_STATE_MASK) == 1)
1450 {
1451 curr_ts_data.pos_x[f_counter] =
1452 (int)GET_X_POSITION(ts_reg_data.finger_data[f_counter][REG_X_POSITION],
1453 ts_reg_data.finger_data[f_counter][REG_YX_POSITION]);
1454 curr_ts_data.pos_y[f_counter] =
1455 (int)GET_Y_POSITION(ts_reg_data.finger_data[f_counter][REG_Y_POSITION],
1456 ts_reg_data.finger_data[f_counter][REG_YX_POSITION]);
1457
1458 if (((ts_reg_data.finger_data[f_counter][REG_WY_WX] & 0xF0) >> 4)
1459 > (ts_reg_data.finger_data[f_counter][REG_WY_WX] & 0x0F)) {
1460 width_max = (ts_reg_data.finger_data[f_counter][REG_WY_WX] & 0xF0) >> 4;
1461 width_min = ts_reg_data.finger_data[f_counter][REG_WY_WX] & 0x0F;
1462 width_orientation = 0;
1463 } else {
1464 width_max = ts_reg_data.finger_data[f_counter][REG_WY_WX] & 0x0F;
1465 width_min = (ts_reg_data.finger_data[f_counter][REG_WY_WX] & 0xF0) >> 4;
1466 width_orientation = 1;
1467 }
1468
1469 curr_ts_data.pressure[f_counter] = ts_reg_data.finger_data[f_counter][REG_Z];
1470
1471 if (ts->pdata->use_ghost_detection) {
1472 if (curr_ts_data.pressure[f_counter] == 0)
1473 pressure_zero = 1;
1474 }
1475 #if defined(MT_PROTOCOL_A)
1476 input_report_abs(ts->input_dev, ABS_MT_TRACKING_ID, f_counter);
1477 #else
1478 input_mt_slot(ts->input_dev, f_counter);
1479 input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, true);
1480 #endif
1481
1482 input_report_abs(ts->input_dev, ABS_MT_POSITION_X, curr_ts_data.pos_x[f_counter]);
1483 input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, curr_ts_data.pos_y[f_counter]);
1484 input_report_abs(ts->input_dev, ABS_MT_PRESSURE, curr_ts_data.pressure[f_counter]);
1485 input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, width_max);
1486 input_report_abs(ts->input_dev, ABS_MT_WIDTH_MINOR, width_min);
1487 input_report_abs(ts->input_dev, ABS_MT_ORIENTATION, width_orientation);
1488
1489 report_enable = 1;
1490 if (ts->finger_prestate[f_counter] == TOUCH_RELEASED) {
1491 finger_oldstate[f_counter] = ts->finger_prestate[f_counter];
1492 ts->finger_prestate[f_counter] = TOUCH_PRESSED;
1493 // if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FINGER_STATUS)
1494 SYNAPTICS_INFO_MSG("[Touch] Finger%d (%d,%d)pressed\n", f_counter, curr_ts_data.pos_x[f_counter], curr_ts_data.pos_y[f_counter]);
1495
1496 //LG_CHANGE_S : 20130805 ticklewind.kim@lge.com
1497 for (b_counter = 0; b_counter < ts->pdata->num_of_button; b_counter++)
1498 if ( ts->button_prestate[b_counter] == TOUCH_PRESSED )
1499 {
1500 input_report_key(ts->input_dev, ts->pdata->button[b_counter], BUTTON_CANCLED);
1501 if (likely(synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_BUTTON_STATUS))
1502 SYNAPTICS_INFO_MSG("Touch KEY[%d] is canceled\n", b_counter);
1503 ts->button_prestate[b_counter] = TOUCH_RELEASED;
1504 }
1505 //LG_CHANGE_E : 20130805 ticklewind.kim@lge.com
1506
1507 /* button interrupt disable when first finger pressed */
1508 if (ts->curr_int_mask & ts->int_status_reg_button_bit) {
1509 ret = cancel_delayed_work_sync(&ts->button_lock_work);
1510
1511 ts->curr_int_mask = ts->curr_int_mask & ~(ts->int_status_reg_button_bit);
1512 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_INT_STATUS)
1513 SYNAPTICS_DEBUG_MSG("Interrupt mask 0x%x\n", ts->curr_int_mask);
1514 ret = i2c_smbus_write_byte_data(ts->client, INTERRUPT_ENABLE_REG, ts->curr_int_mask);
1515 }
1516
1517 }
1518
1519 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FINGER_POSITION)
1520 SYNAPTICS_INFO_MSG("x:%4d, y:%4d, pressure:%4d\n", curr_ts_data.pos_x[f_counter], curr_ts_data.pos_y[f_counter], curr_ts_data.pressure[f_counter]);
1521
1522 old_ts_data.pos_x[f_counter]= ts->pre_ts_data.pos_x[f_counter];
1523 old_ts_data.pos_y[f_counter]= ts->pre_ts_data.pos_y[f_counter];
1524 old_ts_data.pressure[f_counter]= ts->pre_ts_data.pressure[f_counter];
1525 ts->pre_ts_data.pos_x[f_counter] = curr_ts_data.pos_x[f_counter];
1526 ts->pre_ts_data.pos_y[f_counter] = curr_ts_data.pos_y[f_counter];
1527 ts->pre_ts_data.pressure[f_counter] = curr_ts_data.pressure[f_counter];
1528 index++;
1529 } else if (ts->finger_prestate[f_counter] == TOUCH_PRESSED) {
1530 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FINGER_STATUS)
1531 SYNAPTICS_INFO_MSG("[Touch] Finger%d (%d, %d)released\n", f_counter, ts->pre_ts_data.pos_x[f_counter], ts->pre_ts_data.pos_y[f_counter]);
1532
1533
1534 #if !defined(MT_PROTOCOL_A)
1535 input_mt_slot(ts->input_dev, f_counter);
1536 input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, false);
1537 #endif
1538
1539 finger_oldstate[f_counter] = ts->finger_prestate[f_counter];
1540 ts->finger_prestate[f_counter] = TOUCH_RELEASED;
1541
1542 report_enable = 1;
1543
1544 if (ts_reg_data.finger_state_reg[0] == 0
1545 && ts_reg_data.finger_state_reg[1] == 0
1546 /*&& ts_reg_data.finger_state_reg[2] == 0*/) {
1547 /* button interrupt enable when all finger released */
1548 queue_delayed_work(synaptics_wq, &ts->button_lock_work, msecs_to_jiffies(200));
1549 }
1550
1551 ts->pre_ts_data.pos_x[f_counter] = 0;
1552 ts->pre_ts_data.pos_y[f_counter] = 0;
1553 }
1554 #if defined(MT_PROTOCOL_A)
1555 if (report_enable)
1556 input_mt_sync(ts->input_dev);
1557 #endif
1558 report_enable = 0;
1559 }
1560 curr_ts_data.total_num = index;
1561 old_ts_data.total_num = ts->pre_ts_data.total_num;
1562 ts->pre_ts_data.total_num = curr_ts_data.total_num;
1563
1564 input_sync(ts->input_dev);
1565
1566 if (!(synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_INT_INTERVAL)
1567 && !(synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_INT_ISR_DELAY)
1568 && (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FINGER_HANDLE_TIME)
1569 && !(synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_BUTTON_HANDLE_TIME)) {
1570 if (atomic_read(&ts->int_delay.ready) == 1) {
1571 ts->int_delay.end = cpu_clock(smp_processor_id());
1572 ts->int_delay.result_t = ts->int_delay.end - ts->int_delay.start;
1573 ts->int_delay.rem = do_div(ts->int_delay.result_t , 1000000);
1574 SYNAPTICS_DEBUG_MSG("Touch Finger data report done time < %3lu.%03lu\n", (unsigned long)ts->int_delay.result_t, ts->int_delay.rem/1000);
1575 }
1576 }
1577 }
1578
1579 ret = synaptics_ts_read(ts->client, INTERRUPT_ENABLE_REG, sizeof(ts->curr_int_mask), (u8 *) &ts->curr_int_mask);
1580
1581 if (likely(ts->button_dsc.id != 0)) {
1582 if (ts_reg_ctrl.interrupt_status_reg & ts->int_status_reg_button_bit
1583 && ts->curr_int_mask & ts->int_status_reg_button_bit) { /* Button */
1584
1585 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_BUTTON_REG)
1586 SYNAPTICS_DEBUG_MSG("Button register: 0x%x\n", ts_reg_ctrl.button_data_reg);
1587
1588 for (b_counter = 0; b_counter < ts->pdata->num_of_button; b_counter++) {
1589 if ( ((ts_reg_ctrl.button_data_reg >> b_counter) & 0x1) == 1 && (ts->button_prestate[b_counter] == TOUCH_RELEASED)) {
1590 button_oldstate[b_counter] = ts->button_prestate[b_counter];
1591
1592
1593 ts->button_prestate[b_counter] = TOUCH_PRESSED; /* pressed */
1594 report_enable = 1;
1595
1596 /* finger interrupt disable when button pressed */
1597 /*
1598 if (ts->curr_int_mask & ts->int_status_reg_asb0_bit) {
1599 ret = cancel_delayed_work_sync(&ts->button_lock_work);
1600
1601 ts->curr_int_mask = ts->curr_int_mask & ~(ts->int_status_reg_asb0_bit);
1602 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_INT_STATUS)
1603 SYNAPTICS_DEBUG_MSG("Interrupt mask 0x%x\n", ts->curr_int_mask);
1604 ret = i2c_smbus_write_byte_data(ts->client, INTERRUPT_ENABLE_REG, ts->curr_int_mask);
1605 }
1606 */
1607
1608
1609
1610 } else if(((ts_reg_ctrl.button_data_reg >> b_counter) & 0x1) == 0 && (ts->button_prestate[b_counter] == TOUCH_PRESSED)) {
1611 button_oldstate[b_counter] = ts->button_prestate[b_counter];
1612 ts->button_prestate[b_counter] = TOUCH_RELEASED; /* released */
1613 report_enable = 1;
1614 }
1615
1616 if (report_enable)
1617 input_report_key(ts->input_dev, ts->pdata->button[b_counter], ts->button_prestate[b_counter]);
1618
1619 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_BUTTON_STATUS) {
1620 if (report_enable)
1621 SYNAPTICS_INFO_MSG("Touch KEY%d(code:%d) is %s\n", b_counter, ts->pdata->button[b_counter], ts->button_prestate[b_counter]?"pressed":"released");
1622 }
1623 report_enable = 0;
1624 }
1625
1626 input_sync(ts->input_dev);
1627
1628 /* finger interrupt enable when all button released */
1629 if(ts_reg_ctrl.button_data_reg == 0) {
1630 queue_delayed_work(synaptics_wq, &ts->button_lock_work, msecs_to_jiffies(200));
1631 }
1632
1633 if (!(synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_INT_INTERVAL)
1634 && !(synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_INT_ISR_DELAY)
1635 && !(synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FINGER_HANDLE_TIME)
1636 && (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_BUTTON_HANDLE_TIME)) {
1637 if (atomic_read(&ts->int_delay.ready) == 1) {
1638 ts->int_delay.end = cpu_clock(smp_processor_id());
1639 ts->int_delay.result_t = ts->int_delay.end - ts->int_delay.start;
1640 ts->int_delay.rem = do_div(ts->int_delay.result_t , 1000000);
1641 SYNAPTICS_DEBUG_MSG("Touch Button data report done time < %3lu.%03lu\n",
1642 (unsigned long)ts->int_delay.result_t, ts->int_delay.rem/1000);
1643 }
1644 }
1645 }
1646 }
1647
1648 if (ts->pdata->use_ghost_detection) {
1649 ret = ghost_detect_solution();
1650 if(ret == NEED_TO_OUT)
1651 goto exit_work;
1652 else if(ret == NEED_TO_INIT) {
1653 release_all_ts_event();
1654 synaptics_ts_hard_reset(ts);
1655 synaptics_ts_ic_ctrl(ts->client, IC_CTRL_REPORT_MODE, CONTINUOUS_REPORT_MODE);
1656 force_continuous_mode = 1;
1657 ghost_detection = 0;
1658 ghost_detection_count = 0;
1659 do_gettimeofday(&t_ex_debug[TIME_EX_INIT_TIME]);
1660 return;
1661 }
1662 }
1663
1664 exit_work:
1665 atomic_dec(&ts->interrupt_handled);
1666 atomic_inc(&ts->int_delay.ready);
1667
1668 /* Safety code: Check interrupt line status */
1669 if (ts->pdata->use_irq != 0) {
1670 if (mt_get_gpio_in(ts->pdata->int_gpio) != 1
1671 && atomic_read(&ts->interrupt_handled) == 0) {
1672 /* interrupt line to high by Touch IC */
1673 ret = synaptics_ts_read(ts->client, INTERRUPT_STATUS_REG, 1, &temp);
1674 if (ret < 0)
1675 SYNAPTICS_ERR_MSG("INTERRUPT_STATUS_REG read fail\n");
1676
1677 /* FIXME:
1678 * We haven't seen this error case.
1679 * So, can not sure it is OK or have to force re-scanning touch IC.
1680 */
1681 SYNAPTICS_ERR_MSG("WARNING - Safety: Interrupt line isn't set high on time cause unexpected incident\n");
1682 }
1683 }
1684
1685 if ((synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_INT_INTERVAL)
1686 || (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_INT_ISR_DELAY)
1687 || (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FINGER_HANDLE_TIME)
1688 || (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_BUTTON_HANDLE_TIME)) {
1689 /* clear when all event is released */
1690 if (likely(ts->button_dsc.id == 0)) {
1691 if (ts_reg_data.finger_state_reg[0] == 0
1692 && ts_reg_data.finger_state_reg[1] == 0
1693 /*&& ts_reg_data.finger_state_reg[2] == 0*/
1694 && ts_reg_ctrl.button_data_reg == 0
1695 && atomic_read(&ts->interrupt_handled) == 0)
1696 atomic_set(&ts->int_delay.ready, 0);
1697 } else {
1698 if (ts_reg_data.finger_state_reg[0] == 0
1699 && ts_reg_data.finger_state_reg[1] == 0
1700 /*&& ts_reg_data.finger_state_reg[2] == 0*/
1701 && atomic_read(&ts->interrupt_handled) == 0)
1702 atomic_set(&ts->int_delay.ready, 0);
1703 }
1704 }
1705 } else {
1706 /* Touch IC init */
1707 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FUNC_TRACE)
1708 SYNAPTICS_DEBUG_MSG("Touch IC init vale setting\n");
1709
1710 /* check device existence using I2C read */
1711 if (!ts->is_probed) {
1712 /* find register map */
1713 read_page_description_table(ts);
1714
1715 /* define button & finger interrupt maks */
1716 if (likely(ts->button_dsc.id != 0)) {
1717 ts->int_status_reg_asb0_bit = 0x4;
1718 ts->int_status_reg_button_bit = 0x10;
1719 } else {
1720 ts->int_status_reg_asb0_bit = 0x4;
1721 }
1722
1723 ret = synaptics_ts_read(ts->client, MANUFACTURER_ID_REG, 1, &ts->manufcturer_id);
1724 if (ret < 0)
1725 SYNAPTICS_ERR_MSG("Manufcturer ID read fail\n");
1726 SYNAPTICS_INFO_MSG("Manufcturer ID: %d\n", ts->manufcturer_id);
1727
1728 ret = synaptics_ts_read(ts->client, FW_REVISION_REG, 1, &ts->fw_rev);
1729 if (ret < 0)
1730 SYNAPTICS_ERR_MSG("FW revision read fail\n");
1731 SYNAPTICS_INFO_MSG("FW revision: %d\n", ts->fw_rev);
1732
1733 ret = synaptics_ts_read(ts->client, PRODUCT_ID_REG, 10, &ts->product_id[0]); //depend on kernel in the file (i2c.h)
1734 if (ret < 0)
1735 SYNAPTICS_ERR_MSG("Product ID read fail\n");
1736 SYNAPTICS_INFO_MSG("Product ID: %s\n", ts->product_id);
1737
1738 ret = synaptics_ts_read(ts->client, FLASH_CONFIG_ID_REG, sizeof(ts->config_id)-1, &ts->config_id[0]);
1739 if (ret < 0)
1740 SYNAPTICS_ERR_MSG("Config ID read fail\n");
1741 SYNAPTICS_INFO_MSG("Config ID: %s\n", ts->config_id);
1742
1743 ret = synaptics_ts_read(ts->client, SENSOR_MAX_X_POS, sizeof(resolution), resolution);
1744 if (ret < 0)
1745 SYNAPTICS_ERR_MSG("SENSOR_MAX_X_POS read fail\n");
1746 SYNAPTICS_INFO_MSG("SENSOR_MAX_X=%d\n", (int)(resolution[1] << 8 | resolution[0]));
1747
1748 ret = synaptics_ts_read(ts->client, SENSOR_MAX_Y_POS, sizeof(resolution), resolution);
1749 if (ret < 0)
1750 SYNAPTICS_ERR_MSG("SENSOR_MAX_Y_POS read fail\n");
1751 SYNAPTICS_INFO_MSG("SENSOR_MAX_Y=%d\n", (int)(resolution[1] << 8 | resolution[0]));
1752
1753 #if defined(LGE_USE_SYNAPTICS_FW_UPGRADE)
1754 ts->fw_start = (unsigned char *)&SynaFirmware[0];
1755 ts->fw_size = sizeof(SynaFirmware);
1756
1757 strncpy(ts->fw_config_id, &SynaFirmware[0xb100], 4);
1758 strncpy(ts->fw_product_id, &SynaFirmware[0x0040], 6);
1759
1760 SYNAPTICS_INFO_MSG("fw_rev:%d, fw_config_id:%s, fw_product_id:%s\n", ts->fw_start[31], ts->fw_config_id, ts->fw_product_id);
1761
1762 ret = synaptics_ts_read(ts->client, FLASH_CONTROL_REG, sizeof(flash_control), &flash_control);
1763 if (ret < 0)
1764 SYNAPTICS_ERR_MSG("FLASH_CONTROL_REG read fail\n");
1765
1766 ret = synaptics_ts_read(ts->client, DEVICE_STATUS_REG, sizeof(device_status), &device_status);
1767 if (ret < 0)
1768 SYNAPTICS_ERR_MSG("DEVICE_STATUS_REG read fail\n");
1769
1770 /* Firmware has a problem, so we should firmware-upgrade */
1771 if(device_status & DEVICE_STATUS_FLASH_PROG || (device_status & DEVICE_CRC_ERROR_MASK) != 0 || (flash_control & FLASH_STATUS_MASK) != 0) {
1772 SYNAPTICS_ERR_MSG("Firmware has a unknown-problem, so it needs firmware-upgrade.\n");
1773 SYNAPTICS_ERR_MSG("FLASH_CONTROL[%x] DEVICE_STATUS_REG[%x]\n", (u32)flash_control, (u32)device_status);
1774 SYNAPTICS_ERR_MSG("FW-upgrade Force Rework.\n");
1775
1776 /* firmware version info change by force for rework */
1777 snprintf(ts->fw_config_id, sizeof(ts->fw_config_id), "ERR");
1778 ts->fw_force_upgrade = 1;
1779 }
1780
1781 ret = synaptics_ts_need_fw_upgrade();
1782 if(ret != 0) {
1783 synaptics_ts_fw_upgrade(ts, ts->fw_path);
1784 return;
1785 }
1786 #endif
1787 ts->is_probed = 1;
1788 }
1789
1790 ret = i2c_smbus_write_byte_data(ts->client, DEVICE_CONTROL_REG, (DEVICE_CONTROL_REG_NOSLEEP | DEVICE_CONTROL_REG_CONFIGURED));
1791 if (ret < 0)
1792 SYNAPTICS_ERR_MSG("DEVICE_CONTROL_REG write fail\n");
1793
1794 ret = synaptics_ts_read(ts->client, DEVICE_CONTROL_REG, 1, &temp);
1795 if (ret < 0)
1796 SYNAPTICS_ERR_MSG("DEVICE_CONTROL_REG read fail\n");
1797 SYNAPTICS_INFO_MSG("DEVICE_CONTROL_REG = %x\n", temp);
1798
1799 ret = synaptics_ts_read(ts->client, INTERRUPT_ENABLE_REG, 1, &temp);
1800 if (ret < 0)
1801 SYNAPTICS_ERR_MSG("INTERRUPT_ENABLE_REG read fail\n");
1802 SYNAPTICS_INFO_MSG("INTERRUPT_ENABLE_REG = %x\n", temp);
1803
1804 ret = i2c_smbus_write_byte_data(ts->client, INTERRUPT_ENABLE_REG, (temp | ts->int_status_reg_asb0_bit | ts->int_status_reg_button_bit));
1805 if (ret < 0)
1806 SYNAPTICS_ERR_MSG("GESTURE_ENABLE_1_REG write fail\n");
1807
1808 ret = i2c_smbus_write_byte_data(ts->client, TWO_D_REPORTING_MODE, (ts->pdata->report_mode | ABS_MODE | REPORT_BEYOND_CLIP));
1809 if (ret < 0)
1810 SYNAPTICS_ERR_MSG("TWO_D_REPORTING_MODE write fail\n");
1811
1812 ret = i2c_smbus_write_byte_data(ts->client, DELTA_X_THRESH_REG, (u8)ts->pdata->delta_pos_threshold);
1813 if (ret < 0)
1814 SYNAPTICS_ERR_MSG("DELTA_X_THRESH_REG write fail\n");
1815
1816 ret = i2c_smbus_write_byte_data(ts->client, DELTA_Y_THRESH_REG, (u8)ts->pdata->delta_pos_threshold);
1817 if (ret < 0)
1818 SYNAPTICS_ERR_MSG("DELTA_Y_THRESH_REG write fail\n");
1819
1820 ret = synaptics_ts_read(ts->client, SMALL_OBJECT_DETECTION_TUNNING_REG, 1, &temp);
1821 if (ret < 0)
1822 SYNAPTICS_ERR_MSG("SMALL_OBJECT_DETECTION_TUNNING_REG read fail\n");
1823 SYNAPTICS_INFO_MSG("SMALL_OBJECT_DETECTION_TUNNING_REG = %x\n", temp);
1824
1825 ret = synaptics_ts_read(ts->client, INTERRUPT_STATUS_REG, 1, &temp);
1826 if (ret < 0)
1827 SYNAPTICS_ERR_MSG("INTERRUPT_STATUS_REG read fail\n");
1828 if (ts->pdata->use_ghost_detection) {
1829 synaptics_ts_ic_ctrl(ts->client, IC_CTRL_REPORT_MODE, REDUCED_REPORT_MODE);
1830 force_continuous_mode = 1;
1831 ghost_detection = 0;
1832 ghost_detection_count = 0;
1833 do_gettimeofday(&t_ex_debug[TIME_EX_INIT_TIME]);
1834 }
1835 ts->ic_init = 1;
1836 }
1837 }
1838
1839 static void synaptics_eint_interrupt_handler(void)
1840 {
1841 struct synaptics_ts_data *ts;
1842
1843 ts = ts_hub;
1844
1845 if(ts == NULL) {
1846 SYNAPTICS_ERR_MSG("ts is NULL\n");
1847 return;
1848 }
1849
1850 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FUNC_TRACE)
1851 SYNAPTICS_DEBUG_MSG(": %d\n", ts->ic_init);
1852
1853 if (likely(ts->ic_init)) {
1854 if (ts->pdata->use_irq)
1855 mt65xx_eint_mask(ts->pdata->irq_num);
1856
1857 synaptics_tpd_flag = 1;
1858 wake_up_interruptible(&synaptics_waiter);
1859
1860 if (ts->pdata->use_irq)
1861 mt65xx_eint_unmask(ts->pdata->irq_num);
1862 }
1863 }
1864
1865 static int synaptics_touch_event_handler(void *unused)
1866 {
1867 struct sched_param param = {.sched_priority = RTPM_PRIO_TPD};
1868 struct synaptics_ts_data *ts;
1869
1870 sched_setscheduler(current, SCHED_RR, &param);
1871
1872 do
1873 {
1874 set_current_state(TASK_INTERRUPTIBLE);
1875 wait_event_interruptible(synaptics_waiter, (synaptics_tpd_flag != 0));
1876 synaptics_tpd_flag = 0;
1877 ts = ts_hub;
1878 if(ts != NULL) {
1879 set_current_state(TASK_RUNNING);
1880 queue_delayed_work(synaptics_wq, &ts->work, 0);
1881 }
1882
1883 }while(!kthread_should_stop());
1884
1885 return 0;
1886 }
1887
1888 static int synaptics_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)
1889 {
1890 struct synaptics_ts_platform_data *pdata;
1891 struct synaptics_ts_data *ts;
1892 int ret = 0;
1893 int count = 0;
1894 int err = 0;
1895 char temp;
1896 struct task_struct *thread = NULL;
1897
1898
1899 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FUNC_TRACE)
1900 SYNAPTICS_DEBUG_MSG("\n");
1901
1902 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
1903 SYNAPTICS_ERR_MSG("i2c functionality check error\n");
1904 ret = -ENODEV;
1905 goto err_check_functionality_failed;
1906 }
1907
1908 pdata = client->dev.platform_data;
1909 if (pdata == NULL) {
1910 SYNAPTICS_ERR_MSG("Can not read platform data\n");
1911 ret = -ENODEV;
1912 goto err_check_functionality_failed;
1913 }
1914
1915 ts = kzalloc(sizeof(*ts), GFP_KERNEL);
1916 if (ts == NULL) {
1917 SYNAPTICS_ERR_MSG("Can not allocate memory\n");
1918 ret = -ENOMEM;
1919 goto err_alloc_data_failed;
1920 }
1921
1922 /* Device data setting */
1923 ts->pdata = pdata;
1924 //ts->button_width = (ts->pdata->x_max - (ts->pdata->num_of_button - 1) * BUTTON_MARGIN) / ts->pdata->num_of_button;
1925
1926 synaptics_ts_init_sysfs();
1927 #if defined(LGE_USE_SYNAPTICS_FW_UPGRADE)
1928 wake_lock_init(&fw_suspend_lock, WAKE_LOCK_SUSPEND, "fw_wakelock");
1929 #endif
1930 INIT_DELAYED_WORK(&ts->work, synaptics_ts_work_func);
1931 INIT_DELAYED_WORK(&ts->button_lock_work, synaptics_ts_button_lock_work_func);
1932 ts->client = client;
1933 i2c_set_clientdata(client, ts);
1934 ts_hub = ts;
1935 #if defined(LGE_USE_SYNAPTICS_F54)
1936 ds4_i2c_client = client;
1937 #endif
1938
1939 tpd_load_status = 1;
1940
1941 synaptics_ts_reset(ts->pdata->reset_gpio);
1942
1943 if (ts->pdata->power) {
1944 ret = ts->pdata->power(1);
1945
1946 if (ret < 0) {
1947 SYNAPTICS_ERR_MSG("power on failed\n");
1948 goto err_power_failed;
1949 }
1950 }
1951
1952 ts->input_dev = input_allocate_device();
1953 if (ts->input_dev == NULL) {
1954 ret = -ENOMEM;
1955 SYNAPTICS_ERR_MSG("Failed to allocate input device\n");
1956 goto err_input_dev_alloc_failed;
1957 }
1958
1959 ts->input_dev->name = "synaptics_ts"; //driver name
1960
1961 set_bit(EV_SYN, ts->input_dev->evbit);
1962 set_bit(EV_KEY, ts->input_dev->evbit);
1963 set_bit(EV_ABS, ts->input_dev->evbit);
1964 set_bit(INPUT_PROP_DIRECT, ts->input_dev->propbit);
1965
1966 for(count = 0; count < ts->pdata->num_of_button; count++) {
1967 set_bit(ts->pdata->button[count], ts->input_dev->keybit);
1968 }
1969
1970 input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X, 0, ts->pdata->x_max, 0, 0);
1971 input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y, 0, ts->pdata->y_max, 0, 0);
1972 input_set_abs_params(ts->input_dev, ABS_MT_PRESSURE, 0, 255, 0, 0);
1973 input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0, 15, 0, 0);
1974 input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MINOR, 0, 15, 0, 0);
1975 #if defined(MT_PROTOCOL_A)
1976 input_set_abs_params(ts->input_dev, ABS_MT_TRACKING_ID, 0, 10, 0, 0);
1977 #else
1978 input_mt_init_slots(ts->input_dev, ts->pdata->num_of_finger);
1979 #endif
1980 input_set_abs_params(ts->input_dev, ABS_MT_ORIENTATION, 0, 1, 0, 0);
1981
1982 ret = input_register_device(ts->input_dev);
1983 if (ret < 0) {
1984 SYNAPTICS_ERR_MSG("Unable to register %s input device\n",
1985 ts->input_dev->name);
1986 goto err_input_register_device_failed;
1987 }
1988
1989 /* interrupt mode */
1990 if (likely(ts->pdata->use_irq && ts->pdata->irq_num)) {
1991 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FUNC_TRACE)
1992 SYNAPTICS_DEBUG_MSG("irq [%d], irqflags[0x%lx]\n", client->irq, ts->pdata->irqflags);
1993
1994 thread = kthread_run(synaptics_touch_event_handler, 0, TPD_DEVICE);
1995 if (IS_ERR(thread)) {
1996 err = PTR_ERR(thread);
1997 SYNAPTICS_ERR_MSG("failed to create kernel thread: %d\n", err);
1998 }
1999
2000 mt_set_gpio_mode(ts->pdata->int_gpio, GPIO_CTP_EINT_PIN_M_EINT);
2001 mt_set_gpio_dir(ts->pdata->int_gpio, GPIO_DIR_IN);
2002 mt_set_gpio_pull_enable(ts->pdata->int_gpio, GPIO_PULL_ENABLE);
2003 mt_set_gpio_pull_select(ts->pdata->int_gpio, GPIO_PULL_UP);
2004
2005 mt65xx_eint_set_sens(ts->pdata->irq_num, CUST_EINT_TOUCH_PANEL_SENSITIVE);
2006 mt65xx_eint_set_hw_debounce(ts->pdata->irq_num, CUST_EINT_TOUCH_PANEL_DEBOUNCE_CN);
2007 mt65xx_eint_registration(ts->pdata->irq_num, CUST_EINT_TOUCH_PANEL_DEBOUNCE_EN, ts->pdata->irqflags, synaptics_eint_interrupt_handler, 1);
2008 mt65xx_eint_unmask(ts->pdata->irq_num);
2009
2010
2011 if (ret < 0) {
2012 ts->pdata->use_irq = 0;
2013 SYNAPTICS_ERR_MSG("request_irq failed. use polling mode\n");
2014 } else {
2015 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FUNC_TRACE)
2016 SYNAPTICS_DEBUG_MSG("request_irq succeed\n");
2017 }
2018 } else {
2019 ts->pdata->use_irq = 0;
2020 }
2021
2022 /* using hrtimer case of polling mode */
2023 if (unlikely(!ts->pdata->use_irq)) {
2024 hrtimer_init(&ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
2025 ts->timer.function = synaptics_ts_timer_func;
2026 hrtimer_start(&ts->timer, ktime_set(0, (ts->pdata->report_period * 2) + (ts->pdata->ic_booting_delay*1000000)), HRTIMER_MODE_REL);
2027 }
2028
2029 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FUNC_TRACE)
2030 SYNAPTICS_DEBUG_MSG("Start touchscreen %s in %s mode\n", ts->input_dev->name, ts->pdata->use_irq ? "interrupt" : "polling");
2031
2032 /* Touch I2C sanity check */
2033 msleep(ts->pdata->ic_booting_delay);
2034 ret = synaptics_ts_read(ts->client, DESCRIPTION_TABLE_START, 1, &temp);
2035 if (ret < 0) {
2036 SYNAPTICS_ERR_MSG("ts_function_descriptor read fail\n");
2037 goto err_input_register_device_failed;
2038 }
2039
2040 /* Touch IC init setting */
2041 queue_delayed_work(synaptics_wq, &ts->work, 0);
2042 return 0;
2043
2044 err_input_register_device_failed:
2045 input_free_device(ts->input_dev);
2046 err_input_dev_alloc_failed:
2047 if (ts->pdata->power)
2048 ts->pdata->power(0);
2049 err_power_failed:
2050 kfree(ts);
2051 ts_hub = NULL;
2052 err_alloc_data_failed:
2053 err_check_functionality_failed:
2054 return ret;
2055 }
2056
2057 static int synaptics_ts_remove(struct i2c_client *client)
2058 {
2059 struct synaptics_ts_data *ts = i2c_get_clientdata(client);
2060
2061 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FUNC_TRACE)
2062 SYNAPTICS_DEBUG_MSG("\n");
2063
2064 if (ts->pdata->use_irq) {
2065 //free_irq(client->irq, ts);
2066 }
2067 else {
2068 hrtimer_cancel(&ts->timer);
2069 }
2070
2071 input_unregister_device(ts->input_dev);
2072 kfree(ts);
2073
2074 return 0;
2075 }
2076
2077 static void synaptics_ts_suspend_func(struct synaptics_ts_data *ts)
2078 {
2079
2080 int ret = 0;
2081 unsigned int f_counter = 0;
2082 unsigned int b_counter = 0;
2083 char report_enable = 0;
2084
2085 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FUNC_TRACE)
2086 SYNAPTICS_DEBUG_MSG("\n");
2087
2088 if (ts->pdata->use_irq)
2089 mt65xx_eint_mask(ts->pdata->irq_num);
2090 else
2091 hrtimer_cancel(&ts->timer);
2092
2093 ret = cancel_delayed_work_sync(&ts->work);
2094
2095 ret = i2c_smbus_write_byte_data(ts->client, DEVICE_CONTROL_REG, DEVICE_CONTROL_REG_SLEEP); /* sleep */
2096
2097 /* Ghost finger & missed release event defense code
2098 * Release report if we have not released event until suspend
2099 */
2100
2101 /* Finger check */
2102 for(f_counter = 0; f_counter < ts->pdata->num_of_finger; f_counter++) {
2103 if (ts->finger_prestate[f_counter] == TOUCH_PRESSED) {
2104 #if defined(MT_PROTOCOL_A)
2105 input_report_abs(ts->input_dev, ABS_MT_POSITION_X, ts->pre_ts_data.pos_x[f_counter]);
2106 input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, ts->pre_ts_data.pos_y[f_counter]);
2107 input_report_abs(ts->input_dev, ABS_MT_PRESSURE, TOUCH_RELEASED);
2108 input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, TOUCH_RELEASED);
2109
2110 #else
2111 input_mt_slot(ts->input_dev, f_counter);
2112 input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, false);
2113 #endif
2114
2115 report_enable = 1;
2116 }
2117 }
2118
2119 /* Button check */
2120 for(b_counter = 0; b_counter < ts->pdata->num_of_button; b_counter++) {
2121 if (ts->button_prestate[b_counter] == TOUCH_PRESSED) {
2122 report_enable = 1;
2123 input_report_key(ts->input_dev,
2124 ts->pdata->button[b_counter], TOUCH_RELEASED);
2125 }
2126 }
2127
2128 /* Reset finger position data */
2129 memset(&ts->pre_ts_data, 0x0, sizeof(ts_finger_data));
2130
2131 if (report_enable) {
2132 SYNAPTICS_INFO_MSG("Release all pressed event before touch power off\n");
2133 input_sync(ts->input_dev);
2134
2135 /* Reset finger & button status data */
2136 memset(ts->finger_prestate, 0x0, sizeof(char) * ts->pdata->num_of_finger);
2137 memset(ts->button_prestate, 0x0, sizeof(char) * ts->pdata->num_of_button);
2138 }
2139
2140 /* Reset interrupt debug time struct */
2141 if ((synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_INT_INTERVAL)
2142 || (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_INT_ISR_DELAY)
2143 || (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FINGER_HANDLE_TIME)
2144 || (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_BUTTON_HANDLE_TIME))
2145 memset(&ts->int_delay, 0x0, sizeof(struct synaptics_ts_timestamp));
2146
2147 if (ts->pdata->power) {
2148 ret = ts->pdata->power(0);
2149
2150 if (ret < 0) {
2151 SYNAPTICS_ERR_MSG("power off failed\n");
2152 } else {
2153 ts->ic_init = 0;
2154 atomic_set(&ts->interrupt_handled, 0);
2155 }
2156 }
2157 }
2158
2159 static void synaptics_ts_resume_func(struct synaptics_ts_data *ts)
2160 {
2161 int ret = 0;
2162
2163 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FUNC_TRACE)
2164 SYNAPTICS_DEBUG_MSG("\n");
2165
2166 if (ts->pdata->power) {
2167 ret = ts->pdata->power(1);
2168
2169 if (ret < 0)
2170 SYNAPTICS_ERR_MSG("power on failed\n");
2171 }
2172
2173 queue_delayed_work(synaptics_wq, &ts->work,msecs_to_jiffies(ts->pdata->ic_booting_delay));
2174
2175 if ( !synaptics_tpd_keylock_flag )
2176 {
2177 if (ts->pdata->use_irq)
2178 mt65xx_eint_unmask(ts->pdata->irq_num);
2179 else
2180 hrtimer_start(&ts->timer, ktime_set(0, ts->pdata->report_period+(ts->pdata->ic_booting_delay*1000000)), HRTIMER_MODE_REL);
2181 }
2182 }
2183
2184 int touch_power_control(int on)
2185 {
2186 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FUNC_TRACE)
2187 SYNAPTICS_DEBUG_MSG(": %d\n", on);
2188
2189 if(on)
2190 hwPowerOn(MT6323_POWER_LDO_VGP2, VOL_3000, "TP");
2191 else
2192 hwPowerDown(MT6323_POWER_LDO_VGP2, "TP");
2193
2194 return 0;
2195 }
2196
2197 #ifdef CONFIG_HAS_EARLYSUSPEND
2198 static void synaptics_tpd_suspend(struct early_suspend *h)
2199 {
2200 struct synaptics_ts_data *ts = ts_hub;
2201
2202 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FUNC_TRACE)
2203 SYNAPTICS_DEBUG_MSG("\n");
2204
2205 if(ts == NULL) {
2206 SYNAPTICS_ERR_MSG("ts is NULL\n");
2207 return;
2208 }
2209
2210 if (ts->pdata->use_ghost_detection) {
2211 resume_flag = 0;
2212 }
2213
2214 if (likely(!ts->is_downloading))
2215 synaptics_ts_suspend_func(ts);
2216
2217 ts->is_suspended = 1;
2218 }
2219
2220 static void synaptics_tpd_resume(struct early_suspend *h)
2221 {
2222 struct synaptics_ts_data *ts = ts_hub;
2223
2224 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FUNC_TRACE)
2225 SYNAPTICS_DEBUG_MSG ("\n");
2226
2227 if(ts == NULL) {
2228 SYNAPTICS_ERR_MSG("ts is NULL\n");
2229 return;
2230 }
2231
2232 if (ts->pdata->use_ghost_detection) {
2233 resume_flag = 1;
2234 ts_rebase_count = 0;
2235 }
2236
2237 if (likely(!ts->is_downloading))
2238 synaptics_ts_resume_func(ts);
2239
2240 ts->is_suspended = 0;
2241 }
2242 #else
2243 static int synaptics_ts_suspend(struct i2c_client *client, pm_message_t mesg)
2244 {
2245 return 0;
2246 }
2247
2248 static int synaptics_ts_resume(struct i2c_client *client)
2249 {
2250 return 0;
2251 }
2252 #endif
2253
2254
2255 static const struct i2c_device_id synaptics_ts_id[] = {
2256 {"mtk-tpd", 0},
2257 {},
2258 };
2259
2260 static struct i2c_driver synaptics_ts_driver = {
2261 .probe = synaptics_ts_probe,
2262 .remove = synaptics_ts_remove,
2263
2264 #ifndef CONFIG_HAS_EARLYSUSPEND
2265 .suspend = synaptics_ts_suspend,
2266 .resume = synaptics_ts_resume,
2267 #endif
2268 .id_table = synaptics_ts_id,
2269 .driver = {
2270 .name = "mtk-tpd",
2271 .owner = THIS_MODULE,
2272 },
2273 };
2274
2275
2276 int synaptics_tpd_local_init(void)
2277 {
2278 int ret = 0;
2279
2280 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FUNC_TRACE)
2281 SYNAPTICS_DEBUG_MSG("\n");
2282
2283 if(i2c_add_driver(&synaptics_ts_driver)!= 0) {
2284 SYNAPTICS_ERR_MSG("FAIL: i2c_add_driver\n");
2285 return -1;
2286 }
2287
2288 return ret;
2289 }
2290
2291
2292 static struct tpd_driver_t tpd_device_driver = {
2293 .tpd_device_name = "synaptics_2202",
2294 .tpd_local_init = synaptics_tpd_local_init,
2295 #ifdef CONFIG_HAS_EARLYSUSPEND
2296 .suspend = synaptics_tpd_suspend,
2297 .resume = synaptics_tpd_resume,
2298 #endif
2299 #ifdef TPD_HAVE_BUTTON
2300 .tpd_have_button = 1,
2301 #else
2302 .tpd_have_button = 0,
2303 #endif
2304 };
2305
2306 static struct synaptics_ts_platform_data l50_ts_data = {
2307 .use_irq = 1,
2308 .irqflags = CUST_EINT_TOUCH_PANEL_POLARITY,
2309 .irq_num = CUST_EINT_TOUCH_PANEL_NUM,
2310 .int_gpio = GPIO_CTP_EINT_PIN,
2311 .reset_gpio = GPIO_TOUCH_RESET_N,
2312 .power = touch_power_control,
2313 .ic_booting_delay = 100, /* ms */
2314 .report_period = 10000000, /* ns */
2315 .num_of_finger = MAX_NUM_OF_FINGER,
2316 #if defined(LGE_USE_DOME_KEY)
2317 .num_of_button = 2,
2318 .button = {KEY_BACK,KEY_MENU},
2319 #else
2320 .num_of_button = 4,
2321 .button = {KEY_BACK,KEY_HOMEPAGE,KEY_MENU},
2322 #endif
2323 .x_max = 479,
2324 .y_max = 799,
2325 .fw_ver = 0,
2326 .palm_threshold = 1,
2327 .delta_pos_threshold = 1,
2328 #if defined(LGE_USE_DOME_KEY)
2329 .use_ghost_detection = 0,
2330 #else
2331 .use_ghost_detection = 0,
2332 #endif
2333 .report_mode = REDUCED_REPORT_MODE,
2334 };
2335
2336 static struct i2c_board_info __initdata i2c_synaptics[] = {
2337 [0] = {
2338 I2C_BOARD_INFO("mtk-tpd", 0x20),
2339 .platform_data = &l50_ts_data,
2340 },
2341 };
2342
2343
2344 static int __devinit synaptics_ts_init(void)
2345 {
2346 int ret = 0;
2347
2348 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FUNC_TRACE)
2349 SYNAPTICS_DEBUG_MSG("\n");
2350
2351 synaptics_wq = create_singlethread_workqueue("synaptics_wq");
2352 if (!synaptics_wq) {
2353 SYNAPTICS_ERR_MSG("failed to create singlethread workqueue\n");
2354 return -ENOMEM;
2355 }
2356 #if 1
2357 I2CDMABuf_va = (u8 *)dma_alloc_coherent(NULL, 4096, &I2CDMABuf_pa, GFP_KERNEL);
2358 if(!I2CDMABuf_va) {
2359 SYNAPTICS_ERR_MSG("Allocate Touch DMA I2C Buffer failed!\n");
2360 return ENOMEM;
2361 }
2362 #endif // 1
2363
2364 #if defined(LGE_USE_SYNAPTICS_RED_ON_MTK)
2365 red_i2c_device_setup();
2366 #else
2367 i2c_register_board_info(1, &i2c_synaptics[0], 1);
2368 #endif
2369 if(tpd_driver_add(&tpd_device_driver) < 0) {
2370 SYNAPTICS_ERR_MSG("failed to i2c_add_driver\n");
2371 destroy_workqueue(synaptics_wq);
2372 ret = -1;
2373 }
2374
2375 return ret;
2376 }
2377
2378 static void __exit synaptics_ts_exit(void)
2379 {
2380 if (synaptics_rmi4_i2c_debug_mask & SYNAPTICS_RMI4_I2C_DEBUG_FUNC_TRACE)
2381 SYNAPTICS_DEBUG_MSG("\n");
2382
2383 i2c_del_driver(&synaptics_ts_driver);
2384 tpd_driver_remove(&tpd_device_driver);
2385
2386 #if 1
2387 if(I2CDMABuf_va) {
2388 dma_free_coherent(NULL, 4096, I2CDMABuf_va, I2CDMABuf_pa);
2389 I2CDMABuf_va = NULL;
2390 I2CDMABuf_pa = 0;
2391 }
2392 #endif // 1
2393 if (synaptics_wq)
2394 destroy_workqueue(synaptics_wq);
2395 }
2396
2397
2398 module_init(synaptics_ts_init);
2399 module_exit(synaptics_ts_exit);
2400
2401 MODULE_DESCRIPTION("Synaptics 7020 Touchscreen Driver for MTK platform");
2402 MODULE_AUTHOR("TY Kang <taiyou.kang@lge.com>");
2403 MODULE_LICENSE("GPL");
2404
kernel source for telekom puls (alcatel/mediatek)