drivers/input/touchscreen/imagis_30xxc/ist30xxc.c

   1 /*
   2  *  Copyright (C) 2010,Imagis Technology Co. Ltd. All Rights Reserved.
   3  *
   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.
   8  *
   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.
  13  *
  14  */
  15
  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>
  24
  25 #include <linux/platform_device.h>
  26 #include <linux/device.h>
  27 #include <linux/mutex.h>
  28 #include <linux/input/mt.h>
  29
  30 #include <linux/i2c/ist30xxc.h>
  31 #include "ist30xxc_update.h"
  32 #include "ist30xxc_tracking.h"
  33 #ifdef CONFIG_OF
  34 #include <linux/of.h>
  35 #include <linux/of_gpio.h>
  36 #include <linux/of_device.h>
  37 #endif
  38
  39 #if IST30XX_DEBUG
  40 #include "ist30xxc_misc.h"
  41 #endif
  42
  43 #if IST30XX_CMCS_TEST
  44 #include "ist30xxc_cmcs.h"
  45 #if IST30XX_CMCS_JIT_TEST
  46 #include "ist30xxc_cmcs_jit.h"
  47 #endif
  48 #endif
  49
  50 #ifdef CONFIG_SLEEP_MONITOR
  51 #include <linux/power/sleep_monitor.h>
  52 #endif
  53
  54 #define J5_100_OHM_VALUE    0xECEC0001
  55
  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 */
  62
  63 extern int in_calibration(void);
  64
  65 #if IST30XX_USE_KEY
  66 int ist30xx_key_code[IST30XX_MAX_KEYS + 1] = { 0, KEY_RECENT, KEY_BACK, };
  67 #endif
  68
  69 struct ist30xx_data *ts_data;
  70
  71 DEFINE_MUTEX(ist30xx_mutex);
  72
  73 int ist30xx_dbg_level = IST30XX_DEBUG_LEVEL;
  74 void tsp_printk(int level, const char *fmt, ...)
  75 {
  76         struct va_format vaf;
  77         va_list args;
  78
  79         if (ist30xx_dbg_level < level)
  80                 return;
  81
  82         va_start(args, fmt);
  83
  84         vaf.fmt = fmt;
  85         vaf.va = &args;
  86
  87         printk("%s %pV", IST30XX_DEBUG_TAG, &vaf);
  88
  89         va_end(args);
  90 }
  91
  92 long get_milli_second(void)
  93 {
  94         ktime_get_ts(&t_current);
  95
  96         return t_current.tv_sec * 1000 + t_current.tv_nsec / 1000000;
  97 }
  98
  99 void ist30xx_delay(unsigned int ms)
 100 {
 101         if (ms < 20)
 102                 usleep_range(ms * 1000, ms * 1000);
 103         else
 104                 msleep(ms);
 105
 106 }
 107
 108 int ist30xx_intr_wait(struct ist30xx_data *data, long ms)
 109 {
 110         long start_ms = get_milli_second();
 111         long curr_ms = 0;
 112
 113         while (1) {
 114                 if (!data->irq_working)
 115                         break;
 116
 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);
 120                         return -EPERM;
 121                 }
 122
 123                 ist30xx_delay(2);
 124         }
 125         return 0;
 126 }
 127
 128 void ist30xx_disable_irq(struct ist30xx_data *data)
 129 {
 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;
 135         }
 136 }
 137
 138 void ist30xx_enable_irq(struct ist30xx_data *data)
 139 {
 140         if (likely(!data->irq_enabled)) {
 141                 ist30xx_tracking(TRACK_INTR_ENABLE);
 142                 enable_irq(data->client->irq);
 143                 ist30xx_delay(10);
 144                 data->irq_enabled = 1;
 145                 data->status.event_mode = true;
 146         }
 147 }
 148
 149 void ist30xx_scheduled_reset(struct ist30xx_data *data)
 150 {
 151         if (likely(data->initialized))
 152                 schedule_delayed_work(&data->work_reset_check, 0);
 153 }
 154
 155 static void ist30xx_request_reset(struct ist30xx_data *data)
 156 {
 157         data->irq_err_cnt++;
 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;
 162         }
 163 }
 164
 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)
 171 {
 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);
 177         }
 178         /* TA mode */
 179         ist30xx_write_cmd(data->client, IST30XX_HIB_CMD,
 180                         ((eHCOM_SET_MODE_SPECIAL << 16) | (data->noise_mode & 0xFFFF)));
 181
 182         /* Local Model info. do not use this. */
 183 /*
 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);
 188 */
 189
 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);
 194         }
 195
 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);
 200         }
 201
 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__);
 206         }
 207
 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__);
 212         }
 213
 214         ist30xx_cmd_start_scan(data);
 215 }
 216
 217 int ist30xx_get_ver_info(struct ist30xx_data *data)
 218 {
 219         int ret;
 220
 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;
 229
 230         ret = ist30xx_cmd_hold(data, 1);
 231         if (unlikely(ret))
 232                 return ret;
 233
 234         ret = ist30xx_read_reg(data->client,
 235                         IST30XX_DA_ADDR(eHCOM_GET_VER_MAIN), &data->fw.cur.main_ver);
 236         if (unlikely(ret))
 237                 goto err_get_ver;
 238
 239         ret = ist30xx_read_reg(data->client,
 240                         IST30XX_DA_ADDR(eHCOM_GET_VER_FW), &data->fw.cur.fw_ver);
 241         if (unlikely(ret))
 242                 goto err_get_ver;
 243
 244         ret = ist30xx_read_reg(data->client,
 245                         IST30XX_DA_ADDR(eHCOM_GET_VER_CORE), &data->fw.cur.core_ver);
 246         if (unlikely(ret))
 247                 goto err_get_ver;
 248
 249         ret = ist30xx_read_reg(data->client,
 250                         IST30XX_DA_ADDR(eHCOM_GET_VER_TEST), &data->fw.cur.test_ver);
 251         if (unlikely(ret))
 252                 goto err_get_ver;
 253
 254         ret = ist30xx_cmd_hold(data, 0);
 255         if (unlikely(ret))
 256                 goto err_get_ver;
 257
 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);
 261
 262         return 0;
 263
 264 err_get_ver:
 265         ist30xx_reset(data, false);
 266
 267         return ret;
 268 }
 269
 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)
 275 {
 276         int ret;
 277         u32 calib_msg;
 278         u32 ms;
 279
 280         mutex_lock(&ist30xx_mutex);
 281         ist30xx_disable_irq(data);
 282
 283 #if IST30XX_INTERNAL_BIN
 284 #if IST30XX_UPDATE_BY_WORKQUEUE
 285         ist30xx_get_update_info(data, data->fw.buf, data->fw.buf_size);
 286 #endif
 287         ist30xx_get_tsp_info(data);
 288 #else
 289         ret = ist30xx_get_ver_info(data);
 290         if (unlikely(ret))
 291                 goto get_info_end;
 292
 293         ret = ist30xx_get_tsp_info(data);
 294         if (unlikely(ret))
 295                 goto get_info_end;
 296 #endif /* IST30XX_INTERNAL_BIN */
 297
 298 /* remove "print information" -> read sysfs : /sys/class/touch/sys/ic_inform */
 299 /*
 300         ist30xx_print_info(data);
 301 */
 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);
 312                 }
 313         }
 314
 315 #if IST30XX_CHECK_CALIB
 316         if (likely(!data->status.update)) {
 317                 ret = ist30xx_cmd_check_calib(data->client);
 318                 if (likely(!ret)) {
 319                         data->status.calib = 1;
 320                         data->status.calib_msg = 0;
 321                         event_ms = (u32)get_milli_second();
 322                         data->status.event_mode = true;
 323                 }
 324         }
 325 #else
 326         ist30xx_start(data);
 327 #endif
 328
 329 #if !(IST30XX_INTERNAL_BIN)
 330 get_info_end:
 331 #endif
 332
 333         ist30xx_enable_irq(data);
 334         mutex_unlock(&ist30xx_mutex);
 335
 336         return ret;
 337 }
 338
 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)
 349
 350 void ist30xx_special_cmd(struct ist30xx_data *data, int cmd)
 351 {
 352 #if IST30XX_GESTURE
 353         if (((cmd > 0x40) && (cmd < 0x5B)) || ((cmd > 0x90) && (cmd < 0x9A))) {
 354                 tsp_info("Gesture touch: 0x%02X\n", cmd);
 355                 return;
 356         }
 357 #endif
 358
 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);
 364         } else {
 365             if ((cmd & SPECIAL_SUCCESS_MASK) > 0) {
 366                 tsp_info("Blade touch stop: 0x%02X\n", cmd);
 367             } else {
 368                 tsp_info("Blade touch cancel: 0x%02X\n", cmd);
 369             }
 370         }
 371                 return;
 372         }
 373 #endif
 374
 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);
 380         } else {
 381             if ((cmd & SPECIAL_SUCCESS_MASK) > 0) {
 382                 tsp_info("Surface touch stop: 0x%02X\n", cmd);
 383             } else {
 384                 tsp_info("Surface touch cancel: 0x%02X\n", cmd);
 385             }
 386         }
 387
 388                 return;
 389         }
 390 #endif
 391
 392         tsp_warn("Not support special cmd: 0x%02X\n", cmd);
 393 }
 394 #endif
 395
 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, };
 402
 403 void print_tsp_event(struct ist30xx_data *data, finger_info *finger)
 404 {
 405         int idx = finger->bit_field.id - 1;
 406         bool press;
 407
 408         press = PRESSED_FINGER(data->t_status, finger->bit_field.id);
 409
 410         if (press) {
 411                 if (tsp_touched[idx] == false) {
 412                         /* touch down */
 413                         data->touch_pressed_num++;
 414                         tsp_noti("%s [%d] x=%d y=%d z=%d\n",
 415                                         TOUCH_DOWN_MESSAGE, idx,
 416                                         finger->bit_field.x,
 417                                         finger->bit_field.y,
 418                                         data->z_values[idx]);
 419                         tsp_touched[idx] = true;
 420                 } else {
 421                         /* touch move */
 422                         tsp_debug("%s [%d] x=%d y=%d z=%d\n",
 423                                         TOUCH_MOVE_MESSAGE, idx,
 424                                         finger->bit_field.x,
 425                                         finger->bit_field.y,
 426                                         data->z_values[idx]);
 427                 }
 428
 429                 data->lx[idx] = finger->bit_field.x;
 430                 data->ly[idx] = finger->bit_field.y;
 431         } else {
 432                 if (tsp_touched[idx] == true) {
 433                         /* touch up */
 434                         data->touch_pressed_num--;
 435 #ifdef CONFIG_SLEEP_MONITOR
 436                         data->release_cnt++;
 437 #endif
 438                         tsp_noti("%s [%d] x=%d y=%d\n", TOUCH_UP_MESSAGE,
 439                                         finger->bit_field.id-1,
 440                                         data->lx[idx],
 441                                         data->ly[idx]);
 442                         tsp_touched[idx] = false;
 443                 }
 444         }
 445 }
 446 #if IST30XX_USE_KEY
 447 #define PRESS_MSG_KEY           (0x06)
 448 bool tkey_pressed[IST30XX_MAX_KEYS] = { false, };
 449
 450 /* key product_ship log will be add after unpin feature */
 451 void print_tkey_event(struct ist30xx_data *data, int id)
 452 {
 453         int idx = id - 1;
 454         bool press = PRESSED_KEY(data->t_status, id);
 455
 456         if (press) {
 457                 if (tkey_pressed[idx] == false) {
 458                         /* tkey down */
 459                         tsp_noti("k %s%d\n", TOUCH_DOWN_MESSAGE, id);
 460                         tkey_pressed[idx] = true;
 461                 }
 462         } else {
 463                 if (tkey_pressed[idx] == true) {
 464                         /* tkey up */
 465                         tsp_noti("k %s%d\n", TOUCH_UP_MESSAGE, id);
 466                         tkey_pressed[idx] = false;
 467                 }
 468         }
 469 }
 470 #endif
 471 static void release_finger(struct ist30xx_data *data, int id)
 472 {
 473         input_mt_slot(data->input_dev, id - 1);
 474         input_mt_report_slot_state(data->input_dev, MT_TOOL_FINGER, false);
 475
 476         ist30xx_tracking(TRACK_POS_FINGER + id);
 477         tsp_info("%s() %d\n", __func__, id);
 478
 479         tsp_touched[id - 1] = false;
 480
 481         input_sync(data->input_dev);
 482 }
 483
 484 #if IST30XX_USE_KEY
 485 #define CANCEL_KEY  (0xFF)
 486 #define RELEASE_KEY (0)
 487 static void release_key(struct ist30xx_data *data, int id, u8 key_status)
 488 {
 489         input_report_key(data->input_dev, ist30xx_key_code[id], key_status);
 490
 491         ist30xx_tracking(TRACK_POS_KEY + id);
 492         tsp_info("%s() key%d, status: %d\n", __func__, id, key_status);
 493
 494         tkey_pressed[id - 1] = false;
 495
 496         input_sync(data->input_dev);
 497 }
 498 #endif
 499 static void clear_input_data(struct ist30xx_data *data)
 500 {
 501         int id = 1;
 502         u32 status;
 503
 504         status = PARSE_FINGER_STATUS(data->t_status);
 505         while (status) {
 506                 if (status & 1)
 507                         release_finger(data, id);
 508                 status >>= 1;
 509                 id++;
 510         }
 511 #if IST30XX_USE_KEY
 512         id = 1;
 513         status = PARSE_KEY_STATUS(data->t_status);
 514         while (status) {
 515                 if (status & 1)
 516                         release_key(data, id, RELEASE_KEY);
 517                 status >>= 1;
 518                 id++;
 519         }
 520 #endif
 521
 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;
 526 #endif
 527
 528         data->t_status = 0;
 529 }
 530
 531 static int check_report_fingers(struct ist30xx_data *data, int finger_counts)
 532 {
 533         int i;
 534         finger_info *fingers = (finger_info *)data->fingers;
 535
 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);
 545
 546                         fingers[i].bit_field.id = 0;
 547                         ist30xx_tracking(TRACK_POS_UNKNOWN);
 548                         return -EPERM;
 549                 }
 550         }
 551
 552         return 0;
 553 }
 554
 555 static int check_valid_coord(u32 *msg, int cnt)
 556 {
 557         u8 *buf = (u8 *)msg;
 558         u8 chksum1 = msg[0] >> 24;
 559         u8 chksum2 = 0;
 560         u32 tmp = msg[0];
 561
 562         msg[0] &= 0x00FFFFFF;
 563
 564         cnt *= IST30XX_DATA_LEN;
 565
 566         while (cnt--)
 567                 chksum2 += *buf++;
 568
 569         msg[0] = tmp;
 570
 571         if (chksum1 != chksum2) {
 572                 tsp_err("intr chksum: %02x, %02x\n", chksum1, chksum2);
 573                 return -EPERM;
 574         }
 575
 576         return 0;
 577 }
 578
 579 static void report_input_data(struct ist30xx_data *data, int finger_counts,
 580                 int key_counts)
 581 {
 582         int id;
 583         bool press = false;
 584         finger_info *fingers = (finger_info *)data->fingers;
 585         u32 *z_values = (u32 *)data->z_values;
 586         int idx = 0;
 587         u32 status;
 588
 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;
 592
 593                 input_mt_slot(data->input_dev, id);
 594                 input_mt_report_slot_state(data->input_dev, MT_TOOL_FINGER, press);
 595
 596                 fingers[idx].bit_field.id = id + 1;
 597                 print_tsp_event(data, &fingers[idx]);
 598
 599                 if (!press) {
 600                         input_report_key(data->input_dev, BTN_TOUCH, 0);
 601                         input_report_key(data->input_dev, BTN_TOOL_FINGER, 0);
 602                         continue;
 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);
 606                 }
 607
 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);
 614                 if (data->jig_mode)
 615                         input_report_abs(data->input_dev, ABS_MT_PRESSURE, z_values[idx]);
 616                 idx++;
 617         }
 618
 619 #if IST30XX_USE_KEY
 620         status = PARSE_KEY_STATUS(data->t_status);
 621         for (id = 0; id < IST30XX_MAX_KEYS; id++) {
 622                 press = (status & (1 << id)) ? true : false;
 623
 624                 input_report_key(data->input_dev, ist30xx_key_code[id + 1], press);
 625
 626                 print_tkey_event(data, id + 1);
 627         }
 628 #endif /* IST30XX_USE_KEY */
 629
 630         data->irq_err_cnt = 0;
 631         data->scan_retry = 0;
 632
 633         input_sync(data->input_dev);
 634 }
 635
 636 /*
 637  * CMD : CMD_GET_COORD
 638  *
 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]
 642  *      ID        Area      X         Y
 643  */
 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)
 651 {
 652         int i, ret;
 653         int key_cnt, finger_cnt, read_cnt;
 654         struct ist30xx_data *data = (struct ist30xx_data *)ptr;
 655         int offset = 1;
 656 #if IST30XX_STATUS_DEBUG
 657         u32 touch_status;
 658 #endif
 659         u32     t_status;
 660         u32 msg[IST30XX_MAX_MT_FINGERS * 2 + offset];
 661         u32 ms = 0;
 662
 663         data->irq_working = true;
 664
 665         if (unlikely(!data->irq_enabled))
 666                 goto irq_end;
 667
 668         if (data->track_enable) {
 669                 ms = get_milli_second();
 670
 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);
 675
 676                         for (i = 0; i < intr_debug_size; i++)
 677                                 tsp_noti("\t%08x\n", msg[i]);
 678
 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);
 683                 }
 684
 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);
 689
 690                         for (i = 0; i < intr_debug2_size; i++)
 691                                 tsp_noti("\t%08x\n", msg[i]);
 692
 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);
 697                 }
 698         }
 699
 700         memset(msg, 0, sizeof(msg));
 701
 702         ret = ist30xx_read_reg(data->client, IST30XX_HIB_INTR_MSG, msg);
 703         if (unlikely(ret))
 704                 goto irq_err;
 705
 706         tsp_verb("intr msg: 0x%08x\n", *msg);
 707
 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);
 711 #if I2C_BURST_MODE
 712                 ret = ist30xx_burst_read(data->client,
 713                                 IST30XX_HIB_COORD, &msg[offset], IST30XX_MAX_EXCEPT_SIZE, true);
 714 #else
 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]);
 718                 }
 719 #endif
 720                 if (unlikely(ret))
 721                         tsp_err(" exception value read error(%d)\n", ret);
 722                 else
 723                         tsp_err(" exception value : 0x%08X, 0x%08X\n", msg[1], msg[2]);
 724
 725                 goto irq_ic_err;
 726         }
 727
 728         if (unlikely(*msg == 0 || *msg == 0xFFFFFFFF)) /* Unknown CMD */
 729                 goto irq_err;
 730
 731         if (data->track_enable) {
 732                 event_ms = ms;
 733                 ist30xx_put_track_ms(event_ms);
 734                 ist30xx_put_track(&tracking_intr_value, 1);
 735                 ist30xx_put_track(msg, 1);
 736         }
 737
 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);
 741
 742                 goto irq_end;
 743         }
 744
 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);
 749
 750                 goto irq_end;
 751         }
 752
 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);
 757
 758                 goto irq_end;
 759         }
 760 #endif
 761 #endif
 762
 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);
 768
 769                 goto irq_end;
 770         }
 771 #endif
 772
 773 #if IST30XX_STATUS_DEBUG
 774         ret = ist30xx_read_reg(data->client,
 775                         IST30XX_HIB_TOUCH_STATUS, &touch_status);
 776
 777         if (ret == 0)
 778                 tsp_debug("ALG : 0x%08X\n", touch_status);
 779 #endif
 780
 781         memset(data->fingers, 0, sizeof(data->fingers));
 782
 783         /* Unknown interrupt data for extend coordinate */
 784         if (unlikely(!CHECK_INTR_STATUS(*msg)))
 785                 goto irq_err;
 786
 787         t_status = *msg;
 788         key_cnt = PARSE_KEY_CNT(t_status);
 789         finger_cnt = PARSE_FINGER_CNT(t_status);
 790
 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);
 795                 goto irq_err;
 796         }
 797
 798         if (finger_cnt > 0) {
 799 #if I2C_BURST_MODE
 800                 ret = ist30xx_burst_read(data->client,
 801                                 IST30XX_HIB_COORD, &msg[offset], finger_cnt, true);
 802                 if (unlikely(ret))
 803                         goto irq_err;
 804
 805                 for (i = 0; i < finger_cnt; i++)
 806                         data->fingers[i].full_field = msg[i + offset];
 807 #else
 808                 for (i = 0; i < finger_cnt; i++) {
 809                         ret = ist30xx_read_reg(data->client,
 810                                         IST30XX_HIB_COORD + (i * 4), &msg[i + offset]);
 811                         if (unlikely(ret))
 812                                 goto irq_err;
 813
 814                         data->fingers[i].full_field = msg[i + offset];
 815                 }
 816 #endif /* I2C_BURST_MODE */
 817
 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);
 823                 }
 824
 825                 if (data->track_enable) {
 826
 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]);
 831                         }
 832
 833                 }
 834         }
 835
 836         read_cnt = finger_cnt + 1;
 837
 838         ret = check_valid_coord(&msg[0], read_cnt);
 839         if (unlikely(ret))
 840                 goto irq_err;
 841
 842         if (data->track_enable) {
 843                 ret = check_report_fingers(data, finger_cnt);
 844                 if (unlikely(ret))
 845                         goto irq_err;
 846         }
 847
 848         data->t_status = t_status;
 849         report_input_data(data, finger_cnt, key_cnt);
 850
 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);
 854 #endif
 855
 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);
 861
 862                         for (i = 0; i < intr_debug3_size; i++)
 863                                 tsp_noti("\t%08x\n", msg[i]);
 864
 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);
 869                 }
 870
 871         }
 872         goto irq_end;
 873
 874 irq_err:
 875         tsp_err("intr msg: 0x%08x, ret: %d\n", msg[0], ret);
 876 #if IST30XX_GESTURE
 877         if (!data->suspend)
 878 #endif
 879         ist30xx_request_reset(data);
 880 irq_end:
 881         data->irq_working = false;
 882
 883         if (data->track_enable)
 884                 event_ms = (u32)get_milli_second();
 885
 886         return IRQ_HANDLED;
 887
 888 irq_ic_err:
 889         ist30xx_scheduled_reset(data);
 890         data->irq_working = false;
 891         if (data->track_enable)
 892                 event_ms = (u32)get_milli_second();
 893
 894         return IRQ_HANDLED;
 895 }
 896
 897 #if 0
 898 static int ist30xx_pinctrl_configure(struct ist30xx_data *data, bool active)
 899 {
 900         struct pinctrl_state *set_state;
 901
 902         int retval;
 903         tsp_err("%s: %s\n", __func__, active ? "ACTIVE" : "SUSPEND");
 904
 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__);
 908                 return -EINVAL;
 909         }
 910
 911         retval = pinctrl_select_state(data->pinctrl, set_state);
 912         if (retval) {
 913                 tsp_err("%s: cannot set pinctrl %s state\n",
 914                                 __func__, active ? "active" : "suspend");
 915                 return -EINVAL;
 916         }
 917
 918         return 0;
 919 }
 920 #endif
 921
 922 static int ist30xx_suspend(struct device *dev)
 923 {
 924         struct i2c_client *client = to_i2c_client(dev);
 925         struct ist30xx_data *data = i2c_get_clientdata(client);
 926
 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);
 935 #if IST30XX_GESTURE
 936         if (data->gesture) {
 937                 ist30xx_start(data);
 938                 data->status.noise_mode = false;
 939                 ist30xx_enable_irq(data);
 940         }
 941 #endif
 942         mutex_unlock(&ist30xx_mutex);
 943
 944         return 0;
 945 }
 946
 947 static int ist30xx_resume(struct device *dev)
 948 {
 949         struct i2c_client *client = to_i2c_client(dev);
 950         struct ist30xx_data *data = i2c_get_clientdata(client);
 951
 952         data->noise_mode |= (1 << NOISE_MODE_POWER);
 953
 954         mutex_lock(&ist30xx_mutex);
 955         ist30xx_internal_resume(data);
 956         ist30xx_start(data);
 957         ist30xx_enable_irq(data);
 958         mutex_unlock(&ist30xx_mutex);
 959
 960         return 0;
 961 }
 962
 963 #ifdef CONFIG_HAS_EARLYSUSPEND
 964 static void ist30xx_early_suspend(struct early_suspend *h)
 965 {
 966         struct ist30xx_data *data = container_of(h, struct ist30xx_data,
 967                         early_suspend);
 968
 969         ist30xx_suspend(&data->client->dev);
 970 }
 971 static void ist30xx_late_resume(struct early_suspend *h)
 972 {
 973         struct ist30xx_data *data = container_of(h, struct ist30xx_data,
 974                         early_suspend);
 975
 976         ist30xx_resume(&data->client->dev);
 977 }
 978 #endif
 979
 980 static void  ist30xx_ts_close(struct input_dev *dev)
 981 {
 982         struct ist30xx_data *data = input_get_drvdata(dev);
 983
 984         if (data->touch_stopped) {
 985                 tsp_err("%s: IC is already on\n", __func__);
 986                 return;
 987         }
 988
 989         tsp_info("%s\n", __func__);
 990         data->touch_stopped = true;
 991         ist30xx_suspend(&data->client->dev);
 992
 993 #if 0
 994         if (data->pinctrl) {
 995                 int ret = ist30xx_pinctrl_configure(data, false);
 996                 if (ret)
 997                         tsp_err("%s: cannot set pinctrl state\n", __func__);
 998         }
 999 #endif
1000 }
1001 static int ist30xx_ts_open(struct input_dev *dev)
1002 {
1003         struct ist30xx_data *data = input_get_drvdata(dev);
1004
1005         if (!data->touch_stopped) {
1006                 tsp_err("%s: IC is already on\n", __func__);
1007                 return 0;
1008         }
1009         tsp_info("%s\n", __func__);
1010 #if 0
1011         if (data->pinctrl) {
1012                 int ret = ist30xx_pinctrl_configure(data, true);
1013                 if (ret)
1014                         tsp_err("%s: cannot set pinctrl state\n", __func__);
1015         }
1016 #endif
1017         ist30xx_resume(&data->client->dev);
1018         data->touch_stopped = false;
1019
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);
1023
1024         return 0;
1025 }
1026
1027 void ist30xx_set_ta_mode(bool mode)
1028 {
1029         tsp_info("%s: %sconnected\n", __func__, mode ? "":"dis");
1030
1031         if (unlikely(mode == ((ts_data->noise_mode >> NOISE_MODE_TA) & 1)))
1032                 return;
1033
1034         if (mode)
1035                 ts_data->noise_mode |= (1 << NOISE_MODE_TA);
1036         else
1037                 ts_data->noise_mode &= ~(1 << NOISE_MODE_TA);
1038
1039 #if IST30XX_TA_RESET
1040         if (unlikely(ts_data->initialized))
1041                 ist30xx_scheduled_reset(ts_data);
1042 #else
1043         ist30xx_write_cmd(ts_data->client, IST30XX_HIB_CMD,
1044                         ((eHCOM_SET_MODE_SPECIAL << 16) | (ts_data->noise_mode & 0xFFFF)));
1045 #endif
1046
1047         ist30xx_tracking(mode ? TRACK_CMD_TACON : TRACK_CMD_TADISCON);
1048 }
1049 EXPORT_SYMBOL(ist30xx_set_ta_mode);
1050
1051 void ist30xx_set_edge_mode(int mode)
1052 {
1053         tsp_info("%s(), mode = %d\n", __func__, mode);
1054
1055         if (mode)
1056                 ts_data->noise_mode |= (1 << NOISE_MODE_EDGE);
1057         else
1058                 ts_data->noise_mode &= ~(1 << NOISE_MODE_EDGE);
1059
1060         ist30xx_write_cmd(ts_data->client, IST30XX_HIB_CMD,
1061                         ((eHCOM_SET_MODE_SPECIAL << 16) | (ts_data->noise_mode & 0xFFFF)));
1062 }
1063 EXPORT_SYMBOL(ist30xx_set_edge_mode);
1064
1065 void ist30xx_set_call_mode(int mode)
1066 {
1067         tsp_info("%s(), mode = %d\n", __func__, mode);
1068
1069         if (unlikely(mode == ((ts_data->noise_mode >> NOISE_MODE_CALL) & 1)))
1070                 return;
1071
1072         if (mode)
1073                 ts_data->noise_mode |= (1 << NOISE_MODE_CALL);
1074         else
1075                 ts_data->noise_mode &= ~(1 << NOISE_MODE_CALL);
1076
1077 #if IST30XX_TA_RESET
1078         if (unlikely(ts_data->initialized))
1079                 ist30xx_scheduled_reset(ts_data);
1080 #else
1081         ist30xx_write_cmd(ts_data->client, IST30XX_HIB_CMD,
1082                         ((eHCOM_SET_MODE_SPECIAL << 16) | (ts_data->noise_mode & 0xFFFF)));
1083 #endif
1084
1085         ist30xx_tracking(mode ? TRACK_CMD_CALL : TRACK_CMD_NOTCALL);
1086 }
1087 EXPORT_SYMBOL(ist30xx_set_call_mode);
1088
1089 void ist30xx_set_cover_mode(int mode)
1090 {
1091         tsp_info("%s(), mode = %d\n", __func__, mode);
1092
1093         if (unlikely(mode == ((ts_data->noise_mode >> NOISE_MODE_COVER) & 1)))
1094                 return;
1095
1096         if (mode)
1097                 ts_data->noise_mode |= (1 << NOISE_MODE_COVER);
1098         else
1099                 ts_data->noise_mode &= ~(1 << NOISE_MODE_COVER);
1100
1101 #if IST30XX_TA_RESET
1102         if (unlikely(ts_data->initialized))
1103                 ist30xx_scheduled_reset(ts_data);
1104 #else
1105         ist30xx_write_cmd(ts_data->client, IST30XX_HIB_CMD,
1106                         ((eHCOM_SET_MODE_SPECIAL << 16) | (ts_data->noise_mode & 0xFFFF)));
1107 #endif
1108
1109         ist30xx_tracking(mode ? TRACK_CMD_COVER : TRACK_CMD_NOTCOVER);
1110 }
1111 EXPORT_SYMBOL(ist30xx_set_cover_mode);
1112
1113 #ifdef USE_TSP_TA_CALLBACKS
1114 void charger_enable(struct tsp_callbacks *cb, int enable)
1115 {
1116         bool charging = enable ? true : false;
1117
1118         ist30xx_set_ta_mode(charging);
1119 }
1120
1121 static void ist30xx_register_callback(struct tsp_callbacks *cb)
1122 {
1123         ist30xxc_charger_callbacks = cb;
1124         pr_info("%s\n", __func__);
1125 }
1126 #endif
1127
1128 static void reset_work_func(struct work_struct *work)
1129 {
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);
1133
1134         if (unlikely((data == NULL) || (data->client == NULL)))
1135                 return;
1136
1137         if (likely((data->initialized == 1) && (data->status.power == 1) &&
1138                                 (data->status.update != 1) && (data->status.calib != 1))) {
1139
1140                 mutex_lock(&ist30xx_mutex);
1141                 ist30xx_disable_irq(data);
1142 #if IST30XX_GESTURE
1143                 if (data->suspend)
1144                         ist30xx_internal_suspend(data);
1145                 else
1146 #endif
1147                         ist30xx_reset(data, false);
1148                 clear_input_data(data);
1149                 ist30xx_start(data);
1150 #if IST30XX_GESTURE
1151                 if (data->gesture && data->suspend)
1152                         data->status.noise_mode = false;
1153 #endif
1154                 ist30xx_enable_irq(data);
1155                 mutex_unlock(&ist30xx_mutex);
1156         }
1157 }
1158
1159 #if IST30XX_INTERNAL_BIN
1160 #if IST30XX_UPDATE_BY_WORKQUEUE
1161 static void fw_update_func(struct work_struct *work)
1162 {
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);
1166
1167         if (unlikely((data == NULL) || (data->client == NULL)))
1168                 return;
1169
1170         tsp_info("FW update function\n");
1171
1172         if (likely(ist30xx_auto_bin_update(data)))
1173                 ist30xx_disable_irq(data);
1174 }
1175 #endif /* IST30XX_UPDATE_BY_WORKQUEUE */
1176 #endif /* IST30XX_INTERNAL_BIN */
1177
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)
1188 {
1189         int ret;
1190         u32 touch_status = 0;
1191         u32 scan_count = 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);
1195
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");
1200                 goto retry_timer;
1201         }
1202
1203         ist30xx_put_track_ms(timer_ms);
1204         ist30xx_put_track(&touch_status, 1);
1205
1206         tsp_verb("Touch Info: 0x%08x\n", touch_status);
1207
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);
1211                 goto retry_timer;
1212         }
1213
1214         /* Status of IC is deep sleep */
1215         data->deep_sleep = GET_DEEP_SLEEP_STATUS(touch_status) ? true : false;
1216
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);
1222         }
1223
1224         scan_count = GET_SCAN_CNT(touch_status);
1225
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);
1229                 goto retry_timer;
1230         }
1231
1232         data->scan_retry = 0;
1233         data->scan_count = scan_count;
1234         return;
1235
1236 retry_timer:
1237         data->scan_retry++;
1238         tsp_warn("Retry touch status!(%d)\n", data->scan_retry);
1239
1240         if (unlikely(data->scan_retry == data->max_scan_retry)) {
1241                 ist30xx_scheduled_reset(data);
1242                 data->scan_retry = 0;
1243         }
1244 }
1245
1246 static void debug_work_func(struct work_struct *work)
1247 {
1248 #if IST30XX_ALGORITHM_MODE
1249         int ret = -EPERM;
1250         int i;
1251         u32 *buf32;
1252
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);
1256
1257         buf32 = kzalloc(ist30xx_algr_size, GFP_KERNEL);
1258         if (!buf32) {
1259                 tsp_info("%s: Couldn't Allocate memory\n", __func__);
1260                                 return;
1261         }
1262
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);
1266                 if (ret) {
1267                         tsp_warn("Algorithm mem addr read fail!\n");
1268                         return;
1269                 }
1270         }
1271
1272         ist30xx_put_track(buf32, ist30xx_algr_size);
1273
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]);
1276         kfree(buf32);
1277 #endif
1278 }
1279
1280 void timer_handler(unsigned long timer_data)
1281 {
1282         struct ist30xx_data *data = (struct ist30xx_data *)timer_data;
1283         struct ist30xx_status *status = &data->status;
1284
1285         if (data->irq_working)
1286                 goto restart_timer;
1287
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);
1296                                         status->calib = 0;
1297                                 } else if (timer_ms - event_ms >= 3000) {
1298                                         /* over 3 second */
1299                                         tsp_info("calibration timeout over 3sec\n");
1300                                         schedule_delayed_work(&data->work_reset_check, 0);
1301                                         status->calib = 0;
1302                                 }
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);
1307                         }
1308
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);
1315                         }
1316 #endif
1317                 }
1318         }
1319
1320 restart_timer:
1321         mod_timer(&event_timer, get_jiffies_64() + EVENT_TIMER_INTERVAL);
1322 }
1323
1324 static void ist30xx_request_gpio(struct i2c_client *client,
1325                 struct ist30xx_data *data)
1326 {
1327         int ret;
1328
1329         tsp_info("%s\n", __func__);
1330
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");
1334                 if (ret) {
1335                         tsp_err("%s: unable to request touch_en_gpio [%d]\n",
1336                                         __func__, data->dt_data->touch_en_gpio);
1337                         return;
1338                 }
1339         }
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");
1344                 if (ret) {
1345                         tsp_err("%s: unable to request touch_en_gpio [%d]\n",
1346                                         __func__, data->dt_data->keyled_en_gpio);
1347                         return;
1348                 }
1349         }
1350 #endif
1351         if (gpio_is_valid(data->dt_data->irq_gpio)) {
1352                 ret = gpio_request(data->dt_data->irq_gpio, "imagis,irq_gpio");
1353                 if (ret) {
1354                         tsp_err("%s: unable to request irq_gpio [%d]\n",
1355                                         __func__, data->dt_data->irq_gpio);
1356                         return;
1357                 }
1358
1359                 ret = gpio_direction_input(data->dt_data->irq_gpio);
1360                 if (ret) {
1361                         tsp_err("%s: unable to set direction for gpio [%d]\n",
1362                                         __func__, data->dt_data->irq_gpio);
1363                 }
1364                 client->irq = gpio_to_irq(data->dt_data->irq_gpio);
1365         }
1366 }
1367
1368 static void ist30xx_free_gpio(struct ist30xx_data *data)
1369 {
1370         tsp_info("%s\n", __func__);
1371
1372         if (gpio_is_valid(data->dt_data->touch_en_gpio))
1373                 gpio_free(data->dt_data->touch_en_gpio);
1374
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);
1380 #endif
1381 }
1382
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
1388
1389 static int ist30xx_get_sleep_monitor_cb(void* priv, unsigned int *raw_val, int check_level, int caller_type);
1390
1391 static struct sleep_monitor_ops  ist30xx_sleep_monitor_ops = {
1392          .read_cb_func =  ist30xx_get_sleep_monitor_cb,
1393 };
1394
1395 static int ist30xx_get_sleep_monitor_cb(void* priv, unsigned int *raw_val, int check_level, int caller_type)
1396 {
1397         struct ist30xx_data *data = priv;
1398         int state = DEVICE_UNKNOWN;
1399         int tsp_mode;
1400         int pretty = 0;
1401         *raw_val = -1;
1402
1403         if (check_level == SLEEP_MONITOR_CHECK_SOFT) {
1404                 if (data->touch_stopped)
1405                         state = DEVICE_POWER_OFF;
1406                 else
1407                         state = DEVICE_ON_ACTIVE1;
1408                 *raw_val = state;
1409         } else if (check_level == SLEEP_MONITOR_CHECK_HARD) {
1410                 if (data->touch_stopped) {
1411                         state = DEVICE_POWER_OFF;
1412                         goto out;
1413                 }
1414
1415                 if (data->touch_stopped)
1416                         state = DEVICE_POWER_OFF;
1417                 else
1418                         state = DEVICE_ON_ACTIVE1;
1419         }
1420
1421 out:
1422         *raw_val = ((state & STATE_MASK) << STATE_BIT) |\
1423                         (data->release_cnt & CNT_MASK);
1424
1425         if (data->release_cnt > PRETTY_MAX)
1426                 pretty = PRETTY_MAX;
1427         else
1428                 pretty = data->release_cnt;
1429
1430         data->release_cnt = 0;
1431
1432         tsp_info("%s: raw_val[0x%08x], check_level[%d], state[%d], pretty[%d]\n",
1433                 __func__, *raw_val, check_level, state, pretty);
1434
1435         return pretty;
1436 }
1437 #endif
1438
1439
1440 #ifdef CONFIG_OF
1441 static int ist30xx_parse_dt(struct device *dev, struct ist30xx_data *data)
1442 {
1443         struct device_node *np = dev->of_node;
1444         int rc = 0;
1445
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);
1450 #endif
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);
1453
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);
1456
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);
1459
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);
1462
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);
1465
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);
1468
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);
1471
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);
1474
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);
1482                         else
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);
1486
1487                         tsp_info("%s() firm path: %s\n", __func__, data->dt_data->fw_path);
1488                 }
1489
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);
1494         }
1495
1496         rc = of_property_read_string(np, "vdd_ldo_name", &data->dt_data->tsp_vdd_name);
1497         if (rc < 0)
1498                 tsp_err("%s: Unable to read TSP ldo name\n", __func__);
1499
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);
1504 #else
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);
1508
1509 #endif
1510         return 0;
1511 }
1512 #else
1513 static int ist30xx_parse_dt(struct device *dev, struct ist30xx_data *data)
1514 {
1515         return -ENODEV;
1516 }
1517 #endif
1518
1519 static int ist30xx_set_input_device(struct ist30xx_data *data)
1520 {
1521         int ret;
1522 #if IST30XX_USE_KEY
1523         int i;
1524 #endif
1525         set_bit(EV_ABS, data->input_dev->evbit);
1526         set_bit(EV_SYN, data->input_dev->evbit);
1527
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);
1531
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);
1538
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);
1544 #endif
1545
1546 #if IST30XX_USE_KEY
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);
1551
1552         for (i = 1; i < ARRAY_SIZE(ist30xx_key_code); i++)
1553                 set_bit(ist30xx_key_code[i], data->input_dev->keybit);
1554
1555 #if IST30XX_GESTURE
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");
1564 #endif
1565 #endif
1566
1567         input_set_drvdata(data->input_dev, data);
1568         ret = input_register_device(data->input_dev);
1569         if (ret) {
1570                 tsp_err("%s: failed input register device:%d\n", __func__, ret);
1571         } else
1572                 tsp_info("%s: input register device:%d\n", __func__, ret);
1573
1574         return ret;
1575 }
1576
1577 static int ist30xx_probe(struct i2c_client *client,
1578                 const struct i2c_device_id *id)
1579 {
1580         int ret;
1581         int retry = 3;
1582         u32 xy_res;
1583         u32 xy_swap;
1584         u32 tsp_type = 0;
1585
1586         struct ist30xx_data *data;
1587         struct input_dev *input_dev;
1588
1589         tsp_info("### IMAGIS probe(ver:%s, protocol:%X, addr:0x%02X) ###\n",
1590                         IMAGIS_DD_VERSION, IMAGIS_PROTOCOL_B, client->addr);
1591
1592         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
1593                 printk(KERN_INFO "i2c_check_functionality error\n");
1594                 return -EIO;
1595         }
1596
1597         data = kzalloc(sizeof(*data), GFP_KERNEL);
1598         if (!data)
1599                 return -ENOMEM;
1600
1601 #ifdef CONFIG_OF
1602         data->dt_data = NULL;
1603         data->irq_enabled = 1;
1604         data->client = client;
1605         i2c_set_clientdata(client, data);
1606
1607         if (client->dev.of_node) {
1608                 data->dt_data = kzalloc(sizeof(struct ist30xx_dt_data), GFP_KERNEL);
1609
1610                 if (!data->dt_data)
1611                         goto err_alloc_dev;
1612
1613                 ret = ist30xx_parse_dt(&client->dev, data);
1614                 if (ret)
1615                         goto err_alloc_dt;
1616         } else {
1617                 data->dt_data = NULL;
1618                 tsp_err("%s: TSP failed to align dtsi\n", __func__);
1619         }
1620
1621         if (data->dt_data)
1622                 ist30xx_request_gpio(client, data);
1623
1624 #if 0
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)
1629                         goto err_pinctrl;
1630
1631                 tsp_err("%s: Target does not use pinctrl\n", __func__);
1632                 data->pinctrl = NULL;
1633         }
1634
1635         if (data->pinctrl) {
1636                 ret = ist30xx_pinctrl_configure(data, true);
1637                 if (ret)
1638                         tsp_err("%s: cannot set pinctrl state\n", __func__);
1639         }
1640 #endif
1641 #endif
1642         input_dev = input_allocate_device();
1643         if (unlikely(!input_dev)) {
1644                 tsp_err("input_allocate_device failed\n");
1645                 goto err_alloc_dev;
1646         }
1647
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);
1655
1656         input_mt_init_slots(input_dev, IST30XX_MAX_MT_FINGERS, 0);
1657
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;
1663
1664
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);
1670 #endif
1671         ts_data = data;
1672
1673         ret = ist30xx_init_system(data);
1674         if (unlikely(ret)) {
1675                 tsp_err("chip initialization failed\n");
1676                 goto err_init_drv;
1677         }
1678
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);
1682
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);
1689                    else
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);
1693
1694                    tsp_info("%s() firm path: %s\n", __func__, data->dt_data->fw_path);
1695            }
1696         }
1697
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__);
1702
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)) {
1710                                 break;
1711                         }
1712                 } else if (unlikely(retry == 0)) {
1713                         goto err_init_drv;
1714                 }
1715
1716                 ist30xx_reset(data, false);
1717         }
1718
1719         ret = request_threaded_irq(client->irq, NULL, ist30xx_irq_thread,
1720                         IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "ist30xx_ts", data);
1721         if (unlikely(ret))
1722                 goto err_init_drv;
1723
1724         ist30xx_disable_irq(data);
1725
1726 #if (IMAGIS_TSP_IC < IMAGIS_IST3038C)
1727         retry = 3;
1728         data->tsp_type = TSP_TYPE_UNKNOWN;
1729         while (retry-- > 0) {
1730
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);
1735                         break;
1736                 }
1737
1738                 if (unlikely(retry == 0))
1739                         goto err_irq;
1740         }
1741
1742         tsp_info("TSP IC: %x, TSP Vendor: %x\n", data->chip_id, data->tsp_type);
1743 #else
1744         tsp_info("TSP IC: %x\n", data->chip_id);
1745 #endif
1746         data->status.event_mode = false;
1747
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);
1752 #else
1753         ret = ist30xx_auto_bin_update(data);
1754         if (unlikely(ret != 0))
1755                 goto err_irq;
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);
1764         } else {
1765                 data->max_x = (u16)(xy_res >> 16);
1766                 data->max_y = (u16)(xy_res & 0xFFFF);
1767         }
1768         tsp_err("%s: ret:%d, xy:%X, x:%d, y:%d\n", __func__, ret, xy_res, data->max_x, data->max_y);
1769
1770         ret = ist30xx_set_input_device(data);
1771         if (ret < 0)
1772                 goto err_irq;
1773
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__);
1779                 goto err_irq;
1780         }
1781 #endif
1782
1783         ret = ist30xx_init_update_sysfs(data);
1784         if (unlikely(ret))
1785                 goto err_sysfs;
1786
1787 #if IST30XX_DEBUG
1788         ret = ist30xx_init_misc_sysfs(data);
1789         if (unlikely(ret))
1790                 goto err_sysfs;
1791 #endif
1792
1793 #if IST30XX_CMCS_TEST
1794         ret = ist30xx_init_cmcs_sysfs(data);
1795         if (unlikely(ret))
1796                 tsp_err("%s: do not init cmcs\n",__func__);
1797
1798 #if IST30XX_CMCS_JIT_TEST
1799         ret = ist30xx_init_cmcs_jit_sysfs(data);
1800         if (unlikely(ret))
1801                 tsp_err("%s: do not init cmcs jitter\n",__func__);
1802 #endif
1803 #endif
1804
1805 #if IST30XX_TRACKING_MODE
1806         ret = ist30xx_init_tracking_sysfs(data);
1807         if (unlikely(ret))
1808                 goto err_sysfs;
1809 #endif
1810
1811 #if SEC_FACTORY_MODE
1812         ret = sec_fac_cmd_init(data);
1813         if (unlikely(ret))
1814                 goto err_sysfs;
1815
1816         ret = sec_touch_sysfs(data);
1817         if (unlikely(ret))
1818                 goto err_sec_sysfs;
1819 #endif
1820
1821         /* initialize data variable */
1822 #if IST30XX_GESTURE
1823         data->suspend = false;
1824         data->gesture = false;
1825 #endif
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
1833         data->jig_mode = 1;
1834 #endif
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);
1838
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);
1844
1845         ret = ist30xx_get_info(data);
1846         tsp_info("Get info: %s\n", (ret == 0 ? "success" : "fail"));
1847
1848 #ifdef USE_TSP_TA_CALLBACKS
1849         data->callbacks.inform_charger = charger_enable;
1850         ist30xx_register_callback(&data->callbacks);
1851 #endif
1852
1853 #ifdef CONFIG_SLEEP_MONITOR
1854         sleep_monitor_register_ops(data, &ist30xx_sleep_monitor_ops,
1855                         SLEEP_MONITOR_TSP);
1856 #endif
1857
1858         data->initialized = true;
1859
1860         tsp_info("### IMAGIS probe success ###\n");
1861
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__);
1866
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);
1871         }
1872
1873         return 0;
1874 #ifdef CONFIG_SLEEP_MONITOR
1875         sleep_monitor_unregister_ops(SLEEP_MONITOR_TSP);
1876 #endif
1877
1878 err_sec_sysfs:
1879 #if SEC_FACTORY_MODE
1880         sec_fac_cmd_remove(data);
1881         sec_touch_sysfs_remove(data);
1882 #endif
1883 err_sysfs:
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;
1889 #endif
1890 err_irq:
1891         tsp_info("ChipID: %x\n", data->chip_id);
1892         ist30xx_disable_irq(data);
1893         free_irq(client->irq, data);
1894 err_init_drv:
1895         data->status.event_mode = false;
1896         ist30xx_power_off(data);
1897 #ifdef CONFIG_HAS_EARLYSUSPEND
1898         unregister_early_suspend(&data->early_suspend);
1899 #endif
1900 //err_pinctrl:
1901 err_alloc_dt:
1902         if (data->dt_data) {
1903                 tsp_err("%s: Error, ist30xx mem free, line:%d\n", __func__, __LINE__);
1904                 kfree(data->dt_data);
1905         }
1906 err_alloc_dev:
1907         kfree(data);
1908         tsp_err("Error, ist30xx init driver\n");
1909         return -ENODEV;
1910 }
1911
1912
1913 static int ist30xx_remove(struct i2c_client *client)
1914 {
1915         struct ist30xx_data *data = i2c_get_clientdata(client);
1916
1917 #ifdef CONFIG_SLEEP_MONITOR
1918         sleep_monitor_unregister_ops(SLEEP_MONITOR_TSP);
1919 #endif
1920 #ifdef CONFIG_HAS_EARLYSUSPEND
1921         unregister_early_suspend(&data->early_suspend);
1922 #endif
1923
1924         ist30xx_disable_irq(data);
1925         free_irq(client->irq, data);
1926         ist30xx_power_off(data);
1927
1928         sec_fac_cmd_remove(data);
1929
1930         if (data->dt_data)
1931                 ist30xx_free_gpio(data);
1932
1933         input_unregister_device(data->input_dev);
1934 #ifdef CONFIG_INPUT_BOOSTER
1935         input_booster_free(data->tsp_booster);
1936         data->tsp_booster = NULL;
1937 #endif
1938         kfree(data);
1939
1940         return 0;
1941 }
1942
1943 static void ist30xx_shutdown(struct i2c_client *client)
1944 {
1945         struct ist30xx_data *data = i2c_get_clientdata(client);
1946
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;
1960 #endif
1961 }
1962
1963 static struct i2c_device_id ist30xx_idtable[] = {
1964         { IST30XX_DEV_NAME, 0 },
1965         {},
1966 };
1967 MODULE_DEVICE_TABLE(i2c, ist30xx_idtable);
1968
1969 #ifdef CONFIG_OF
1970 static struct of_device_id ist30xx_match_table[] = {
1971         { .compatible = "imagis,ist30xx-ts", },
1972         { },
1973 };
1974 #else
1975 #define ist30xx_match_table NULL
1976 #endif
1977
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,
1983         .driver         = {
1984                 .owner          = THIS_MODULE,
1985                 .name           = IST30XX_DEV_NAME,
1986                 .of_match_table = ist30xx_match_table,
1987         },
1988 };
1989
1990 static int __init ist30xx_init(void)
1991 {
1992         tsp_info("%s()\n", __func__);
1993         return i2c_add_driver(&ist30xx_i2c_driver);
1994 }
1995
1996
1997 static void __exit ist30xx_exit(void)
1998 {
1999         tsp_info("%s()\n", __func__);
2000         i2c_del_driver(&ist30xx_i2c_driver);
2001 }
2002
2003 module_init(ist30xx_init);
2004 module_exit(ist30xx_exit);
2005
2006 MODULE_DESCRIPTION("Imagis IST30XX touch driver");
2007 MODULE_LICENSE("GPL");