drivers/input/touchscreen/imagis_30xxc/ist30xxc_sec.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
  17 #include <linux/mutex.h>
  18 #include <linux/i2c.h>
  19 #include <linux/delay.h>
  20 #include <linux/slab.h>
  21 #include <linux/input.h>
  22 #include <linux/stat.h>
  23 #include <linux/err.h>
  24 #include <linux/firmware.h>
  25 #include <linux/gpio.h>
  26 #ifdef CONFIG_INPUT_BOOSTER
  27 #include <linux/input/input_booster.h>
  28 #endif
  29 #include <linux/i2c/ist30xxc.h>
  30 #include "ist30xxc_update.h"
  31 #if IST30XX_DEBUG
  32 #include "ist30xxc_misc.h"
  33 #endif
  34 #if IST30XX_CMCS_TEST
  35 #include "ist30xxc_cmcs.h"
  36 #endif
  37
  38 #if SEC_FACTORY_MODE
  39 #define COMMAND_LENGTH          64
  40 #define FACTORY_BUF_SIZE    PAGE_SIZE
  41 #define BUILT_IN            (0)
  42 #define UMS                 (1)
  43
  44 #define CMD_STATE_WAITING   (0)
  45 #define CMD_STATE_RUNNING   (1)
  46 #define CMD_STATE_OK        (2)
  47 #define CMD_STATE_FAIL      (3)
  48 #define CMD_STATE_NA        (4)
  49
  50 #define TSP_NODE_DEBUG      (0)
  51 #define TSP_CM_DEBUG        (0)
  52
  53 #define TSP_CH_UNUSED       (0)
  54 #define TSP_CH_SCREEN       (1)
  55 #define TSP_CH_GTX          (2)
  56 #define TSP_CH_KEY          (3)
  57 #define TSP_CH_UNKNOWN      (-1)
  58
  59 #define TSP_CMD(name, func) .cmd_name = name, .cmd_func = func
  60 struct tsp_cmd {
  61         struct list_head        list;
  62         const char *            cmd_name;
  63         void                    (*cmd_func)(void *dev_data);
  64 };
  65
  66 u32 ist30xx_get_fw_ver(struct ist30xx_data *data)
  67 {
  68         u32 ver = 0;
  69         int ret = 0;
  70
  71         ret = ist30xx_read_cmd(data, eHCOM_GET_VER_FW, &ver);
  72         if (unlikely(ret))
  73         {
  74                 ist30xx_reset(data, false);
  75                 ist30xx_start(data);
  76                 tsp_info("%s(), ret=%d\n", __func__, ret);
  77                 return ver;
  78         }
  79
  80         tsp_debug("Reg addr: %x, ver: %x\n", eHCOM_GET_VER_FW, ver);
  81
  82         return ver;
  83 }
  84
  85 u32 ist30xx_get_fw_chksum(struct ist30xx_data *data)
  86 {
  87
  88         u32 chksum = 0;
  89         int ret = 0;
  90
  91         ret = ist30xx_read_cmd(data, eHCOM_GET_CRC32, &chksum);
  92         if (unlikely(ret)) {
  93                 ist30xx_reset(data, false);
  94                 ist30xx_start(data);
  95                 tsp_info("%s(), ret=%d\n", __func__, ret);
  96                 return 0;
  97         }
  98
  99         tsp_debug("Reg addr: %x, chksum: %x\n", eHCOM_GET_CRC32,chksum);
 100
 101         return chksum;
 102 }
 103
 104 #define KEY_SENSITIVITY_OFFSET  0x10
 105 u32 key_sensitivity = 0;
 106 int ist30xx_get_key_sensitivity(struct ist30xx_data *data, int id)
 107 {
 108         u32 addr = IST30XX_DA_ADDR(data->tags.algo_base) + KEY_SENSITIVITY_OFFSET;
 109         u32 val = 0;
 110         int ret = 0;
 111
 112         if (unlikely(id >= data->tkey_info.key_num))
 113                 return 0;
 114
 115         if (ist30xx_intr_wait(data, 30) < 0)
 116                 return 0;
 117
 118         ret = ist30xx_read_cmd(data, addr, &val);
 119         if (ret) {
 120                 ist30xx_reset(data, false);
 121                 ist30xx_start(data);
 122                 tsp_info("%s(), ret=%d\n", __func__, ret);
 123                 return 0;
 124         }
 125
 126         if ((val & 0xFFF) == 0xFFF)
 127                 return (key_sensitivity >> (16 * id)) & 0xFFFF;
 128
 129         key_sensitivity = val;
 130
 131         tsp_debug("Reg addr: %x, val: %8x\n", addr, val);
 132
 133         val >>= (16 * id);
 134
 135         return (int)(val & 0xFFFF);
 136 }
 137
 138
 139 /* Factory CMD function */
 140 static void set_default_result(struct sec_factory *sec)
 141 {
 142         char delim = ':';
 143
 144         memset(sec->cmd_result, 0, sec->cmd_result_length);
 145         memcpy(sec->cmd_result, sec->cmd, strlen(sec->cmd));
 146         strncat(sec->cmd_result, &delim, CMD_STATE_RUNNING);
 147 }
 148
 149 static void set_cmd_result(struct sec_factory *sec, char *buf, int len)
 150 {
 151         strncat(sec->cmd_result, buf, len);
 152 }
 153
 154 static void not_support_cmd(void *dev_data)
 155 {
 156         char buf[16] = { 0 };
 157
 158         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 159         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 160
 161         set_default_result(sec);
 162         snprintf(buf, sizeof(buf), "%s", "NA");
 163         tsp_info("%s(), %s\n", __func__, buf);
 164
 165         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 166
 167         mutex_lock(&sec->cmd_lock);
 168         sec->cmd_is_running = false;
 169         mutex_unlock(&sec->cmd_lock);
 170
 171         sec->cmd_state = CMD_STATE_NA;
 172         dev_info(&data->client->dev, "%s: \"%s(%d)\"\n", __func__,
 173                         buf, strnlen(buf, sizeof(buf)));
 174         return;
 175 }
 176
 177 static void get_chip_vendor(void *dev_data)
 178 {
 179         char buf[16] = { 0 };
 180
 181         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 182         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 183
 184         set_default_result(sec);
 185         snprintf(buf, sizeof(buf), "%s", TSP_CHIP_VENDOR);
 186         tsp_info("%s(), %s\n", __func__, buf);
 187
 188         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 189         sec->cmd_state = CMD_STATE_OK;
 190         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__,
 191                         buf, strnlen(buf, sizeof(buf)));
 192 }
 193
 194 static void get_chip_name(void *dev_data)
 195 {
 196         char buf[16] = { 0 };
 197
 198         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 199         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 200
 201         set_default_result(sec);
 202         snprintf(buf, sizeof(buf), "%s", TSP_CHIP_NAME);
 203         tsp_info("%s(), %s\n", __func__, buf);
 204
 205         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 206         sec->cmd_state = CMD_STATE_OK;
 207         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__,
 208                         buf, strnlen(buf, sizeof(buf)));
 209 }
 210
 211 static void get_chip_id(void *dev_data)
 212 {
 213         char buf[16] = { 0 };
 214
 215         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 216         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 217
 218         set_default_result(sec);
 219         snprintf(buf, sizeof(buf), "%#02x", data->chip_id);
 220         tsp_info("%s(), %s\n", __func__, buf);
 221
 222         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 223         sec->cmd_state = CMD_STATE_OK;
 224         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__,
 225                         buf, strnlen(buf, sizeof(buf)));
 226 }
 227 #include <linux/uaccess.h>
 228 #define MAX_FW_PATH 255
 229 static void fw_update(void *dev_data)
 230 {
 231         int ret;
 232         char buf[16] = { 0 };
 233         mm_segment_t old_fs = {0};
 234         struct file *fp = NULL;
 235         long fsize = 0, nread = 0;
 236         u8 *fw;
 237         char fw_path[MAX_FW_PATH+1];
 238         const struct firmware *firmware = NULL;
 239
 240         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 241         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 242
 243         set_default_result(sec);
 244
 245         tsp_info("%s(), %d\n", __func__, sec->cmd_param[0]);
 246
 247         switch (sec->cmd_param[0]) {
 248         case BUILT_IN:
 249                 if (data->dt_data->fw_bin) {
 250                         ret = request_firmware(&firmware, data->dt_data->fw_path, &data->client->dev);
 251                         if (ret) {
 252                                 tsp_err("%s: do not request firmware: %d\n", __func__, ret);
 253                                 goto out;
 254                         }
 255
 256                         data->fw.buf = (u8 *)firmware->data;
 257                         data->fw.size = firmware->size;
 258                 }
 259                 ret = ist30xx_fw_recovery(data);
 260                 if (ret < 0) {
 261                         if (data->dt_data->fw_bin && firmware) {
 262                                 release_firmware(firmware);
 263                                 data->fw.buf = NULL;
 264                         }
 265                         tsp_err("%s: failed fw_recovery: %d\n", __func__, ret);
 266                         goto out;
 267                 }
 268
 269                 if (data->dt_data->fw_bin && firmware) {
 270                         release_firmware(firmware);
 271                         data->fw.buf = NULL;
 272                 }
 273
 274                 break;
 275         case UMS:
 276                 old_fs = get_fs();
 277                 set_fs(get_ds());
 278
 279                 snprintf(fw_path, MAX_FW_PATH, "%s", IST30XX_FW_NAME);
 280                 fp = filp_open(fw_path, O_RDONLY, 0);
 281                 if (IS_ERR(fp)) {
 282                         tsp_warn("%s(), file %s open error:%d\n", __func__,
 283                                         fw_path, (s32)fp);
 284                         set_fs(old_fs);
 285                         goto out;
 286                 }
 287
 288                 fsize = fp->f_path.dentry->d_inode->i_size;
 289                 if (fsize != data->fw.buf_size) {
 290                         tsp_warn("%s(), invalid fw size!!\n", __func__);
 291                         set_fs(old_fs);
 292                         goto out;
 293                 }
 294
 295                 fw = kzalloc((size_t)fsize, GFP_KERNEL);
 296                 if (!fw) {
 297                         tsp_warn("%s(), failed to alloc buffer for fw\n", __func__);
 298                         filp_close(fp, NULL);
 299                         set_fs(old_fs);
 300                         goto out;
 301                 }
 302
 303                 nread = vfs_read(fp, (char __user *)fw, fsize, &fp->f_pos);
 304                 if (nread != fsize) {
 305                         tsp_warn("%s(), failed to read fw\n", __func__);
 306                         kfree(fw);
 307                         filp_close(fp, NULL);
 308                         set_fs(old_fs);
 309                         goto out;
 310                 }
 311
 312                 filp_close(fp, current->files);
 313                 set_fs(old_fs);
 314                 tsp_info("%s(), ums fw is loaded!!\n", __func__);
 315
 316                 ret = ist30xx_get_update_info(data, fw, fsize);
 317                 if (ret) {
 318                         tsp_warn("%s(), failed to update info\n", __func__);
 319                         kfree(fw);
 320                         goto out;
 321                 }
 322                 data->fw.bin.main_ver = ist30xx_parse_ver(data, FLAG_MAIN, fw);
 323                 data->fw.bin.fw_ver = ist30xx_parse_ver(data, FLAG_FW, fw);
 324                 data->fw.bin.test_ver = ist30xx_parse_ver(data, FLAG_TEST, fw);
 325                 data->fw.bin.core_ver = ist30xx_parse_ver(data, FLAG_CORE, fw);
 326
 327                 mutex_lock(&ist30xx_mutex);
 328                 ret = ist30xx_fw_update(data, fw, fsize);
 329                 if (ret) {
 330                         mutex_unlock(&ist30xx_mutex);
 331                         kfree(fw);
 332                         goto out;
 333                 }
 334                 mutex_unlock(&ist30xx_mutex);
 335
 336                 kfree(fw);
 337                 ist30xx_calibrate(data, 1);
 338                 break;
 339
 340         default:
 341                 tsp_warn("%s(), Invalid fw file type!\n", __func__);
 342                 goto out;
 343                 break;
 344         }
 345
 346         sec->cmd_state = CMD_STATE_OK;
 347         snprintf(buf, sizeof(buf), "%s", "OK");
 348         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 349
 350         return;
 351
 352 out:
 353         sec->cmd_state = CMD_STATE_FAIL;
 354         snprintf(buf, sizeof(buf), "%s", "NG");
 355         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 356
 357 }
 358
 359
 360 static void get_fw_ver_bin(void *dev_data)
 361 {
 362         u32 ver = 0;
 363         char buf[16] = { 0 };
 364
 365         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 366         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 367         const struct firmware *firmware = NULL;
 368         int ret;
 369
 370         set_default_result(sec);
 371
 372         if (data->dt_data->fw_bin) {
 373                 ret = request_firmware(&firmware, data->dt_data->fw_path, &data->client->dev);
 374                 if (ret) {
 375                         tsp_err("%s: do not request firmware: %d\n", __func__, ret);
 376                         sec->cmd_state = CMD_STATE_FAIL;
 377
 378                         return;
 379                 }
 380
 381                 data->fw.buf = (u8 *)firmware->data;
 382                 data->fw.size = firmware->size;
 383         }
 384
 385         ver = ist30xx_parse_ver(data, FLAG_FW, data->fw.buf);
 386         snprintf(buf, sizeof(buf), "IM00%04x", ver);
 387         tsp_info("%s(), %s\n", __func__, buf);
 388
 389         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 390         sec->cmd_state = CMD_STATE_OK;
 391         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__,
 392                         buf, strnlen(buf, sizeof(buf)));
 393
 394         if (data->dt_data->fw_bin && firmware) {
 395                 release_firmware(firmware);
 396                 data->fw.buf = NULL;
 397         }
 398 }
 399 static void get_config_ver(void *dev_data)
 400 {
 401         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 402         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 403
 404         char buff[255] = {0};
 405
 406         set_default_result(sec);
 407
 408         snprintf(buff, sizeof(buff), "%s_%s", TSP_CHIP_VENDOR, TSP_CHIP_NAME);
 409
 410         set_cmd_result(sec, buff, strnlen(buff, sizeof(buff)));
 411         sec->cmd_state = CMD_STATE_OK;
 412         tsp_info("%s(): %s(%d)\n", __func__, buff,
 413                  strnlen(buff, sizeof(buff)));
 414 }
 415 static void get_checksum_data(void *dev_data)
 416 {
 417
 418         char buf[16] = {0};
 419         u32 chksum = 0;
 420         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 421         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 422
 423         set_default_result(sec);
 424
 425         if (data->status.power == 1) {
 426                 chksum = ist30xx_get_fw_chksum(data);
 427                 if (chksum == 0) {
 428                         tsp_info("%s(), Failed get the checksum data \n", __func__);
 429                         snprintf(buf, sizeof(buf), "%s", "NG");
 430                         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 431                         sec->cmd_state = CMD_STATE_FAIL;
 432                         return;
 433                 }
 434         }
 435
 436         snprintf(buf, sizeof(buf), "0x%06X", chksum);
 437
 438         tsp_info("%s(), %s\n", __func__, buf);
 439
 440         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 441         sec->cmd_state = CMD_STATE_OK;
 442         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__,
 443                         buf, strnlen(buf, sizeof(buf)));
 444 }
 445
 446 static void get_fw_ver_ic(void *dev_data)
 447 {
 448         u32 ver = 0;
 449         char msg[8];
 450         char buf[16] = { 0 };
 451
 452         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 453         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 454
 455         set_default_result(sec);
 456
 457         if (data->status.power == 1) {
 458                 ver = ist30xx_get_fw_ver(data);
 459                 snprintf(buf, sizeof(buf), "IM00%04x", ver & 0xFFFF);
 460         } else {
 461                 snprintf(buf, sizeof(buf), "IM00%04x", data->fw.cur.fw_ver & 0xFFFF);
 462         }
 463
 464         if (data->fw.cur.test_ver > 0) {
 465                 sprintf(msg, "(T%d)", data->fw.cur.test_ver);
 466                 strcat(buf, msg);
 467         }
 468
 469         tsp_info("%s(), %s\n", __func__, buf);
 470
 471         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 472         sec->cmd_state = CMD_STATE_OK;
 473         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__,
 474                         buf, strnlen(buf, sizeof(buf)));
 475 }
 476
 477 static void set_edge_mode(void *dev_data)
 478 {
 479         char buf[16] = { 0 };
 480
 481         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 482         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 483
 484         set_default_result(sec);
 485
 486         tsp_info("%s(), %d\n", __func__, sec->cmd_param[0]);
 487
 488         switch (sec->cmd_param[0]) {
 489         case 0:
 490                 sec->cmd_state = CMD_STATE_OK;
 491                 tsp_info("%s(), Set Edge Mode\n", __func__);
 492                 ist30xx_set_edge_mode(1);
 493                 break;
 494         case 1:
 495                 sec->cmd_state = CMD_STATE_OK;
 496                 tsp_info("%s(), Unset Edge Mode\n", __func__);
 497                 ist30xx_set_edge_mode(0);
 498                 break;
 499         default:
 500                 tsp_info("%s(), Invalid Argument\n", __func__);
 501                 break;
 502         }
 503         if (sec->cmd_state == CMD_STATE_OK)
 504                 snprintf(buf, sizeof(buf), "%s", "OK");
 505         else
 506                 snprintf(buf, sizeof(buf), "%s", "NG");
 507
 508         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 509         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__,
 510                         buf, strnlen(buf, sizeof(buf)));
 511 }
 512
 513 static void run_connect_test(void *dev_data)
 514 {
 515         int ret = 0;
 516         u32 val = 0;
 517         char buf[16] = { 0 };
 518
 519         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 520         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 521
 522         set_default_result(sec);
 523
 524         ret = ist30xx_read_cmd(data, eHCOM_GET_TOUCH_TH, &val);
 525         if (ret)
 526                 snprintf(buf, sizeof(buf), "%s", "NG");
 527         else
 528                 snprintf(buf, sizeof(buf), "%s", "OK");
 529
 530         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 531         sec->cmd_state = CMD_STATE_OK;
 532         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__,
 533                         buf, strnlen(buf, sizeof(buf)));
 534 }
 535
 536 static void get_threshold(void *dev_data)
 537 {
 538         int ret = 0;
 539         u32 val = 0;
 540         char buf[16] = { 0 };
 541         int threshold;
 542
 543         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 544         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 545
 546         ret = ist30xx_read_cmd(data, eHCOM_GET_TOUCH_TH, &val);
 547         if (unlikely(ret)) {
 548                 ist30xx_reset(data, false);
 549                 ist30xx_start(data);
 550                 tsp_info("%s(), ret=%d\n", __func__, ret);
 551                 val = 0;
 552         }
 553
 554         set_default_result(sec);
 555
 556         threshold = (int)(val & 0xFFFF);
 557
 558         snprintf(buf, sizeof(buf), "%d", threshold);
 559         tsp_info("%s(), %s\n", __func__, buf);
 560
 561         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 562         sec->cmd_state = CMD_STATE_OK;
 563         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__,
 564                         buf, strnlen(buf, sizeof(buf)));
 565 }
 566
 567 static void get_scr_x_num(void *dev_data)
 568 {
 569         int val = -1;
 570         char buf[16] = { 0 };
 571
 572         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 573         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 574
 575         set_default_result(sec);
 576
 577         if (data->tsp_info.dir.swap_xy)
 578                 val = data->tsp_info.screen.tx;
 579         else
 580                 val = data->tsp_info.screen.rx;
 581
 582         if (val >= 0) {
 583                 snprintf(buf, sizeof(buf), "%u", val);
 584                 sec->cmd_state = CMD_STATE_OK;
 585                 dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf,
 586                                 strnlen(buf, sizeof(buf)));
 587         } else {
 588                 snprintf(buf, sizeof(buf), "%s", "NG");
 589                 sec->cmd_state = CMD_STATE_FAIL;
 590                 dev_info(&data->client->dev,
 591                                 "%s: fail to read num of x (%d).\n", __func__, val);
 592         }
 593         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 594         tsp_info("%s(), %s\n", __func__, buf);
 595 }
 596
 597 static void get_scr_y_num(void *dev_data)
 598 {
 599         int val = -1;
 600         char buf[16] = { 0 };
 601
 602         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 603         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 604
 605         set_default_result(sec);
 606
 607         if (data->tsp_info.dir.swap_xy)
 608                 val = data->tsp_info.screen.rx;
 609         else
 610                 val = data->tsp_info.screen.tx;
 611
 612         if (val >= 0) {
 613                 snprintf(buf, sizeof(buf), "%u", val);
 614                 sec->cmd_state = CMD_STATE_OK;
 615                 dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf,
 616                                 strnlen(buf, sizeof(buf)));
 617         } else {
 618                 snprintf(buf, sizeof(buf), "%s", "NG");
 619                 sec->cmd_state = CMD_STATE_FAIL;
 620                 dev_info(&data->client->dev,
 621                                 "%s: fail to read num of y (%d).\n", __func__, val);
 622         }
 623         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 624         tsp_info("%s(), %s\n", __func__, buf);
 625 }
 626
 627 static void get_all_x_num(void *dev_data)
 628 {
 629         int val = - 1;
 630         char buf[16] = { 0 };
 631
 632         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 633         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 634
 635         set_default_result(sec);
 636
 637         if (data->tsp_info.dir.swap_xy)
 638                 val = data->tsp_info.ch_num.tx;
 639         else
 640                 val = data->tsp_info.ch_num.rx;
 641
 642         if (val >= 0) {
 643                 snprintf(buf, sizeof(buf), "%u", val);
 644                 sec->cmd_state = CMD_STATE_OK;
 645                 dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf,
 646                                 strnlen(buf, sizeof(buf)));
 647         } else {
 648                 snprintf(buf, sizeof(buf), "%s", "NG");
 649                 sec->cmd_state = CMD_STATE_FAIL;
 650                 dev_info(&data->client->dev,
 651                                 "%s: fail to read all num of x (%d).\n", __func__, val);
 652         }
 653         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 654         tsp_info("%s(), %s\n", __func__, buf);
 655 }
 656
 657 static void get_all_y_num(void *dev_data)
 658 {
 659         int val = -1;
 660         char buf[16] = { 0 };
 661
 662         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 663         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 664
 665         set_default_result(sec);
 666
 667         if (data->tsp_info.dir.swap_xy)
 668                 val = data->tsp_info.ch_num.rx;
 669         else
 670                 val = data->tsp_info.ch_num.tx;
 671
 672         if (val >= 0) {
 673                 snprintf(buf, sizeof(buf), "%u", val);
 674                 sec->cmd_state = CMD_STATE_OK;
 675                 dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf,
 676                                 strnlen(buf, sizeof(buf)));
 677         } else {
 678                 snprintf(buf, sizeof(buf), "%s", "NG");
 679                 sec->cmd_state = CMD_STATE_FAIL;
 680                 dev_info(&data->client->dev,
 681                                 "%s: fail to read all num of y (%d).\n", __func__, val);
 682         }
 683         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 684         tsp_info("%s(), %s\n", __func__, buf);
 685 }
 686
 687 #ifdef CONFIG_INPUT_BOOSTER
 688 /*
 689  *      DVFS_STAGE_NONE 0x0001  : 0000 0000 0000 0001
 690  *      DVFS_STAGE_SINGLE       0x0002  : 0000 0000 0000 0010
 691  *      DVFS_STAGE_DUAL 0x0004  : 0000 0000 0000 0100
 692  */
 693 static void boost_level(void *dev_data)
 694 {
 695         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 696         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 697         char buf[16] = { 0 };
 698         int ret;
 699
 700         set_default_result(sec);
 701
 702         ret = input_booster_set_level_change(sec->cmd_param[0]);
 703         if (ret < 0) {
 704                 snprintf(buf, sizeof(buf), "%u", sec->cmd_param[0]);
 705                 sec->cmd_state = CMD_STATE_FAIL;
 706                 goto out_boost_level;
 707         }
 708
 709         snprintf(buf, sizeof(buf), "%u", sec->cmd_param[0]);
 710         sec->cmd_state = CMD_STATE_OK;
 711
 712 out_boost_level:
 713         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf,
 714                         strnlen(buf, sizeof(buf)));
 715
 716         sec->cmd_state = CMD_STATE_WAITING;
 717
 718         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 719         tsp_info("%s(), %s\n", __func__, buf);
 720 }
 721 #endif
 722
 723 int check_tsp_channel(void *dev_data, int width, int height)
 724 {
 725         int node = -EPERM;
 726
 727         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 728         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 729
 730         if (data->tsp_info.dir.swap_xy) {
 731                 if ((sec->cmd_param[0] < 0) || (sec->cmd_param[0] >= height) ||
 732                         (sec->cmd_param[1] < 0) || (sec->cmd_param[1] >= width)) {
 733                         tsp_info("%s: parameter error: %u,%u\n",
 734                                  __func__, sec->cmd_param[0], sec->cmd_param[1]);
 735                 } else {
 736                         node = sec->cmd_param[1] + sec->cmd_param[0] * width;
 737                         tsp_info("%s: node = %d\n", __func__, node);
 738                 }
 739         } else {
 740                 if ((sec->cmd_param[0] < 0) || (sec->cmd_param[0] >= width) ||
 741                         (sec->cmd_param[1] < 0) || (sec->cmd_param[1] >= height)) {
 742                 tsp_info("%s: parameter error: %u,%u\n",
 743                                 __func__, sec->cmd_param[0], sec->cmd_param[1]);
 744                 } else {
 745                 node = sec->cmd_param[0] + sec->cmd_param[1] * width;
 746                 tsp_info("%s: node = %d\n", __func__, node);
 747                 }
 748         }
 749
 750         return node;
 751 }
 752
 753 static u16 node_value[IST30XX_NODE_TOTAL_NUM];
 754 static u16 key_node_value[IST30XX_MAX_KEYS];
 755 void get_raw_array(void *dev_data)
 756 {
 757         int i, ret;
 758         int count = 0;
 759         char *buf;
 760         const int msg_len = 16;
 761         char msg[msg_len];
 762         u8 flag = NODE_FLAG_RAW;
 763
 764         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 765         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 766         TSP_INFO *tsp = &data->tsp_info;
 767
 768         set_default_result(sec);
 769
 770         mutex_lock(&ist30xx_mutex);
 771         ret = ist30xx_read_touch_node(data, flag, &tsp->node);
 772         if (ret) {
 773                 mutex_unlock(&ist30xx_mutex);
 774                 sec->cmd_state = CMD_STATE_FAIL;
 775                 tsp_warn("%s(), tsp node read fail!\n", __func__);
 776                 return;
 777         }
 778         mutex_unlock(&ist30xx_mutex);
 779         ist30xx_parse_touch_node(data, flag, &tsp->node);
 780
 781         ret = parse_tsp_node(data, flag, &tsp->node, node_value, TS_RAW_ALL);
 782         if (ret) {
 783                 sec->cmd_state = CMD_STATE_FAIL;
 784                 tsp_warn("%s(), tsp node parse fail - flag: %d\n", __func__, flag);
 785                 return;
 786         }
 787
 788         buf = kmalloc(IST30XX_NODE_TOTAL_NUM * 5, GFP_KERNEL);
 789         if (!buf) {
 790                 tsp_info("%s: Couldn't Allocate memory\n", __func__);
 791                 return;
 792         }
 793         memset(buf, 0, IST30XX_NODE_TOTAL_NUM * 5);
 794
 795         for (i = 0; i < tsp->ch_num.rx * tsp->ch_num.tx; i++) {
 796 #if TSP_NODE_DEBUG
 797                 if ((i % tsp->ch_num.rx) == 0)
 798                         printk("\n%s %4d: ", IST30XX_DEBUG_TAG, i);
 799
 800                 printk("%4d ", node_value[i]);
 801 #endif
 802                 count += snprintf(msg, msg_len, "%d,", node_value[i]);
 803                 strncat(buf, msg, msg_len);
 804         }
 805
 806         printk("\n");
 807         tsp_info("%s: %d\n", __func__, count - 1);
 808         sec->cmd_state = CMD_STATE_OK;
 809         set_cmd_result(sec, buf, count - 1);
 810         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf, count);
 811         kfree(buf);
 812 }
 813
 814 void run_raw_read(void *dev_data)
 815 {
 816         int i;
 817         int ret = 0;
 818         int min_val, max_val;
 819         char buf[16] = { 0 };
 820         u8 flag = NODE_FLAG_RAW;
 821
 822         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 823         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 824         TSP_INFO *tsp = &data->tsp_info;
 825
 826         set_default_result(sec);
 827
 828         ret = ist30xx_read_touch_node(data, flag, &tsp->node);
 829         if (ret) {
 830                 sec->cmd_state = CMD_STATE_FAIL;
 831                 tsp_warn("%s(), tsp node read fail!\n", __func__);
 832                 return;
 833         }
 834         ist30xx_parse_touch_node(data, flag, &tsp->node);
 835
 836         ret = parse_tsp_node(data, flag, &tsp->node, node_value, TS_RAW_SCREEN);
 837         if (ret) {
 838                 sec->cmd_state = CMD_STATE_FAIL;
 839                 tsp_warn("%s(), tsp node parse fail - flag: %d\n", __func__, flag);
 840                 return;
 841         }
 842
 843         min_val = max_val = node_value[0];
 844         for (i = 0; i < tsp->screen.rx * tsp->screen.tx; i++) {         // modify block
 845 #if TSP_NODE_DEBUG
 846                 if ((i % tsp->screen.rx) == 0)
 847                         printk("\n%s %4d: ", IST30XX_DEBUG_TAG, i);
 848
 849                 printk("%4d ", node_value[i]);
 850 #endif
 851                 max_val = max(max_val, (int)node_value[i]);
 852
 853                 min_val = min(min_val, (int)node_value[i]);
 854         }
 855
 856         snprintf(buf, sizeof(buf), "%d,%d", min_val, max_val);
 857         tsp_info("%s(), %s\n", __func__, buf);
 858
 859         sec->cmd_state = CMD_STATE_OK;
 860         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 861         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf,
 862                         strnlen(buf, sizeof(buf)));
 863 }
 864
 865 void run_raw_read_key(void *dev_data)
 866 {
 867         int ret = 0;
 868         char buf[16] = { 0 };
 869         u8 flag = NODE_FLAG_RAW;
 870
 871         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 872         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 873         TSP_INFO *tsp = &data->tsp_info;
 874
 875         set_default_result(sec);
 876
 877         ret = ist30xx_read_touch_node(data, flag, &tsp->node);
 878         if (ret) {
 879                 sec->cmd_state = CMD_STATE_FAIL;
 880                 tsp_warn("%s(), tsp node read fail!\n", __func__);
 881                 return;
 882         }
 883         ist30xx_parse_touch_node(data, flag, &tsp->node);
 884
 885         ret = parse_tsp_node(data, flag, &tsp->node, key_node_value, TS_RAW_KEY);
 886         if (ret) {
 887                 sec->cmd_state = CMD_STATE_FAIL;
 888                 tsp_warn("%s(), tsp node parse fail - flag: %d\n", __func__, flag);
 889                 return;
 890         }
 891
 892         snprintf(buf, sizeof(buf), "%d,%d", key_node_value[0], key_node_value[1]);
 893         tsp_info("%s(), %s\n", __func__, buf);
 894
 895         sec->cmd_state = CMD_STATE_OK;
 896         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 897         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf,
 898                         strnlen(buf, sizeof(buf)));
 899 }
 900
 901 void get_raw_value(void *dev_data)
 902 {
 903         int idx = 0;
 904         char buf[16] = { 0 };
 905
 906         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 907         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 908         TSP_INFO *tsp = &data->tsp_info;
 909
 910         set_default_result(sec);
 911
 912         idx = check_tsp_channel(data, tsp->screen.rx, tsp->screen.tx);
 913         if (idx < 0) { // Parameter parsing fail
 914                 snprintf(buf, sizeof(buf), "%s", "NG");
 915                 sec->cmd_state = CMD_STATE_FAIL;
 916         } else {
 917                 snprintf(buf, sizeof(buf), "%d", node_value[idx]);
 918                 sec->cmd_state = CMD_STATE_OK;
 919         }
 920
 921         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 922         tsp_info("%s(), [%d][%d]: %s\n", __func__,
 923                         sec->cmd_param[0], sec->cmd_param[1], buf);
 924         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf,
 925                         strnlen(buf, sizeof(buf)));
 926 }
 927
 928 void get_raw_all_data(void *dev_data) {
 929         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 930         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 931         TSP_INFO *tsp = &data->tsp_info;
 932         int i;
 933         int ret;
 934         u8 flag = NODE_FLAG_RAW;
 935         char *raw_buffer;
 936         char temp[10];
 937
 938         set_default_result(sec);
 939
 940         raw_buffer = kzalloc(sec->cmd_result_length, GFP_KERNEL);
 941         if (!raw_buffer) {
 942                 tsp_err("%s: failed to allication memory\n", __func__);
 943                 goto out_raw_all_data;
 944         }
 945
 946         ret = ist30xx_read_touch_node(data, flag, &tsp->node);
 947         if (ret) {
 948                 sec->cmd_state = CMD_STATE_FAIL;
 949                 tsp_warn("%s(), tsp node read fail!\n", __func__);
 950                 goto err_read_data;
 951         }
 952         ist30xx_parse_touch_node(data, flag, &tsp->node);
 953
 954         ret = parse_tsp_node(data, flag, &tsp->node, node_value, TS_RAW_SCREEN);
 955         if (ret) {
 956                 sec->cmd_state = CMD_STATE_FAIL;
 957                 tsp_warn("%s(), tsp node parse fail - flag: %d\n", __func__, flag);
 958                 goto err_read_data;
 959         }
 960
 961         for (i = 0; i < tsp->screen.rx * tsp->screen.tx; i++) {
 962                 snprintf(temp, 10, "%d,", node_value[i]);
 963                 strncat(raw_buffer, temp, 10);
 964         }
 965
 966         set_cmd_result(sec, raw_buffer, sec->cmd_result_length);
 967
 968         sec->cmd_state = CMD_STATE_OK;
 969
 970         kfree(raw_buffer);
 971         return;
 972
 973 err_read_data:
 974         kfree(raw_buffer);
 975 out_raw_all_data:
 976         sec->cmd_state = CMD_STATE_FAIL;
 977 }
 978
 979 #if IST30XX_CMCS_TEST
 980 extern u8 *ts_cmcs_bin;
 981 extern u32 ts_cmcs_bin_size;
 982 extern CMCS_BIN_INFO *ts_cmcs;
 983 extern CMCS_BUF *ts_cmcs_buf;
 984 int get_read_all_data(struct ist30xx_data *data, u8 flag)
 985 {
 986         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 987         TSP_INFO *tsp = &data->tsp_info;
 988
 989         int ii;
 990         int count = 0;
 991         int type;
 992         char *buffer;
 993         char *temp;
 994         int ret;
 995
 996         if ((ts_cmcs_bin == NULL) || (ts_cmcs_bin_size == 0)) {
 997                 tsp_err("%s: cmcs binary is NULL!\n", __func__);
 998                 goto cm_err_out;
 999         }
1000
1001         ret = ist30xx_get_cmcs_info(ts_cmcs_bin, ts_cmcs_bin_size);
1002         if (unlikely(ret)) {
1003                 tsp_err("%s: tsp get cmcs infomation fail!\n", __func__);
1004                 goto cm_err_out;
1005         }
1006
1007         mutex_lock(&ist30xx_mutex);
1008         ret = ist30xx_cmcs_test(data, ts_cmcs_bin, ts_cmcs_bin_size);
1009         if (unlikely(ret)) {
1010                 mutex_unlock(&ist30xx_mutex);
1011                 tsp_err("%s: tsp cmcs test fail!\n", __func__);
1012                 goto cm_err_out;
1013         }
1014         mutex_unlock(&ist30xx_mutex);
1015
1016         buffer = kzalloc(sec->cmd_result_length, GFP_KERNEL);
1017         if (!buffer) {
1018                 tsp_err("%s: failed to buffer alloc\n", __func__);
1019                 goto cm_err_out;
1020         }
1021
1022         temp = kzalloc(10, GFP_KERNEL);
1023         if (!temp) {
1024                 tsp_err("%s: failed to temp alloc\n", __func__);
1025                 goto cm_err_alloc_out;
1026         }
1027
1028         for (ii = 0; ii < tsp->ch_num.rx * tsp->ch_num.tx; ii++) {
1029
1030                 type = check_tsp_type(data, ii / tsp->ch_num.rx, ii % tsp->ch_num.rx);
1031                 if ((type == TSP_CH_UNKNOWN) || (type == TSP_CH_UNUSED)) {
1032                         count += snprintf(temp, 10, "%d,", 0);
1033                 } else {
1034                         switch (flag) {
1035                         case TEST_CM_ALL_DATA:
1036                                 count += snprintf(temp, 10, "%d,", ts_cmcs_buf->cm[ii]);
1037                                 break;
1038                         case TEST_SLOPE0_ALL_DATA:
1039                                 count += snprintf(temp, 10, "%d,", ts_cmcs_buf->slope0[ii]);
1040                                 break;
1041                         case TEST_SLOPE1_ALL_DATA:
1042                                 count += snprintf(temp, 10, "%d,", ts_cmcs_buf->slope1[ii]);
1043                                 break;
1044                         case TEST_CS_ALL_DATA:
1045                                 count += snprintf(temp, 10, "%d,", ts_cmcs_buf->cs[ii]);
1046                                 break;
1047                         }
1048                 }
1049                 strncat(buffer, temp, 10);
1050         }
1051
1052         set_cmd_result(sec, buffer, count - 1);
1053         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buffer, count);
1054         kfree(buffer);
1055         kfree(temp);
1056         return 0;
1057
1058 cm_err_alloc_out:
1059         kfree(buffer);
1060 cm_err_out:
1061         sec->cmd_state = CMD_STATE_FAIL;
1062         set_cmd_result(sec, "NULL", sec->cmd_result_length);
1063         return -1;
1064
1065 }
1066
1067 void get_cm_all_data(void *dev_data) {
1068         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
1069         struct sec_factory *sec = (struct sec_factory *)&data->sec;
1070         int ret;
1071
1072         set_default_result(sec);
1073
1074         ret = get_read_all_data(data, TEST_CM_ALL_DATA);
1075         if (ret < 0)
1076                 sec->cmd_state = CMD_STATE_FAIL;
1077         else
1078                 sec->cmd_state = CMD_STATE_OK;
1079
1080 }
1081
1082 void get_slope0_all_data(void *dev_data) {
1083         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
1084         struct sec_factory *sec = (struct sec_factory *)&data->sec;
1085         int ret;
1086
1087         set_default_result(sec);
1088
1089         ret = get_read_all_data(data, TEST_SLOPE0_ALL_DATA);
1090         if (ret < 0)
1091                 sec->cmd_state = CMD_STATE_FAIL;
1092         else
1093                 sec->cmd_state = CMD_STATE_OK;
1094 }
1095
1096 void get_slope1_all_data(void *dev_data) {
1097         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
1098         struct sec_factory *sec = (struct sec_factory *)&data->sec;
1099         int ret;
1100
1101         set_default_result(sec);
1102
1103         ret = get_read_all_data(data, TEST_SLOPE1_ALL_DATA);
1104         if (ret < 0)
1105                 sec->cmd_state = CMD_STATE_FAIL;
1106         else
1107                 sec->cmd_state = CMD_STATE_OK;
1108 }
1109
1110 void get_cs_all_data(void *dev_data) {
1111         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
1112         struct sec_factory *sec = (struct sec_factory *)&data->sec;
1113         int ret;
1114
1115         set_default_result(sec);
1116
1117         ret = get_read_all_data(data, TEST_CS_ALL_DATA);
1118         if (ret < 0)
1119                 sec->cmd_state = CMD_STATE_FAIL;
1120         else
1121                 sec->cmd_state = CMD_STATE_OK;
1122 }
1123
1124 void run_cm_test(void *dev_data)
1125 {
1126         int i, j;
1127         int ret = 0;
1128         char buf[16] = { 0 };
1129         int type, idx;
1130         int min_val, max_val;
1131
1132         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
1133         struct sec_factory *sec = (struct sec_factory *)&data->sec;
1134         TSP_INFO *tsp = &data->tsp_info;
1135
1136         set_default_result(sec);
1137
1138         if ((ts_cmcs_bin == NULL) || (ts_cmcs_bin_size == 0)) {
1139                 sec->cmd_state = CMD_STATE_FAIL;
1140                 tsp_warn("%s(), Binary is not correct!\n", __func__);
1141                 return;
1142         }
1143
1144         ret = ist30xx_get_cmcs_info(ts_cmcs_bin, ts_cmcs_bin_size);
1145         if (unlikely(ret)) {
1146                 sec->cmd_state = CMD_STATE_FAIL;
1147                 tsp_warn("%s(), tsp get cmcs infomation fail!\n", __func__);
1148                 return;
1149         }
1150
1151         mutex_lock(&ist30xx_mutex);
1152         ret = ist30xx_cmcs_test(data, ts_cmcs_bin, ts_cmcs_bin_size);
1153         if (unlikely(ret)) {
1154                 mutex_unlock(&ist30xx_mutex);
1155                 sec->cmd_state = CMD_STATE_FAIL;
1156                 tsp_warn("%s(), tsp cmcs test fail!\n", __func__);
1157                 return;
1158         }
1159         mutex_unlock(&ist30xx_mutex);
1160
1161         min_val = max_val = ts_cmcs_buf->cm[0];
1162         for (i = 0; i < tsp->ch_num.tx; i++) {
1163 #if TSP_CM_DEBUG
1164                 printk("%s", IST30XX_DEBUG_TAG);
1165 #endif
1166                 for (j = 0; j < tsp->ch_num.rx; j++) {
1167                         idx = (i * tsp->ch_num.rx) + j;
1168                         type = check_tsp_type(data, i, j);
1169
1170                         if ((type == TSP_CH_SCREEN) || (type == TSP_CH_GTX)) {
1171                                 max_val = max(max_val, (int)ts_cmcs_buf->cm[idx]);
1172                                 min_val = min(min_val, (int)ts_cmcs_buf->cm[idx]);
1173                         }
1174 #if TSP_CM_DEBUG
1175                         printk("%5d ", ts_cmcs_buf->cm[idx]);
1176 #endif
1177                 }
1178 #if TSP_CM_DEBUG
1179                 printk("\n");
1180 #endif
1181         }
1182
1183         snprintf(buf, sizeof(buf), "%d,%d", min_val, max_val);
1184         tsp_info("%s(), %s\n", __func__, buf);
1185
1186         sec->cmd_state = CMD_STATE_OK;
1187         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
1188         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf,
1189                         strnlen(buf, sizeof(buf)));
1190 }
1191
1192 void run_cm_test_key(void *dev_data)
1193 {
1194         int i, j;
1195         int ret = 0;
1196         char buf[16] = { 0 };
1197         int type, idx;
1198         int cm_key[IST30XX_MAX_KEYS] = { 0 };
1199         int key_count = 0;
1200
1201         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
1202         struct sec_factory *sec = (struct sec_factory *)&data->sec;
1203         TSP_INFO *tsp = &data->tsp_info;
1204
1205         set_default_result(sec);
1206
1207         if ((ts_cmcs_bin == NULL) || (ts_cmcs_bin_size == 0)) {
1208                 sec->cmd_state = CMD_STATE_FAIL;
1209                 tsp_warn("%s(), Binary is not correct!\n", __func__);
1210                 return;
1211         }
1212
1213         ret = ist30xx_get_cmcs_info(ts_cmcs_bin, ts_cmcs_bin_size);
1214         if (unlikely(ret)) {
1215                 sec->cmd_state = CMD_STATE_FAIL;
1216                 tsp_warn("%s(), tsp get cmcs infomation fail!\n", __func__);
1217                 return;
1218         }
1219
1220         mutex_lock(&ist30xx_mutex);
1221         ret = ist30xx_cmcs_test(data, ts_cmcs_bin, ts_cmcs_bin_size);
1222         if (unlikely(ret)) {
1223                 mutex_unlock(&ist30xx_mutex);
1224                 sec->cmd_state = CMD_STATE_FAIL;
1225                 tsp_warn("%s(), tsp cmcs test fail!\n", __func__);
1226                 return;
1227         }
1228         mutex_unlock(&ist30xx_mutex);
1229
1230         for (i = 0; i < tsp->ch_num.tx; i++) {
1231 #if TSP_CM_DEBUG
1232                 printk("%s", IST30XXC_DEBUG_TAG);
1233 #endif
1234                 for (j = 0; j < tsp->ch_num.rx; j++) {
1235                         idx = (i * tsp->ch_num.rx) + j;
1236                         type = check_tsp_type(data, i, j);
1237
1238                         if (type == TSP_CH_KEY) {
1239                                 cm_key[key_count++] = (int)ts_cmcs_buf->cm[idx];
1240                         }
1241 #if TSP_CM_DEBUG
1242                         printk("%5d ", tsp_cmcs_buf->cm[idx]);
1243 #endif
1244                 }
1245 #if TSP_CM_DEBUG
1246                 printk("\n");
1247 #endif
1248         }
1249
1250         snprintf(buf, sizeof(buf), "%d,%d", cm_key[0], cm_key[1]);
1251         tsp_info("%s(), %s\n", __func__, buf);
1252
1253         sec->cmd_state = CMD_STATE_OK;
1254         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
1255         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf,
1256                         strnlen(buf, sizeof(buf)));
1257 }
1258
1259 void get_cm_value(void *dev_data)
1260 {
1261         int idx = 0;
1262         char buf[16] = { 0 };
1263
1264         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
1265         struct sec_factory *sec = (struct sec_factory *)&data->sec;
1266         TSP_INFO *tsp = &data->tsp_info;
1267
1268         set_default_result(sec);
1269
1270         idx = check_tsp_channel(data, tsp->ch_num.rx, tsp->ch_num.tx);
1271         if (idx < 0) { // Parameter parsing fail
1272                 snprintf(buf, sizeof(buf), "%s", "NG");
1273                 sec->cmd_state = CMD_STATE_FAIL;
1274         } else {
1275                 snprintf(buf, sizeof(buf), "%d", ts_cmcs_buf->cm[idx]);
1276                 sec->cmd_state = CMD_STATE_OK;
1277         }
1278
1279         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
1280         tsp_info("%s(), [%d][%d]: %s\n", __func__,
1281                         sec->cmd_param[0], sec->cmd_param[1], buf);
1282         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf,
1283                         strnlen(buf, sizeof(buf)));
1284 }
1285
1286 void run_cmcs_test(void *dev_data)
1287 {
1288         int ret = 0;
1289         char buf[16] = { 0 };
1290
1291         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
1292         struct sec_factory *sec = (struct sec_factory *)&data->sec;
1293
1294         set_default_result(sec);
1295
1296         if ((ts_cmcs_bin == NULL) || (ts_cmcs_bin_size == 0)) {
1297                 sec->cmd_state = CMD_STATE_FAIL;
1298                 tsp_warn("%s(), Binary is not correct!\n", __func__);
1299                 return;
1300         }
1301
1302         ret = ist30xx_get_cmcs_info(ts_cmcs_bin, ts_cmcs_bin_size);
1303         if (unlikely(ret)) {
1304                 sec->cmd_state = CMD_STATE_FAIL;
1305                 tsp_warn("%s(), tsp get cmcs infomation fail!\n", __func__);
1306                 return;
1307         }
1308
1309         mutex_lock(&ist30xx_mutex);
1310         ret = ist30xx_cmcs_test(data, ts_cmcs_bin, ts_cmcs_bin_size);
1311         if (unlikely(ret)) {
1312                 mutex_unlock(&ist30xx_mutex);
1313                 sec->cmd_state = CMD_STATE_FAIL;
1314                 tsp_warn("%s(), tsp cmcs test fail!\n", __func__);
1315                 return;
1316         }
1317         mutex_unlock(&ist30xx_mutex);
1318
1319         snprintf(buf, sizeof(buf), "%s", "OK");
1320         tsp_info("%s(), %s\n", __func__, buf);
1321
1322         sec->cmd_state = CMD_STATE_OK;
1323         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
1324         dev_info(&data->client->dev, "%s: %s(%d)\n",
1325                         __func__, buf,  strnlen(buf, sizeof(buf)));
1326 }
1327
1328 void get_cm_array(void *dev_data)
1329 {
1330         int i;
1331         int count = 0;
1332         int type;
1333         char *buf;
1334         const int msg_len = 16;
1335         char msg[msg_len];
1336
1337         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
1338         struct sec_factory *sec = (struct sec_factory *)&data->sec;
1339         TSP_INFO *tsp = &data->tsp_info;
1340
1341         set_default_result(sec);
1342
1343         buf = kmalloc(IST30XX_NODE_TOTAL_NUM * 5, GFP_KERNEL);
1344         if (!buf) {
1345                 tsp_info("%s: Couldn't Allocate memory\n", __func__);
1346                 return;
1347         }
1348         memset(buf, 0, IST30XX_NODE_TOTAL_NUM * 5);
1349
1350         for (i = 0; i < tsp->ch_num.rx * tsp->ch_num.tx; i++) {
1351 #if TSP_CM_DEBUG
1352                 if ((i % tsp->ch_num.rx) == 0)
1353                         printk("\n%s %4d: ", IST30XX_DEBUG_TAG, i);
1354
1355                 printk("%4d ", ts_cmcs_buf->cm[i]);
1356 #endif
1357                 type = check_tsp_type(data, i / tsp->ch_num.rx, i % tsp->ch_num.rx);
1358                 if ((type == TSP_CH_UNKNOWN) || (type == TSP_CH_UNUSED))
1359                         count += snprintf(msg, msg_len, "%d,", 0);
1360                 else
1361                         count += snprintf(msg, msg_len, "%d,", ts_cmcs_buf->cm[i]);
1362                 strncat(buf, msg, msg_len);
1363         }
1364
1365         printk("\n");
1366         tsp_info("%s: %d\n", __func__, count - 1);
1367         sec->cmd_state = CMD_STATE_OK;
1368         set_cmd_result(sec, buf, count - 1);
1369         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf, count);
1370         kfree(buf);
1371 }
1372
1373 void get_slope0_array(void *dev_data)
1374 {
1375         int i;
1376         int count = 0;
1377         char *buf;
1378         const int msg_len = 16;
1379         char msg[msg_len];
1380
1381         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
1382         struct sec_factory *sec = (struct sec_factory *)&data->sec;
1383         TSP_INFO *tsp = &data->tsp_info;
1384
1385         set_default_result(sec);
1386
1387         buf = kmalloc(IST30XX_NODE_TOTAL_NUM * 5, GFP_KERNEL);
1388         if (!buf) {
1389                 tsp_info("%s: Couldn't Allocate memory\n", __func__);
1390                 return;
1391         }
1392         memset(buf, 0, IST30XX_NODE_TOTAL_NUM * 5);
1393
1394         for (i = 0; i < tsp->ch_num.rx * tsp->ch_num.tx; i++) {
1395 #if TSP_CM_DEBUG
1396                 if ((i % tsp->ch_num.rx) == 0)
1397                         printk("\n%s %4d: ", IST30XX_DEBUG_TAG, i);
1398
1399                 printk("%4d ", ts_cmcs_buf->slope0[i]);
1400 #endif
1401                 count += snprintf(msg, msg_len, "%d,", ts_cmcs_buf->slope0[i]);
1402                 strncat(buf, msg, msg_len);
1403         }
1404
1405         printk("\n");
1406         tsp_info("%s: %d\n", __func__, count - 1);
1407         sec->cmd_state = CMD_STATE_OK;
1408         set_cmd_result(sec, buf, count - 1);
1409         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf, count);
1410         kfree(buf);
1411 }
1412
1413 void get_slope1_array(void *dev_data)
1414 {
1415         int i;
1416         int count = 0;
1417         char *buf;
1418         const int msg_len = 16;
1419         char msg[msg_len];
1420
1421         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
1422         struct sec_factory *sec = (struct sec_factory *)&data->sec;
1423         TSP_INFO *tsp = &data->tsp_info;
1424
1425         set_default_result(sec);
1426
1427         buf = kmalloc(IST30XX_NODE_TOTAL_NUM * 5, GFP_KERNEL);
1428         if (!buf) {
1429                 tsp_info("%s: Couldn't Allocate memory\n", __func__);
1430                 return;
1431         }
1432         memset(buf, 0, IST30XX_NODE_TOTAL_NUM * 5);
1433
1434         for (i = 0; i < tsp->ch_num.rx * tsp->ch_num.tx; i++) {
1435 #if TSP_CM_DEBUG
1436                 if ((i % tsp->ch_num.rx) == 0)
1437                         printk("\n%s %4d: ", IST30XX_DEBUG_TAG, i);
1438
1439                 printk("%4d ", ts_cmcs_buf->slope1[i]);
1440 #endif
1441                 count += snprintf(msg, msg_len, "%d,", ts_cmcs_buf->slope1[i]);
1442                 strncat(buf, msg, msg_len);
1443         }
1444
1445         printk("\n");
1446         tsp_info("%s: %d\n", __func__, count - 1);
1447         sec->cmd_state = CMD_STATE_OK;
1448         set_cmd_result(sec, buf, count - 1);
1449         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf, count);
1450         kfree(buf);
1451 }
1452
1453 void get_cs_array(void *dev_data)
1454 {
1455         int i;
1456         int count = 0;
1457         int type;
1458         char *buf;
1459         const int msg_len = 16;
1460         char msg[msg_len];
1461
1462         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
1463         struct sec_factory *sec = (struct sec_factory *)&data->sec;
1464         TSP_INFO *tsp = &data->tsp_info;
1465
1466         set_default_result(sec);
1467
1468         buf = kmalloc(IST30XX_NODE_TOTAL_NUM * 5, GFP_KERNEL);
1469         if (!buf) {
1470                 tsp_info("%s: Couldn't Allocate memory\n", __func__);
1471                 return;
1472         }
1473         memset(buf, 0, IST30XX_NODE_TOTAL_NUM * 5);
1474
1475         for (i = 0; i < tsp->ch_num.rx * tsp->ch_num.tx; i++) {
1476 #if TSP_CM_DEBUG
1477                 if ((i % tsp->ch_num.rx) == 0)
1478                         printk("\n%s %4d: ", IST30XX_DEBUG_TAG, i);
1479
1480                 printk("%4d ", ts_cmcs_buf->cs[i]);
1481 #endif
1482                 type = check_tsp_type(data, i / tsp->ch_num.rx, i % tsp->ch_num.rx);
1483                 if ((type == TSP_CH_UNKNOWN) || (type == TSP_CH_UNUSED))
1484                         count += snprintf(msg, msg_len, "%d,", 0);
1485                 else
1486                         count += snprintf(msg, msg_len, "%d,", ts_cmcs_buf->cs[i]);
1487                 strncat(buf, msg, msg_len);
1488         }
1489
1490         printk("\n");
1491         tsp_info("%s: %d\n", __func__, count - 1);
1492         sec->cmd_state = CMD_STATE_OK;
1493         set_cmd_result(sec, buf, count - 1);
1494         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf, count);
1495         kfree(buf);
1496 }
1497 #endif
1498
1499
1500 /* sysfs: /sys/class/sec/tsp/close_tsp_test */
1501 static ssize_t show_close_tsp_test(struct device *dev,
1502                 struct device_attribute *attr, char *buf)
1503 {
1504         return snprintf(buf, FACTORY_BUF_SIZE, "%u\n", 0);
1505 }
1506
1507 /* sysfs: /sys/class/sec/tsp/cmd */
1508 static ssize_t store_cmd(struct device *dev, struct device_attribute
1509                 *devattr, const char *buf, size_t count)
1510 {
1511         struct ist30xx_data *data = dev_get_drvdata(dev);
1512         struct sec_factory *sec = (struct sec_factory *)&data->sec;
1513         struct i2c_client *client = data->client;
1514
1515         char *cur, *start, *end;
1516         char msg[SEC_CMD_STR_LEN] = { 0 };
1517         int len, i;
1518         struct tsp_cmd *tsp_cmd_ptr = NULL;
1519         char delim = ',';
1520         bool cmd_found = false;
1521         int param_cnt = 0;
1522         int ret;
1523
1524         if (sec->cmd_is_running == true) {
1525                 dev_err(&client->dev, "tsp_cmd: other cmd is running.\n");
1526                 tsp_err("tsp_cmd: other cmd is running.\n");
1527                 goto err_out;
1528         }
1529
1530         /* check lock  */
1531         mutex_lock(&sec->cmd_lock);
1532         sec->cmd_is_running = true;
1533         mutex_unlock(&sec->cmd_lock);
1534
1535         sec->cmd_state = CMD_STATE_RUNNING;
1536
1537         for (i = 0; i < ARRAY_SIZE(sec->cmd_param); i++)
1538                 sec->cmd_param[i] = 0;
1539
1540         len = (int)count;
1541         if (*(buf + len - 1) == '\n')
1542                 len--;
1543         memset(sec->cmd, 0, ARRAY_SIZE(sec->cmd));
1544         memcpy(sec->cmd, buf, len);
1545
1546         cur = strchr(buf, (int)delim);
1547         if (cur)
1548                 memcpy(msg, buf, cur - buf);
1549         else
1550                 memcpy(msg, buf, len);
1551         /* find command */
1552         list_for_each_entry(tsp_cmd_ptr, &sec->cmd_list_head, list) {
1553                 if (!strcmp(msg, tsp_cmd_ptr->cmd_name)) {
1554                         cmd_found = true;
1555                         break;
1556                 }
1557         }
1558
1559         /* set not_support_cmd */
1560         if (!cmd_found) {
1561                 list_for_each_entry(tsp_cmd_ptr, &sec->cmd_list_head, list) {
1562                         if (!strcmp("not_support_cmd", tsp_cmd_ptr->cmd_name))
1563                                 break;
1564                 }
1565         }
1566
1567         /* parsing parameters */
1568         if (cur && cmd_found) {
1569                 cur++;
1570                 start = cur;
1571                 memset(msg, 0, ARRAY_SIZE(msg));
1572                 do {
1573                         if (*cur == delim || cur - buf == len) {
1574                                 end = cur;
1575                                 memcpy(msg, start, end - start);
1576                                 *(msg + strlen(msg)) = '\0';
1577                                 ret = kstrtoint(msg, 10, \
1578                                                 sec->cmd_param + param_cnt);
1579                                 start = cur + 1;
1580                                 memset(msg, 0, ARRAY_SIZE(msg));
1581                                 param_cnt++;
1582                         }
1583                         cur++;
1584                 } while (cur - buf <= len);
1585         }
1586         tsp_info("SEC CMD = %s\n", tsp_cmd_ptr->cmd_name);
1587
1588         for (i = 0; i < param_cnt; i++)
1589                 tsp_info("SEC CMD Param %d= %d\n", i, sec->cmd_param[i]);
1590
1591         tsp_cmd_ptr->cmd_func(data);
1592
1593 err_out:
1594         return count;
1595 }
1596
1597 /* sysfs: /sys/class/sec/tsp/cmd_status */
1598 static ssize_t show_cmd_status(struct device *dev,
1599                 struct device_attribute *devattr, char *buf)
1600 {
1601         struct ist30xx_data *data = dev_get_drvdata(dev);
1602         struct sec_factory *sec = (struct sec_factory *)&data->sec;
1603         char msg[16] = { 0 };
1604
1605         dev_info(&data->client->dev, "tsp cmd: status:%d\n", sec->cmd_state);
1606
1607         if (sec->cmd_state == CMD_STATE_WAITING)
1608                 snprintf(msg, sizeof(msg), "WAITING");
1609         else if (sec->cmd_state == CMD_STATE_RUNNING)
1610                 snprintf(msg, sizeof(msg), "RUNNING");
1611         else if (sec->cmd_state == CMD_STATE_OK)
1612                 snprintf(msg, sizeof(msg), "OK");
1613         else if (sec->cmd_state == CMD_STATE_FAIL)
1614                 snprintf(msg, sizeof(msg), "FAIL");
1615         else if (sec->cmd_state == CMD_STATE_NA)
1616                 snprintf(msg, sizeof(msg), "NOT_APPLICABLE");
1617
1618         return snprintf(buf, FACTORY_BUF_SIZE, "%s\n", msg);
1619 }
1620
1621 /* sysfs: /sys/class/sec/tsp/cmd_result */
1622 static ssize_t show_cmd_result(struct device *dev, struct device_attribute
1623                 *devattr, char *buf)
1624 {
1625         struct ist30xx_data *data = dev_get_drvdata(dev);
1626         struct sec_factory *sec = (struct sec_factory *)&data->sec;
1627
1628         dev_info(&data->client->dev, "tsp cmd: result: %s\n", sec->cmd_result);
1629
1630         mutex_lock(&sec->cmd_lock);
1631         sec->cmd_is_running = false;
1632         mutex_unlock(&sec->cmd_lock);
1633
1634         sec->cmd_state = CMD_STATE_WAITING;
1635
1636         return snprintf(buf, FACTORY_BUF_SIZE, "%s\n", sec->cmd_result);
1637 }
1638
1639 #if IST30XX_USE_KEY
1640 static ssize_t recent_sensitivity_show(struct device *dev,
1641                 struct device_attribute *attr, char *buf)
1642 {
1643         int sensitivity = 0;
1644         struct ist30xx_data *data = dev_get_drvdata(dev);
1645
1646         sensitivity = ist30xx_get_key_sensitivity(data, 0);
1647
1648         tsp_info("%s(), %d\n", __func__, sensitivity);
1649
1650         return sprintf(buf, "%d", sensitivity);
1651 }
1652
1653 static ssize_t back_sensitivity_show(struct device *dev,
1654                 struct device_attribute *attr, char *buf)
1655 {
1656         int sensitivity = 0;
1657         struct ist30xx_data *data = dev_get_drvdata(dev);
1658
1659         sensitivity = ist30xx_get_key_sensitivity(data, 1);
1660
1661         tsp_info("%s(), %d\n", __func__, sensitivity);
1662
1663         return sprintf(buf, "%d", sensitivity);
1664 }
1665
1666 static ssize_t touchkey_threshold_show(struct device *dev,
1667                 struct device_attribute *attr, char *buf)
1668 {
1669         int ret = 0;
1670         u32 val = 0;
1671         int threshold = 0;
1672         struct ist30xx_data *data = dev_get_drvdata(dev);
1673
1674         ret = ist30xx_read_cmd(data, eHCOM_GET_TOUCH_TH, &val);
1675         if (unlikely(ret)) {
1676                 ist30xx_reset(data, false);
1677                 ist30xx_start(data);
1678                 val = 0;
1679         }
1680
1681         threshold = (int)((val >> 16) & 0xFFFF);
1682
1683         tsp_info("%s(), %d (ret=%d)\n", __func__, threshold, ret);
1684
1685         return sprintf(buf, "%d", threshold);
1686 }
1687 #endif
1688
1689 struct tsp_cmd tsp_cmds[] = {
1690         { TSP_CMD("get_chip_vendor", get_chip_vendor), },
1691         { TSP_CMD("get_chip_name",   get_chip_name),   },
1692         { TSP_CMD("get_chip_id",     get_chip_id),     },
1693         { TSP_CMD("fw_update",       fw_update),       },
1694         { TSP_CMD("get_fw_ver_bin",  get_fw_ver_bin),  },
1695         { TSP_CMD("get_fw_ver_ic",   get_fw_ver_ic),   },
1696         { TSP_CMD("get_threshold",   get_threshold),   },
1697         { TSP_CMD("get_x_num",       get_scr_x_num),   },
1698         { TSP_CMD("get_y_num",       get_scr_y_num),   },
1699         { TSP_CMD("get_all_x_num",       get_all_x_num),},
1700         { TSP_CMD("get_all_y_num",       get_all_y_num),},
1701         { TSP_CMD("clear_cover_mode", not_support_cmd),},
1702 #ifdef CONFIG_INPUT_BOOSTER
1703         { TSP_CMD("boost_level", boost_level),},
1704 #endif
1705         { TSP_CMD("run_reference_read", run_raw_read),  },
1706         { TSP_CMD("run_reference_read_key", run_raw_read_key),},
1707         { TSP_CMD("get_reference",   get_raw_value),   },
1708         { TSP_CMD("run_raw_read",    run_raw_read),    },
1709         { TSP_CMD("run_raw_read_key", run_raw_read_key),},
1710         { TSP_CMD("get_raw_value",   get_raw_value),   },
1711         { TSP_CMD("get_raw_all_data", get_raw_all_data),},
1712         { TSP_CMD("dead_zone_enable", set_edge_mode),},
1713         { TSP_CMD("get_checksum_data", get_checksum_data),},
1714         { TSP_CMD("tsp_connect_test", run_connect_test),   },
1715 #if IST30XX_CMCS_TEST
1716         { TSP_CMD("get_cm_all_data", get_cm_all_data),},
1717         { TSP_CMD("get_slope0_all_data", get_slope0_all_data),},
1718         { TSP_CMD("get_slope1_all_data", get_slope1_all_data),},
1719         { TSP_CMD("get_cs_all_data", get_cs_all_data),},
1720         { TSP_CMD("run_cm_test",     run_cm_test),     },
1721         { TSP_CMD("get_cm_value",    get_cm_value),    },
1722         { TSP_CMD("run_cm_test_key", run_cm_test_key),},
1723         { TSP_CMD("get_raw_array",   get_raw_array),   },
1724         { TSP_CMD("run_cmcs_test",   run_cmcs_test),   },
1725         { TSP_CMD("get_cm_array",    get_cm_array),    },
1726         { TSP_CMD("get_slope0_array", get_slope0_array),},
1727         { TSP_CMD("get_slope1_array", get_slope1_array),},
1728         { TSP_CMD("get_cs_array",    get_cs_array),    },
1729         { TSP_CMD("get_cs0_array",   get_cs_array),    },
1730         { TSP_CMD("get_cs1_array",   get_cs_array),    },
1731 #endif
1732         { TSP_CMD("get_config_ver", get_config_ver),   },
1733         { TSP_CMD("not_support_cmd", not_support_cmd), },
1734 };
1735
1736 /* sysfs: /sys/class/sec/tsp/cmd_list */
1737 static ssize_t show_cmd_list(struct device *dev, struct device_attribute
1738                 *devattr, char *buf)
1739 {
1740         char *buffer;
1741         char *temp;
1742         unsigned int ii = 0;
1743         int ret;
1744
1745         buffer = kzalloc(FACTORY_BUF_SIZE, GFP_KERNEL);
1746         if (!buffer)
1747                 goto err_alloc;
1748
1749         temp = kzalloc(COMMAND_LENGTH, GFP_KERNEL);
1750         if (!temp)
1751                 goto err_alloc_tmp;
1752
1753         snprintf(buffer, COMMAND_LENGTH, "++factory command list++\n");
1754
1755         if (!tsp_cmds[ii].cmd_name)
1756                 goto err_cmd;
1757
1758         while(strncmp(tsp_cmds[ii].cmd_name, "not_support_cmd", 16) != 0) {
1759                 snprintf(temp, COMMAND_LENGTH, "%s\n", tsp_cmds[ii].cmd_name);
1760                 strncat(buffer, temp, COMMAND_LENGTH);
1761                 ii++;
1762         }
1763
1764         ret = snprintf(buf, PAGE_SIZE, "%s\n", buffer);
1765
1766         tsp_info("%s(%d)\n", buffer, ii);
1767
1768         kfree(buffer);
1769         kfree(temp);
1770
1771         return ret;
1772 err_cmd:
1773         kfree(temp);
1774 err_alloc_tmp:
1775         kfree(buffer);
1776 err_alloc:
1777         return snprintf(buf, PAGE_SIZE, "NULL\n");
1778 }
1779 #if defined(CONFIG_TOUCH_KEY_LED)
1780 static ssize_t touch_led_control(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
1781 {
1782         struct ist30xx_data *info = dev_get_drvdata(dev);
1783         struct i2c_client *client = info->client;
1784         int data;
1785         int ret;
1786
1787         ret = sscanf(buf, "%d", &data);
1788         if (ret != 1) {
1789                 dev_err(&client->dev, "%s: cmd read err\n", __func__);
1790                 return size;
1791         }
1792
1793         if (!(data == 0 || data == 1)) {
1794                 dev_err(&client->dev, "%s: wrong command(%d)\n",
1795                                 __func__, data);
1796                 return size;
1797         }
1798
1799
1800         tsp_info("[TKEY] %s : %d\n", __func__, data);
1801
1802         if (data == 1) {
1803                 if (info->dt_data->keyled_en_gpio >= 0)
1804                         gpio_direction_output(info->dt_data->keyled_en_gpio, 1);
1805         } else {
1806                 if (info->dt_data->keyled_en_gpio >= 0)
1807                         gpio_direction_output(info->dt_data->keyled_en_gpio, 0);
1808         }
1809
1810         return size;
1811 }
1812 #endif
1813
1814 /* sysfs - tsp */
1815 static DEVICE_ATTR(close_tsp_test, S_IRUGO, show_close_tsp_test, NULL);
1816 static DEVICE_ATTR(cmd, S_IWUSR | S_IWGRP, NULL, store_cmd);
1817 static DEVICE_ATTR(cmd_status, S_IRUGO, show_cmd_status, NULL);
1818 static DEVICE_ATTR(cmd_result, S_IRUGO, show_cmd_result, NULL);
1819 static DEVICE_ATTR(cmd_list, S_IRUGO, show_cmd_list, NULL);
1820
1821 static struct attribute *sec_touch_facotry_attributes[] = {
1822         &dev_attr_close_tsp_test.attr,
1823         &dev_attr_cmd.attr,
1824         &dev_attr_cmd_status.attr,
1825         &dev_attr_cmd_result.attr,
1826         &dev_attr_cmd_list.attr,
1827         NULL,
1828 };
1829
1830 static struct attribute_group sec_touch_factory_attr_group = {
1831         .attrs  = sec_touch_facotry_attributes,
1832 };
1833
1834 #if IST30XX_USE_KEY
1835 /* sysfs - touchkey */
1836 static DEVICE_ATTR(touchkey_menu, S_IRUGO,
1837                 recent_sensitivity_show, NULL);
1838 static DEVICE_ATTR(touchkey_recent, S_IRUGO,
1839                 recent_sensitivity_show, NULL);
1840 static DEVICE_ATTR(touchkey_back, S_IRUGO,
1841                 back_sensitivity_show, NULL);
1842 static DEVICE_ATTR(touchkey_threshold, S_IRUGO,
1843                 touchkey_threshold_show, NULL);
1844 #if defined(CONFIG_TOUCH_KEY_LED)
1845 static DEVICE_ATTR(brightness, 0664, NULL, touch_led_control);
1846 #endif
1847
1848 static struct attribute *sec_tkey_attributes[] = {
1849         &dev_attr_touchkey_menu.attr,
1850         &dev_attr_touchkey_recent.attr,
1851         &dev_attr_touchkey_back.attr,
1852         &dev_attr_touchkey_threshold.attr,
1853 #if defined(CONFIG_TOUCH_KEY_LED)
1854         &dev_attr_brightness.attr,
1855 #endif
1856         NULL,
1857 };
1858
1859 static struct attribute_group sec_tkey_attr_group = {
1860         .attrs  = sec_tkey_attributes,
1861 };
1862
1863 struct device *sec_touchkey;
1864 #endif
1865 struct device *sec_fac_dev;
1866
1867 int sec_touch_sysfs(struct ist30xx_data *data)
1868 {
1869         int ret;
1870 #if IST30XX_USE_KEY
1871         /* /sys/class/sec/sec_touchkey */
1872         if (!data->dt_data->tkey) {
1873                 sec_touchkey = device_create(sec_class, NULL, 1, data, "sec_touchkey");
1874                 if (IS_ERR(sec_touchkey)) {
1875                         tsp_err("Failed to create device (%s)!\n", "sec_touchkey");
1876                         goto err_sec_touchkey;
1877                 }
1878                 /* /sys/class/sec/sec_touchkey/... */
1879                 if (sysfs_create_group(&sec_touchkey->kobj, &sec_tkey_attr_group)) {
1880                         tsp_err("Failed to create sysfs group(%s)!\n", "sec_touchkey");
1881                         goto err_sec_touchkey_attr;
1882                 }
1883         }
1884 #endif
1885         /* /sys/class/sec/tsp */
1886         sec_fac_dev = device_create(sec_class, NULL, 2, data, "tsp");
1887         if (IS_ERR(sec_fac_dev)) {
1888                 tsp_err("Failed to create device (%s)!\n", "tsp");
1889                 goto err_sec_fac_dev;
1890         }
1891         ret = sysfs_create_link(&sec_fac_dev->kobj, &data->input_dev->dev.kobj, "input");
1892         if (ret < 0)
1893                 tsp_err("%s: Failed to create input symbolic link\n", __func__);
1894         /* /sys/class/sec/tsp/... */
1895         if (sysfs_create_group(&sec_fac_dev->kobj, &sec_touch_factory_attr_group)) {
1896                 tsp_err("Failed to create sysfs group(%s)!\n", "tsp");
1897                 goto err_sec_fac_dev_attr;
1898         }
1899
1900         return 0;
1901
1902 err_sec_fac_dev_attr:
1903         device_destroy(sec_class, 2);
1904 err_sec_fac_dev:
1905 #if IST30XX_USE_KEY
1906 err_sec_touchkey_attr:
1907         if (!data->dt_data->tkey) {
1908                 device_destroy(sec_class, 1);
1909         }
1910 err_sec_touchkey:
1911 #endif
1912         return -ENODEV;
1913 }
1914 EXPORT_SYMBOL(sec_touch_sysfs);
1915 int sec_fac_cmd_init(struct ist30xx_data *data)
1916 {
1917         int i;
1918         struct sec_factory *sec = (struct sec_factory *)&data->sec;
1919
1920         INIT_LIST_HEAD(&sec->cmd_list_head);
1921         for (i = 0; i < ARRAY_SIZE(tsp_cmds); i++)
1922                 list_add_tail(&tsp_cmds[i].list, &sec->cmd_list_head);
1923
1924         sec->cmd_result_length = IST30XX_NODE_TOTAL_NUM * (sizeof(u32) / sizeof(char) + 1);
1925         sec->cmd_result = kzalloc(sec->cmd_result_length, GFP_KERNEL);
1926         if (!sec->cmd_result) {
1927                 tsp_err("%s: cmd_result is not allocated memory\n", __func__);
1928                 return -ENOMEM;
1929         }
1930
1931         tsp_info("%s: cmd_result lenght is %d\n", __func__, sec->cmd_result_length);
1932
1933         mutex_init(&sec->cmd_lock);
1934         sec->cmd_is_running = false;
1935
1936         return 0;
1937 }
1938 EXPORT_SYMBOL(sec_fac_cmd_init);
1939
1940 void sec_touch_sysfs_remove(struct ist30xx_data *data)
1941 {
1942         sysfs_remove_link(&sec_fac_dev->kobj, "input");
1943         sysfs_remove_group(&sec_fac_dev->kobj, &sec_touch_factory_attr_group);
1944 #if IST30XX_USE_KEY
1945         if (!data->dt_data->tkey) {
1946                 sysfs_remove_group(&sec_touchkey->kobj, &sec_tkey_attr_group);
1947                 device_destroy(sec_class, 1);
1948         }
1949 #endif
1950         device_destroy(sec_class, 2);
1951 }
1952 EXPORT_SYMBOL(sec_touch_sysfs_remove);
1953
1954 void sec_fac_cmd_remove(struct ist30xx_data *data)
1955 {
1956         struct sec_factory *sec = (struct sec_factory *)&data->sec;
1957
1958         list_del(&sec->cmd_list_head);
1959         mutex_destroy(&sec->cmd_lock);
1960 }
1961 EXPORT_SYMBOL(sec_fac_cmd_remove);
1962 #endif