drivers/input/touchscreen/imagis_30xxc/ist30xxc_misc.c

   1 /*
   2  *  Copyright (C) 2010,Imagis Technology Co. Ltd. All Rights Reserved.
   3  *
   4  *  This program is free software; you can redistribute it and/or modify
   5  *  it under the terms of the GNU General Public License as published by
   6  *  the Free Software Foundation; either version 2 of the License, or
   7  *  (at your option) any later version.
   8  *
   9  *  This program is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *  GNU General Public License for more details.
  13  *
  14  */
  15
  16 #include <linux/i2c.h>
  17 #include <linux/delay.h>
  18 #include <linux/slab.h>
  19 #include <linux/firmware.h>
  20 #include <linux/stat.h>
  21
  22 #include <linux/i2c/ist30xxc.h>
  23 #include "ist30xxc_update.h"
  24 #include "ist30xxc_misc.h"
  25
  26 #define TSP_CH_UNUSED                   (0)
  27 #define TSP_CH_SCREEN                   (1)
  28 #define TSP_CH_GTX                      (2)
  29 #define TSP_CH_KEY                      (3)
  30 #define TSP_CH_UNKNOWN                  (-1)
  31
  32 #define TOUCH_NODE_PARSING_DEBUG        (0)
  33
  34 static u32 *ist30xx_frame_buf;
  35 static u32 *ist30xx_frame_rawbuf;
  36 static u32 *ist30xx_frame_fltbuf;
  37
  38 int ist30xx_check_valid_ch(struct ist30xx_data *data, int ch_tx, int ch_rx)
  39 {
  40         int i;
  41         TKEY_INFO *tkey = &data->tkey_info;
  42         TSP_INFO *tsp = &data->tsp_info;
  43
  44         if (unlikely((ch_tx >= tsp->ch_num.tx) || (ch_rx >= tsp->ch_num.rx)))
  45                 return TSP_CH_UNKNOWN;
  46
  47         if ((ch_tx >= tsp->screen.tx) || (ch_rx >= tsp->screen.rx)) {
  48                 if (tsp->gtx.num) {
  49                         for (i = 0; i < tsp->gtx.num; i++) {
  50                                 if ((ch_tx == tsp->gtx.ch_num[i]) && (ch_rx < tsp->screen.rx))
  51                                         return TSP_CH_GTX;
  52                         }
  53                 }
  54
  55                 if (tkey->enable) {
  56                         for (i = 0; i < tkey->key_num; i++) {
  57                                 if ((ch_tx == tkey->ch_num[i].tx) &&
  58                                         (ch_rx == tkey->ch_num[i].rx))
  59                                         return TSP_CH_KEY;
  60                         }
  61                 }
  62         } else {
  63                 return TSP_CH_SCREEN;
  64         }
  65
  66         return TSP_CH_UNUSED;
  67 }
  68
  69 int ist30xx_parse_touch_node(struct ist30xx_data *data, u8 flag,
  70         struct TSP_NODE_BUF *node)
  71 {
  72 #if TOUCH_NODE_PARSING_DEBUG
  73         int j;
  74         TSP_INFO *tsp = &data->tsp_info;
  75 #endif
  76         int i;
  77         u16 *raw = (u16 *)&node->raw;
  78         u16 *base = (u16 *)&node->base;
  79         u16 *filter = (u16 *)&node->filter;
  80         u32 *tmp_rawbuf = ist30xx_frame_rawbuf;
  81         u32 *tmp_fltbuf = ist30xx_frame_fltbuf;
  82
  83         for (i = 0; i < node->len; i++) {
  84                 if (flag & (NODE_FLAG_RAW | NODE_FLAG_BASE)) {
  85                         *raw++ = *tmp_rawbuf & 0xFFF;
  86                         *base++ = (*tmp_rawbuf >> 16) & 0xFFF;
  87
  88                         tmp_rawbuf++;
  89                 }
  90                 if (flag & NODE_FLAG_FILTER)
  91                         *filter++ = *tmp_fltbuf++ & 0xFFF;
  92         }
  93
  94 #if TOUCH_NODE_PARSING_DEBUG
  95         tsp_info("RAW - %d * %d\n", tsp->ch_num.tx, tsp->ch_num.rx);
  96         for (i = 0; i < tsp->ch_num.tx; i++) {
  97                 printk("\n[ TSP ] ");
  98                 for (j = 0; j < tsp->ch_num.rx; j++)
  99                         printk("%4d ", node->raw[(i * tsp->ch_num.rx) + j]);
 100         }
 101
 102         tsp_info("BASE - %d * %d\n", tsp->ch_num.tx, tsp->ch_num.rx);
 103         for (i = 0; i < tsp->ch_num.tx; i++) {
 104                 printk("\n[ TSP ] ");
 105                 for (j = 0; j < tsp->ch_num.rx; j++)
 106                         printk("%4d ", node->base[(i * tsp->ch_num.rx) + j]);
 107         }
 108
 109         tsp_info("FILTER - %d * %d\n", tsp->ch_num.tx, tsp->ch_num.rx);
 110         for (i = 0; i < tsp->ch_num.tx; i++) {
 111                 printk("\n[ TSP ] ");
 112                 for (j = 0; j < tsp->ch_num.rx; j++)
 113                         printk("%4d ", node->filter[(i * tsp->ch_num.rx) + j]);
 114         }
 115 #endif
 116
 117         return 0;
 118 }
 119
 120 int print_touch_node(struct ist30xx_data *data, u8 flag,
 121         struct TSP_NODE_BUF *node, char *buf)
 122 {
 123         int i, j;
 124         int count = 0;
 125         int val = 0;
 126         const int msg_len = 128;
 127         char msg[msg_len];
 128         TSP_INFO *tsp = &data->tsp_info;
 129
 130         if (tsp->dir.swap_xy) {
 131                 for (i = 0; i < tsp->ch_num.rx; i++) {
 132                         for (j = 0; j < tsp->ch_num.tx; j++) {
 133                                 if (flag == NODE_FLAG_RAW)
 134                                         val = (int)node->raw[(j * tsp->ch_num.rx) + i];
 135                                 else if (flag == NODE_FLAG_BASE)
 136                                         val = (int)node->base[(j * tsp->ch_num.rx) + i];
 137                                 else if (flag == NODE_FLAG_FILTER)
 138                                         val = (int)node->filter[(j * tsp->ch_num.rx) + i];
 139                                 else if (flag == NODE_FLAG_DIFF)
 140                                         val = (int)(node->raw[(j * tsp->ch_num.rx) + i]
 141                                                 - node->base[(j * tsp->ch_num.rx) + i]);
 142                                 else
 143                                         return 0;
 144
 145                                 if (val < 0) val = 0;
 146
 147                                 if (ist30xx_check_valid_ch(data, j, i) == TSP_CH_UNUSED)
 148                                         count += snprintf(msg, msg_len, "%4d ", 0);
 149                                 else
 150                                         count += snprintf(msg, msg_len, "%4d ", val);
 151
 152                                 strncat(buf, msg, msg_len);
 153                         }
 154
 155                         count += snprintf(msg, msg_len, "\n");
 156                         strncat(buf, msg, msg_len);
 157                 }
 158         } else {
 159                 for (i = 0; i < tsp->ch_num.tx; i++) {
 160                         for (j = 0; j < tsp->ch_num.rx; j++) {
 161                                 if (flag == NODE_FLAG_RAW)
 162                                         val = (int)node->raw[(i * tsp->ch_num.rx) + j];
 163                                 else if (flag == NODE_FLAG_BASE)
 164                                         val = (int)node->base[(i * tsp->ch_num.rx) + j];
 165                                 else if (flag == NODE_FLAG_FILTER)
 166                                         val = (int)node->filter[(i * tsp->ch_num.rx) + j];
 167                                 else if (flag == NODE_FLAG_DIFF)
 168                                         val = (int)(node->raw[(i * tsp->ch_num.rx) + j]
 169                                                 - node->base[(i * tsp->ch_num.rx) + j]);
 170                                 else
 171                                         return 0;
 172
 173                                 if (val < 0) val = 0;
 174
 175                                 if (ist30xx_check_valid_ch(data, i, j) == TSP_CH_UNUSED)
 176                                         count += snprintf(msg, msg_len, "%4d ", 0);
 177                                 else
 178                                         count += snprintf(msg, msg_len, "%4d ", val);
 179
 180                                 strncat(buf, msg, msg_len);
 181                         }
 182
 183                         count += snprintf(msg, msg_len, "\n");
 184                         strncat(buf, msg, msg_len);
 185                 }
 186         }
 187
 188         return count;
 189 }
 190
 191 int parse_tsp_node(struct ist30xx_data *data, u8 flag,
 192         struct TSP_NODE_BUF *node, s16 *buf16, int mode)
 193 {
 194         int i, j;
 195         s16 val = 0;
 196         TSP_INFO *tsp = &data->tsp_info;
 197
 198         if (unlikely((flag != NODE_FLAG_RAW) && (flag != NODE_FLAG_BASE) &&
 199                 (flag != NODE_FLAG_FILTER) && (flag != NODE_FLAG_DIFF)))
 200                 return -EPERM;
 201
 202         for (i = 0; i < tsp->ch_num.tx; i++) {
 203                 for (j = 0; j < tsp->ch_num.rx; j++) {
 204                         if (mode & TS_RAW_SCREEN) {
 205                                 if (ist30xx_check_valid_ch(data, i, j) != TSP_CH_SCREEN)
 206                                         continue;
 207                         } else if (mode & TS_RAW_KEY) {
 208                                 if (ist30xx_check_valid_ch(data, i, j) != TSP_CH_KEY)
 209                                         continue;
 210                         }
 211                         switch (flag) {
 212                         case NODE_FLAG_RAW:
 213                                 val = (s16)node->raw[(i * tsp->ch_num.rx) + j];
 214                                 break;
 215                         case NODE_FLAG_BASE:
 216                                 val = (s16)node->base[(i * tsp->ch_num.rx) + j];
 217                                 break;
 218                         case NODE_FLAG_FILTER:
 219                                 val = (s16)node->filter[(i * tsp->ch_num.rx) + j];
 220                                 break;
 221                         case NODE_FLAG_DIFF:
 222                                 val = (s16)(node->raw[(i * tsp->ch_num.rx) + j]
 223                                         - node->base[(i * tsp->ch_num.rx) + j]);
 224                                 break;
 225                         }
 226
 227                         if (val < 0) val = 0;
 228
 229                         if (ist30xx_check_valid_ch(data, i, j) == TSP_CH_UNUSED)
 230                                 val = 0;
 231
 232                         *buf16++ = val;
 233                 }
 234         }
 235
 236         return 0;
 237 }
 238
 239 int ist30xx_read_touch_node(struct ist30xx_data *data, u8 flag,
 240         struct TSP_NODE_BUF *node)
 241 {
 242         int i;
 243         int ret;
 244         u32 addr;
 245         u32 *tmp_rawbuf = ist30xx_frame_rawbuf;
 246         u32 *tmp_fltbuf = ist30xx_frame_fltbuf;
 247
 248         ist30xx_disable_irq(data);
 249
 250         if (flag & NODE_FLAG_NO_CCP) {
 251                 ist30xx_reset(data, false);
 252                 ret = ist30xx_write_cmd(data->client, IST30XX_HIB_CMD,
 253                         ((eHCOM_CP_CORRECT_EN << 16) | (IST30XX_DISABLE & 0xFFFF)));
 254                 if (unlikely(ret))
 255                         goto read_tsp_node_end;
 256
 257                 msleep(1000);
 258         }
 259
 260         ret = ist30xx_cmd_hold(data, 1);
 261         if (unlikely(ret))
 262                 goto read_tsp_node_end;
 263
 264         addr = IST30XX_DA_ADDR(data->tags.raw_base);
 265         if (flag & (NODE_FLAG_RAW | NODE_FLAG_BASE)) {
 266                 tsp_info("Reg addr: %x, size: %d\n", addr, node->len);
 267                 for (i = 0; i < node->len; i++) {
 268                         ret = ist30xx_read_buf(data->client, addr, tmp_rawbuf, 1);
 269                         if (unlikely(ret))
 270                                 goto reg_access_end;
 271
 272                         addr += IST30XX_DATA_LEN;
 273                         tmp_rawbuf++;
 274                 }
 275         }
 276
 277         addr = IST30XX_DA_ADDR(data->tags.filter_base);
 278         if (flag & NODE_FLAG_FILTER) {
 279                 tsp_info("Reg addr: %x, size: %d\n", addr, node->len);
 280                 for (i = 0; i < node->len; i++) {
 281                         ret = ist30xx_read_buf(data->client, addr, tmp_fltbuf, 1);
 282                         if (unlikely(ret))
 283                                 goto reg_access_end;
 284
 285                         addr += IST30XX_DATA_LEN;
 286                         tmp_fltbuf++;
 287                 }
 288         }
 289
 290 reg_access_end:
 291         ist30xx_cmd_hold(data, 0);
 292
 293         if (flag & NODE_FLAG_NO_CCP) {
 294                 ist30xx_reset(data, false);
 295                 ist30xx_start(data);
 296         }
 297
 298 read_tsp_node_end:
 299         ist30xx_enable_irq(data);
 300
 301         return ret;
 302 }
 303
 304 /* sysfs: /sys/class/touch/node/refresh */
 305 ssize_t ist30xx_frame_refresh(struct device *dev, struct device_attribute *attr,
 306                                 char *buf)
 307 {
 308         int ret = 0;
 309         struct ist30xx_data *data = dev_get_drvdata(dev);
 310         TSP_INFO *tsp = &data->tsp_info;
 311         u8 flag = NODE_FLAG_RAW | NODE_FLAG_BASE | NODE_FLAG_FILTER;
 312
 313         tsp_info("refresh\n");
 314         mutex_lock(&ist30xx_mutex);
 315         ret = ist30xx_read_touch_node(data, flag, &tsp->node);
 316         if (unlikely(ret)) {
 317         mutex_unlock(&ist30xx_mutex);
 318                 tsp_err("cmd 1frame raw update fail\n");
 319                 return sprintf(buf, "FAIL\n");
 320         }
 321         mutex_unlock(&ist30xx_mutex);
 322
 323         ist30xx_parse_touch_node(data, flag, &tsp->node);
 324
 325         return sprintf(buf, "OK\n");
 326 }
 327
 328
 329 /* sysfs: /sys/class/touch/node/read_nocp */
 330 ssize_t ist30xx_frame_nocp(struct device *dev, struct device_attribute *attr,
 331                         char *buf)
 332 {
 333         int ret = 0;
 334         struct ist30xx_data *data = dev_get_drvdata(dev);
 335         TSP_INFO *tsp = &data->tsp_info;
 336         u8 flag = NODE_FLAG_RAW | NODE_FLAG_BASE | NODE_FLAG_FILTER |
 337                   NODE_FLAG_NO_CCP;
 338
 339         mutex_lock(&ist30xx_mutex);
 340         ret = ist30xx_read_touch_node(data, flag, &tsp->node);
 341         if (unlikely(ret)) {
 342                 mutex_unlock(&ist30xx_mutex);
 343                 tsp_err("cmd 1frame raw update fail\n");
 344                 return sprintf(buf, "FAIL\n");
 345         }
 346         mutex_unlock(&ist30xx_mutex);
 347
 348         ist30xx_parse_touch_node(data, flag, &tsp->node);
 349
 350         return sprintf(buf, "OK\n");
 351 }
 352
 353
 354 /* sysfs: /sys/class/touch/node/base */
 355 ssize_t ist30xx_base_show(struct device *dev, struct device_attribute *attr,
 356                           char *buf)
 357 {
 358         int count = 0;
 359         struct ist30xx_data *data = dev_get_drvdata(dev);
 360         TSP_INFO *tsp = &data->tsp_info;
 361
 362         buf[0] = '\0';
 363         count = sprintf(buf, "dump ist30xx baseline(%d)\n", tsp->node.len);
 364
 365         count += print_touch_node(data, NODE_FLAG_BASE, &tsp->node, buf);
 366
 367         return count;
 368 }
 369
 370
 371 /* sysfs: /sys/class/touch/node/raw */
 372 ssize_t ist30xx_raw_show(struct device *dev, struct device_attribute *attr,
 373                          char *buf)
 374 {
 375         int count = 0;
 376         struct ist30xx_data *data = dev_get_drvdata(dev);
 377         TSP_INFO *tsp = &data->tsp_info;
 378
 379         buf[0] = '\0';
 380         count = sprintf(buf, "dump ist30xx raw(%d)\n", tsp->node.len);
 381
 382         count += print_touch_node(data, NODE_FLAG_RAW, &tsp->node, buf);
 383
 384         return count;
 385 }
 386
 387
 388 /* sysfs: /sys/class/touch/node/diff */
 389 ssize_t ist30xx_diff_show(struct device *dev, struct device_attribute *attr,
 390                           char *buf)
 391 {
 392         int count = 0;
 393         struct ist30xx_data *data = dev_get_drvdata(dev);
 394         TSP_INFO *tsp = &data->tsp_info;
 395
 396         buf[0] = '\0';
 397         count = sprintf(buf, "dump ist30xx difference (%d)\n", tsp->node.len);
 398
 399         count += print_touch_node(data, NODE_FLAG_DIFF, &tsp->node, buf);
 400
 401         return count;
 402 }
 403
 404
 405 /* sysfs: /sys/class/touch/node/filter */
 406 ssize_t ist30xx_filter_show(struct device *dev, struct device_attribute *attr,
 407                             char *buf)
 408 {
 409         int count = 0;
 410         struct ist30xx_data *data = dev_get_drvdata(dev);
 411         TSP_INFO *tsp = &data->tsp_info;
 412
 413         buf[0] = '\0';
 414         count = sprintf(buf, "dump ist30xx filter (%d)\n", tsp->node.len);
 415
 416         count += print_touch_node(data, NODE_FLAG_FILTER, &tsp->node, buf);
 417
 418         return count;
 419 }
 420
 421 /* sysfs: /sys/class/touch/sys/debug_mode */
 422 ssize_t ist30xx_debug_mode_store(struct device *dev,
 423                                 struct device_attribute *attr, const char *buf, size_t size)
 424 {
 425         int ret = 0;
 426         int enable;
 427         struct ist30xx_data *data = dev_get_drvdata(dev);
 428
 429         sscanf(buf, "%d", &enable);
 430
 431         if (unlikely((enable != 0) && (enable != 1))) {
 432                 tsp_err("input data error(%d)\n", enable);
 433                 return size;
 434         }
 435
 436         if (data->status.power) {
 437                 ret = ist30xx_write_cmd(data->client, IST30XX_HIB_CMD,
 438                         (eHCOM_SLEEP_MODE_EN << 16) | ((enable ? 0 : 1) & 0xFFFF));
 439
 440                 if (ret) {
 441                         tsp_info("failed to set debug mode(%d)\n", enable);
 442                 } else {
 443                         data->debug_mode = enable;
 444                         tsp_info("debug mode %s\n", enable ? "start" : "stop");
 445                 }
 446         } else {
 447                 data->debug_mode = enable;
 448                 tsp_info("debug mode %s\n", enable ? "start" : "stop");
 449         }
 450
 451         return size;
 452 }
 453
 454 /* sysfs: /sys/class/touch/sys/jig_mode */
 455 ssize_t ist30xx_jig_mode_store(struct device *dev,
 456                                 struct device_attribute *attr, const char *buf, size_t size)
 457 {
 458         int enable;
 459         struct ist30xx_data *data = dev_get_drvdata(dev);
 460
 461         sscanf(buf, "%d", &enable);
 462
 463         if (unlikely((enable != 0) && (enable != 1))) {
 464                 tsp_err("input data error(%d)\n", enable);
 465                 return size;
 466         }
 467
 468         data->jig_mode = enable;
 469         tsp_info("set jig mode: %s\n", enable ? "start" : "stop");
 470
 471         mutex_lock(&ist30xx_mutex);
 472         ist30xx_reset(data, false);
 473         ist30xx_start(data);
 474         mutex_unlock(&ist30xx_mutex);
 475
 476         return size;
 477 }
 478
 479 extern int calib_ms_delay;
 480 /* sysfs: /sys/class/touch/sys/clb_time */
 481 ssize_t ist30xx_calib_time_store(struct device *dev,
 482                                 struct device_attribute *attr, const char *buf, size_t size)
 483 {
 484         int ms_delay;
 485
 486         sscanf(buf, "%d", &ms_delay);
 487
 488         if (ms_delay > 10 && ms_delay < 1000) // 1sec ~ 100sec
 489                 calib_ms_delay = ms_delay;
 490
 491         tsp_info("Calibration wait time %dsec\n", calib_ms_delay / 10);
 492
 493         return size;
 494 }
 495
 496 /* sysfs: /sys/class/touch/sys/clb */
 497 ssize_t ist30xx_calib_show(struct device *dev, struct device_attribute *attr,
 498                         char *buf)
 499 {
 500         struct ist30xx_data *data = dev_get_drvdata(dev);
 501
 502         mutex_lock(&ist30xx_mutex);
 503         ist30xx_disable_irq(data);
 504
 505         ist30xx_reset(data, false);
 506         ist30xx_calibrate(data, 1);
 507
 508         mutex_unlock(&ist30xx_mutex);
 509         ist30xx_start(data);
 510
 511         return 0;
 512 }
 513
 514 /* sysfs: /sys/class/touch/sys/clb_result */
 515 ssize_t ist30xx_calib_result_show(struct device *dev,
 516                                 struct device_attribute *attr, char *buf)
 517 {
 518         int ret;
 519         int count = 0;
 520         u32 value;
 521         struct ist30xx_data *data = dev_get_drvdata(dev);
 522
 523         ret = ist30xx_read_cmd(data, eHCOM_GET_CAL_RESULT, &value);
 524         if (unlikely(ret)) {
 525                 mutex_lock(&ist30xx_mutex);
 526                 ist30xx_reset(data, false);
 527                 ist30xx_start(data);
 528                 mutex_unlock(&ist30xx_mutex);
 529                 tsp_warn("Error Read Calibration Result\n");
 530                 count = sprintf(buf, "Error Read Calibration Result\n");
 531                 goto calib_show_end;
 532         }
 533
 534         count = sprintf(buf,
 535                         "Calibration Status : %d, Max raw gap : %d - (raw: %08x)\n",
 536                         CALIB_TO_STATUS(value), CALIB_TO_GAP(value), value);
 537
 538 calib_show_end:
 539
 540         return count;
 541 }
 542
 543 /* sysfs: /sys/class/touch/sys/power_on */
 544 ssize_t ist30xx_power_on_show(struct device *dev, struct device_attribute *attr,
 545                                 char *buf)
 546 {
 547         struct ist30xx_data *data = dev_get_drvdata(dev);
 548
 549         tsp_info("Power enable: %d\n", true);
 550
 551         mutex_lock(&ist30xx_mutex);
 552         ist30xx_internal_resume(data);
 553         ist30xx_enable_irq(data);
 554         mutex_unlock(&ist30xx_mutex);
 555
 556         ist30xx_start(data);
 557
 558         return 0;
 559 }
 560
 561 /* sysfs: /sys/class/touch/sys/power_off */
 562 ssize_t ist30xx_power_off_show(struct device *dev,
 563                                 struct device_attribute *attr, char *buf)
 564 {
 565         struct ist30xx_data *data = dev_get_drvdata(dev);
 566
 567         tsp_info("Power enable: %d\n", false);
 568
 569         mutex_lock(&ist30xx_mutex);
 570         ist30xx_disable_irq(data);
 571         ist30xx_internal_suspend(data);
 572         mutex_unlock(&ist30xx_mutex);
 573
 574         return 0;
 575 }
 576
 577 /* sysfs: /sys/class/touch/sys/errcnt */
 578 ssize_t ist30xx_errcnt_store(struct device *dev, struct device_attribute *attr,
 579                                 const char *buf, size_t size)
 580 {
 581         int err_cnt;
 582         struct ist30xx_data *data = dev_get_drvdata(dev);
 583
 584         sscanf(buf, "%d", &err_cnt);
 585
 586         if (unlikely(err_cnt < 0))
 587                 return size;
 588
 589         tsp_info("Request reset error count: %d\n", err_cnt);
 590
 591         data->max_irq_err_cnt = err_cnt;
 592
 593         return size;
 594 }
 595
 596 /* sysfs: /sys/class/touch/sys/scancnt */
 597 ssize_t ist30xx_scancnt_store(struct device *dev, struct device_attribute *attr,
 598                                 const char *buf, size_t size)
 599 {
 600         int retry;
 601         struct ist30xx_data *data = dev_get_drvdata(dev);
 602
 603         sscanf(buf, "%d", &retry);
 604
 605         if (unlikely(retry < 0))
 606                 return size;
 607
 608         tsp_info("Timer scan count retry: %d\n", retry);
 609
 610         data->max_scan_retry = retry;
 611
 612         return size;
 613 }
 614
 615 extern int ist30xx_dbg_level;
 616 /* sysfs: /sys/class/touch/sys/printk */
 617 ssize_t ist30xx_printk_store(struct device *dev, struct device_attribute *attr,
 618                                 const char *buf, size_t size)
 619 {
 620         int level;
 621
 622         sscanf(buf, "%d", &level);
 623
 624         if (unlikely((level < DEV_ERR) || (level > DEV_VERB)))
 625                 return size;
 626
 627         tsp_info("prink log level: %d\n", level);
 628
 629         ist30xx_dbg_level = level;
 630
 631         return size;
 632 }
 633
 634 ssize_t ist30xx_printk_show(struct device *dev, struct device_attribute *attr,
 635                         char *buf)
 636 {
 637     return sprintf(buf, "prink log level: %d\n", ist30xx_dbg_level);
 638 }
 639
 640 /* sysfs: /sys/class/touch/sys/printk5 */
 641 ssize_t ist30xx_printk5_show(struct device *dev, struct device_attribute *attr,
 642                         char *buf)
 643 {
 644         tsp_info("prink log level:%d\n", DEV_DEBUG);
 645
 646         ist30xx_dbg_level = DEV_DEBUG;
 647
 648         return 0;
 649 }
 650
 651 /* sysfs: /sys/class/touch/sys/printk6 */
 652 ssize_t ist30xx_printk6_show(struct device *dev, struct device_attribute *attr,
 653                         char *buf)
 654 {
 655         tsp_info("prink log level:%d\n", DEV_VERB);
 656
 657         ist30xx_dbg_level = DEV_VERB;
 658
 659         return 0;
 660 }
 661
 662 #if IST30XX_GESTURE
 663 /* sysfs: /sys/class/touch/sys/gesture */
 664 ssize_t ist30xx_gesture_store(struct device *dev, struct device_attribute *attr,
 665                         const char *buf, size_t size)
 666 {
 667         int gesture;
 668         struct ist30xx_data *data = dev_get_drvdata(dev);
 669
 670         sscanf(buf, "%d", &gesture);
 671
 672         tsp_info("gesture enable : %s\n", (gesture == 0) ? "disable" : "enable");
 673
 674         data->gesture = (gesture == 0) ? false : true;
 675
 676         return size;
 677 }
 678 #endif
 679
 680 /* sysfs: /sys/class/touch/sys/touch_rate */
 681 ssize_t ist30xx_touch_rate_store(struct device *dev,
 682                                 struct device_attribute *attr, const char *buf, size_t size)
 683 {
 684         int rate;
 685         struct ist30xx_data *data = dev_get_drvdata(dev);
 686
 687         sscanf(buf, "%d", &rate);               // us
 688
 689         if (unlikely(rate > 0xFFFF))            // over 65.5ms
 690                 return size;
 691
 692         data->report_rate = rate;
 693         ist30xx_write_cmd(data->client, IST30XX_HIB_CMD,
 694                 ((eHCOM_SET_TIME_ACTIVE << 16) | (data->report_rate & 0xFFFF)));
 695         tsp_info(" active rate : %dus\n", data->report_rate);
 696
 697         return size;
 698 }
 699
 700 /* sysfs: /sys/class/touch/sys/idle_rate */
 701 ssize_t ist30xx_idle_scan_rate_store(struct device *dev,
 702                 struct device_attribute *attr, const char *buf, size_t size)
 703 {
 704         int rate;
 705         struct ist30xx_data *data = dev_get_drvdata(dev);
 706
 707         sscanf(buf, "%d", &rate);               // us
 708
 709         if (unlikely(rate > 0xFFFF))            // over 65.5ms
 710                 return size;
 711
 712         data->idle_rate = rate;
 713         ist30xx_write_cmd(data->client, IST30XX_HIB_CMD,
 714                 ((eHCOM_SET_TIME_IDLE << 16) | (data->idle_rate & 0xFFFF)));
 715         tsp_info(" idle rate : %dus\n", data->idle_rate);
 716
 717         return size;
 718 }
 719
 720 extern void ist30xx_set_ta_mode(bool charging);
 721 /* sysfs: /sys/class/touch/sys/mode_ta */
 722 ssize_t ist30xx_ta_mode_store(struct device *dev, struct device_attribute *attr,
 723                                 const char *buf, size_t size)
 724 {
 725         int mode;
 726
 727         sscanf(buf, "%d", &mode);
 728
 729         if (unlikely((mode != 0) && (mode != 1)))   // enable/disable
 730                 return size;
 731
 732         ist30xx_set_ta_mode(mode);
 733
 734         return size;
 735 }
 736
 737 extern void ist30xx_set_call_mode(int mode);
 738 /* sysfs: /sys/class/touch/sys/mode_call */
 739 ssize_t ist30xx_call_mode_store(struct device *dev,
 740                                 struct device_attribute *attr, const char *buf, size_t size)
 741 {
 742         int mode;
 743
 744         sscanf(buf, "%d", &mode);
 745
 746         if (unlikely((mode != 0) && (mode != 1)))   // enable/disable
 747                 return size;
 748
 749         ist30xx_set_call_mode(mode);
 750
 751         return size;
 752 }
 753
 754 extern void ist30xx_set_cover_mode(int mode);
 755 /* sysfs: /sys/class/touch/sys/mode_cover */
 756 ssize_t ist30xx_cover_mode_store(struct device *dev,
 757                                 struct device_attribute *attr, const char *buf, size_t size)
 758 {
 759         int mode;
 760
 761         sscanf(buf, "%d", &mode);
 762
 763         if (unlikely((mode != 0) && (mode != 1)))   // enable/disable
 764                 return size;
 765
 766         ist30xx_set_cover_mode(mode);
 767
 768         return size;
 769 }
 770
 771 /* sysfs: /sys/class/touch/sys/ic_inform */
 772 ssize_t ist30xx_read_ic_inform(struct device *dev, struct device_attribute *attr,
 773                         char *buf)
 774 {
 775         struct ist30xx_data *data = dev_get_drvdata(dev);
 776
 777         ist30xx_print_info(data);
 778
 779         return 0;
 780 }
 781
 782 #define TUNES_CMD_WRITE         (1)
 783 #define TUNES_CMD_READ          (2)
 784 #define TUNES_CMD_REG_ENTER     (3)
 785 #define TUNES_CMD_REG_EXIT      (4)
 786 #define TUNES_CMD_UPDATE_PARAM  (5)
 787 #define TUNES_CMD_UPDATE_FW     (6)
 788
 789 #define DIRECT_ADDR(n)          (IST30XX_DA_ADDR(n))
 790 #define DIRECT_CMD_WRITE        ('w')
 791 #define DIRECT_CMD_READ         ('r')
 792
 793 #pragma pack(1)
 794 typedef struct {
 795         u8      cmd;
 796         u32     addr;
 797         u16     len;
 798 } TUNES_INFO;
 799 #pragma pack()
 800 #pragma pack(1)
 801 typedef struct {
 802         char    cmd;
 803         u32     addr;
 804         u32     val;
 805 } DIRECT_INFO;
 806 #pragma pack()
 807
 808 static TUNES_INFO ist30xx_tunes;
 809 static DIRECT_INFO ist30xx_direct;
 810 static bool tunes_cmd_done = false;
 811 static bool ist30xx_reg_mode = false;
 812
 813 /* sysfs: /sys/class/touch/sys/direct */
 814 ssize_t ist30xx_direct_store(struct device *dev, struct device_attribute *attr,
 815                                 const char *buf, size_t size)
 816 {
 817         int ret = -EPERM;
 818         struct ist30xx_data *data = dev_get_drvdata(dev);
 819         DIRECT_INFO *direct = (DIRECT_INFO *)&ist30xx_direct;
 820
 821         sscanf(buf, "%c %x %x", &direct->cmd, &direct->addr, &direct->val);
 822
 823         tsp_debug("Direct cmd: %c, addr: %x, val: %x\n",
 824                 direct->cmd, direct->addr, direct->val);
 825
 826         if (unlikely((direct->cmd != DIRECT_CMD_WRITE) &&
 827                 (direct->cmd != DIRECT_CMD_READ))) {
 828                 tsp_warn("Direct cmd is not correct!\n");
 829                 return size;
 830         }
 831
 832         if (ist30xx_intr_wait(data, 30) < 0)
 833                 return size;
 834
 835         data->status.event_mode = false;
 836         if (direct->cmd == DIRECT_CMD_WRITE) {
 837                 ist30xx_cmd_hold(data, 1);
 838                 ist30xx_write_cmd(data->client, DIRECT_ADDR(direct->addr),
 839                         direct->val);
 840                 ist30xx_read_reg(data->client, DIRECT_ADDR(direct->addr),
 841                         &direct->val);
 842                 ret = ist30xx_cmd_hold(data, 0);
 843                 if (ret) {
 844                         tsp_debug("Direct write fail\n");
 845                         ist30xx_reset(data, false);
 846                         ist30xx_start(data);
 847                 } else {
 848                         tsp_debug("Direct write addr: %x, val: %x\n",
 849                         direct->addr, direct->val);
 850                 }
 851         }
 852         data->status.event_mode = true;
 853
 854         return size;
 855 }
 856
 857 #define DIRECT_BUF_COUNT        (4)
 858 ssize_t ist30xx_direct_show(struct device *dev, struct device_attribute *attr,
 859                             char *buf)
 860 {
 861         int i, ret, count = 0;
 862         int len;
 863         u32 addr;
 864         u32 buf32[DIRECT_BUF_COUNT];
 865         int max_len = DIRECT_BUF_COUNT;
 866         const int msg_len = 256;
 867         char msg[msg_len];
 868         struct ist30xx_data *data = dev_get_drvdata(dev);
 869         DIRECT_INFO *direct = (DIRECT_INFO *)&ist30xx_direct;
 870
 871         if (unlikely(direct->cmd != DIRECT_CMD_READ))
 872                 return sprintf(buf, "ex) echo r addr len > direct\n");
 873
 874         len = direct->val;
 875         addr = DIRECT_ADDR(direct->addr);
 876
 877         if (ist30xx_intr_wait(data, 30) < 0)
 878                 return 0;
 879
 880         data->status.event_mode = false;
 881         ist30xx_cmd_hold(data, 1);
 882
 883         while (len > 0) {
 884                 if (len < max_len) max_len = len;
 885
 886                 memset(buf32, 0, sizeof(buf32));
 887                 for (i = 0; i < max_len; i++) {
 888                         ret = ist30xx_read_buf(data->client, addr, &buf32[i], 1);
 889                         if (unlikely(ret)) {
 890                                 count = sprintf(buf, "I2C Burst read fail, addr: %x\n", addr);
 891                         break;
 892                         }
 893
 894                         addr += IST30XX_DATA_LEN;
 895                 }
 896
 897                 for (i = 0; i < max_len; i++) {
 898                         count += snprintf(msg, msg_len, "0x%08x ", buf32[i]);
 899                         strncat(buf, msg, msg_len);
 900                 }
 901                 count += snprintf(msg, msg_len, "\n");
 902                 strncat(buf, msg, msg_len);
 903
 904                 len -= max_len;
 905         }
 906
 907         ret = ist30xx_cmd_hold(data, 0);
 908         if (ret) {
 909                 ist30xx_reset(data, false);
 910                 ist30xx_start(data);
 911         }
 912         data->status.event_mode = true;
 913
 914         tsp_debug("%s", buf);
 915
 916         return count;
 917 }
 918
 919 /* sysfs: /sys/class/touch/tunes/node_info */
 920 ssize_t tunes_node_info_show(struct device *dev,
 921                                 struct device_attribute *attr, char *buf)
 922 {
 923         int size;
 924         struct ist30xx_data *data = dev_get_drvdata(dev);
 925         TSP_INFO *tsp = &data->tsp_info;
 926         TKEY_INFO *tkey = &data->tkey_info;
 927
 928
 929         size = sprintf(buf, "%d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d %d",
 930                         data->chip_id, tsp->dir.swap_xy, tsp->ch_num.tx,
 931                         tsp->ch_num.rx,tsp->screen.tx, tsp->screen.rx,
 932                         tsp->gtx.num, tsp->gtx.ch_num[0],
 933                         tsp->gtx.ch_num[1], tsp->gtx.ch_num[2], tsp->gtx.ch_num[3],
 934                         tsp->baseline, tkey->enable, tkey->baseline, tkey->key_num,
 935                         tkey->ch_num[0].tx, tkey->ch_num[0].rx, tkey->ch_num[1].tx,
 936                         tkey->ch_num[1].rx, tkey->ch_num[2].tx, tkey->ch_num[2].rx,
 937                         tkey->ch_num[3].tx, tkey->ch_num[3].rx, tkey->ch_num[4].tx,
 938                         tkey->ch_num[4].rx, data->tags.raw_base, data->tags.filter_base);
 939
 940         return size;
 941 }
 942
 943 /* sysfs: /sys/class/touch/tunes/regcmd */
 944 ssize_t tunes_regcmd_store(struct device *dev, struct device_attribute *attr,
 945                            const char *buf, size_t size)
 946 {
 947         int ret = -1;
 948         u32 *buf32;
 949         struct ist30xx_data *data = dev_get_drvdata(dev);
 950
 951         memcpy(&ist30xx_tunes, buf, sizeof(ist30xx_tunes));
 952         buf += sizeof(ist30xx_tunes);
 953         buf32 = (u32 *)buf;
 954
 955         tunes_cmd_done = false;
 956
 957         switch (ist30xx_tunes.cmd) {
 958         case TUNES_CMD_WRITE:
 959                 break;
 960         case TUNES_CMD_READ:
 961                 break;
 962         case TUNES_CMD_REG_ENTER:
 963                 ist30xx_disable_irq(data);
 964
 965                 /* enter reg access mode */
 966                 ret = ist30xx_cmd_hold(data, 1);
 967                 if (unlikely(ret))
 968                         goto regcmd_fail;
 969
 970                 ist30xx_reg_mode = true;
 971                 break;
 972         case TUNES_CMD_REG_EXIT:
 973                 /* exit reg access mode */
 974                 ret = ist30xx_cmd_hold(data, 0);
 975                 if (unlikely(ret)) {
 976                         ist30xx_reset(data, false);
 977                         ist30xx_start(data);
 978                         goto regcmd_fail;
 979                 }
 980
 981                 ist30xx_reg_mode = false;
 982                 ist30xx_enable_irq(data);
 983                 break;
 984         default:
 985                 ist30xx_enable_irq(data);
 986                 return size;
 987         }
 988         tunes_cmd_done = true;
 989
 990         return size;
 991
 992 regcmd_fail:
 993         tsp_err("Tunes regcmd i2c_fail, ret=%d\n", ret);
 994         return size;
 995 }
 996
 997 ssize_t tunes_regcmd_show(struct device *dev, struct device_attribute *attr,
 998                           char *buf)
 999 {
1000         int size;
1001
1002         size = sprintf(buf, "cmd: 0x%02x, addr: 0x%08x, len: 0x%04x\n",
1003                         ist30xx_tunes.cmd, ist30xx_tunes.addr, ist30xx_tunes.len);
1004
1005         return size;
1006 }
1007
1008 #define MAX_WRITE_LEN   (1)
1009 /* sysfs: /sys/class/touch/tunes/reg */
1010 ssize_t tunes_reg_store(struct device *dev, struct device_attribute *attr,
1011                         const char *buf, size_t size)
1012 {
1013         int ret;
1014         u32 *buf32 = (u32 *)buf;
1015         int waddr, wcnt = 0, len = 0;
1016         struct ist30xx_data *data = dev_get_drvdata(dev);
1017
1018         if (unlikely(ist30xx_tunes.cmd != TUNES_CMD_WRITE)) {
1019                 tsp_err("error, IST30XX_REG_CMD is not correct!\n");
1020                 return size;
1021         }
1022
1023         if (unlikely(!ist30xx_reg_mode)) {
1024                 tsp_err("error, IST30XX_REG_CMD is not ready!\n");
1025                 return size;
1026         }
1027
1028         if (unlikely(!tunes_cmd_done)) {
1029                 tsp_err("error, IST30XX_REG_CMD is not ready!\n");
1030                 return size;
1031         }
1032
1033         waddr = ist30xx_tunes.addr;
1034         if (ist30xx_tunes.len >= MAX_WRITE_LEN)
1035                 len = MAX_WRITE_LEN;
1036         else
1037                 len = ist30xx_tunes.len;
1038
1039         while (wcnt < ist30xx_tunes.len) {
1040                 ret = ist30xx_write_buf(data->client, waddr, buf32, len);
1041                 if (unlikely(ret)) {
1042                         tsp_err("Tunes regstore i2c_fail, ret=%d\n", ret);
1043                         return size;
1044                 }
1045
1046                 wcnt += len;
1047
1048                 if ((ist30xx_tunes.len - wcnt) < MAX_WRITE_LEN)
1049                         len = ist30xx_tunes.len - wcnt;
1050
1051                 buf32 += MAX_WRITE_LEN;
1052                 waddr += MAX_WRITE_LEN * IST30XX_DATA_LEN;
1053         }
1054
1055         tunes_cmd_done = false;
1056
1057         return size;
1058 }
1059
1060 ssize_t tunes_reg_show(struct device *dev, struct device_attribute *attr,
1061                         char *buf)
1062 {
1063         int ret;
1064         int size = 0;
1065 #if I2C_MONOPOLY_MODE
1066         unsigned long flags;
1067 #endif
1068         struct ist30xx_data *data = dev_get_drvdata(dev);
1069
1070         if (unlikely(ist30xx_tunes.cmd != TUNES_CMD_READ)) {
1071                 tsp_err("error, IST30XX_REG_CMD is not correct!\n");
1072                 return 0;
1073         }
1074
1075         if (unlikely(!tunes_cmd_done)) {
1076                 tsp_err("error, IST30XX_REG_CMD is not ready!\n");
1077                 return 0;
1078         }
1079
1080 #if I2C_MONOPOLY_MODE
1081         local_irq_save(flags);          // Activated only when the GPIO I2C is used
1082 #endif
1083     ret = ist30xx_burst_read(data->client,  ist30xx_tunes.addr,
1084                 (u32 *)buf, ist30xx_tunes.len, false);
1085 #if I2C_MONOPOLY_MODE
1086         local_irq_restore(flags);       // Activated only when the GPIO I2C is used
1087 #endif
1088         if (unlikely(ret)) {
1089                 tsp_err("Tunes regshow i2c_fail, ret=%d\n", ret);
1090                 return size;
1091         }
1092
1093         size = ist30xx_tunes.len * IST30XX_DATA_LEN;
1094
1095         tunes_cmd_done = false;
1096
1097         return size;
1098 }
1099
1100 /* sysfs: /sys/class/touch/tunes/adb */
1101 ssize_t tunes_adb_store(struct device *dev, struct device_attribute *attr,
1102                         const char *buf, size_t size)
1103 {
1104         int ret;
1105         char *tmp, *ptr;
1106         char token[9];
1107         u32 cmd, addr, len, val;
1108         int write_len;
1109         struct ist30xx_data *data = dev_get_drvdata(dev);
1110
1111         sscanf(buf, "%x %x %x", &cmd, &addr, &len);
1112
1113         switch (cmd) {
1114         case TUNES_CMD_WRITE:   /* write cmd */
1115                 write_len = 0;
1116                 ptr = (char *)(buf + 15);
1117
1118                 while (write_len < len) {
1119                         memcpy(token, ptr, 8);
1120                         token[8] = 0;
1121                         val = simple_strtoul(token, &tmp, 16);
1122                         ret = ist30xx_write_buf(data->client, addr, &val, 1);
1123                         if (unlikely(ret)) {
1124                                 tsp_err("Tunes regstore i2c_fail, ret=%d\n", ret);
1125                                 return size;
1126                         }
1127
1128                         ptr += 8;
1129                         write_len++;
1130                         addr += 4;
1131                 }
1132                 break;
1133
1134         case TUNES_CMD_READ:   /* read cmd */
1135                 ist30xx_tunes.cmd = cmd;
1136                 ist30xx_tunes.addr = addr;
1137                 ist30xx_tunes.len = len;
1138                 break;
1139
1140         case TUNES_CMD_REG_ENTER:   /* enter */
1141                 ist30xx_disable_irq(data);
1142
1143                 ret = ist30xx_cmd_hold(data, 1);
1144                 if (unlikely(ret < 0)) {
1145                         goto cmd_fail;
1146                 }
1147
1148                 ist30xx_reg_mode = true;
1149                 break;
1150
1151         case TUNES_CMD_REG_EXIT:   /* exit */
1152                 if (ist30xx_reg_mode == true) {
1153                         ret = ist30xx_cmd_hold(data, 0);
1154                         if (unlikely(ret < 0)) {
1155                                 ist30xx_reset(data, false);
1156                                 ist30xx_start(data);
1157                                 goto cmd_fail;
1158                         }
1159
1160                         ist30xx_reg_mode = false;
1161                         ist30xx_enable_irq(data);
1162                 }
1163                 break;
1164
1165         default:
1166                 break;
1167         }
1168
1169         return size;
1170
1171 cmd_fail:
1172         tsp_err("Tunes adb i2c_fail\n");
1173         return size;
1174 }
1175
1176 ssize_t tunes_adb_show(struct device *dev, struct device_attribute *attr,
1177                         char *buf)
1178 {
1179         int ret;
1180         int i, len, size = 0;
1181         char reg_val[10];
1182 #if I2C_MONOPOLY_MODE
1183         unsigned long flags;
1184 #endif
1185         struct ist30xx_data *data = dev_get_drvdata(dev);
1186
1187         tsp_info("tunes_adb_show,%08x,%d\n", ist30xx_tunes.addr, ist30xx_tunes.len);
1188
1189 #if I2C_MONOPOLY_MODE
1190         local_irq_save(flags);          // Activated only when the GPIO I2C is used
1191 #endif
1192         ret = ist30xx_burst_read(data->client, ist30xx_tunes.addr,
1193                 ist30xx_frame_buf, ist30xx_tunes.len, false);
1194         if (unlikely(ret)) {
1195                 tsp_err("Tunes adbshow i2c_fail, ret=%d\n", ret);
1196                 return size;
1197         }
1198
1199 #if I2C_MONOPOLY_MODE
1200         local_irq_restore(flags);       // Activated only when the GPIO I2C is used
1201 #endif
1202
1203         size = 0;
1204         buf[0] = 0;
1205         len = sprintf(reg_val, "%08x", ist30xx_tunes.addr);
1206         strcat(buf, reg_val);
1207         size += len;
1208         for (i = 0; i < ist30xx_tunes.len; i++) {
1209                 len = sprintf(reg_val, "%08x", ist30xx_frame_buf[i]);
1210                 strcat(buf, reg_val);
1211                 size += len;
1212         }
1213
1214         return size;
1215 }
1216
1217 #ifdef IST30XX_ALGORITHM_MODE
1218 /* sysfs: /sys/class/touch/tunes/algorithm */
1219 extern u32 ist30xx_algr_addr, ist30xx_algr_size;
1220 ssize_t ist30xx_algr_store(struct device *dev, struct device_attribute *attr,
1221                            const char *buf, size_t size)
1222 {
1223         sscanf(buf, "%x %d", &ist30xx_algr_addr, &ist30xx_algr_size);
1224
1225         tsp_info("Algorithm addr: 0x%x, count: %d\n",
1226                  ist30xx_algr_addr, ist30xx_algr_size);
1227
1228         ist30xx_algr_addr |= IST30XX_DIRECT_ACCESS;
1229
1230         return size;
1231 }
1232
1233 ssize_t ist30xx_algr_show(struct device *dev, struct device_attribute *attr,
1234                           char *buf)
1235 {
1236         int ret;
1237         u32 algr_addr;
1238         int count = 0;
1239         struct ist30xx_data *data = dev_get_drvdata(dev);
1240
1241         ret = ist30xx_read_cmd(data, eHCOM_GET_ALGO_BASE, &algr_addr);
1242         if (unlikely(ret)) {
1243                 mutex_lock(&ist30xx_mutex);
1244                 ist30xx_reset(data, false);
1245                 ist30xx_start(data);
1246                 mutex_unlock(&ist30xx_mutex);
1247                 tsp_warn("Algorithm mem addr read fail!\n");
1248                 return 0;
1249         }
1250
1251         tsp_info("algr_addr(0x%x): 0x%x\n", eHCOM_GET_ALGO_BASE, algr_addr);
1252
1253         count = sprintf(buf, "Algorithm addr : 0x%x\n", algr_addr);
1254
1255         return count;
1256 }
1257 #endif // IST30XX_ALGORITHM_MODE
1258
1259 /* sysfs: /sys/class/touch/tunes/intr_debug */
1260 extern u32 intr_debug_addr, intr_debug_size;
1261 ssize_t intr_debug_store(struct device *dev, struct device_attribute *attr,
1262                          const char *buf, size_t size)
1263 {
1264         sscanf(buf, "%x %d", &intr_debug_addr, &intr_debug_size);
1265         tsp_info("Interrupt debug addr: 0x%x, count: %d\n",
1266                  intr_debug_addr, intr_debug_size);
1267
1268         intr_debug_addr |= IST30XX_DIRECT_ACCESS;
1269
1270         return size;
1271 }
1272
1273 ssize_t intr_debug_show(struct device *dev, struct device_attribute *attr,
1274                         char *buf)
1275 {
1276         int count = 0;
1277
1278         tsp_info("intr_debug_addr(0x%x): %d\n", intr_debug_addr, intr_debug_size);
1279
1280         count = sprintf(buf, "intr_debug_addr(0x%x): %d\n",
1281                         intr_debug_addr, intr_debug_size);
1282
1283         return count;
1284 }
1285
1286 /* sysfs: /sys/class/touch/tunes/intr_debug2 */
1287 extern u32 intr_debug2_addr, intr_debug2_size;
1288 ssize_t intr_debug2_store(struct device *dev, struct device_attribute *attr,
1289                          const char *buf, size_t size)
1290 {
1291         sscanf(buf, "%x %d", &intr_debug2_addr, &intr_debug2_size);
1292         tsp_info("Interrupt debug2 addr: 0x%x, count: %d\n",
1293                     intr_debug2_addr, intr_debug2_size);
1294
1295         intr_debug2_addr |= IST30XX_DIRECT_ACCESS;
1296
1297         return size;
1298 }
1299
1300 ssize_t intr_debug2_show(struct device *dev, struct device_attribute *attr,
1301                         char *buf)
1302 {
1303         int count = 0;
1304
1305         tsp_info("intr_debug2_addr(0x%x): %d\n",
1306                 intr_debug2_addr, intr_debug2_size);
1307
1308         count = sprintf(buf, "intr_debug2_addr(0x%x): %d\n",
1309                         intr_debug2_addr, intr_debug2_size);
1310
1311         return count;
1312 }
1313
1314 /* sysfs: /sys/class/touch/tunes/intr_debug3 */
1315 extern u32 intr_debug3_addr, intr_debug3_size;
1316 ssize_t intr_debug3_store(struct device *dev, struct device_attribute *attr,
1317                          const char *buf, size_t size)
1318 {
1319         sscanf(buf, "%x %d", &intr_debug3_addr, &intr_debug3_size);
1320         tsp_info("Interrupt debug3 addr: 0x%x, count: %d\n",
1321                 intr_debug3_addr, intr_debug3_size);
1322
1323         intr_debug3_addr |= IST30XX_DIRECT_ACCESS;
1324
1325         return size;
1326 }
1327
1328 ssize_t intr_debug3_show(struct device *dev, struct device_attribute *attr,
1329                         char *buf)
1330 {
1331         int count = 0;
1332
1333         tsp_info("intr_debug3_addr(0x%x): %d\n",
1334                 intr_debug3_addr, intr_debug3_size);
1335
1336         count = sprintf(buf, "intr_debug3_addr(0x%x): %d\n",
1337                         intr_debug3_addr, intr_debug3_size);
1338
1339         return count;
1340 }
1341
1342 /* sysfs : node */
1343 static DEVICE_ATTR(refresh, S_IRUGO, ist30xx_frame_refresh, NULL);
1344 static DEVICE_ATTR(nocp, S_IRUGO, ist30xx_frame_nocp, NULL);
1345 static DEVICE_ATTR(filter, S_IRUGO, ist30xx_filter_show, NULL);
1346 static DEVICE_ATTR(raw, S_IRUGO, ist30xx_raw_show, NULL);
1347 static DEVICE_ATTR(base, S_IRUGO, ist30xx_base_show, NULL);
1348 static DEVICE_ATTR(diff, S_IRUGO, ist30xx_diff_show, NULL);
1349
1350 /* sysfs : sys */
1351 static DEVICE_ATTR(debug_mode, S_IWUSR | S_IWGRP, NULL, ist30xx_debug_mode_store);
1352 static DEVICE_ATTR(jig_mode, S_IWUSR | S_IWGRP, NULL, ist30xx_jig_mode_store);
1353 static DEVICE_ATTR(printk, S_IRUGO | S_IWUSR | S_IWGRP,
1354                    ist30xx_printk_show, ist30xx_printk_store);
1355 static DEVICE_ATTR(printk5, S_IRUGO, ist30xx_printk5_show, NULL);
1356 static DEVICE_ATTR(printk6, S_IRUGO, ist30xx_printk6_show, NULL);
1357 #if IST30XX_GESTURE
1358 static DEVICE_ATTR(gesture, S_IWUSR | S_IWGRP, NULL, ist30xx_gesture_store);
1359 #endif
1360 static DEVICE_ATTR(direct, S_IRUGO | S_IWUSR | S_IWGRP,
1361                    ist30xx_direct_show, ist30xx_direct_store);
1362 static DEVICE_ATTR(clb_time, S_IWUSR | S_IWGRP, NULL, ist30xx_calib_time_store);
1363 static DEVICE_ATTR(clb, S_IRUGO, ist30xx_calib_show, NULL);
1364 static DEVICE_ATTR(clb_result, S_IRUGO, ist30xx_calib_result_show, NULL);
1365 static DEVICE_ATTR(tsp_power_on, S_IRUGO, ist30xx_power_on_show, NULL);
1366 static DEVICE_ATTR(tsp_power_off, S_IRUGO, ist30xx_power_off_show, NULL);
1367 static DEVICE_ATTR(errcnt, S_IWUSR | S_IWGRP, NULL, ist30xx_errcnt_store);
1368 static DEVICE_ATTR(scancnt, S_IWUSR | S_IWGRP, NULL, ist30xx_scancnt_store);
1369 static DEVICE_ATTR(report_rate, S_IWUSR | S_IWGRP, NULL, ist30xx_touch_rate_store);
1370 static DEVICE_ATTR(idle_rate, S_IWUSR | S_IWGRP, NULL, ist30xx_idle_scan_rate_store);
1371 static DEVICE_ATTR(mode_ta, S_IWUSR | S_IWGRP, NULL, ist30xx_ta_mode_store);
1372 static DEVICE_ATTR(mode_call, S_IWUSR | S_IWGRP, NULL, ist30xx_call_mode_store);
1373 static DEVICE_ATTR(mode_cover, S_IWUSR | S_IWGRP, NULL, ist30xx_cover_mode_store);
1374 static DEVICE_ATTR(ic_inform, S_IRUGO, ist30xx_read_ic_inform, NULL);
1375 /* sysfs : tunes */
1376 static DEVICE_ATTR(node_info, S_IRUGO, tunes_node_info_show, NULL);
1377 static DEVICE_ATTR(regcmd, S_IRUGO | S_IWUSR | S_IWGRP, tunes_regcmd_show, tunes_regcmd_store);
1378 static DEVICE_ATTR(reg, S_IRUGO | S_IWUSR | S_IWGRP, tunes_reg_show, tunes_reg_store);
1379 static DEVICE_ATTR(adb, S_IRUGO | S_IWUSR | S_IWGRP, tunes_adb_show, tunes_adb_store);
1380 #ifdef IST30XX_ALGORITHM_MODE
1381 static DEVICE_ATTR(algorithm, S_IRUGO | S_IWUSR | S_IWGRP, ist30xx_algr_show, ist30xx_algr_store);
1382 #endif
1383 static DEVICE_ATTR(intr_debug, S_IRUGO | S_IWUSR | S_IWGRP, intr_debug_show, intr_debug_store);
1384 static DEVICE_ATTR(intr_debug2, S_IRUGO | S_IWUSR | S_IWGRP, intr_debug2_show, intr_debug2_store);
1385 static DEVICE_ATTR(intr_debug3, S_IRUGO | S_IWUSR | S_IWGRP, intr_debug3_show, intr_debug3_store);
1386
1387 static struct attribute *node_attributes[] = {
1388         &dev_attr_refresh.attr,
1389         &dev_attr_nocp.attr,
1390         &dev_attr_filter.attr,
1391         &dev_attr_raw.attr,
1392         &dev_attr_base.attr,
1393         &dev_attr_diff.attr,
1394         NULL,
1395 };
1396
1397 static struct attribute *sys_attributes[] = {
1398         &dev_attr_debug_mode.attr,
1399         &dev_attr_jig_mode.attr,
1400         &dev_attr_printk.attr,
1401         &dev_attr_printk5.attr,
1402         &dev_attr_printk6.attr,
1403 #if IST30XX_GESTURE
1404         &dev_attr_gesture.attr,
1405 #endif
1406         &dev_attr_direct.attr,
1407         &dev_attr_clb_time.attr,
1408         &dev_attr_clb.attr,
1409         &dev_attr_clb_result.attr,
1410         &dev_attr_tsp_power_on.attr,
1411         &dev_attr_tsp_power_off.attr,
1412         &dev_attr_errcnt.attr,
1413         &dev_attr_scancnt.attr,
1414         &dev_attr_report_rate.attr,
1415         &dev_attr_idle_rate.attr,
1416         &dev_attr_mode_ta.attr,
1417         &dev_attr_mode_call.attr,
1418         &dev_attr_mode_cover.attr,
1419         &dev_attr_ic_inform.attr,
1420         NULL,
1421 };
1422
1423 static struct attribute *tunes_attributes[] = {
1424         &dev_attr_node_info.attr,
1425         &dev_attr_regcmd.attr,
1426         &dev_attr_reg.attr,
1427         &dev_attr_adb.attr,
1428 #ifdef IST30XX_ALGORITHM_MODE
1429         &dev_attr_algorithm.attr,
1430 #endif
1431         &dev_attr_intr_debug.attr,
1432         &dev_attr_intr_debug2.attr,
1433         &dev_attr_intr_debug3.attr,
1434         NULL,
1435 };
1436
1437 static struct attribute_group node_attr_group = {
1438         .attrs  = node_attributes,
1439 };
1440
1441 static struct attribute_group sys_attr_group = {
1442         .attrs  = sys_attributes,
1443 };
1444
1445 static struct attribute_group tunes_attr_group = {
1446         .attrs  = tunes_attributes,
1447 };
1448
1449 extern struct class *ist30xx_class;
1450 struct device *ist30xx_sys_dev;
1451 struct device *ist30xx_tunes_dev;
1452 struct device *ist30xx_node_dev;
1453
1454 int ist30xx_init_misc_sysfs(struct ist30xx_data *data)
1455 {
1456         int frame_buf_size = IST30XX_NODE_TOTAL_NUM * IST30XX_DATA_LEN;
1457
1458         /* /sys/class/touch/sys */
1459         ist30xx_sys_dev = device_create(ist30xx_class, NULL, 0, data, "sys");
1460
1461         /* /sys/class/touch/sys/... */
1462         if (unlikely(sysfs_create_group(&ist30xx_sys_dev->kobj,
1463                                         &sys_attr_group)))
1464                 tsp_err("Failed to create sysfs group(%s)!\n", "sys");
1465
1466         /* /sys/class/touch/tunes */
1467         ist30xx_tunes_dev = device_create(ist30xx_class, NULL, 0, data, "tunes");
1468
1469         /* /sys/class/touch/tunes/... */
1470         if (unlikely(sysfs_create_group(&ist30xx_tunes_dev->kobj,
1471                                         &tunes_attr_group)))
1472                 tsp_err("Failed to create sysfs group(%s)!\n", "tunes");
1473
1474         /* /sys/class/touch/node */
1475         ist30xx_node_dev = device_create(ist30xx_class, NULL, 0, data, "node");
1476
1477         /* /sys/class/touch/node/... */
1478         if (unlikely(sysfs_create_group(&ist30xx_node_dev->kobj,
1479                                         &node_attr_group)))
1480                 tsp_err("Failed to create sysfs group(%s)!\n", "node");
1481
1482         ist30xx_frame_buf = kmalloc(frame_buf_size, GFP_KERNEL);
1483         ist30xx_frame_rawbuf = kmalloc(frame_buf_size, GFP_KERNEL);
1484         ist30xx_frame_fltbuf = kmalloc(frame_buf_size, GFP_KERNEL);
1485         if (!ist30xx_frame_buf || !ist30xx_frame_rawbuf || !ist30xx_frame_fltbuf)
1486                 return -ENOMEM;
1487
1488         return 0;
1489 }