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