drivers/iio/accel/kxcjk-1013.c

   1 /*
   2  * KXCJK-1013 3-axis accelerometer driver
   3  * Copyright (c) 2014, Intel Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  */
  14
  15 #include <linux/module.h>
  16 #include <linux/i2c.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/delay.h>
  19 #include <linux/bitops.h>
  20 #include <linux/slab.h>
  21 #include <linux/string.h>
  22 #include <linux/acpi.h>
  23 #include <linux/gpio/consumer.h>
  24 #include <linux/pm.h>
  25 #include <linux/pm_runtime.h>
  26 #include <linux/iio/iio.h>
  27 #include <linux/iio/sysfs.h>
  28 #include <linux/iio/buffer.h>
  29 #include <linux/iio/trigger.h>
  30 #include <linux/iio/events.h>
  31 #include <linux/iio/trigger_consumer.h>
  32 #include <linux/iio/triggered_buffer.h>
  33 #include <linux/iio/accel/kxcjk_1013.h>
  34
  35 #define KXCJK1013_DRV_NAME "kxcjk1013"
  36 #define KXCJK1013_IRQ_NAME "kxcjk1013_event"
  37
  38 #define KXCJK1013_REG_XOUT_L            0x06
  39 /*
  40  * From low byte X axis register, all the other addresses of Y and Z can be
  41  * obtained by just applying axis offset. The following axis defines are just
  42  * provide clarity, but not used.
  43  */
  44 #define KXCJK1013_REG_XOUT_H            0x07
  45 #define KXCJK1013_REG_YOUT_L            0x08
  46 #define KXCJK1013_REG_YOUT_H            0x09
  47 #define KXCJK1013_REG_ZOUT_L            0x0A
  48 #define KXCJK1013_REG_ZOUT_H            0x0B
  49
  50 #define KXCJK1013_REG_DCST_RESP         0x0C
  51 #define KXCJK1013_REG_WHO_AM_I          0x0F
  52 #define KXCJK1013_REG_INT_SRC1          0x16
  53 #define KXCJK1013_REG_INT_SRC2          0x17
  54 #define KXCJK1013_REG_STATUS_REG        0x18
  55 #define KXCJK1013_REG_INT_REL           0x1A
  56 #define KXCJK1013_REG_CTRL1             0x1B
  57 #define KXCJK1013_REG_CTRL2             0x1D
  58 #define KXCJK1013_REG_INT_CTRL1         0x1E
  59 #define KXCJK1013_REG_INT_CTRL2         0x1F
  60 #define KXCJK1013_REG_DATA_CTRL         0x21
  61 #define KXCJK1013_REG_WAKE_TIMER        0x29
  62 #define KXCJK1013_REG_SELF_TEST         0x3A
  63 #define KXCJK1013_REG_WAKE_THRES        0x6A
  64
  65 #define KXCJK1013_REG_CTRL1_BIT_PC1     BIT(7)
  66 #define KXCJK1013_REG_CTRL1_BIT_RES     BIT(6)
  67 #define KXCJK1013_REG_CTRL1_BIT_DRDY    BIT(5)
  68 #define KXCJK1013_REG_CTRL1_BIT_GSEL1   BIT(4)
  69 #define KXCJK1013_REG_CTRL1_BIT_GSEL0   BIT(3)
  70 #define KXCJK1013_REG_CTRL1_BIT_WUFE    BIT(1)
  71 #define KXCJK1013_REG_INT_REG1_BIT_IEA  BIT(4)
  72 #define KXCJK1013_REG_INT_REG1_BIT_IEN  BIT(5)
  73
  74 #define KXCJK1013_DATA_MASK_12_BIT      0x0FFF
  75 #define KXCJK1013_MAX_STARTUP_TIME_US   100000
  76
  77 #define KXCJK1013_SLEEP_DELAY_MS        2000
  78
  79 #define KXCJK1013_REG_INT_SRC2_BIT_ZP   BIT(0)
  80 #define KXCJK1013_REG_INT_SRC2_BIT_ZN   BIT(1)
  81 #define KXCJK1013_REG_INT_SRC2_BIT_YP   BIT(2)
  82 #define KXCJK1013_REG_INT_SRC2_BIT_YN   BIT(3)
  83 #define KXCJK1013_REG_INT_SRC2_BIT_XP   BIT(4)
  84 #define KXCJK1013_REG_INT_SRC2_BIT_XN   BIT(5)
  85
  86 #define KXCJK1013_DEFAULT_WAKE_THRES    1
  87
  88 enum kx_chipset {
  89         KXCJK1013,
  90         KXCJ91008,
  91         KXTJ21009,
  92         KX_MAX_CHIPS /* this must be last */
  93 };
  94
  95 struct kxcjk1013_data {
  96         struct i2c_client *client;
  97         struct iio_trigger *dready_trig;
  98         struct iio_trigger *motion_trig;
  99         struct mutex mutex;
 100         s16 buffer[8];
 101         u8 odr_bits;
 102         u8 range;
 103         int wake_thres;
 104         int wake_dur;
 105         bool active_high_intr;
 106         bool dready_trigger_on;
 107         int ev_enable_state;
 108         bool motion_trigger_on;
 109         int64_t timestamp;
 110         enum kx_chipset chipset;
 111         bool is_smo8500_device;
 112 };
 113
 114 enum kxcjk1013_axis {
 115         AXIS_X,
 116         AXIS_Y,
 117         AXIS_Z,
 118 };
 119
 120 enum kxcjk1013_mode {
 121         STANDBY,
 122         OPERATION,
 123 };
 124
 125 enum kxcjk1013_range {
 126         KXCJK1013_RANGE_2G,
 127         KXCJK1013_RANGE_4G,
 128         KXCJK1013_RANGE_8G,
 129 };
 130
 131 static const struct {
 132         int val;
 133         int val2;
 134         int odr_bits;
 135 } samp_freq_table[] = { {0, 781000, 0x08}, {1, 563000, 0x09},
 136                         {3, 125000, 0x0A}, {6, 250000, 0x0B}, {12, 500000, 0},
 137                         {25, 0, 0x01}, {50, 0, 0x02}, {100, 0, 0x03},
 138                         {200, 0, 0x04}, {400, 0, 0x05}, {800, 0, 0x06},
 139                         {1600, 0, 0x07} };
 140
 141 /* Refer to section 4 of the specification */
 142 static const struct {
 143         int odr_bits;
 144         int usec;
 145 } odr_start_up_times[KX_MAX_CHIPS][12] = {
 146         /* KXCJK-1013 */
 147         {
 148                 {0x08, 100000},
 149                 {0x09, 100000},
 150                 {0x0A, 100000},
 151                 {0x0B, 100000},
 152                 {0, 80000},
 153                 {0x01, 41000},
 154                 {0x02, 21000},
 155                 {0x03, 11000},
 156                 {0x04, 6400},
 157                 {0x05, 3900},
 158                 {0x06, 2700},
 159                 {0x07, 2100},
 160         },
 161         /* KXCJ9-1008 */
 162         {
 163                 {0x08, 100000},
 164                 {0x09, 100000},
 165                 {0x0A, 100000},
 166                 {0x0B, 100000},
 167                 {0, 80000},
 168                 {0x01, 41000},
 169                 {0x02, 21000},
 170                 {0x03, 11000},
 171                 {0x04, 6400},
 172                 {0x05, 3900},
 173                 {0x06, 2700},
 174                 {0x07, 2100},
 175         },
 176         /* KXCTJ2-1009 */
 177         {
 178                 {0x08, 1240000},
 179                 {0x09, 621000},
 180                 {0x0A, 309000},
 181                 {0x0B, 151000},
 182                 {0, 80000},
 183                 {0x01, 41000},
 184                 {0x02, 21000},
 185                 {0x03, 11000},
 186                 {0x04, 6000},
 187                 {0x05, 4000},
 188                 {0x06, 3000},
 189                 {0x07, 2000},
 190         },
 191 };
 192
 193 static const struct {
 194         u16 scale;
 195         u8 gsel_0;
 196         u8 gsel_1;
 197 } KXCJK1013_scale_table[] = { {9582, 0, 0},
 198                               {19163, 1, 0},
 199                               {38326, 0, 1} };
 200
 201 static const struct {
 202         int val;
 203         int val2;
 204         int odr_bits;
 205 } wake_odr_data_rate_table[] = { {0, 781000, 0x00},
 206                                  {1, 563000, 0x01},
 207                                  {3, 125000, 0x02},
 208                                  {6, 250000, 0x03},
 209                                  {12, 500000, 0x04},
 210                                  {25, 0, 0x05},
 211                                  {50, 0, 0x06},
 212                                  {100, 0, 0x06},
 213                                  {200, 0, 0x06},
 214                                  {400, 0, 0x06},
 215                                  {800, 0, 0x06},
 216                                  {1600, 0, 0x06} };
 217
 218 static int kxcjk1013_set_mode(struct kxcjk1013_data *data,
 219                               enum kxcjk1013_mode mode)
 220 {
 221         int ret;
 222
 223         ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1);
 224         if (ret < 0) {
 225                 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
 226                 return ret;
 227         }
 228
 229         if (mode == STANDBY)
 230                 ret &= ~KXCJK1013_REG_CTRL1_BIT_PC1;
 231         else
 232                 ret |= KXCJK1013_REG_CTRL1_BIT_PC1;
 233
 234         ret = i2c_smbus_write_byte_data(data->client,
 235                                         KXCJK1013_REG_CTRL1, ret);
 236         if (ret < 0) {
 237                 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
 238                 return ret;
 239         }
 240
 241         return 0;
 242 }
 243
 244 static int kxcjk1013_get_mode(struct kxcjk1013_data *data,
 245                               enum kxcjk1013_mode *mode)
 246 {
 247         int ret;
 248
 249         ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1);
 250         if (ret < 0) {
 251                 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
 252                 return ret;
 253         }
 254
 255         if (ret & KXCJK1013_REG_CTRL1_BIT_PC1)
 256                 *mode = OPERATION;
 257         else
 258                 *mode = STANDBY;
 259
 260         return 0;
 261 }
 262
 263 static int kxcjk1013_set_range(struct kxcjk1013_data *data, int range_index)
 264 {
 265         int ret;
 266
 267         ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1);
 268         if (ret < 0) {
 269                 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
 270                 return ret;
 271         }
 272
 273         ret |= (KXCJK1013_scale_table[range_index].gsel_0 << 3);
 274         ret |= (KXCJK1013_scale_table[range_index].gsel_1 << 4);
 275
 276         ret = i2c_smbus_write_byte_data(data->client,
 277                                         KXCJK1013_REG_CTRL1,
 278                                         ret);
 279         if (ret < 0) {
 280                 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
 281                 return ret;
 282         }
 283
 284         data->range = range_index;
 285
 286         return 0;
 287 }
 288
 289 static int kxcjk1013_chip_init(struct kxcjk1013_data *data)
 290 {
 291         int ret;
 292
 293         ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_WHO_AM_I);
 294         if (ret < 0) {
 295                 dev_err(&data->client->dev, "Error reading who_am_i\n");
 296                 return ret;
 297         }
 298
 299         dev_dbg(&data->client->dev, "KXCJK1013 Chip Id %x\n", ret);
 300
 301         ret = kxcjk1013_set_mode(data, STANDBY);
 302         if (ret < 0)
 303                 return ret;
 304
 305         ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1);
 306         if (ret < 0) {
 307                 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
 308                 return ret;
 309         }
 310
 311         /* Set 12 bit mode */
 312         ret |= KXCJK1013_REG_CTRL1_BIT_RES;
 313
 314         ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_CTRL1,
 315                                         ret);
 316         if (ret < 0) {
 317                 dev_err(&data->client->dev, "Error reading reg_ctrl\n");
 318                 return ret;
 319         }
 320
 321         /* Setting range to 4G */
 322         ret = kxcjk1013_set_range(data, KXCJK1013_RANGE_4G);
 323         if (ret < 0)
 324                 return ret;
 325
 326         ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_DATA_CTRL);
 327         if (ret < 0) {
 328                 dev_err(&data->client->dev, "Error reading reg_data_ctrl\n");
 329                 return ret;
 330         }
 331
 332         data->odr_bits = ret;
 333
 334         /* Set up INT polarity */
 335         ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_CTRL1);
 336         if (ret < 0) {
 337                 dev_err(&data->client->dev, "Error reading reg_int_ctrl1\n");
 338                 return ret;
 339         }
 340
 341         if (data->active_high_intr)
 342                 ret |= KXCJK1013_REG_INT_REG1_BIT_IEA;
 343         else
 344                 ret &= ~KXCJK1013_REG_INT_REG1_BIT_IEA;
 345
 346         ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_INT_CTRL1,
 347                                         ret);
 348         if (ret < 0) {
 349                 dev_err(&data->client->dev, "Error writing reg_int_ctrl1\n");
 350                 return ret;
 351         }
 352
 353         ret = kxcjk1013_set_mode(data, OPERATION);
 354         if (ret < 0)
 355                 return ret;
 356
 357         data->wake_thres = KXCJK1013_DEFAULT_WAKE_THRES;
 358
 359         return 0;
 360 }
 361
 362 #ifdef CONFIG_PM_RUNTIME
 363 static int kxcjk1013_get_startup_times(struct kxcjk1013_data *data)
 364 {
 365         int i;
 366         int idx = data->chipset;
 367
 368         for (i = 0; i < ARRAY_SIZE(odr_start_up_times[idx]); ++i) {
 369                 if (odr_start_up_times[idx][i].odr_bits == data->odr_bits)
 370                         return odr_start_up_times[idx][i].usec;
 371         }
 372
 373         return KXCJK1013_MAX_STARTUP_TIME_US;
 374 }
 375 #endif
 376
 377 static int kxcjk1013_set_power_state(struct kxcjk1013_data *data, bool on)
 378 {
 379 #ifdef CONFIG_PM
 380         int ret;
 381
 382         if (on)
 383                 ret = pm_runtime_get_sync(&data->client->dev);
 384         else {
 385                 pm_runtime_mark_last_busy(&data->client->dev);
 386                 ret = pm_runtime_put_autosuspend(&data->client->dev);
 387         }
 388         if (ret < 0) {
 389                 dev_err(&data->client->dev,
 390                         "Failed: kxcjk1013_set_power_state for %d\n", on);
 391                 return ret;
 392         }
 393 #endif
 394
 395         return 0;
 396 }
 397
 398 static int kxcjk1013_chip_update_thresholds(struct kxcjk1013_data *data)
 399 {
 400         int ret;
 401
 402         ret = i2c_smbus_write_byte_data(data->client,
 403                                         KXCJK1013_REG_WAKE_TIMER,
 404                                         data->wake_dur);
 405         if (ret < 0) {
 406                 dev_err(&data->client->dev,
 407                         "Error writing reg_wake_timer\n");
 408                 return ret;
 409         }
 410
 411         ret = i2c_smbus_write_byte_data(data->client,
 412                                         KXCJK1013_REG_WAKE_THRES,
 413                                         data->wake_thres);
 414         if (ret < 0) {
 415                 dev_err(&data->client->dev, "Error writing reg_wake_thres\n");
 416                 return ret;
 417         }
 418
 419         return 0;
 420 }
 421
 422 static int kxcjk1013_setup_any_motion_interrupt(struct kxcjk1013_data *data,
 423                                                 bool status)
 424 {
 425         int ret;
 426         enum kxcjk1013_mode store_mode;
 427
 428         ret = kxcjk1013_get_mode(data, &store_mode);
 429         if (ret < 0)
 430                 return ret;
 431
 432         /* This is requirement by spec to change state to STANDBY */
 433         ret = kxcjk1013_set_mode(data, STANDBY);
 434         if (ret < 0)
 435                 return ret;
 436
 437         ret = kxcjk1013_chip_update_thresholds(data);
 438         if (ret < 0)
 439                 return ret;
 440
 441         ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_CTRL1);
 442         if (ret < 0) {
 443                 dev_err(&data->client->dev, "Error reading reg_int_ctrl1\n");
 444                 return ret;
 445         }
 446
 447         if (status)
 448                 ret |= KXCJK1013_REG_INT_REG1_BIT_IEN;
 449         else
 450                 ret &= ~KXCJK1013_REG_INT_REG1_BIT_IEN;
 451
 452         ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_INT_CTRL1,
 453                                         ret);
 454         if (ret < 0) {
 455                 dev_err(&data->client->dev, "Error writing reg_int_ctrl1\n");
 456                 return ret;
 457         }
 458
 459         ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1);
 460         if (ret < 0) {
 461                 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
 462                 return ret;
 463         }
 464
 465         if (status)
 466                 ret |= KXCJK1013_REG_CTRL1_BIT_WUFE;
 467         else
 468                 ret &= ~KXCJK1013_REG_CTRL1_BIT_WUFE;
 469
 470         ret = i2c_smbus_write_byte_data(data->client,
 471                                         KXCJK1013_REG_CTRL1, ret);
 472         if (ret < 0) {
 473                 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
 474                 return ret;
 475         }
 476
 477         if (store_mode == OPERATION) {
 478                 ret = kxcjk1013_set_mode(data, OPERATION);
 479                 if (ret < 0)
 480                         return ret;
 481         }
 482
 483         return 0;
 484 }
 485
 486 static int kxcjk1013_setup_new_data_interrupt(struct kxcjk1013_data *data,
 487                                               bool status)
 488 {
 489         int ret;
 490         enum kxcjk1013_mode store_mode;
 491
 492         ret = kxcjk1013_get_mode(data, &store_mode);
 493         if (ret < 0)
 494                 return ret;
 495
 496         /* This is requirement by spec to change state to STANDBY */
 497         ret = kxcjk1013_set_mode(data, STANDBY);
 498         if (ret < 0)
 499                 return ret;
 500
 501         ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_CTRL1);
 502         if (ret < 0) {
 503                 dev_err(&data->client->dev, "Error reading reg_int_ctrl1\n");
 504                 return ret;
 505         }
 506
 507         if (status)
 508                 ret |= KXCJK1013_REG_INT_REG1_BIT_IEN;
 509         else
 510                 ret &= ~KXCJK1013_REG_INT_REG1_BIT_IEN;
 511
 512         ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_INT_CTRL1,
 513                                         ret);
 514         if (ret < 0) {
 515                 dev_err(&data->client->dev, "Error writing reg_int_ctrl1\n");
 516                 return ret;
 517         }
 518
 519         ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1);
 520         if (ret < 0) {
 521                 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
 522                 return ret;
 523         }
 524
 525         if (status)
 526                 ret |= KXCJK1013_REG_CTRL1_BIT_DRDY;
 527         else
 528                 ret &= ~KXCJK1013_REG_CTRL1_BIT_DRDY;
 529
 530         ret = i2c_smbus_write_byte_data(data->client,
 531                                         KXCJK1013_REG_CTRL1, ret);
 532         if (ret < 0) {
 533                 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
 534                 return ret;
 535         }
 536
 537         if (store_mode == OPERATION) {
 538                 ret = kxcjk1013_set_mode(data, OPERATION);
 539                 if (ret < 0)
 540                         return ret;
 541         }
 542
 543         return 0;
 544 }
 545
 546 static int kxcjk1013_convert_freq_to_bit(int val, int val2)
 547 {
 548         int i;
 549
 550         for (i = 0; i < ARRAY_SIZE(samp_freq_table); ++i) {
 551                 if (samp_freq_table[i].val == val &&
 552                         samp_freq_table[i].val2 == val2) {
 553                         return samp_freq_table[i].odr_bits;
 554                 }
 555         }
 556
 557         return -EINVAL;
 558 }
 559
 560 static int kxcjk1013_convert_wake_odr_to_bit(int val, int val2)
 561 {
 562         int i;
 563
 564         for (i = 0; i < ARRAY_SIZE(wake_odr_data_rate_table); ++i) {
 565                 if (wake_odr_data_rate_table[i].val == val &&
 566                         wake_odr_data_rate_table[i].val2 == val2) {
 567                         return wake_odr_data_rate_table[i].odr_bits;
 568                 }
 569         }
 570
 571         return -EINVAL;
 572 }
 573
 574 static int kxcjk1013_set_odr(struct kxcjk1013_data *data, int val, int val2)
 575 {
 576         int ret;
 577         int odr_bits;
 578         enum kxcjk1013_mode store_mode;
 579
 580         ret = kxcjk1013_get_mode(data, &store_mode);
 581         if (ret < 0)
 582                 return ret;
 583
 584         odr_bits = kxcjk1013_convert_freq_to_bit(val, val2);
 585         if (odr_bits < 0)
 586                 return odr_bits;
 587
 588         /* To change ODR, the chip must be set to STANDBY as per spec */
 589         ret = kxcjk1013_set_mode(data, STANDBY);
 590         if (ret < 0)
 591                 return ret;
 592
 593         ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_DATA_CTRL,
 594                                         odr_bits);
 595         if (ret < 0) {
 596                 dev_err(&data->client->dev, "Error writing data_ctrl\n");
 597                 return ret;
 598         }
 599
 600         data->odr_bits = odr_bits;
 601
 602         odr_bits = kxcjk1013_convert_wake_odr_to_bit(val, val2);
 603         if (odr_bits < 0)
 604                 return odr_bits;
 605
 606         ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_CTRL2,
 607                                         odr_bits);
 608         if (ret < 0) {
 609                 dev_err(&data->client->dev, "Error writing reg_ctrl2\n");
 610                 return ret;
 611         }
 612
 613         if (store_mode == OPERATION) {
 614                 ret = kxcjk1013_set_mode(data, OPERATION);
 615                 if (ret < 0)
 616                         return ret;
 617         }
 618
 619         return 0;
 620 }
 621
 622 static int kxcjk1013_get_odr(struct kxcjk1013_data *data, int *val, int *val2)
 623 {
 624         int i;
 625
 626         for (i = 0; i < ARRAY_SIZE(samp_freq_table); ++i) {
 627                 if (samp_freq_table[i].odr_bits == data->odr_bits) {
 628                         *val = samp_freq_table[i].val;
 629                         *val2 = samp_freq_table[i].val2;
 630                         return IIO_VAL_INT_PLUS_MICRO;
 631                 }
 632         }
 633
 634         return -EINVAL;
 635 }
 636
 637 static int kxcjk1013_get_acc_reg(struct kxcjk1013_data *data, int axis)
 638 {
 639         u8 reg = KXCJK1013_REG_XOUT_L + axis * 2;
 640         int ret;
 641
 642         ret = i2c_smbus_read_word_data(data->client, reg);
 643         if (ret < 0) {
 644                 dev_err(&data->client->dev,
 645                         "failed to read accel_%c registers\n", 'x' + axis);
 646                 return ret;
 647         }
 648
 649         return ret;
 650 }
 651
 652 static int kxcjk1013_set_scale(struct kxcjk1013_data *data, int val)
 653 {
 654         int ret, i;
 655         enum kxcjk1013_mode store_mode;
 656
 657
 658         for (i = 0; i < ARRAY_SIZE(KXCJK1013_scale_table); ++i) {
 659                 if (KXCJK1013_scale_table[i].scale == val) {
 660
 661                         ret = kxcjk1013_get_mode(data, &store_mode);
 662                         if (ret < 0)
 663                                 return ret;
 664
 665                         ret = kxcjk1013_set_mode(data, STANDBY);
 666                         if (ret < 0)
 667                                 return ret;
 668
 669                         ret = kxcjk1013_set_range(data, i);
 670                         if (ret < 0)
 671                                 return ret;
 672
 673                         if (store_mode == OPERATION) {
 674                                 ret = kxcjk1013_set_mode(data, OPERATION);
 675                                 if (ret)
 676                                         return ret;
 677                         }
 678
 679                         return 0;
 680                 }
 681         }
 682
 683         return -EINVAL;
 684 }
 685
 686 static int kxcjk1013_read_raw(struct iio_dev *indio_dev,
 687                               struct iio_chan_spec const *chan, int *val,
 688                               int *val2, long mask)
 689 {
 690         struct kxcjk1013_data *data = iio_priv(indio_dev);
 691         int ret;
 692
 693         switch (mask) {
 694         case IIO_CHAN_INFO_RAW:
 695                 mutex_lock(&data->mutex);
 696                 if (iio_buffer_enabled(indio_dev))
 697                         ret = -EBUSY;
 698                 else {
 699                         ret = kxcjk1013_set_power_state(data, true);
 700                         if (ret < 0) {
 701                                 mutex_unlock(&data->mutex);
 702                                 return ret;
 703                         }
 704                         ret = kxcjk1013_get_acc_reg(data, chan->scan_index);
 705                         if (ret < 0) {
 706                                 kxcjk1013_set_power_state(data, false);
 707                                 mutex_unlock(&data->mutex);
 708                                 return ret;
 709                         }
 710                         *val = sign_extend32(ret >> 4, 11);
 711                         ret = kxcjk1013_set_power_state(data, false);
 712                 }
 713                 mutex_unlock(&data->mutex);
 714
 715                 if (ret < 0)
 716                         return ret;
 717
 718                 return IIO_VAL_INT;
 719
 720         case IIO_CHAN_INFO_SCALE:
 721                 *val = 0;
 722                 *val2 = KXCJK1013_scale_table[data->range].scale;
 723                 return IIO_VAL_INT_PLUS_MICRO;
 724
 725         case IIO_CHAN_INFO_SAMP_FREQ:
 726                 mutex_lock(&data->mutex);
 727                 ret = kxcjk1013_get_odr(data, val, val2);
 728                 mutex_unlock(&data->mutex);
 729                 return ret;
 730
 731         default:
 732                 return -EINVAL;
 733         }
 734 }
 735
 736 static int kxcjk1013_write_raw(struct iio_dev *indio_dev,
 737                                struct iio_chan_spec const *chan, int val,
 738                                int val2, long mask)
 739 {
 740         struct kxcjk1013_data *data = iio_priv(indio_dev);
 741         int ret;
 742
 743         switch (mask) {
 744         case IIO_CHAN_INFO_SAMP_FREQ:
 745                 mutex_lock(&data->mutex);
 746                 ret = kxcjk1013_set_odr(data, val, val2);
 747                 mutex_unlock(&data->mutex);
 748                 break;
 749         case IIO_CHAN_INFO_SCALE:
 750                 if (val)
 751                         return -EINVAL;
 752
 753                 mutex_lock(&data->mutex);
 754                 ret = kxcjk1013_set_scale(data, val2);
 755                 mutex_unlock(&data->mutex);
 756                 break;
 757         default:
 758                 ret = -EINVAL;
 759         }
 760
 761         return ret;
 762 }
 763
 764 static int kxcjk1013_read_event(struct iio_dev *indio_dev,
 765                                    const struct iio_chan_spec *chan,
 766                                    enum iio_event_type type,
 767                                    enum iio_event_direction dir,
 768                                    enum iio_event_info info,
 769                                    int *val, int *val2)
 770 {
 771         struct kxcjk1013_data *data = iio_priv(indio_dev);
 772
 773         *val2 = 0;
 774         switch (info) {
 775         case IIO_EV_INFO_VALUE:
 776                 *val = data->wake_thres;
 777                 break;
 778         case IIO_EV_INFO_PERIOD:
 779                 *val = data->wake_dur;
 780                 break;
 781         default:
 782                 return -EINVAL;
 783         }
 784
 785         return IIO_VAL_INT;
 786 }
 787
 788 static int kxcjk1013_write_event(struct iio_dev *indio_dev,
 789                                     const struct iio_chan_spec *chan,
 790                                     enum iio_event_type type,
 791                                     enum iio_event_direction dir,
 792                                     enum iio_event_info info,
 793                                     int val, int val2)
 794 {
 795         struct kxcjk1013_data *data = iio_priv(indio_dev);
 796
 797         if (data->ev_enable_state)
 798                 return -EBUSY;
 799
 800         switch (info) {
 801         case IIO_EV_INFO_VALUE:
 802                 data->wake_thres = val;
 803                 break;
 804         case IIO_EV_INFO_PERIOD:
 805                 data->wake_dur = val;
 806                 break;
 807         default:
 808                 return -EINVAL;
 809         }
 810
 811         return 0;
 812 }
 813
 814 static int kxcjk1013_read_event_config(struct iio_dev *indio_dev,
 815                                           const struct iio_chan_spec *chan,
 816                                           enum iio_event_type type,
 817                                           enum iio_event_direction dir)
 818 {
 819
 820         struct kxcjk1013_data *data = iio_priv(indio_dev);
 821
 822         return data->ev_enable_state;
 823 }
 824
 825 static int kxcjk1013_write_event_config(struct iio_dev *indio_dev,
 826                                            const struct iio_chan_spec *chan,
 827                                            enum iio_event_type type,
 828                                            enum iio_event_direction dir,
 829                                            int state)
 830 {
 831         struct kxcjk1013_data *data = iio_priv(indio_dev);
 832         int ret;
 833
 834         if (state && data->ev_enable_state)
 835                 return 0;
 836
 837         mutex_lock(&data->mutex);
 838
 839         if (!state && data->motion_trigger_on) {
 840                 data->ev_enable_state = 0;
 841                 mutex_unlock(&data->mutex);
 842                 return 0;
 843         }
 844
 845         /*
 846          * We will expect the enable and disable to do operation in
 847          * in reverse order. This will happen here anyway as our
 848          * resume operation uses sync mode runtime pm calls, the
 849          * suspend operation will be delayed by autosuspend delay
 850          * So the disable operation will still happen in reverse of
 851          * enable operation. When runtime pm is disabled the mode
 852          * is always on so sequence doesn't matter
 853          */
 854         ret = kxcjk1013_set_power_state(data, state);
 855         if (ret < 0) {
 856                 mutex_unlock(&data->mutex);
 857                 return ret;
 858         }
 859
 860         ret =  kxcjk1013_setup_any_motion_interrupt(data, state);
 861         if (ret < 0) {
 862                 mutex_unlock(&data->mutex);
 863                 return ret;
 864         }
 865
 866         data->ev_enable_state = state;
 867         mutex_unlock(&data->mutex);
 868
 869         return 0;
 870 }
 871
 872 static int kxcjk1013_validate_trigger(struct iio_dev *indio_dev,
 873                                       struct iio_trigger *trig)
 874 {
 875         struct kxcjk1013_data *data = iio_priv(indio_dev);
 876
 877         if (data->dready_trig != trig && data->motion_trig != trig)
 878                 return -EINVAL;
 879
 880         return 0;
 881 }
 882
 883 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(
 884         "0.781000 1.563000 3.125000 6.250000 12.500000 25 50 100 200 400 800 1600");
 885
 886 static IIO_CONST_ATTR(in_accel_scale_available, "0.009582 0.019163 0.038326");
 887
 888 static struct attribute *kxcjk1013_attributes[] = {
 889         &iio_const_attr_sampling_frequency_available.dev_attr.attr,
 890         &iio_const_attr_in_accel_scale_available.dev_attr.attr,
 891         NULL,
 892 };
 893
 894 static const struct attribute_group kxcjk1013_attrs_group = {
 895         .attrs = kxcjk1013_attributes,
 896 };
 897
 898 static const struct iio_event_spec kxcjk1013_event = {
 899                 .type = IIO_EV_TYPE_THRESH,
 900                 .dir = IIO_EV_DIR_RISING | IIO_EV_DIR_FALLING,
 901                 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
 902                                  BIT(IIO_EV_INFO_ENABLE) |
 903                                  BIT(IIO_EV_INFO_PERIOD)
 904 };
 905
 906 #define KXCJK1013_CHANNEL(_axis) {                                      \
 907         .type = IIO_ACCEL,                                              \
 908         .modified = 1,                                                  \
 909         .channel2 = IIO_MOD_##_axis,                                    \
 910         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),                   \
 911         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |          \
 912                                 BIT(IIO_CHAN_INFO_SAMP_FREQ),           \
 913         .scan_index = AXIS_##_axis,                                     \
 914         .scan_type = {                                                  \
 915                 .sign = 's',                                            \
 916                 .realbits = 12,                                         \
 917                 .storagebits = 16,                                      \
 918                 .shift = 4,                                             \
 919                 .endianness = IIO_CPU,                                  \
 920         },                                                              \
 921         .event_spec = &kxcjk1013_event,                         \
 922         .num_event_specs = 1                                            \
 923 }
 924
 925 static const struct iio_chan_spec kxcjk1013_channels[] = {
 926         KXCJK1013_CHANNEL(X),
 927         KXCJK1013_CHANNEL(Y),
 928         KXCJK1013_CHANNEL(Z),
 929         IIO_CHAN_SOFT_TIMESTAMP(3),
 930 };
 931
 932 static const struct iio_info kxcjk1013_info = {
 933         .attrs                  = &kxcjk1013_attrs_group,
 934         .read_raw               = kxcjk1013_read_raw,
 935         .write_raw              = kxcjk1013_write_raw,
 936         .read_event_value       = kxcjk1013_read_event,
 937         .write_event_value      = kxcjk1013_write_event,
 938         .write_event_config     = kxcjk1013_write_event_config,
 939         .read_event_config      = kxcjk1013_read_event_config,
 940         .validate_trigger       = kxcjk1013_validate_trigger,
 941         .driver_module          = THIS_MODULE,
 942 };
 943
 944 static irqreturn_t kxcjk1013_trigger_handler(int irq, void *p)
 945 {
 946         struct iio_poll_func *pf = p;
 947         struct iio_dev *indio_dev = pf->indio_dev;
 948         struct kxcjk1013_data *data = iio_priv(indio_dev);
 949         int bit, ret, i = 0;
 950
 951         mutex_lock(&data->mutex);
 952
 953         for_each_set_bit(bit, indio_dev->buffer->scan_mask,
 954                          indio_dev->masklength) {
 955                 ret = kxcjk1013_get_acc_reg(data, bit);
 956                 if (ret < 0) {
 957                         mutex_unlock(&data->mutex);
 958                         goto err;
 959                 }
 960                 data->buffer[i++] = ret;
 961         }
 962         mutex_unlock(&data->mutex);
 963
 964         iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
 965                                            data->timestamp);
 966 err:
 967         iio_trigger_notify_done(indio_dev->trig);
 968
 969         return IRQ_HANDLED;
 970 }
 971
 972 static int kxcjk1013_trig_try_reen(struct iio_trigger *trig)
 973 {
 974         struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
 975         struct kxcjk1013_data *data = iio_priv(indio_dev);
 976         int ret;
 977
 978         ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_REL);
 979         if (ret < 0) {
 980                 dev_err(&data->client->dev, "Error reading reg_int_rel\n");
 981                 return ret;
 982         }
 983
 984         return 0;
 985 }
 986
 987 static int kxcjk1013_data_rdy_trigger_set_state(struct iio_trigger *trig,
 988                                                 bool state)
 989 {
 990         struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
 991         struct kxcjk1013_data *data = iio_priv(indio_dev);
 992         int ret;
 993
 994         mutex_lock(&data->mutex);
 995
 996         if (!state && data->ev_enable_state && data->motion_trigger_on) {
 997                 data->motion_trigger_on = false;
 998                 mutex_unlock(&data->mutex);
 999                 return 0;
1000         }
1001
1002         ret = kxcjk1013_set_power_state(data, state);
1003         if (ret < 0) {
1004                 mutex_unlock(&data->mutex);
1005                 return ret;
1006         }
1007         if (data->motion_trig == trig)
1008                 ret = kxcjk1013_setup_any_motion_interrupt(data, state);
1009         else
1010                 ret = kxcjk1013_setup_new_data_interrupt(data, state);
1011         if (ret < 0) {
1012                 mutex_unlock(&data->mutex);
1013                 return ret;
1014         }
1015         if (data->motion_trig == trig)
1016                 data->motion_trigger_on = state;
1017         else
1018                 data->dready_trigger_on = state;
1019
1020         mutex_unlock(&data->mutex);
1021
1022         return 0;
1023 }
1024
1025 static const struct iio_trigger_ops kxcjk1013_trigger_ops = {
1026         .set_trigger_state = kxcjk1013_data_rdy_trigger_set_state,
1027         .try_reenable = kxcjk1013_trig_try_reen,
1028         .owner = THIS_MODULE,
1029 };
1030
1031 static irqreturn_t kxcjk1013_event_handler(int irq, void *private)
1032 {
1033         struct iio_dev *indio_dev = private;
1034         struct kxcjk1013_data *data = iio_priv(indio_dev);
1035         int ret;
1036
1037         ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_SRC1);
1038         if (ret < 0) {
1039                 dev_err(&data->client->dev, "Error reading reg_int_src1\n");
1040                 goto ack_intr;
1041         }
1042
1043         if (ret & 0x02) {
1044                 ret = i2c_smbus_read_byte_data(data->client,
1045                                                KXCJK1013_REG_INT_SRC2);
1046                 if (ret < 0) {
1047                         dev_err(&data->client->dev,
1048                                 "Error reading reg_int_src2\n");
1049                         goto ack_intr;
1050                 }
1051
1052                 if (ret & KXCJK1013_REG_INT_SRC2_BIT_XN)
1053                         iio_push_event(indio_dev,
1054                                        IIO_MOD_EVENT_CODE(IIO_ACCEL,
1055                                        0,
1056                                        IIO_MOD_X,
1057                                        IIO_EV_TYPE_THRESH,
1058                                        IIO_EV_DIR_FALLING),
1059                                        data->timestamp);
1060                 if (ret & KXCJK1013_REG_INT_SRC2_BIT_XP)
1061                         iio_push_event(indio_dev,
1062                                        IIO_MOD_EVENT_CODE(IIO_ACCEL,
1063                                        0,
1064                                        IIO_MOD_X,
1065                                        IIO_EV_TYPE_THRESH,
1066                                        IIO_EV_DIR_RISING),
1067                                        data->timestamp);
1068
1069
1070                 if (ret & KXCJK1013_REG_INT_SRC2_BIT_YN)
1071                         iio_push_event(indio_dev,
1072                                        IIO_MOD_EVENT_CODE(IIO_ACCEL,
1073                                        0,
1074                                        IIO_MOD_Y,
1075                                        IIO_EV_TYPE_THRESH,
1076                                        IIO_EV_DIR_FALLING),
1077                                        data->timestamp);
1078                 if (ret & KXCJK1013_REG_INT_SRC2_BIT_YP)
1079                         iio_push_event(indio_dev,
1080                                        IIO_MOD_EVENT_CODE(IIO_ACCEL,
1081                                        0,
1082                                        IIO_MOD_Y,
1083                                        IIO_EV_TYPE_THRESH,
1084                                        IIO_EV_DIR_RISING),
1085                                        data->timestamp);
1086
1087                 if (ret & KXCJK1013_REG_INT_SRC2_BIT_ZN)
1088                         iio_push_event(indio_dev,
1089                                        IIO_MOD_EVENT_CODE(IIO_ACCEL,
1090                                        0,
1091                                        IIO_MOD_Z,
1092                                        IIO_EV_TYPE_THRESH,
1093                                        IIO_EV_DIR_FALLING),
1094                                        data->timestamp);
1095                 if (ret & KXCJK1013_REG_INT_SRC2_BIT_ZP)
1096                         iio_push_event(indio_dev,
1097                                        IIO_MOD_EVENT_CODE(IIO_ACCEL,
1098                                        0,
1099                                        IIO_MOD_Z,
1100                                        IIO_EV_TYPE_THRESH,
1101                                        IIO_EV_DIR_RISING),
1102                                        data->timestamp);
1103         }
1104
1105 ack_intr:
1106         if (data->dready_trigger_on)
1107                 return IRQ_HANDLED;
1108
1109         ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_REL);
1110         if (ret < 0)
1111                 dev_err(&data->client->dev, "Error reading reg_int_rel\n");
1112
1113         return IRQ_HANDLED;
1114 }
1115
1116 static irqreturn_t kxcjk1013_data_rdy_trig_poll(int irq, void *private)
1117 {
1118         struct iio_dev *indio_dev = private;
1119         struct kxcjk1013_data *data = iio_priv(indio_dev);
1120
1121         data->timestamp = iio_get_time_ns();
1122
1123         if (data->dready_trigger_on)
1124                 iio_trigger_poll(data->dready_trig);
1125         else if (data->motion_trigger_on)
1126                 iio_trigger_poll(data->motion_trig);
1127
1128         if (data->ev_enable_state)
1129                 return IRQ_WAKE_THREAD;
1130         else
1131                 return IRQ_HANDLED;
1132 }
1133
1134 static const char *kxcjk1013_match_acpi_device(struct device *dev,
1135                                                enum kx_chipset *chipset,
1136                                                bool *is_smo8500_device)
1137 {
1138         const struct acpi_device_id *id;
1139         id = acpi_match_device(dev->driver->acpi_match_table, dev);
1140         if (!id)
1141                 return NULL;
1142         if (strcmp(id->id, "SMO8500") == 0)
1143                 *is_smo8500_device = true;
1144         *chipset = (enum kx_chipset)id->driver_data;
1145
1146         return dev_name(dev);
1147 }
1148
1149 static int kxcjk1013_gpio_probe(struct i2c_client *client,
1150                                 struct kxcjk1013_data *data)
1151 {
1152         struct device *dev;
1153         struct gpio_desc *gpio;
1154         int ret;
1155
1156         if (!client)
1157                 return -EINVAL;
1158         if (data->is_smo8500_device)
1159                 return -ENOTSUPP;
1160
1161         dev = &client->dev;
1162
1163         /* data ready gpio interrupt pin */
1164         gpio = devm_gpiod_get_index(dev, "kxcjk1013_int", 0);
1165         if (IS_ERR(gpio)) {
1166                 dev_err(dev, "acpi gpio get index failed\n");
1167                 return PTR_ERR(gpio);
1168         }
1169
1170         ret = gpiod_direction_input(gpio);
1171         if (ret)
1172                 return ret;
1173
1174         ret = gpiod_to_irq(gpio);
1175
1176         dev_dbg(dev, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio), ret);
1177
1178         return ret;
1179 }
1180
1181 static int kxcjk1013_probe(struct i2c_client *client,
1182                            const struct i2c_device_id *id)
1183 {
1184         struct kxcjk1013_data *data;
1185         struct iio_dev *indio_dev;
1186         struct kxcjk_1013_platform_data *pdata;
1187         const char *name;
1188         int ret;
1189
1190         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
1191         if (!indio_dev)
1192                 return -ENOMEM;
1193
1194         data = iio_priv(indio_dev);
1195         i2c_set_clientdata(client, indio_dev);
1196         data->client = client;
1197
1198         pdata = dev_get_platdata(&client->dev);
1199         if (pdata)
1200                 data->active_high_intr = pdata->active_high_intr;
1201         else
1202                 data->active_high_intr = true; /* default polarity */
1203
1204         if (id) {
1205                 data->chipset = (enum kx_chipset)(id->driver_data);
1206                 name = id->name;
1207         } else if (ACPI_HANDLE(&client->dev)) {
1208                 name = kxcjk1013_match_acpi_device(&client->dev,
1209                                                    &data->chipset,
1210                                                    &data->is_smo8500_device);
1211         } else
1212                 return -ENODEV;
1213
1214         ret = kxcjk1013_chip_init(data);
1215         if (ret < 0)
1216                 return ret;
1217
1218         mutex_init(&data->mutex);
1219
1220         indio_dev->dev.parent = &client->dev;
1221         indio_dev->channels = kxcjk1013_channels;
1222         indio_dev->num_channels = ARRAY_SIZE(kxcjk1013_channels);
1223         indio_dev->name = name;
1224         indio_dev->modes = INDIO_DIRECT_MODE;
1225         indio_dev->info = &kxcjk1013_info;
1226
1227         if (client->irq < 0)
1228                 client->irq = kxcjk1013_gpio_probe(client, data);
1229
1230         if (client->irq >= 0) {
1231                 ret = devm_request_threaded_irq(&client->dev, client->irq,
1232                                                 kxcjk1013_data_rdy_trig_poll,
1233                                                 kxcjk1013_event_handler,
1234                                                 IRQF_TRIGGER_RISING,
1235                                                 KXCJK1013_IRQ_NAME,
1236                                                 indio_dev);
1237                 if (ret)
1238                         return ret;
1239
1240                 data->dready_trig = devm_iio_trigger_alloc(&client->dev,
1241                                                            "%s-dev%d",
1242                                                            indio_dev->name,
1243                                                            indio_dev->id);
1244                 if (!data->dready_trig)
1245                         return -ENOMEM;
1246
1247                 data->motion_trig = devm_iio_trigger_alloc(&client->dev,
1248                                                           "%s-any-motion-dev%d",
1249                                                           indio_dev->name,
1250                                                           indio_dev->id);
1251                 if (!data->motion_trig)
1252                         return -ENOMEM;
1253
1254                 data->dready_trig->dev.parent = &client->dev;
1255                 data->dready_trig->ops = &kxcjk1013_trigger_ops;
1256                 iio_trigger_set_drvdata(data->dready_trig, indio_dev);
1257                 indio_dev->trig = data->dready_trig;
1258                 iio_trigger_get(indio_dev->trig);
1259                 ret = iio_trigger_register(data->dready_trig);
1260                 if (ret)
1261                         return ret;
1262
1263                 data->motion_trig->dev.parent = &client->dev;
1264                 data->motion_trig->ops = &kxcjk1013_trigger_ops;
1265                 iio_trigger_set_drvdata(data->motion_trig, indio_dev);
1266                 ret = iio_trigger_register(data->motion_trig);
1267                 if (ret) {
1268                         data->motion_trig = NULL;
1269                         goto err_trigger_unregister;
1270                 }
1271
1272                 ret = iio_triggered_buffer_setup(indio_dev,
1273                                                 &iio_pollfunc_store_time,
1274                                                 kxcjk1013_trigger_handler,
1275                                                 NULL);
1276                 if (ret < 0) {
1277                         dev_err(&client->dev,
1278                                         "iio triggered buffer setup failed\n");
1279                         goto err_trigger_unregister;
1280                 }
1281         }
1282
1283         ret = iio_device_register(indio_dev);
1284         if (ret < 0) {
1285                 dev_err(&client->dev, "unable to register iio device\n");
1286                 goto err_buffer_cleanup;
1287         }
1288
1289         ret = pm_runtime_set_active(&client->dev);
1290         if (ret)
1291                 goto err_iio_unregister;
1292
1293         pm_runtime_enable(&client->dev);
1294         pm_runtime_set_autosuspend_delay(&client->dev,
1295                                          KXCJK1013_SLEEP_DELAY_MS);
1296         pm_runtime_use_autosuspend(&client->dev);
1297
1298         return 0;
1299
1300 err_iio_unregister:
1301         iio_device_unregister(indio_dev);
1302 err_buffer_cleanup:
1303         if (data->dready_trig)
1304                 iio_triggered_buffer_cleanup(indio_dev);
1305 err_trigger_unregister:
1306         if (data->dready_trig)
1307                 iio_trigger_unregister(data->dready_trig);
1308         if (data->motion_trig)
1309                 iio_trigger_unregister(data->motion_trig);
1310
1311         return ret;
1312 }
1313
1314 static int kxcjk1013_remove(struct i2c_client *client)
1315 {
1316         struct iio_dev *indio_dev = i2c_get_clientdata(client);
1317         struct kxcjk1013_data *data = iio_priv(indio_dev);
1318
1319         pm_runtime_disable(&client->dev);
1320         pm_runtime_set_suspended(&client->dev);
1321         pm_runtime_put_noidle(&client->dev);
1322
1323         iio_device_unregister(indio_dev);
1324
1325         if (data->dready_trig) {
1326                 iio_triggered_buffer_cleanup(indio_dev);
1327                 iio_trigger_unregister(data->dready_trig);
1328                 iio_trigger_unregister(data->motion_trig);
1329         }
1330
1331         mutex_lock(&data->mutex);
1332         kxcjk1013_set_mode(data, STANDBY);
1333         mutex_unlock(&data->mutex);
1334
1335         return 0;
1336 }
1337
1338 #ifdef CONFIG_PM_SLEEP
1339 static int kxcjk1013_suspend(struct device *dev)
1340 {
1341         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1342         struct kxcjk1013_data *data = iio_priv(indio_dev);
1343         int ret;
1344
1345         mutex_lock(&data->mutex);
1346         ret = kxcjk1013_set_mode(data, STANDBY);
1347         mutex_unlock(&data->mutex);
1348
1349         return ret;
1350 }
1351
1352 static int kxcjk1013_resume(struct device *dev)
1353 {
1354         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1355         struct kxcjk1013_data *data = iio_priv(indio_dev);
1356         int ret = 0;
1357
1358         mutex_lock(&data->mutex);
1359         ret = kxcjk1013_set_mode(data, OPERATION);
1360         mutex_unlock(&data->mutex);
1361
1362         return ret;
1363 }
1364 #endif
1365
1366 #ifdef CONFIG_PM_RUNTIME
1367 static int kxcjk1013_runtime_suspend(struct device *dev)
1368 {
1369         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1370         struct kxcjk1013_data *data = iio_priv(indio_dev);
1371
1372         return kxcjk1013_set_mode(data, STANDBY);
1373 }
1374
1375 static int kxcjk1013_runtime_resume(struct device *dev)
1376 {
1377         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1378         struct kxcjk1013_data *data = iio_priv(indio_dev);
1379         int ret;
1380         int sleep_val;
1381
1382         ret = kxcjk1013_set_mode(data, OPERATION);
1383         if (ret < 0)
1384                 return ret;
1385
1386         sleep_val = kxcjk1013_get_startup_times(data);
1387         if (sleep_val < 20000)
1388                 usleep_range(sleep_val, 20000);
1389         else
1390                 msleep_interruptible(sleep_val/1000);
1391
1392         return 0;
1393 }
1394 #endif
1395
1396 static const struct dev_pm_ops kxcjk1013_pm_ops = {
1397         SET_SYSTEM_SLEEP_PM_OPS(kxcjk1013_suspend, kxcjk1013_resume)
1398         SET_RUNTIME_PM_OPS(kxcjk1013_runtime_suspend,
1399                            kxcjk1013_runtime_resume, NULL)
1400 };
1401
1402 static const struct acpi_device_id kx_acpi_match[] = {
1403         {"KXCJ1013", KXCJK1013},
1404         {"KXCJ1008", KXCJ91008},
1405         {"KXTJ1009", KXTJ21009},
1406         {"SMO8500",  KXCJ91008},
1407         { },
1408 };
1409 MODULE_DEVICE_TABLE(acpi, kx_acpi_match);
1410
1411 static const struct i2c_device_id kxcjk1013_id[] = {
1412         {"kxcjk1013", KXCJK1013},
1413         {"kxcj91008", KXCJ91008},
1414         {"kxtj21009", KXTJ21009},
1415         {"SMO8500",   KXCJ91008},
1416         {}
1417 };
1418
1419 MODULE_DEVICE_TABLE(i2c, kxcjk1013_id);
1420
1421 static struct i2c_driver kxcjk1013_driver = {
1422         .driver = {
1423                 .name   = KXCJK1013_DRV_NAME,
1424                 .acpi_match_table = ACPI_PTR(kx_acpi_match),
1425                 .pm     = &kxcjk1013_pm_ops,
1426         },
1427         .probe          = kxcjk1013_probe,
1428         .remove         = kxcjk1013_remove,
1429         .id_table       = kxcjk1013_id,
1430 };
1431 module_i2c_driver(kxcjk1013_driver);
1432
1433 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
1434 MODULE_LICENSE("GPL v2");
1435 MODULE_DESCRIPTION("KXCJK1013 accelerometer driver");