drivers/iio/imu/kmx61.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * KMX61 - Kionix 6-axis Accelerometer/Magnetometer
   4  *
   5  * Copyright (c) 2014, Intel Corporation.
   6  *
   7  * IIO driver for KMX61 (7-bit I2C slave address 0x0E or 0x0F).
   8  */
   9
  10 #include <linux/module.h>
  11 #include <linux/i2c.h>
  12 #include <linux/acpi.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/pm.h>
  15 #include <linux/pm_runtime.h>
  16 #include <linux/iio/iio.h>
  17 #include <linux/iio/sysfs.h>
  18 #include <linux/iio/events.h>
  19 #include <linux/iio/trigger.h>
  20 #include <linux/iio/buffer.h>
  21 #include <linux/iio/triggered_buffer.h>
  22 #include <linux/iio/trigger_consumer.h>
  23
  24 #define KMX61_DRV_NAME "kmx61"
  25 #define KMX61_IRQ_NAME "kmx61_event"
  26
  27 #define KMX61_REG_WHO_AM_I      0x00
  28 #define KMX61_REG_INS1          0x01
  29 #define KMX61_REG_INS2          0x02
  30
  31 /*
  32  * three 16-bit accelerometer output registers for X/Y/Z axis
  33  * we use only XOUT_L as a base register, all other addresses
  34  * can be obtained by applying an offset and are provided here
  35  * only for clarity.
  36  */
  37 #define KMX61_ACC_XOUT_L        0x0A
  38 #define KMX61_ACC_XOUT_H        0x0B
  39 #define KMX61_ACC_YOUT_L        0x0C
  40 #define KMX61_ACC_YOUT_H        0x0D
  41 #define KMX61_ACC_ZOUT_L        0x0E
  42 #define KMX61_ACC_ZOUT_H        0x0F
  43
  44 /*
  45  * one 16-bit temperature output register
  46  */
  47 #define KMX61_TEMP_L            0x10
  48 #define KMX61_TEMP_H            0x11
  49
  50 /*
  51  * three 16-bit magnetometer output registers for X/Y/Z axis
  52  */
  53 #define KMX61_MAG_XOUT_L        0x12
  54 #define KMX61_MAG_XOUT_H        0x13
  55 #define KMX61_MAG_YOUT_L        0x14
  56 #define KMX61_MAG_YOUT_H        0x15
  57 #define KMX61_MAG_ZOUT_L        0x16
  58 #define KMX61_MAG_ZOUT_H        0x17
  59
  60 #define KMX61_REG_INL           0x28
  61 #define KMX61_REG_STBY          0x29
  62 #define KMX61_REG_CTRL1         0x2A
  63 #define KMX61_REG_CTRL2         0x2B
  64 #define KMX61_REG_ODCNTL        0x2C
  65 #define KMX61_REG_INC1          0x2D
  66
  67 #define KMX61_REG_WUF_THRESH    0x3D
  68 #define KMX61_REG_WUF_TIMER     0x3E
  69
  70 #define KMX61_ACC_STBY_BIT      BIT(0)
  71 #define KMX61_MAG_STBY_BIT      BIT(1)
  72 #define KMX61_ACT_STBY_BIT      BIT(7)
  73
  74 #define KMX61_ALL_STBY          (KMX61_ACC_STBY_BIT | KMX61_MAG_STBY_BIT)
  75
  76 #define KMX61_REG_INS1_BIT_WUFS         BIT(1)
  77
  78 #define KMX61_REG_INS2_BIT_ZP           BIT(0)
  79 #define KMX61_REG_INS2_BIT_ZN           BIT(1)
  80 #define KMX61_REG_INS2_BIT_YP           BIT(2)
  81 #define KMX61_REG_INS2_BIT_YN           BIT(3)
  82 #define KMX61_REG_INS2_BIT_XP           BIT(4)
  83 #define KMX61_REG_INS2_BIT_XN           BIT(5)
  84
  85 #define KMX61_REG_CTRL1_GSEL_MASK       0x03
  86
  87 #define KMX61_REG_CTRL1_BIT_RES         BIT(4)
  88 #define KMX61_REG_CTRL1_BIT_DRDYE       BIT(5)
  89 #define KMX61_REG_CTRL1_BIT_WUFE        BIT(6)
  90 #define KMX61_REG_CTRL1_BIT_BTSE        BIT(7)
  91
  92 #define KMX61_REG_INC1_BIT_WUFS         BIT(0)
  93 #define KMX61_REG_INC1_BIT_DRDYM        BIT(1)
  94 #define KMX61_REG_INC1_BIT_DRDYA        BIT(2)
  95 #define KMX61_REG_INC1_BIT_IEN          BIT(5)
  96
  97 #define KMX61_ACC_ODR_SHIFT     0
  98 #define KMX61_MAG_ODR_SHIFT     4
  99 #define KMX61_ACC_ODR_MASK      0x0F
 100 #define KMX61_MAG_ODR_MASK      0xF0
 101
 102 #define KMX61_OWUF_MASK         0x7
 103
 104 #define KMX61_DEFAULT_WAKE_THRESH       1
 105 #define KMX61_DEFAULT_WAKE_DURATION     1
 106
 107 #define KMX61_SLEEP_DELAY_MS    2000
 108
 109 #define KMX61_CHIP_ID           0x12
 110
 111 /* KMX61 devices */
 112 #define KMX61_ACC       0x01
 113 #define KMX61_MAG       0x02
 114
 115 struct kmx61_data {
 116         struct i2c_client *client;
 117
 118         /* serialize access to non-atomic ops, e.g set_mode */
 119         struct mutex lock;
 120
 121         /* standby state */
 122         bool acc_stby;
 123         bool mag_stby;
 124
 125         /* power state */
 126         bool acc_ps;
 127         bool mag_ps;
 128
 129         /* config bits */
 130         u8 range;
 131         u8 odr_bits;
 132         u8 wake_thresh;
 133         u8 wake_duration;
 134
 135         /* accelerometer specific data */
 136         struct iio_dev *acc_indio_dev;
 137         struct iio_trigger *acc_dready_trig;
 138         struct iio_trigger *motion_trig;
 139         bool acc_dready_trig_on;
 140         bool motion_trig_on;
 141         bool ev_enable_state;
 142
 143         /* magnetometer specific data */
 144         struct iio_dev *mag_indio_dev;
 145         struct iio_trigger *mag_dready_trig;
 146         bool mag_dready_trig_on;
 147 };
 148
 149 enum kmx61_range {
 150         KMX61_RANGE_2G,
 151         KMX61_RANGE_4G,
 152         KMX61_RANGE_8G,
 153 };
 154
 155 enum kmx61_axis {
 156         KMX61_AXIS_X,
 157         KMX61_AXIS_Y,
 158         KMX61_AXIS_Z,
 159 };
 160
 161 static const u16 kmx61_uscale_table[] = {9582, 19163, 38326};
 162
 163 static const struct {
 164         int val;
 165         int val2;
 166 } kmx61_samp_freq_table[] = { {12, 500000},
 167                         {25, 0},
 168                         {50, 0},
 169                         {100, 0},
 170                         {200, 0},
 171                         {400, 0},
 172                         {800, 0},
 173                         {1600, 0},
 174                         {0, 781000},
 175                         {1, 563000},
 176                         {3, 125000},
 177                         {6, 250000} };
 178
 179 static const struct {
 180         int val;
 181         int val2;
 182         int odr_bits;
 183 } kmx61_wake_up_odr_table[] = { {0, 781000, 0x00},
 184                                  {1, 563000, 0x01},
 185                                  {3, 125000, 0x02},
 186                                  {6, 250000, 0x03},
 187                                  {12, 500000, 0x04},
 188                                  {25, 0, 0x05},
 189                                  {50, 0, 0x06},
 190                                  {100, 0, 0x06},
 191                                  {200, 0, 0x06},
 192                                  {400, 0, 0x06},
 193                                  {800, 0, 0x06},
 194                                  {1600, 0, 0x06} };
 195
 196 static IIO_CONST_ATTR(accel_scale_available, "0.009582 0.019163 0.038326");
 197 static IIO_CONST_ATTR(magn_scale_available, "0.001465");
 198 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(
 199         "0.781000 1.563000 3.125000 6.250000 12.500000 25 50 100 200 400 800");
 200
 201 static struct attribute *kmx61_acc_attributes[] = {
 202         &iio_const_attr_accel_scale_available.dev_attr.attr,
 203         &iio_const_attr_sampling_frequency_available.dev_attr.attr,
 204         NULL,
 205 };
 206
 207 static struct attribute *kmx61_mag_attributes[] = {
 208         &iio_const_attr_magn_scale_available.dev_attr.attr,
 209         &iio_const_attr_sampling_frequency_available.dev_attr.attr,
 210         NULL,
 211 };
 212
 213 static const struct attribute_group kmx61_acc_attribute_group = {
 214         .attrs = kmx61_acc_attributes,
 215 };
 216
 217 static const struct attribute_group kmx61_mag_attribute_group = {
 218         .attrs = kmx61_mag_attributes,
 219 };
 220
 221 static const struct iio_event_spec kmx61_event = {
 222         .type = IIO_EV_TYPE_THRESH,
 223         .dir = IIO_EV_DIR_EITHER,
 224         .mask_separate = BIT(IIO_EV_INFO_VALUE) |
 225                          BIT(IIO_EV_INFO_ENABLE) |
 226                          BIT(IIO_EV_INFO_PERIOD),
 227 };
 228
 229 #define KMX61_ACC_CHAN(_axis) { \
 230         .type = IIO_ACCEL, \
 231         .modified = 1, \
 232         .channel2 = IIO_MOD_ ## _axis, \
 233         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
 234         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
 235                                 BIT(IIO_CHAN_INFO_SAMP_FREQ), \
 236         .address = KMX61_ACC, \
 237         .scan_index = KMX61_AXIS_ ## _axis, \
 238         .scan_type = { \
 239                 .sign = 's', \
 240                 .realbits = 12, \
 241                 .storagebits = 16, \
 242                 .shift = 4, \
 243                 .endianness = IIO_LE, \
 244         }, \
 245         .event_spec = &kmx61_event, \
 246         .num_event_specs = 1 \
 247 }
 248
 249 #define KMX61_MAG_CHAN(_axis) { \
 250         .type = IIO_MAGN, \
 251         .modified = 1, \
 252         .channel2 = IIO_MOD_ ## _axis, \
 253         .address = KMX61_MAG, \
 254         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
 255         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
 256                                 BIT(IIO_CHAN_INFO_SAMP_FREQ), \
 257         .scan_index = KMX61_AXIS_ ## _axis, \
 258         .scan_type = { \
 259                 .sign = 's', \
 260                 .realbits = 14, \
 261                 .storagebits = 16, \
 262                 .shift = 2, \
 263                 .endianness = IIO_LE, \
 264         }, \
 265 }
 266
 267 static const struct iio_chan_spec kmx61_acc_channels[] = {
 268         KMX61_ACC_CHAN(X),
 269         KMX61_ACC_CHAN(Y),
 270         KMX61_ACC_CHAN(Z),
 271 };
 272
 273 static const struct iio_chan_spec kmx61_mag_channels[] = {
 274         KMX61_MAG_CHAN(X),
 275         KMX61_MAG_CHAN(Y),
 276         KMX61_MAG_CHAN(Z),
 277 };
 278
 279 static void kmx61_set_data(struct iio_dev *indio_dev, struct kmx61_data *data)
 280 {
 281         struct kmx61_data **priv = iio_priv(indio_dev);
 282
 283         *priv = data;
 284 }
 285
 286 static struct kmx61_data *kmx61_get_data(struct iio_dev *indio_dev)
 287 {
 288         return *(struct kmx61_data **)iio_priv(indio_dev);
 289 }
 290
 291 static int kmx61_convert_freq_to_bit(int val, int val2)
 292 {
 293         int i;
 294
 295         for (i = 0; i < ARRAY_SIZE(kmx61_samp_freq_table); i++)
 296                 if (val == kmx61_samp_freq_table[i].val &&
 297                     val2 == kmx61_samp_freq_table[i].val2)
 298                         return i;
 299         return -EINVAL;
 300 }
 301
 302 static int kmx61_convert_wake_up_odr_to_bit(int val, int val2)
 303 {
 304         int i;
 305
 306         for (i = 0; i < ARRAY_SIZE(kmx61_wake_up_odr_table); ++i)
 307                 if (kmx61_wake_up_odr_table[i].val == val &&
 308                         kmx61_wake_up_odr_table[i].val2 == val2)
 309                                 return kmx61_wake_up_odr_table[i].odr_bits;
 310         return -EINVAL;
 311 }
 312
 313 /**
 314  * kmx61_set_mode() - set KMX61 device operating mode
 315  * @data: kmx61 device private data pointer
 316  * @mode: bitmask, indicating operating mode for @device
 317  * @device: bitmask, indicating device for which @mode needs to be set
 318  * @update: update stby bits stored in device's private  @data
 319  *
 320  * For each sensor (accelerometer/magnetometer) there are two operating modes
 321  * STANDBY and OPERATION. Neither accel nor magn can be disabled independently
 322  * if they are both enabled. Internal sensors state is saved in acc_stby and
 323  * mag_stby members of driver's private @data.
 324  */
 325 static int kmx61_set_mode(struct kmx61_data *data, u8 mode, u8 device,
 326                           bool update)
 327 {
 328         int ret;
 329         int acc_stby = -1, mag_stby = -1;
 330
 331         ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_STBY);
 332         if (ret < 0) {
 333                 dev_err(&data->client->dev, "Error reading reg_stby\n");
 334                 return ret;
 335         }
 336         if (device & KMX61_ACC) {
 337                 if (mode & KMX61_ACC_STBY_BIT) {
 338                         ret |= KMX61_ACC_STBY_BIT;
 339                         acc_stby = 1;
 340                 } else {
 341                         ret &= ~KMX61_ACC_STBY_BIT;
 342                         acc_stby = 0;
 343                 }
 344         }
 345
 346         if (device & KMX61_MAG) {
 347                 if (mode & KMX61_MAG_STBY_BIT) {
 348                         ret |= KMX61_MAG_STBY_BIT;
 349                         mag_stby = 1;
 350                 } else {
 351                         ret &= ~KMX61_MAG_STBY_BIT;
 352                         mag_stby = 0;
 353                 }
 354         }
 355
 356         if (mode & KMX61_ACT_STBY_BIT)
 357                 ret |= KMX61_ACT_STBY_BIT;
 358
 359         ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_STBY, ret);
 360         if (ret < 0) {
 361                 dev_err(&data->client->dev, "Error writing reg_stby\n");
 362                 return ret;
 363         }
 364
 365         if (acc_stby != -1 && update)
 366                 data->acc_stby = acc_stby;
 367         if (mag_stby != -1 && update)
 368                 data->mag_stby = mag_stby;
 369
 370         return 0;
 371 }
 372
 373 static int kmx61_get_mode(struct kmx61_data *data, u8 *mode, u8 device)
 374 {
 375         int ret;
 376
 377         ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_STBY);
 378         if (ret < 0) {
 379                 dev_err(&data->client->dev, "Error reading reg_stby\n");
 380                 return ret;
 381         }
 382         *mode = 0;
 383
 384         if (device & KMX61_ACC) {
 385                 if (ret & KMX61_ACC_STBY_BIT)
 386                         *mode |= KMX61_ACC_STBY_BIT;
 387                 else
 388                         *mode &= ~KMX61_ACC_STBY_BIT;
 389         }
 390
 391         if (device & KMX61_MAG) {
 392                 if (ret & KMX61_MAG_STBY_BIT)
 393                         *mode |= KMX61_MAG_STBY_BIT;
 394                 else
 395                         *mode &= ~KMX61_MAG_STBY_BIT;
 396         }
 397
 398         return 0;
 399 }
 400
 401 static int kmx61_set_wake_up_odr(struct kmx61_data *data, int val, int val2)
 402 {
 403         int ret, odr_bits;
 404
 405         odr_bits = kmx61_convert_wake_up_odr_to_bit(val, val2);
 406         if (odr_bits < 0)
 407                 return odr_bits;
 408
 409         ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL2,
 410                                         odr_bits);
 411         if (ret < 0)
 412                 dev_err(&data->client->dev, "Error writing reg_ctrl2\n");
 413         return ret;
 414 }
 415
 416 static int kmx61_set_odr(struct kmx61_data *data, int val, int val2, u8 device)
 417 {
 418         int ret;
 419         u8 mode;
 420         int lodr_bits, odr_bits;
 421
 422         ret = kmx61_get_mode(data, &mode, KMX61_ACC | KMX61_MAG);
 423         if (ret < 0)
 424                 return ret;
 425
 426         lodr_bits = kmx61_convert_freq_to_bit(val, val2);
 427         if (lodr_bits < 0)
 428                 return lodr_bits;
 429
 430         /* To change ODR, accel and magn must be in STDBY */
 431         ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG,
 432                              true);
 433         if (ret < 0)
 434                 return ret;
 435
 436         odr_bits = 0;
 437         if (device & KMX61_ACC)
 438                 odr_bits |= lodr_bits << KMX61_ACC_ODR_SHIFT;
 439         if (device & KMX61_MAG)
 440                 odr_bits |= lodr_bits << KMX61_MAG_ODR_SHIFT;
 441
 442         ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_ODCNTL,
 443                                         odr_bits);
 444         if (ret < 0)
 445                 return ret;
 446
 447         data->odr_bits = odr_bits;
 448
 449         if (device & KMX61_ACC) {
 450                 ret = kmx61_set_wake_up_odr(data, val, val2);
 451                 if (ret)
 452                         return ret;
 453         }
 454
 455         return kmx61_set_mode(data, mode, KMX61_ACC | KMX61_MAG, true);
 456 }
 457
 458 static int kmx61_get_odr(struct kmx61_data *data, int *val, int *val2,
 459                          u8 device)
 460 {
 461         u8 lodr_bits;
 462
 463         if (device & KMX61_ACC)
 464                 lodr_bits = (data->odr_bits >> KMX61_ACC_ODR_SHIFT) &
 465                              KMX61_ACC_ODR_MASK;
 466         else if (device & KMX61_MAG)
 467                 lodr_bits = (data->odr_bits >> KMX61_MAG_ODR_SHIFT) &
 468                              KMX61_MAG_ODR_MASK;
 469         else
 470                 return -EINVAL;
 471
 472         if (lodr_bits >= ARRAY_SIZE(kmx61_samp_freq_table))
 473                 return -EINVAL;
 474
 475         *val = kmx61_samp_freq_table[lodr_bits].val;
 476         *val2 = kmx61_samp_freq_table[lodr_bits].val2;
 477
 478         return 0;
 479 }
 480
 481 static int kmx61_set_range(struct kmx61_data *data, u8 range)
 482 {
 483         int ret;
 484
 485         ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1);
 486         if (ret < 0) {
 487                 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
 488                 return ret;
 489         }
 490
 491         ret &= ~KMX61_REG_CTRL1_GSEL_MASK;
 492         ret |= range & KMX61_REG_CTRL1_GSEL_MASK;
 493
 494         ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret);
 495         if (ret < 0) {
 496                 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
 497                 return ret;
 498         }
 499
 500         data->range = range;
 501
 502         return 0;
 503 }
 504
 505 static int kmx61_set_scale(struct kmx61_data *data, u16 uscale)
 506 {
 507         int ret, i;
 508         u8  mode;
 509
 510         for (i = 0; i < ARRAY_SIZE(kmx61_uscale_table); i++) {
 511                 if (kmx61_uscale_table[i] == uscale) {
 512                         ret = kmx61_get_mode(data, &mode,
 513                                              KMX61_ACC | KMX61_MAG);
 514                         if (ret < 0)
 515                                 return ret;
 516
 517                         ret = kmx61_set_mode(data, KMX61_ALL_STBY,
 518                                              KMX61_ACC | KMX61_MAG, true);
 519                         if (ret < 0)
 520                                 return ret;
 521
 522                         ret = kmx61_set_range(data, i);
 523                         if (ret < 0)
 524                                 return ret;
 525
 526                         return  kmx61_set_mode(data, mode,
 527                                                KMX61_ACC | KMX61_MAG, true);
 528                 }
 529         }
 530         return -EINVAL;
 531 }
 532
 533 static int kmx61_chip_init(struct kmx61_data *data)
 534 {
 535         int ret, val, val2;
 536
 537         ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_WHO_AM_I);
 538         if (ret < 0) {
 539                 dev_err(&data->client->dev, "Error reading who_am_i\n");
 540                 return ret;
 541         }
 542
 543         if (ret != KMX61_CHIP_ID) {
 544                 dev_err(&data->client->dev,
 545                         "Wrong chip id, got %x expected %x\n",
 546                          ret, KMX61_CHIP_ID);
 547                 return -EINVAL;
 548         }
 549
 550         /* set accel 12bit, 4g range */
 551         ret = kmx61_set_range(data, KMX61_RANGE_4G);
 552         if (ret < 0)
 553                 return ret;
 554
 555         ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_ODCNTL);
 556         if (ret < 0) {
 557                 dev_err(&data->client->dev, "Error reading reg_odcntl\n");
 558                 return ret;
 559         }
 560         data->odr_bits = ret;
 561
 562         /*
 563          * set output data rate for wake up (motion detection) function
 564          * to match data rate for accelerometer sampling
 565          */
 566         ret = kmx61_get_odr(data, &val, &val2, KMX61_ACC);
 567         if (ret < 0)
 568                 return ret;
 569
 570         ret = kmx61_set_wake_up_odr(data, val, val2);
 571         if (ret < 0)
 572                 return ret;
 573
 574         /* set acc/magn to OPERATION mode */
 575         ret = kmx61_set_mode(data, 0, KMX61_ACC | KMX61_MAG, true);
 576         if (ret < 0)
 577                 return ret;
 578
 579         data->wake_thresh = KMX61_DEFAULT_WAKE_THRESH;
 580         data->wake_duration = KMX61_DEFAULT_WAKE_DURATION;
 581
 582         return 0;
 583 }
 584
 585 static int kmx61_setup_new_data_interrupt(struct kmx61_data *data,
 586                                           bool status, u8 device)
 587 {
 588         u8 mode;
 589         int ret;
 590
 591         ret = kmx61_get_mode(data, &mode, KMX61_ACC | KMX61_MAG);
 592         if (ret < 0)
 593                 return ret;
 594
 595         ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
 596         if (ret < 0)
 597                 return ret;
 598
 599         ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INC1);
 600         if (ret < 0) {
 601                 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
 602                 return ret;
 603         }
 604
 605         if (status) {
 606                 ret |= KMX61_REG_INC1_BIT_IEN;
 607                 if (device & KMX61_ACC)
 608                         ret |= KMX61_REG_INC1_BIT_DRDYA;
 609                 if (device & KMX61_MAG)
 610                         ret |=  KMX61_REG_INC1_BIT_DRDYM;
 611         } else {
 612                 ret &= ~KMX61_REG_INC1_BIT_IEN;
 613                 if (device & KMX61_ACC)
 614                         ret &= ~KMX61_REG_INC1_BIT_DRDYA;
 615                 if (device & KMX61_MAG)
 616                         ret &= ~KMX61_REG_INC1_BIT_DRDYM;
 617         }
 618         ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_INC1, ret);
 619         if (ret < 0) {
 620                 dev_err(&data->client->dev, "Error writing reg_int_ctrl1\n");
 621                 return ret;
 622         }
 623
 624         ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1);
 625         if (ret < 0) {
 626                 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
 627                 return ret;
 628         }
 629
 630         if (status)
 631                 ret |= KMX61_REG_CTRL1_BIT_DRDYE;
 632         else
 633                 ret &= ~KMX61_REG_CTRL1_BIT_DRDYE;
 634
 635         ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret);
 636         if (ret < 0) {
 637                 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
 638                 return ret;
 639         }
 640
 641         return kmx61_set_mode(data, mode, KMX61_ACC | KMX61_MAG, true);
 642 }
 643
 644 static int kmx61_chip_update_thresholds(struct kmx61_data *data)
 645 {
 646         int ret;
 647
 648         ret = i2c_smbus_write_byte_data(data->client,
 649                                         KMX61_REG_WUF_TIMER,
 650                                         data->wake_duration);
 651         if (ret < 0) {
 652                 dev_err(&data->client->dev, "Errow writing reg_wuf_timer\n");
 653                 return ret;
 654         }
 655
 656         ret = i2c_smbus_write_byte_data(data->client,
 657                                         KMX61_REG_WUF_THRESH,
 658                                         data->wake_thresh);
 659         if (ret < 0)
 660                 dev_err(&data->client->dev, "Error writing reg_wuf_thresh\n");
 661
 662         return ret;
 663 }
 664
 665 static int kmx61_setup_any_motion_interrupt(struct kmx61_data *data,
 666                                             bool status)
 667 {
 668         u8 mode;
 669         int ret;
 670
 671         ret = kmx61_get_mode(data, &mode, KMX61_ACC | KMX61_MAG);
 672         if (ret < 0)
 673                 return ret;
 674
 675         ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
 676         if (ret < 0)
 677                 return ret;
 678
 679         ret = kmx61_chip_update_thresholds(data);
 680         if (ret < 0)
 681                 return ret;
 682
 683         ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INC1);
 684         if (ret < 0) {
 685                 dev_err(&data->client->dev, "Error reading reg_inc1\n");
 686                 return ret;
 687         }
 688         if (status)
 689                 ret |= (KMX61_REG_INC1_BIT_IEN | KMX61_REG_INC1_BIT_WUFS);
 690         else
 691                 ret &= ~(KMX61_REG_INC1_BIT_IEN | KMX61_REG_INC1_BIT_WUFS);
 692
 693         ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_INC1, ret);
 694         if (ret < 0) {
 695                 dev_err(&data->client->dev, "Error writing reg_inc1\n");
 696                 return ret;
 697         }
 698
 699         ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1);
 700         if (ret < 0) {
 701                 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
 702                 return ret;
 703         }
 704
 705         if (status)
 706                 ret |= KMX61_REG_CTRL1_BIT_WUFE | KMX61_REG_CTRL1_BIT_BTSE;
 707         else
 708                 ret &= ~(KMX61_REG_CTRL1_BIT_WUFE | KMX61_REG_CTRL1_BIT_BTSE);
 709
 710         ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret);
 711         if (ret < 0) {
 712                 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
 713                 return ret;
 714         }
 715         mode |= KMX61_ACT_STBY_BIT;
 716         return kmx61_set_mode(data, mode, KMX61_ACC | KMX61_MAG, true);
 717 }
 718
 719 /**
 720  * kmx61_set_power_state() - set power state for kmx61 @device
 721  * @data: kmx61 device private pointer
 722  * @on: power state to be set for @device
 723  * @device: bitmask indicating device for which @on state needs to be set
 724  *
 725  * Notice that when ACC power state needs to be set to ON and MAG is in
 726  * OPERATION then we know that kmx61_runtime_resume was already called
 727  * so we must set ACC OPERATION mode here. The same happens when MAG power
 728  * state needs to be set to ON and ACC is in OPERATION.
 729  */
 730 static int kmx61_set_power_state(struct kmx61_data *data, bool on, u8 device)
 731 {
 732 #ifdef CONFIG_PM
 733         int ret;
 734
 735         if (device & KMX61_ACC) {
 736                 if (on && !data->acc_ps && !data->mag_stby) {
 737                         ret = kmx61_set_mode(data, 0, KMX61_ACC, true);
 738                         if (ret < 0)
 739                                 return ret;
 740                 }
 741                 data->acc_ps = on;
 742         }
 743         if (device & KMX61_MAG) {
 744                 if (on && !data->mag_ps && !data->acc_stby) {
 745                         ret = kmx61_set_mode(data, 0, KMX61_MAG, true);
 746                         if (ret < 0)
 747                                 return ret;
 748                 }
 749                 data->mag_ps = on;
 750         }
 751
 752         if (on) {
 753                 ret = pm_runtime_get_sync(&data->client->dev);
 754         } else {
 755                 pm_runtime_mark_last_busy(&data->client->dev);
 756                 ret = pm_runtime_put_autosuspend(&data->client->dev);
 757         }
 758         if (ret < 0) {
 759                 dev_err(&data->client->dev,
 760                         "Failed: kmx61_set_power_state for %d, ret %d\n",
 761                         on, ret);
 762                 if (on)
 763                         pm_runtime_put_noidle(&data->client->dev);
 764
 765                 return ret;
 766         }
 767 #endif
 768         return 0;
 769 }
 770
 771 static int kmx61_read_measurement(struct kmx61_data *data, u8 base, u8 offset)
 772 {
 773         int ret;
 774         u8 reg = base + offset * 2;
 775
 776         ret = i2c_smbus_read_word_data(data->client, reg);
 777         if (ret < 0)
 778                 dev_err(&data->client->dev, "failed to read reg at %x\n", reg);
 779
 780         return ret;
 781 }
 782
 783 static int kmx61_read_raw(struct iio_dev *indio_dev,
 784                           struct iio_chan_spec const *chan, int *val,
 785                           int *val2, long mask)
 786 {
 787         int ret;
 788         u8 base_reg;
 789         struct kmx61_data *data = kmx61_get_data(indio_dev);
 790
 791         switch (mask) {
 792         case IIO_CHAN_INFO_RAW:
 793                 switch (chan->type) {
 794                 case IIO_ACCEL:
 795                         base_reg = KMX61_ACC_XOUT_L;
 796                         break;
 797                 case IIO_MAGN:
 798                         base_reg = KMX61_MAG_XOUT_L;
 799                         break;
 800                 default:
 801                         return -EINVAL;
 802                 }
 803                 mutex_lock(&data->lock);
 804
 805                 ret = kmx61_set_power_state(data, true, chan->address);
 806                 if (ret) {
 807                         mutex_unlock(&data->lock);
 808                         return ret;
 809                 }
 810
 811                 ret = kmx61_read_measurement(data, base_reg, chan->scan_index);
 812                 if (ret < 0) {
 813                         kmx61_set_power_state(data, false, chan->address);
 814                         mutex_unlock(&data->lock);
 815                         return ret;
 816                 }
 817                 *val = sign_extend32(ret >> chan->scan_type.shift,
 818                                      chan->scan_type.realbits - 1);
 819                 ret = kmx61_set_power_state(data, false, chan->address);
 820
 821                 mutex_unlock(&data->lock);
 822                 if (ret)
 823                         return ret;
 824                 return IIO_VAL_INT;
 825         case IIO_CHAN_INFO_SCALE:
 826                 switch (chan->type) {
 827                 case IIO_ACCEL:
 828                         *val = 0;
 829                         *val2 = kmx61_uscale_table[data->range];
 830                         return IIO_VAL_INT_PLUS_MICRO;
 831                 case IIO_MAGN:
 832                         /* 14 bits res, 1465 microGauss per magn count */
 833                         *val = 0;
 834                         *val2 = 1465;
 835                         return IIO_VAL_INT_PLUS_MICRO;
 836                 default:
 837                         return -EINVAL;
 838                 }
 839         case IIO_CHAN_INFO_SAMP_FREQ:
 840                 if (chan->type != IIO_ACCEL && chan->type != IIO_MAGN)
 841                         return -EINVAL;
 842
 843                 mutex_lock(&data->lock);
 844                 ret = kmx61_get_odr(data, val, val2, chan->address);
 845                 mutex_unlock(&data->lock);
 846                 if (ret)
 847                         return -EINVAL;
 848                 return IIO_VAL_INT_PLUS_MICRO;
 849         }
 850         return -EINVAL;
 851 }
 852
 853 static int kmx61_write_raw(struct iio_dev *indio_dev,
 854                            struct iio_chan_spec const *chan, int val,
 855                            int val2, long mask)
 856 {
 857         int ret;
 858         struct kmx61_data *data = kmx61_get_data(indio_dev);
 859
 860         switch (mask) {
 861         case IIO_CHAN_INFO_SAMP_FREQ:
 862                 if (chan->type != IIO_ACCEL && chan->type != IIO_MAGN)
 863                         return -EINVAL;
 864
 865                 mutex_lock(&data->lock);
 866                 ret = kmx61_set_odr(data, val, val2, chan->address);
 867                 mutex_unlock(&data->lock);
 868                 return ret;
 869         case IIO_CHAN_INFO_SCALE:
 870                 switch (chan->type) {
 871                 case IIO_ACCEL:
 872                         if (val != 0)
 873                                 return -EINVAL;
 874                         mutex_lock(&data->lock);
 875                         ret = kmx61_set_scale(data, val2);
 876                         mutex_unlock(&data->lock);
 877                         return ret;
 878                 default:
 879                         return -EINVAL;
 880                 }
 881         default:
 882                 return -EINVAL;
 883         }
 884 }
 885
 886 static int kmx61_read_event(struct iio_dev *indio_dev,
 887                             const struct iio_chan_spec *chan,
 888                             enum iio_event_type type,
 889                             enum iio_event_direction dir,
 890                             enum iio_event_info info,
 891                             int *val, int *val2)
 892 {
 893         struct kmx61_data *data = kmx61_get_data(indio_dev);
 894
 895         *val2 = 0;
 896         switch (info) {
 897         case IIO_EV_INFO_VALUE:
 898                 *val = data->wake_thresh;
 899                 return IIO_VAL_INT;
 900         case IIO_EV_INFO_PERIOD:
 901                 *val = data->wake_duration;
 902                 return IIO_VAL_INT;
 903         default:
 904                 return -EINVAL;
 905         }
 906 }
 907
 908 static int kmx61_write_event(struct iio_dev *indio_dev,
 909                              const struct iio_chan_spec *chan,
 910                              enum iio_event_type type,
 911                              enum iio_event_direction dir,
 912                              enum iio_event_info info,
 913                              int val, int val2)
 914 {
 915         struct kmx61_data *data = kmx61_get_data(indio_dev);
 916
 917         if (data->ev_enable_state)
 918                 return -EBUSY;
 919
 920         switch (info) {
 921         case IIO_EV_INFO_VALUE:
 922                 data->wake_thresh = val;
 923                 return IIO_VAL_INT;
 924         case IIO_EV_INFO_PERIOD:
 925                 data->wake_duration = val;
 926                 return IIO_VAL_INT;
 927         default:
 928                 return -EINVAL;
 929         }
 930 }
 931
 932 static int kmx61_read_event_config(struct iio_dev *indio_dev,
 933                                    const struct iio_chan_spec *chan,
 934                                    enum iio_event_type type,
 935                                    enum iio_event_direction dir)
 936 {
 937         struct kmx61_data *data = kmx61_get_data(indio_dev);
 938
 939         return data->ev_enable_state;
 940 }
 941
 942 static int kmx61_write_event_config(struct iio_dev *indio_dev,
 943                                     const struct iio_chan_spec *chan,
 944                                     enum iio_event_type type,
 945                                     enum iio_event_direction dir,
 946                                     int state)
 947 {
 948         struct kmx61_data *data = kmx61_get_data(indio_dev);
 949         int ret = 0;
 950
 951         if (state && data->ev_enable_state)
 952                 return 0;
 953
 954         mutex_lock(&data->lock);
 955
 956         if (!state && data->motion_trig_on) {
 957                 data->ev_enable_state = false;
 958                 goto err_unlock;
 959         }
 960
 961         ret = kmx61_set_power_state(data, state, KMX61_ACC);
 962         if (ret < 0)
 963                 goto err_unlock;
 964
 965         ret = kmx61_setup_any_motion_interrupt(data, state);
 966         if (ret < 0) {
 967                 kmx61_set_power_state(data, false, KMX61_ACC);
 968                 goto err_unlock;
 969         }
 970
 971         data->ev_enable_state = state;
 972
 973 err_unlock:
 974         mutex_unlock(&data->lock);
 975
 976         return ret;
 977 }
 978
 979 static int kmx61_acc_validate_trigger(struct iio_dev *indio_dev,
 980                                       struct iio_trigger *trig)
 981 {
 982         struct kmx61_data *data = kmx61_get_data(indio_dev);
 983
 984         if (data->acc_dready_trig != trig && data->motion_trig != trig)
 985                 return -EINVAL;
 986
 987         return 0;
 988 }
 989
 990 static int kmx61_mag_validate_trigger(struct iio_dev *indio_dev,
 991                                       struct iio_trigger *trig)
 992 {
 993         struct kmx61_data *data = kmx61_get_data(indio_dev);
 994
 995         if (data->mag_dready_trig != trig)
 996                 return -EINVAL;
 997
 998         return 0;
 999 }
