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