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