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