drivers/iio/accel/kxcjk-1013.c

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