drivers/input/touchscreen/ist30xxc/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
  25 #include "ist30xxc.h"
  26 #include "ist30xxc_update.h"
  27 #if IST30XX_DEBUG
  28 #include "ist30xxc_misc.h"
  29 #endif
  30 #if IST30XX_CMCS_TEST
  31 #include "ist30xxc_cmcs.h"
  32 #endif
  33
  34 #if SEC_FACTORY_MODE
  35 static char IsfwUpdate[20] = { 0 };
  36
  37 #define FW_DOWNLOADING                  "Downloading"
  38 #define FW_DOWNLOAD_COMPLETE    "Complete"
  39 #define FW_DOWNLOAD_FAIL                "FAIL"
  40
  41 #define FACTORY_BUF_SIZE                (2048)
  42 #define BUILT_IN                        (0)
  43 #define UMS                             (1)
  44
  45 #define CMD_STATE_WAITING       (0)
  46 #define CMD_STATE_RUNNING       (1)
  47 #define CMD_STATE_OK            (2)
  48 #define CMD_STATE_FAIL          (3)
  49 #define CMD_STATE_NA            (4)
  50
  51 #define TSP_NODE_DEBUG          (0)
  52 #define TSP_CM_DEBUG            (0)
  53
  54 #define TSP_CH_UNUSED           (0)
  55 #define TSP_CH_SCREEN           (1)
  56 #define TSP_CH_GTX                      (2)
  57 #define TSP_CH_KEY                      (3)
  58 #define TSP_CH_UNKNOWN          (-1)
  59
  60 #define TSP_CMD(name, func) .cmd_name = name, .cmd_func = func
  61 struct tsp_cmd {
  62         struct list_head list;
  63         const char * cmd_name;
  64         void (*cmd_func)(void *dev_data);
  65 };
  66
  67 u32 ist30xx_get_fw_ver(struct ist30xx_data *data)
  68 {
  69         u32 ver = 0;
  70         int ret = 0;
  71
  72         ret = ist30xx_read_cmd(data, eHCOM_GET_VER_FW, &ver);
  73         if (unlikely(ret)) {
  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 #define KEY_SENSITIVITY_OFFSET  0x10
  86 u32 key_sensitivity = 0;
  87 int ist30xx_get_key_sensitivity(struct ist30xx_data *data, int id)
  88 {
  89         u32 addr = IST30XX_DA_ADDR(data->tags.algo_base) + KEY_SENSITIVITY_OFFSET;
  90         u32 val = 0;
  91         int ret = 0;
  92
  93         if (unlikely(id >= data->tkey_info.key_num))
  94                 return 0;
  95
  96         if (ist30xx_intr_wait(data, 30) < 0)
  97                 return 0;
  98
  99         ret = ist30xx_read_cmd(data, addr, &val);
 100         if (ret) {
 101                 ist30xx_reset(data, false);
 102                 ist30xx_start(data);
 103                 tsp_info("%s(), ret=%d\n", __func__, ret);
 104                 return 0;
 105         }
 106
 107         if ((val & 0xFFF) == 0xFFF)
 108                 return (key_sensitivity >> (16 * id)) & 0xFFFF;
 109
 110         key_sensitivity = val;
 111
 112         tsp_debug("Reg addr: %x, val: %8x\n", addr, val);
 113
 114         val >>= (16 * id);
 115
 116         return (int)(val & 0xFFFF);
 117 }
 118
 119
 120 /* Factory CMD function */
 121 static void set_default_result(struct sec_factory *sec)
 122 {
 123         char delim = ':';
 124
 125         memset(sec->cmd_result, 0, ARRAY_SIZE(sec->cmd_result));
 126         memcpy(sec->cmd_result, sec->cmd, strlen(sec->cmd));
 127         strncat(sec->cmd_result, &delim, CMD_STATE_RUNNING);
 128 }
 129
 130 static void set_cmd_result(struct sec_factory *sec, char *buf, int len)
 131 {
 132         strncat(sec->cmd_result, buf, len);
 133 }
 134
 135 static void not_support_cmd(void *dev_data)
 136 {
 137         char buf[16] = { 0 };
 138
 139         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 140         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 141
 142         set_default_result(sec);
 143         snprintf(buf, sizeof(buf), "%s", "NA");
 144         tsp_info("%s(), %s\n", __func__, buf);
 145
 146         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 147         sec->cmd_state = CMD_STATE_NA;
 148         dev_info(&data->client->dev, "%s: \"%s(%d)\"\n", __func__,
 149                  buf, strnlen(buf, sizeof(buf)));
 150         return;
 151 }
 152
 153 static void get_chip_vendor(void *dev_data)
 154 {
 155         char buf[16] = { 0 };
 156
 157         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 158         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 159
 160         set_default_result(sec);
 161         snprintf(buf, sizeof(buf), "%s", TSP_CHIP_VENDOR);
 162         tsp_info("%s(), %s\n", __func__, buf);
 163
 164         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 165         sec->cmd_state = CMD_STATE_OK;
 166         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__,
 167                  buf, strnlen(buf, sizeof(buf)));
 168 }
 169
 170 static void get_chip_name(void *dev_data)
 171 {
 172         char buf[16] = { 0 };
 173
 174         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 175         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 176
 177         set_default_result(sec);
 178         snprintf(buf, sizeof(buf), "%s", TSP_CHIP_NAME);
 179         tsp_info("%s(), %s\n", __func__, buf);
 180
 181         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 182         sec->cmd_state = CMD_STATE_OK;
 183         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__,
 184                  buf, strnlen(buf, sizeof(buf)));
 185 }
 186
 187 static void get_chip_id(void *dev_data)
 188 {
 189         char buf[16] = { 0 };
 190
 191         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 192         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 193
 194         set_default_result(sec);
 195         snprintf(buf, sizeof(buf), "%#02x", data->chip_id);
 196         tsp_info("%s(), %s\n", __func__, buf);
 197
 198         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 199         sec->cmd_state = CMD_STATE_OK;
 200         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__,
 201                  buf, strnlen(buf, sizeof(buf)));
 202 }
 203 #include <linux/uaccess.h>
 204 #define MAX_FW_PATH 255
 205 static void fw_update(void *dev_data)
 206 {
 207         int ret;
 208         char buf[16] = { 0 };
 209         mm_segment_t old_fs = {0};
 210         struct file *fp = NULL;
 211         long fsize = 0, nread = 0;
 212         u8 *fw;
 213         char fw_path[MAX_FW_PATH+1];
 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
 220         tsp_info("%s(), %d\n", __func__, sec->cmd_param[0]);
 221
 222         switch (sec->cmd_param[0]) {
 223         case BUILT_IN:
 224                 sec->cmd_state = CMD_STATE_OK;
 225                 ret = ist30xx_fw_recovery(data);
 226                 if (ret < 0)
 227                         sec->cmd_state = CMD_STATE_FAIL;
 228                 break;
 229         case UMS:
 230                 sec->cmd_state = CMD_STATE_OK;
 231                 old_fs = get_fs();
 232                 set_fs(get_ds());
 233
 234                 snprintf(fw_path, MAX_FW_PATH, "/sdcard/%s", IST30XX_FW_NAME);
 235                 fp = filp_open(fw_path, O_RDONLY, 0);
 236                 if (IS_ERR(fp)) {
 237                         tsp_warn("%s(), file %s open error:%d\n", __func__,
 238                     fw_path, (s32)fp);
 239                         sec->cmd_state= CMD_STATE_FAIL;
 240                         set_fs(old_fs);
 241                         break;
 242                 }
 243
 244                 fsize = fp->f_path.dentry->d_inode->i_size;
 245                 if (fsize != data->fw.buf_size) {
 246                         tsp_warn("%s(), invalid fw size!!\n", __func__);
 247                         sec->cmd_state = CMD_STATE_FAIL;
 248                         set_fs(old_fs);
 249                         break;
 250                 }
 251                 fw = kzalloc((size_t)fsize, GFP_KERNEL);
 252                 if (!fw) {
 253                         tsp_warn("%s(), failed to alloc buffer for fw\n", __func__);
 254                         sec->cmd_state = CMD_STATE_FAIL;
 255                         filp_close(fp, NULL);
 256                         set_fs(old_fs);
 257                         break;
 258                 }
 259                 nread = vfs_read(fp, (char __user *)fw, fsize, &fp->f_pos);
 260                 if (nread != fsize) {
 261                         tsp_warn("%s(), failed to read fw\n", __func__);
 262                         sec->cmd_state = CMD_STATE_FAIL;
 263                         filp_close(fp, NULL);
 264                         set_fs(old_fs);
 265                         break;
 266                 }
 267
 268                 filp_close(fp, current->files);
 269                 set_fs(old_fs);
 270                 tsp_info("%s(), ums fw is loaded!!\n", __func__);
 271
 272                 ret = ist30xx_get_update_info(data, fw, fsize);
 273                 if (ret) {
 274                         sec->cmd_state = CMD_STATE_FAIL;
 275                         break;
 276                 }
 277                 data->fw.bin.main_ver = ist30xx_parse_ver(data, FLAG_MAIN, fw);
 278                 data->fw.bin.fw_ver = ist30xx_parse_ver(data, FLAG_FW, fw);
 279                 data->fw.bin.test_ver = ist30xx_parse_ver(data, FLAG_TEST, fw);
 280                 data->fw.bin.core_ver = ist30xx_parse_ver(data, FLAG_CORE, fw);
 281
 282                 mutex_lock(&ist30xx_mutex);
 283                 ret = ist30xx_fw_update(data, fw, fsize);
 284                 if (ret) {
 285                         sec->cmd_state = CMD_STATE_FAIL;
 286                         break;
 287                 }
 288
 289                 mutex_unlock(&ist30xx_mutex);
 290
 291                 ist30xx_calibrate(data, 1);
 292                 break;
 293
 294         default:
 295                 tsp_warn("%s(), Invalid fw file type!\n", __func__);
 296                 break;
 297         }
 298
 299         if (sec->cmd_state == CMD_STATE_OK)
 300                 snprintf(buf, sizeof(buf), "%s", "OK");
 301         else
 302                 snprintf(buf, sizeof(buf), "%s", "NG");
 303
 304         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 305 }
 306
 307
 308 static void get_fw_ver_bin(void *dev_data)
 309 {
 310         u32 ver = 0;
 311         char buf[16] = { 0 };
 312
 313         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 314         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 315
 316         set_default_result(sec);
 317
 318         ver = ist30xx_parse_ver(data, FLAG_FW, data->fw.buf);
 319         snprintf(buf, sizeof(buf), "IM00%04x", ver);
 320         tsp_info("%s(), %s\n", __func__, buf);
 321
 322         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 323         sec->cmd_state = CMD_STATE_OK;
 324         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__,
 325                  buf, strnlen(buf, sizeof(buf)));
 326 }
 327
 328 static void get_fw_ver_ic(void *dev_data)
 329 {
 330         u32 ver = 0;
 331         char msg[8];
 332         char buf[16] = { 0 };
 333
 334         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 335         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 336
 337         set_default_result(sec);
 338
 339         if (data->status.power == 1)
 340                 ver = ist30xx_get_fw_ver(data);
 341
 342         snprintf(buf, sizeof(buf), "IM00%04x", ver & 0xFFFF);
 343
 344         if (data->fw.cur.test_ver > 0) {
 345                 sprintf(msg, "(T%d)", data->fw.cur.test_ver);
 346                 strcat(buf, msg);
 347         }
 348
 349         tsp_info("%s(), %s\n", __func__, buf);
 350
 351         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 352         sec->cmd_state = CMD_STATE_OK;
 353         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__,
 354                  buf, strnlen(buf, sizeof(buf)));
 355 }
 356
 357 static void get_threshold(void *dev_data)
 358 {
 359         int ret = 0;
 360         u32 val = 0;
 361         char buf[16] = { 0 };
 362         int threshold;
 363
 364         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 365         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 366
 367         ret = ist30xx_read_cmd(data, eHCOM_GET_TOUCH_TH, &val);
 368         if (unlikely(ret)) {
 369                 ist30xx_reset(data, false);
 370                 ist30xx_start(data);
 371                 tsp_info("%s(), ret=%d\n", __func__, ret);
 372                 val = 0;
 373         }
 374
 375         set_default_result(sec);
 376
 377         threshold = (int)(val & 0xFFFF);
 378
 379         snprintf(buf, sizeof(buf), "%d", threshold);
 380         tsp_info("%s(), %s\n", __func__, buf);
 381
 382         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 383         sec->cmd_state = CMD_STATE_OK;
 384         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__,
 385                  buf, strnlen(buf, sizeof(buf)));
 386 }
 387
 388 static void get_scr_x_num(void *dev_data)
 389 {
 390         int val = -1;
 391         char buf[16] = { 0 };
 392
 393         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 394         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 395
 396         set_default_result(sec);
 397
 398         if (data->tsp_info.dir.swap_xy)
 399                 val = data->tsp_info.screen.tx;
 400         else
 401                 val = data->tsp_info.screen.rx;
 402
 403         if (val >= 0) {
 404                 snprintf(buf, sizeof(buf), "%u", val);
 405                 sec->cmd_state = CMD_STATE_OK;
 406                 dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf,
 407                          strnlen(buf, sizeof(buf)));
 408         } else {
 409                 snprintf(buf, sizeof(buf), "%s", "NG");
 410                 sec->cmd_state = CMD_STATE_FAIL;
 411                 dev_info(&data->client->dev,
 412                          "%s: fail to read num of x (%d).\n", __func__, val);
 413         }
 414         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 415         tsp_info("%s(), %s\n", __func__, buf);
 416 }
 417
 418 static void get_scr_y_num(void *dev_data)
 419 {
 420         int val = -1;
 421         char buf[16] = { 0 };
 422
 423         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 424         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 425
 426         set_default_result(sec);
 427
 428         if (data->tsp_info.dir.swap_xy)
 429                 val = data->tsp_info.screen.rx;
 430         else
 431                 val = data->tsp_info.screen.tx;
 432
 433         if (val >= 0) {
 434                 snprintf(buf, sizeof(buf), "%u", val);
 435                 sec->cmd_state = CMD_STATE_OK;
 436                 dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf,
 437                          strnlen(buf, sizeof(buf)));
 438         } else {
 439                 snprintf(buf, sizeof(buf), "%s", "NG");
 440                 sec->cmd_state = CMD_STATE_FAIL;
 441                 dev_info(&data->client->dev,
 442                          "%s: fail to read num of y (%d).\n", __func__, val);
 443         }
 444         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 445         tsp_info("%s(), %s\n", __func__, buf);
 446 }
 447
 448 static void get_all_x_num(void *dev_data)
 449 {
 450         int val = - 1;
 451         char buf[16] = { 0 };
 452
 453         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 454         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 455
 456         set_default_result(sec);
 457
 458         if (data->tsp_info.dir.swap_xy)
 459                 val = data->tsp_info.ch_num.tx;
 460         else
 461                 val = data->tsp_info.ch_num.rx;
 462
 463         if (val >= 0) {
 464                 snprintf(buf, sizeof(buf), "%u", val);
 465                 sec->cmd_state = CMD_STATE_OK;
 466                 dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf,
 467                          strnlen(buf, sizeof(buf)));
 468         } else {
 469                 snprintf(buf, sizeof(buf), "%s", "NG");
 470                 sec->cmd_state = CMD_STATE_FAIL;
 471                 dev_info(&data->client->dev,
 472                          "%s: fail to read all num of x (%d).\n", __func__, val);
 473         }
 474         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 475         tsp_info("%s(), %s\n", __func__, buf);
 476 }
 477
 478 static void get_all_y_num(void *dev_data)
 479 {
 480         int val = -1;
 481         char buf[16] = { 0 };
 482
 483         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 484         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 485
 486         set_default_result(sec);
 487
 488         if (data->tsp_info.dir.swap_xy)
 489                 val = data->tsp_info.ch_num.rx;
 490         else
 491                 val = data->tsp_info.ch_num.tx;
 492
 493         if (val >= 0) {
 494                 snprintf(buf, sizeof(buf), "%u", val);
 495                 sec->cmd_state = CMD_STATE_OK;
 496                 dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf,
 497                          strnlen(buf, sizeof(buf)));
 498         } else {
 499                 snprintf(buf, sizeof(buf), "%s", "NG");
 500                 sec->cmd_state = CMD_STATE_FAIL;
 501                 dev_info(&data->client->dev,
 502                          "%s: fail to read all num of y (%d).\n", __func__, val);
 503         }
 504         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 505         tsp_info("%s(), %s\n", __func__, buf);
 506 }
 507
 508 int check_tsp_channel(void *dev_data, int width, int height)
 509 {
 510         int node = -EPERM;
 511
 512         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 513         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 514
 515         if ((sec->cmd_param[0] < 0) || (sec->cmd_param[0] >= width) ||
 516             (sec->cmd_param[1] < 0) || (sec->cmd_param[1] >= height)) {
 517                 tsp_info("%s: parameter error: %u,%u\n",
 518                          __func__, sec->cmd_param[0], sec->cmd_param[1]);
 519         } else {
 520                 node = sec->cmd_param[0] + sec->cmd_param[1] * width;
 521                 tsp_info("%s: node = %d\n", __func__, node);
 522         }
 523
 524         return node;
 525 }
 526
 527 static u16 node_value[IST30XX_NODE_TOTAL_NUM];
 528 void get_raw_array(void *dev_data)
 529 {
 530         int i, ret;
 531         int count = 0;
 532         char *buf;
 533         const int msg_len = 16;
 534         char msg[msg_len];
 535         u8 flag = NODE_FLAG_RAW;
 536
 537         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 538         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 539         TSP_INFO *tsp = &data->tsp_info;
 540
 541         set_default_result(sec);
 542
 543         mutex_lock(&ist30xx_mutex);
 544         ret = ist30xx_read_touch_node(data, flag, &tsp->node);
 545         if (ret) {
 546                 mutex_unlock(&ist30xx_mutex);
 547                 sec->cmd_state = CMD_STATE_FAIL;
 548                 tsp_warn("%s(), tsp node read fail!\n", __func__);
 549                 return;
 550         }
 551         mutex_unlock(&ist30xx_mutex);
 552         ist30xx_parse_touch_node(data, flag, &tsp->node);
 553
 554         ret = parse_tsp_node(data, flag, &tsp->node, node_value, false);
 555         if (ret) {
 556                 sec->cmd_state = CMD_STATE_FAIL;
 557                 tsp_warn("%s(), tsp node parse fail - flag: %d\n", __func__, flag);
 558                 return;
 559         }
 560
 561         buf = kmalloc(IST30XX_NODE_TOTAL_NUM * 5, GFP_KERNEL);
 562         memset(buf, 0, sizeof(buf));
 563
 564         for (i = 0; i < tsp->ch_num.rx * tsp->ch_num.tx; i++) {
 565 #if TSP_NODE_DEBUG
 566                 if ((i % tsp->ch_num.rx) == 0)
 567                         printk("\n%s %4d: ", IST30XX_DEBUG_TAG, i);
 568
 569                 printk("%4d ", node_value[i]);
 570 #endif
 571                 count += snprintf(msg, msg_len, "%d,", node_value[i]);
 572                 strncat(buf, msg, msg_len);
 573         }
 574
 575         printk("\n");
 576         tsp_info("%s: %d\n", __func__, count - 1);
 577         sec->cmd_state = CMD_STATE_OK;
 578         set_cmd_result(sec, buf, count - 1);
 579         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf, count);
 580         kfree(buf);
 581 }
 582
 583 void run_raw_read(void *dev_data)
 584 {
 585         int i;
 586         int ret = 0;
 587         int min_val, max_val;
 588         char buf[16] = { 0 };
 589         u8 flag = NODE_FLAG_RAW;
 590
 591         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 592         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 593         TSP_INFO *tsp = &data->tsp_info;
 594
 595         set_default_result(sec);
 596
 597         ret = ist30xx_read_touch_node(data, flag, &tsp->node);
 598         if (ret) {
 599                 sec->cmd_state = CMD_STATE_FAIL;
 600                 tsp_warn("%s(), tsp node read fail!\n", __func__);
 601                 return;
 602         }
 603         ist30xx_parse_touch_node(data, flag, &tsp->node);
 604
 605         ret = parse_tsp_node(data, flag, &tsp->node, node_value, true);
 606         if (ret) {
 607                 sec->cmd_state = CMD_STATE_FAIL;
 608                 tsp_warn("%s(), tsp node parse fail - flag: %d\n", __func__, flag);
 609                 return;
 610         }
 611
 612         min_val = max_val = node_value[0];
 613         for (i = 0; i < tsp->screen.rx * tsp->screen.tx; i++) {
 614 #if TSP_NODE_DEBUG
 615                 if ((i % tsp->screen.rx) == 0)
 616                         printk("\n%s %4d: ", IST30XX_DEBUG_TAG, i);
 617
 618                 printk("%4d ", node_value[i]);
 619 #endif
 620
 621                 max_val = max(max_val, (int)node_value[i]);
 622                 min_val = min(min_val, (int)node_value[i]);
 623         }
 624
 625         snprintf(buf, sizeof(buf), "%d,%d", min_val, max_val);
 626         tsp_info("%s(), %s\n", __func__, buf);
 627
 628         sec->cmd_state = CMD_STATE_OK;
 629         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 630         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf,
 631                  strnlen(buf, sizeof(buf)));
 632 }
 633
 634 void get_raw_value(void *dev_data)
 635 {
 636         int idx = 0;
 637         char buf[16] = { 0 };
 638
 639         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 640         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 641         TSP_INFO *tsp = &data->tsp_info;
 642
 643         set_default_result(sec);
 644
 645         idx = check_tsp_channel(data, tsp->screen.rx, tsp->screen.tx);
 646         if (idx < 0) { // Parameter parsing fail
 647                 snprintf(buf, sizeof(buf), "%s", "NG");
 648                 sec->cmd_state = CMD_STATE_FAIL;
 649         } else {
 650                 snprintf(buf, sizeof(buf), "%d", node_value[idx]);
 651                 sec->cmd_state = CMD_STATE_OK;
 652         }
 653
 654         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 655         tsp_info("%s(), [%d][%d]: %s\n", __func__,
 656                  sec->cmd_param[0], sec->cmd_param[1], buf);
 657         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf,
 658                  strnlen(buf, sizeof(buf)));
 659 }
 660
 661 #if IST30XX_CMCS_TEST
 662 extern u8 *ts_cmcs_bin;
 663 extern u32 ts_cmcs_bin_size;
 664 extern CMCS_BIN_INFO *ts_cmcs;
 665 extern CMCS_BUF *ts_cmcs_buf;
 666 void run_cm_test(void *dev_data)
 667 {
 668         int i, j;
 669         int ret = 0;
 670         char buf[16] = { 0 };
 671         int type, idx;
 672         int min_val, max_val;
 673
 674         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 675         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 676         TSP_INFO *tsp = &data->tsp_info;
 677
 678         set_default_result(sec);
 679
 680         if ((ts_cmcs_bin == NULL) || (ts_cmcs_bin_size == 0)) {
 681                 sec->cmd_state = CMD_STATE_FAIL;
 682                 tsp_warn("%s(), Binary is not correct!\n", __func__);
 683                 return;
 684         }
 685
 686         ret = ist30xx_get_cmcs_info(ts_cmcs_bin, ts_cmcs_bin_size);
 687         if (unlikely(ret)) {
 688                 sec->cmd_state = CMD_STATE_FAIL;
 689                 tsp_warn("%s(), tsp get cmcs infomation fail!\n", __func__);
 690                 return;
 691         }
 692
 693         mutex_lock(&ist30xx_mutex);
 694         ret = ist30xx_cmcs_test(data, ts_cmcs_bin, ts_cmcs_bin_size);
 695         if (unlikely(ret)) {
 696                 mutex_unlock(&ist30xx_mutex);
 697                 sec->cmd_state = CMD_STATE_FAIL;
 698                 tsp_warn("%s(), tsp cmcs test fail!\n", __func__);
 699                 return;
 700         }
 701         mutex_unlock(&ist30xx_mutex);
 702
 703         min_val = max_val = ts_cmcs_buf->cm[0];
 704         for (i = 0; i < tsp->ch_num.tx; i++) {
 705 #if TSP_CM_DEBUG
 706                 printk("%s", IST30XX_DEBUG_TAG);
 707 #endif
 708                 for (j = 0; j < tsp->ch_num.rx; j++) {
 709                         idx = (i * tsp->ch_num.rx) + j;
 710                         type = check_tsp_type(data, i, j);
 711
 712                         if ((type == TSP_CH_SCREEN) || (type == TSP_CH_GTX)) {
 713                                 max_val = max(max_val, (int)ts_cmcs_buf->cm[idx]);
 714                                 min_val = min(min_val, (int)ts_cmcs_buf->cm[idx]);
 715                         }
 716 #if TSP_CM_DEBUG
 717                 printk("%5d ", ts_cmcs_buf->cm[idx]);
 718 #endif
 719                 }
 720 #if TSP_CM_DEBUG
 721                 printk("\n");
 722 #endif
 723         }
 724
 725         snprintf(buf, sizeof(buf), "%d,%d", min_val, max_val);
 726         tsp_info("%s(), %s\n", __func__, buf);
 727
 728         sec->cmd_state = CMD_STATE_OK;
 729         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 730         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf,
 731                  strnlen(buf, sizeof(buf)));
 732 }
 733
 734 void get_cm_value(void *dev_data)
 735 {
 736         int idx = 0;
 737         char buf[16] = { 0 };
 738
 739         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 740         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 741         TSP_INFO *tsp = &data->tsp_info;
 742
 743         set_default_result(sec);
 744
 745         idx = check_tsp_channel(data, tsp->ch_num.rx, tsp->ch_num.tx);
 746         if (idx < 0) { // Parameter parsing fail
 747                 snprintf(buf, sizeof(buf), "%s", "NG");
 748                 sec->cmd_state = CMD_STATE_FAIL;
 749         } else {
 750                 snprintf(buf, sizeof(buf), "%d", ts_cmcs_buf->cm[idx]);
 751                 sec->cmd_state = CMD_STATE_OK;
 752         }
 753
 754         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 755         tsp_info("%s(), [%d][%d]: %s\n", __func__,
 756                  sec->cmd_param[0], sec->cmd_param[1], buf);
 757         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf,
 758                  strnlen(buf, sizeof(buf)));
 759 }
 760
 761 void run_cmcs_test(void *dev_data)
 762 {
 763         int ret = 0;
 764         char buf[16] = { 0 };
 765
 766         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 767         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 768
 769         set_default_result(sec);
 770
 771         if ((ts_cmcs_bin == NULL) || (ts_cmcs_bin_size == 0)) {
 772                 sec->cmd_state = CMD_STATE_FAIL;
 773                 tsp_warn("%s(), Binary is not correct!\n", __func__);
 774                 return;
 775         }
 776
 777         ret = ist30xx_get_cmcs_info(ts_cmcs_bin, ts_cmcs_bin_size);
 778         if (unlikely(ret)) {
 779                 sec->cmd_state = CMD_STATE_FAIL;
 780                 tsp_warn("%s(), tsp get cmcs infomation fail!\n", __func__);
 781                 return;
 782         }
 783
 784         mutex_lock(&ist30xx_mutex);
 785         ret = ist30xx_cmcs_test(data, ts_cmcs_bin, ts_cmcs_bin_size);
 786         if (unlikely(ret)) {
 787                 mutex_unlock(&ist30xx_mutex);
 788                 sec->cmd_state = CMD_STATE_FAIL;
 789                 tsp_warn("%s(), tsp cmcs test fail!\n", __func__);
 790                 return;
 791         }
 792         mutex_unlock(&ist30xx_mutex);
 793
 794         snprintf(buf, sizeof(buf), "%s", "OK");
 795         tsp_info("%s(), %s\n", __func__, buf);
 796
 797         sec->cmd_state = CMD_STATE_OK;
 798         set_cmd_result(sec, buf, strnlen(buf, sizeof(buf)));
 799         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf,
 800                  strnlen(buf, sizeof(buf)));
 801 }
 802
 803 void get_cm_array(void *dev_data)
 804 {
 805         int i;
 806         int count = 0;
 807         int type;
 808         char *buf;
 809         const int msg_len = 16;
 810         char msg[msg_len];
 811
 812         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 813         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 814         TSP_INFO *tsp = &data->tsp_info;
 815
 816         set_default_result(sec);
 817
 818         buf = kmalloc(IST30XX_NODE_TOTAL_NUM * 5, GFP_KERNEL);
 819         memset(buf, 0, sizeof(buf));
 820
 821         for (i = 0; i < tsp->ch_num.rx * tsp->ch_num.tx; i++) {
 822 #if TSP_CM_DEBUG
 823                 if ((i % tsp->ch_num.rx) == 0)
 824                         printk("\n%s %4d: ", IST30XX_DEBUG_TAG, i);
 825
 826                 printk("%4d ", ts_cmcs_buf->cm[i]);
 827 #endif
 828                 type = check_tsp_type(data, i / tsp->ch_num.rx, i % tsp->ch_num.rx);
 829                 if ((type == TSP_CH_UNKNOWN) || (type == TSP_CH_UNUSED))
 830                         count += snprintf(msg, msg_len, "%d,", 0);
 831                 else
 832                         count += snprintf(msg, msg_len, "%d,", ts_cmcs_buf->cm[i]);
 833                 strncat(buf, msg, msg_len);
 834         }
 835
 836         printk("\n");
 837         tsp_info("%s: %d\n", __func__, count - 1);
 838         sec->cmd_state = CMD_STATE_OK;
 839         set_cmd_result(sec, buf, count - 1);
 840         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf, count);
 841         kfree(buf);
 842 }
 843
 844 void get_slope0_array(void *dev_data)
 845 {
 846         int i;
 847         int count = 0;
 848         char *buf;
 849         const int msg_len = 16;
 850         char msg[msg_len];
 851
 852         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 853         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 854         TSP_INFO *tsp = &data->tsp_info;
 855
 856         set_default_result(sec);
 857
 858         buf = kmalloc(IST30XX_NODE_TOTAL_NUM * 5, GFP_KERNEL);
 859         memset(buf, 0, sizeof(buf));
 860
 861         for (i = 0; i < tsp->ch_num.rx * tsp->ch_num.tx; i++) {
 862 #if TSP_CM_DEBUG
 863                 if ((i % tsp->ch_num.rx) == 0)
 864                         printk("\n%s %4d: ", IST30XX_DEBUG_TAG, i);
 865
 866                 printk("%4d ", ts_cmcs_buf->slope0[i]);
 867 #endif
 868                 count += snprintf(msg, msg_len, "%d,", ts_cmcs_buf->slope0[i]);
 869                 strncat(buf, msg, msg_len);
 870         }
 871
 872         printk("\n");
 873         tsp_info("%s: %d\n", __func__, count - 1);
 874         sec->cmd_state = CMD_STATE_OK;
 875         set_cmd_result(sec, buf, count - 1);
 876         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf, count);
 877         kfree(buf);
 878 }
 879
 880 void get_slope1_array(void *dev_data)
 881 {
 882         int i;
 883         int count = 0;
 884         char *buf;
 885         const int msg_len = 16;
 886         char msg[msg_len];
 887
 888         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 889         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 890         TSP_INFO *tsp = &data->tsp_info;
 891
 892         set_default_result(sec);
 893
 894         buf = kmalloc(IST30XX_NODE_TOTAL_NUM * 5, GFP_KERNEL);
 895         memset(buf, 0, sizeof(buf));
 896
 897         for (i = 0; i < tsp->ch_num.rx * tsp->ch_num.tx; i++) {
 898 #if TSP_CM_DEBUG
 899                 if ((i % tsp->ch_num.rx) == 0)
 900                         printk("\n%s %4d: ", IST30XX_DEBUG_TAG, i);
 901
 902                 printk("%4d ", ts_cmcs_buf->slope1[i]);
 903 #endif
 904                 count += snprintf(msg, msg_len, "%d,", ts_cmcs_buf->slope1[i]);
 905                 strncat(buf, msg, msg_len);
 906         }
 907
 908         printk("\n");
 909         tsp_info("%s: %d\n", __func__, count - 1);
 910         sec->cmd_state = CMD_STATE_OK;
 911         set_cmd_result(sec, buf, count - 1);
 912         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf, count);
 913         kfree(buf);
 914 }
 915
 916 void get_cs_array(void *dev_data)
 917 {
 918         int i;
 919         int count = 0;
 920         int type;
 921         char *buf;
 922         const int msg_len = 16;
 923         char msg[msg_len];
 924
 925         struct ist30xx_data *data = (struct ist30xx_data *)dev_data;
 926         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 927         TSP_INFO *tsp = &data->tsp_info;
 928
 929         set_default_result(sec);
 930
 931         buf = kmalloc(IST30XX_NODE_TOTAL_NUM * 5, GFP_KERNEL);
 932         memset(buf, 0, sizeof(buf));
 933
 934         for (i = 0; i < tsp->ch_num.rx * tsp->ch_num.tx; i++) {
 935 #if TSP_CM_DEBUG
 936                 if ((i % tsp->ch_num.rx) == 0)
 937                         printk("\n%s %4d: ", IST30XX_DEBUG_TAG, i);
 938
 939                 printk("%4d ", ts_cmcs_buf->cs[i]);
 940 #endif
 941                 type = check_tsp_type(data, i / tsp->ch_num.rx, i % tsp->ch_num.rx);
 942                 if ((type == TSP_CH_UNKNOWN) || (type == TSP_CH_UNUSED))
 943                         count += snprintf(msg, msg_len, "%d,", 0);
 944                 else
 945                         count += snprintf(msg, msg_len, "%d,", ts_cmcs_buf->cs[i]);
 946                 strncat(buf, msg, msg_len);
 947         }
 948
 949         printk("\n");
 950         tsp_info("%s: %d\n", __func__, count - 1);
 951         sec->cmd_state = CMD_STATE_OK;
 952         set_cmd_result(sec, buf, count - 1);
 953         dev_info(&data->client->dev, "%s: %s(%d)\n", __func__, buf, count);
 954         kfree(buf);
 955 }
 956 #endif
 957 /* sysfs: /sys/class/sec/tsp/close_tsp_test */
 958 static ssize_t show_close_tsp_test(struct device *dev,
 959                                    struct device_attribute *attr, char *buf)
 960 {
 961         return snprintf(buf, FACTORY_BUF_SIZE, "%u\n", 0);
 962 }
 963
 964 /* sysfs: /sys/class/sec/tsp/cmd */
 965 static ssize_t store_cmd(struct device *dev, struct device_attribute
 966                          *devattr, const char *buf, size_t count)
 967 {
 968         struct ist30xx_data *data = dev_get_drvdata(dev);
 969         struct sec_factory *sec = (struct sec_factory *)&data->sec;
 970         struct i2c_client *client = data->client;
 971
 972         char *cur, *start, *end;
 973         char msg[SEC_CMD_STR_LEN] = { 0 };
 974         int len, i;
 975         struct tsp_cmd *tsp_cmd_ptr = NULL;
 976         char delim = ',';
 977         bool cmd_found = false;
 978         int param_cnt = 0;
 979         int ret;
 980
 981         if (sec->cmd_is_running == true) {
 982                 dev_err(&client->dev, "tsp_cmd: other cmd is running.\n");
 983                 tsp_err("tsp_cmd: other cmd is running.\n");
 984                 goto err_out;
 985         }
 986
 987         /* check lock  */
 988         mutex_lock(&sec->cmd_lock);
 989         sec->cmd_is_running = true;
 990         mutex_unlock(&sec->cmd_lock);
 991
 992         sec->cmd_state = CMD_STATE_RUNNING;
 993
 994         for (i = 0; i < ARRAY_SIZE(sec->cmd_param); i++)
 995                 sec->cmd_param[i] = 0;
 996
 997         len = (int)count;
 998         if (*(buf + len - 1) == '\n')
 999                 len--;
1000         memset(sec->cmd, 0, ARRAY_SIZE(sec->cmd));
1001         memcpy(sec->cmd, buf, len);
1002
1003         cur = strchr(buf, (int)delim);
1004         if (cur)
1005                 memcpy(msg, buf, cur - buf);
1006         else
1007                 memcpy(msg, buf, len);
1008         /* find command */
1009         list_for_each_entry(tsp_cmd_ptr, &sec->cmd_list_head, list) {
1010                 if (!strcmp(msg, tsp_cmd_ptr->cmd_name)) {
1011                         cmd_found = true;
1012                         break;
1013                 }
1014         }
1015
1016         /* set not_support_cmd */
1017         if (!cmd_found) {
1018                 list_for_each_entry(tsp_cmd_ptr, &sec->cmd_list_head, list) {
1019                         if (!strcmp("not_support_cmd", tsp_cmd_ptr->cmd_name))
1020                                 break;
1021                 }
1022         }
1023
1024         /* parsing parameters */
1025         if (cur && cmd_found) {
1026                 cur++;
1027                 start = cur;
1028                 memset(msg, 0, ARRAY_SIZE(msg));
1029                 do {
1030                         if (*cur == delim || cur - buf == len) {
1031                                 end = cur;
1032                                 memcpy(msg, start, end - start);
1033                                 *(msg + strlen(msg)) = '\0';
1034                                 ret = kstrtoint(msg, 10, \
1035                                                 sec->cmd_param + param_cnt);
1036                                 start = cur + 1;
1037                                 memset(msg, 0, ARRAY_SIZE(msg));
1038                                 param_cnt++;
1039                         }
1040                         cur++;
1041                 } while (cur - buf <= len);
1042         }
1043         tsp_info("SEC CMD = %s\n", tsp_cmd_ptr->cmd_name);
1044
1045         for (i = 0; i < param_cnt; i++)
1046                 tsp_info("SEC CMD Param %d= %d\n", i, sec->cmd_param[i]);
1047
1048         tsp_cmd_ptr->cmd_func(data);
1049
1050 err_out:
1051         return count;
1052 }
1053
1054 /* sysfs: /sys/class/sec/tsp/cmd_status */
1055 static ssize_t show_cmd_status(struct device *dev,
1056                                struct device_attribute *devattr, char *buf)
1057 {
1058         struct ist30xx_data *data = dev_get_drvdata(dev);
1059         struct sec_factory *sec = (struct sec_factory *)&data->sec;
1060         char msg[16] = { 0 };
1061
1062         dev_info(&data->client->dev, "tsp cmd: status:%d\n", sec->cmd_state);
1063
1064         if (sec->cmd_state == CMD_STATE_WAITING)
1065                 snprintf(msg, sizeof(msg), "WAITING");
1066         else if (sec->cmd_state == CMD_STATE_RUNNING)
1067                 snprintf(msg, sizeof(msg), "RUNNING");
1068         else if (sec->cmd_state == CMD_STATE_OK)
1069                 snprintf(msg, sizeof(msg), "OK");
1070         else if (sec->cmd_state == CMD_STATE_FAIL)
1071                 snprintf(msg, sizeof(msg), "FAIL");
1072         else if (sec->cmd_state == CMD_STATE_NA)
1073                 snprintf(msg, sizeof(msg), "NOT_APPLICABLE");
1074
1075         return snprintf(buf, FACTORY_BUF_SIZE, "%s\n", msg);
1076 }
1077
1078 /* sysfs: /sys/class/sec/tsp/cmd_result */
1079 static ssize_t show_cmd_result(struct device *dev, struct device_attribute
1080                                *devattr, char *buf)
1081 {
1082         struct ist30xx_data *data = dev_get_drvdata(dev);
1083         struct sec_factory *sec = (struct sec_factory *)&data->sec;
1084
1085         dev_info(&data->client->dev, "tsp cmd: result: %s\n", sec->cmd_result);
1086
1087         mutex_lock(&sec->cmd_lock);
1088         sec->cmd_is_running = false;
1089         mutex_unlock(&sec->cmd_lock);
1090
1091         sec->cmd_state = CMD_STATE_WAITING;
1092
1093         return snprintf(buf, FACTORY_BUF_SIZE, "%s\n", sec->cmd_result);
1094 }
1095
1096
1097
1098 /* sysfs: /sys/class/sec/sec_touchscreen/tsp_firm_version_phone */
1099 static ssize_t phone_firmware_show(struct device *dev,
1100                                    struct device_attribute *attr, char *buf)
1101 {
1102         struct ist30xx_data *data = dev_get_drvdata(dev);
1103
1104         u32 ver = ist30xx_parse_ver(data, FLAG_FW, data->fw.buf);
1105
1106         tsp_info("%s(), IM00%04x\n", __func__, ver);
1107
1108         return sprintf(buf, "IM00%04x", ver);
1109 }
1110
1111 /* sysfs: /sys/class/sec/sec_touchscreen/tsp_firm_version_panel */
1112 static ssize_t part_firmware_show(struct device *dev,
1113                                   struct device_attribute *attr, char *buf)
1114 {
1115         u32 ver = 0;
1116         struct ist30xx_data *data = dev_get_drvdata(dev);
1117
1118         if (data->status.power == 1)
1119                 ver = ist30xx_get_fw_ver(data);
1120
1121         tsp_info("%s(), IM00%04x\n", __func__, ver);
1122
1123         return sprintf(buf, "IM00%04x", ver);
1124 }
1125
1126 /* sysfs: /sys/class/sec/sec_touchscreen/tsp_threshold */
1127 static ssize_t threshold_firmware_show(struct device *dev,
1128                                        struct device_attribute *attr, char *buf)
1129 {
1130         int ret = 0;
1131         u32 val = 0;
1132         int threshold = 0;
1133         struct ist30xx_data *data = dev_get_drvdata(dev);
1134
1135         ret = ist30xx_read_cmd(data, eHCOM_GET_TOUCH_TH, &val);
1136         if (unlikely(ret)) {
1137                 ist30xx_reset(data, false);
1138                 ist30xx_start(data);
1139                 tsp_info("%s(), ret=%d\n", __func__, ret);
1140                 val = 0;
1141         }
1142
1143         threshold = (int)(val & 0xFFFF);
1144
1145         tsp_info("%s(), %d (ret=%d)\n", __func__, threshold, ret);
1146
1147         return sprintf(buf, "%d", threshold);
1148 }
1149
1150 /* sysfs: /sys/class/sec/sec_touchscreen/tsp_firm_update */
1151 static ssize_t firmware_update(struct device *dev,
1152                                struct device_attribute *attr, char *buf)
1153 {
1154         bool ret;
1155         struct ist30xx_data *data = dev_get_drvdata(dev);
1156
1157         sprintf(IsfwUpdate, "%s\n", FW_DOWNLOADING);
1158         tsp_info("%s(), %s\n", __func__, IsfwUpdate);
1159
1160         ret = ist30xx_fw_recovery(data);
1161         ret = (ret == 0 ? 1 : -1);
1162
1163         sprintf(IsfwUpdate, "%s\n",
1164                 (ret > 0 ? FW_DOWNLOAD_COMPLETE : FW_DOWNLOAD_FAIL));
1165         tsp_info("%s(), %s\n", __func__, IsfwUpdate);
1166
1167         return sprintf(buf, "%d", ret);
1168 }
1169
1170 /* sysfs: /sys/class/sec/sec_touchscreen/tsp_firm_update_status */
1171 static ssize_t firmware_update_status(struct device *dev,
1172                                       struct device_attribute *attr, char *buf)
1173 {
1174         tsp_info("%s(), %s\n", __func__, IsfwUpdate);
1175
1176         return sprintf(buf, "%s\n", IsfwUpdate);
1177 }
1178
1179 /* sysfs: /sys/class/sec/sec_touchkey/touchkey_menu */
1180 /* sysfs: /sys/class/sec/sec_touchkey/touchkey_recent */
1181 static ssize_t recent_sensitivity_show(struct device *dev,
1182                                        struct device_attribute *attr, char *buf)
1183 {
1184         int sensitivity = 0;
1185         struct ist30xx_data *data = dev_get_drvdata(dev);
1186
1187         sensitivity = ist30xx_get_key_sensitivity(data, 0);
1188
1189         tsp_info("%s(), %d\n", __func__, sensitivity);
1190
1191         return sprintf(buf, "%d", sensitivity);
1192 }
1193
1194 /* sysfs: /sys/class/sec/sec_touchkey/touchkey_back */
1195 static ssize_t back_sensitivity_show(struct device *dev,
1196                                      struct device_attribute *attr, char *buf)
1197 {
1198         int sensitivity = 0;
1199         struct ist30xx_data *data = dev_get_drvdata(dev);
1200
1201         sensitivity = ist30xx_get_key_sensitivity(data, 1);
1202
1203         tsp_info("%s(), %d\n", __func__, sensitivity);
1204
1205         return sprintf(buf, "%d", sensitivity);
1206 }
1207
1208 /* sysfs: /sys/class/sec/sec_touchkey/touchkey_threshold */
1209 static ssize_t touchkey_threshold_show(struct device *dev,
1210                                        struct device_attribute *attr, char *buf)
1211 {
1212         int ret = 0;
1213         u32 val = 0;
1214         int threshold = 0;
1215         struct ist30xx_data *data = dev_get_drvdata(dev);
1216
1217         ret = ist30xx_read_cmd(data, eHCOM_GET_TOUCH_TH, &val);
1218         if (unlikely(ret)) {
1219                 ist30xx_reset(data, false);
1220                 ist30xx_start(data);
1221                 val = 0;
1222         }
1223
1224         threshold = (int)((val >> 16) & 0xFFFF);
1225
1226         tsp_info("%s(), %d (ret=%d)\n", __func__, threshold, ret);
1227
1228         return sprintf(buf, "%d", threshold);
1229 }
1230
1231 struct tsp_cmd tsp_cmds[] = {
1232         { TSP_CMD("get_chip_vendor", get_chip_vendor), },
1233         { TSP_CMD("get_chip_name",   get_chip_name),   },
1234         { TSP_CMD("get_chip_id",     get_chip_id),     },
1235         { TSP_CMD("fw_update",       fw_update),       },
1236         { TSP_CMD("get_fw_ver_bin",  get_fw_ver_bin),  },
1237         { TSP_CMD("get_fw_ver_ic",   get_fw_ver_ic),   },
1238         { TSP_CMD("get_threshold",   get_threshold),   },
1239         { TSP_CMD("get_x_num",       get_scr_x_num),   },
1240         { TSP_CMD("get_y_num",       get_scr_y_num),   },
1241         { TSP_CMD("get_all_x_num",       get_all_x_num),   },
1242         { TSP_CMD("get_all_y_num",       get_all_y_num),   },
1243         { TSP_CMD("run_raw_read",    run_raw_read),    },
1244         { TSP_CMD("get_raw_value",   get_raw_value),   },
1245 #if IST30XX_CMCS_TEST
1246         { TSP_CMD("run_cm_test",     run_cm_test),     },
1247         { TSP_CMD("get_cm_value",    get_cm_value),    },
1248 #if IST30XX_JIG_MODE
1249         { TSP_CMD("get_raw_array",   get_raw_array),   },
1250         { TSP_CMD("run_cmcs_test",   run_cmcs_test),   },
1251         { TSP_CMD("get_cm_array",    get_cm_array),    },
1252         { TSP_CMD("get_slope0_array",get_slope0_array),},
1253         { TSP_CMD("get_slope1_array",get_slope1_array),},
1254         { TSP_CMD("get_cs_array",    get_cs_array),    },
1255         { TSP_CMD("get_cs0_array",   get_cs_array),    },
1256         { TSP_CMD("get_cs1_array",   get_cs_array),    },
1257 #endif
1258 #endif
1259         { TSP_CMD("not_support_cmd", not_support_cmd), },
1260 };
1261
1262 #define SEC_DEFAULT_ATTR    (S_IRUGO | S_IWUSR | S_IWOTH | S_IXOTH)
1263 /* sysfs - touchscreen */
1264 static DEVICE_ATTR(tsp_firm_version_phone, SEC_DEFAULT_ATTR,
1265                    phone_firmware_show, NULL);
1266 static DEVICE_ATTR(tsp_firm_version_panel, SEC_DEFAULT_ATTR,
1267                    part_firmware_show, NULL);
1268 static DEVICE_ATTR(tsp_threshold, SEC_DEFAULT_ATTR,
1269                    threshold_firmware_show, NULL);
1270 static DEVICE_ATTR(tsp_firm_update, SEC_DEFAULT_ATTR,
1271                    firmware_update, NULL);
1272 static DEVICE_ATTR(tsp_firm_update_status, SEC_DEFAULT_ATTR,
1273                    firmware_update_status, NULL);
1274
1275 /* sysfs - touchkey */
1276 static DEVICE_ATTR(touchkey_menu, SEC_DEFAULT_ATTR,
1277                    recent_sensitivity_show, NULL);
1278 static DEVICE_ATTR(touchkey_recent, SEC_DEFAULT_ATTR,
1279                    recent_sensitivity_show, NULL);
1280 static DEVICE_ATTR(touchkey_back, SEC_DEFAULT_ATTR,
1281                    back_sensitivity_show, NULL);
1282 static DEVICE_ATTR(touchkey_threshold, SEC_DEFAULT_ATTR,
1283                    touchkey_threshold_show, NULL);
1284
1285 /* sysfs - tsp */
1286 static DEVICE_ATTR(close_tsp_test, S_IRUGO, show_close_tsp_test, NULL);
1287 static DEVICE_ATTR(cmd, S_IWUSR | S_IWGRP, NULL, store_cmd);
1288 static DEVICE_ATTR(cmd_status, S_IRUGO, show_cmd_status, NULL);
1289 static DEVICE_ATTR(cmd_result, S_IRUGO, show_cmd_result, NULL);
1290
1291 static struct attribute *sec_tsp_attributes[] = {
1292         &dev_attr_tsp_firm_version_phone.attr,
1293         &dev_attr_tsp_firm_version_panel.attr,
1294         &dev_attr_tsp_threshold.attr,
1295         &dev_attr_tsp_firm_update.attr,
1296         &dev_attr_tsp_firm_update_status.attr,
1297         NULL,
1298 };
1299
1300 static struct attribute *sec_tkey_attributes[] = {
1301         &dev_attr_touchkey_menu.attr,
1302         &dev_attr_touchkey_recent.attr,
1303         &dev_attr_touchkey_back.attr,
1304         &dev_attr_touchkey_threshold.attr,
1305         NULL,
1306 };
1307
1308 static struct attribute *sec_touch_facotry_attributes[] = {
1309         &dev_attr_close_tsp_test.attr,
1310         &dev_attr_cmd.attr,
1311         &dev_attr_cmd_status.attr,
1312         &dev_attr_cmd_result.attr,
1313         NULL,
1314 };
1315
1316 static struct attribute_group sec_tsp_attr_group = {
1317         .attrs  = sec_tsp_attributes,
1318 };
1319
1320 static struct attribute_group sec_tkey_attr_group = {
1321         .attrs  = sec_tkey_attributes,
1322 };
1323
1324 static struct attribute_group sec_touch_factory_attr_group = {
1325         .attrs  = sec_touch_facotry_attributes,
1326 };
1327
1328 extern struct class *sec_class;
1329 struct device *sec_touchscreen;
1330 struct device *sec_touchkey;
1331 struct device *sec_fac_dev;
1332
1333 int sec_touch_sysfs(struct ist30xx_data *data)
1334 {
1335         /* /sys/class/sec/sec_touchscreen */
1336         sec_touchscreen = device_create(sec_class, NULL, 1, data,
1337                                         "sec_touchscreen");
1338         if (IS_ERR(sec_touchscreen)) {
1339                 tsp_err("Failed to create device (%s)!\n", "sec_touchscreen");
1340                 goto err_sec_touchscreen;
1341         }
1342         /* /sys/class/sec/sec_touchscreen/... */
1343         if (sysfs_create_group(&sec_touchscreen->kobj, &sec_tsp_attr_group)) {
1344                 tsp_err("Failed to create sysfs group(%s)!\n", "sec_touchscreen");
1345                 goto err_sec_touchscreen_attr;
1346         }
1347
1348         /* /sys/class/sec/sec_touchkey */
1349         sec_touchkey = device_create(sec_class, NULL, 2, data, "sec_touchkey");
1350         if (IS_ERR(sec_touchkey)) {
1351                 tsp_err("Failed to create device (%s)!\n", "sec_touchkey");
1352                 goto err_sec_touchkey;
1353         }
1354         /* /sys/class/sec/sec_touchkey/... */
1355         if (sysfs_create_group(&sec_touchkey->kobj, &sec_tkey_attr_group)) {
1356                 tsp_err("Failed to create sysfs group(%s)!\n", "sec_touchkey");
1357                 goto err_sec_touchkey_attr;
1358         }
1359
1360         /* /sys/class/sec/tsp */
1361         sec_fac_dev = device_create(sec_class, NULL, 3, data, "tsp");
1362         if (IS_ERR(sec_fac_dev)) {
1363                 tsp_err("Failed to create device (%s)!\n", "tsp");
1364                 goto err_sec_fac_dev;
1365         }
1366         /* /sys/class/sec/tsp/... */
1367         if (sysfs_create_group(&sec_fac_dev->kobj, &sec_touch_factory_attr_group)) {
1368                 tsp_err("Failed to create sysfs group(%s)!\n", "tsp");
1369                 goto err_sec_fac_dev_attr;
1370         }
1371
1372         return 0;
1373
1374 err_sec_fac_dev_attr:
1375         device_destroy(sec_class, 3);
1376 err_sec_fac_dev:
1377 err_sec_touchkey_attr:
1378         device_destroy(sec_class, 2);
1379 err_sec_touchkey:
1380 err_sec_touchscreen_attr:
1381         device_destroy(sec_class, 1);
1382 err_sec_touchscreen:
1383
1384         return -ENODEV;
1385 }
1386 EXPORT_SYMBOL(sec_touch_sysfs);
1387 int sec_fac_cmd_init(struct ist30xx_data *data)
1388 {
1389         int i;
1390         struct sec_factory *sec = (struct sec_factory *)&data->sec;
1391
1392         INIT_LIST_HEAD(&sec->cmd_list_head);
1393         for (i = 0; i < ARRAY_SIZE(tsp_cmds); i++)
1394                 list_add_tail(&tsp_cmds[i].list, &sec->cmd_list_head);
1395
1396         mutex_init(&sec->cmd_lock);
1397         sec->cmd_is_running = false;
1398
1399         return 0;
1400 }
1401 EXPORT_SYMBOL(sec_fac_cmd_init);
1402 #endif