2 * Copyright (C) 2010,Imagis Technology Co. Ltd. All Rights Reserved.
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
16 #include <linux/version.h>
17 #include <linux/kernel.h>
18 #include <linux/module.h>
19 #include <linux/input.h>
20 #include <linux/interrupt.h>
21 #include <linux/i2c.h>
22 #include <linux/delay.h>
23 #include <linux/slab.h>
25 #include <linux/platform_device.h>
26 #include <linux/device.h>
27 #include <linux/mutex.h>
28 #include <linux/input/mt.h>
30 #include <linux/i2c/ist30xxc.h>
31 #include "ist30xxc_update.h"
32 #include "ist30xxc_tracking.h"
35 #include <linux/of_gpio.h>
36 #include <linux/of_device.h>
40 #include "ist30xxc_misc.h"
44 #include "ist30xxc_cmcs.h"
45 #if IST30XX_CMCS_JIT_TEST
46 #include "ist30xxc_cmcs_jit.h"
50 #ifdef CONFIG_SLEEP_MONITOR
51 #include <linux/power/sleep_monitor.h>
54 #define J5_100_OHM_VALUE 0xECEC0001
56 #define MAX_ERR_CNT (100)
57 #define EVENT_TIMER_INTERVAL (HZ * timer_period_ms / 1000)
58 u32 event_ms = 0, timer_ms = 0;
59 static struct timer_list event_timer;
60 static struct timespec t_current; /* nano seconds */
61 int timer_period_ms = 500; /* 500 msec */
63 extern int in_calibration(void);
66 int ist30xx_key_code[IST30XX_MAX_KEYS + 1] = { 0, KEY_RECENT, KEY_BACK, };
69 struct ist30xx_data *ts_data;
71 DEFINE_MUTEX(ist30xx_mutex);
73 int ist30xx_dbg_level = IST30XX_DEBUG_LEVEL;
74 void tsp_printk(int level, const char *fmt, ...)
79 if (ist30xx_dbg_level < level)
87 printk("%s %pV", IST30XX_DEBUG_TAG, &vaf);
92 long get_milli_second(void)
94 ktime_get_ts(&t_current);
96 return t_current.tv_sec * 1000 + t_current.tv_nsec / 1000000;
99 void ist30xx_delay(unsigned int ms)
102 usleep_range(ms * 1000, ms * 1000);
108 int ist30xx_intr_wait(struct ist30xx_data *data, long ms)
110 long start_ms = get_milli_second();
114 if (!data->irq_working)
117 curr_ms = get_milli_second();
118 if ((curr_ms < 0) || (start_ms < 0) || (curr_ms - start_ms > ms)) {
119 tsp_info("%s() timeout(%dms)\n", __func__, ms);
128 void ist30xx_disable_irq(struct ist30xx_data *data)
130 if (likely(data->irq_enabled)) {
131 ist30xx_tracking(TRACK_INTR_DISABLE);
132 disable_irq(data->client->irq);
133 data->irq_enabled = 0;
134 data->status.event_mode = false;
138 void ist30xx_enable_irq(struct ist30xx_data *data)
140 if (likely(!data->irq_enabled)) {
141 ist30xx_tracking(TRACK_INTR_ENABLE);
142 enable_irq(data->client->irq);
144 data->irq_enabled = 1;
145 data->status.event_mode = true;
149 void ist30xx_scheduled_reset(struct ist30xx_data *data)
151 if (likely(data->initialized))
152 schedule_delayed_work(&data->work_reset_check, 0);
155 static void ist30xx_request_reset(struct ist30xx_data *data)
158 if (unlikely(data->irq_err_cnt >= data->max_irq_err_cnt)) {
159 tsp_info("%s()\n", __func__);
160 ist30xx_scheduled_reset(data);
161 data->irq_err_cnt = 0;
165 #define NOISE_MODE_TA (0)
166 #define NOISE_MODE_CALL (1)
167 #define NOISE_MODE_COVER (2)
168 #define NOISE_MODE_EDGE (4)
169 #define NOISE_MODE_POWER (8)
170 void ist30xx_start(struct ist30xx_data *data)
172 if (data->initialized) {
173 data->scan_count = 0;
174 data->scan_retry = 0;
175 data->deep_sleep = false;
176 mod_timer(&event_timer, get_jiffies_64() + EVENT_TIMER_INTERVAL * 2);
179 ist30xx_write_cmd(data->client, IST30XX_HIB_CMD,
180 ((eHCOM_SET_MODE_SPECIAL << 16) | (data->noise_mode & 0xFFFF)));
182 /* Local Model info. do not use this. */
184 ist30xx_write_cmd(data->client, IST30XX_HIB_CMD,
185 ((eHCOM_SET_LOCAL_MODEL << 16) | (TSP_LOCAL_CODE & 0xFFFF)));
186 tsp_info("%s(), local : %d, mode : 0x%x\n", __func__,
187 TSP_LOCAL_CODE & 0xFFFF, data->noise_mode & 0xFFFF);
190 if (data->report_rate >= 0) {
191 ist30xx_write_cmd(data->client, IST30XX_HIB_CMD,
192 ((eHCOM_SET_TIME_ACTIVE << 16) | (data->report_rate & 0xFFFF)));
193 tsp_info("%s: active rate : %dus\n", __func__, data->report_rate);
196 if (data->idle_rate >= 0) {
197 ist30xx_write_cmd(data->client, IST30XX_HIB_CMD,
198 ((eHCOM_SET_TIME_IDLE << 16) | (data->idle_rate & 0xFFFF)));
199 tsp_info("%s: idle rate : %dus\n", __func__, data->idle_rate);
202 if (data->jig_mode) {
203 ist30xx_write_cmd(data->client, IST30XX_HIB_CMD,
204 (eHCOM_SET_JIG_MODE << 16) | (IST30XX_JIG_TOUCH & 0xFFFF));
205 tsp_info("%s: jig mode start\n", __func__);
208 if (data->debug_mode || data->jig_mode) {
209 ist30xx_write_cmd(data->client, IST30XX_HIB_CMD,
210 (eHCOM_SLEEP_MODE_EN << 16) | (IST30XX_DISABLE & 0xFFFF));
211 tsp_info("%s: debug mode start\n", __func__);
214 ist30xx_cmd_start_scan(data);
217 int ist30xx_get_ver_info(struct ist30xx_data *data)
221 data->fw.prev.main_ver = data->fw.cur.main_ver;
222 data->fw.prev.fw_ver = data->fw.cur.fw_ver;
223 data->fw.prev.core_ver = data->fw.cur.core_ver;
224 data->fw.prev.test_ver = data->fw.cur.test_ver;
225 data->fw.cur.main_ver = 0;
226 data->fw.cur.fw_ver = 0;
227 data->fw.cur.core_ver = 0;
228 data->fw.cur.test_ver = 0;
230 ret = ist30xx_cmd_hold(data, 1);
234 ret = ist30xx_read_reg(data->client,
235 IST30XX_DA_ADDR(eHCOM_GET_VER_MAIN), &data->fw.cur.main_ver);
239 ret = ist30xx_read_reg(data->client,
240 IST30XX_DA_ADDR(eHCOM_GET_VER_FW), &data->fw.cur.fw_ver);
244 ret = ist30xx_read_reg(data->client,
245 IST30XX_DA_ADDR(eHCOM_GET_VER_CORE), &data->fw.cur.core_ver);
249 ret = ist30xx_read_reg(data->client,
250 IST30XX_DA_ADDR(eHCOM_GET_VER_TEST), &data->fw.cur.test_ver);
254 ret = ist30xx_cmd_hold(data, 0);
258 tsp_info("IC version main: %x, fw: %x, test: %x, core: %x\n",
259 data->fw.cur.main_ver, data->fw.cur.fw_ver, data->fw.cur.test_ver,
260 data->fw.cur.core_ver);
265 ist30xx_reset(data, false);
270 #define CALIB_MSG_MASK (0xF0000FFF)
271 #define CALIB_MSG_VALID (0x80000CAB)
272 #define TRACKING_INTR_VALID (0x127EA597)
273 u32 tracking_intr_value = TRACKING_INTR_VALID;
274 int ist30xx_get_info(struct ist30xx_data *data)
280 mutex_lock(&ist30xx_mutex);
281 ist30xx_disable_irq(data);
283 #if IST30XX_INTERNAL_BIN
284 #if IST30XX_UPDATE_BY_WORKQUEUE
285 ist30xx_get_update_info(data, data->fw.buf, data->fw.buf_size);
287 ist30xx_get_tsp_info(data);
289 ret = ist30xx_get_ver_info(data);
293 ret = ist30xx_get_tsp_info(data);
296 #endif /* IST30XX_INTERNAL_BIN */
298 /* remove "print information" -> read sysfs : /sys/class/touch/sys/ic_inform */
300 ist30xx_print_info(data);
302 ret = ist30xx_read_cmd(data, eHCOM_GET_CAL_RESULT, &calib_msg);
303 if (likely(ret == 0)) {
304 tsp_info("calib status: 0x%08x\n", calib_msg);
305 ms = get_milli_second();
306 ist30xx_put_track_ms(ms);
307 ist30xx_put_track(&tracking_intr_value, 1);
308 ist30xx_put_track(&calib_msg, 1);
309 if ((calib_msg & CALIB_MSG_MASK) != CALIB_MSG_VALID ||
310 CALIB_TO_STATUS(calib_msg) > 0) {
311 ist30xx_calibrate(data, IST30XX_MAX_RETRY_CNT);
315 #if IST30XX_CHECK_CALIB
316 if (likely(!data->status.update)) {
317 ret = ist30xx_cmd_check_calib(data->client);
319 data->status.calib = 1;
320 data->status.calib_msg = 0;
321 event_ms = (u32)get_milli_second();
322 data->status.event_mode = true;
329 #if !(IST30XX_INTERNAL_BIN)
333 ist30xx_enable_irq(data);
334 mutex_unlock(&ist30xx_mutex);
339 #if (IST30XX_GESTURE || IST30XX_SURFACE_TOUCH || IST30XX_BLADE_TOUCH)
340 #define SPECIAL_MAGIC_STRING (0x4170CF00)
341 #define SPECIAL_MAGIC_MASK (0xFFFFFF00)
342 #define SPECIAL_MESSAGE_MASK (~SPECIAL_MAGIC_MASK)
343 #define PARSE_SPECIAL_MESSAGE(n) \
344 ((n & SPECIAL_MAGIC_MASK) == SPECIAL_MAGIC_STRING ? \
345 (n & SPECIAL_MESSAGE_MASK) : -EINVAL)
346 #define SPECIAL_START_MASK (0x80)
347 #define SPECIAL_SUCCESS_MASK (0x0F)
348 #define MAX_LK_KEYCODE_NUM (256)
350 void ist30xx_special_cmd(struct ist30xx_data *data, int cmd)
353 if (((cmd > 0x40) && (cmd < 0x5B)) || ((cmd > 0x90) && (cmd < 0x9A))) {
354 tsp_info("Gesture touch: 0x%02X\n", cmd);
359 #if IST30XX_BLADE_TOUCH
360 if (((cmd & (~SPECIAL_START_MASK)) >= 0x10) &&
361 ((cmd & (~SPECIAL_START_MASK)) <= 0x14)) {
362 if (cmd & SPECIAL_START_MASK) {
363 tsp_info("Blade touch start: 0x%02X\n", cmd);
365 if ((cmd & SPECIAL_SUCCESS_MASK) > 0) {
366 tsp_info("Blade touch stop: 0x%02X\n", cmd);
368 tsp_info("Blade touch cancel: 0x%02X\n", cmd);
375 #if IST30XX_SURFACE_TOUCH
376 if (((cmd & (~SPECIAL_START_MASK)) >= 0x20) &&
377 ((cmd & (~SPECIAL_START_MASK)) <= 0x21)) {
378 if (cmd & SPECIAL_START_MASK) {
379 tsp_info("Surface touch start: 0x%02X\n", cmd);
381 if ((cmd & SPECIAL_SUCCESS_MASK) > 0) {
382 tsp_info("Surface touch stop: 0x%02X\n", cmd);
384 tsp_info("Surface touch cancel: 0x%02X\n", cmd);
392 tsp_warn("Not support special cmd: 0x%02X\n", cmd);
396 #define PRESS_MSG_MASK (0x01)
397 #define MULTI_MSG_MASK (0x02)
398 #define TOUCH_DOWN_MESSAGE ("P")
399 #define TOUCH_UP_MESSAGE ("R")
400 #define TOUCH_MOVE_MESSAGE ("M")
401 bool tsp_touched[IST30XX_MAX_MT_FINGERS] = { false, };
403 void print_tsp_event(struct ist30xx_data *data, finger_info *finger)
405 int idx = finger->bit_field.id - 1;
408 press = PRESSED_FINGER(data->t_status, finger->bit_field.id);
411 if (tsp_touched[idx] == false) {
413 data->touch_pressed_num++;
414 tsp_noti("%s [%d] x=%d y=%d z=%d\n",
415 TOUCH_DOWN_MESSAGE, idx,
418 data->z_values[idx]);
419 tsp_touched[idx] = true;
422 tsp_debug("%s [%d] x=%d y=%d z=%d\n",
423 TOUCH_MOVE_MESSAGE, idx,
426 data->z_values[idx]);
429 data->lx[idx] = finger->bit_field.x;
430 data->ly[idx] = finger->bit_field.y;
432 if (tsp_touched[idx] == true) {
434 data->touch_pressed_num--;
435 #ifdef CONFIG_SLEEP_MONITOR
438 tsp_noti("%s [%d] x=%d y=%d\n", TOUCH_UP_MESSAGE,
439 finger->bit_field.id-1,
442 tsp_touched[idx] = false;
447 #define PRESS_MSG_KEY (0x06)
448 bool tkey_pressed[IST30XX_MAX_KEYS] = { false, };
450 /* key product_ship log will be add after unpin feature */
451 void print_tkey_event(struct ist30xx_data *data, int id)
454 bool press = PRESSED_KEY(data->t_status, id);
457 if (tkey_pressed[idx] == false) {
459 tsp_noti("k %s%d\n", TOUCH_DOWN_MESSAGE, id);
460 tkey_pressed[idx] = true;
463 if (tkey_pressed[idx] == true) {
465 tsp_noti("k %s%d\n", TOUCH_UP_MESSAGE, id);
466 tkey_pressed[idx] = false;
471 static void release_finger(struct ist30xx_data *data, int id)
473 input_mt_slot(data->input_dev, id - 1);
474 input_mt_report_slot_state(data->input_dev, MT_TOOL_FINGER, false);
476 ist30xx_tracking(TRACK_POS_FINGER + id);
477 tsp_info("%s() %d\n", __func__, id);
479 tsp_touched[id - 1] = false;
481 input_sync(data->input_dev);
485 #define CANCEL_KEY (0xFF)
486 #define RELEASE_KEY (0)
487 static void release_key(struct ist30xx_data *data, int id, u8 key_status)
489 input_report_key(data->input_dev, ist30xx_key_code[id], key_status);
491 ist30xx_tracking(TRACK_POS_KEY + id);
492 tsp_info("%s() key%d, status: %d\n", __func__, id, key_status);
494 tkey_pressed[id - 1] = false;
496 input_sync(data->input_dev);
499 static void clear_input_data(struct ist30xx_data *data)
504 status = PARSE_FINGER_STATUS(data->t_status);
507 release_finger(data, id);
513 status = PARSE_KEY_STATUS(data->t_status);
516 release_key(data, id, RELEASE_KEY);
522 #ifdef CONFIG_INPUT_BOOSTER
523 if (data->tsp_booster && data->tsp_booster->dvfs_set)
524 data->tsp_booster->dvfs_set(data->tsp_booster, -1);
525 data->touch_pressed_num = 0;
531 static int check_report_fingers(struct ist30xx_data *data, int finger_counts)
534 finger_info *fingers = (finger_info *)data->fingers;
536 /* current finger info */
537 for (i = 0; i < finger_counts; i++) {
538 if (unlikely((fingers[i].bit_field.x >= data->max_x) ||
539 (fingers[i].bit_field.y >= data->max_y))) {
540 tsp_warn("Invalid touch data - %d: %d(%d, %d), 0x%08x\n", i,
541 fingers[i].bit_field.id,
542 fingers[i].bit_field.x,
543 fingers[i].bit_field.y,
544 fingers[i].full_field);
546 fingers[i].bit_field.id = 0;
547 ist30xx_tracking(TRACK_POS_UNKNOWN);
555 static int check_valid_coord(u32 *msg, int cnt)
558 u8 chksum1 = msg[0] >> 24;
562 msg[0] &= 0x00FFFFFF;
564 cnt *= IST30XX_DATA_LEN;
571 if (chksum1 != chksum2) {
572 tsp_err("intr chksum: %02x, %02x\n", chksum1, chksum2);
579 static void report_input_data(struct ist30xx_data *data, int finger_counts,
584 finger_info *fingers = (finger_info *)data->fingers;
585 u32 *z_values = (u32 *)data->z_values;
589 status = PARSE_FINGER_STATUS(data->t_status);
590 for (id = 0; id < IST30XX_MAX_MT_FINGERS; id++) {
591 press = (status & (1 << id)) ? true : false;
593 input_mt_slot(data->input_dev, id);
594 input_mt_report_slot_state(data->input_dev, MT_TOOL_FINGER, press);
596 fingers[idx].bit_field.id = id + 1;
597 print_tsp_event(data, &fingers[idx]);
600 input_report_key(data->input_dev, BTN_TOUCH, 0);
601 input_report_key(data->input_dev, BTN_TOOL_FINGER, 0);
603 } else if (!tsp_touched[id]) {
604 input_report_key(data->input_dev, BTN_TOUCH, 1);
605 input_report_key(data->input_dev, BTN_TOOL_FINGER, 1);
608 input_report_abs(data->input_dev, ABS_MT_POSITION_X,
609 fingers[idx].bit_field.x);
610 input_report_abs(data->input_dev, ABS_MT_POSITION_Y,
611 fingers[idx].bit_field.y);
612 input_report_abs(data->input_dev, ABS_MT_TOUCH_MAJOR,
613 fingers[idx].bit_field.area);
615 input_report_abs(data->input_dev, ABS_MT_PRESSURE, z_values[idx]);
620 status = PARSE_KEY_STATUS(data->t_status);
621 for (id = 0; id < IST30XX_MAX_KEYS; id++) {
622 press = (status & (1 << id)) ? true : false;
624 input_report_key(data->input_dev, ist30xx_key_code[id + 1], press);
626 print_tkey_event(data, id + 1);
628 #endif /* IST30XX_USE_KEY */
630 data->irq_err_cnt = 0;
631 data->scan_retry = 0;
633 input_sync(data->input_dev);
637 * CMD : CMD_GET_COORD
639 * 1st [31:24] [23:21] [20:16] [15:12] [11:10] [9:0]
640 * Checksum KeyCnt KeyStatus FingerCnt Rsvd. FingerStatus
641 * 2nd [31:28] [27:24] [23:12] [11:0]
644 #define TRACKING_INTR_DEBUG1_VALID (0x127A6E81)
645 #define TRACKING_INTR_DEBUG2_VALID (0x127A6E82)
646 #define TRACKING_INTR_DEBUG3_VALID (0x127A6E83)
647 u32 tracking_intr_debug_value = 0;
648 u32 intr_debug_addr, intr_debug2_addr, intr_debug3_addr = 0;
649 u32 intr_debug_size, intr_debug2_size, intr_debug3_size = 0;
650 static irqreturn_t ist30xx_irq_thread(int irq, void *ptr)
653 int key_cnt, finger_cnt, read_cnt;
654 struct ist30xx_data *data = (struct ist30xx_data *)ptr;
656 #if IST30XX_STATUS_DEBUG
660 u32 msg[IST30XX_MAX_MT_FINGERS * 2 + offset];
663 data->irq_working = true;
665 if (unlikely(!data->irq_enabled))
668 if (data->track_enable) {
669 ms = get_milli_second();
671 if (intr_debug_addr >= 0 && intr_debug_size > 0) {
672 tsp_noti("Intr_debug (addr: 0x%08x)\n", intr_debug_addr);
673 ist30xx_burst_read(data->client, IST30XX_DA_ADDR(intr_debug_addr),
674 &msg[0], intr_debug_size, true);
676 for (i = 0; i < intr_debug_size; i++)
677 tsp_noti("\t%08x\n", msg[i]);
679 tracking_intr_debug_value = TRACKING_INTR_DEBUG1_VALID;
680 ist30xx_put_track_ms(ms);
681 ist30xx_put_track(&tracking_intr_debug_value, 1);
682 ist30xx_put_track(msg, intr_debug_size);
685 if (intr_debug2_addr >= 0 && intr_debug2_size > 0) {
686 tsp_noti("Intr_debug2 (addr: 0x%08x)\n", intr_debug2_addr);
687 ist30xx_burst_read(data->client, IST30XX_DA_ADDR(intr_debug2_addr),
688 &msg[0], intr_debug2_size, true);
690 for (i = 0; i < intr_debug2_size; i++)
691 tsp_noti("\t%08x\n", msg[i]);
693 tracking_intr_debug_value = TRACKING_INTR_DEBUG2_VALID;
694 ist30xx_put_track_ms(ms);
695 ist30xx_put_track(&tracking_intr_debug_value, 1);
696 ist30xx_put_track(msg, intr_debug2_size);
700 memset(msg, 0, sizeof(msg));
702 ret = ist30xx_read_reg(data->client, IST30XX_HIB_INTR_MSG, msg);
706 tsp_verb("intr msg: 0x%08x\n", *msg);
708 /* TSP IC Exception */
709 if (unlikely((*msg & IST30XX_EXCEPT_MASK) == IST30XX_EXCEPT_VALUE)) {
710 tsp_err("Occured IC exception(0x%02X)\n", *msg & 0xFF);
712 ret = ist30xx_burst_read(data->client,
713 IST30XX_HIB_COORD, &msg[offset], IST30XX_MAX_EXCEPT_SIZE, true);
715 for (i = 0; i < IST30XX_MAX_EXCEPT_SIZE; i++) {
716 ret = ist30xx_read_reg(data->client,
717 IST30XX_HIB_COORD + (i * 4), &msg[i + offset]);
721 tsp_err(" exception value read error(%d)\n", ret);
723 tsp_err(" exception value : 0x%08X, 0x%08X\n", msg[1], msg[2]);
728 if (unlikely(*msg == 0 || *msg == 0xFFFFFFFF)) /* Unknown CMD */
731 if (data->track_enable) {
733 ist30xx_put_track_ms(event_ms);
734 ist30xx_put_track(&tracking_intr_value, 1);
735 ist30xx_put_track(msg, 1);
738 if (unlikely((*msg & CALIB_MSG_MASK) == CALIB_MSG_VALID)) {
739 data->status.calib_msg = *msg;
740 tsp_info("calib status: 0x%08x\n", data->status.calib_msg);
745 #if IST30XX_CMCS_TEST
746 if (unlikely(*msg == IST30XX_CMCS_MSG_VALID)) {
747 data->status.cmcs = 1;
748 tsp_info("cmcs status: 0x%08x\n", *msg);
753 #if IST30XX_CMCS_JIT_TEST
754 if (((*msg & CMCS_MSG_MASK) == CM_MSG_VALID) || ((*msg & CMCS_MSG_MASK) == CS_MSG_VALID)) {
755 data->status.cmcs = *msg;
756 tsp_info("cmcs status: 0x%08x\n", *msg);
763 #if (IST30XX_GESTURE || IST30XX_SURFACE_TOUCH || IST30XX_BLADE_TOUCH)
764 ret = PARSE_SPECIAL_MESSAGE(*msg);
765 if (unlikely(ret > 0)) {
766 tsp_verb("special cmd: %d (0x%08x)\n", ret, *msg);
767 ist30xx_special_cmd(data, ret);
773 #if IST30XX_STATUS_DEBUG
774 ret = ist30xx_read_reg(data->client,
775 IST30XX_HIB_TOUCH_STATUS, &touch_status);
778 tsp_debug("ALG : 0x%08X\n", touch_status);
781 memset(data->fingers, 0, sizeof(data->fingers));
783 /* Unknown interrupt data for extend coordinate */
784 if (unlikely(!CHECK_INTR_STATUS(*msg)))
788 key_cnt = PARSE_KEY_CNT(t_status);
789 finger_cnt = PARSE_FINGER_CNT(t_status);
791 if (unlikely((finger_cnt > data->max_fingers) ||
792 (key_cnt > data->max_keys))) {
793 tsp_warn("Invalid touch count - finger: %d(%d), key: %d(%d)\n",
794 finger_cnt, data->max_fingers, key_cnt, data->max_keys);
798 if (finger_cnt > 0) {
800 ret = ist30xx_burst_read(data->client,
801 IST30XX_HIB_COORD, &msg[offset], finger_cnt, true);
805 for (i = 0; i < finger_cnt; i++)
806 data->fingers[i].full_field = msg[i + offset];
808 for (i = 0; i < finger_cnt; i++) {
809 ret = ist30xx_read_reg(data->client,
810 IST30XX_HIB_COORD + (i * 4), &msg[i + offset]);
814 data->fingers[i].full_field = msg[i + offset];
816 #endif /* I2C_BURST_MODE */
818 if (data->jig_mode) {
819 /* z-values ram address define */
820 ret = ist30xx_burst_read(data->client,
821 IST30XX_DA_ADDR(data->tags.zvalue_base),
822 data->z_values, finger_cnt, true);
825 if (data->track_enable) {
827 ist30xx_put_track(msg + offset, finger_cnt);
828 for (i = 0; i < finger_cnt; i++) {
829 tsp_verb("intr msg(%d): 0x%08x, %d\n",
830 i + offset, msg[i + offset], data->z_values[i]);
836 read_cnt = finger_cnt + 1;
838 ret = check_valid_coord(&msg[0], read_cnt);
842 if (data->track_enable) {
843 ret = check_report_fingers(data, finger_cnt);
848 data->t_status = t_status;
849 report_input_data(data, finger_cnt, key_cnt);
851 #ifdef CONFIG_INPUT_BOOSTER
852 if (data->tsp_booster && data->tsp_booster->dvfs_set)
853 data->tsp_booster->dvfs_set(data->tsp_booster, !!data->touch_pressed_num);
856 if (data->track_enable) {
857 if (intr_debug3_addr >= 0 && intr_debug3_size > 0) {
858 tsp_noti("Intr_debug3 (addr: 0x%08x)\n", intr_debug3_addr);
859 ist30xx_burst_read(data->client, IST30XX_DA_ADDR(intr_debug3_addr),
860 &msg[0], intr_debug3_size, true);
862 for (i = 0; i < intr_debug3_size; i++)
863 tsp_noti("\t%08x\n", msg[i]);
865 tracking_intr_debug_value = TRACKING_INTR_DEBUG3_VALID;
866 ist30xx_put_track_ms(ms);
867 ist30xx_put_track(&tracking_intr_debug_value, 1);
868 ist30xx_put_track(msg, intr_debug3_size);
875 tsp_err("intr msg: 0x%08x, ret: %d\n", msg[0], ret);
879 ist30xx_request_reset(data);
881 data->irq_working = false;
883 if (data->track_enable)
884 event_ms = (u32)get_milli_second();
889 ist30xx_scheduled_reset(data);
890 data->irq_working = false;
891 if (data->track_enable)
892 event_ms = (u32)get_milli_second();
898 static int ist30xx_pinctrl_configure(struct ist30xx_data *data, bool active)
900 struct pinctrl_state *set_state;
903 tsp_err("%s: %s\n", __func__, active ? "ACTIVE" : "SUSPEND");
905 set_state = pinctrl_lookup_state(data->pinctrl, active ? "active_state" : "suspend_state");
906 if (IS_ERR(set_state)) {
907 tsp_err("%s: cannot get active state\n", __func__);
911 retval = pinctrl_select_state(data->pinctrl, set_state);
913 tsp_err("%s: cannot set pinctrl %s state\n",
914 __func__, active ? "active" : "suspend");
922 static int ist30xx_suspend(struct device *dev)
924 struct i2c_client *client = to_i2c_client(dev);
925 struct ist30xx_data *data = i2c_get_clientdata(client);
927 del_timer(&event_timer);
928 cancel_delayed_work_sync(&data->work_noise_protect);
929 cancel_delayed_work_sync(&data->work_reset_check);
930 cancel_delayed_work_sync(&data->work_debug_algorithm);
931 mutex_lock(&ist30xx_mutex);
932 ist30xx_disable_irq(data);
933 ist30xx_internal_suspend(data);
934 clear_input_data(data);
938 data->status.noise_mode = false;
939 ist30xx_enable_irq(data);
942 mutex_unlock(&ist30xx_mutex);
947 static int ist30xx_resume(struct device *dev)
949 struct i2c_client *client = to_i2c_client(dev);
950 struct ist30xx_data *data = i2c_get_clientdata(client);
952 data->noise_mode |= (1 << NOISE_MODE_POWER);
954 mutex_lock(&ist30xx_mutex);
955 ist30xx_internal_resume(data);
957 ist30xx_enable_irq(data);
958 mutex_unlock(&ist30xx_mutex);
963 #ifdef CONFIG_HAS_EARLYSUSPEND
964 static void ist30xx_early_suspend(struct early_suspend *h)
966 struct ist30xx_data *data = container_of(h, struct ist30xx_data,
969 ist30xx_suspend(&data->client->dev);
971 static void ist30xx_late_resume(struct early_suspend *h)
973 struct ist30xx_data *data = container_of(h, struct ist30xx_data,
976 ist30xx_resume(&data->client->dev);
980 static void ist30xx_ts_close(struct input_dev *dev)
982 struct ist30xx_data *data = input_get_drvdata(dev);
984 if (data->touch_stopped) {
985 tsp_err("%s: IC is already on\n", __func__);
989 tsp_info("%s\n", __func__);
990 data->touch_stopped = true;
991 ist30xx_suspend(&data->client->dev);
995 int ret = ist30xx_pinctrl_configure(data, false);
997 tsp_err("%s: cannot set pinctrl state\n", __func__);
1001 static int ist30xx_ts_open(struct input_dev *dev)
1003 struct ist30xx_data *data = input_get_drvdata(dev);
1005 if (!data->touch_stopped) {
1006 tsp_err("%s: IC is already on\n", __func__);
1009 tsp_info("%s\n", __func__);
1011 if (data->pinctrl) {
1012 int ret = ist30xx_pinctrl_configure(data, true);
1014 tsp_err("%s: cannot set pinctrl state\n", __func__);
1017 ist30xx_resume(&data->client->dev);
1018 data->touch_stopped = false;
1020 tsp_info("%s: IC version fw(main, test, core): %x(%x, %x, %x)\n", __func__,
1021 data->fw.cur.fw_ver, data->fw.cur.main_ver,
1022 data->fw.cur.test_ver, data->fw.cur.core_ver);
1027 void ist30xx_set_ta_mode(bool mode)
1029 tsp_info("%s: %sconnected\n", __func__, mode ? "":"dis");
1031 if (unlikely(mode == ((ts_data->noise_mode >> NOISE_MODE_TA) & 1)))
1035 ts_data->noise_mode |= (1 << NOISE_MODE_TA);
1037 ts_data->noise_mode &= ~(1 << NOISE_MODE_TA);
1039 #if IST30XX_TA_RESET
1040 if (unlikely(ts_data->initialized))
1041 ist30xx_scheduled_reset(ts_data);
1043 ist30xx_write_cmd(ts_data->client, IST30XX_HIB_CMD,
1044 ((eHCOM_SET_MODE_SPECIAL << 16) | (ts_data->noise_mode & 0xFFFF)));
1047 ist30xx_tracking(mode ? TRACK_CMD_TACON : TRACK_CMD_TADISCON);
1049 EXPORT_SYMBOL(ist30xx_set_ta_mode);
1051 void ist30xx_set_edge_mode(int mode)
1053 tsp_info("%s(), mode = %d\n", __func__, mode);
1056 ts_data->noise_mode |= (1 << NOISE_MODE_EDGE);
1058 ts_data->noise_mode &= ~(1 << NOISE_MODE_EDGE);
1060 ist30xx_write_cmd(ts_data->client, IST30XX_HIB_CMD,
1061 ((eHCOM_SET_MODE_SPECIAL << 16) | (ts_data->noise_mode & 0xFFFF)));
1063 EXPORT_SYMBOL(ist30xx_set_edge_mode);
1065 void ist30xx_set_call_mode(int mode)
1067 tsp_info("%s(), mode = %d\n", __func__, mode);
1069 if (unlikely(mode == ((ts_data->noise_mode >> NOISE_MODE_CALL) & 1)))
1073 ts_data->noise_mode |= (1 << NOISE_MODE_CALL);
1075 ts_data->noise_mode &= ~(1 << NOISE_MODE_CALL);
1077 #if IST30XX_TA_RESET
1078 if (unlikely(ts_data->initialized))
1079 ist30xx_scheduled_reset(ts_data);
1081 ist30xx_write_cmd(ts_data->client, IST30XX_HIB_CMD,
1082 ((eHCOM_SET_MODE_SPECIAL << 16) | (ts_data->noise_mode & 0xFFFF)));
1085 ist30xx_tracking(mode ? TRACK_CMD_CALL : TRACK_CMD_NOTCALL);
1087 EXPORT_SYMBOL(ist30xx_set_call_mode);
1089 void ist30xx_set_cover_mode(int mode)
1091 tsp_info("%s(), mode = %d\n", __func__, mode);
1093 if (unlikely(mode == ((ts_data->noise_mode >> NOISE_MODE_COVER) & 1)))
1097 ts_data->noise_mode |= (1 << NOISE_MODE_COVER);
1099 ts_data->noise_mode &= ~(1 << NOISE_MODE_COVER);
1101 #if IST30XX_TA_RESET
1102 if (unlikely(ts_data->initialized))
1103 ist30xx_scheduled_reset(ts_data);
1105 ist30xx_write_cmd(ts_data->client, IST30XX_HIB_CMD,
1106 ((eHCOM_SET_MODE_SPECIAL << 16) | (ts_data->noise_mode & 0xFFFF)));
1109 ist30xx_tracking(mode ? TRACK_CMD_COVER : TRACK_CMD_NOTCOVER);
1111 EXPORT_SYMBOL(ist30xx_set_cover_mode);
1113 #ifdef USE_TSP_TA_CALLBACKS
1114 void charger_enable(struct tsp_callbacks *cb, int enable)
1116 bool charging = enable ? true : false;
1118 ist30xx_set_ta_mode(charging);
1121 static void ist30xx_register_callback(struct tsp_callbacks *cb)
1123 ist30xxc_charger_callbacks = cb;
1124 pr_info("%s\n", __func__);
1128 static void reset_work_func(struct work_struct *work)
1130 struct delayed_work *delayed_work = to_delayed_work(work);
1131 struct ist30xx_data *data = container_of(delayed_work,
1132 struct ist30xx_data, work_reset_check);
1134 if (unlikely((data == NULL) || (data->client == NULL)))
1137 if (likely((data->initialized == 1) && (data->status.power == 1) &&
1138 (data->status.update != 1) && (data->status.calib != 1))) {
1140 mutex_lock(&ist30xx_mutex);
1141 ist30xx_disable_irq(data);
1144 ist30xx_internal_suspend(data);
1147 ist30xx_reset(data, false);
1148 clear_input_data(data);
1149 ist30xx_start(data);
1151 if (data->gesture && data->suspend)
1152 data->status.noise_mode = false;
1154 ist30xx_enable_irq(data);
1155 mutex_unlock(&ist30xx_mutex);
1159 #if IST30XX_INTERNAL_BIN
1160 #if IST30XX_UPDATE_BY_WORKQUEUE
1161 static void fw_update_func(struct work_struct *work)
1163 struct delayed_work *delayed_work = to_delayed_work(work);
1164 struct ist30xx_data *data = container_of(delayed_work,
1165 struct ist30xx_data, work_fw_update);
1167 if (unlikely((data == NULL) || (data->client == NULL)))
1170 tsp_info("FW update function\n");
1172 if (likely(ist30xx_auto_bin_update(data)))
1173 ist30xx_disable_irq(data);
1175 #endif /* IST30XX_UPDATE_BY_WORKQUEUE */
1176 #endif /* IST30XX_INTERNAL_BIN */
1178 #define TOUCH_STATUS_MAGIC (0x00000075)
1179 #define TOUCH_STATUS_MASK (0x000000FF)
1180 #define FINGER_ENABLE_MASK (0x00100000)
1181 #define DEEP_SLEEP_MASK (0x00080000)
1182 #define SCAN_CNT_MASK (0xFFE00000)
1183 #define GET_FINGER_ENABLE(n) ((n & FINGER_ENABLE_MASK) >> 20)
1184 #define GET_DEEP_SLEEP_STATUS(n) ((n & DEEP_SLEEP_MASK) >> 19)
1185 #define GET_SCAN_CNT(n) ((n & SCAN_CNT_MASK) >> 21)
1186 u32 ist30xx_algr_addr = 0, ist30xx_algr_size = 0;
1187 static void noise_work_func(struct work_struct *work)
1190 u32 touch_status = 0;
1192 struct delayed_work *delayed_work = to_delayed_work(work);
1193 struct ist30xx_data *data = container_of(delayed_work,
1194 struct ist30xx_data, work_noise_protect);
1196 ret = ist30xx_read_reg(data->client,
1197 IST30XX_HIB_TOUCH_STATUS, &touch_status);
1198 if (unlikely(ret)) {
1199 tsp_warn("Touch status read fail!\n");
1203 ist30xx_put_track_ms(timer_ms);
1204 ist30xx_put_track(&touch_status, 1);
1206 tsp_verb("Touch Info: 0x%08x\n", touch_status);
1208 /* Check valid scan count */
1209 if (unlikely((touch_status & TOUCH_STATUS_MASK) != TOUCH_STATUS_MAGIC)) {
1210 tsp_warn("Touch status is not corrected! (0x%08x)\n", touch_status);
1214 /* Status of IC is deep sleep */
1215 data->deep_sleep = GET_DEEP_SLEEP_STATUS(touch_status) ? true : false;
1217 /* Status of IC is idle */
1218 if (GET_FINGER_ENABLE(touch_status) == 0) {
1219 if ((PARSE_FINGER_CNT(data->t_status) > 0) ||
1220 (PARSE_KEY_CNT(data->t_status) > 0))
1221 clear_input_data(data);
1224 scan_count = GET_SCAN_CNT(touch_status);
1226 /* Status of IC is lock-up */
1227 if (unlikely(scan_count == data->scan_count)) {
1228 tsp_warn("TSP IC is not responded! (0x%08x)\n", scan_count);
1232 data->scan_retry = 0;
1233 data->scan_count = scan_count;
1238 tsp_warn("Retry touch status!(%d)\n", data->scan_retry);
1240 if (unlikely(data->scan_retry == data->max_scan_retry)) {
1241 ist30xx_scheduled_reset(data);
1242 data->scan_retry = 0;
1246 static void debug_work_func(struct work_struct *work)
1248 #if IST30XX_ALGORITHM_MODE
1253 struct delayed_work *delayed_work = to_delayed_work(work);
1254 struct ist30xx_data *data = container_of(delayed_work,
1255 struct ist30xx_data, work_debug_algorithm);
1257 buf32 = kzalloc(ist30xx_algr_size, GFP_KERNEL);
1259 tsp_info("%s: Couldn't Allocate memory\n", __func__);
1263 for (i = 0; i < ist30xx_algr_size; i++) {
1264 ret = ist30xx_read_buf(data->client,
1265 ist30xx_algr_addr + IST30XX_DATA_LEN * i, &buf32[i], 1);
1267 tsp_warn("Algorithm mem addr read fail!\n");
1272 ist30xx_put_track(buf32, ist30xx_algr_size);
1274 tsp_debug(" 0x%08x 0x%08x 0x%08x 0x%08x 0x%08x\n",
1275 buf32[0], buf32[1], buf32[2], buf32[3], buf32[4]);
1280 void timer_handler(unsigned long timer_data)
1282 struct ist30xx_data *data = (struct ist30xx_data *)timer_data;
1283 struct ist30xx_status *status = &data->status;
1285 if (data->irq_working)
1288 if (status->event_mode) {
1289 if (likely((status->power == 1) && (status->update != 1))) {
1290 timer_ms = (u32)get_milli_second();
1291 if (unlikely(status->calib == 1)) {
1292 /* Check calibration */
1293 if ((status->calib_msg & CALIB_MSG_MASK) == CALIB_MSG_VALID) {
1294 tsp_info("Calibration check OK!!\n");
1295 schedule_delayed_work(&data->work_reset_check, 0);
1297 } else if (timer_ms - event_ms >= 3000) {
1299 tsp_info("calibration timeout over 3sec\n");
1300 schedule_delayed_work(&data->work_reset_check, 0);
1303 } else if (likely(status->noise_mode)) {
1304 /* 100ms after last interrupt */
1305 if (timer_ms - event_ms > 100)
1306 schedule_delayed_work(&data->work_noise_protect, 0);
1309 #if IST30XX_ALGORITHM_MODE
1310 if ((ist30xx_algr_addr >= IST30XX_DIRECT_ACCESS) &&
1311 (ist30xx_algr_size > 0)) {
1312 /* 100ms after last interrupt */
1313 if (timer_ms - event_ms > 100)
1314 schedule_delayed_work(&data->work_debug_algorithm, 0);
1321 mod_timer(&event_timer, get_jiffies_64() + EVENT_TIMER_INTERVAL);
1324 static void ist30xx_request_gpio(struct i2c_client *client,
1325 struct ist30xx_data *data)
1329 tsp_info("%s\n", __func__);
1331 if (gpio_is_valid(data->dt_data->touch_en_gpio)) {
1332 ret = gpio_request(data->dt_data->touch_en_gpio,
1333 "imagis,touch_en_gpio");
1335 tsp_err("%s: unable to request touch_en_gpio [%d]\n",
1336 __func__, data->dt_data->touch_en_gpio);
1340 #if defined(CONFIG_TOUCH_KEY_LED)
1341 if (gpio_is_valid(data->dt_data->keyled_en_gpio)) {
1342 ret = gpio_request(data->dt_data->keyled_en_gpio,
1343 "imagis,touch_en_gpio");
1345 tsp_err("%s: unable to request touch_en_gpio [%d]\n",
1346 __func__, data->dt_data->keyled_en_gpio);
1351 if (gpio_is_valid(data->dt_data->irq_gpio)) {
1352 ret = gpio_request(data->dt_data->irq_gpio, "imagis,irq_gpio");
1354 tsp_err("%s: unable to request irq_gpio [%d]\n",
1355 __func__, data->dt_data->irq_gpio);
1359 ret = gpio_direction_input(data->dt_data->irq_gpio);
1361 tsp_err("%s: unable to set direction for gpio [%d]\n",
1362 __func__, data->dt_data->irq_gpio);
1364 client->irq = gpio_to_irq(data->dt_data->irq_gpio);
1368 static void ist30xx_free_gpio(struct ist30xx_data *data)
1370 tsp_info("%s\n", __func__);
1372 if (gpio_is_valid(data->dt_data->touch_en_gpio))
1373 gpio_free(data->dt_data->touch_en_gpio);
1375 if (gpio_is_valid(data->dt_data->irq_gpio))
1376 gpio_free(data->dt_data->irq_gpio);
1377 #if defined(CONFIG_TOUCH_KEY_LED)
1378 if (gpio_is_valid(data->dt_data->keyled_en_gpio))
1379 gpio_free(data->dt_data->keyled_en_gpio);
1383 #ifdef CONFIG_SLEEP_MONITOR
1384 #define PRETTY_MAX 14
1385 #define STATE_BIT 24
1386 #define CNT_MASK 0xffff
1387 #define STATE_MASK 0xff
1389 static int ist30xx_get_sleep_monitor_cb(void* priv, unsigned int *raw_val, int check_level, int caller_type);
1391 static struct sleep_monitor_ops ist30xx_sleep_monitor_ops = {
1392 .read_cb_func = ist30xx_get_sleep_monitor_cb,
1395 static int ist30xx_get_sleep_monitor_cb(void* priv, unsigned int *raw_val, int check_level, int caller_type)
1397 struct ist30xx_data *data = priv;
1398 int state = DEVICE_UNKNOWN;
1403 if (check_level == SLEEP_MONITOR_CHECK_SOFT) {
1404 if (data->touch_stopped)
1405 state = DEVICE_POWER_OFF;
1407 state = DEVICE_ON_ACTIVE1;
1409 } else if (check_level == SLEEP_MONITOR_CHECK_HARD) {
1410 if (data->touch_stopped) {
1411 state = DEVICE_POWER_OFF;
1415 if (data->touch_stopped)
1416 state = DEVICE_POWER_OFF;
1418 state = DEVICE_ON_ACTIVE1;
1422 *raw_val = ((state & STATE_MASK) << STATE_BIT) |\
1423 (data->release_cnt & CNT_MASK);
1425 if (data->release_cnt > PRETTY_MAX)
1426 pretty = PRETTY_MAX;
1428 pretty = data->release_cnt;
1430 data->release_cnt = 0;
1432 tsp_info("%s: raw_val[0x%08x], check_level[%d], state[%d], pretty[%d]\n",
1433 __func__, *raw_val, check_level, state, pretty);
1441 static int ist30xx_parse_dt(struct device *dev, struct ist30xx_data *data)
1443 struct device_node *np = dev->of_node;
1446 data->dt_data->irq_gpio = of_get_named_gpio(np, "imagis,irq-gpio", 0);
1447 data->dt_data->touch_en_gpio = of_get_named_gpio(np, "vdd_en-gpio", 0);
1448 #if defined(CONFIG_TOUCH_KEY_LED)
1449 data->dt_data->keyled_en_gpio = of_get_named_gpio(np, "keyled_en-gpio", 0);
1451 if (of_property_read_u32(np, "imagis,bring-up", &data->dt_data->bringup))
1452 tsp_info("%s() bring up: %d\n", __func__, data->dt_data->bringup);
1454 if (of_property_read_u32(np, "imagis,fw-bin", &data->dt_data->fw_bin))
1455 tsp_info("%s() fw-bin: %d\n", __func__, data->dt_data->fw_bin);
1457 if (of_property_read_u32(np, "imagis,tkey", &data->dt_data->tkey) >= 0 )
1458 tsp_info("%s() tkey: %d\n", __func__, data->dt_data->tkey);
1460 if (of_property_read_u32(np, "imagis,octa-hw", &data->dt_data->octa_hw) >= 0 )
1461 tsp_info("%s() octa-hw: %d\n", __func__, data->dt_data->octa_hw);
1463 if (of_property_read_u32(np, "imagis,multiple-tsp", &data->dt_data->multiple_tsp) >= 0 )
1464 tsp_info("%s() multiple_tsp: %d\n", __func__, data->dt_data->multiple_tsp);
1466 if (of_property_read_string(np, "imagis,ic-version", &data->dt_data->ic_version) >= 0)
1467 tsp_info("%s() ic_version: %s\n", __func__, data->dt_data->ic_version);
1469 if (of_property_read_string(np, "imagis,project-name", &data->dt_data->project_name) >= 0)
1470 tsp_info("%s() project_name: %s\n", __func__, data->dt_data->project_name);
1472 if (of_property_read_string(np, "imagis,extra-string", &data->dt_data->extra_string) >= 0)
1473 tsp_info("%s() extra_string: %s\n", __func__, data->dt_data->extra_string);
1475 if (data->dt_data->ic_version && data->dt_data->project_name) {
1476 if (!data->dt_data->multiple_tsp) {
1477 if (data->dt_data->extra_string)
1478 snprintf(data->dt_data->fw_path, FIRMWARE_PATH_LENGTH,
1479 "%s%s_%s_%s.fw", FIRMWARE_PATH,
1480 data->dt_data->ic_version, data->dt_data->project_name,
1481 data->dt_data->extra_string);
1483 snprintf(data->dt_data->fw_path, FIRMWARE_PATH_LENGTH,
1484 "%s%s_%s.fw", FIRMWARE_PATH,
1485 data->dt_data->ic_version, data->dt_data->project_name);
1487 tsp_info("%s() firm path: %s\n", __func__, data->dt_data->fw_path);
1490 snprintf(data->dt_data->cmcs_path, FIRMWARE_PATH_LENGTH,
1491 "%s%s_%s_cmcs.bin", FIRMWARE_PATH,
1492 data->dt_data->ic_version, data->dt_data->project_name);
1493 tsp_info("%s() cmcs bin path: %s\n", __func__, data->dt_data->cmcs_path);
1496 rc = of_property_read_string(np, "vdd_ldo_name", &data->dt_data->tsp_vdd_name);
1498 tsp_err("%s: Unable to read TSP ldo name\n", __func__);
1500 #if defined(CONFIG_TOUCH_KEY_LED)
1501 tsp_info("%s() irq:%d, touch_en:%d, keyled_en:%d\n",
1502 __func__, data->dt_data->irq_gpio, data->dt_data->touch_en_gpio,
1503 data->dt_data->keyled_en_gpio);
1505 tsp_info("%s() irq:%d, touch_en:%d, tsp_ldo: %s\n",
1506 __func__, data->dt_data->irq_gpio, data->dt_data->touch_en_gpio,
1507 data->dt_data->tsp_vdd_name);
1513 static int ist30xx_parse_dt(struct device *dev, struct ist30xx_data *data)
1519 static int ist30xx_set_input_device(struct ist30xx_data *data)
1525 set_bit(EV_ABS, data->input_dev->evbit);
1526 set_bit(EV_SYN, data->input_dev->evbit);
1528 set_bit(EV_KEY, data->input_dev->evbit);
1529 set_bit(INPUT_PROP_DIRECT, data->input_dev->propbit);
1530 set_bit(BTN_TOUCH, data->input_dev->keybit);
1532 input_set_abs_params(data->input_dev, ABS_MT_POSITION_X,
1533 0, data->max_x - 1, 0, 0);
1534 input_set_abs_params(data->input_dev, ABS_MT_POSITION_Y,
1535 0, data->max_y - 1, 0, 0);
1536 input_set_abs_params(data->input_dev, ABS_X, 0, data->max_x - 1, 0, 0);
1537 input_set_abs_params(data->input_dev, ABS_Y, 0, data->max_y - 1, 0, 0);
1539 input_set_abs_params(data->input_dev, ABS_MT_TOUCH_MAJOR, 0, IST30XX_MAX_W, 0, 0);
1540 input_set_abs_params(data->input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
1541 input_set_abs_params(data->input_dev, ABS_MT_TRACKING_ID, 0, 3, 0, 0);
1542 #ifdef CONFIG_SEC_FACTORY
1543 input_set_abs_params(data->input_dev, ABS_MT_PRESSURE, 0, 0x1000, 0, 0);
1547 set_bit(EV_KEY, data->input_dev->evbit);
1548 set_bit(EV_SYN, data->input_dev->evbit);
1549 set_bit(EV_LED, data->input_dev->evbit);
1550 set_bit(LED_MISC, data->input_dev->ledbit);
1552 for (i = 1; i < ARRAY_SIZE(ist30xx_key_code); i++)
1553 set_bit(ist30xx_key_code[i], data->input_dev->keybit);
1556 input_set_capability(data->input_dev, EV_KEY, KEY_POWER);
1557 input_set_capability(data->input_dev, EV_KEY, KEY_PLAYPAUSE);
1558 input_set_capability(data->input_dev, EV_KEY, KEY_NEXTSONG);
1559 input_set_capability(data->input_dev, EV_KEY, KEY_PREVIOUSSONG);
1560 input_set_capability(data->input_dev, EV_KEY, KEY_VOLUMEUP);
1561 input_set_capability(data->input_dev, EV_KEY, KEY_VOLUMEDOWN);
1562 input_set_capability(data->input_dev, EV_KEY, KEY_MUTE);
1563 tsp_info("regist gesture key!\n");
1567 input_set_drvdata(data->input_dev, data);
1568 ret = input_register_device(data->input_dev);
1570 tsp_err("%s: failed input register device:%d\n", __func__, ret);
1572 tsp_info("%s: input register device:%d\n", __func__, ret);
1577 static int ist30xx_probe(struct i2c_client *client,
1578 const struct i2c_device_id *id)
1586 struct ist30xx_data *data;
1587 struct input_dev *input_dev;
1589 tsp_info("### IMAGIS probe(ver:%s, protocol:%X, addr:0x%02X) ###\n",
1590 IMAGIS_DD_VERSION, IMAGIS_PROTOCOL_B, client->addr);
1592 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
1593 printk(KERN_INFO "i2c_check_functionality error\n");
1597 data = kzalloc(sizeof(*data), GFP_KERNEL);
1602 data->dt_data = NULL;
1603 data->irq_enabled = 1;
1604 data->client = client;
1605 i2c_set_clientdata(client, data);
1607 if (client->dev.of_node) {
1608 data->dt_data = kzalloc(sizeof(struct ist30xx_dt_data), GFP_KERNEL);
1613 ret = ist30xx_parse_dt(&client->dev, data);
1617 data->dt_data = NULL;
1618 tsp_err("%s: TSP failed to align dtsi\n", __func__);
1622 ist30xx_request_gpio(client, data);
1625 /* Get pinctrl if target uses pinctrl */
1626 data->pinctrl = devm_pinctrl_get(&client->dev);
1627 if (IS_ERR(data->pinctrl)) {
1628 if (PTR_ERR(data->pinctrl) == -EPROBE_DEFER)
1631 tsp_err("%s: Target does not use pinctrl\n", __func__);
1632 data->pinctrl = NULL;
1635 if (data->pinctrl) {
1636 ret = ist30xx_pinctrl_configure(data, true);
1638 tsp_err("%s: cannot set pinctrl state\n", __func__);
1642 input_dev = input_allocate_device();
1643 if (unlikely(!input_dev)) {
1644 tsp_err("input_allocate_device failed\n");
1648 tsp_info("client->irq : %d\n", client->irq);
1649 data->max_fingers = IST30XX_MAX_MT_FINGERS;
1650 data->max_keys = IST30XX_MAX_KEYS;
1651 data->irq_enabled = 1;
1652 data->client = client;
1653 data->input_dev = input_dev;
1654 i2c_set_clientdata(client, data);
1656 input_mt_init_slots(input_dev, IST30XX_MAX_MT_FINGERS, 0);
1658 input_dev->name = "sec_touchscreen";
1659 input_dev->id.bustype = BUS_I2C;
1660 input_dev->dev.parent = &client->dev;
1661 input_dev->open = ist30xx_ts_open;
1662 input_dev->close = ist30xx_ts_close;
1665 #ifdef CONFIG_HAS_EARLYSUSPEND
1666 data->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;
1667 data->early_suspend.suspend = ist30xx_early_suspend;
1668 data->early_suspend.resume = ist30xx_late_resume;
1669 register_early_suspend(&data->early_suspend);
1673 ret = ist30xx_init_system(data);
1674 if (unlikely(ret)) {
1675 tsp_err("chip initialization failed\n");
1679 if (data->dt_data->multiple_tsp) {
1680 ret = ist30xxc_isp_info_read(data, 0, &tsp_type, 1);
1681 tsp_info("%s: ret: %d, tsp_type: %x\n", __func__, ret, tsp_type);
1683 if (data->dt_data->ic_version && data->dt_data->project_name && data->dt_data->extra_string) {
1684 if (ret || (tsp_type == J5_100_OHM_VALUE))
1685 snprintf(data->dt_data->fw_path, FIRMWARE_PATH_LENGTH,
1686 "%s%s_%s_%s.fw", FIRMWARE_PATH,
1687 data->dt_data->ic_version, data->dt_data->project_name,
1688 data->dt_data->extra_string);
1690 snprintf(data->dt_data->fw_path, FIRMWARE_PATH_LENGTH,
1691 "%s%s_%s.fw", FIRMWARE_PATH,
1692 data->dt_data->ic_version, data->dt_data->project_name);
1694 tsp_info("%s() firm path: %s\n", __func__, data->dt_data->fw_path);
1698 /* FW do not enter sleep mode in probe */
1699 ret = ist30xx_write_cmd(data->client,
1700 IST30XX_HIB_CMD, (eHCOM_FW_HOLD << 16) | (1 & 0xFFFF));
1701 tsp_info("%s: set FW_HOLD\n", __func__);
1703 while (retry-- > 0) {
1704 ret = ist30xx_read_cmd(data, IST30XX_REG_CHIPID, &data->chip_id);
1705 data->chip_id &= 0xFFFF;
1706 if (unlikely(ret == 0)) {
1707 if ((data->chip_id == IST30XX_CHIP_ID) ||
1708 (data->chip_id == IST30XXC_DEFAULT_CHIP_ID) ||
1709 (data->chip_id == IST3048C_DEFAULT_CHIP_ID)) {
1712 } else if (unlikely(retry == 0)) {
1716 ist30xx_reset(data, false);
1719 ret = request_threaded_irq(client->irq, NULL, ist30xx_irq_thread,
1720 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "ist30xx_ts", data);
1724 ist30xx_disable_irq(data);
1726 #if (IMAGIS_TSP_IC < IMAGIS_IST3038C)
1728 data->tsp_type = TSP_TYPE_UNKNOWN;
1729 while (retry-- > 0) {
1731 ret = ist30xx_read_cmd(data, IST30XX_REG_TSPTYPE, &data->tsp_type);
1732 if (likely(ret == 0)) {
1733 data->tsp_type = IST30XX_PARSE_TSPTYPE(data->tsp_type);
1734 tsp_info("tsptype: %x\n", data->tsp_type);
1738 if (unlikely(retry == 0))
1742 tsp_info("TSP IC: %x, TSP Vendor: %x\n", data->chip_id, data->tsp_type);
1744 tsp_info("TSP IC: %x\n", data->chip_id);
1746 data->status.event_mode = false;
1748 #if IST30XX_INTERNAL_BIN
1749 #if IST30XX_UPDATE_BY_WORKQUEUE
1750 INIT_DELAYED_WORK(&data->work_fw_update, fw_update_func);
1751 schedule_delayed_work(&data->work_fw_update, IST30XX_UPDATE_DELAY);
1753 ret = ist30xx_auto_bin_update(data);
1754 if (unlikely(ret != 0))
1756 #endif /* IST30XX_UPDATE_BY_WORKQUEUE */
1757 #endif /* IST30XX_INTERNAL_BIN */
1758 ret = ist30xx_read_cmd(data, IST30XX_REG_XY_SWAP, &xy_swap);
1759 tsp_err("%s: ret:%d, swap:%x\n", __func__, ret, xy_swap & 0x01);
1760 ret = ist30xx_read_cmd(data, IST30XX_REG_XY_RES, &xy_res);
1761 if (xy_swap & 0x01) {
1762 data->max_x = (u16)(xy_res & 0xFFFF);
1763 data->max_y = (u16)(xy_res >> 16);
1765 data->max_x = (u16)(xy_res >> 16);
1766 data->max_y = (u16)(xy_res & 0xFFFF);
1768 tsp_err("%s: ret:%d, xy:%X, x:%d, y:%d\n", __func__, ret, xy_res, data->max_x, data->max_y);
1770 ret = ist30xx_set_input_device(data);
1774 #ifdef CONFIG_INPUT_BOOSTER
1775 tsp_info("input Booster\n");
1776 data->tsp_booster = input_booster_allocate(INPUT_BOOSTER_ID_TSP);
1777 if (!data->tsp_booster) {
1778 tsp_err("%s booster allocation is failed\n", __func__);
1783 ret = ist30xx_init_update_sysfs(data);
1788 ret = ist30xx_init_misc_sysfs(data);
1793 #if IST30XX_CMCS_TEST
1794 ret = ist30xx_init_cmcs_sysfs(data);
1796 tsp_err("%s: do not init cmcs\n",__func__);
1798 #if IST30XX_CMCS_JIT_TEST
1799 ret = ist30xx_init_cmcs_jit_sysfs(data);
1801 tsp_err("%s: do not init cmcs jitter\n",__func__);
1805 #if IST30XX_TRACKING_MODE
1806 ret = ist30xx_init_tracking_sysfs(data);
1811 #if SEC_FACTORY_MODE
1812 ret = sec_fac_cmd_init(data);
1816 ret = sec_touch_sysfs(data);
1821 /* initialize data variable */
1823 data->suspend = false;
1824 data->gesture = false;
1826 data->irq_working = false;
1827 data->max_scan_retry = 2;
1828 data->max_irq_err_cnt = MAX_ERR_CNT;
1829 data->report_rate = -1;
1830 data->idle_rate = -1;
1831 data->deep_sleep = false;
1832 #ifdef CONFIG_SEC_FACTORY
1835 INIT_DELAYED_WORK(&data->work_reset_check, reset_work_func);
1836 INIT_DELAYED_WORK(&data->work_noise_protect, noise_work_func);
1837 INIT_DELAYED_WORK(&data->work_debug_algorithm, debug_work_func);
1839 init_timer(&event_timer);
1840 event_timer.data = (unsigned long)data;
1841 event_timer.function = timer_handler;
1842 event_timer.expires = jiffies_64 + (EVENT_TIMER_INTERVAL);
1843 mod_timer(&event_timer, get_jiffies_64() + EVENT_TIMER_INTERVAL * 2);
1845 ret = ist30xx_get_info(data);
1846 tsp_info("Get info: %s\n", (ret == 0 ? "success" : "fail"));
1848 #ifdef USE_TSP_TA_CALLBACKS
1849 data->callbacks.inform_charger = charger_enable;
1850 ist30xx_register_callback(&data->callbacks);
1853 #ifdef CONFIG_SLEEP_MONITOR
1854 sleep_monitor_register_ops(data, &ist30xx_sleep_monitor_ops,
1858 data->initialized = true;
1860 tsp_info("### IMAGIS probe success ###\n");
1862 /* release Firmware hold mode(forced active mode) */
1863 ret = ist30xx_write_cmd(data->client,
1864 IST30XX_HIB_CMD, (eHCOM_FW_HOLD << 16) | (0 & 0xFFFF));
1865 tsp_info("%s: release FW_HOLD\n", __func__);
1867 if (in_calibration()) {
1868 tsp_info("%s: power_off for cal_mod\n", __func__);
1869 data->touch_stopped = true;
1870 ist30xx_suspend(&data->client->dev);
1874 #ifdef CONFIG_SLEEP_MONITOR
1875 sleep_monitor_unregister_ops(SLEEP_MONITOR_TSP);
1879 #if SEC_FACTORY_MODE
1880 sec_fac_cmd_remove(data);
1881 sec_touch_sysfs_remove(data);
1884 class_destroy(ist30xx_class);
1885 input_unregister_device(input_dev);
1886 #ifdef CONFIG_INPUT_BOOSTER
1887 input_booster_free(data->tsp_booster);
1888 data->tsp_booster = NULL;
1891 tsp_info("ChipID: %x\n", data->chip_id);
1892 ist30xx_disable_irq(data);
1893 free_irq(client->irq, data);
1895 data->status.event_mode = false;
1896 ist30xx_power_off(data);
1897 #ifdef CONFIG_HAS_EARLYSUSPEND
1898 unregister_early_suspend(&data->early_suspend);
1902 if (data->dt_data) {
1903 tsp_err("%s: Error, ist30xx mem free, line:%d\n", __func__, __LINE__);
1904 kfree(data->dt_data);
1908 tsp_err("Error, ist30xx init driver\n");
1913 static int ist30xx_remove(struct i2c_client *client)
1915 struct ist30xx_data *data = i2c_get_clientdata(client);
1917 #ifdef CONFIG_SLEEP_MONITOR
1918 sleep_monitor_unregister_ops(SLEEP_MONITOR_TSP);
1920 #ifdef CONFIG_HAS_EARLYSUSPEND
1921 unregister_early_suspend(&data->early_suspend);
1924 ist30xx_disable_irq(data);
1925 free_irq(client->irq, data);
1926 ist30xx_power_off(data);
1928 sec_fac_cmd_remove(data);
1931 ist30xx_free_gpio(data);
1933 input_unregister_device(data->input_dev);
1934 #ifdef CONFIG_INPUT_BOOSTER
1935 input_booster_free(data->tsp_booster);
1936 data->tsp_booster = NULL;
1943 static void ist30xx_shutdown(struct i2c_client *client)
1945 struct ist30xx_data *data = i2c_get_clientdata(client);
1947 tsp_err("%s is called\n", __func__);
1948 del_timer(&event_timer);
1949 cancel_delayed_work_sync(&data->work_noise_protect);
1950 cancel_delayed_work_sync(&data->work_reset_check);
1951 cancel_delayed_work_sync(&data->work_debug_algorithm);
1952 mutex_lock(&ist30xx_mutex);
1953 ist30xx_disable_irq(data);
1954 ist30xx_internal_suspend(data);
1955 clear_input_data(data);
1956 mutex_unlock(&ist30xx_mutex);
1957 #ifdef CONFIG_INPUT_BOOSTER
1958 input_booster_free(data->tsp_booster);
1959 data->tsp_booster = NULL;
1963 static struct i2c_device_id ist30xx_idtable[] = {
1964 { IST30XX_DEV_NAME, 0 },
1967 MODULE_DEVICE_TABLE(i2c, ist30xx_idtable);
1970 static struct of_device_id ist30xx_match_table[] = {
1971 { .compatible = "imagis,ist30xx-ts", },
1975 #define ist30xx_match_table NULL
1978 static struct i2c_driver ist30xx_i2c_driver = {
1979 .id_table = ist30xx_idtable,
1980 .probe = ist30xx_probe,
1981 .remove = ist30xx_remove,
1982 .shutdown = ist30xx_shutdown,
1984 .owner = THIS_MODULE,
1985 .name = IST30XX_DEV_NAME,
1986 .of_match_table = ist30xx_match_table,
1990 static int __init ist30xx_init(void)
1992 tsp_info("%s()\n", __func__);
1993 return i2c_add_driver(&ist30xx_i2c_driver);
1997 static void __exit ist30xx_exit(void)
1999 tsp_info("%s()\n", __func__);
2000 i2c_del_driver(&ist30xx_i2c_driver);
2003 module_init(ist30xx_init);
2004 module_exit(ist30xx_exit);
2006 MODULE_DESCRIPTION("Imagis IST30XX touch driver");
2007 MODULE_LICENSE("GPL");