1000
1001 static const struct iio_info kmx61_acc_info = {
1002         .read_raw               = kmx61_read_raw,
1003         .write_raw              = kmx61_write_raw,
1004         .attrs                  = &kmx61_acc_attribute_group,
1005         .read_event_value       = kmx61_read_event,
1006         .write_event_value      = kmx61_write_event,
1007         .read_event_config      = kmx61_read_event_config,
1008         .write_event_config     = kmx61_write_event_config,
1009         .validate_trigger       = kmx61_acc_validate_trigger,
1010 };
1011
1012 static const struct iio_info kmx61_mag_info = {
1013         .read_raw               = kmx61_read_raw,
1014         .write_raw              = kmx61_write_raw,
1015         .attrs                  = &kmx61_mag_attribute_group,
1016         .validate_trigger       = kmx61_mag_validate_trigger,
1017 };
1018
1019
1020 static int kmx61_data_rdy_trigger_set_state(struct iio_trigger *trig,
1021                                             bool state)
1022 {
1023         int ret = 0;
1024         u8 device;
1025
1026         struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
1027         struct kmx61_data *data = kmx61_get_data(indio_dev);
1028
1029         mutex_lock(&data->lock);
1030
1031         if (!state && data->ev_enable_state && data->motion_trig_on) {
1032                 data->motion_trig_on = false;
1033                 goto err_unlock;
1034         }
1035
1036         if (data->acc_dready_trig == trig || data->motion_trig == trig)
1037                 device = KMX61_ACC;
1038         else
1039                 device = KMX61_MAG;
1040
1041         ret = kmx61_set_power_state(data, state, device);
1042         if (ret < 0)
1043                 goto err_unlock;
1044
1045         if (data->acc_dready_trig == trig || data->mag_dready_trig == trig)
1046                 ret = kmx61_setup_new_data_interrupt(data, state, device);
1047         else
1048                 ret = kmx61_setup_any_motion_interrupt(data, state);
1049         if (ret < 0) {
1050                 kmx61_set_power_state(data, false, device);
1051                 goto err_unlock;
1052         }
1053
1054         if (data->acc_dready_trig == trig)
1055                 data->acc_dready_trig_on = state;
1056         else if (data->mag_dready_trig == trig)
1057                 data->mag_dready_trig_on = state;
1058         else
1059                 data->motion_trig_on = state;
1060 err_unlock:
1061         mutex_unlock(&data->lock);
1062
1063         return ret;
1064 }
1065
1066 static int kmx61_trig_try_reenable(struct iio_trigger *trig)
1067 {
1068         struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
1069         struct kmx61_data *data = kmx61_get_data(indio_dev);
1070         int ret;
1071
1072         ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INL);
1073         if (ret < 0) {
1074                 dev_err(&data->client->dev, "Error reading reg_inl\n");
1075                 return ret;
1076         }
1077
1078         return 0;
1079 }
1080
1081 static const struct iio_trigger_ops kmx61_trigger_ops = {
1082         .set_trigger_state = kmx61_data_rdy_trigger_set_state,
1083         .try_reenable = kmx61_trig_try_reenable,
1084 };
1085
1086 static irqreturn_t kmx61_event_handler(int irq, void *private)
1087 {
1088         struct kmx61_data *data = private;
1089         struct iio_dev *indio_dev = data->acc_indio_dev;
1090         int ret;
1091
1092         ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INS1);
1093         if (ret < 0) {
1094                 dev_err(&data->client->dev, "Error reading reg_ins1\n");
1095                 goto ack_intr;
1096         }
1097
1098         if (ret & KMX61_REG_INS1_BIT_WUFS) {
1099                 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INS2);
1100                 if (ret < 0) {
1101                         dev_err(&data->client->dev, "Error reading reg_ins2\n");
1102                         goto ack_intr;
1103                 }
1104
1105                 if (ret & KMX61_REG_INS2_BIT_XN)
1106                         iio_push_event(indio_dev,
1107                                        IIO_MOD_EVENT_CODE(IIO_ACCEL,
1108                                        0,
1109                                        IIO_MOD_X,
1110                                        IIO_EV_TYPE_THRESH,
1111                                        IIO_EV_DIR_FALLING),
1112                                        0);
1113
1114                 if (ret & KMX61_REG_INS2_BIT_XP)
1115                         iio_push_event(indio_dev,
1116                                        IIO_MOD_EVENT_CODE(IIO_ACCEL,
1117                                        0,
1118                                        IIO_MOD_X,
1119                                        IIO_EV_TYPE_THRESH,
1120                                        IIO_EV_DIR_RISING),
1121                                        0);
1122
1123                 if (ret & KMX61_REG_INS2_BIT_YN)
1124                         iio_push_event(indio_dev,
1125                                        IIO_MOD_EVENT_CODE(IIO_ACCEL,
1126                                        0,
1127                                        IIO_MOD_Y,
1128                                        IIO_EV_TYPE_THRESH,
1129                                        IIO_EV_DIR_FALLING),
1130                                        0);
1131
1132                 if (ret & KMX61_REG_INS2_BIT_YP)
1133                         iio_push_event(indio_dev,
1134                                        IIO_MOD_EVENT_CODE(IIO_ACCEL,
1135                                        0,
1136                                        IIO_MOD_Y,
1137                                        IIO_EV_TYPE_THRESH,
1138                                        IIO_EV_DIR_RISING),
1139                                        0);
1140
1141                 if (ret & KMX61_REG_INS2_BIT_ZN)
1142                         iio_push_event(indio_dev,
1143                                        IIO_MOD_EVENT_CODE(IIO_ACCEL,
1144                                        0,
1145                                        IIO_MOD_Z,
1146                                        IIO_EV_TYPE_THRESH,
1147                                        IIO_EV_DIR_FALLING),
1148                                        0);
1149
1150                 if (ret & KMX61_REG_INS2_BIT_ZP)
1151                         iio_push_event(indio_dev,
1152                                        IIO_MOD_EVENT_CODE(IIO_ACCEL,
1153                                        0,
1154                                        IIO_MOD_Z,
1155                                        IIO_EV_TYPE_THRESH,
1156                                        IIO_EV_DIR_RISING),
1157                                        0);
1158         }
1159
1160 ack_intr:
1161         ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1);
1162         if (ret < 0)
1163                 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
1164
1165         ret |= KMX61_REG_CTRL1_BIT_RES;
1166         ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret);
1167         if (ret < 0)
1168                 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
1169
1170         ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INL);
1171         if (ret < 0)
1172                 dev_err(&data->client->dev, "Error reading reg_inl\n");
1173
1174         return IRQ_HANDLED;
1175 }
1176
1177 static irqreturn_t kmx61_data_rdy_trig_poll(int irq, void *private)
1178 {
1179         struct kmx61_data *data = private;
1180
1181         if (data->acc_dready_trig_on)
1182                 iio_trigger_poll(data->acc_dready_trig);
1183         if (data->mag_dready_trig_on)
1184                 iio_trigger_poll(data->mag_dready_trig);
1185
1186         if (data->motion_trig_on)
1187                 iio_trigger_poll(data->motion_trig);
1188
1189         if (data->ev_enable_state)
1190                 return IRQ_WAKE_THREAD;
1191         return IRQ_HANDLED;
1192 }
1193
1194 static irqreturn_t kmx61_trigger_handler(int irq, void *p)
1195 {
1196         struct iio_poll_func *pf = p;
1197         struct iio_dev *indio_dev = pf->indio_dev;
1198         struct kmx61_data *data = kmx61_get_data(indio_dev);
1199         int bit, ret, i = 0;
1200         u8 base;
1201         s16 buffer[8];
1202
1203         if (indio_dev == data->acc_indio_dev)
1204                 base = KMX61_ACC_XOUT_L;
1205         else
1206                 base = KMX61_MAG_XOUT_L;
1207
1208         mutex_lock(&data->lock);
1209         for_each_set_bit(bit, indio_dev->active_scan_mask,
1210                          indio_dev->masklength) {
1211                 ret = kmx61_read_measurement(data, base, bit);
1212                 if (ret < 0) {
1213                         mutex_unlock(&data->lock);
1214                         goto err;
1215                 }
1216                 buffer[i++] = ret;
1217         }
1218         mutex_unlock(&data->lock);
1219
1220         iio_push_to_buffers(indio_dev, buffer);
1221 err:
1222         iio_trigger_notify_done(indio_dev->trig);
1223
1224         return IRQ_HANDLED;
1225 }
1226
1227 static const char *kmx61_match_acpi_device(struct device *dev)
1228 {
1229         const struct acpi_device_id *id;
1230
1231         id = acpi_match_device(dev->driver->acpi_match_table, dev);
1232         if (!id)
1233                 return NULL;
1234         return dev_name(dev);
1235 }
1236
1237 static struct iio_dev *kmx61_indiodev_setup(struct kmx61_data *data,
1238                                             const struct iio_info *info,
1239                                             const struct iio_chan_spec *chan,
1240                                             int num_channels,
1241                                             const char *name)
1242 {
1243         struct iio_dev *indio_dev;
1244
1245         indio_dev = devm_iio_device_alloc(&data->client->dev, sizeof(data));
1246         if (!indio_dev)
1247                 return ERR_PTR(-ENOMEM);
1248
1249         kmx61_set_data(indio_dev, data);
1250
1251         indio_dev->channels = chan;
1252         indio_dev->num_channels = num_channels;
1253         indio_dev->name = name;
1254         indio_dev->modes = INDIO_DIRECT_MODE;
1255         indio_dev->info = info;
1256
1257         return indio_dev;
1258 }
1259
1260 static struct iio_trigger *kmx61_trigger_setup(struct kmx61_data *data,
1261                                                struct iio_dev *indio_dev,
1262                                                const char *tag)
1263 {
1264         struct iio_trigger *trig;
1265         int ret;
1266
1267         trig = devm_iio_trigger_alloc(&data->client->dev,
1268                                       "%s-%s-dev%d",
1269                                       indio_dev->name,
1270                                       tag,
1271                                       indio_dev->id);
1272         if (!trig)
1273                 return ERR_PTR(-ENOMEM);
1274
1275         trig->dev.parent = &data->client->dev;
1276         trig->ops = &kmx61_trigger_ops;
1277         iio_trigger_set_drvdata(trig, indio_dev);
1278
1279         ret = iio_trigger_register(trig);
1280         if (ret)
1281                 return ERR_PTR(ret);
1282
1283         return trig;
1284 }
1285
1286 static int kmx61_probe(struct i2c_client *client,
1287                        const struct i2c_device_id *id)
1288 {
1289         int ret;
1290         struct kmx61_data *data;
1291         const char *name = NULL;
1292
1293         data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
1294         if (!data)
1295                 return -ENOMEM;
1296
1297         i2c_set_clientdata(client, data);
1298         data->client = client;
1299
1300         mutex_init(&data->lock);
1301
1302         if (id)
1303                 name = id->name;
1304         else if (ACPI_HANDLE(&client->dev))
1305                 name = kmx61_match_acpi_device(&client->dev);
1306         else
1307                 return -ENODEV;
1308
1309         data->acc_indio_dev =
1310                 kmx61_indiodev_setup(data, &kmx61_acc_info,
1311                                      kmx61_acc_channels,
1312                                      ARRAY_SIZE(kmx61_acc_channels),
1313                                      name);
1314         if (IS_ERR(data->acc_indio_dev))
1315                 return PTR_ERR(data->acc_indio_dev);
1316
1317         data->mag_indio_dev =
1318                 kmx61_indiodev_setup(data, &kmx61_mag_info,
1319                                      kmx61_mag_channels,
1320                                      ARRAY_SIZE(kmx61_mag_channels),
1321                                      name);
1322         if (IS_ERR(data->mag_indio_dev))
1323                 return PTR_ERR(data->mag_indio_dev);
1324
1325         ret = kmx61_chip_init(data);
1326         if (ret < 0)
1327                 return ret;
1328
1329         if (client->irq > 0) {
1330                 ret = devm_request_threaded_irq(&client->dev, client->irq,
1331                                                 kmx61_data_rdy_trig_poll,
1332                                                 kmx61_event_handler,
1333                                                 IRQF_TRIGGER_RISING,
1334                                                 KMX61_IRQ_NAME,
1335                                                 data);
1336                 if (ret)
1337                         goto err_chip_uninit;
1338
1339                 data->acc_dready_trig =
1340                         kmx61_trigger_setup(data, data->acc_indio_dev,
1341                                             "dready");
1342                 if (IS_ERR(data->acc_dready_trig)) {
1343                         ret = PTR_ERR(data->acc_dready_trig);
1344                         goto err_chip_uninit;
1345                 }
1346
1347                 data->mag_dready_trig =
1348                         kmx61_trigger_setup(data, data->mag_indio_dev,
1349                                             "dready");
1350                 if (IS_ERR(data->mag_dready_trig)) {
1351                         ret = PTR_ERR(data->mag_dready_trig);
1352                         goto err_trigger_unregister_acc_dready;
1353                 }
1354
1355                 data->motion_trig =
1356                         kmx61_trigger_setup(data, data->acc_indio_dev,
1357                                             "any-motion");
1358                 if (IS_ERR(data->motion_trig)) {
1359                         ret = PTR_ERR(data->motion_trig);
1360                         goto err_trigger_unregister_mag_dready;
1361                 }
1362
1363                 ret = iio_triggered_buffer_setup(data->acc_indio_dev,
1364                                                  &iio_pollfunc_store_time,
1365                                                  kmx61_trigger_handler,
1366                                                  NULL);
1367                 if (ret < 0) {
1368                         dev_err(&data->client->dev,
1369                                 "Failed to setup acc triggered buffer\n");
1370                         goto err_trigger_unregister_motion;
1371                 }
1372
1373                 ret = iio_triggered_buffer_setup(data->mag_indio_dev,
1374                                                  &iio_pollfunc_store_time,
1375                                                  kmx61_trigger_handler,
1376                                                  NULL);
1377                 if (ret < 0) {
1378                         dev_err(&data->client->dev,
1379                                 "Failed to setup mag triggered buffer\n");
1380                         goto err_buffer_cleanup_acc;
1381                 }
1382         }
1383
1384         ret = pm_runtime_set_active(&client->dev);
1385         if (ret < 0)
1386                 goto err_buffer_cleanup_mag;
1387
1388         pm_runtime_enable(&client->dev);
1389         pm_runtime_set_autosuspend_delay(&client->dev, KMX61_SLEEP_DELAY_MS);
1390         pm_runtime_use_autosuspend(&client->dev);
1391
1392         ret = iio_device_register(data->acc_indio_dev);
1393         if (ret < 0) {
1394                 dev_err(&client->dev, "Failed to register acc iio device\n");
1395                 goto err_pm_cleanup;
1396         }
1397
1398         ret = iio_device_register(data->mag_indio_dev);
1399         if (ret < 0) {
1400                 dev_err(&client->dev, "Failed to register mag iio device\n");
1401                 goto err_iio_unregister_acc;
1402         }
1403
1404         return 0;
1405
1406 err_iio_unregister_acc:
1407         iio_device_unregister(data->acc_indio_dev);
1408 err_pm_cleanup:
1409         pm_runtime_dont_use_autosuspend(&client->dev);
1410         pm_runtime_disable(&client->dev);
1411 err_buffer_cleanup_mag:
1412         if (client->irq > 0)
1413                 iio_triggered_buffer_cleanup(data->mag_indio_dev);
1414 err_buffer_cleanup_acc:
1415         if (client->irq > 0)
1416                 iio_triggered_buffer_cleanup(data->acc_indio_dev);
1417 err_trigger_unregister_motion:
1418         iio_trigger_unregister(data->motion_trig);
1419 err_trigger_unregister_mag_dready:
1420         iio_trigger_unregister(data->mag_dready_trig);
1421 err_trigger_unregister_acc_dready:
1422         iio_trigger_unregister(data->acc_dready_trig);
1423 err_chip_uninit:
1424         kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
1425         return ret;
1426 }
1427
1428 static int kmx61_remove(struct i2c_client *client)
1429 {
1430         struct kmx61_data *data = i2c_get_clientdata(client);
1431
1432         iio_device_unregister(data->acc_indio_dev);
1433         iio_device_unregister(data->mag_indio_dev);
1434
1435         pm_runtime_disable(&client->dev);
1436         pm_runtime_set_suspended(&client->dev);
1437         pm_runtime_put_noidle(&client->dev);
1438
1439         if (client->irq > 0) {
1440                 iio_triggered_buffer_cleanup(data->acc_indio_dev);
1441                 iio_triggered_buffer_cleanup(data->mag_indio_dev);
1442                 iio_trigger_unregister(data->acc_dready_trig);
1443                 iio_trigger_unregister(data->mag_dready_trig);
1444                 iio_trigger_unregister(data->motion_trig);
1445         }
1446
1447         mutex_lock(&data->lock);
1448         kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
1449         mutex_unlock(&data->lock);
1450
1451         return 0;
1452 }
1453
1454 #ifdef CONFIG_PM_SLEEP
1455 static int kmx61_suspend(struct device *dev)
1456 {
1457         int ret;
1458         struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev));
1459
1460         mutex_lock(&data->lock);
1461         ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG,
1462                              false);
1463         mutex_unlock(&data->lock);
1464
1465         return ret;
1466 }
1467
1468 static int kmx61_resume(struct device *dev)
1469 {
1470         u8 stby = 0;
1471         struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev));
1472
1473         if (data->acc_stby)
1474                 stby |= KMX61_ACC_STBY_BIT;
1475         if (data->mag_stby)
1476                 stby |= KMX61_MAG_STBY_BIT;
1477
1478         return kmx61_set_mode(data, stby, KMX61_ACC | KMX61_MAG, true);
1479 }
1480 #endif
1481
1482 #ifdef CONFIG_PM
1483 static int kmx61_runtime_suspend(struct device *dev)
1484 {
1485         struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev));
1486         int ret;
1487
1488         mutex_lock(&data->lock);
1489         ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
1490         mutex_unlock(&data->lock);
1491
1492         return ret;
1493 }
1494
1495 static int kmx61_runtime_resume(struct device *dev)
1496 {
1497         struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev));
1498         u8 stby = 0;
1499
1500         if (!data->acc_ps)
1501                 stby |= KMX61_ACC_STBY_BIT;
1502         if (!data->mag_ps)
1503                 stby |= KMX61_MAG_STBY_BIT;
1504
1505         return kmx61_set_mode(data, stby, KMX61_ACC | KMX61_MAG, true);
1506 }
1507 #endif
1508
1509 static const struct dev_pm_ops kmx61_pm_ops = {
1510         SET_SYSTEM_SLEEP_PM_OPS(kmx61_suspend, kmx61_resume)
1511         SET_RUNTIME_PM_OPS(kmx61_runtime_suspend, kmx61_runtime_resume, NULL)
1512 };
1513
1514 static const struct acpi_device_id kmx61_acpi_match[] = {
1515         {"KMX61021", 0},
1516         {}
1517 };
1518
1519 MODULE_DEVICE_TABLE(acpi, kmx61_acpi_match);
1520
1521 static const struct i2c_device_id kmx61_id[] = {
1522         {"kmx611021", 0},
1523         {}
1524 };
1525
1526 MODULE_DEVICE_TABLE(i2c, kmx61_id);
1527
1528 static struct i2c_driver kmx61_driver = {
1529         .driver = {
1530                 .name = KMX61_DRV_NAME,
1531                 .acpi_match_table = ACPI_PTR(kmx61_acpi_match),
1532                 .pm = &kmx61_pm_ops,
1533         },
1534         .probe          = kmx61_probe,
1535         .remove         = kmx61_remove,
1536         .id_table       = kmx61_id,
1537 };
1538
1539 module_i2c_driver(kmx61_driver);
1540
1541 MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com>");
1542 MODULE_DESCRIPTION("KMX61 accelerometer/magnetometer driver");
1543 MODULE_LICENSE("GPL v2");