drivers/sensor/k2hh.c

   1 /*
   2  * Copyright (C) 2013 Samsung Electronics. All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * version 2 as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  16  * 02110-1301 USA
  17  */
  18 #include <linux/fs.h>
  19 #include <linux/uaccess.h>
  20 #include <linux/module.h>
  21 #include <linux/i2c.h>
  22 #include <linux/errno.h>
  23 #include <linux/input.h>
  24 #include <linux/workqueue.h>
  25 #include <linux/slab.h>
  26 #include <linux/delay.h>
  27 #include <linux/of_gpio.h>
  28 #include <linux/wakelock.h>
  29 #include <linux/regulator/consumer.h>
  30 #include <linux/irq.h>
  31 #include <linux/gpio.h>
  32 #include <linux/interrupt.h>
  33 #include <linux/sensors_core.h>
  34
  35
  36 #define I2C_M_WR                      0 /* for i2c Write */
  37 #define I2c_M_RD                      1 /* for i2c Read */
  38 #define READ_DATA_LENTH               6
  39
  40 #define VENDOR_NAME                   "STM"
  41 #define MODEL_NAME                    "K2HH"
  42 #define MODULE_NAME                   "accelerometer_sensor"
  43
  44 #define CALIBRATION_FILE_PATH         "/efs/accel_calibration_data"
  45 #define CALIBRATION_DATA_AMOUNT       20
  46 #define MAX_ACCEL_1G                  16384
  47
  48 #define K2HH_DEFAULT_DELAY            200000000LL
  49
  50 #define CHIP_ID_RETRIES               3
  51 #define ACCEL_LOG_TIME                15 /* 15 sec */
  52
  53 #define K2HH_MODE_SUSPEND             0
  54 #define K2HH_MODE_NORMAL              1
  55
  56 #define SENSITIVITY_2G                61
  57 #define SENSITIVITY_4G                122
  58 #define SENSITIVITY_8G                244
  59
  60 #define K2HH_RANGE_2G                 0
  61 #define K2HH_RANGE_4G                 1
  62 #define K2HH_RANGE_8G                 2
  63
  64 #define WHOAMI_REG                    0x0F
  65 #define AXISDATA_REG                  0x28
  66
  67 #define CTRL1_REG                     0x20
  68 #define CTRL2_REG                     0x21
  69 #define CTRL3_REG                     0x22
  70 #define CTRL4_REG                     0x23
  71 #define CTRL5_REG                     0x24
  72 #define CTRL6_REG                     0x25
  73 #define CTRL7_REG                     0x26
  74 #define STATUS_REG                    0x27
  75
  76 /* CTRL1 */
  77 #define CTRL1_HR_DISABLE              0x00
  78 #define CTRL1_HR_ENABLE               0x80
  79 #define CTRL1_HR_MASK                 0x80
  80 #define CTRL1_BDU_ENABLE              0x08
  81 #define CTRL1_BDU_MASK                0x08
  82
  83 /* CTRL2 */
  84 #define CTRL2_IG1_INT1                0x08
  85
  86 /* CTRL3 */
  87 #define CTRL3_IG1_INT1                0x08
  88
  89 /* CTRL7 */
  90 #define CTRL7_LIR2                    0x08
  91 #define CTRL7_LIR1                    0x04
  92
  93 #define ACC_PM_OFF                    0x00
  94 #define ACC_ENABLE_ALL_AXES           0x07
  95
  96 #define INT_CFG1_REG                  0x30
  97 #define INT_SRC1_REG                  0x31
  98 #define K2HH_CHIP_ID                  0x41
  99
 100 #define K2HH_ACC_FS_MASK              0x30
 101 #define K2HH_ACC_ODR_MASK             0x70
 102 #define K2HH_ACC_AXES_MASK            0x07
 103
 104 #define SELF_TEST_2G_MAX_LSB          24576
 105 #define SELF_TEST_2G_MIN_LSB          1146
 106
 107 #define K2HH_ACC_FS_2G                0x00
 108 #define K2HH_ACC_FS_4G                0x20
 109 #define K2HH_ACC_FS_8G                0x30
 110
 111 #define INT_THSX1_REG                 0x32
 112 #define INT_THSY1_REG                 0x33
 113 #define INT_THSZ1_REG                 0x34
 114
 115 #define DYNAMIC_THRESHOLD             5000
 116
 117 enum {
 118         OFF = 0,
 119         ON = 1
 120 };
 121
 122 struct k2hh_v {
 123         union {
 124                 s16 v[3];
 125                 struct {
 126                         s16 x;
 127                         s16 y;
 128                         s16 z;
 129                 };
 130         };
 131 };
 132
 133 struct k2hh_p {
 134         struct wake_lock reactive_wake_lock;
 135         struct i2c_client *client;
 136         struct input_dev *input;
 137         struct delayed_work irq_work;
 138         struct device *factory_device;
 139         struct k2hh_v accdata;
 140         struct k2hh_v caldata;
 141         struct mutex mode_mutex;
 142         struct hrtimer accel_timer;
 143         struct workqueue_struct *accel_wq;
 144         struct work_struct work;
 145         struct regulator *vdd;
 146         //struct regulator *vio;
 147         ktime_t poll_delay;
 148         atomic_t enable;
 149
 150         int recog_flag;
 151         int irq1;
 152         int irq_state;
 153         int acc_int1;
 154         int sda_gpio;
 155         int scl_gpio;
 156         int time_count;
 157
 158         u8 axis_map_x;
 159         u8 axis_map_y;
 160         u8 axis_map_z;
 161
 162         u8 negate_x;
 163         u8 negate_y;
 164         u8 negate_z;
 165 };
 166
 167 #define ACC_ODR10               0x10    /*   10Hz output data rate */
 168 #define ACC_ODR50               0x20    /*   50Hz output data rate */
 169 #define ACC_ODR100              0x30    /*  100Hz output data rate */
 170 #define ACC_ODR200              0x40    /*  200Hz output data rate */
 171 #define ACC_ODR400              0x50    /*  400Hz output data rate */
 172 #define ACC_ODR800              0x60    /*  800Hz output data rate */
 173 #define ACC_ODR_MASK            0X70
 174
 175 struct k2hh_acc_odr {
 176         unsigned int cutoff_ms;
 177         unsigned int mask;
 178 };
 179
 180 #define OUTPUT_ALWAYS_ANTI_ALIASED
 181
 182 const struct k2hh_acc_odr k2hh_acc_odr_table[] = {
 183         {  2, ACC_ODR800},
 184         {  3, ACC_ODR400},
 185         {  5, ACC_ODR200},
 186         { 10, ACC_ODR100},
 187 #ifndef OUTPUT_ALWAYS_ANTI_ALIASED
 188         { 20, ACC_ODR50},
 189         {100, ACC_ODR10},
 190 #endif
 191 };
 192
 193 static int k2hh_open_calibration(struct k2hh_p *);
 194 static int k2hh_regulator_onoff(struct k2hh_p *data, bool onoff);
 195 #if 0
 196 static int k2hh_i2c_recovery(struct k2hh_p *data)
 197 {
 198         int ret = 0;
 199         struct gpiomux_setting old_config[2];
 200         struct gpiomux_setting recovery_config = {
 201                 .func = GPIOMUX_FUNC_3,
 202                 .drv = GPIOMUX_DRV_2MA,
 203                 .pull = GPIOMUX_PULL_NONE,
 204                 .dir = GPIOMUX_IN,
 205         };
 206
 207         if (data->sda_gpio < 0 || data->scl_gpio < 0) {
 208                 pr_err("[SENSOR]: %s - no sda, scl gpio\n", __func__);
 209                 return -EINVAL;
 210         }
 211
 212         pr_err("[SENSOR] ################# %s #################\n", __func__);
 213
 214         /*If LDO's are disabled then enable, Fallback LDO off scenario*/
 215         do {
 216                 if( 0 == regulator_is_enabled(data->vdd) ) {
 217                         ret = regulator_enable(data->vdd);
 218                         if (ret){
 219                                 pr_err(KERN_ERR "%s: vdd enable failed (%d)\n",__func__, ret);
 220                                 break;
 221                         }
 222                         ret++;
 223                 }
 224                 if( 0 == regulator_is_enabled(data->vio) ) {
 225                         ret = regulator_enable(data->vio);
 226                         if (ret){
 227                                 pr_err(KERN_ERR "%s: vio enable failed (%d)\n",__func__, ret);
 228                                 break;
 229                         }
 230                         ret++;
 231                 }
 232                 if(ret)
 233                         msleep(30);
 234         }while(0);
 235
 236         if(ret){
 237                 pr_err("RECOVERY called as one of regulator was off:****\n Regulator \
 238                         on/recovery complete****\n ");
 239         }
 240
 241
 242         ret = msm_gpiomux_write(data->sda_gpio, GPIOMUX_ACTIVE,
 243                         &recovery_config, &old_config[0]);
 244         if (ret < 0) {
 245                 pr_err("[SENSOR]: %s sda_gpio have no active setting %d\n",
 246                         __func__, ret);
 247                 goto exit;
 248         }
 249
 250         ret = msm_gpiomux_write(data->scl_gpio, GPIOMUX_ACTIVE,
 251                         &recovery_config, &old_config[1]);
 252         if (ret < 0) {
 253                 pr_err("[SENSOR]: %s scl_gpio have no active setting %d\n",
 254                         __func__, ret);
 255                 goto exit;
 256         }
 257
 258         ret = gpio_request(data->sda_gpio, "SENSOR_SDA");
 259         if (ret < 0) {
 260                 pr_err("[SENSOR]: %s - gpio %d request failed (%d)\n",
 261                         __func__, data->sda_gpio, ret);
 262                 goto exit;
 263         }
 264
 265         ret = gpio_request(data->scl_gpio, "SENSOR_SCL");
 266         if (ret < 0) {
 267                 pr_err("[SENSOR]: %s - gpio %d request failed (%d)\n",
 268                         __func__, data->scl_gpio, ret);
 269                 gpio_free(data->scl_gpio);
 270                 goto exit;
 271         }
 272
 273         ret = gpio_direction_input(data->sda_gpio);
 274         if (ret < 0) {
 275                 pr_err("[SENSOR]: %s - failed to set gpio %d as output (%d)\n",
 276                         __func__, data->sda_gpio, ret);
 277                 goto exit_to_free;
 278         }
 279
 280         ret = gpio_direction_input(data->scl_gpio);
 281         if (ret < 0) {
 282                 pr_err("[SENSOR]: %s - failed to set gpio %d as output (%d)\n",
 283                         __func__, data->scl_gpio, ret);
 284                 goto exit_to_free;
 285         }
 286
 287         /*Setting initial value after recovery*/
 288         udelay(100);
 289         gpio_set_value_cansleep(data->sda_gpio, 0);
 290         gpio_set_value_cansleep(data->scl_gpio, 0);
 291         udelay(100);
 292         gpio_set_value_cansleep(data->sda_gpio, 1);
 293         gpio_set_value_cansleep(data->scl_gpio, 1);
 294
 295
 296 exit_to_free:
 297         gpio_free(data->sda_gpio);
 298         gpio_free(data->scl_gpio);
 299 exit:
 300         msm_gpiomux_write(data->sda_gpio, GPIOMUX_ACTIVE, &old_config[0], NULL);
 301         msm_gpiomux_write(data->scl_gpio, GPIOMUX_ACTIVE, &old_config[1], NULL);
 302
 303         return ret;
 304 }
 305 #endif
 306
 307 static int k2hh_i2c_read(struct k2hh_p *data,
 308                 unsigned char reg_addr, unsigned char *buf, unsigned int len)
 309 {
 310         int ret, retries = 0;
 311         struct i2c_msg msg[2];
 312
 313         msg[0].addr = data->client->addr;
 314         msg[0].flags = I2C_M_WR;
 315         msg[0].len = 1;
 316         msg[0].buf = &reg_addr;
 317
 318         msg[1].addr = data->client->addr;
 319         msg[1].flags = I2C_M_RD;
 320         msg[1].len = len;
 321         msg[1].buf = buf;
 322
 323         do {
 324                 ret = i2c_transfer(data->client->adapter, msg, 2);
 325                 if (ret >= 0)
 326                         break;
 327                 //else
 328                 //      k2hh_i2c_recovery(data);
 329         } while (retries++ < 2);
 330
 331         if (ret < 0) {
 332                 pr_err("[SENSOR]: %s - i2c read error %d\n", __func__, ret);
 333                 return ret;
 334         }
 335
 336         return 0;
 337 }
 338
 339 static int k2hh_i2c_write(struct k2hh_p *data,
 340                 unsigned char reg_addr, unsigned char buf)
 341 {
 342         int ret, retries = 0;
 343         struct i2c_msg msg;
 344         unsigned char w_buf[2];
 345
 346         w_buf[0] = reg_addr;
 347         w_buf[1] = buf;
 348
 349         msg.addr = data->client->addr;
 350         msg.flags = I2C_M_WR;
 351         msg.len = 2;
 352         msg.buf = (char *)w_buf;
 353
 354         do {
 355                 ret = i2c_transfer(data->client->adapter, &msg, 1);
 356                 if (ret >= 0)
 357                         break;
 358                 //else
 359                 //      k2hh_i2c_recovery(data);
 360         } while (retries++ < 2);
 361
 362         if (ret < 0) {
 363                 pr_err("[SENSOR]: %s - i2c write error %d\n", __func__, ret);
 364                 return ret;
 365         }
 366
 367         return 0;
 368 }
 369
 370 static int k2hh_set_range(struct k2hh_p *data, unsigned char range)
 371 {
 372         int ret = 0;
 373         unsigned char temp, new_range, buf, mask;
 374
 375         switch (range) {
 376         case K2HH_RANGE_2G:
 377                 new_range = K2HH_ACC_FS_2G;
 378                 break;
 379         case K2HH_RANGE_4G:
 380                 new_range = K2HH_ACC_FS_4G;
 381                 break;
 382         case K2HH_RANGE_8G:
 383                 new_range = K2HH_ACC_FS_8G;
 384                 break;
 385         default:
 386                 new_range = K2HH_ACC_FS_2G;
 387                 break;
 388         }
 389
 390         mask = K2HH_ACC_FS_MASK;
 391         ret = k2hh_i2c_read(data, CTRL4_REG, &temp, 1);
 392 #ifndef OUTPUT_ALWAYS_ANTI_ALIASED
 393         buf = (mask & new_range) | ((~mask) & temp);
 394 #else
 395         buf = 0xCC;
 396 #endif
 397         ret += k2hh_i2c_write(data, CTRL4_REG, buf);
 398
 399         return ret;
 400 }
 401
 402 static int k2hh_set_odr(struct k2hh_p *data)
 403 {
 404         int ret = 0, i;
 405         unsigned char buf, new_odr, mask, temp;
 406
 407         /* Following, looks for the longest possible odr interval scrolling the
 408          * odr_table vector from the end (shortest interval) backward (longest
 409          * interval), to support the poll_interval requested by the system.
 410          * It must be the longest interval lower then the poll interval.*/
 411         for (i = ARRAY_SIZE(k2hh_acc_odr_table) - 1; i >= 0; i--) {
 412                 if ((k2hh_acc_odr_table[i].cutoff_ms <= \
 413                         ktime_to_ms(data->poll_delay)) || (i == 0))
 414                         break;
 415         }
 416
 417         if (data->recog_flag == ON)
 418                 i = ARRAY_SIZE(k2hh_acc_odr_table) - 1;
 419
 420         new_odr = k2hh_acc_odr_table[i].mask;
 421
 422         mask = K2HH_ACC_ODR_MASK;
 423         ret = k2hh_i2c_read(data, CTRL1_REG, &temp, 1);
 424         buf = ((mask & new_odr) | ((~mask) & temp));
 425         ret += k2hh_i2c_write(data, CTRL1_REG, buf);
 426
 427         pr_info("[SENSOR]: %s - change odr %d\n", __func__, i);
 428         return ret;
 429 }
 430
 431 static int k2hh_set_mode(struct k2hh_p *data, unsigned char mode)
 432 {
 433         int ret = 0;
 434         unsigned char buf, mask, temp;
 435
 436         mutex_lock(&data->mode_mutex);
 437
 438         switch (mode) {
 439         case K2HH_MODE_NORMAL:
 440                 mask = K2HH_ACC_AXES_MASK;
 441                 ret = k2hh_i2c_read(data, CTRL1_REG, &temp, 1);
 442                 buf = ((mask & ACC_ENABLE_ALL_AXES) | ((~mask) & temp));
 443                 ret += k2hh_i2c_write(data, CTRL1_REG, buf);
 444                 k2hh_set_odr(data);
 445                 pr_info("[SENSOR]: %s - normal mode\n", __func__);
 446                 break;
 447
 448         case K2HH_MODE_SUSPEND:
 449                 if (data->recog_flag == ON)
 450                         break;
 451
 452                 mask = K2HH_ACC_AXES_MASK | K2HH_ACC_ODR_MASK;
 453                 ret = k2hh_i2c_read(data, CTRL1_REG, &temp, 1);
 454                 buf = ((mask & ACC_PM_OFF) | ((~mask) & temp));
 455                 ret += k2hh_i2c_write(data, CTRL1_REG, buf);
 456                 pr_info("[SENSOR]: %s - suspend mode\n", __func__);
 457                 break;
 458         default:
 459                 ret = -EINVAL;
 460                 break;
 461         }
 462
 463         mutex_unlock(&data->mode_mutex);
 464         return ret;
 465 }
 466
 467 static int k2hh_read_accel_xyz(struct k2hh_p *data, struct k2hh_v *acc)
 468 {
 469         int ret = 0;
 470         struct k2hh_v rawdata;
 471         unsigned char buf[READ_DATA_LENTH];
 472
 473         ret += k2hh_i2c_read(data, AXISDATA_REG, buf, READ_DATA_LENTH);
 474
 475         if (ret < 0)
 476                 goto exit;
 477
 478         rawdata.v[0] = ((s16) ((buf[1] << 8) | buf[0]));
 479         rawdata.v[1] = ((s16) ((buf[3] << 8) | buf[2]));
 480         rawdata.v[2] = ((s16) ((buf[5] << 8) | buf[4]));
 481
 482         acc->v[0] = ((data->negate_x) ? (-rawdata.v[data->axis_map_x])
 483                    : (rawdata.v[data->axis_map_x]));
 484         acc->v[1] = ((data->negate_y) ? (-rawdata.v[data->axis_map_y])
 485                    : (rawdata.v[data->axis_map_y]));
 486         acc->v[2] = ((data->negate_z) ? (-rawdata.v[data->axis_map_z])
 487                    : (rawdata.v[data->axis_map_z]));
 488
 489 exit:
 490         return ret;
 491 }
 492
 493 static enum hrtimer_restart k2hh_timer_func(struct hrtimer *timer)
 494 {
 495         struct k2hh_p *data = container_of(timer,
 496                                         struct k2hh_p, accel_timer);
 497
 498         if (!work_pending(&data->work))
 499                 queue_work(data->accel_wq, &data->work);
 500
 501         hrtimer_forward_now(&data->accel_timer, data->poll_delay);
 502
 503         return HRTIMER_RESTART;
 504 }
 505
 506 static void k2hh_work_func(struct work_struct *work)
 507 {
 508         int ret;
 509         struct k2hh_v acc;
 510         struct k2hh_p *data = container_of(work, struct k2hh_p, work);
 511
 512         ret = k2hh_read_accel_xyz(data, &acc);
 513         if (ret < 0)
 514                 goto exit;
 515
 516         data->accdata.x = acc.x - data->caldata.x;
 517         data->accdata.y = acc.y - data->caldata.y;
 518         data->accdata.z = acc.z - data->caldata.z;
 519
 520         input_report_rel(data->input, REL_X, data->accdata.x);
 521         input_report_rel(data->input, REL_Y, data->accdata.y);
 522         input_report_rel(data->input, REL_Z, data->accdata.z);
 523         input_sync(data->input);
 524
 525 exit:
 526         if ((ktime_to_ns(data->poll_delay) * (int64_t)data->time_count)
 527                 >= ((int64_t)ACCEL_LOG_TIME * NSEC_PER_SEC)) {
 528                 pr_info("[SENSOR]: %s - x = %d, y = %d, z = %d (ra:%d)\n",
 529                         __func__, data->accdata.x, data->accdata.y,
 530                         data->accdata.z, data->recog_flag);
 531                 data->time_count = 0;
 532         } else
 533                 data->time_count++;
 534 }
 535
 536 static void k2hh_set_enable(struct k2hh_p *data, int enable)
 537 {
 538         if (enable == ON) {
 539                 hrtimer_start(&data->accel_timer, data->poll_delay,
 540                       HRTIMER_MODE_REL);
 541         } else {
 542                 hrtimer_cancel(&data->accel_timer);
 543                 cancel_work_sync(&data->work);
 544         }
 545 }
 546
 547 static ssize_t k2hh_enable_show(struct device *dev,
 548                 struct device_attribute *attr, char *buf)
 549 {
 550         struct k2hh_p *data = dev_get_drvdata(dev);
 551
 552         return snprintf(buf, PAGE_SIZE, "%d\n", atomic_read(&data->enable));
 553 }
 554
 555 static ssize_t k2hh_enable_store(struct device *dev,
 556                 struct device_attribute *attr, const char *buf, size_t size)
 557 {
 558         u8 enable;
 559         int ret, pre_enable;
 560         struct k2hh_p *data = dev_get_drvdata(dev);
 561
 562         ret = kstrtou8(buf, 2, &enable);
 563         if (ret) {
 564                 pr_err("[SENSOR]: %s - Invalid Argument\n", __func__);
 565                 return ret;
 566         }
 567
 568         pr_info("[SENSOR]: %s - new_value = %u\n", __func__, enable);
 569         pre_enable = atomic_read(&data->enable);
 570
 571         if (enable) {
 572                 if (pre_enable == OFF) {
 573                         k2hh_regulator_onoff(data, true);
 574                         k2hh_open_calibration(data);
 575                         k2hh_set_range(data, K2HH_RANGE_2G);
 576
 577                         k2hh_set_mode(data, K2HH_MODE_NORMAL);
 578                         atomic_set(&data->enable, ON);
 579                         k2hh_set_enable(data, ON);
 580                 }
 581         } else {
 582                 if (pre_enable == ON) {
 583                         atomic_set(&data->enable, OFF);
 584                         k2hh_set_mode(data, K2HH_MODE_SUSPEND);
 585                         k2hh_set_enable(data, OFF);
 586                         k2hh_regulator_onoff(data, false);
 587                 }
 588         }
 589
 590         return size;
 591 }
 592
 593 static ssize_t k2hh_delay_show(struct device *dev,
 594                 struct device_attribute *attr, char *buf)
 595 {
 596         struct k2hh_p *data = dev_get_drvdata(dev);
 597
 598         return snprintf(buf, PAGE_SIZE, "%lld\n",
 599                         ktime_to_ns(data->poll_delay));
 600 }
 601
 602 static ssize_t k2hh_delay_store(struct device *dev,
 603                 struct device_attribute *attr, const char *buf, size_t size)
 604 {
 605         int ret;
 606         int64_t delay;
 607         struct k2hh_p *data = dev_get_drvdata(dev);
 608
 609         ret = kstrtoll(buf, 10, &delay);
 610         if (ret) {
 611                 pr_err("[SENSOR]: %s - Invalid Argument\n", __func__);
 612                 return ret;
 613         }
 614
 615         data->poll_delay = ns_to_ktime(delay);
 616         k2hh_set_odr(data);
 617
 618         if (atomic_read(&data->enable) == ON) {
 619                 k2hh_set_mode(data, K2HH_MODE_SUSPEND);
 620                 k2hh_set_mode(data, K2HH_MODE_NORMAL);
 621         }
 622
 623         pr_info("[SENSOR]: %s - poll_delay = %lld\n", __func__, delay);
 624         return size;
 625 }
 626
 627 static DEVICE_ATTR(poll_delay, S_IRUGO | S_IWUSR | S_IWGRP,
 628                 k2hh_delay_show, k2hh_delay_store);
 629 static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR | S_IWGRP,
 630                 k2hh_enable_show, k2hh_enable_store);
 631
 632 static struct attribute *k2hh_attributes[] = {
 633         &dev_attr_poll_delay.attr,
 634         &dev_attr_enable.attr,
 635         NULL
 636 };
 637
 638 static struct attribute_group k2hh_attribute_group = {
 639         .attrs = k2hh_attributes
 640 };
 641
 642
 643 static ssize_t k2hh_vendor_show(struct device *dev,
 644                 struct device_attribute *attr, char *buf)
 645 {
 646         return snprintf(buf, PAGE_SIZE, "%s\n", VENDOR_NAME);
 647 }
 648
 649 static ssize_t k2hh_name_show(struct device *dev,
 650                 struct device_attribute *attr, char *buf)
 651 {
 652         return snprintf(buf, PAGE_SIZE, "%s\n", MODEL_NAME);
 653 }
 654
 655 static int k2hh_open_calibration(struct k2hh_p *data)
 656 {
 657         int ret = 0;
 658         mm_segment_t old_fs;
 659         struct file *cal_filp = NULL;
 660
 661         old_fs = get_fs();
 662         set_fs(KERNEL_DS);
 663
 664         cal_filp = filp_open(CALIBRATION_FILE_PATH, O_RDONLY, 0666);
 665         if (IS_ERR(cal_filp)) {
 666                 set_fs(old_fs);
 667                 ret = PTR_ERR(cal_filp);
 668
 669                 data->caldata.x = 0;
 670                 data->caldata.y = 0;
 671                 data->caldata.z = 0;
 672
 673                 pr_info("[SENSOR]: %s - No Calibration\n", __func__);
 674
 675                 return ret;
 676         }
 677
 678         ret = cal_filp->f_op->read(cal_filp, (char *)&data->caldata.v,
 679                 3 * sizeof(s16), &cal_filp->f_pos);
 680         if (ret != 3 * sizeof(s16)) {
 681                 pr_err("[SENSOR] %s: - Can't read the cal data\n", __func__);
 682                 ret = -EIO;
 683         }
 684
 685         filp_close(cal_filp, current->files);
 686         set_fs(old_fs);
 687
 688         pr_info("[SENSOR]: open accel calibration %d, %d, %d\n",
 689                 data->caldata.x, data->caldata.y, data->caldata.z);
 690
 691         if ((data->caldata.x == 0) && (data->caldata.y == 0)
 692                 && (data->caldata.z == 0))
 693                 return -EIO;
 694
 695         return ret;
 696 }
 697
 698 static int k2hh_do_calibrate(struct k2hh_p *data, int enable)
 699 {
 700         int sum[3] = { 0, };
 701         int ret = 0, cnt;
 702         struct file *cal_filp = NULL;
 703         struct k2hh_v acc;
 704         mm_segment_t old_fs;
 705
 706         if (enable) {
 707                 data->caldata.x = 0;
 708                 data->caldata.y = 0;
 709                 data->caldata.z = 0;
 710
 711                 if (atomic_read(&data->enable) == ON)
 712                         k2hh_set_enable(data, OFF);
 713                 else
 714                         k2hh_set_mode(data, K2HH_MODE_NORMAL);
 715
 716                 msleep(300);
 717
 718                 for (cnt = 0; cnt < CALIBRATION_DATA_AMOUNT; cnt++) {
 719                         k2hh_read_accel_xyz(data, &acc);
 720                         sum[0] += acc.x;
 721                         sum[1] += acc.y;
 722                         sum[2] += acc.z;
 723                         mdelay(10);
 724                 }
 725
 726                 if (atomic_read(&data->enable) == ON)
 727                         k2hh_set_enable(data, ON);
 728                 else
 729                         k2hh_set_mode(data, K2HH_MODE_SUSPEND);
 730
 731                 data->caldata.x = (sum[0] / CALIBRATION_DATA_AMOUNT);
 732                 data->caldata.y = (sum[1] / CALIBRATION_DATA_AMOUNT);
 733                 data->caldata.z = (sum[2] / CALIBRATION_DATA_AMOUNT);
 734
 735                 if (data->caldata.z > 0)
 736                         data->caldata.z -= MAX_ACCEL_1G;
 737                 else if (data->caldata.z < 0)
 738                         data->caldata.z += MAX_ACCEL_1G;
 739         } else {
 740                 data->caldata.x = 0;
 741                 data->caldata.y = 0;
 742                 data->caldata.z = 0;
 743         }
 744
 745         pr_info("[SENSOR]: %s - do accel calibrate %d, %d, %d\n", __func__,
 746                 data->caldata.x, data->caldata.y, data->caldata.z);
 747
 748         old_fs = get_fs();
 749         set_fs(KERNEL_DS);
 750
 751         cal_filp = filp_open(CALIBRATION_FILE_PATH,
 752                         O_CREAT | O_TRUNC | O_WRONLY, 0666);
 753         if (IS_ERR(cal_filp)) {
 754                 pr_err("[SENSOR]: %s - Can't open calibration file\n",
 755                         __func__);
 756                 set_fs(old_fs);
 757                 ret = PTR_ERR(cal_filp);
 758                 return ret;
 759         }
 760
 761         ret = cal_filp->f_op->write(cal_filp, (char *)&data->caldata.v,
 762                 3 * sizeof(s16), &cal_filp->f_pos);
 763         if (ret != 3 * sizeof(s16)) {
 764                 pr_err("[SENSOR]: %s - Can't write the caldata to file\n",
 765                         __func__);
 766                 ret = -EIO;
 767         }
 768
 769         filp_close(cal_filp, current->files);
 770         set_fs(old_fs);
 771
 772         return ret;
 773 }
 774
 775 static ssize_t k2hh_calibration_show(struct device *dev,
 776                 struct device_attribute *attr, char *buf)
 777 {
 778         int ret;
 779         struct k2hh_p *data = dev_get_drvdata(dev);
 780
 781         ret = k2hh_open_calibration(data);
 782         if (ret < 0)
 783                 pr_err("[SENSOR]: %s - calibration open failed(%d)\n",
 784                         __func__, ret);
 785
 786         pr_info("[SENSOR]: %s - cal data %d %d %d - ret : %d\n", __func__,
 787                 data->caldata.x, data->caldata.y, data->caldata.z, ret);
 788
 789         return snprintf(buf, PAGE_SIZE, "%d %d %d %d\n", ret, data->caldata.x,
 790                         data->caldata.y, data->caldata.z);
 791 }
 792
 793 static ssize_t k2hh_calibration_store(struct device *dev,
 794                 struct device_attribute *attr, const char *buf, size_t size)
 795 {
 796         int ret;
 797         int64_t dEnable;
 798         struct k2hh_p *data = dev_get_drvdata(dev);
 799
 800         ret = kstrtoll(buf, 10, &dEnable);
 801         if (ret < 0)
 802                 return ret;
 803
 804         ret = k2hh_do_calibrate(data, (int)dEnable);
 805         if (ret < 0)
 806                 pr_err("[SENSOR]: %s - accel calibrate failed\n", __func__);
 807
 808         return size;
 809 }
 810
 811 static ssize_t k2hh_raw_data_read(struct device *dev,
 812                 struct device_attribute *attr, char *buf)
 813 {
 814         struct k2hh_v acc;
 815         struct k2hh_p *data = dev_get_drvdata(dev);
 816
 817         if (atomic_read(&data->enable) == OFF) {
 818                 k2hh_set_mode(data, K2HH_MODE_NORMAL);
 819                 msleep(20);
 820                 k2hh_read_accel_xyz(data, &acc);
 821                 k2hh_set_mode(data, K2HH_MODE_SUSPEND);
 822
 823                 acc.x = acc.x - data->caldata.x;
 824                 acc.y = acc.y - data->caldata.y;
 825                 acc.z = acc.z - data->caldata.z;
 826         } else {
 827                 acc = data->accdata;
 828         }
 829
 830         return snprintf(buf, PAGE_SIZE, "%d,%d,%d\n",
 831                         acc.x, acc.y, acc.z);
 832 }
 833
 834 static ssize_t k2hh_reactive_alert_store(struct device *dev,
 835                 struct device_attribute *attr, const char *buf, size_t size)
 836 {
 837         unsigned char threshx, threshy, threshz;
 838         int enable = OFF, factory_mode = OFF;
 839         struct k2hh_v acc;
 840         struct k2hh_p *data = dev_get_drvdata(dev);
 841
 842         if (sysfs_streq(buf, "0")) {
 843                 enable = OFF;
 844                 factory_mode = OFF;
 845                 pr_info("[SENSOR]: %s - disable\n", __func__);
 846         } else if (sysfs_streq(buf, "1")) {
 847                 enable = ON;
 848                 factory_mode = OFF;
 849                 pr_info("[SENSOR]: %s - enable\n", __func__);
 850         } else if (sysfs_streq(buf, "2")) {
 851                 enable = ON;
 852                 factory_mode = ON;
 853                 pr_info("[SENSOR]: %s - factory mode\n", __func__);
 854         } else {
 855                 pr_err("[SENSOR]: %s - invalid value %d\n", __func__, *buf);
 856                 return -EINVAL;
 857         }
 858
 859         if ((enable == ON) && (data->recog_flag == OFF)) {
 860                 data->irq_state = 0;
 861                 data->recog_flag = ON;
 862
 863                 if (factory_mode == ON) {
 864                         k2hh_i2c_write(data, INT_THSX1_REG, 0x00);
 865                         k2hh_i2c_write(data, INT_THSY1_REG, 0x00);
 866                         k2hh_i2c_write(data, INT_THSZ1_REG, 0x00);
 867                         k2hh_i2c_write(data, INT_CFG1_REG, 0x3f);
 868                 } else {
 869                         k2hh_set_odr(data);
 870                         if (atomic_read(&data->enable) == OFF) {
 871                                 k2hh_set_mode(data, K2HH_MODE_NORMAL);
 872                                 msleep(20);
 873                                 k2hh_read_accel_xyz(data, &acc);
 874                                 k2hh_set_mode(data, K2HH_MODE_SUSPEND);
 875                         } else {
 876                                 acc.x = data->accdata.x;
 877                                 acc.y = data->accdata.y;
 878                                 acc.z = data->accdata.z;
 879                         }
 880
 881                         threshx = (abs(acc.v[data->axis_map_x]) \
 882                                         + DYNAMIC_THRESHOLD) >> 8;
 883                         threshy = (abs(acc.v[data->axis_map_y]) \
 884                                         + DYNAMIC_THRESHOLD) >> 8;
 885                         threshz = (abs(acc.v[data->axis_map_z]) \
 886                                         + DYNAMIC_THRESHOLD) >> 8;
 887
 888                         k2hh_i2c_write(data, INT_THSX1_REG, threshx);
 889                         k2hh_i2c_write(data, INT_THSY1_REG, threshy);
 890                         k2hh_i2c_write(data, INT_THSZ1_REG, threshz);
 891                         k2hh_i2c_write(data, INT_CFG1_REG, 0x0a);
 892                 }
 893
 894                 k2hh_i2c_write(data, CTRL7_REG, CTRL7_LIR1);
 895                 k2hh_i2c_write(data, CTRL3_REG, CTRL3_IG1_INT1);
 896
 897                 enable_irq(data->irq1);
 898                 enable_irq_wake(data->irq1);
 899
 900                 pr_info("[SENSOR]: %s - reactive alert is on!\n", __func__);
 901         } else if ((enable == OFF) && (data->recog_flag == ON)) {
 902                 k2hh_i2c_write(data, CTRL3_REG, 0x00);
 903
 904                 disable_irq_wake(data->irq1);
 905                 disable_irq_nosync(data->irq1);
 906                 data->recog_flag = OFF;
 907                 pr_info("[SENSOR]: %s - reactive alert is off! irq = %d\n",
 908                         __func__, data->irq_state);
 909         }
 910
 911         return size;
 912 }
 913
 914 static ssize_t k2hh_reactive_alert_show(struct device *dev,
 915         struct device_attribute *attr, char *buf)
 916 {
 917         struct k2hh_p *data = dev_get_drvdata(dev);
 918
 919         return snprintf(buf, PAGE_SIZE, "%d\n", data->irq_state);
 920 }
 921
 922 static ssize_t k2hh_selftest_show(struct device *dev,
 923        struct device_attribute *attr, char *buf)
 924 {
 925         struct k2hh_p *data = dev_get_drvdata(dev);
 926         struct k2hh_v acc;
 927         unsigned char temp;
 928         int result = 1, i;
 929         ssize_t ret;
 930         s32 NO_ST[3] = {0, 0, 0};
 931         s32 ST[3] = {0, 0, 0};
 932
 933         if (atomic_read(&data->enable) == OFF)
 934                 k2hh_set_mode(data, K2HH_MODE_NORMAL);
 935         else
 936                 k2hh_set_enable(data, OFF);
 937
 938         k2hh_i2c_write(data, CTRL1_REG, 0x3f);
 939         k2hh_i2c_write(data, CTRL4_REG, 0x04);
 940         k2hh_i2c_write(data, CTRL5_REG, 0x00);
 941         k2hh_i2c_write(data, CTRL6_REG, 0x00);
 942
 943         mdelay(80);
 944
 945         k2hh_read_accel_xyz(data, &acc);
 946
 947         for (i = 0; i < 5; i++) {
 948                 while (1) {
 949                         if (k2hh_i2c_read(data, STATUS_REG, &temp, 1) < 0) {
 950                                 pr_err("[SENSOR] %s: i2c error", __func__);
 951                                 goto exit_status_err;
 952                         }
 953
 954                         if (temp & 0x08)
 955                                 break;
 956                 }
 957
 958                 k2hh_read_accel_xyz(data, &acc);
 959                 NO_ST[0] += acc.x;
 960                 NO_ST[1] += acc.y;
 961                 NO_ST[2] += acc.z;
 962         }
 963         NO_ST[0]  /= 5;
 964         NO_ST[1]  /= 5;
 965         NO_ST[2]  /= 5;
 966
 967         k2hh_i2c_write(data, CTRL5_REG, 0x04);
 968
 969         mdelay(80);
 970
 971         k2hh_read_accel_xyz(data, &acc);
 972
 973         for (i = 0; i < 5; i++) {
 974                 while (1) {
 975                         if (k2hh_i2c_read(data, STATUS_REG, &temp, 1) < 0) {
 976                                 pr_err("[SENSOR] %s: i2c error", __func__);
 977                                 goto exit_status_err;
 978                         }
 979
 980                         if (temp & 0x08)
 981                                 break;
 982                 }
 983
 984                 k2hh_read_accel_xyz(data, &acc);
 985                 ST[0] += acc.x;
 986                 ST[1] += acc.y;
 987                 ST[2] += acc.z;
 988         }
 989
 990         ST[0] /= 5;
 991         ST[1] /= 5;
 992         ST[2] /= 5;
 993
 994         for (i = 0; i < 3; i++) {
 995                 ST[i] -= NO_ST[i];
 996                 ST[i] = abs(ST[i]);
 997
 998                 if ((SELF_TEST_2G_MIN_LSB > ST[i]) \
 999                         || (ST[i] > SELF_TEST_2G_MAX_LSB)) {
1000                         pr_info("[SENSOR] %s: %d Out of range!! (%d)\n",
1001                                 __func__, i, ST[i]);
1002                         result = 0;
1003                 }
1004         }
1005
1006         if (result)
1007                 ret = sprintf(buf, "1,%d,%d,%d\n", ST[0], ST[1], ST[2]);
1008         else
1009                 ret = sprintf(buf, "0,%d,%d,%d\n", ST[0], ST[1], ST[2]);
1010
1011         goto exit;
1012
1013 exit_status_err:
1014         ret = sprintf(buf, "-1,0,0,0\n");
1015 exit:
1016         k2hh_i2c_write(data, CTRL1_REG, 0x00);
1017         k2hh_i2c_write(data, CTRL5_REG, 0x00);
1018
1019         if (atomic_read(&data->enable) == OFF) {
1020                 k2hh_set_mode(data, K2HH_MODE_SUSPEND);
1021         } else {
1022                 k2hh_set_mode(data, K2HH_MODE_NORMAL);
1023                 k2hh_set_enable(data, ON);
1024         }
1025
1026         return ret;
1027 }
1028
1029 static DEVICE_ATTR(selftest, S_IRUGO, k2hh_selftest_show, NULL);
1030 static DEVICE_ATTR(name, S_IRUGO, k2hh_name_show, NULL);
1031 static DEVICE_ATTR(vendor, S_IRUGO, k2hh_vendor_show, NULL);
1032 static DEVICE_ATTR(calibration, S_IRUGO | S_IWUSR | S_IWGRP,
1033         k2hh_calibration_show, k2hh_calibration_store);
1034 static DEVICE_ATTR(raw_data, S_IRUGO, k2hh_raw_data_read, NULL);
1035 static DEVICE_ATTR(reactive_alert, S_IRUGO | S_IWUSR | S_IWGRP,
1036         k2hh_reactive_alert_show, k2hh_reactive_alert_store);
1037
1038 static struct device_attribute *sensor_attrs[] = {
1039         &dev_attr_name,
1040         &dev_attr_vendor,
1041         &dev_attr_calibration,
1042         &dev_attr_raw_data,
1043         &dev_attr_reactive_alert,
1044         &dev_attr_selftest,
1045         NULL,
1046 };
1047
1048 static void k2hh_irq_work_func(struct work_struct *work)
1049 {
1050         struct k2hh_p *data = container_of((struct delayed_work *)work,
1051                 struct k2hh_p, irq_work);
1052         unsigned char buf;
1053
1054         k2hh_i2c_write(data, INT_CFG1_REG, 0x00);
1055         k2hh_i2c_read(data, INT_SRC1_REG, &buf, 1);
1056 }
1057
1058 static irqreturn_t k2hh_irq_thread(int irq, void *k2hh_data_p)
1059 {
1060         struct k2hh_p *data = k2hh_data_p;
1061
1062         data->irq_state = 1;
1063         wake_lock_timeout(&data->reactive_wake_lock,
1064                 msecs_to_jiffies(2000));
1065         schedule_delayed_work(&data->irq_work, msecs_to_jiffies(100));
1066         pr_info("###### [SENSOR]: %s reactive irq ######\n", __func__);
1067
1068         return IRQ_HANDLED;
1069 }
1070
1071 static int k2hh_setup_pin(struct k2hh_p *data)
1072 {
1073         int ret;
1074
1075         ret = gpio_request(data->acc_int1, "ACC_INT1");
1076         if (ret < 0) {
1077                 pr_err("[SENSOR] %s - gpio %d request failed (%d)\n",
1078                         __func__, data->acc_int1, ret);
1079                 goto exit;
1080         }
1081
1082         ret = gpio_direction_input(data->acc_int1);
1083         if (ret < 0) {
1084                 pr_err("[SENSOR]: %s - failed to set gpio %d as input (%d)\n",
1085                         __func__, data->acc_int1, ret);
1086                 goto exit_acc_int1;
1087         }
1088
1089         wake_lock_init(&data->reactive_wake_lock, WAKE_LOCK_SUSPEND,
1090                        "reactive_wake_lock");
1091
1092         data->irq1 = gpio_to_irq(data->acc_int1);
1093         ret = request_threaded_irq(data->irq1, NULL, k2hh_irq_thread,
1094                 IRQF_TRIGGER_RISING | IRQF_ONESHOT, "k2hh_accel", data);
1095         if (ret < 0) {
1096                 pr_err("[SENSOR]: %s - can't allocate irq.\n", __func__);
1097                 goto exit_reactive_irq;
1098         }
1099
1100         disable_irq(data->irq1);
1101         goto exit;
1102
1103 exit_reactive_irq:
1104         wake_lock_destroy(&data->reactive_wake_lock);
1105 exit_acc_int1:
1106         gpio_free(data->acc_int1);
1107 exit:
1108         return ret;
1109 }
1110
1111 static int k2hh_input_init(struct k2hh_p *data)
1112 {
1113         int ret = 0;
1114         struct input_dev *dev;
1115
1116         dev = input_allocate_device();
1117         if (!dev)
1118                 return -ENOMEM;
1119
1120         dev->name = MODULE_NAME;
1121         dev->id.bustype = BUS_I2C;
1122
1123         input_set_capability(dev, EV_REL, REL_X);
1124         input_set_capability(dev, EV_REL, REL_Y);
1125         input_set_capability(dev, EV_REL, REL_Z);
1126         input_set_drvdata(dev, data);
1127
1128         ret = input_register_device(dev);
1129         if (ret < 0) {
1130                 input_free_device(dev);
1131                 return ret;
1132         }
1133         /* sysfs node creation */
1134         ret = sysfs_create_group(&dev->dev.kobj, &k2hh_attribute_group);
1135         if (ret < 0) {
1136                 input_unregister_device(dev);
1137                 return ret;
1138         }
1139
1140         data->input = dev;
1141         return 0;
1142 }
1143
1144 static int k2hh_parse_dt(struct k2hh_p *data, struct device *dev)
1145 {
1146         struct device_node *dNode = dev->of_node;
1147         enum of_gpio_flags flags;
1148         int ret;
1149         u32 temp;
1150
1151         if (dNode == NULL)
1152                 return -ENODEV;
1153
1154         data->acc_int1 = of_get_named_gpio_flags(dNode,
1155                         "stm,irq_gpio", 0, &flags);
1156         if (data->acc_int1 < 0) {
1157                 pr_err("[SENSOR]: %s - get acc_int1 error\n", __func__);
1158                 return -ENODEV;
1159         }
1160
1161         data->sda_gpio = of_get_named_gpio_flags(dNode,
1162                 "stm,sda", 0, &flags);
1163         if (data->sda_gpio < 0)
1164                 pr_info("[SENSOR]: %s - no sda_gpio\n", __func__);
1165
1166         data->scl_gpio = of_get_named_gpio_flags(dNode,
1167                 "stm,scl", 0, &flags);
1168         if (data->scl_gpio < 0)
1169                 pr_info("[SENSOR]: %s - no scl_gpio\n", __func__);
1170
1171         ret = of_property_read_u32(dNode,"stm,axis_map_x", &temp);
1172         if ((data->axis_map_x > 2) || (ret < 0)) {
1173                 pr_err("%s: invalid x axis_map value %u\n",
1174                         __func__, data->axis_map_x);
1175                 data->axis_map_x = 0;
1176         } else {
1177                 data->axis_map_x= (u8)temp;
1178         }
1179
1180         ret = of_property_read_u32(dNode,"stm,axis_map_y", &temp);
1181         if ((data->axis_map_y > 2) || (ret < 0)) {
1182                 pr_err("%s: invalid y axis_map value %u\n",
1183                         __func__, data->axis_map_y);
1184                 data->axis_map_y = 1;
1185         } else {
1186                 data->axis_map_y= (u8)temp;
1187         }
1188
1189         ret = of_property_read_u32(dNode,"stm,axis_map_z", &temp);
1190         if ((data->axis_map_z > 2) || (ret < 0)) {
1191                 pr_err("%s: invalid z axis_map value %u\n",
1192                         __func__, data->axis_map_z);
1193                 data->axis_map_z = 2;
1194         } else {
1195                 data->axis_map_z= (u8)temp;
1196         }
1197
1198         ret = of_property_read_u32(dNode,"stm,negate_x", &temp);
1199         if ((data->negate_x > 1) || (ret < 0)) {
1200                 pr_err("%s: invalid x axis_map value %u\n",
1201                         __func__, data->negate_x);
1202                 data->negate_x = 0;
1203         } else {
1204                 data->negate_x= (u8)temp;
1205         }
1206
1207         ret = of_property_read_u32(dNode,"stm,negate_y", &temp);
1208         if ((data->negate_y > 1) || (ret < 0)) {
1209                 pr_err("%s: invalid y axis_map value %u\n",
1210                         __func__, data->negate_y);
1211                 data->negate_y = 0;
1212         } else {
1213                 data->negate_y= (u8)temp;
1214         }
1215
1216         ret = of_property_read_u32(dNode,"stm,negate_z", &temp);
1217         if ((data->negate_z > 1) || (ret < 0)) {
1218                 pr_err("%s: invalid z axis_map value %u\n",
1219                         __func__, data->negate_z);
1220                 data->negate_z = 0;
1221         } else {
1222                 data->negate_z= (u8)temp;
1223         }
1224
1225         return 0;
1226 }
1227
1228 static int k2hh_regulator_onoff(struct k2hh_p *data, bool onoff)
1229 {
1230 #if 0
1231         int ret = -1;
1232
1233         if (!data->vdd) {
1234                 data->vdd = regulator_get(&data->client->dev, "stm,reg_vdd");
1235                 if (!data->vdd) {
1236                         pr_err("%s: regulator pointer null vdd, rc=%d\n",
1237                                 __func__, ret);
1238                         return ret;
1239                 }
1240                 ret = regulator_set_voltage(data->vdd, 3000000, 3000000);
1241                 if (ret) {
1242                         pr_err("%s: set voltage failed on vdd, rc=%d\n",
1243                                 __func__, ret);
1244                         return ret;
1245                 }
1246         }
1247         /*if (!data->vio) {
1248                 data->vio = regulator_get(&data->client->dev, "stm,reg_vio");
1249                 if(!data->vio){
1250                         pr_err("%s: regulator_get for vio failed\n",
1251                                 __func__);
1252                         return 0;
1253                 }
1254         }*/
1255         if(onoff){
1256                 ret = regulator_enable(data->vdd);
1257                 if (ret) {
1258                         pr_err("%s: Failed to enable regulator vdd.\n",
1259                                 __func__);
1260                         return ret;
1261                 }
1262                 /*ret = regulator_enable(data->vio);
1263                 if (ret) {
1264                         pr_err("%s: Failed to enable regulator vio.\n",
1265                                 __func__);
1266                         return ret;
1267                 }
1268                 msleep(30);*/
1269         }
1270         else {
1271                 ret = regulator_disable(data->vdd);
1272                 if (ret) {
1273                         pr_err("%s: Failed to disable regulator vdd.\n",
1274                                 __func__);
1275                         return ret;
1276                 }
1277                 /*ret = regulator_disable(data->vio);
1278                 if (ret) {
1279                         pr_err("%s: Failed to disable regulator vio.\n",
1280                                 __func__);
1281                         return ret;
1282                 }*/
1283         }
1284 #endif
1285         return 0;
1286 }
1287
1288
1289 static int k2hh_probe(struct i2c_client *client,
1290                 const struct i2c_device_id *id)
1291 {
1292         u8 temp;
1293         int ret = -ENODEV, i;
1294         struct k2hh_p *data = NULL;
1295
1296         pr_err("[SENSOR]: %s - Probe Start!\n", __func__);
1297         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
1298                 pr_err("[SENSOR]: %s - i2c_check_functionality error\n",
1299                         __func__);
1300                 goto exit;
1301         }
1302
1303         data = kzalloc(sizeof(struct k2hh_p), GFP_KERNEL);
1304         if (data == NULL) {
1305                 pr_err("[SENSOR]: %s - kzalloc error\n", __func__);
1306                 ret = -ENOMEM;
1307                 goto exit_kzalloc;
1308         }
1309
1310         i2c_set_clientdata(client, data);
1311         data->client = client;
1312
1313         ret = k2hh_parse_dt(data, &client->dev);
1314         if (ret < 0) {
1315                 pr_err("[SENSOR]: %s - of_node error\n", __func__);
1316                 ret = -ENODEV;
1317                 goto exit_of_node;
1318         }
1319
1320         ret = k2hh_regulator_onoff(data, true);
1321         if (ret < 0)
1322                 pr_err("[SENSOR]: %s - No regulator\n", __func__);
1323
1324         ret = k2hh_setup_pin(data);
1325         if (ret < 0) {
1326                 pr_err("[SENSOR]: %s - could not setup pin\n", __func__);
1327                 goto exit_setup_pin;
1328         }
1329
1330         mutex_init(&data->mode_mutex);
1331
1332         /* read chip id */
1333         k2hh_set_mode(data, K2HH_MODE_NORMAL);
1334         for (i = 0; i < CHIP_ID_RETRIES; i++) {
1335                 ret = k2hh_i2c_read(data, WHOAMI_REG, &temp, 1);
1336                 if (temp != K2HH_CHIP_ID) {
1337                         pr_err("[SENSOR]: %s - chip id failed 0x%x : %d\n",
1338                                 __func__, temp, ret);
1339                 } else {
1340                         pr_info("[SENSOR]: %s - chip id success 0x%x\n",
1341                                 __func__, temp);
1342                         break;
1343                 }
1344                 msleep(20);
1345         }
1346
1347         if (i >= CHIP_ID_RETRIES) {
1348                 ret = -ENODEV;
1349                 goto exit_read_chipid;
1350         }
1351
1352         /* input device init */
1353         ret = k2hh_input_init(data);
1354         if (ret < 0)
1355                 goto exit_input_init;
1356
1357         sensors_register(data->factory_device, data, sensor_attrs, MODULE_NAME);
1358
1359         /* accel_timer settings. we poll for light values using a timer. */
1360         hrtimer_init(&data->accel_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1361         data->poll_delay = ns_to_ktime(K2HH_DEFAULT_DELAY);
1362         data->accel_timer.function = k2hh_timer_func;
1363
1364         /* the timer just fires off a work queue request.  we need a thread
1365            to read the i2c (can be slow and blocking). */
1366         data->accel_wq = create_singlethread_workqueue("accel_wq");
1367         if (!data->accel_wq) {
1368                 ret = -ENOMEM;
1369                 pr_err("[SENSOR]: %s - could not create workqueue\n", __func__);
1370                 goto exit_create_workqueue;
1371         }
1372
1373         /* this is the thread function we run on the work queue */
1374         INIT_WORK(&data->work, k2hh_work_func);
1375         INIT_DELAYED_WORK(&data->irq_work, k2hh_irq_work_func);
1376
1377         atomic_set(&data->enable, OFF);
1378         data->time_count = 0;
1379         data->irq_state = 0;
1380         data->recog_flag = OFF;
1381
1382         k2hh_set_range(data, K2HH_RANGE_2G);
1383         k2hh_set_mode(data, K2HH_MODE_SUSPEND);
1384
1385         /*power off the regulators, for next enable power will be on*/
1386         ret = k2hh_regulator_onoff(data, false);
1387
1388         pr_err("[SENSOR]: %s - Probe done!\n", __func__);
1389
1390         return 0;
1391
1392 exit_create_workqueue:
1393         sensors_unregister(data->factory_device, sensor_attrs);
1394         sysfs_remove_group(&data->input->dev.kobj, &k2hh_attribute_group);
1395         input_unregister_device(data->input);
1396 exit_input_init:
1397 exit_read_chipid:
1398         mutex_destroy(&data->mode_mutex);
1399         free_irq(data->irq1, data);
1400         wake_lock_destroy(&data->reactive_wake_lock);
1401         gpio_free(data->acc_int1);
1402 exit_setup_pin:
1403 exit_of_node:
1404         kfree(data);
1405 exit_kzalloc:
1406 exit:
1407         pr_err("[SENSOR]: %s - Probe fail!\n", __func__);
1408         return ret;
1409 }
1410
1411 static void k2hh_shutdown(struct i2c_client *client)
1412 {
1413         struct k2hh_p *data = (struct k2hh_p *)i2c_get_clientdata(client);
1414
1415         pr_info("[SENSOR]: %s\n", __func__);
1416
1417         if (atomic_read(&data->enable) == ON)
1418                 k2hh_set_enable(data, OFF);
1419
1420         atomic_set(&data->enable, OFF);
1421         k2hh_set_mode(data, K2HH_MODE_SUSPEND);
1422 }
1423
1424 /*
1425 static int k2hh_remove(struct i2c_client *client)
1426 {
1427         struct k2hh_p *data = (struct k2hh_p *)i2c_get_clientdata(client);
1428
1429         if (atomic_read(&data->enable) == ON)
1430                 k2hh_set_enable(data, OFF);
1431
1432         atomic_set(&data->enable, OFF);
1433         cancel_delayed_work_sync(&data->irq_work);
1434
1435         k2hh_set_mode(data, K2HH_MODE_SUSPEND);
1436         sensors_unregister(data->factory_device, sensor_attrs);
1437
1438         sysfs_remove_group(&data->input->dev.kobj, &k2hh_attribute_group);
1439         input_unregister_device(data->input);
1440
1441         free_irq(data->irq1, data);
1442         wake_lock_destroy(&data->reactive_wake_lock);
1443         mutex_destroy(&data->mode_mutex);
1444         gpio_free(data->acc_int1);
1445         kfree(data);
1446
1447         return 0;
1448 }
1449 */
1450
1451 static int k2hh_suspend(struct device *dev)
1452 {
1453         struct k2hh_p *data = dev_get_drvdata(dev);
1454
1455         pr_info("[SENSOR]: %s\n", __func__);
1456
1457         if (atomic_read(&data->enable) == ON) {
1458                 k2hh_set_mode(data, K2HH_MODE_SUSPEND);
1459                 k2hh_set_enable(data, OFF);
1460         }
1461
1462         return 0;
1463 }
1464
1465 static int k2hh_resume(struct device *dev)
1466 {
1467         struct k2hh_p *data = dev_get_drvdata(dev);
1468
1469         pr_info("[SENSOR]: %s\n", __func__);
1470
1471         if (atomic_read(&data->enable) == ON) {
1472                 k2hh_set_mode(data, K2HH_MODE_NORMAL);
1473                 k2hh_set_enable(data, ON);
1474         }
1475
1476         return 0;
1477 }
1478
1479 static struct of_device_id k2hh_match_table[] = {
1480         { .compatible = "stm,k2hh",},
1481         {},
1482 };
1483
1484 static const struct i2c_device_id k2hh_id[] = {
1485         { "k2hh_match_table", 0 },
1486         { }
1487 };
1488
1489 static const struct dev_pm_ops k2hh_pm_ops = {
1490         .suspend = k2hh_suspend,
1491         .resume = k2hh_resume
1492 };
1493
1494 static struct i2c_driver k2hh_driver = {
1495         .driver = {
1496                 .name   = MODEL_NAME,
1497                 .owner  = THIS_MODULE,
1498                 .of_match_table = k2hh_match_table,
1499                 .pm = &k2hh_pm_ops
1500         },
1501         .probe          = k2hh_probe,
1502         .shutdown       = k2hh_shutdown,
1503 /*      .remove         = k2hh_remove, */
1504         .id_table       = k2hh_id,
1505 };
1506
1507 static int __init k2hh_init(void)
1508 {
1509         return i2c_add_driver(&k2hh_driver);
1510 }
1511
1512 static void __exit k2hh_exit(void)
1513 {
1514         i2c_del_driver(&k2hh_driver);
1515 }
1516
1517 module_init(k2hh_init);
1518 module_exit(k2hh_exit);
1519
1520 MODULE_DESCRIPTION("k2hh accelerometer sensor driver");
1521 MODULE_AUTHOR("Samsung Electronics");
1522 MODULE_LICENSE("GPL");
1523