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