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