drivers/iio/imu/kmx61.c

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