1 /*
2 *
3 * FocalTech TouchScreen driver.
4 *
5 * Copyright (c) 2012-2018, FocalTech Systems, Ltd., all rights reserved.
6 *
7 * This software is licensed under the terms of the GNU General Public
8 * License version 2, as published by the Free Software Foundation, and
9 * may be copied, distributed, and modified under those terms.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 */
17 /*****************************************************************************
18 *
19 * File Name: focaltech_core.c
20 *
21 * Author: Focaltech Driver Team
22 *
23 * Created: 2016-08-08
24 *
25 * Abstract: entrance for focaltech ts driver
26 *
27 * Version: V1.0
28 *
29 *****************************************************************************/
30
31 /*****************************************************************************
32 * Included header files
33 *****************************************************************************/
34 #include "focaltech_core.h"
35 #if defined(CONFIG_FB)
36 #include <linux/notifier.h>
37 #include <linux/fb.h>
38 #elif defined(CONFIG_HAS_EARLYSUSPEND)
39 #include <linux/earlysuspend.h>
40 #define FTS_SUSPEND_LEVEL 1 /* Early-suspend level */
41 #endif
42
43 /*****************************************************************************
44 * Private constant and macro definitions using #define
45 *****************************************************************************/
46 #define FTS_DRIVER_NAME "fts_ts"
47 #define INTERVAL_READ_REG 100 /* unit:ms */
48 #define TIMEOUT_READ_REG 1000 /* unit:ms */
49 #if FTS_POWER_SOURCE_CUST_EN
50 #define FTS_VTG_MIN_UV 2600000
51 #define FTS_VTG_MAX_UV 3300000
52 #define FTS_I2C_VTG_MIN_UV 1800000
53 #define FTS_I2C_VTG_MAX_UV 1800000
54 #endif
55
56 //#define CFG_SWAP_XY
57 /*****************************************************************************
58 * Global variable or extern global variabls/functions
59 *****************************************************************************/
60 struct fts_ts_data *fts_data;
61
62 /*****************************************************************************
63 * Static function prototypes
64 *****************************************************************************/
65 static void fts_release_all_finger(void);
66 static int fts_ts_suspend(struct device *dev);
67 static int fts_ts_resume(struct device *dev);
68
69 /*****************************************************************************
70 * Name: fts_reset_proc
71 * Brief: Execute reset operation
72 * Input: hdelayms - delay time unit:ms
73 * Output:
74 * Return:
75 *****************************************************************************/
fts_reset_proc(int hdelayms)76 int fts_reset_proc(int hdelayms)
77 {
78 FTS_FUNC_ENTER();
79 gpio_direction_output(fts_data->pdata->reset_gpio, 0);
80 msleep(5);
81 gpio_direction_output(fts_data->pdata->reset_gpio, 1);
82 if (hdelayms) {
83 msleep(hdelayms);
84 }
85
86 FTS_FUNC_EXIT();
87 return 0;
88 }
89
90
91 /*****************************************************************************
92 * Name: fts_wait_tp_to_valid
93 * Brief: Read chip id until TP FW become valid(Timeout: TIMEOUT_READ_REG),
94 * need call when reset/power on/resume...
95 * Input:
96 * Output:
97 * Return: return 0 if tp valid, otherwise return error code
98 *****************************************************************************/
fts_wait_tp_to_valid(struct i2c_client * client)99 int fts_wait_tp_to_valid(struct i2c_client *client)
100 {
101 int ret = 0;
102 int cnt = 0;
103 u8 reg_value = 0;
104 u8 chip_id = fts_data->ic_info.ids.chip_idh;
105 fts_reset_proc(200);
106 do {
107 ret = fts_i2c_read_reg(client, FTS_REG_CHIP_ID, ®_value);
108 if ((ret < 0) || (reg_value != chip_id)) {
109 FTS_DEBUG("TP Not Ready, ReadData = 0x%x", reg_value);
110 } else if (reg_value == chip_id) {
111 FTS_INFO("TP Ready, Device ID = 0x%x", reg_value);
112 return 0;
113 }
114 cnt++;
115 msleep(INTERVAL_READ_REG);
116 } while ((cnt * INTERVAL_READ_REG) < TIMEOUT_READ_REG);
117
118 return -EIO;
119 }
120
121 /************************************************************************
122 * Name: fts_get_chip_types
123 * Brief: verity chip id and get chip type data
124 * Input:
125 * Output:
126 * Return: return 0 if success, otherwise return error code
127 ***********************************************************************/
fts_get_chip_types(struct fts_ts_data * ts_data,u8 id_h,u8 id_l,bool fw_valid)128 static int fts_get_chip_types(
129 struct fts_ts_data *ts_data,
130 u8 id_h, u8 id_l, bool fw_valid)
131 {
132 int i = 0;
133 struct ft_chip_t ctype[] = FTS_CHIP_TYPE_MAPPING;
134 u32 ctype_entries = sizeof(ctype) / sizeof(struct ft_chip_t);
135
136 if ((0x0 == id_h) || (0x0 == id_l)) {
137 FTS_ERROR("id_h/id_l is 0");
138 return -EINVAL;
139 }
140
141 FTS_DEBUG("verify id:0x%02x%02x", id_h, id_l);
142 for (i = 0; i < ctype_entries; i++) {
143 if (VALID == fw_valid) {
144 if ((id_h == ctype[i].chip_idh) && (id_l == ctype[i].chip_idl))
145 break;
146 } else {
147 if (((id_h == ctype[i].rom_idh) && (id_l == ctype[i].rom_idl))
148 || ((id_h == ctype[i].pb_idh) && (id_l == ctype[i].pb_idl))
149 || ((id_h == ctype[i].bl_idh) && (id_l == ctype[i].bl_idl)))
150 break;
151 }
152 }
153
154 /*if (i >= ctype_entries) {
155 return -ENODATA;
156 }*/
157 if(ctype_entries >= 2)
158 ts_data->ic_info.ids = ctype[1];
159
160 return 0;
161 }
162
163 /*****************************************************************************
164 * Name: fts_get_ic_information
165 * Brief:
166 * Input:
167 * Output:
168 * Return: return 0 if success, otherwise return error code
169 *****************************************************************************/
fts_get_ic_information(struct fts_ts_data * ts_data)170 static int fts_get_ic_information(struct fts_ts_data *ts_data)
171 {
172 int ret = 0;
173 int ret1 = 0;
174 int cnt = 0;
175 u8 chip_id[2] = { 0 };
176 u8 id_cmd[4] = { 0 };
177 u32 id_cmd_len = 0;
178 struct i2c_client *client = ts_data->client;
179
180 ts_data->ic_info.is_incell = FTS_CHIP_IDC;
181 ts_data->ic_info.hid_supported = FTS_HID_SUPPORTTED;
182
183 fts_reset_proc(200);
184
185 do {
186 ret = fts_i2c_read_reg(client, FTS_REG_CHIP_ID, &chip_id[0]);
187 ret1 = fts_i2c_read_reg(client, FTS_REG_CHIP_ID2, &chip_id[1]);
188 if ((ret < 0) || (ret1 < 0) || (0x0 == chip_id[0]) || (0x0 == chip_id[1])) {
189 FTS_DEBUG("i2c read invalid, read:0x%02x%02x", chip_id[0], chip_id[1]);
190 } else {
191 ret = fts_get_chip_types(ts_data, chip_id[0], chip_id[1], VALID);
192 if (!ret)
193 break;
194 FTS_DEBUG("TP not ready, read:0x%02x%02x", chip_id[0], chip_id[1]);
195 }
196
197 cnt++;
198 msleep(INTERVAL_READ_REG);
199 } while ((cnt * INTERVAL_READ_REG) < TIMEOUT_READ_REG);
200
201 if ((cnt * INTERVAL_READ_REG) >= TIMEOUT_READ_REG) {
202 FTS_INFO("fw is invalid, need read boot id");
203 if (ts_data->ic_info.hid_supported) {
204 fts_i2c_hid2std(client);
205 }
206
207 id_cmd[0] = FTS_CMD_START1;
208 id_cmd[1] = FTS_CMD_START2;
209 ret = fts_i2c_write(client, id_cmd, 2);
210 if (ret < 0) {
211 FTS_ERROR("start cmd write fail");
212 return ret;
213 }
214
215 msleep(FTS_CMD_START_DELAY);
216 id_cmd[0] = FTS_CMD_READ_ID;
217 id_cmd[1] = id_cmd[2] = id_cmd[3] = 0x00;
218 if (ts_data->ic_info.is_incell)
219 id_cmd_len = FTS_CMD_READ_ID_LEN_INCELL;
220 else
221 id_cmd_len = FTS_CMD_READ_ID_LEN;
222 ret = fts_i2c_read(client, id_cmd, id_cmd_len, chip_id, 2);
223 if ((ret < 0) || (0x0 == chip_id[0]) || (0x0 == chip_id[1])) {
224 FTS_ERROR("read boot id fail");
225 return -EIO;
226 }
227 ret = fts_get_chip_types(ts_data, chip_id[0], chip_id[1], INVALID);
228 if (ret < 0) {
229 FTS_ERROR("can't get ic informaton");
230 return ret;
231 }
232 }
233
234 FTS_INFO("get ic information, chip id = 0x%02x%02x",
235 ts_data->ic_info.ids.chip_idh, ts_data->ic_info.ids.chip_idl);
236
237 return 0;
238 }
239
240 /*****************************************************************************
241 * Name: fts_tp_state_recovery
242 * Brief: Need execute this function when reset
243 * Input:
244 * Output:
245 * Return:
246 *****************************************************************************/
fts_tp_state_recovery(struct i2c_client * client)247 void fts_tp_state_recovery(struct i2c_client *client)
248 {
249 FTS_FUNC_ENTER();
250 /* wait tp stable */
251 fts_wait_tp_to_valid(client);
252 /* recover TP charger state 0x8B */
253 /* recover TP glove state 0xC0 */
254 /* recover TP cover state 0xC1 */
255 fts_ex_mode_recovery(client);
256 /* recover TP gesture state 0xD0 */
257 #if FTS_GESTURE_EN
258 fts_gesture_recovery(client);
259 #endif
260 FTS_FUNC_EXIT();
261 }
262
263 /*****************************************************************************
264 * Name: fts_irq_disable
265 * Brief: disable irq
266 * Input:
267 * Output:
268 * Return:
269 *****************************************************************************/
fts_irq_disable(void)270 void fts_irq_disable(void)
271 {
272 unsigned long irqflags;
273
274 FTS_FUNC_ENTER();
275 spin_lock_irqsave(&fts_data->irq_lock, irqflags);
276
277 if (!fts_data->irq_disabled) {
278 disable_irq_nosync(fts_data->irq);
279 fts_data->irq_disabled = true;
280 }
281
282 spin_unlock_irqrestore(&fts_data->irq_lock, irqflags);
283 FTS_FUNC_EXIT();
284 }
285
286 /*****************************************************************************
287 * Name: fts_irq_enable
288 * Brief: enable irq
289 * Input:
290 * Output:
291 * Return:
292 *****************************************************************************/
fts_irq_enable(void)293 void fts_irq_enable(void)
294 {
295 unsigned long irqflags = 0;
296
297 FTS_FUNC_ENTER();
298 spin_lock_irqsave(&fts_data->irq_lock, irqflags);
299
300 if (fts_data->irq_disabled) {
301 enable_irq(fts_data->irq);
302 fts_data->irq_disabled = false;
303 }
304
305 spin_unlock_irqrestore(&fts_data->irq_lock, irqflags);
306 FTS_FUNC_EXIT();
307 }
308
309 #if FTS_POWER_SOURCE_CUST_EN
310 /*****************************************************************************
311 * Power Control
312 *****************************************************************************/
fts_power_source_init(struct fts_ts_data * data)313 static int fts_power_source_init(struct fts_ts_data *data)
314 {
315 int ret = 0;
316
317 FTS_FUNC_ENTER();
318
319 data->vdd = regulator_get(&data->client->dev, "power");
320 if (IS_ERR(data->vdd)) {
321 ret = PTR_ERR(data->vdd);
322 FTS_ERROR("get vdd regulator failed,ret=%d", ret);
323 return ret;
324 }
325
326 if (regulator_count_voltages(data->vdd) > 0) {
327 ret = regulator_set_voltage(data->vdd, FTS_VTG_MIN_UV, FTS_VTG_MAX_UV);
328 if (ret) {
329 FTS_ERROR("vdd regulator set_vtg failed ret=%d", ret);
330 goto err_set_vtg_vdd;
331 }
332 }
333
334 data->vcc_i2c = regulator_get(&data->client->dev, "vcc_i2c");
335 if (IS_ERR(data->vcc_i2c)) {
336 ret = PTR_ERR(data->vcc_i2c);
337 FTS_ERROR("ret vcc_i2c regulator failed,ret=%d", ret);
338 goto err_get_vcc;
339 }
340
341 if (regulator_count_voltages(data->vcc_i2c) > 0) {
342 ret = regulator_set_voltage(data->vcc_i2c, FTS_I2C_VTG_MIN_UV, FTS_I2C_VTG_MAX_UV);
343 if (ret) {
344 FTS_ERROR("vcc_i2c regulator set_vtg failed ret=%d", ret);
345 goto err_set_vtg_vcc;
346 }
347 }
348
349 FTS_FUNC_EXIT();
350 return 0;
351
352 err_set_vtg_vcc:
353 regulator_put(data->vcc_i2c);
354 err_get_vcc:
355 if (regulator_count_voltages(data->vdd) > 0)
356 regulator_set_voltage(data->vdd, 0, FTS_VTG_MAX_UV);
357 err_set_vtg_vdd:
358 regulator_put(data->vdd);
359
360 FTS_FUNC_EXIT();
361 return ret;
362 }
363
fts_power_source_release(struct fts_ts_data * data)364 static int fts_power_source_release(struct fts_ts_data *data)
365 {
366 if (regulator_count_voltages(data->vdd) > 0)
367 regulator_set_voltage(data->vdd, 0, FTS_VTG_MAX_UV);
368 regulator_put(data->vdd);
369
370 if (regulator_count_voltages(data->vcc_i2c) > 0)
371 regulator_set_voltage(data->vcc_i2c, 0, FTS_I2C_VTG_MAX_UV);
372 regulator_put(data->vcc_i2c);
373
374 return 0;
375 }
376
fts_power_source_ctrl(struct fts_ts_data * data,int enable)377 static int fts_power_source_ctrl(struct fts_ts_data *data, int enable)
378 {
379 int ret = 0;
380
381 FTS_FUNC_ENTER();
382 if (enable) {
383 if (data->power_disabled) {
384 FTS_DEBUG("regulator enable !");
385 gpio_direction_output(fts_data->pdata->reset_gpio, 0);
386 msleep(1);
387 ret = regulator_enable(data->vdd);
388 if (ret) {
389 FTS_ERROR("enable vdd regulator failed,ret=%d", ret);
390 }
391
392 ret = regulator_enable(data->vcc_i2c);
393 if (ret) {
394 FTS_ERROR("enable vcc_i2c regulator failed,ret=%d", ret);
395 }
396 data->power_disabled = false;
397 }
398 } else {
399 if (!data->power_disabled) {
400 FTS_DEBUG("regulator disable !");
401 gpio_direction_output(fts_data->pdata->reset_gpio, 0);
402 msleep(1);
403 ret = regulator_disable(data->vdd);
404 if (ret) {
405 FTS_ERROR("disable vdd regulator failed,ret=%d", ret);
406 }
407 ret = regulator_disable(data->vcc_i2c);
408 if (ret) {
409 FTS_ERROR("disable vcc_i2c regulator failed,ret=%d", ret);
410 }
411 data->power_disabled = true;
412 }
413 }
414
415 FTS_FUNC_EXIT();
416 return ret;
417 }
418
419 #if FTS_PINCTRL_EN
420 /*****************************************************************************
421 * Name: fts_pinctrl_init
422 * Brief:
423 * Input:
424 * Output:
425 * Return:
426 *****************************************************************************/
fts_pinctrl_init(struct fts_ts_data * ts)427 static int fts_pinctrl_init(struct fts_ts_data *ts)
428 {
429 int ret = 0;
430 struct i2c_client *client = ts->client;
431
432 ts->pinctrl = devm_pinctrl_get(&client->dev);
433 if (IS_ERR_OR_NULL(ts->pinctrl)) {
434 FTS_ERROR("Failed to get pinctrl, please check dts");
435 ret = PTR_ERR(ts->pinctrl);
436 goto err_pinctrl_get;
437 }
438
439 ts->pins_active = pinctrl_lookup_state(ts->pinctrl, "pmx_ts_active");
440 if (IS_ERR_OR_NULL(ts->pins_active)) {
441 FTS_ERROR("Pin state[active] not found");
442 ret = PTR_ERR(ts->pins_active);
443 goto err_pinctrl_lookup;
444 }
445
446 ts->pins_suspend = pinctrl_lookup_state(ts->pinctrl, "pmx_ts_suspend");
447 if (IS_ERR_OR_NULL(ts->pins_suspend)) {
448 FTS_ERROR("Pin state[suspend] not found");
449 ret = PTR_ERR(ts->pins_suspend);
450 goto err_pinctrl_lookup;
451 }
452
453 ts->pins_release = pinctrl_lookup_state(ts->pinctrl, "pmx_ts_release");
454 if (IS_ERR_OR_NULL(ts->pins_release)) {
455 FTS_ERROR("Pin state[release] not found");
456 ret = PTR_ERR(ts->pins_release);
457 }
458
459 return 0;
460 err_pinctrl_lookup:
461 if (ts->pinctrl) {
462 devm_pinctrl_put(ts->pinctrl);
463 }
464 err_pinctrl_get:
465 ts->pinctrl = NULL;
466 ts->pins_release = NULL;
467 ts->pins_suspend = NULL;
468 ts->pins_active = NULL;
469 return ret;
470 }
471
fts_pinctrl_select_normal(struct fts_ts_data * ts)472 static int fts_pinctrl_select_normal(struct fts_ts_data *ts)
473 {
474 int ret = 0;
475
476 if (ts->pinctrl && ts->pins_active) {
477 ret = pinctrl_select_state(ts->pinctrl, ts->pins_active);
478 if (ret < 0) {
479 FTS_ERROR("Set normal pin state error:%d", ret);
480 }
481 }
482
483 return ret;
484 }
485
fts_pinctrl_select_suspend(struct fts_ts_data * ts)486 static int fts_pinctrl_select_suspend(struct fts_ts_data *ts)
487 {
488 int ret = 0;
489
490 if (ts->pinctrl && ts->pins_suspend) {
491 ret = pinctrl_select_state(ts->pinctrl, ts->pins_suspend);
492 if (ret < 0) {
493 FTS_ERROR("Set suspend pin state error:%d", ret);
494 }
495 }
496
497 return ret;
498 }
499
fts_pinctrl_select_release(struct fts_ts_data * ts)500 static int fts_pinctrl_select_release(struct fts_ts_data *ts)
501 {
502 int ret = 0;
503
504 if (ts->pinctrl) {
505 if (IS_ERR_OR_NULL(ts->pins_release)) {
506 devm_pinctrl_put(ts->pinctrl);
507 ts->pinctrl = NULL;
508 } else {
509 ret = pinctrl_select_state(ts->pinctrl, ts->pins_release);
510 if (ret < 0)
511 FTS_ERROR("Set gesture pin state error:%d", ret);
512 }
513 }
514
515 return ret;
516 }
517 #endif /* FTS_PINCTRL_EN */
518
519 #endif /* FTS_POWER_SOURCE_CUST_EN */
520
521 /*****************************************************************************
522 * Reprot related
523 *****************************************************************************/
524 #if (FTS_DEBUG_EN && (FTS_DEBUG_LEVEL == 2))
525 char g_sz_debug[1024] = {0};
fts_show_touch_buffer(u8 * buf,int point_num)526 static void fts_show_touch_buffer(u8 *buf, int point_num)
527 {
528 int len = point_num * FTS_ONE_TCH_LEN;
529 int count = 0;
530 int i;
531
532 memset(g_sz_debug, 0, 1024);
533 if (len > (fts_data->pnt_buf_size - 3)) {
534 len = fts_data->pnt_buf_size - 3;
535 } else if (len == 0) {
536 len += FTS_ONE_TCH_LEN;
537 }
538 count += snprintf(g_sz_debug, PAGE_SIZE, "%02X,%02X,%02X", buf[0], buf[1], buf[2]);
539 for (i = 0; i < len; i++) {
540 count += snprintf(g_sz_debug + count, PAGE_SIZE, ",%02X", buf[i + 3]);
541 }
542 FTS_DEBUG("buffer: %s", g_sz_debug);
543 }
544 #endif
545
546 /*****************************************************************************
547 * Name: fts_release_all_finger
548 * Brief: report all points' up events, release touch
549 * Input:
550 * Output:
551 * Return:
552 *****************************************************************************/
fts_release_all_finger(void)553 static void fts_release_all_finger(void)
554 {
555 struct input_dev *input_dev = fts_data->input_dev;
556 #if FTS_MT_PROTOCOL_B_EN
557 u32 finger_count = 0;
558 #endif
559
560 FTS_FUNC_ENTER();
561 mutex_lock(&fts_data->report_mutex);
562 #if FTS_MT_PROTOCOL_B_EN
563 for (finger_count = 0; finger_count < fts_data->pdata->max_touch_number; finger_count++) {
564 input_mt_slot(input_dev, finger_count);
565 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, false);
566 }
567 #else
568 input_mt_sync(input_dev);
569 #endif
570 input_report_key(input_dev, BTN_TOUCH, 0);
571 input_sync(input_dev);
572
573 mutex_unlock(&fts_data->report_mutex);
574 FTS_FUNC_EXIT();
575 }
576
577 /************************************************************************
578 * Name: fts_input_report_key
579 * Brief: report key event
580 * Input: events info
581 * Output:
582 * Return: return 0 if success
583 ***********************************************************************/
fts_input_report_key(struct fts_ts_data * data,int index)584 static int fts_input_report_key(struct fts_ts_data *data, int index)
585 {
586 u32 ik;
587 int id = data->events[index].id;
588 int x = data->events[index].x;
589 int y = data->events[index].y;
590 int flag = data->events[index].flag;
591 u32 key_num = data->pdata->key_number;
592
593 if (!KEY_EN(data)) {
594 return -EINVAL;
595 }
596 for (ik = 0; ik < key_num; ik++) {
597 if (TOUCH_IN_KEY(x, data->pdata->key_x_coords[ik])) {
598 if (EVENT_DOWN(flag)) {
599 data->key_down = true;
600 input_report_key(data->input_dev, data->pdata->keys[ik], 1);
601 FTS_DEBUG("Key%d(%d, %d) DOWN!", ik, x, y);
602 } else {
603 data->key_down = false;
604 input_report_key(data->input_dev, data->pdata->keys[ik], 0);
605 FTS_DEBUG("Key%d(%d, %d) Up!", ik, x, y);
606 }
607 return 0;
608 }
609 }
610
611 FTS_ERROR("invalid touch for key, [%d](%d, %d)", id, x, y);
612 return -EINVAL;
613 }
614
615
616 #if FTS_MT_PROTOCOL_B_EN
fts_input_report_b(struct fts_ts_data * data)617 static int fts_input_report_b(struct fts_ts_data *data)
618 {
619 int i = 0;
620 int uppoint = 0;
621 int touchs = 0;
622 bool va_reported = false;
623 u32 max_touch_num = data->pdata->max_touch_number;
624 u32 key_y_coor = data->pdata->key_y_coord;
625 struct ts_event *events = data->events;
626
627 for (i = 0; i < data->touch_point; i++) {
628 if (KEY_EN(data) && TOUCH_IS_KEY(events[i].y, key_y_coor)) {
629 fts_input_report_key(data, i);
630 continue;
631 }
632
633 if (events[i].id >= max_touch_num)
634 break;
635
636 va_reported = true;
637 input_mt_slot(data->input_dev, events[i].id);
638
639 if (EVENT_DOWN(events[i].flag)) {
640 input_mt_report_slot_state(data->input_dev, MT_TOOL_FINGER, true);
641
642 #if FTS_REPORT_PRESSURE_EN
643 if (events[i].p <= 0) {
644 events[i].p = 0x3f;
645 }
646 input_report_abs(data->input_dev, ABS_MT_PRESSURE, events[i].p);
647 #endif
648 if (events[i].area <= 0) {
649 events[i].area = 0x09;
650 }
651 #ifdef CFG_SWAP_XY
652 swap(events[i].x,events[i].y);
653 #endif /* CFG_CTS_SWAP_XY */
654
655
656 input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, events[i].area);
657 #if 0
658 input_report_abs(data->input_dev, ABS_MT_POSITION_X, 2176 - events[i].x);
659 input_report_abs(data->input_dev, ABS_MT_POSITION_Y, events[i].y);
660 #else
661 input_report_abs(data->input_dev, ABS_MT_POSITION_X, events[i].x);
662 input_report_abs(data->input_dev, ABS_MT_POSITION_Y, events[i].y);
663 #endif
664 //printk("bb...x = %d, y - %d\n...", events[i].x, 2176 - events[i].y, events[i].p);
665 touchs |= BIT(events[i].id);
666 data->touchs |= BIT(events[i].id);
667
668 FTS_DEBUG("[B]P%d(0x%x, 0x%x)[p:%d,tm:%d] DOWN!", events[i].id, events[i].x,
669 events[i].y, events[i].p, events[i].area);
670 } else {
671 uppoint++;
672 input_mt_report_slot_state(data->input_dev, MT_TOOL_FINGER, false);
673 data->touchs &= ~BIT(events[i].id);
674 FTS_DEBUG("[B]P%d UP!", events[i].id);
675 }
676 }
677
678 if (unlikely(data->touchs ^ touchs)) {
679 for (i = 0; i < max_touch_num; i++) {
680 if (BIT(i) & (data->touchs ^ touchs)) {
681 FTS_DEBUG("[B]P%d UP!", i);
682 va_reported = true;
683 input_mt_slot(data->input_dev, i);
684 input_mt_report_slot_state(data->input_dev, MT_TOOL_FINGER, false);
685 }
686 }
687 }
688 data->touchs = touchs;
689
690 if (va_reported) {
691 /* touchs==0, there's no point but key */
692 if (EVENT_NO_DOWN(data) || (!touchs)) {
693 FTS_DEBUG("[B]Points All Up!");
694 input_report_key(data->input_dev, BTN_TOUCH, 0);
695 } else {
696 input_report_key(data->input_dev, BTN_TOUCH, 1);
697 }
698 }
699
700 input_sync(data->input_dev);
701 return 0;
702 }
703
704 #else
fts_input_report_a(struct fts_ts_data * data)705 static int fts_input_report_a(struct fts_ts_data *data)
706 {
707 int i = 0;
708 int touchs = 0;
709 bool va_reported = false;
710 u32 key_y_coor = data->pdata->key_y_coord;
711 struct ts_event *events = data->events;
712
713 for (i = 0; i < data->touch_point; i++) {
714 if (KEY_EN(data) && TOUCH_IS_KEY(events[i].y, key_y_coor)) {
715 fts_input_report_key(data, i);
716 continue;
717 }
718
719 va_reported = true;
720 if (EVENT_DOWN(events[i].flag)) {
721 input_report_abs(data->input_dev, ABS_MT_TRACKING_ID, events[i].id);
722 #if FTS_REPORT_PRESSURE_EN
723 if (events[i].p <= 0) {
724 events[i].p = 0x3f;
725 }
726 input_report_abs(data->input_dev, ABS_MT_PRESSURE, events[i].p);
727 #endif
728 if (events[i].area <= 0) {
729 events[i].area = 0x09;
730 }
731 input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR, events[i].area);
732
733 input_report_abs(data->input_dev, ABS_MT_POSITION_X, events[i].x);
734 input_report_abs(data->input_dev, ABS_MT_POSITION_Y, 2176 - events[i].y);
735 //printk("aa...x = %d, y - %d...p = %d\n...", events[i].x, 2176 - events[i].y, events[i].p);
736 input_mt_sync(data->input_dev);
737
738 FTS_DEBUG("[A]P%d(%d, %d)[p:%d,tm:%d] DOWN!", events[i].id, events[i].x,
739 events[i].y, events[i].p, events[i].area);
740 touchs++;
741 }
742 }
743
744 /* last point down, current no point but key */
745 if (data->touchs && !touchs) {
746 va_reported = true;
747 }
748 data->touchs = touchs;
749
750 if (va_reported) {
751 if (EVENT_NO_DOWN(data)) {
752 FTS_DEBUG("[A]Points All Up!");
753 input_report_key(data->input_dev, BTN_TOUCH, 1);
754 input_mt_sync(data->input_dev);
755 } else {
756 input_report_key(data->input_dev, BTN_TOUCH, 0);
757 }
758 }
759
760 input_sync(data->input_dev);
761 return 0;
762 }
763 #endif
764
765 /*****************************************************************************
766 * Name: fts_read_touchdata
767 * Brief:
768 * Input:
769 * Output:
770 * Return: return 0 if succuss
771 *****************************************************************************/
fts_read_touchdata(struct fts_ts_data * data)772 static int fts_read_touchdata(struct fts_ts_data *data)
773 {
774 int ret = 0;
775 int i = 0;
776 u8 pointid;
777 int base;
778 struct ts_event *events = data->events;
779 int max_touch_num = data->pdata->max_touch_number;
780 u8 *buf = data->point_buf;
781 struct i2c_client *client = data->client;
782
783 #if FTS_GESTURE_EN
784 if (0 == fts_gesture_readdata(data)) {
785 FTS_INFO("succuss to get gesture data in irq handler");
786 return 1;
787 }
788 #endif
789
790 #if FTS_POINT_REPORT_CHECK_EN
791 fts_prc_queue_work(data);
792 #endif
793
794 data->point_num = 0;
795 data->touch_point = 0;
796
797 memset(buf, 0xFF, data->pnt_buf_size);
798 buf[0] = 0x00;
799
800 ret = fts_i2c_read(data->client, buf, 1, buf, data->pnt_buf_size);
801 if (ret < 0) {
802 FTS_ERROR("read touchdata failed, ret:%d", ret);
803 return ret;
804 }
805 data->point_num = buf[FTS_TOUCH_POINT_NUM] & 0x0F;
806
807 if (data->ic_info.is_incell) {
808 if ((data->point_num == 0x0F) && (buf[1] == 0xFF) && (buf[2] == 0xFF)
809 && (buf[3] == 0xFF) && (buf[4] == 0xFF) && (buf[5] == 0xFF) && (buf[6] == 0xFF)) {
810 FTS_INFO("touch buff is 0xff, need recovery state");
811 fts_tp_state_recovery(client);
812 return -EIO;
813 }
814 }
815
816 if (data->point_num > max_touch_num) {
817 FTS_INFO("invalid point_num(%d)", data->point_num);
818 return -EIO;
819 }
820
821 #if (FTS_DEBUG_EN && (FTS_DEBUG_LEVEL == 2))
822 fts_show_touch_buffer(buf, data->point_num);
823 #endif
824
825 for (i = 0; i < max_touch_num; i++) {
826 base = FTS_ONE_TCH_LEN * i;
827
828 pointid = (buf[FTS_TOUCH_ID_POS + base]) >> 4;
829 if (pointid >= FTS_MAX_ID)
830 break;
831 else if (pointid >= max_touch_num) {
832 FTS_ERROR("ID(%d) beyond max_touch_number", pointid);
833 return -EINVAL;
834 }
835
836 data->touch_point++;
837
838 events[i].x = ((buf[FTS_TOUCH_X_H_POS + base] & 0x0F) << 8) +
839 (buf[FTS_TOUCH_X_L_POS + base] & 0xFF);
840 events[i].y = ((buf[FTS_TOUCH_Y_H_POS + base] & 0x0F) << 8) +
841 (buf[FTS_TOUCH_Y_L_POS + base] & 0xFF);
842 events[i].flag = buf[FTS_TOUCH_EVENT_POS + base] >> 6;
843 events[i].id = buf[FTS_TOUCH_ID_POS + base] >> 4;
844 events[i].area = buf[FTS_TOUCH_AREA_POS + base] >> 4;
845 events[i].p = buf[FTS_TOUCH_PRE_POS + base];
846
847 if (EVENT_DOWN(events[i].flag) && (data->point_num == 0)) {
848 FTS_INFO("abnormal touch data from fw");
849 return -EIO;
850 }
851 }
852 if (data->touch_point == 0) {
853 FTS_INFO("no touch point information");
854 return -EIO;
855 }
856
857 return 0;
858 }
859
860 /*****************************************************************************
861 * Name: fts_report_event
862 * Brief:
863 * Input:
864 * Output:
865 * Return:
866 *****************************************************************************/
fts_report_event(struct fts_ts_data * data)867 static void fts_report_event(struct fts_ts_data *data)
868 {
869 #if FTS_MT_PROTOCOL_B_EN
870 fts_input_report_b(data);
871 #else
872 fts_input_report_a(data);
873 #endif
874 }
875
876 /*****************************************************************************
877 * Name: fts_ts_interrupt
878 * Brief:
879 * Input:
880 * Output:
881 * Return:
882 *****************************************************************************/
fts_ts_interrupt(int irq,void * data)883 static irqreturn_t fts_ts_interrupt(int irq, void *data)
884 {
885 int ret = 0;
886 struct fts_ts_data *ts_data = (struct fts_ts_data *)data;
887
888
889 //FTS_ERROR("fts_ts_interrupt.......yyk...........\n");
890
891 if (!ts_data) {
892 FTS_ERROR("[INTR]: Invalid fts_ts_data");
893 return IRQ_HANDLED;
894 }
895
896 #if FTS_ESDCHECK_EN
897 fts_esdcheck_set_intr(1);
898 #endif
899
900 ret = fts_read_touchdata(ts_data);
901 if (ret == 0) {
902 mutex_lock(&ts_data->report_mutex);
903 fts_report_event(ts_data);
904 mutex_unlock(&ts_data->report_mutex);
905 }
906
907 #if FTS_ESDCHECK_EN
908 fts_esdcheck_set_intr(0);
909 #endif
910
911 return IRQ_HANDLED;
912 }
913
914 /*****************************************************************************
915 * Name: fts_irq_registration
916 * Brief:
917 * Input:
918 * Output:
919 * Return: return 0 if succuss, otherwise return error code
920 *****************************************************************************/
fts_irq_registration(struct fts_ts_data * ts_data)921 static int fts_irq_registration(struct fts_ts_data *ts_data)
922 {
923 int ret = 0;
924 struct fts_ts_platform_data *pdata = ts_data->pdata;
925
926 ts_data->irq = gpio_to_irq(pdata->irq_gpio);
927 FTS_INFO("irq in ts_data:%d irq in client:%d", ts_data->irq, ts_data->client->irq);
928 if (ts_data->irq != ts_data->client->irq)
929 FTS_ERROR("IRQs are inconsistent, please check <interrupts> & <focaltech,irq-gpio> in DTS");
930
931 if (0 == pdata->irq_gpio_flags)
932 pdata->irq_gpio_flags = IRQF_TRIGGER_FALLING;
933 FTS_INFO("irq flag:%x", pdata->irq_gpio_flags);
934 ret = request_threaded_irq(ts_data->irq, NULL, fts_ts_interrupt,
935 pdata->irq_gpio_flags | IRQF_ONESHOT,
936 ts_data->client->name, ts_data);
937
938 /*ret = devm_request_irq(&ts_data->client->dev, ts_data->irq, fts_ts_interrupt,
939 IRQF_TRIGGER_FALLING|IRQ_TYPE_EDGE_RISING,ts_data->client->name, ts_data);*/
940 return ret;
941 }
942
943 /*****************************************************************************
944 * Name: fts_input_init
945 * Brief: input device init
946 * Input:
947 * Output:
948 * Return:
949 *****************************************************************************/
fts_input_init(struct fts_ts_data * ts_data)950 static int fts_input_init(struct fts_ts_data *ts_data)
951 {
952 int ret = 0;
953 int key_num = 0;
954 struct fts_ts_platform_data *pdata = ts_data->pdata;
955 struct input_dev *input_dev;
956 int point_num;
957
958 FTS_FUNC_ENTER();
959
960 input_dev = input_allocate_device();
961 if (!input_dev) {
962 FTS_ERROR("Failed to allocate memory for input device");
963 return -ENOMEM;
964 }
965
966 /* Init and register Input device */
967 input_dev->name = FTS_DRIVER_NAME;
968 input_dev->id.bustype = BUS_I2C;
969 input_dev->dev.parent = &ts_data->client->dev;
970
971 input_set_drvdata(input_dev, ts_data);
972
973 __set_bit(EV_SYN, input_dev->evbit);
974 __set_bit(EV_ABS, input_dev->evbit);
975 __set_bit(EV_KEY, input_dev->evbit);
976 __set_bit(BTN_TOUCH, input_dev->keybit);
977 __set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
978
979 if (pdata->have_key) {
980 FTS_INFO("set key capabilities");
981 for (key_num = 0; key_num < pdata->key_number; key_num++)
982 input_set_capability(input_dev, EV_KEY, pdata->keys[key_num]);
983 }
984
985 #if FTS_MT_PROTOCOL_B_EN
986 input_mt_init_slots(input_dev, pdata->max_touch_number, INPUT_MT_DIRECT);
987 #else
988 input_set_abs_params(input_dev, ABS_MT_TRACKING_ID, 0, 0x0f, 0, 0);
989 #endif
990
991 #ifdef CFG_SWAP_XY
992 input_set_abs_params(input_dev, ABS_MT_POSITION_X,
993 0, pdata->y_max, 0, 0);
994 input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
995 0, pdata->x_max, 0, 0);
996 #else /* CFG_CTS_SWAP_XY */
997 input_set_abs_params(input_dev, ABS_MT_POSITION_X,
998 0, pdata->x_max, 0, 0);
999 input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
1000 0, pdata->y_max, 0, 0);
1001 #endif /* CFG_CTS_SWAP_XY */
1002 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 0xFF, 0, 0);
1003 #if FTS_REPORT_PRESSURE_EN
1004 input_set_abs_params(input_dev, ABS_MT_PRESSURE, 0, 0xFF, 0, 0);
1005 #endif
1006 point_num = pdata->max_touch_number;
1007 ts_data->pnt_buf_size = point_num * FTS_ONE_TCH_LEN + 3;
1008 ts_data->point_buf = (u8 *)kzalloc(ts_data->pnt_buf_size, GFP_KERNEL);
1009 if (!ts_data->point_buf) {
1010 FTS_ERROR("failed to alloc memory for point buf!");
1011 ret = -ENOMEM;
1012 goto err_point_buf;
1013 }
1014
1015 ts_data->events = (struct ts_event *)kzalloc(point_num * sizeof(struct ts_event), GFP_KERNEL);
1016 if (!ts_data->events) {
1017
1018 FTS_ERROR("failed to alloc memory for point events!");
1019 ret = -ENOMEM;
1020 goto err_event_buf;
1021 }
1022
1023
1024 ret = input_register_device(input_dev);
1025 if (ret) {
1026 FTS_ERROR("Input device registration failed");
1027 goto err_input_reg;
1028 }
1029
1030 ts_data->input_dev = input_dev;
1031
1032 FTS_FUNC_EXIT();
1033 return 0;
1034
1035 err_input_reg:
1036 kfree_safe(ts_data->events);
1037
1038 err_event_buf:
1039 kfree_safe(ts_data->point_buf);
1040
1041 err_point_buf:
1042 input_set_drvdata(input_dev, NULL);
1043 input_free_device(input_dev);
1044 input_dev = NULL;
1045
1046 FTS_FUNC_EXIT();
1047 return ret;
1048 }
1049
1050
1051 /*****************************************************************************
1052 * Name: fts_gpio_configure
1053 * Brief: Configure IRQ&RESET GPIO
1054 * Input:
1055 * Output:
1056 * Return: return 0 if succuss
1057 *****************************************************************************/
fts_gpio_configure(struct fts_ts_data * data)1058 static int fts_gpio_configure(struct fts_ts_data *data)
1059 {
1060 int ret = 0;
1061
1062 FTS_FUNC_ENTER();
1063 /* request irq gpio */
1064 if (gpio_is_valid(data->pdata->irq_gpio)) {
1065 ret = gpio_request(data->pdata->irq_gpio, "fts_irq_gpio");
1066 if (ret) {
1067 FTS_ERROR("[GPIO]irq gpio request failed");
1068 goto err_irq_gpio_req;
1069 }
1070
1071 ret = gpio_direction_input(data->pdata->irq_gpio);
1072 if (ret) {
1073 FTS_ERROR("[GPIO]set_direction for irq gpio failed");
1074 goto err_irq_gpio_dir;
1075 }
1076 }
1077
1078 /* request reset gpio */
1079 if (gpio_is_valid(data->pdata->reset_gpio)) {
1080 ret = gpio_request(data->pdata->reset_gpio, "fts_reset_gpio");
1081 if (ret) {
1082 FTS_ERROR("[GPIO]reset gpio request failed");
1083 goto err_irq_gpio_dir;
1084 }
1085
1086 ret = gpio_direction_output(data->pdata->reset_gpio, 1);
1087 if (ret) {
1088 FTS_ERROR("[GPIO]set_direction for reset gpio failed");
1089 goto err_reset_gpio_dir;
1090 }
1091 }
1092
1093 FTS_FUNC_EXIT();
1094 return 0;
1095
1096 err_reset_gpio_dir:
1097 if (gpio_is_valid(data->pdata->reset_gpio))
1098 gpio_free(data->pdata->reset_gpio);
1099 err_irq_gpio_dir:
1100 if (gpio_is_valid(data->pdata->irq_gpio))
1101 gpio_free(data->pdata->irq_gpio);
1102 err_irq_gpio_req:
1103 FTS_FUNC_EXIT();
1104 return ret;
1105 }
1106
1107 /*****************************************************************************
1108 * Name: fts_get_dt_coords
1109 * Brief:
1110 * Input:
1111 * Output:
1112 * Return: return 0 if succuss, otherwise return error code
1113 *****************************************************************************/
fts_get_dt_coords(struct device * dev,char * name,struct fts_ts_platform_data * pdata)1114 static int fts_get_dt_coords(struct device *dev, char *name,
1115 struct fts_ts_platform_data *pdata)
1116 {
1117 //int ret = 0;
1118 //u32 coords[FTS_COORDS_ARR_SIZE] = { 0 };
1119 //struct property *prop;
1120 //struct device_node *np = dev->of_node;
1121 //int coords_size;
1122
1123 pdata->x_min = FTS_X_MIN_DISPLAY_DEFAULT;
1124 pdata->y_min = FTS_Y_MIN_DISPLAY_DEFAULT;
1125 pdata->x_max = FTS_X_MAX_DISPLAY_DEFAULT;
1126 pdata->y_max = FTS_Y_MAX_DISPLAY_DEFAULT;
1127
1128
1129
1130 /*prop = of_find_property(np, name, NULL);
1131 if (!prop)
1132 return -EINVAL;
1133 if (!prop->value)
1134 return -ENODATA;
1135
1136 coords_size = prop->length / sizeof(u32);
1137 if (coords_size != FTS_COORDS_ARR_SIZE) {
1138 FTS_ERROR("invalid:%s, size:%d", name, coords_size);
1139 return -EINVAL;
1140 }
1141
1142 ret = of_property_read_u32_array(np, name, coords, coords_size);
1143 if (ret && (ret != -EINVAL)) {
1144 FTS_ERROR("Unable to read %s", name);
1145 return -ENODATA;
1146 }
1147
1148 if (!strcmp(name, "focaltech,display-coords")) {
1149 pdata->x_min = coords[0];
1150 pdata->y_min = coords[1];
1151 pdata->x_max = coords[2];
1152 pdata->y_max = coords[3];
1153 } else {
1154 FTS_ERROR("unsupported property %s", name);
1155 pdata->x_min = FTS_X_MIN_DISPLAY_DEFAULT;
1156 pdata->y_min = FTS_Y_MIN_DISPLAY_DEFAULT;
1157 pdata->x_max = FTS_X_MAX_DISPLAY_DEFAULT;
1158 pdata->y_max = FTS_Y_MAX_DISPLAY_DEFAULT;
1159 // return -EINVAL;
1160 }
1161 */
1162 printk("display x(%d %d) y(%d %d)", pdata->x_min, pdata->x_max, pdata->y_min, pdata->y_max);
1163 /*FTS_INFO("display x(%d %d) y(%d %d)", pdata->x_min, pdata->x_max,
1164 pdata->y_min, pdata->y_max);*/
1165 return 0;
1166 }
1167
1168 /*****************************************************************************
1169 * Name: fts_parse_dt
1170 * Brief:
1171 * Input:
1172 * Output:
1173 * Return:
1174 *****************************************************************************/
fts_parse_dt(struct device * dev,struct fts_ts_platform_data * pdata)1175 static int fts_parse_dt(struct device *dev, struct fts_ts_platform_data *pdata)
1176 {
1177 int ret = 0;
1178 struct device_node *np = dev->of_node;
1179 u32 temp_val;
1180
1181 FTS_FUNC_ENTER();
1182
1183 ret = fts_get_dt_coords(dev, "focaltech,display-coords", pdata);
1184 if (ret < 0)
1185 FTS_ERROR("Unable to get display-coords");
1186
1187 /* key */
1188 pdata->have_key = of_property_read_bool(np, "focaltech,have-key");
1189 if (pdata->have_key) {
1190 ret = of_property_read_u32(np, "focaltech,key-number", &pdata->key_number);
1191 if (ret)
1192 FTS_ERROR("Key number undefined!");
1193
1194 ret = of_property_read_u32_array(np, "focaltech,keys",
1195 pdata->keys, pdata->key_number);
1196
1197 if (ret)
1198 FTS_ERROR("Keys undefined!");
1199 else if (pdata->key_number > FTS_MAX_KEYS)
1200 pdata->key_number = FTS_MAX_KEYS;
1201
1202 ret = of_property_read_u32(np, "focaltech,key-y-coord", &pdata->key_y_coord);
1203
1204 if (ret)
1205 FTS_ERROR("Key Y Coord undefined!");
1206
1207 ret = of_property_read_u32_array(np, "focaltech,key-x-coords",
1208 pdata->key_x_coords, pdata->key_number);
1209
1210 if (ret)
1211 FTS_ERROR("Key X Coords undefined!");
1212
1213 FTS_INFO("VK(%d): (%d, %d, %d), [%d, %d, %d][%d]",
1214 pdata->key_number, pdata->keys[0], pdata->keys[1], pdata->keys[2],
1215 pdata->key_x_coords[0], pdata->key_x_coords[1], pdata->key_x_coords[2],
1216 pdata->key_y_coord);
1217 }
1218
1219 /* reset, irq gpio info */
1220 pdata->reset_gpio = of_get_named_gpio_flags(np, "focaltech,reset-gpio", 0, &pdata->reset_gpio_flags);
1221 pdata->irq_gpio = of_get_named_gpio_flags(np, "focaltech,irq-gpio", 0, &pdata->irq_gpio_flags);
1222
1223 ret = of_property_read_u32(np, "focaltech,max-touch-number", &temp_val);
1224 if (0 == ret) {
1225 if (temp_val < 2)
1226 pdata->max_touch_number = 2;
1227 else if (temp_val > FTS_MAX_POINTS_SUPPORT)
1228 pdata->max_touch_number = FTS_MAX_POINTS_SUPPORT;
1229 else
1230 pdata->max_touch_number = temp_val;
1231 } else {
1232 FTS_ERROR("Unable to get max-touch-number");
1233 pdata->max_touch_number = FTS_MAX_POINTS_SUPPORT;
1234 }
1235
1236 FTS_INFO("max touch number:%d, irq gpio:%d, reset gpio:%d",
1237 pdata->max_touch_number, pdata->irq_gpio, pdata->reset_gpio);
1238
1239 FTS_FUNC_EXIT();
1240 return 0;
1241 }
1242
1243 #if defined(CONFIG_FB)
1244 /*****************************************************************************
1245 * Name: fts_resume_work
1246 * Brief:
1247 * Input:
1248 * Output:
1249 * Return:
1250 *****************************************************************************/
fts_resume_work(struct work_struct * work)1251 static void fts_resume_work(struct work_struct *work)
1252 {
1253 struct fts_ts_data *ts_data = container_of(work,
1254 struct fts_ts_data, resume_work);
1255
1256 fts_ts_resume(&ts_data->client->dev);
1257
1258 }
1259
1260 /*****************************************************************************
1261 * Name: fb_notifier_callback
1262 * Brief:
1263 * Input:
1264 * Output:
1265 * Return:
1266 *****************************************************************************/
fb_notifier_callback(struct notifier_block * self,unsigned long event,void * data)1267 static int fb_notifier_callback(struct notifier_block *self,
1268 unsigned long event, void *data)
1269 {
1270 struct fb_event *evdata = data;
1271 int *blank;
1272 struct fts_ts_data *fts_data =
1273 container_of(self, struct fts_ts_data, fb_notif);
1274
1275 if (evdata && evdata->data && event == FB_EVENT_BLANK &&
1276 fts_data && fts_data->client) {
1277 blank = evdata->data;
1278 if (*blank == FB_BLANK_UNBLANK)
1279 queue_work(fts_data->ts_workqueue, &fts_data->resume_work);
1280 else if (*blank == FB_BLANK_POWERDOWN)
1281 fts_ts_suspend(&fts_data->client->dev);
1282 }
1283
1284 return 0;
1285 }
1286 #elif defined(CONFIG_HAS_EARLYSUSPEND)
1287 /*****************************************************************************
1288 * Name: fts_ts_early_suspend
1289 * Brief:
1290 * Input:
1291 * Output:
1292 * Return:
1293 *****************************************************************************/
fts_ts_early_suspend(struct early_suspend * handler)1294 static void fts_ts_early_suspend(struct early_suspend *handler)
1295 {
1296 struct fts_ts_data *data = container_of(handler,
1297 struct fts_ts_data,
1298 early_suspend);
1299
1300 fts_ts_suspend(&data->client->dev);
1301 }
1302
1303 /*****************************************************************************
1304 * Name: fts_ts_late_resume
1305 * Brief:
1306 * Input:
1307 * Output:
1308 * Return:
1309 *****************************************************************************/
fts_ts_late_resume(struct early_suspend * handler)1310 static void fts_ts_late_resume(struct early_suspend *handler)
1311 {
1312 struct fts_ts_data *data = container_of(handler,
1313 struct fts_ts_data,
1314 early_suspend);
1315
1316 fts_ts_resume(&data->client->dev);
1317 }
1318 #endif
1319
1320 extern int fts_test_exit(struct i2c_client *client);
1321 extern int fts_test_init(struct i2c_client *client);
1322 /*****************************************************************************
1323 * Name: fts_ts_probe
1324 * Brief:
1325 * Input:
1326 * Output:
1327 * Return:
1328 *****************************************************************************/
fts_ts_probe(struct i2c_client * client,const struct i2c_device_id * id)1329 static int fts_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)
1330 {
1331 int ret = 0;
1332 struct fts_ts_platform_data *pdata;
1333 struct fts_ts_data *ts_data;
1334
1335 FTS_FUNC_ENTER();
1336 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
1337 FTS_ERROR("I2C not supported");
1338 return -ENODEV;
1339 }
1340
1341 if (client->dev.of_node) {
1342 pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
1343 if (!pdata) {
1344 FTS_ERROR("Failed to allocate memory for platform data");
1345 return -ENOMEM;
1346 }
1347 ret = fts_parse_dt(&client->dev, pdata);
1348 if (ret)
1349 FTS_ERROR("[DTS]DT parsing failed");
1350 } else {
1351 pdata = client->dev.platform_data;
1352 }
1353
1354 if (!pdata) {
1355 FTS_ERROR("no ts platform data found");
1356 return -EINVAL;
1357 }
1358
1359 ts_data = devm_kzalloc(&client->dev, sizeof(*ts_data), GFP_KERNEL);
1360 if (!ts_data) {
1361 FTS_ERROR("Failed to allocate memory for fts_data");
1362 return -ENOMEM;
1363 }
1364
1365 fts_data = ts_data;
1366 ts_data->client = client;
1367 ts_data->pdata = pdata;
1368 i2c_set_clientdata(client, ts_data);
1369
1370 ts_data->ts_workqueue = create_singlethread_workqueue("fts_wq");
1371 if (NULL == ts_data->ts_workqueue) {
1372 FTS_ERROR("failed to create fts workqueue");
1373 }
1374
1375 spin_lock_init(&ts_data->irq_lock);
1376 mutex_init(&ts_data->report_mutex);
1377
1378 ret = fts_input_init(ts_data);
1379 if (ret) {
1380 FTS_ERROR("fts input initialize fail");
1381 goto err_input_init;
1382 }
1383
1384 ret = fts_gpio_configure(ts_data);
1385 if (ret) {
1386 FTS_ERROR("[GPIO]Failed to configure the gpios");
1387 goto err_gpio_config;
1388 }
1389
1390 #if FTS_POWER_SOURCE_CUST_EN
1391 ret = fts_power_source_init(ts_data);
1392 if (ret) {
1393 FTS_ERROR("fail to get vdd/vcc_i2c regulator");
1394 goto err_power_init;
1395 }
1396
1397 ts_data->power_disabled = true;
1398 ret = fts_power_source_ctrl(ts_data, ENABLE);
1399 if (ret) {
1400 FTS_ERROR("fail to enable vdd/vcc_i2c regulator");
1401 goto err_power_ctrl;
1402 }
1403
1404 #if FTS_PINCTRL_EN
1405 ret = fts_pinctrl_init(ts_data);
1406 if (0 == ret) {
1407 fts_pinctrl_select_normal(ts_data);
1408 }
1409 #endif
1410 #endif
1411
1412 #if (!FTS_CHIP_IDC)
1413 fts_reset_proc(200);
1414 #endif
1415
1416 ret = fts_get_ic_information(ts_data);
1417 if (ret) {
1418 FTS_ERROR("not focal IC, unregister driver");
1419 goto err_irq_req;
1420 }
1421
1422 #if FTS_APK_NODE_EN
1423 ret = fts_create_apk_debug_channel(ts_data);
1424 if (ret) {
1425 FTS_ERROR("create apk debug node fail");
1426 }
1427 #endif
1428
1429 #if FTS_SYSFS_NODE_EN
1430 ret = fts_create_sysfs(client);
1431 if (ret) {
1432 FTS_ERROR("create sysfs node fail");
1433 }
1434 #endif
1435
1436 #if FTS_POINT_REPORT_CHECK_EN
1437 ret = fts_point_report_check_init(ts_data);
1438 if (ret) {
1439 FTS_ERROR("init point report check fail");
1440 }
1441 #endif
1442
1443 ret = fts_ex_mode_init(client);
1444 if (ret) {
1445 FTS_ERROR("init glove/cover/charger fail");
1446 }
1447
1448 #if FTS_GESTURE_EN
1449 ret = fts_gesture_init(ts_data);
1450 if (ret) {
1451 FTS_ERROR("init gesture fail");
1452 }
1453 #endif
1454
1455 #if FTS_TEST_EN
1456 ret = fts_test_init(client);
1457 if (ret) {
1458 FTS_ERROR("init production test fail");
1459 }
1460 #endif
1461
1462 #if FTS_ESDCHECK_EN
1463 ret = fts_esdcheck_init(ts_data);
1464 if (ret) {
1465 FTS_ERROR("init esd check fail");
1466 }
1467 #endif
1468
1469 ret = fts_irq_registration(ts_data);
1470 if (ret) {
1471 FTS_ERROR("request irq failed");
1472 goto err_irq_req;
1473 }
1474
1475 #if FTS_AUTO_UPGRADE_EN
1476 ret = fts_fwupg_init(ts_data);
1477 if (ret) {
1478 FTS_ERROR("init fw upgrade fail");
1479 }
1480 #endif
1481
1482 #if defined(CONFIG_FB)
1483 if (ts_data->ts_workqueue) {
1484 INIT_WORK(&ts_data->resume_work, fts_resume_work);
1485 }
1486 ts_data->fb_notif.notifier_call = fb_notifier_callback;
1487 ret = fb_register_client(&ts_data->fb_notif);
1488 if (ret) {
1489 FTS_ERROR("[FB]Unable to register fb_notifier: %d", ret);
1490 }
1491 #elif defined(CONFIG_HAS_EARLYSUSPEND)
1492 ts_data->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + FTS_SUSPEND_LEVEL;
1493 ts_data->early_suspend.suspend = fts_ts_early_suspend;
1494 ts_data->early_suspend.resume = fts_ts_late_resume;
1495 register_early_suspend(&ts_data->early_suspend);
1496 #endif
1497
1498 FTS_FUNC_EXIT();
1499 return 0;
1500
1501 err_irq_req:
1502 if (gpio_is_valid(pdata->reset_gpio))
1503 gpio_free(pdata->reset_gpio);
1504 if (gpio_is_valid(pdata->irq_gpio))
1505 gpio_free(pdata->irq_gpio);
1506 err_gpio_config:
1507 #if FTS_POWER_SOURCE_CUST_EN
1508 #if FTS_PINCTRL_EN
1509 fts_pinctrl_select_release(ts_data);
1510 #endif
1511 fts_power_source_ctrl(ts_data, DISABLE);
1512 err_power_ctrl:
1513 fts_power_source_release(ts_data);
1514 err_power_init:
1515 #endif
1516 kfree_safe(ts_data->point_buf);
1517 kfree_safe(ts_data->events);
1518 input_unregister_device(ts_data->input_dev);
1519 err_input_init:
1520 if (ts_data->ts_workqueue)
1521 destroy_workqueue(ts_data->ts_workqueue);
1522 devm_kfree(&client->dev, ts_data);
1523
1524 FTS_FUNC_EXIT();
1525 return ret;
1526 }
1527
1528 /*****************************************************************************
1529 * Name: fts_ts_remove
1530 * Brief:
1531 * Input:
1532 * Output:
1533 * Return:
1534 *****************************************************************************/
fts_ts_remove(struct i2c_client * client)1535 static int fts_ts_remove(struct i2c_client *client)
1536 {
1537 struct fts_ts_data *ts_data = i2c_get_clientdata(client);
1538
1539 FTS_FUNC_ENTER();
1540
1541 #if FTS_POINT_REPORT_CHECK_EN
1542 fts_point_report_check_exit(ts_data);
1543 #endif
1544
1545 #if FTS_APK_NODE_EN
1546 fts_release_apk_debug_channel(ts_data);
1547 #endif
1548
1549 #if FTS_SYSFS_NODE_EN
1550 fts_remove_sysfs(client);
1551 #endif
1552
1553 fts_ex_mode_exit(client);
1554
1555 #if FTS_AUTO_UPGRADE_EN
1556 fts_fwupg_exit(ts_data);
1557 #endif
1558
1559 #if FTS_TEST_EN
1560 fts_test_exit(client);
1561 #endif
1562
1563 #if FTS_ESDCHECK_EN
1564 fts_esdcheck_exit(ts_data);
1565 #endif
1566
1567 #if FTS_GESTURE_EN
1568 fts_gesture_exit(client);
1569 #endif
1570
1571 #if defined(CONFIG_FB)
1572 if (fb_unregister_client(&ts_data->fb_notif))
1573 FTS_ERROR("Error occurred while unregistering fb_notifier.");
1574 #elif defined(CONFIG_HAS_EARLYSUSPEND)
1575 unregister_early_suspend(&ts_data->early_suspend);
1576 #endif
1577
1578 free_irq(ts_data->irq, ts_data);
1579 input_unregister_device(ts_data->input_dev);
1580
1581 if (gpio_is_valid(ts_data->pdata->reset_gpio))
1582 gpio_free(ts_data->pdata->reset_gpio);
1583
1584 if (gpio_is_valid(ts_data->pdata->irq_gpio))
1585 gpio_free(ts_data->pdata->irq_gpio);
1586
1587 if (ts_data->ts_workqueue)
1588 destroy_workqueue(ts_data->ts_workqueue);
1589
1590 #if FTS_POWER_SOURCE_CUST_EN
1591 #if FTS_PINCTRL_EN
1592 fts_pinctrl_select_release(ts_data);
1593 #endif
1594 fts_power_source_ctrl(ts_data, DISABLE);
1595 fts_power_source_release(ts_data);
1596 #endif
1597
1598 kfree_safe(ts_data->point_buf);
1599 kfree_safe(ts_data->events);
1600
1601 devm_kfree(&client->dev, ts_data);
1602
1603 FTS_FUNC_EXIT();
1604 return 0;
1605 }
1606
1607 /*****************************************************************************
1608 * Name: fts_ts_suspend
1609 * Brief:
1610 * Input:
1611 * Output:
1612 * Return:
1613 *****************************************************************************/
fts_ts_suspend(struct device * dev)1614 static int fts_ts_suspend(struct device *dev)
1615 {
1616 int ret = 0;
1617 struct fts_ts_data *ts_data = dev_get_drvdata(dev);
1618
1619 FTS_FUNC_ENTER();
1620 if (ts_data->suspended) {
1621 FTS_INFO("Already in suspend state");
1622 return 0;
1623 }
1624
1625 if (ts_data->fw_loading) {
1626 FTS_INFO("fw upgrade in process, can't suspend");
1627 return 0;
1628 }
1629
1630 #if FTS_ESDCHECK_EN
1631 fts_esdcheck_suspend();
1632 #endif
1633
1634 #if FTS_GESTURE_EN
1635 if (fts_gesture_suspend(ts_data->client) == 0) {
1636 ts_data->suspended = true;
1637 return 0;
1638 }
1639 #endif
1640
1641 fts_irq_disable();
1642
1643 #if FTS_POWER_SOURCE_CUST_EN
1644 ret = fts_power_source_ctrl(ts_data, DISABLE);
1645 if (ret < 0) {
1646 FTS_ERROR("power off fail, ret=%d", ret);
1647 }
1648 #if FTS_PINCTRL_EN
1649 fts_pinctrl_select_suspend(ts_data);
1650 #endif
1651 #else
1652 /* TP enter sleep mode */
1653 ret = fts_i2c_write_reg(ts_data->client, FTS_REG_POWER_MODE, FTS_REG_POWER_MODE_SLEEP_VALUE);
1654 if (ret < 0)
1655 FTS_ERROR("set TP to sleep mode fail, ret=%d", ret);
1656 #endif
1657
1658 ts_data->suspended = true;
1659 FTS_FUNC_EXIT();
1660 return 0;
1661 }
1662
1663 /*****************************************************************************
1664 * Name: fts_ts_resume
1665 * Brief:
1666 * Input:
1667 * Output:
1668 * Return:
1669 *****************************************************************************/
fts_ts_resume(struct device * dev)1670 static int fts_ts_resume(struct device *dev)
1671 {
1672 struct fts_ts_data *ts_data = dev_get_drvdata(dev);
1673
1674 FTS_FUNC_ENTER();
1675 if (!ts_data->suspended) {
1676 FTS_DEBUG("Already in awake state");
1677 return 0;
1678 }
1679
1680 fts_release_all_finger();
1681
1682 #if FTS_POWER_SOURCE_CUST_EN
1683 fts_power_source_ctrl(ts_data, ENABLE);
1684 #if FTS_PINCTRL_EN
1685 fts_pinctrl_select_normal(ts_data);
1686 #endif
1687 #endif
1688
1689 if (!ts_data->ic_info.is_incell) {
1690 fts_reset_proc(200);
1691 }
1692
1693 fts_tp_state_recovery(ts_data->client);
1694
1695 #if FTS_ESDCHECK_EN
1696 fts_esdcheck_resume();
1697 #endif
1698
1699 #if FTS_GESTURE_EN
1700 if (fts_gesture_resume(ts_data->client) == 0) {
1701 ts_data->suspended = false;
1702 return 0;
1703 }
1704 #endif
1705
1706 ts_data->suspended = false;
1707 fts_irq_enable();
1708
1709 FTS_FUNC_EXIT();
1710 return 0;
1711 }
1712
1713 static const struct dev_pm_ops focaltech_ts_pm_ops = {
1714 .suspend = fts_ts_suspend,
1715 .resume = fts_ts_resume,
1716 };
1717
1718 /*****************************************************************************
1719 * I2C Driver
1720 *****************************************************************************/
1721 static const struct i2c_device_id fts_ts_id[] = {
1722 {FTS_DRIVER_NAME, 0},
1723 {},
1724 };
1725 MODULE_DEVICE_TABLE(i2c, fts_ts_id);
1726
1727 static struct of_device_id fts_match_table[] = {
1728 { .compatible = "focaltech,fts", },
1729 { },
1730 };
1731
1732 static struct i2c_driver fts_ts_driver = {
1733 .probe = fts_ts_probe,
1734 .remove = fts_ts_remove,
1735 .driver = {
1736 .name = FTS_DRIVER_NAME,
1737 .owner = THIS_MODULE,
1738 .of_match_table = fts_match_table,
1739 #if !defined(CONFIG_FB) && defined(CONFIG_PM)
1740 .pm = &focaltech_ts_pm_ops,
1741 #endif
1742 },
1743 .id_table = fts_ts_id,
1744 };
1745
1746 /*****************************************************************************
1747 * Name: fts_ts_init
1748 * Brief:
1749 * Input:
1750 * Output:
1751 * Return:
1752 *****************************************************************************/
fts_ts_init(void)1753 static int __init fts_ts_init(void)
1754 {
1755 int ret = 0;
1756
1757 FTS_FUNC_ENTER();
1758 ret = i2c_add_driver(&fts_ts_driver);
1759 if ( ret != 0 ) {
1760 FTS_ERROR("Focaltech touch screen driver init failed!");
1761 }
1762 FTS_FUNC_EXIT();
1763 return ret;
1764 }
1765
1766 /*****************************************************************************
1767 * Name: fts_ts_exit
1768 * Brief:
1769 * Input:
1770 * Output:
1771 * Return:
1772 *****************************************************************************/
fts_ts_exit(void)1773 static void __exit fts_ts_exit(void)
1774 {
1775 i2c_del_driver(&fts_ts_driver);
1776 }
1777
1778 module_init(fts_ts_init);
1779 module_exit(fts_ts_exit);
1780
1781 MODULE_AUTHOR("FocalTech Driver Team");
1782 MODULE_DESCRIPTION("FocalTech Touchscreen Driver");
1783 MODULE_LICENSE("GPL v2");
1784