drivers/input/keyboard/coreriver/tc350-touchkey.c

   1 /*
   2  * CORERIVER TOUCHCORE touchkey driver
   3  *
   4  * Copyright (C) 2012 Samsung Electronics Co.Ltd
   5  * Author: Taeyoon Yoon <tyoony.yoon@samsung.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  *
  11  */
  12
  13 #include <linux/delay.h>
  14 #include <linux/firmware.h>
  15 #include <linux/of_gpio.h>
  16 #include <linux/gpio.h>
  17 #include <linux/i2c.h>
  18 #include <linux/init.h>
  19 #include <linux/input.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/irq.h>
  22 #include <linux/kernel.h>
  23 #include <linux/leds.h>
  24 #include <linux/module.h>
  25 #include <linux/mutex.h>
  26 #include <linux/slab.h>
  27 #include <linux/wakelock.h>
  28 #include <linux/workqueue.h>
  29 #include <linux/uaccess.h>
  30 #include <linux/regulator/consumer.h>
  31 #include "tc350-touchkey.h"
  32 #ifdef CONFIG_SLEEP_MONITOR
  33 #include <linux/power/sleep_monitor.h>
  34 #endif
  35
  36 #define TC300K_FW_BUILTIN_PATH  "coreriver"
  37 #define TC300K_FW_IN_SDCARD_PATH        "/opt/usr/media/"
  38
  39 #define TC300K_POWERON_DELAY            300
  40 #define TC300K_KEY_INDEX_MASK           0x07
  41 #define TC300K_KEY_PRESS_MASK           0x08
  42 /* registers */
  43 #define TC300K_KEYCODE                  0x00
  44 #define TC300K_FWVER                    0x01
  45 #define TC300K_MDVER                    0x02
  46 #define TC300K_MODE                     0x03
  47 #define TC300K_CHECKS_H         0x04
  48 #define TC300K_CHECKS_L         0x05
  49
  50 #define TC300K_1KEY_DATA                0x10
  51 #define TC300K_2KEY_DATA                0x18
  52 #define TC300K_3KEY_DATA                0x20
  53 #define TC300K_4KEY_DATA                0x28
  54
  55 #define TC300K_THRES_H_OFFSET           0x00
  56 #define TC300K_THRES_L_OFFSET           0x01
  57 #define TC300K_CH_PCK_H_OFFSET  0x02
  58 #define TC300K_CH_PCK_L_OFFSET  0x03
  59 #define TC300K_DIFF_H_OFFSET            0x04
  60 #define TC300K_DIFF_L_OFFSET            0x05
  61 #define TC300K_RAW_H_OFFSET             0x06
  62 #define TC300K_RAW_L_OFFSET             0x07
  63
  64 /* command */
  65 #define TC300K_CMD_ADDR         0x00
  66 #define TC300K_CMD_LED_ON               0x10
  67 #define TC300K_CMD_LED_OFF              0x20
  68 #define TC300K_CMD_GLOVE_ON             0x30
  69 #define TC300K_CMD_GLOVE_OFF            0x40
  70 #define TC300K_CMD_FAC_ON               0x50
  71 #define TC300K_CMD_FAC_OFF              0x60
  72 #define TC300K_CMD_CAL_CHECKSUM 0x70
  73 #define TC300K_CMD_DELAY                50
  74
  75 /* ISP command */
  76 #define TC300K_CSYNC1                   0xA3
  77 #define TC300K_CSYNC2                   0xAC
  78 #define TC300K_CSYNC3                   0xA5
  79 #define TC300K_CCFG                     0x92
  80 #define TC300K_PRDATA                   0x81
  81 #define TC300K_PEDATA                   0x82
  82 #define TC300K_PWDATA                   0x83
  83 #define TC300K_PECHIP                   0x8A
  84 #define TC300K_PEDISC                   0xB0
  85 #define TC300K_LDDATA                   0xB2
  86 #define TC300K_LDMODE                   0xB8
  87 #define TC300K_RDDATA                   0xB9
  88 #define TC300K_PCRST                    0xB4
  89 #define TC300K_PCRED                    0xB5
  90 #define TC300K_PCINC                    0xB6
  91 #define TC300K_RDPCH                    0xBD
  92
  93 /* ISP delay */
  94 #define TC300K_TSYNC1                   300     /* us */
  95 #define TC300K_TSYNC2                   50      /* 1ms~50ms */
  96 #define TC300K_TSYNC3                   100     /* us */
  97 #define TC300K_TDLY1                    1       /* us */
  98 #define TC300K_TDLY2                    2       /* us */
  99 #define TC300K_TFERASE                  10      /* ms */
 100 #define TC300K_TPROG                    20      /* us */
 101
 102 #define TC300K_CHECKSUM_DELAY           500
 103 #define TO_STRING(x) #x
 104
 105 #define TC300K_RETRY_CNT                3
 106
 107 #define TC300K_KEY_PRESS                1
 108 #define TC300K_KEY_RELEASE              0
 109
 110 #define TC300K_INVALID_VER              0xff
 111
 112 #define SEC_DEV_TOUCHKEY_MAJOR  1
 113 #define SEC_DEV_TOUCHKEY_MINOR  0
 114
 115 enum {
 116         FW_BUILT_IN = 0,
 117         FW_IN_SDCARD,
 118 };
 119
 120 enum {
 121         HAVE_LATEST_FW = 1,
 122         FW_UPDATE_RUNNING,
 123 };
 124
 125 enum {
 126         DOWNLOADING = 1,
 127         FAIL,
 128         PASS,
 129 };
 130
 131 struct fdata_struct {
 132         struct device   *dummy_dev;
 133         u8              fw_flash_status;
 134         u8              fw_update_skip;
 135 };
 136
 137 struct fw_image {
 138         u8 hdr_ver;
 139         u8 hdr_len;
 140         u16 first_fw_ver;
 141         u16 second_fw_ver;
 142         u16 third_ver;
 143         u32 fw_len;
 144         u16 checksum;
 145         u16 alignment_dummy;
 146         u8 data[0];
 147 } __attribute__ ((packed));
 148
 149 struct tsk_event_val {
 150         u16     tsk_bitmap;
 151         u8      tsk_status;
 152         int     tsk_keycode;
 153         char*   tsk_keyname;
 154 };
 155
 156 struct tc300k_data {
 157         struct i2c_client       *client;
 158         struct input_dev        *input_dev;
 159         struct tc300k_platform_data     *pdata;
 160         struct mutex            lock;
 161         struct fw_image         *fw_img;
 162         struct pinctrl *pinctrl;
 163         struct fdata_struct     *fdata;
 164         struct wake_lock        fw_wake_lock;
 165         struct regulator *vcc_en;
 166         struct regulator *vdd_led;
 167         struct tsk_event_val *tsk_ev_val;
 168         const struct firmware   *fw;
 169         char    phys[32];
 170         int     num_key;
 171         int     *keycodes;
 172         int     ic_fw_ver;
 173         u32     scl;
 174         u32     sda;
 175         u16     threhold;
 176         u8      cur_fw_path;
 177         u8      fw_flash_state;
 178         u8      suspend_type;
 179         bool    counting_timer;
 180         bool    enabled;
 181         bool    glove_mode;
 182         bool    factory_mode;
 183         bool    led_on;
 184         u32     release_cnt;
 185 };
 186
 187 struct tsk_event_val tsk_ev[TC300K_MAX_KEY*2] =
 188 {
 189         {0x01, TC300K_KEY_PRESS, KEY_PHONE, "MENU_KEY"},
 190         {0x02, TC300K_KEY_PRESS, KEY_BACK, "BACK_KEY"},
 191         {0x10, TC300K_KEY_RELEASE, KEY_PHONE, "MENU_KEY"},
 192         {0x20, TC300K_KEY_RELEASE, KEY_BACK, "BACK_KEY"},
 193 };
 194
 195 #ifdef CONFIG_PM_SLEEP
 196 static int tc300k_input_open(struct input_dev *dev);
 197 static void tc300k_input_close(struct input_dev *dev);
 198 #endif
 199 extern struct class *sec_class;
 200
 201 static int tkey_pinctrl_configure(struct tc300k_data *data, bool active)
 202 {
 203 #if 0
 204         struct pinctrl_state *set_state_i2c;
 205         int retval;
 206
 207         dev_info(&data->client->dev, "%s: %s\n", __func__, active ? "ACTIVE" : "SUSPEND");
 208
 209         if (active) {
 210                 set_state_i2c =
 211                         pinctrl_lookup_state(data->pinctrl,
 212                                 "tkey_gpio_active");
 213                 if (IS_ERR(set_state_i2c)) {
 214                         dev_err(&data->client->dev, "%s: cannot get pinctrl(i2c) active state\n", __func__);
 215                         return PTR_ERR(set_state_i2c);
 216                 }
 217         } else {
 218                 set_state_i2c =
 219                         pinctrl_lookup_state(data->pinctrl,
 220                                         "tkey_gpio_suspend");
 221                 if (IS_ERR(set_state_i2c)) {
 222                         dev_err(&data->client->dev, "%s: cannot get pinctrl(i2c) sleep state\n", __func__);
 223                         return PTR_ERR(set_state_i2c);
 224                 }
 225         }
 226
 227         retval = pinctrl_select_state(data->pinctrl, set_state_i2c);
 228         if (retval) {
 229                 dev_err(&data->client->dev, "%s: cannot set pinctrl(i2c) %s state\n",
 230                         __func__, active ? "active" : "suspend");
 231                 return retval;
 232         }
 233
 234         if (active) {
 235                 gpio_direction_input(data->pdata->gpio_sda);
 236                 gpio_direction_input(data->pdata->gpio_scl);
 237                 gpio_direction_input(data->pdata->gpio_int);
 238         }
 239 #endif
 240         return 0;
 241
 242 }
 243
 244 static void tc300k_gpio_request(struct tc300k_data *data)
 245 {
 246         struct tc300k_platform_data     *pdata = data->pdata;
 247         struct i2c_client *client = data->client;
 248         int ret = 0;
 249
 250         ret = gpio_request(pdata->gpio_en, "touchkey_en_gpio");
 251         if (ret)
 252                 dev_err(&client->dev, "%s: unable to request touchkey_en_gpio[%d]\n",
 253                         __func__, pdata->gpio_en);
 254         else
 255                 dev_dbg(&client->dev, "%s: request touchkey_en_gpio[%d]\n",
 256                         __func__, pdata->gpio_en);
 257
 258
 259         ret = gpio_request(pdata->gpio_int, "touchkey_irq");
 260         if (ret)
 261                 dev_err(&client->dev, "%s: unable to request touchkey_irq [%d]\n",
 262                         __func__, pdata->gpio_int);
 263         else
 264                 dev_dbg(&client->dev, "%s: request touchkey_irq [%d]\n",
 265                         __func__, pdata->gpio_int);
 266
 267         ret = gpio_request(pdata->gpio_sda, "touchkey_sda");
 268         if (ret)
 269                 dev_err(&client->dev, "%s: unable to request touchkey_sda [%d]\n",
 270                         __func__, pdata->gpio_sda);
 271         else
 272                 dev_dbg(&client->dev, "%s: request touchkey_sda [%d]\n",
 273                         __func__, pdata->gpio_sda);
 274
 275         ret = gpio_request(pdata->gpio_sda, "touchkey_scl");
 276         if (ret)
 277                 dev_err(&client->dev, "%s: unable to request touchkey_scl [%d]\n",
 278                         __func__, pdata->gpio_scl);
 279         else
 280                 dev_dbg(&client->dev, "%s: request touchkey_scl [%d]\n",
 281                         __func__, pdata->gpio_scl);
 282
 283         if ((int)(pdata->gpio_2p8_en) > 0) {
 284         ret = gpio_request(pdata->gpio_2p8_en, "touchkey_en_gpio2p8");
 285                 if (ret)
 286                 dev_err(&client->dev, "%s: unable to request touchkey_en_gpio2p8[%d]\n",
 287                         __func__, pdata->gpio_2p8_en);
 288                 else
 289                 dev_dbg(&client->dev, "%s: request touchkey_en_gpio2p8[%d]\n",
 290                         __func__, pdata->gpio_2p8_en);
 291         }
 292
 293         ret = gpio_direction_input(pdata->gpio_sda);
 294         if (ret)
 295                 dev_err(&client->dev, "%s: unable to change direction touchkey_sda [%d]\n",
 296                         __func__, pdata->gpio_sda);
 297         else
 298                 dev_dbg(&client->dev, "%s: change direction touchkey_sda [%d]\n",
 299                         __func__, pdata->gpio_sda);
 300
 301         ret = gpio_direction_input(pdata->gpio_scl);
 302         if (ret)
 303                 dev_err(&client->dev, "%s: unable to change direction touchkey_scl [%d]\n",
 304                         __func__, pdata->gpio_sda);
 305         else
 306                 dev_dbg(&client->dev, "%s: change direction touchkey_scl [%d]\n",
 307                         __func__, pdata->gpio_scl);
 308
 309         ret = gpio_direction_input(pdata->gpio_int);
 310         if (ret)
 311                 dev_err(&client->dev, "%s: unable to change direction touchkey_int [%d]\n",
 312                         __func__, pdata->gpio_int);
 313         else
 314                 dev_dbg(&client->dev, "%s: change direction touchkey_int [%d]\n",
 315                         __func__, pdata->gpio_int);
 316
 317         ret = gpio_direction_output(pdata->gpio_en, 0);
 318         if (ret)
 319                 dev_err(&client->dev, "%s: unable to change direction touchkey_en [%d]\n",
 320                         __func__, pdata->gpio_en);
 321         else
 322                 dev_dbg(&client->dev, "%s: change direction touchkey_en [%d]\n",
 323                         __func__, pdata->gpio_en);
 324
 325         if ((int)(pdata->gpio_2p8_en) > 0 ) {
 326                 ret = gpio_direction_output(pdata->gpio_2p8_en, 0);
 327                 if (ret)
 328                         dev_err(&client->dev, "%s: unable to change direction touchkey_2p8_en [%d]\n",
 329                                 __func__, pdata->gpio_2p8_en);
 330                 else
 331                         dev_dbg(&client->dev, "%s: change direction touchkey_2p8_en [%d]\n",
 332                                 __func__, pdata->gpio_2p8_en);
 333         }
 334 }
 335
 336 void tc300k_power(struct tc300k_data *data, int onoff)
 337 {
 338         struct i2c_client *client = data->client;
 339
 340         if (onoff)
 341                 gpio_direction_output(data->pdata->gpio_en, 1);
 342         else
 343                 gpio_direction_output(data->pdata->gpio_en, 0);
 344
 345         if ((int)(data->pdata->gpio_2p8_en) > 0 )
 346                 gpio_direction_output(data->pdata->gpio_2p8_en, onoff);
 347
 348         dev_info(&client->dev, "%s: [%s]\n",__func__, onoff ? "ON" : "OFF");
 349 }
 350
 351 void tc300k_led_power(struct tc300k_data *data, bool onoff)
 352 {
 353         return;
 354
 355         if (onoff)
 356                 pr_info("%sTKEY_LED 3.3V[vdd_led] on is finished.\n",__func__);
 357         else
 358                 pr_info("%sTKEY_LED 3.3V[vdd_led] off is finished\n",__func__);
 359 }
 360
 361 static int tc300k_get_module_ver(struct tc300k_data *data)
 362 {
 363         struct i2c_client *client = data->client;
 364         int retries = 3;
 365         int module_ver = 0;
 366
 367 read_module_version:
 368         module_ver = i2c_smbus_read_byte_data(client, TC300K_MDVER);
 369         if (module_ver < 0) {
 370                 dev_err(&client->dev,
 371                         "%s: failed to read IC module ver [%d][%d]\n", __func__,
 372                         module_ver, retries);
 373                 if (retries-- > 0) {
 374                         tc300k_power(data,0);
 375                         msleep(TC300K_POWERON_DELAY);
 376                         tc300k_power(data,1);
 377                         msleep(TC300K_POWERON_DELAY);
 378                         goto read_module_version;
 379                 }
 380         }
 381
 382         return module_ver;
 383 }
 384
 385 static int tc300k_get_fw_ver(struct tc300k_data *data)
 386 {
 387         struct i2c_client *client = data->client;
 388         int ver = 0;
 389         int retries = 2;
 390
 391 read_version:
 392         ver = i2c_smbus_read_byte_data(client, TC300K_FWVER);
 393         if (ver < 0) {
 394                 dev_err(&client->dev,
 395                         "%s : failed to read IC fw ver. [%d][%d]\n",
 396                         __func__, ver, retries);
 397                 if (retries--) {
 398                         tc300k_power(data,0);
 399                         msleep(TC300K_POWERON_DELAY);
 400                         tc300k_power(data,1);
 401                         msleep(TC300K_POWERON_DELAY);
 402                         goto read_version;
 403                 }
 404         }
 405
 406         if (retries)
 407                 data->ic_fw_ver= ver;
 408         else
 409                 dev_err(&client->dev, "%s : failed to get IC fw ver.\n", __func__);
 410
 411         return ver;
 412 }
 413
 414 static inline void setsda(struct tc300k_data *data, int state)
 415 {
 416         if (state)
 417                 gpio_direction_output(data->pdata->gpio_sda, 1);
 418         else
 419                 gpio_direction_output(data->pdata->gpio_sda, 0);
 420 }
 421
 422 static inline void setscl(struct tc300k_data *data, int state)
 423 {
 424         if (state)
 425                 gpio_direction_output(data->pdata->gpio_scl, 1);
 426         else
 427                 gpio_direction_output(data->pdata->gpio_scl, 0);
 428 }
 429
 430 static inline int getsda(struct tc300k_data *data)
 431 {
 432         gpio_direction_input(data->pdata->gpio_sda);
 433
 434         return gpio_get_value(data->pdata->gpio_sda);
 435 }
 436
 437 static inline int getscl(struct tc300k_data *data)
 438 {
 439         return gpio_get_value(data->pdata->gpio_scl);
 440 }
 441
 442 static void send_9bit(struct tc300k_data *data, u8 buff)
 443 {
 444         int i;
 445
 446         setscl(data, 1);
 447         setsda(data, 0);
 448         setscl(data, 0);
 449
 450         for (i = 0; i < 8; i++) {
 451                 setscl(data, 1);
 452                 setsda(data, (buff >> i) & 0x01);
 453                 setscl(data, 0);
 454         }
 455
 456         setsda(data, 0);
 457 }
 458
 459 static u8 wait_9bit(struct tc300k_data *data)
 460 {
 461         int i;
 462         int buf;
 463         u8 send_buf = 0;
 464
 465         getsda(data);
 466         setscl(data, 1);
 467         setscl(data, 0);
 468
 469         for (i = 0; i < 8; i++) {
 470                 setscl(data, 1);
 471                 buf = getsda(data);
 472                 setscl(data, 0);
 473                 send_buf |= (buf & 0x01) << i;
 474         }
 475         setsda(data, 0);
 476
 477         return send_buf;
 478 }
 479
 480 static void tc300k_reset_for_isp(struct tc300k_data *data, bool start)
 481 {
 482         if (start) {
 483                 tc300k_led_power(data,0);
 484                 gpio_direction_input(data->pdata->gpio_int);
 485                 gpio_direction_output(data->pdata->gpio_scl, 0);
 486                 gpio_direction_output(data->pdata->gpio_sda, 0);
 487                 gpio_direction_output(data->pdata->gpio_int, 0);
 488                 tc300k_power(data,0);
 489                 msleep(100);
 490                 tc300k_power(data,1);
 491                 usleep_range(5000, 6000);
 492         } else {
 493                 tc300k_led_power(data,0);
 494                 tc300k_power(data,0);
 495                 msleep(100);
 496                 gpio_direction_output(data->pdata->gpio_scl, 1);
 497                 gpio_direction_output(data->pdata->gpio_sda, 1);
 498                 gpio_direction_output(data->pdata->gpio_int, 1);
 499                 usleep_range(10,10);
 500                 tc300k_power(data,1);
 501                 msleep(70);
 502                 tc300k_led_power(data,1);
 503                 gpio_direction_input(data->pdata->gpio_sda);
 504                 gpio_direction_input(data->pdata->gpio_scl);
 505                 gpio_direction_input(data->pdata->gpio_int);
 506                 msleep(300);
 507         }
 508 }
 509
 510 static void load(struct tc300k_data *data, u8 buff)
 511 {
 512         send_9bit(data, TC300K_LDDATA);
 513         udelay(1);
 514         send_9bit(data, buff);
 515         udelay(1);
 516 }
 517
 518 static void step(struct tc300k_data *data, u8 buff)
 519 {
 520         send_9bit(data, TC300K_CCFG);
 521         udelay(1);
 522         send_9bit(data, buff);
 523         udelay(2);
 524 }
 525
 526 static void setpc(struct tc300k_data *data, u16 addr)
 527 {
 528         u8 buf[4];
 529         int i;
 530
 531         buf[0] = 0x02;
 532         buf[1] = addr >> 8;
 533         buf[2] = addr & 0xff;
 534         buf[3] = 0x00;
 535
 536         for (i = 0; i < 4; i++)
 537                 step(data, buf[i]);
 538 }
 539
 540 static void configure_isp(struct tc300k_data *data)
 541 {
 542         u8 buf[7];
 543         int i;
 544
 545         buf[0] = 0x75;  buf[1] = 0xFC;  buf[2] = 0xAC;
 546         buf[3] = 0x75;  buf[4] = 0xFC;  buf[5] = 0x35;
 547         buf[6] = 0x00;
 548
 549         /* Step(cmd) */
 550         for (i = 0; i < 7; i++)
 551                 step(data, buf[i]);
 552 }
 553
 554 static int tc300k_erase_fw(struct tc300k_data *data)
 555 {
 556         struct i2c_client *client = data->client;
 557         int i;
 558         u8 state = 0;
 559
 560         dev_info(&client->dev, "%s\n", __func__);
 561
 562         tc300k_reset_for_isp(data, true);
 563
 564         udelay(300);
 565
 566         /* isp_enable_condition */
 567         send_9bit(data, TC300K_CSYNC1);
 568         udelay(10);
 569         send_9bit(data, TC300K_CSYNC2);
 570         udelay(10);
 571         send_9bit(data, TC300K_CSYNC3);
 572         usleep_range(150, 160);
 573
 574         state = wait_9bit(data);
 575         if (state != 0x01) {
 576                 dev_err(&client->dev, "%s isp enable error %d\n",
 577                         __func__, state);
 578                 return -1;
 579         }
 580
 581         configure_isp(data);
 582
 583         /* Full Chip Erase */
 584         send_9bit(data, TC300K_PCRST);
 585         udelay(1);
 586         send_9bit(data, TC300K_PECHIP);
 587         usleep_range(15000, 15500);
 588
 589         state = 0;
 590         for (i = 0; i < 100; i++) {
 591                 udelay(2);
 592                 send_9bit(data, TC300K_CSYNC1);
 593                 udelay(10);
 594                 send_9bit(data, TC300K_CSYNC2);
 595                 udelay(10);
 596                 send_9bit(data, TC300K_CSYNC3);
 597                 usleep_range(150, 160);
 598
 599                 state = wait_9bit(data);
 600                 if ((state & 0x04) == 0x00)
 601                         break;
 602         }
 603
 604         if (i >= 100) {
 605                 dev_err(&client->dev, "%s fail\n", __func__);
 606                 return -1;
 607         }
 608         dev_info(&client->dev, "%s success\n", __func__);
 609
 610         return 0;
 611 }
 612
 613 static int tc300k_write_fw(struct tc300k_data *data)
 614 {
 615         struct input_dev *input_dev = data->input_dev;
 616         u16 addr = 0;
 617         u8 code_data;
 618
 619         dev_info(&input_dev->dev, "%s\n", __func__);
 620
 621         setpc(data, addr);
 622         load(data, TC300K_PWDATA);
 623         send_9bit(data, TC300K_LDMODE);
 624         udelay(1);
 625
 626         while (addr < data->fw_img->fw_len) {
 627                 code_data = data->fw_img->data[addr++];
 628                 load(data, code_data);
 629                 usleep_range(20, 21);
 630         }
 631
 632         send_9bit(data, TC300K_PEDISC);
 633         udelay(1);
 634
 635         return 0;
 636 }
 637
 638
 639 static int tc300k_verify_fw(struct tc300k_data *data)
 640 {
 641         struct i2c_client *client = data->client;
 642         u16 addr = 0;
 643         u8 code_data;
 644
 645         dev_info(&client->dev, "%s\n", __func__);
 646
 647         setpc(data, addr);
 648
 649         while (addr < data->fw_img->fw_len) {
 650                 send_9bit(data, TC300K_PRDATA);
 651                 udelay(2);
 652                 code_data = wait_9bit(data);
 653                 udelay(1);
 654
 655                 if (code_data != data->fw_img->data[addr++]) {
 656                         dev_err(&client->dev,
 657                                 "%s addr : %#x data error (0x%2x)\n",
 658                                 __func__, addr - 1, code_data );
 659                         return -1;
 660                 }
 661         }
 662
 663         return 0;
 664 }
 665
 666 static int tc300k_crc_check(struct tc300k_data *data)
 667 {
 668         struct i2c_client *client = data->client;
 669         int ret;
 670         u16 checksum;
 671         u8 checksum_h, checksum_l, cmd;
 672
 673         dev_info(&client->dev, "%s\n", __func__);
 674
 675         cmd = TC300K_CMD_CAL_CHECKSUM;
 676         ret = i2c_smbus_write_byte_data(client, TC300K_CMD_ADDR, cmd);
 677         if (ret) {
 678                 dev_err(&client->dev, "%s command fail (%d)\n", __func__, ret);
 679                 return ret;
 680         }
 681
 682         msleep(TC300K_CHECKSUM_DELAY);
 683
 684         ret = i2c_smbus_read_byte_data(client, TC300K_CHECKS_H);
 685         if (ret < 0) {
 686                 dev_err(&client->dev, "%s: failed to read checksum_h (%d)\n",
 687                         __func__, ret);
 688                 return ret;
 689         }
 690         checksum_h = ret;
 691
 692         ret = i2c_smbus_read_byte_data(client, TC300K_CHECKS_L);
 693         if (ret < 0) {
 694                 dev_err(&client->dev, "%s: failed to read checksum_l (%d)\n",
 695                         __func__, ret);
 696                 return ret;
 697         }
 698         checksum_l = ret;
 699
 700         checksum = (checksum_h << 8) | checksum_l;
 701
 702         if (data->fw_img->checksum != checksum) {
 703                 dev_err(&client->dev,
 704                         "%s checksum fail - firm checksum(%d),"
 705                         " compute checksum(%d)\n", __func__,
 706                         data->fw_img->checksum, checksum);
 707                 return -1;
 708         }
 709
 710         dev_info(&client->dev, "%s success (0x%04x)\n", __func__, checksum);
 711
 712         return 0;
 713 }
 714
 715 static int tc300k_fw_update(struct tc300k_data *data)
 716 {
 717         struct i2c_client *client = data->client;
 718         int verify_retries= TC300K_RETRY_CNT;
 719         int retries = TC300K_RETRY_CNT;
 720         int ret =1;
 721
 722         dev_info(&client->dev, "%s\n", __func__);
 723         disable_irq(client->irq);
 724
 725 erase_fw:
 726         ret = tc300k_erase_fw(data);
 727         if (ret) {
 728                 if (retries--) {
 729                         dev_err(&client->dev, "%s: retry erasing fw (%d)\n",
 730                                  __func__, retries);
 731                         goto erase_fw;
 732                 } else {
 733                         dev_err(&client->dev, "%s: failed erasing fw\n",
 734                                  __func__);
 735                         goto end_tc300k_flash_fw;
 736                 }
 737         }
 738
 739         dev_info(&client->dev, "succeed in erasing fw\n");
 740         retries = TC300K_RETRY_CNT;
 741
 742 write_fw:
 743         /* Write */
 744         ret = tc300k_write_fw(data);
 745         if (ret) {
 746                 if (retries--) {
 747                         dev_err(&client->dev, "%s: retry writing fw (%d)\n",
 748                                 __func__, retries);
 749                         goto write_fw;
 750                 } else {
 751                         dev_err(&client->dev, "%s: failed writing fw\n",
 752                                  __func__);
 753                         goto end_tc300k_flash_fw;
 754                 }
 755         }
 756
 757         dev_info(&client->dev, "succeed in writing fw\n");
 758
 759         /* Verify */
 760         ret = tc300k_verify_fw(data);
 761         if (ret) {
 762                 if (verify_retries-- > 0) {
 763                         dev_err(&client->dev, "%s: retry verifing fw (%d)\n",
 764                                 __func__, verify_retries);
 765                         retries = TC300K_RETRY_CNT;
 766                         goto erase_fw;
 767                 } else {
 768                         dev_err(&client->dev, "%s: failed verifing fw\n",
 769                                  __func__);
 770                         goto end_tc300k_flash_fw;
 771                 }
 772         }
 773
 774         dev_info(&client->dev, "succeed in verifing fw\n");
 775
 776         tc300k_reset_for_isp(data, false);
 777
 778         dev_info(&client->dev, "%s: fw_ver(%#x)\n",
 779                 __func__, tc300k_get_fw_ver(data));
 780
 781         ret = tc300k_crc_check(data);
 782         if (ret) {
 783                 dev_err(&client->dev, "%s: crc check fail (%d)\n",
 784                         __func__, ret);
 785                 goto    end_tc300k_flash_fw;
 786         }
 787
 788         data->fdata->fw_flash_status = PASS;
 789
 790 end_tc300k_flash_fw:
 791
 792         enable_irq(client->irq);
 793         data->enabled = true;
 794         return ret;
 795 }
 796
 797 static int load_fw_built_in(struct tc300k_data *data)
 798 {
 799         struct i2c_client *client = data->client;
 800         int ret;
 801         char *fw_name;
 802
 803         fw_name = kasprintf(GFP_KERNEL, "%s/%s.fw",
 804                 TC300K_FW_BUILTIN_PATH,  data->pdata->fw_name);
 805
 806 //      dev_info(&client->dev, "built in fw file name: [%s]\n",fw_name);
 807         ret = request_firmware(&data->fw, fw_name, &client->dev);
 808         if (ret) {
 809                 dev_err(&client->dev,
 810                         "%s: error requesting built-in firmware (%d)\n"
 811                         , __func__, ret);
 812                 goto out;
 813         }
 814
 815         data->fw_img = (struct fw_image *)data->fw->data;
 816
 817         dev_info(&client->dev, "%s: BIN fw version=[0x%02x] size=[%d byte]\n",
 818                 __func__, data->fw_img->first_fw_ver,
 819                 data->fw_img->fw_len);
 820
 821 out:
 822         kfree(fw_name);
 823         return ret;
 824 }
 825
 826 static int load_fw_in_sdcard(struct tc300k_data *data)
 827 {
 828         struct i2c_client *client = data->client;
 829         struct tc300k_platform_data *pdata = data->pdata;
 830         struct file *fp;
 831         mm_segment_t old_fs;
 832         long nread;
 833         int len, ret;
 834
 835         char *fw_name = kasprintf(GFP_KERNEL, "%s%s.in.fw",
 836                   TC300K_FW_IN_SDCARD_PATH, pdata->fw_name);
 837
 838         old_fs = get_fs();
 839         set_fs(KERNEL_DS);
 840
 841         fp = filp_open(fw_name, O_RDONLY, S_IRUSR);
 842         if (IS_ERR(fp)) {
 843                 dev_err(&client->dev, "%s: fail to open fw in %s\n",
 844                         __func__, fw_name);
 845                 ret = -ENOENT;
 846                 goto err_open_fw;
 847         }
 848         len = fp->f_path.dentry->d_inode->i_size;
 849
 850         data->fw_img = kzalloc(len, GFP_KERNEL);
 851         if (!data->fw_img) {
 852                 dev_err(&client->dev, "%s: fail to alloc mem for fw\n",
 853                         __func__);
 854                 ret = -ENOMEM;
 855                 goto err_alloc;
 856         }
 857         nread = vfs_read(fp, (char __user *)data->fw_img, len, &fp->f_pos);
 858
 859         dev_info(&client->dev, "%s: load fw in internal sd (%ld)\n",
 860                  __func__, nread);
 861
 862         ret = 0;
 863
 864 err_alloc:
 865         filp_close(fp, NULL);
 866 err_open_fw:
 867         set_fs(old_fs);
 868         kfree(fw_name);
 869         return ret;
 870 }
 871
 872 static int tc300k_load_fw(struct tc300k_data *data, u8 fw_path)
 873 {
 874         struct i2c_client *client = data->client;
 875         int ret;
 876
 877         switch (fw_path) {
 878         case FW_BUILT_IN:
 879                 ret = load_fw_built_in(data);
 880                 break;
 881
 882         case FW_IN_SDCARD:
 883                 ret = load_fw_in_sdcard(data);
 884                 break;
 885
 886         default:
 887                 dev_err(&client->dev, "%s: invalid fw path [%d]\n",
 888                         __func__, fw_path);
 889                 return -ENOENT;
 890         }
 891
 892         if (ret) {
 893                 dev_err(&client->dev, "%s: fail to load fw in [%d][%d]\n",
 894                         __func__, fw_path, ret);
 895                 return ret;
 896         }
 897
 898         return 0;
 899 }
 900
 901 static int tc300k_unload_fw(struct tc300k_data *data, u8 fw_path)
 902 {
 903         struct i2c_client *client = data->client;
 904
 905         switch (fw_path) {
 906         case FW_BUILT_IN:
 907                 release_firmware(data->fw);
 908                 break;
 909
 910         case FW_IN_SDCARD:
 911                 kfree(data->fw_img);
 912                 break;
 913
 914         default:
 915                 dev_err(&client->dev, "%s: invalid fw path (%d)\n",
 916                         __func__, fw_path);
 917                 return -ENOENT;
 918         }
 919
 920         return 0;
 921 }
 922
 923 static int tc300k_flash_fw(struct tc300k_data *data, u8 fw_path, bool force)
 924 {
 925         struct i2c_client *client = data->client;
 926         int ret, fw_ver, module_ver;
 927
 928         dev_info(&client->dev, "%s\n", __func__);
 929
 930         ret = tc300k_load_fw(data, fw_path);
 931         if (ret) {
 932                 dev_err(&client->dev, "fail to load fw (%d)\n", ret);
 933                 return ret;
 934         }
 935
 936         data->cur_fw_path = fw_path;
 937         fw_ver = tc300k_get_fw_ver(data);
 938         module_ver = tc300k_get_module_ver(data);
 939
 940         dev_info(&client->dev, "%s: IC fw version=[0x%02x], module_ver=[0x%02x]\n",
 941                         __func__, fw_ver,module_ver);
 942
 943         if (!data->pdata->firmup) {
 944                 dev_err(&client->dev, "%s: pass firmup, h/w rev not support\n", __func__);
 945                 ret = HAVE_LATEST_FW;
 946                 goto out;
 947         }
 948
 949         if (fw_ver == TC300K_INVALID_VER) {
 950                 force = true;
 951                 dev_info(&client->dev,
 952                         "%s: Enable force_update by invalid version.\n",
 953                         __func__);
 954         }
 955
 956         if ((fw_ver >= data->fw_img->first_fw_ver) && !force) {
 957                 ret = HAVE_LATEST_FW;
 958                 data->fdata->fw_update_skip = true;
 959                 dev_info(&client->dev,
 960                         "%s: IC aleady have latest firmware.\n", __func__);
 961                 goto out;
 962         }
 963
 964         dev_info(&client->dev, "%s: fw update to %#x (from %#x) (%s)\n",
 965                         __func__, data->fw_img->first_fw_ver,
 966                         fw_ver, force ? "force":"version mismatch");
 967
 968         data->fdata->fw_update_skip = false;
 969
 970         ret = tc300k_fw_update(data);
 971         if (ret)
 972                 goto err_fw_update;
 973
 974         ret = HAVE_LATEST_FW;
 975 err_fw_update:
 976  out:
 977         tc300k_unload_fw(data, fw_path);
 978
 979         return ret;
 980 }
 981
 982 static int tc300k_load_firmware(struct tc300k_data *data)
 983 {
 984         struct i2c_client *client = data->client;
 985         int ret;
 986
 987         ret = tc300k_flash_fw(data, FW_BUILT_IN, false);
 988         if (ret)
 989                 dev_info(&client->dev, "success to flash fw (%d)\n", ret);
 990         else
 991                 dev_err(&client->dev, "fail to flash fw (%d)\n", ret);
 992
 993         return ret;
 994 }
 995
 996 static ssize_t tc300k_fw_ver_ic_show(struct device *dev,
 997                   struct device_attribute *attr, char *buf)
 998 {
 999         struct tc300k_data *data = dev_get_drvdata(dev);
1000         struct i2c_client *client = data->client;
1001         int ver;
1002         int ret;
1003
1004         if (data->enabled) {
1005                 data->fdata->fw_update_skip = 0;
1006                 ver = tc300k_get_fw_ver(data);
1007         }
1008
1009         ver = data->ic_fw_ver;
1010         if (ver < 0) {
1011                 dev_err(&client->dev, "%s: fail to read fw ver (%d)\n.",
1012                         __func__, ver);
1013                 ret = sprintf(buf, "%s\n", "error");
1014                 goto out;
1015         }
1016
1017         dev_info(&client->dev, "%s: 0x%02x\n", __func__, (u8)ver);
1018         ret = sprintf(buf, "0x%02x\n", (u8)ver);
1019 out:
1020         return ret;
1021 }
1022
1023 static ssize_t tc300k_fw_ver_src_show(struct device *dev,
1024                 struct device_attribute *attr, char *buf)
1025 {
1026         struct tc300k_data *data = dev_get_drvdata(dev);
1027         struct i2c_client *client = data->client;
1028         int ret;
1029         u16 ver;
1030
1031         if (data->enabled) {
1032                 ret = tc300k_load_fw(data, FW_BUILT_IN);
1033                 if (ret < 0) {
1034                         dev_err(&client->dev,
1035                                 "%s: fail to load fw (%d)\n.",
1036                                 __func__, ret);
1037                         ver = 0;
1038                         goto out;
1039                 }
1040         }
1041
1042         ver = data->fw_img->first_fw_ver;
1043
1044         if (data->enabled) {
1045                 ret = tc300k_unload_fw(data, FW_BUILT_IN);
1046                 if (ret < 0) {
1047                         dev_err(&client->dev,
1048                                 "%s: fail to unload fw (%d)\n.",
1049                                 __func__, ret);
1050                         ver = 0;
1051                         goto out;
1052                 }
1053         }
1054
1055 out:
1056         ret = sprintf(buf, "0x%02x\n", ver);
1057         dev_info(&client->dev, "%s: 0x%02x\n", __func__, ver);
1058         return ret;
1059 }
1060
1061 static ssize_t tc300k_fw_update_store(struct device *dev,
1062                 struct device_attribute *devattr,
1063                 const char *buf, size_t count)
1064 {
1065         struct tc300k_data *data = dev_get_drvdata(dev);
1066         struct i2c_client *client = data->client;
1067         int ret;
1068         u8 fw_path;
1069
1070         if (!data->enabled) {
1071                 dev_err(&client->dev,
1072                         "%s: device is disabled (fw_update_skip =% d)\n.",
1073                         __func__, data->fdata->fw_update_skip);
1074                 return -EPERM;
1075         }
1076
1077         switch (*buf) {
1078         case 's':
1079         case 'S':
1080                 fw_path = FW_BUILT_IN;
1081                 break;
1082         case 'i':
1083         case 'I':
1084                 fw_path = FW_IN_SDCARD;
1085                 break;
1086         default:
1087                 dev_err(&client->dev, "%s: invalid parameter %c\n.", __func__,
1088                         *buf);
1089                 return -EINVAL;
1090         }
1091
1092         data->fdata->fw_flash_status = DOWNLOADING;
1093         data->enabled = false;
1094
1095         ret = tc300k_flash_fw(data, fw_path, true);
1096         data->enabled = true;
1097         if (ret < 0) {
1098                 data->fdata->fw_flash_status = FAIL;
1099                 dev_err(&client->dev,
1100                         "%s: fail to flash fw (%d)\n.", __func__,
1101                         ret);
1102                 return ret;
1103         }
1104
1105         data->fdata->fw_flash_status = PASS;
1106
1107         return count;
1108 }
1109
1110 static ssize_t tc300k_fw_update_status_show(struct device *dev,
1111                          struct device_attribute *attr,
1112                          char *buf)
1113 {
1114         struct tc300k_data *data = dev_get_drvdata(dev);
1115         struct i2c_client *client = data->client;
1116         int ret;
1117
1118         switch (data->fdata->fw_flash_status) {
1119         case DOWNLOADING:
1120                 ret = sprintf(buf, "%s\n", TO_STRING(DOWNLOADING));
1121                 break;
1122         case FAIL:
1123                 ret = sprintf(buf, "%s\n", TO_STRING(FAIL));
1124                 break;
1125         case PASS:
1126                 ret = sprintf(buf, "%s\n", TO_STRING(PASS));
1127                 break;
1128         default:
1129                 dev_err(&client->dev, "%s: invalid status\n", __func__);
1130                 ret = 0;
1131                 goto out;
1132         }
1133
1134         dev_info(&client->dev, "%s: %#x\n", __func__,
1135                         data->fdata->fw_flash_status);
1136                         data->fdata->fw_update_skip = 0;
1137
1138 out:
1139         return ret;
1140 }
1141
1142 static int tc300k_factory_mode_enable(struct i2c_client *client, u8 cmd)
1143 {
1144         int ret;
1145
1146         ret = i2c_smbus_write_byte_data(client, TC300K_CMD_ADDR, cmd);
1147         msleep(TC300K_CMD_DELAY);
1148
1149         return ret;
1150 }
1151
1152 static ssize_t tc300k_factory_mode(struct device *dev,
1153          struct device_attribute *attr, const char *buf, size_t count)
1154 {
1155         struct tc300k_data *data = dev_get_drvdata(dev);
1156         struct i2c_client *client = data->client;
1157         int scan_buffer;
1158         int ret;
1159         u8 cmd;
1160
1161         ret = sscanf(buf, "%d", &scan_buffer);
1162         if (ret != 1) {
1163                 dev_err(&client->dev, "%s: cmd read err\n", __func__);
1164                 return count;
1165         }
1166
1167         if (!(scan_buffer == 0 || scan_buffer == 1)) {
1168                 dev_err(&client->dev, "%s: wrong command(%d)\n",
1169                         __func__, scan_buffer);
1170                 return count;
1171         }
1172
1173         if (data->factory_mode == (bool)scan_buffer) {
1174                 dev_info(&client->dev, "%s same command(%d)\n",
1175                         __func__, scan_buffer);
1176                 return count;
1177         }
1178
1179         if (scan_buffer == 1) {
1180                 dev_notice(&client->dev, "factory mode\n");
1181                 cmd = TC300K_CMD_FAC_ON;
1182         } else {
1183                 dev_notice(&client->dev, "normale mode\n");
1184                 cmd = TC300K_CMD_FAC_OFF;
1185         }
1186
1187         if ((!data->enabled)) {
1188                 dev_err(&client->dev, "can't excute %s\n", __func__);
1189                 data->factory_mode = (bool)scan_buffer;
1190                 return count;
1191         }
1192
1193         ret = tc300k_factory_mode_enable(client, cmd);
1194         if (ret < 0)
1195                 dev_err(&client->dev, "%s fail(%d)\n", __func__, ret);
1196
1197         data->factory_mode = (bool)scan_buffer;
1198
1199         return count;
1200 }
1201
1202 static ssize_t tc300k_factory_mode_show(struct device *dev,
1203                         struct device_attribute *attr, char *buf)
1204 {
1205         struct tc300k_data *data = dev_get_drvdata(dev);
1206
1207         return sprintf(buf, "%d\n", data->factory_mode);
1208 }
1209
1210 static ssize_t recent_key_show(struct device *dev,
1211                          struct device_attribute *attr,
1212                          char *buf)
1213 {
1214         struct tc300k_data *data = dev_get_drvdata(dev);
1215         struct i2c_client *client = data->client;
1216         int ret;
1217         u8 buff[8] = {0, };
1218         u16 value;
1219
1220         if (!data->enabled) {
1221                 dev_err(&client->dev, "%s: device is disabled\n.", __func__);
1222                 return -EPERM;
1223         }
1224
1225         ret = i2c_smbus_read_i2c_block_data(client, TC300K_1KEY_DATA, 8, buff);
1226         if (ret != 8) {
1227                 dev_err(&client->dev, "%s read fail(%d)\n", __func__, ret);
1228                 return -1;
1229         }
1230
1231         value = (buff[TC300K_CH_PCK_H_OFFSET] << 8) |
1232         buff[TC300K_CH_PCK_L_OFFSET];
1233
1234         return sprintf(buf, "%d\n", value);
1235 }
1236
1237 static ssize_t back_key_show(struct device *dev,
1238                          struct device_attribute *attr, char *buf)
1239 {
1240         struct tc300k_data *data = dev_get_drvdata(dev);
1241         struct i2c_client *client = data->client;
1242         int ret;
1243         int value;
1244         u8 buff[8] = {0, };
1245
1246         if (!data->enabled) {
1247                 dev_err(&client->dev, "%s: device is disabled\n.", __func__);
1248                 return -EPERM;
1249         }
1250
1251         ret = i2c_smbus_read_i2c_block_data(client, TC300K_2KEY_DATA, 8, buff);
1252         if (ret != 8) {
1253                 dev_err(&client->dev, "%s read fail(%d)\n", __func__, ret);
1254                 return -1;
1255         }
1256
1257         value = (buff[TC300K_CH_PCK_H_OFFSET] << 8) |
1258         buff[TC300K_CH_PCK_L_OFFSET];
1259
1260         return sprintf(buf, "%d\n", value);
1261 }
1262
1263 static ssize_t tc300k_recent_inner_show(struct device *dev,
1264                          struct device_attribute *attr,
1265                          char *buf)
1266 {
1267         struct tc300k_data *data = dev_get_drvdata(dev);
1268         struct i2c_client *client = data->client;
1269         int ret;
1270         u8 buff[8] = {0, };
1271         u16 value;
1272         if (!data->enabled) {
1273                 dev_err(&client->dev, "%s: device is disabled\n.", __func__);
1274                 return -EPERM;
1275         }
1276
1277         ret = i2c_smbus_read_i2c_block_data(client, TC300K_1KEY_DATA, 8, buff);
1278         if (ret != 8) {
1279                 dev_err(&client->dev, "%s read fail(%d)\n", __func__, ret);
1280                 return -1;
1281         }
1282
1283         value = (buff[TC300K_CH_PCK_H_OFFSET] << 8) |
1284         buff[TC300K_CH_PCK_L_OFFSET];
1285
1286         return sprintf(buf, "%d\n", value);
1287 }
1288
1289 static ssize_t tc300k_recent_outer_show(struct device *dev,
1290                          struct device_attribute *attr,
1291                          char *buf)
1292 {
1293         struct tc300k_data *data = dev_get_drvdata(dev);
1294         struct i2c_client *client = data->client;
1295         int ret;
1296         u8 buff[8] = {0, };
1297         u16 value;
1298
1299         if (!data->enabled) {
1300                 dev_err(&client->dev, "%s: device is disabled\n.", __func__);
1301                 return -EPERM;
1302         }
1303
1304         ret = i2c_smbus_read_i2c_block_data(client, TC300K_3KEY_DATA, 8, buff);
1305         if (ret != 8) {
1306                 dev_err(&client->dev, "%s read fail(%d)\n", __func__, ret);
1307                 return -1;
1308         }
1309
1310         value = (buff[TC300K_CH_PCK_H_OFFSET] << 8) |
1311         buff[TC300K_CH_PCK_L_OFFSET];
1312
1313         return sprintf(buf, "%d\n", value);
1314 }
1315
1316 static ssize_t tc300k_back_inner_show(struct device *dev,
1317                          struct device_attribute *attr, char *buf)
1318 {
1319         struct tc300k_data *data = dev_get_drvdata(dev);
1320         struct i2c_client *client = data->client;
1321         int ret;
1322         int value;
1323         u8 buff[8] = {0, };
1324
1325         if (!data->enabled) {
1326                 dev_err(&client->dev, "%s: device is disabled\n.", __func__);
1327                 return -EPERM;
1328         }
1329
1330         ret = i2c_smbus_read_i2c_block_data(client, TC300K_2KEY_DATA, 8, buff);
1331         if (ret != 8) {
1332                 dev_err(&client->dev, "%s read fail(%d)\n", __func__, ret);
1333                 return -1;
1334         }
1335
1336         value = (buff[TC300K_CH_PCK_H_OFFSET] << 8) |
1337         buff[TC300K_CH_PCK_L_OFFSET];
1338
1339         return sprintf(buf, "%d\n", value);
1340 }
1341
1342 static ssize_t tc300k_back_outer_show(struct device *dev,
1343                          struct device_attribute *attr, char *buf)
1344 {
1345         struct tc300k_data *data = dev_get_drvdata(dev);
1346         struct i2c_client *client = data->client;
1347         int ret;
1348         int value;
1349         u8 buff[8] = {0, };
1350
1351         if (!data->enabled) {
1352                 dev_err(&client->dev, "%s: device is disabled\n.", __func__);
1353                 return -EPERM;
1354         }
1355
1356         ret = i2c_smbus_read_i2c_block_data(client, TC300K_4KEY_DATA, 8, buff);
1357         if (ret != 8) {
1358                 dev_err(&client->dev, "%s read fail(%d)\n", __func__, ret);
1359                 return -1;
1360         }
1361
1362         value = (buff[TC300K_CH_PCK_H_OFFSET] << 8) |
1363         buff[TC300K_CH_PCK_L_OFFSET];
1364
1365         return sprintf(buf, "%d\n", value);
1366 }
1367
1368
1369 static ssize_t recent_key_raw(struct device *dev,
1370         struct device_attribute *attr, char *buf)
1371 {
1372         struct tc300k_data *data = dev_get_drvdata(dev);
1373         struct i2c_client *client = data->client;
1374         int ret;
1375         u8 buff[8] = {0, };
1376         int value;
1377
1378         if (!data->enabled) {
1379                 dev_err(&client->dev, "can't excute %s\n", __func__);
1380                 return -1;
1381         }
1382
1383         ret = i2c_smbus_read_i2c_block_data(client, TC300K_1KEY_DATA, 8, buff);
1384         if (ret != 8) {
1385                 dev_err(&client->dev, "%s read fail(%d)\n", __func__, ret);
1386                 return -1;
1387         }
1388
1389         value = (buff[TC300K_RAW_H_OFFSET] << 8) |
1390         buff[TC300K_RAW_L_OFFSET];
1391
1392         return sprintf(buf, "%d\n", value);
1393 }
1394
1395 static ssize_t back_key_raw(struct device *dev,
1396         struct device_attribute *attr, char *buf)
1397 {
1398         struct tc300k_data *data = dev_get_drvdata(dev);
1399         struct i2c_client *client = data->client;
1400         int ret;
1401         u8 buff[8] = {0, };
1402         int value;
1403
1404         if ((!data->enabled)) {
1405                 dev_err(&client->dev, "can't excute %s\n", __func__);
1406                 return -1;
1407         }
1408
1409         ret = i2c_smbus_read_i2c_block_data(client, TC300K_2KEY_DATA, 8, buff);
1410         if (ret != 8) {
1411                 dev_err(&client->dev, "%s read fail(%d)\n", __func__, ret);
1412                 return -1;
1413         }
1414
1415         value = (buff[TC300K_RAW_H_OFFSET] << 8) |
1416         buff[TC300K_RAW_L_OFFSET];
1417
1418         return sprintf(buf, "%d\n", value);
1419 }
1420
1421 static ssize_t tc300k_recent_raw_inner_show(struct device *dev,
1422         struct device_attribute *attr, char *buf)
1423 {
1424         struct tc300k_data *data = dev_get_drvdata(dev);
1425         struct i2c_client *client = data->client;
1426         int ret;
1427         u8 buff[8] = {0, };
1428         int value;
1429
1430         if (!data->enabled) {
1431                 dev_err(&client->dev, "can't excute %s\n", __func__);
1432                 return -1;
1433         }
1434
1435         ret = i2c_smbus_read_i2c_block_data(client, TC300K_1KEY_DATA, 8, buff);
1436         if (ret != 8) {
1437                 dev_err(&client->dev, "%s read fail(%d)\n", __func__, ret);
1438                 return -1;
1439         }
1440
1441         value = (buff[TC300K_RAW_H_OFFSET] << 8) |
1442         buff[TC300K_RAW_L_OFFSET];
1443
1444         return sprintf(buf, "%d\n", value);
1445 }
1446
1447 static ssize_t tc300k_recent_raw_outer_show(struct device *dev,
1448         struct device_attribute *attr, char *buf)
1449 {
1450         struct tc300k_data *data = dev_get_drvdata(dev);
1451         struct i2c_client *client = data->client;
1452         int value, ret;
1453         u8 buff[8] = {0, };
1454
1455         if (!data->enabled) {
1456                 dev_err(&client->dev, "can't excute %s\n", __func__);
1457                 return -1;
1458         }
1459
1460         ret = i2c_smbus_read_i2c_block_data(client, TC300K_3KEY_DATA, 8, buff);
1461         if (ret != 8) {
1462                 dev_err(&client->dev, "%s read fail(%d)\n", __func__, ret);
1463                 return -1;
1464         }
1465
1466         value = (buff[TC300K_RAW_H_OFFSET] << 8) |
1467         buff[TC300K_RAW_L_OFFSET];
1468
1469         return sprintf(buf, "%d\n", value);
1470 }
1471
1472 static ssize_t tc300k_back_raw_inner_show(struct device *dev,
1473         struct device_attribute *attr, char *buf)
1474 {
1475         struct tc300k_data *data = dev_get_drvdata(dev);
1476         struct i2c_client *client = data->client;
1477         int ret, value;
1478         u8 buff[8] = {0, };
1479
1480         if ((!data->enabled)) {
1481                 dev_err(&client->dev, "can't excute %s\n", __func__);
1482                 return -1;
1483         }
1484
1485         ret = i2c_smbus_read_i2c_block_data(client, TC300K_2KEY_DATA, 8, buff);
1486         if (ret != 8) {
1487                 dev_err(&client->dev, "%s read fail(%d)\n", __func__, ret);
1488                 return -1;
1489         }
1490
1491         value = (buff[TC300K_RAW_H_OFFSET] << 8) |
1492         buff[TC300K_RAW_L_OFFSET];
1493
1494         return sprintf(buf, "%d\n", value);
1495 }
1496
1497 static ssize_t tc300k_back_raw_outer_show(struct device *dev,
1498         struct device_attribute *attr, char *buf)
1499 {
1500         struct tc300k_data *data = dev_get_drvdata(dev);
1501         struct i2c_client *client = data->client;
1502         int ret;
1503         u8 buff[8] = {0, };
1504         int value;
1505
1506         if ((!data->enabled)) {
1507                 dev_err(&client->dev, "can't excute %s\n", __func__);
1508                 return -1;
1509         }
1510
1511         ret = i2c_smbus_read_i2c_block_data(client, TC300K_4KEY_DATA, 8, buff);
1512         if (ret != 8) {
1513                 dev_err(&client->dev, "%s read fail(%d)\n", __func__, ret);
1514                 return -1;
1515         }
1516
1517         value = (buff[TC300K_RAW_H_OFFSET] << 8) |
1518         buff[TC300K_RAW_L_OFFSET];
1519
1520         return sprintf(buf, "%d\n", value);
1521 }
1522
1523 static ssize_t tc300k_threshold_show(struct device *dev,
1524         struct device_attribute *attr, char *buf)
1525 {
1526         struct tc300k_data *data = dev_get_drvdata(dev);
1527         struct i2c_client *client = data->client;
1528         int ret;
1529         u8 buff[8] = {0, };
1530         int thr_recent, thr_back;
1531
1532         if (!data->enabled) {
1533                 dev_err(&client->dev, "%s: device is disabled\n.", __func__);
1534                 return -EPERM;
1535         }
1536
1537         ret = i2c_smbus_read_i2c_block_data(client, TC300K_1KEY_DATA, 8, buff);
1538         if (ret != 8) {
1539                 dev_err(&client->dev, "%s: thr_recent read fail(%d)\n", __func__, ret);
1540                 return -1;
1541         }
1542
1543         thr_recent = (buff[TC300K_THRES_H_OFFSET] << 8) |
1544         buff[TC300K_THRES_L_OFFSET];
1545
1546         ret = i2c_smbus_read_i2c_block_data(client, TC300K_2KEY_DATA, 8, buff);
1547         if (ret != 8) {
1548                 dev_err(&client->dev, "%s: thr_back read fail(%d)\n", __func__, ret);
1549                 return -1;
1550         }
1551
1552         thr_back = (buff[TC300K_THRES_H_OFFSET] << 8) |
1553         buff[TC300K_THRES_L_OFFSET];
1554
1555         dev_info(&client->dev, "%s: %d, %d\n", __func__, thr_recent, thr_back);
1556
1557         return sprintf(buf, "%d, %d\n", thr_recent, thr_back);
1558 }
1559
1560 static ssize_t tc300k_recent_threshold_inner_show(struct device *dev,
1561         struct device_attribute *attr, char *buf)
1562 {
1563         struct tc300k_data *data = dev_get_drvdata(dev);
1564         struct i2c_client *client = data->client;
1565         int ret;
1566         u8 buff[8] = {0, };
1567         int thr_recent_inner;
1568
1569         if (!data->enabled) {
1570                 dev_err(&client->dev, "%s: device is disabled\n.", __func__);
1571                 return -EPERM;
1572         }
1573
1574         ret = i2c_smbus_read_i2c_block_data(client, TC300K_1KEY_DATA, 8, buff);
1575         if (ret != 8) {
1576                 dev_err(&client->dev, "%s: thr_recent inner read fail(%d)\n", __func__, ret);
1577                 return -1;
1578         }
1579
1580         thr_recent_inner = (buff[TC300K_THRES_H_OFFSET] << 8) |
1581         buff[TC300K_THRES_L_OFFSET];
1582
1583         dev_info(&client->dev, "%s: %d\n", __func__, thr_recent_inner);
1584
1585         return sprintf(buf, "%d\n", thr_recent_inner);
1586 }
1587
1588 static ssize_t tc300k_recent_threshold_outer_show(struct device *dev,
1589         struct device_attribute *attr, char *buf)
1590 {
1591         struct tc300k_data *data = dev_get_drvdata(dev);
1592         struct i2c_client *client = data->client;
1593         int ret;
1594         u8 buff[8] = {0, };
1595         int thr_recent_outer;
1596
1597         if (!data->enabled) {
1598                 dev_err(&client->dev, "%s: device is disabled\n.", __func__);
1599                 return -EPERM;
1600         }
1601
1602         ret = i2c_smbus_read_i2c_block_data(client, TC300K_3KEY_DATA, 8, buff);
1603         if (ret != 8) {
1604                 dev_err(&client->dev, "%s: thr_recent outer read fail(%d)\n", __func__, ret);
1605                 return -1;
1606         }
1607
1608         thr_recent_outer = (buff[TC300K_THRES_H_OFFSET] << 8) |
1609         buff[TC300K_THRES_L_OFFSET];
1610
1611         dev_info(&client->dev, "%s: %d\n", __func__, thr_recent_outer);
1612
1613         return sprintf(buf, "%d\n", thr_recent_outer);
1614 }
1615
1616 static ssize_t tc300k_back_threshold_inner_show(struct device *dev,
1617         struct device_attribute *attr, char *buf)
1618 {
1619         struct tc300k_data *data = dev_get_drvdata(dev);
1620         struct i2c_client *client = data->client;
1621         int ret;
1622         u8 buff[8] = {0, };
1623         int thr_back_inner;
1624
1625         if (!data->enabled) {
1626                 dev_err(&client->dev, "%s: device is disabled\n.", __func__);
1627                 return -EPERM;
1628         }
1629
1630         ret = i2c_smbus_read_i2c_block_data(client, TC300K_2KEY_DATA, 8, buff);
1631         if (ret != 8) {
1632                 dev_err(&client->dev, "%s: thr_back inner read fail(%d)\n", __func__, ret);
1633                 return -1;
1634         }
1635
1636         thr_back_inner = (buff[TC300K_THRES_H_OFFSET] << 8) |
1637         buff[TC300K_THRES_L_OFFSET];
1638
1639         dev_info(&client->dev, "%s: %d\n", __func__, thr_back_inner);
1640
1641         return sprintf(buf, "%d\n", thr_back_inner);
1642 }
1643
1644 static ssize_t tc300k_back_threshold_outer_show(struct device *dev,
1645         struct device_attribute *attr, char *buf)
1646 {
1647         struct tc300k_data *data = dev_get_drvdata(dev);
1648         struct i2c_client *client = data->client;
1649         int ret;
1650         u8 buff[8] = {0, };
1651         int thr_back_outer;
1652
1653         if (!data->enabled) {
1654                 dev_err(&client->dev, "%s: device is disabled\n.", __func__);
1655                 return -EPERM;
1656         }
1657
1658         ret = i2c_smbus_read_i2c_block_data(client, TC300K_4KEY_DATA, 8, buff);
1659         if (ret != 8) {
1660                 dev_err(&client->dev, "%s: thr_back read fail(%d)\n", __func__, ret);
1661                 return -1;
1662         }
1663
1664         thr_back_outer = (buff[TC300K_THRES_H_OFFSET] << 8) |
1665         buff[TC300K_THRES_L_OFFSET];
1666
1667         dev_info(&client->dev, "%s: %d\n", __func__, thr_back_outer);
1668
1669         return sprintf(buf, "%d\n", thr_back_outer);
1670 }
1671
1672 static int tc300k_glove_mode_enable(struct i2c_client *client, u8 cmd)
1673 {
1674         int ret;
1675
1676         ret = i2c_smbus_write_byte_data(client, TC300K_CMD_ADDR, cmd);
1677         msleep(TC300K_CMD_DELAY);
1678
1679         return ret;
1680 }
1681
1682 static ssize_t tc300k_glove_mode(struct device *dev,
1683          struct device_attribute *attr, const char *buf, size_t count)
1684 {
1685         struct tc300k_data *data = dev_get_drvdata(dev);
1686         struct i2c_client *client = data->client;
1687         int scan_buffer;
1688         int ret;
1689         u8 cmd;
1690
1691         ret = sscanf(buf, "%d", &scan_buffer);
1692         if (ret != 1) {
1693                 dev_err(&client->dev, "%s: cmd read err\n", __func__);
1694                 return count;
1695         }
1696
1697         if (!(scan_buffer == 0 || scan_buffer == 1)) {
1698                 dev_err(&client->dev, "%s: wrong command(%d)\n",
1699                         __func__, scan_buffer);
1700                 return count;
1701         }
1702
1703         if (data->glove_mode == (bool)scan_buffer) {
1704                 dev_info(&client->dev, "%s same command(%d)\n",
1705                         __func__, scan_buffer);
1706                 return count;
1707         }
1708
1709         if (scan_buffer == 1) {
1710                 dev_notice(&client->dev, "factory mode\n");
1711                 cmd = TC300K_CMD_GLOVE_ON;
1712         } else {
1713                 dev_notice(&client->dev, "normale mode\n");
1714                 cmd = TC300K_CMD_GLOVE_OFF;
1715         }
1716
1717         if (!data->enabled) {
1718                 dev_err(&client->dev, "can't excute %s\n", __func__);
1719                 data->glove_mode = (bool)scan_buffer;
1720                 return count;
1721         }
1722
1723         ret = tc300k_glove_mode_enable(client, cmd);
1724         if (ret < 0)
1725                 dev_err(&client->dev, "%s fail(%d)\n", __func__, ret);
1726
1727         data->glove_mode = (bool)scan_buffer;
1728
1729         return count;
1730 }
1731
1732 static ssize_t tc300k_glove_mode_show(struct device *dev,
1733         struct device_attribute *attr, char *buf)
1734 {
1735         struct tc300k_data *data = dev_get_drvdata(dev);
1736
1737         return sprintf(buf, "%d\n", data->glove_mode);
1738 }
1739
1740 static ssize_t tc300k_modecheck_show(struct device *dev,
1741         struct device_attribute *attr, char *buf)
1742 {
1743         struct tc300k_data *data = dev_get_drvdata(dev);
1744         struct i2c_client *client = data->client;
1745         int ret;
1746         u8 mode, glove, factory;
1747
1748         if (!data->enabled) {
1749                 dev_err(&client->dev, "can't excute %s\n", __func__);
1750                 return -EPERM;
1751         }
1752
1753         ret = i2c_smbus_read_byte_data(client, TC300K_MODE);
1754         if (ret < 0) {
1755                 dev_err(&client->dev, "%s: failed to read threshold_h (%d)\n",
1756                         __func__, ret);
1757                 return ret;
1758         }
1759
1760         mode = ret;
1761         glove = ((mode & 0xf0) >> 4);
1762         factory = mode & 0x0f;
1763
1764         return sprintf(buf, "glove:%d, factory:%d\n", glove, factory);
1765 }
1766
1767 static DEVICE_ATTR(touchkey_threshold, S_IRUGO, tc300k_threshold_show, NULL);
1768 static DEVICE_ATTR(touchkey_firm_version_panel, S_IRUGO | S_IWUSR | S_IWGRP,
1769         tc300k_fw_ver_ic_show, NULL);
1770 static DEVICE_ATTR(touchkey_firm_version_phone, S_IRUGO | S_IWUSR | S_IWGRP,
1771         tc300k_fw_ver_src_show, NULL);
1772 static DEVICE_ATTR(touchkey_firm_update, S_IRUGO | S_IWUSR | S_IWGRP,
1773         NULL, tc300k_fw_update_store);
1774 static DEVICE_ATTR(touchkey_firm_update_status, S_IRUGO,
1775         tc300k_fw_update_status_show, NULL);
1776 static DEVICE_ATTR(touchkey_recent, S_IRUGO, recent_key_show, NULL);
1777 static DEVICE_ATTR(touchkey_back, S_IRUGO, back_key_show, NULL);
1778 static DEVICE_ATTR(touchkey_raw_recent, S_IRUGO, recent_key_raw, NULL);
1779 static DEVICE_ATTR(touchkey_raw_back, S_IRUGO, back_key_raw, NULL);
1780 static DEVICE_ATTR(glove_mode, S_IRUGO | S_IWUSR | S_IWGRP,
1781         tc300k_glove_mode_show, tc300k_glove_mode);
1782 static DEVICE_ATTR(touchkey_factory_mode, S_IRUGO | S_IWUSR | S_IWGRP,
1783         tc300k_factory_mode_show, tc300k_factory_mode);
1784 static DEVICE_ATTR(modecheck, S_IRUGO, tc300k_modecheck_show, NULL);
1785 static DEVICE_ATTR(touchkey_recent_threshold_inner, S_IRUGO, tc300k_recent_threshold_inner_show, NULL);
1786 static DEVICE_ATTR(touchkey_recent_threshold_outer, S_IRUGO, tc300k_recent_threshold_outer_show, NULL);
1787 static DEVICE_ATTR(touchkey_back_threshold_inner, S_IRUGO, tc300k_back_threshold_inner_show, NULL);
1788 static DEVICE_ATTR(touchkey_back_threshold_outer, S_IRUGO, tc300k_back_threshold_outer_show, NULL);
1789 static DEVICE_ATTR(touchkey_recent_raw_inner, S_IRUGO, tc300k_recent_raw_inner_show, NULL);
1790 static DEVICE_ATTR(touchkey_recent_raw_outer, S_IRUGO, tc300k_recent_raw_outer_show, NULL);
1791 static DEVICE_ATTR(touchkey_back_raw_inner, S_IRUGO, tc300k_back_raw_inner_show, NULL);
1792 static DEVICE_ATTR(touchkey_back_raw_outer, S_IRUGO, tc300k_back_raw_outer_show, NULL);
1793 static DEVICE_ATTR(touchkey_recent_inner, S_IRUGO, tc300k_recent_inner_show, NULL);
1794 static DEVICE_ATTR(touchkey_recent_outer, S_IRUGO, tc300k_recent_outer_show, NULL);
1795 static DEVICE_ATTR(touchkey_back_inner, S_IRUGO, tc300k_back_inner_show, NULL);
1796 static DEVICE_ATTR(touchkey_back_outer, S_IRUGO, tc300k_back_outer_show, NULL);
1797
1798 static struct attribute *touchkey_attributes[] = {
1799         &dev_attr_touchkey_threshold.attr,
1800         &dev_attr_touchkey_firm_version_panel.attr,
1801         &dev_attr_touchkey_firm_version_phone.attr,
1802         &dev_attr_touchkey_firm_update.attr,
1803         &dev_attr_touchkey_firm_update_status.attr,
1804         &dev_attr_touchkey_recent.attr,
1805         &dev_attr_touchkey_back.attr,
1806         &dev_attr_touchkey_raw_recent.attr,
1807         &dev_attr_touchkey_raw_back.attr,
1808         &dev_attr_touchkey_factory_mode.attr,
1809         &dev_attr_glove_mode.attr,
1810         &dev_attr_modecheck.attr,
1811         &dev_attr_touchkey_recent_threshold_inner.attr,
1812         &dev_attr_touchkey_recent_threshold_outer.attr,
1813         &dev_attr_touchkey_back_threshold_inner.attr,
1814         &dev_attr_touchkey_back_threshold_outer.attr,
1815         &dev_attr_touchkey_recent_raw_inner.attr,
1816         &dev_attr_touchkey_recent_raw_outer.attr,
1817         &dev_attr_touchkey_back_raw_inner.attr,
1818         &dev_attr_touchkey_back_raw_outer.attr,
1819         &dev_attr_touchkey_recent_inner.attr,
1820         &dev_attr_touchkey_recent_outer.attr,
1821         &dev_attr_touchkey_back_inner.attr,
1822         &dev_attr_touchkey_back_outer.attr,
1823         NULL,
1824 };
1825
1826 static struct attribute_group touchkey_attr_group = {
1827         .attrs = touchkey_attributes,
1828 };
1829
1830 #ifdef CONFIG_PM
1831 static void tc300k_input_close(struct input_dev *dev)
1832 {
1833         struct tc300k_data *data = input_get_drvdata(dev);
1834         struct i2c_client *client = data->client;
1835         int i;
1836
1837         mutex_lock(&data->lock);
1838
1839         if (unlikely(wake_lock_active(&data->fw_wake_lock))) {
1840                 dev_info(&data->client->dev,
1841                         "%s, now fw updating. suspend "
1842                          "control is ignored.\n", __func__);
1843                 goto out;
1844         }
1845
1846         if (!data->enabled) {
1847                 dev_info(&client->dev,
1848                         "%s, already disabled.\n", __func__);
1849                 goto out;
1850         }
1851
1852         disable_irq(client->irq);
1853         data->enabled = false;
1854
1855         /* report not released key */
1856         for (i = 0; i < data->num_key; i++)
1857                 input_report_key(data->input_dev, data->keycodes[i], 0);
1858
1859         input_sync(data->input_dev);
1860
1861         tc300k_led_power(data,false);
1862         tc300k_power(data,0);
1863         data->led_on = false;
1864 out:
1865         mutex_unlock(&data->lock);
1866         dev_info(&client->dev, "%s\n", __func__);
1867
1868         return;
1869 }
1870
1871 static int tc300k_input_open(struct input_dev *dev)
1872 {
1873         struct tc300k_data *data = input_get_drvdata(dev);
1874         struct i2c_client *client = data->client;
1875         int ret;
1876         u8 cmd;
1877
1878         mutex_lock(&data->lock);
1879
1880         if (unlikely(wake_lock_active(&data->fw_wake_lock))) {
1881                 dev_info(&client->dev, "%s, now fw updating. resume "
1882                          "control is ignored.\n", __func__);
1883                 goto out;
1884         }
1885
1886         if (data->enabled) {
1887                 dev_info(&client->dev, "%s, already enabled.\n", __func__);
1888                 goto out;
1889         }
1890
1891         if (data->pinctrl) {
1892                 ret = tkey_pinctrl_configure(data, false);
1893                 if (ret)
1894                         dev_err(&client->dev, "%s: cannot set pinctrl state\n", __func__);
1895         }
1896
1897         tc300k_led_power(data,true);
1898         tc300k_power(data,1);
1899         msleep(5);
1900         if (data->pinctrl) {
1901                 ret = tkey_pinctrl_configure(data, true);
1902                 if (ret)
1903                         pr_err("%s: cannot set pinctrl state\n", __func__);
1904         }
1905
1906         msleep(200 - 5);
1907         enable_irq(client->irq);
1908         data->enabled = true;
1909         if (data->led_on == true) {
1910                 data->led_on = false;
1911                 dev_notice(&client->dev, "led on(resume)\n");
1912                 cmd = TC300K_CMD_LED_ON;
1913                 ret = i2c_smbus_write_byte_data(client, TC300K_CMD_ADDR, cmd);
1914                 if (ret < 0)
1915                         dev_err(&client->dev, "%s led on fail(%d)\n", __func__, ret);
1916                 else
1917                         msleep(TC300K_CMD_DELAY);
1918         }
1919
1920         if (data->glove_mode) {
1921                 ret = tc300k_glove_mode_enable(client, TC300K_CMD_GLOVE_ON);
1922                 if (ret < 0)
1923                         dev_err(&client->dev, "%s glovemode fail(%d)\n", __func__, ret);
1924         }
1925
1926         if (data->factory_mode) {
1927                 ret = tc300k_factory_mode_enable(client, TC300K_CMD_FAC_ON);
1928                 if (ret < 0)
1929                         dev_err(&client->dev, "%s factorymode fail(%d)\n", __func__, ret);
1930         }
1931 out:
1932         mutex_unlock(&data->lock);
1933         data->release_cnt = 0;
1934         dev_info(&client->dev, "%s\n", __func__);
1935         return 0;
1936 }
1937 #endif
1938
1939 static irqreturn_t tc300k_interrupt(int irq, void *dev_id)
1940 {
1941         struct tc300k_data *data = dev_id;
1942         struct i2c_client *client = data->client;
1943         u32 key_val;
1944         int i;
1945
1946         if (!data->enabled) {
1947                 dev_err(&client->dev, "%s: device is not enabled.\n", __func__);
1948                 goto out;
1949         }
1950
1951         key_val = i2c_smbus_read_byte_data(client, TC300K_KEYCODE);
1952         if (!key_val) {
1953                 dev_err(&client->dev, "failed to read key data (%d)\n", key_val);
1954                 goto out;
1955         }
1956
1957         dev_dbg(&client->dev, "%s: key_value=[0x%x]\n", __func__, key_val);
1958
1959         for (i = 0 ; i < data->num_key*2; i++) {
1960                 if ((key_val & data->tsk_ev_val[i].tsk_bitmap)) {
1961                         input_report_key(data->input_dev,
1962                                 data->tsk_ev_val[i].tsk_keycode,
1963                                 data->tsk_ev_val[i].tsk_status);
1964
1965                         if (!data->tsk_ev_val[i].tsk_status)
1966                                 data->release_cnt++;
1967
1968                         dev_info(&client->dev, "%s:[%s] %s\n", __func__,
1969                                 data->tsk_ev_val[i].tsk_status? "P" : "R",
1970                                 data->tsk_ev_val[i].tsk_keyname);
1971                 }
1972         }
1973         input_sync(data->input_dev);
1974
1975 out:
1976         return IRQ_HANDLED;
1977 }
1978
1979 static int tc300k_init_interface(struct tc300k_data *data)
1980 {
1981         struct i2c_client *client = data->client;
1982         int ret;
1983
1984         data->fdata->dummy_dev = device_create(sec_class, NULL,
1985                 MKDEV(SEC_DEV_TOUCHKEY_MAJOR, SEC_DEV_TOUCHKEY_MINOR),
1986                 data, TC300K_DEVICE);
1987         if (IS_ERR(data->fdata->dummy_dev)) {
1988         dev_err(&client->dev, "Failed to create fac tsp temp dev\n");
1989         ret = -ENODEV;
1990         data->fdata->dummy_dev = NULL;
1991         goto err_create_sec_class_dev;
1992         }
1993
1994         ret = sysfs_create_group(&data->fdata->dummy_dev->kobj,
1995                  &touchkey_attr_group);
1996         if (ret) {
1997         dev_err(&client->dev, "%s: failed to create fac_attr_group "
1998                 "(%d)\n", __func__, ret);
1999         ret = (ret > 0) ? -ret : ret;
2000         goto err_create_fac_attr_group;
2001         }
2002
2003         return 0;
2004
2005         sysfs_remove_group(&data->fdata->dummy_dev->kobj,
2006                 &touchkey_attr_group);
2007 err_create_fac_attr_group:
2008         device_destroy(sec_class, data->fdata->dummy_dev->devt);
2009 err_create_sec_class_dev:
2010         return ret;
2011 }
2012
2013 #ifdef CONFIG_SLEEP_MONITOR
2014 #define PRETTY_MAX      14
2015 #define STATE_BIT       24
2016 #define CNT_MASK        0xffff
2017 #define STATE_MASK      0xff
2018
2019 static int tc300k_get_sleep_monitor_cb(void* priv, unsigned int *raw_val, int check_level, int caller_type);
2020
2021 static struct sleep_monitor_ops  tc300k_sleep_monitor_ops = {
2022          .read_cb_func =  tc300k_get_sleep_monitor_cb,
2023 };
2024
2025 static int tc300k_get_sleep_monitor_cb(void* priv, unsigned int *raw_val, int check_level, int caller_type)
2026 {
2027         struct tc300k_data *data = priv;
2028         struct i2c_client *client = data->client;
2029         int state = DEVICE_UNKNOWN;
2030         int pwr_mode;
2031         int pretty;
2032
2033         if (check_level == SLEEP_MONITOR_CHECK_SOFT) {
2034                 if (data->enabled)
2035                         state = DEVICE_ON_ACTIVE1;
2036                 else
2037                         state = DEVICE_POWER_OFF;
2038         } else if (check_level == SLEEP_MONITOR_CHECK_HARD) {
2039                 if (data->enabled)
2040                         state = DEVICE_ON_ACTIVE1;
2041                 else
2042                         state = DEVICE_POWER_OFF;
2043         }
2044
2045         *raw_val = ((state & STATE_MASK) << STATE_BIT) |\
2046                         (data->release_cnt & CNT_MASK);
2047
2048         if (data->release_cnt > PRETTY_MAX)
2049                 pretty = PRETTY_MAX;
2050         else
2051                 pretty = data->release_cnt;
2052
2053         dev_dbg(&client->dev, "%s: raw_val[0x%08x], check_level[%d], release_cnt[%d], state[%d], pretty[%d]\n",
2054                 __func__, *raw_val, check_level, data->release_cnt, state, pretty);
2055
2056         return pretty;
2057 }
2058 #endif
2059
2060 #ifdef CONFIG_OF
2061 static int tc300k_parse_dt_keycodes(struct device *dev, char *name,
2062                                 struct tc300k_platform_data *pdata)
2063 {
2064         struct property *prop;
2065         struct device_node *np = dev->of_node;
2066         int rc = 0, i;
2067
2068         prop = of_find_property(np, name, NULL);
2069         if (!prop)
2070                 return -EINVAL;
2071         if (!prop->value)
2072                 return -ENODATA;
2073
2074         pdata->num_key = prop->length / sizeof(u32);
2075
2076         rc = of_property_read_u32_array(np, name, pdata->keycodes, pdata->num_key);
2077         if (rc && (rc != -EINVAL)) {
2078                 dev_err(dev, "%s: Unable to read %s\n", __func__, name);
2079                 return rc;
2080         }
2081
2082         for (i = 0; i < pdata->num_key; i++)
2083                 dev_info(dev, "%s: keycode[%d] = [%d]\n",
2084                         __func__, i, pdata->keycodes[i]);
2085
2086         return 0;
2087 }
2088
2089
2090 static int tc300k_parse_dt(struct device *dev,
2091                 struct tc300k_platform_data *pdata)
2092 {
2093         struct device_node *np = dev->of_node;
2094         int rc;
2095
2096 //      pdata->num_key =ARRAY_SIZE(tc300k_keycodes);
2097 //      pdata->keycodes = tc300k_keycodes;
2098
2099         rc = tc300k_parse_dt_keycodes(dev, "coreriver,keycodes", pdata);
2100         if (rc) {
2101                 dev_err(dev, "%s: Unable to read keycodes rc = %d\n", __func__, rc);
2102                 return rc;
2103         }
2104
2105         pdata->gpio_en = of_get_named_gpio_flags(np, "coreriver,vcc_en-gpio", 0, &pdata->vcc_gpio_flags);
2106         pdata->gpio_scl = of_get_named_gpio_flags(np, "coreriver,scl-gpio", 0, &pdata->scl_gpio_flags);
2107         pdata->gpio_sda = of_get_named_gpio_flags(np, "coreriver,sda-gpio", 0, &pdata->sda_gpio_flags);
2108         pdata->gpio_int = of_get_named_gpio_flags(np, "coreriver,irq-gpio", 0, &pdata->irq_gpio_flags);
2109         pdata->firmup = of_property_read_bool(np, "coreriver,firm-up");
2110         pdata->gpio_2p8_en = of_get_named_gpio_flags(np, "coreriver,vcc_en-gpio2p8", 0, &pdata->vcc_gpio2p8_flags);
2111
2112         rc = of_property_read_string(np, "coreriver,fw-name", &pdata->fw_name);
2113         if (rc < 0) {
2114                 dev_err(dev, "%s: Unable to read fw-name. rc = %d\n", __func__, rc);
2115         }
2116
2117         rc = of_property_read_string(np, "coreriver,vcc_en_ldo_name", &pdata->vcc_en_ldo_name);
2118         if (rc < 0) {
2119                 dev_err(dev, "%s: Unable to read vcc_en_ldo_name. rc = %d\n", __func__, rc);
2120         }
2121
2122         rc = of_property_read_string(np, "coreriver,vdd_led_ldo_name", &pdata->vdd_led_ldo_name);
2123         if (rc < 0) {
2124                 dev_err(dev, "%s: Unable to read vdd_led_ldo_name. rc = %d\n", __func__, rc);
2125         }
2126
2127 //      dev_info(dev, "%s: fw-name: [%s]\n", __func__, pdata->fw_name);
2128         dev_info(dev, "%s: gpio_en = [%d], tkey_scl= [%d], tkey_sda= [%d], tkey_int= [%d], firmup= [%d]\n",
2129                 __func__, pdata->gpio_en, pdata->gpio_scl, pdata->gpio_sda, pdata->gpio_int, pdata->firmup);
2130
2131         return 0;
2132 }
2133 #else
2134 static int tc300k_parse_dt(struct device *dev,
2135                 struct tc300k_platform_data *pdata)
2136 {
2137         return -ENODEV;
2138 }
2139 #endif
2140
2141 static int tc300k_probe(struct i2c_client *client,
2142                  const struct i2c_device_id *id)
2143 {
2144         struct tc300k_platform_data *pdata;
2145         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
2146         struct tc300k_data *data;
2147         struct input_dev *input_dev;
2148         int ret, i, err;
2149
2150         dev_info(&client->dev, "%s\n", __func__);
2151
2152         if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))
2153                 return -EIO;
2154
2155         if (client->dev.of_node) {
2156                 pdata = devm_kzalloc(&client->dev,
2157                                 sizeof(struct tc300k_platform_data),
2158                                 GFP_KERNEL);
2159                 if (!pdata) {
2160                         dev_err(&client->dev, "Failed to allocate memory\n");
2161                         return -ENOMEM;
2162                 }
2163
2164                 err = tc300k_parse_dt(&client->dev, pdata);
2165                 if (err) {
2166                         dev_err(&client->dev, "Failed to parse dt data.\n");
2167                         return err;
2168                 }
2169         } else
2170                 pdata = client->dev.platform_data;
2171
2172         data = kzalloc(sizeof(struct tc300k_data), GFP_KERNEL);
2173         if (!data) {
2174                 dev_err(&client->dev, "failed to alloc memory\n");
2175                 ret = -ENOMEM;
2176                 goto err_data_alloc;
2177         }
2178
2179         data->fdata = kzalloc(sizeof(struct fdata_struct), GFP_KERNEL);
2180         if (!data->fdata) {
2181                 dev_err(&client->dev, "failed to alloc memory for fdata\n");
2182                 ret = -ENOMEM;
2183                 goto err_data_alloc_fdata;
2184         }
2185
2186         input_dev = input_allocate_device();
2187         if (!input_dev) {
2188                 dev_err(&client->dev, "failed to allocate input device\n");
2189                 ret = -ENOMEM;
2190                 goto err_input_devalloc;
2191         }
2192
2193         data->client = client;
2194         data->pdata = pdata;
2195         data->input_dev = input_dev;
2196         data->num_key = pdata->num_key;
2197         data->keycodes = pdata->keycodes;
2198         data->suspend_type = pdata->suspend_type;
2199         data->scl = pdata->gpio_scl;
2200         data->sda = pdata->gpio_sda;
2201
2202         tc300k_gpio_request(data);
2203
2204 #if 0
2205         /* Get pinctrl if target uses pinctrl */
2206         data->pinctrl = devm_pinctrl_get(&client->dev);
2207         if (IS_ERR(data->pinctrl)) {
2208                 if (PTR_ERR(data->pinctrl) == -EPROBE_DEFER)
2209                         dev_err(&client->dev,
2210                                 "%s: pinctrl is EPROBE_DEFER\n", __func__);
2211                 dev_err(&client->dev,
2212                         "%s: Target does not use pinctrl\n", __func__);
2213                 data->pinctrl = NULL;
2214         }
2215         if (data->pinctrl) {
2216                 ret = tkey_pinctrl_configure(data, false);
2217                 if (ret)
2218                         dev_err(&client->dev,
2219                                 "%s: cannot set pinctrl state\n", __func__);
2220         }
2221 #endif
2222         tc300k_led_power(data,1);
2223         tc300k_power(data,1);
2224         msleep(5);
2225
2226         if (data->pinctrl) {
2227                 ret = tkey_pinctrl_configure(data, true);
2228                 if (ret)
2229                         dev_err(&client->dev,
2230                                 "%s: cannot set pinctrl state\n", __func__);
2231         }
2232         msleep(TC300K_POWERON_DELAY - 5);
2233
2234         mutex_init(&data->lock);
2235         wake_lock_init(&data->fw_wake_lock, WAKE_LOCK_SUSPEND, "tc300k_fw_wake_lock");
2236
2237         client->irq=gpio_to_irq(pdata->gpio_int);
2238
2239         snprintf(data->phys, sizeof(data->phys), "%s/input0", dev_name(&client->dev));
2240         input_dev->name = TC300K_DEVICE;
2241         input_dev->phys = data->phys;
2242         input_dev->id.bustype = BUS_I2C;
2243         input_dev->dev.parent = &client->dev;
2244         input_dev->keycode = data->keycodes;
2245         input_dev->keycodesize = sizeof(data->keycodes[0]);
2246         input_dev->keycodemax = data->num_key;
2247         data->tsk_ev_val = tsk_ev;
2248 #ifdef CONFIG_PM_SLEEP
2249         input_dev->open = tc300k_input_open;
2250         input_dev->close = tc300k_input_close;
2251 #endif
2252
2253         set_bit(EV_SYN, input_dev->evbit);
2254         set_bit(EV_ABS, input_dev->evbit);
2255         set_bit(EV_LED, input_dev->evbit);
2256         set_bit(LED_MISC, input_dev->ledbit);
2257         for (i = 0; i < data->num_key; i++) {
2258                 input_set_capability(input_dev, EV_KEY, data->keycodes[i]);
2259                 set_bit(data->keycodes[i], input_dev->keybit);
2260         }
2261
2262         i2c_set_clientdata(client, data);
2263         input_set_drvdata(input_dev, data);
2264         ret = input_register_device(data->input_dev);
2265         if (ret) {
2266                 dev_err(&client->dev, "fail to register input_dev (%d).\n",
2267                         ret);
2268                 goto err_register_input_dev;
2269         }
2270
2271         ret = tc300k_init_interface(data);
2272         if (ret < 0) {
2273                 dev_err(&client->dev, "failed to init interface (%d)\n", ret);
2274                 goto err_init_interface;
2275         }
2276
2277         /* Add symbolic link */
2278         ret = sysfs_create_link(&data->fdata->dummy_dev->kobj, &input_dev->dev.kobj, "input");
2279         if (ret < 0) {
2280                 dev_err(&client->dev,
2281                         "%s: Failed to create input symbolic link\n",
2282                         __func__);
2283         }
2284         dev_set_drvdata(data->fdata->dummy_dev, data);
2285         dev_set_drvdata(&client->dev, data);
2286
2287         if (client->irq) {
2288                 ret = request_threaded_irq(client->irq, NULL, tc300k_interrupt,
2289                                 IRQF_TRIGGER_FALLING | IRQF_ONESHOT , TC300K_DEVICE, data);
2290                 if (ret) {
2291                         dev_err(&client->dev, "fail to request irq (%d).\n",
2292                         client->irq);
2293                         goto err_request_irq;
2294                 }
2295         }
2296
2297         ret = tc300k_load_firmware(data);
2298         if (ret < 0) {
2299                 dev_err(&client->dev, "fail to load touchkey firmware. (%d).\n",
2300                         ret);
2301                 goto err_initialize;
2302         }
2303
2304 #ifdef CONFIG_SLEEP_MONITOR
2305         sleep_monitor_register_ops(data, &tc300k_sleep_monitor_ops,
2306                         SLEEP_MONITOR_TOUCHKEY);
2307 #endif
2308
2309         data->enabled = true;
2310         dev_info(&client->dev, "successfully probed.\n");
2311
2312         return 0;
2313
2314 err_initialize:
2315         free_irq(client->irq, data);
2316 err_request_irq:
2317         sysfs_remove_group(&data->fdata->dummy_dev->kobj,
2318                 &touchkey_attr_group);
2319         device_destroy(sec_class, data->fdata->dummy_dev->devt);
2320 err_init_interface:
2321         input_unregister_device(input_dev);
2322         input_dev = NULL;
2323 err_register_input_dev:
2324         wake_lock_destroy(&data->fw_wake_lock);
2325         if (input_dev)
2326         input_free_device(input_dev);
2327 err_input_devalloc:
2328         kfree(data->fdata);
2329 err_data_alloc_fdata:
2330         kfree(data);
2331 err_data_alloc:
2332         return ret;
2333 }
2334
2335 static int tc300k_remove(struct i2c_client *client)
2336 {
2337         struct tc300k_data *data = i2c_get_clientdata(client);
2338
2339 #ifdef CONFIG_SLEEP_MONITOR
2340         sleep_monitor_unregister_ops(SLEEP_MONITOR_TOUCHKEY);
2341 #endif
2342         free_irq(client->irq, data);
2343         gpio_free(data->pdata->gpio_int);
2344         input_unregister_device(data->input_dev);
2345         input_free_device(data->input_dev);
2346         kfree(data->fdata);
2347         kfree(data);
2348
2349         return 0;
2350 }
2351
2352 static const struct i2c_device_id tc300k_id[] = {
2353         { TC300K_DEVICE, 0 },
2354         { }
2355 };
2356
2357 #ifdef CONFIG_OF
2358 static struct of_device_id coreriver_match_table[] = {
2359         { .compatible = "coreriver,coreriver-tkey",},
2360         { },
2361 };
2362 #else
2363 #define coreriver_match_table   NULL
2364 #endif
2365
2366 #ifndef CONFIG_HAS_EARLYSUSPEND
2367 static int tc300k_suspend(struct device *dev)
2368 {
2369         struct tc300k_data *data = dev_get_drvdata(dev);
2370         struct input_dev *input_dev = data->input_dev;
2371
2372         tc300k_input_close(input_dev);
2373
2374         return 0;
2375 }
2376
2377 static int tc300k_resume(struct device *dev)
2378 {
2379         struct tc300k_data *data = dev_get_drvdata(dev);
2380         struct input_dev *input_dev = data->input_dev;
2381
2382         return tc300k_input_open(input_dev);
2383 }
2384 #endif
2385
2386 MODULE_DEVICE_TABLE(i2c, tc300k_id);
2387
2388 #ifndef CONFIG_HAS_EARLYSUSPEND
2389 const struct dev_pm_ops tc300k_pm_ops = {
2390         .suspend = tc300k_suspend,
2391         .resume = tc300k_resume,
2392 };
2393 #endif
2394
2395 static struct i2c_driver tc300k_driver = {
2396         .probe  = tc300k_probe,
2397         .remove = tc300k_remove,
2398         .driver = {
2399         .name   = TC300K_DEVICE,
2400 #ifdef CONFIG_OF
2401         .of_match_table = coreriver_match_table,
2402 #endif
2403 #ifndef CONFIG_HAS_EARLYSUSPEND
2404         .pm                     = &tc300k_pm_ops,
2405 #endif
2406         },
2407         .id_table       = tc300k_id,
2408 };
2409
2410 static int __init tc300k_init(void)
2411 {
2412         int ret = 0;
2413
2414         ret = i2c_add_driver(&tc300k_driver);
2415         if (ret) {
2416                 printk(KERN_ERR "coreriver touch keypad"
2417                         " registration failed. ret= %d\n",
2418                         ret);
2419         }
2420
2421         return ret;
2422 }
2423
2424 static void __exit tc300k_exit(void)
2425 {
2426         i2c_del_driver(&tc300k_driver);
2427 }
2428
2429 module_init(tc300k_init);
2430 module_exit(tc300k_exit);
2431
2432 MODULE_AUTHOR("Samsung Electronics");
2433 MODULE_DESCRIPTION("Touchkey driver for Coreriver TC300K");
2434 MODULE_LICENSE("GPL");