drivers/iio/accel/kxcjk-1013.c

   1 /*
   2  * KXCJK-1013 3-axis accelerometer driver
   3  * Copyright (c) 2014, Intel Corporation.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms and conditions of the GNU General Public License,
   7  * version 2, as published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12  * more details.
  13  */
  14
  15 #include <linux/module.h>
  16 #include <linux/i2c.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/delay.h>
  19 #include <linux/bitops.h>
  20 #include <linux/slab.h>
  21 #include <linux/string.h>
  22 #include <linux/acpi.h>
  23 #include <linux/gpio/consumer.h>
  24 #include <linux/iio/iio.h>
  25 #include <linux/iio/sysfs.h>
  26 #include <linux/iio/buffer.h>
  27 #include <linux/iio/trigger.h>
  28 #include <linux/iio/trigger_consumer.h>
  29 #include <linux/iio/triggered_buffer.h>
  30 #include <linux/iio/accel/kxcjk_1013.h>
  31
  32 #define KXCJK1013_DRV_NAME "kxcjk1013"
  33 #define KXCJK1013_IRQ_NAME "kxcjk1013_event"
  34
  35 #define KXCJK1013_REG_XOUT_L            0x06
  36 /*
  37  * From low byte X axis register, all the other addresses of Y and Z can be
  38  * obtained by just applying axis offset. The following axis defines are just
  39  * provide clarity, but not used.
  40  */
  41 #define KXCJK1013_REG_XOUT_H            0x07
  42 #define KXCJK1013_REG_YOUT_L            0x08
  43 #define KXCJK1013_REG_YOUT_H            0x09
  44 #define KXCJK1013_REG_ZOUT_L            0x0A
  45 #define KXCJK1013_REG_ZOUT_H            0x0B
  46
  47 #define KXCJK1013_REG_DCST_RESP         0x0C
  48 #define KXCJK1013_REG_WHO_AM_I          0x0F
  49 #define KXCJK1013_REG_INT_SRC1          0x16
  50 #define KXCJK1013_REG_INT_SRC2          0x17
  51 #define KXCJK1013_REG_STATUS_REG        0x18
  52 #define KXCJK1013_REG_INT_REL           0x1A
  53 #define KXCJK1013_REG_CTRL1             0x1B
  54 #define KXCJK1013_REG_CTRL2             0x1D
  55 #define KXCJK1013_REG_INT_CTRL1         0x1E
  56 #define KXCJK1013_REG_INT_CTRL2         0x1F
  57 #define KXCJK1013_REG_DATA_CTRL         0x21
  58 #define KXCJK1013_REG_WAKE_TIMER        0x29
  59 #define KXCJK1013_REG_SELF_TEST         0x3A
  60 #define KXCJK1013_REG_WAKE_THRES        0x6A
  61
  62 #define KXCJK1013_REG_CTRL1_BIT_PC1     BIT(7)
  63 #define KXCJK1013_REG_CTRL1_BIT_RES     BIT(6)
  64 #define KXCJK1013_REG_CTRL1_BIT_DRDY    BIT(5)
  65 #define KXCJK1013_REG_CTRL1_BIT_GSEL1   BIT(4)
  66 #define KXCJK1013_REG_CTRL1_BIT_GSEL0   BIT(3)
  67 #define KXCJK1013_REG_CTRL1_BIT_WUFE    BIT(1)
  68 #define KXCJK1013_REG_INT_REG1_BIT_IEA  BIT(4)
  69 #define KXCJK1013_REG_INT_REG1_BIT_IEN  BIT(5)
  70
  71 #define KXCJK1013_DATA_MASK_12_BIT      0x0FFF
  72 #define KXCJK1013_MAX_STARTUP_TIME_US   100000
  73
  74 struct kxcjk1013_data {
  75         struct i2c_client *client;
  76         struct iio_trigger *trig;
  77         bool trig_mode;
  78         struct mutex mutex;
  79         s16 buffer[8];
  80         int power_state;
  81         u8 odr_bits;
  82         bool active_high_intr;
  83 };
  84
  85 enum kxcjk1013_axis {
  86         AXIS_X,
  87         AXIS_Y,
  88         AXIS_Z,
  89 };
  90
  91 enum kxcjk1013_mode {
  92         STANDBY,
  93         OPERATION,
  94 };
  95
  96 static const struct {
  97         int val;
  98         int val2;
  99         int odr_bits;
 100 } samp_freq_table[] = { {0, 781000, 0x08}, {1, 563000, 0x09},
 101                         {3, 125000, 0x0A}, {6, 250000, 0x0B}, {12, 500000, 0},
 102                         {25, 0, 0x01}, {50, 0, 0x02}, {100, 0, 0x03},
 103                         {200, 0, 0x04}, {400, 0, 0x05}, {800, 0, 0x06},
 104                         {1600, 0, 0x07} };
 105
 106 /* Refer to section 4 of the specification */
 107 static const struct {
 108         int odr_bits;
 109         int usec;
 110 } odr_start_up_times[] = { {0x08, 100000}, {0x09, 100000}, {0x0A, 100000},
 111                            {0x0B, 100000}, { 0, 80000}, {0x01, 41000},
 112                            {0x02, 21000}, {0x03, 11000}, {0x04, 6400},
 113                            {0x05, 3900}, {0x06, 2700}, {0x07, 2100} };
 114
 115 static int kxcjk1013_set_mode(struct kxcjk1013_data *data,
 116                               enum kxcjk1013_mode mode)
 117 {
 118         int ret;
 119
 120         ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1);
 121         if (ret < 0) {
 122                 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
 123                 return ret;
 124         }
 125
 126         if (mode == STANDBY)
 127                 ret &= ~KXCJK1013_REG_CTRL1_BIT_PC1;
 128         else
 129                 ret |= KXCJK1013_REG_CTRL1_BIT_PC1;
 130
 131         ret = i2c_smbus_write_byte_data(data->client,
 132                                         KXCJK1013_REG_CTRL1, ret);
 133         if (ret < 0) {
 134                 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
 135                 return ret;
 136         }
 137
 138         return 0;
 139 }
 140
 141 static int kxcjk1013_chip_init(struct kxcjk1013_data *data)
 142 {
 143         int ret;
 144
 145         ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_WHO_AM_I);
 146         if (ret < 0) {
 147                 dev_err(&data->client->dev, "Error reading who_am_i\n");
 148                 return ret;
 149         }
 150
 151         dev_dbg(&data->client->dev, "KXCJK1013 Chip Id %x\n", ret);
 152
 153         ret = kxcjk1013_set_mode(data, STANDBY);
 154         if (ret < 0)
 155                 return ret;
 156
 157         ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1);
 158         if (ret < 0) {
 159                 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
 160                 return ret;
 161         }
 162
 163         /* Setting range to 4G */
 164         ret |= KXCJK1013_REG_CTRL1_BIT_GSEL0;
 165         ret &= ~KXCJK1013_REG_CTRL1_BIT_GSEL1;
 166
 167         /* Set 12 bit mode */
 168         ret |= KXCJK1013_REG_CTRL1_BIT_RES;
 169
 170         ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_CTRL1,
 171                                         ret);
 172         if (ret < 0) {
 173                 dev_err(&data->client->dev, "Error reading reg_ctrl\n");
 174                 return ret;
 175         }
 176
 177         ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_DATA_CTRL);
 178         if (ret < 0) {
 179                 dev_err(&data->client->dev, "Error reading reg_data_ctrl\n");
 180                 return ret;
 181         }
 182
 183         data->odr_bits = ret;
 184
 185         /* Set up INT polarity */
 186         ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_CTRL1);
 187         if (ret < 0) {
 188                 dev_err(&data->client->dev, "Error reading reg_int_ctrl1\n");
 189                 return ret;
 190         }
 191
 192         if (data->active_high_intr)
 193                 ret |= KXCJK1013_REG_INT_REG1_BIT_IEA;
 194         else
 195                 ret &= ~KXCJK1013_REG_INT_REG1_BIT_IEA;
 196
 197         ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_INT_CTRL1,
 198                                         ret);
 199         if (ret < 0) {
 200                 dev_err(&data->client->dev, "Error writing reg_int_ctrl1\n");
 201                 return ret;
 202         }
 203
 204         return 0;
 205 }
 206
 207 static int kxcjk1013_chip_setup_interrupt(struct kxcjk1013_data *data,
 208                                           bool status)
 209 {
 210         int ret;
 211
 212         /* This is requirement by spec to change state to STANDBY */
 213         ret = kxcjk1013_set_mode(data, STANDBY);
 214         if (ret < 0)
 215                 return ret;
 216
 217         ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_CTRL1);
 218         if (ret < 0) {
 219                 dev_err(&data->client->dev, "Error reading reg_int_ctrl1\n");
 220                 return ret;
 221         }
 222
 223         if (status)
 224                 ret |= KXCJK1013_REG_INT_REG1_BIT_IEN;
 225         else
 226                 ret &= ~KXCJK1013_REG_INT_REG1_BIT_IEN;
 227
 228         ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_INT_CTRL1,
 229                                         ret);
 230         if (ret < 0) {
 231                 dev_err(&data->client->dev, "Error writing reg_int_ctrl1\n");
 232                 return ret;
 233         }
 234
 235         ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1);
 236         if (ret < 0) {
 237                 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
 238                 return ret;
 239         }
 240
 241         if (status)
 242                 ret |= KXCJK1013_REG_CTRL1_BIT_DRDY;
 243         else
 244                 ret &= ~KXCJK1013_REG_CTRL1_BIT_DRDY;
 245
 246         ret = i2c_smbus_write_byte_data(data->client,
 247                                         KXCJK1013_REG_CTRL1, ret);
 248         if (ret < 0) {
 249                 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
 250                 return ret;
 251         }
 252
 253         return ret;
 254 }
 255
 256 static int kxcjk1013_convert_freq_to_bit(int val, int val2)
 257 {
 258         int i;
 259
 260         for (i = 0; i < ARRAY_SIZE(samp_freq_table); ++i) {
 261                 if (samp_freq_table[i].val == val &&
 262                         samp_freq_table[i].val2 == val2) {
 263                         return samp_freq_table[i].odr_bits;
 264                 }
 265         }
 266
 267         return -EINVAL;
 268 }
 269
 270 static int kxcjk1013_set_odr(struct kxcjk1013_data *data, int val, int val2)
 271 {
 272         int ret;
 273         int odr_bits;
 274
 275         odr_bits = kxcjk1013_convert_freq_to_bit(val, val2);
 276         if (odr_bits < 0)
 277                 return odr_bits;
 278
 279         /* To change ODR, the chip must be set to STANDBY as per spec */
 280         ret = kxcjk1013_set_mode(data, STANDBY);
 281         if (ret < 0)
 282                 return ret;
 283
 284         ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_DATA_CTRL,
 285                                         odr_bits);
 286         if (ret < 0) {
 287                 dev_err(&data->client->dev, "Error writing data_ctrl\n");
 288                 return ret;
 289         }
 290
 291         data->odr_bits = odr_bits;
 292
 293         /* Check, if the ODR is changed after data enable */
 294         if (data->power_state) {
 295                 /* Set the state back to operation */
 296                 ret = kxcjk1013_set_mode(data, OPERATION);
 297                 if (ret < 0)
 298                         return ret;
 299         }
 300
 301         return 0;
 302 }
 303
 304 static int kxcjk1013_get_odr(struct kxcjk1013_data *data, int *val, int *val2)
 305 {
 306         int i;
 307
 308         for (i = 0; i < ARRAY_SIZE(samp_freq_table); ++i) {
 309                 if (samp_freq_table[i].odr_bits == data->odr_bits) {
 310                         *val = samp_freq_table[i].val;
 311                         *val2 = samp_freq_table[i].val2;
 312                         return IIO_VAL_INT_PLUS_MICRO;
 313                 }
 314         }
 315
 316         return -EINVAL;
 317 }
 318
 319 static int kxcjk1013_get_acc_reg(struct kxcjk1013_data *data, int axis)
 320 {
 321         u8 reg = KXCJK1013_REG_XOUT_L + axis * 2;
 322         int ret;
 323
 324         ret = i2c_smbus_read_word_data(data->client, reg);
 325         if (ret < 0) {
 326                 dev_err(&data->client->dev,
 327                         "failed to read accel_%c registers\n", 'x' + axis);
 328                 return ret;
 329         }
 330
 331         return ret;
 332 }
 333
 334 static int kxcjk1013_get_startup_times(struct kxcjk1013_data *data)
 335 {
 336         int i;
 337
 338         for (i = 0; i < ARRAY_SIZE(odr_start_up_times); ++i) {
 339                 if (odr_start_up_times[i].odr_bits == data->odr_bits)
 340                         return odr_start_up_times[i].usec;
 341         }
 342
 343         return KXCJK1013_MAX_STARTUP_TIME_US;
 344 }
 345
 346 static int kxcjk1013_read_raw(struct iio_dev *indio_dev,
 347                               struct iio_chan_spec const *chan, int *val,
 348                               int *val2, long mask)
 349 {
 350         struct kxcjk1013_data *data = iio_priv(indio_dev);
 351         int ret;
 352
 353         switch (mask) {
 354         case IIO_CHAN_INFO_RAW:
 355                 mutex_lock(&data->mutex);
 356                 if (iio_buffer_enabled(indio_dev))
 357                         ret = -EBUSY;
 358                 else {
 359                         int sleep_val;
 360
 361                         ret = kxcjk1013_set_mode(data, OPERATION);
 362                         if (ret < 0) {
 363                                 mutex_unlock(&data->mutex);
 364                                 return ret;
 365                         }
 366                         ++data->power_state;
 367                         sleep_val = kxcjk1013_get_startup_times(data);
 368                         if (sleep_val < 20000)
 369                                 usleep_range(sleep_val, 20000);
 370                         else
 371                                 msleep_interruptible(sleep_val/1000);
 372                         ret = kxcjk1013_get_acc_reg(data, chan->scan_index);
 373                         if (--data->power_state == 0)
 374                                 kxcjk1013_set_mode(data, STANDBY);
 375                 }
 376                 mutex_unlock(&data->mutex);
 377
 378                 if (ret < 0)
 379                         return ret;
 380
 381                 *val = sign_extend32(ret >> 4, 11);
 382                 return IIO_VAL_INT;
 383
 384         case IIO_CHAN_INFO_SCALE:
 385                 *val = 0;
 386                 *val2 = 19163; /* range +-4g (4/2047*9.806650) */
 387                 return IIO_VAL_INT_PLUS_MICRO;
 388
 389         case IIO_CHAN_INFO_SAMP_FREQ:
 390                 mutex_lock(&data->mutex);
 391                 ret = kxcjk1013_get_odr(data, val, val2);
 392                 mutex_unlock(&data->mutex);
 393                 return ret;
 394
 395         default:
 396                 return -EINVAL;
 397         }
 398 }
 399
 400 static int kxcjk1013_write_raw(struct iio_dev *indio_dev,
 401                                struct iio_chan_spec const *chan, int val,
 402                                int val2, long mask)
 403 {
 404         struct kxcjk1013_data *data = iio_priv(indio_dev);
 405         int ret;
 406
 407         switch (mask) {
 408         case IIO_CHAN_INFO_SAMP_FREQ:
 409                 mutex_lock(&data->mutex);
 410                 ret = kxcjk1013_set_odr(data, val, val2);
 411                 mutex_unlock(&data->mutex);
 412                 break;
 413         default:
 414                 ret = -EINVAL;
 415         }
 416
 417         return ret;
 418 }
 419
 420 static int kxcjk1013_validate_trigger(struct iio_dev *indio_dev,
 421                                       struct iio_trigger *trig)
 422 {
 423         struct kxcjk1013_data *data = iio_priv(indio_dev);
 424
 425         if (data->trig != trig)
 426                 return -EINVAL;
 427
 428         return 0;
 429 }
 430
 431 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(
 432         "0.781000 1.563000 3.125000 6.250000 12.500000 25 50 100 200 400 800 1600");
 433
 434 static struct attribute *kxcjk1013_attributes[] = {
 435         &iio_const_attr_sampling_frequency_available.dev_attr.attr,
 436         NULL,
 437 };
 438
 439 static const struct attribute_group kxcjk1013_attrs_group = {
 440         .attrs = kxcjk1013_attributes,
 441 };
 442
 443 #define KXCJK1013_CHANNEL(_axis) {                                      \
 444         .type = IIO_ACCEL,                                              \
 445         .modified = 1,                                                  \
 446         .channel2 = IIO_MOD_##_axis,                                    \
 447         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),                   \
 448         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |          \
 449                                 BIT(IIO_CHAN_INFO_SAMP_FREQ),           \
 450         .scan_index = AXIS_##_axis,                                     \
 451         .scan_type = {                                                  \
 452                 .sign = 's',                                            \
 453                 .realbits = 12,                                         \
 454                 .storagebits = 16,                                      \
 455                 .shift = 4,                                             \
 456                 .endianness = IIO_CPU,                                  \
 457         },                                                              \
 458 }
 459
 460 static const struct iio_chan_spec kxcjk1013_channels[] = {
 461         KXCJK1013_CHANNEL(X),
 462         KXCJK1013_CHANNEL(Y),
 463         KXCJK1013_CHANNEL(Z),
 464         IIO_CHAN_SOFT_TIMESTAMP(3),
 465 };
 466
 467 static const struct iio_info kxcjk1013_info = {
 468         .attrs                  = &kxcjk1013_attrs_group,
 469         .read_raw               = kxcjk1013_read_raw,
 470         .write_raw              = kxcjk1013_write_raw,
 471         .validate_trigger       = kxcjk1013_validate_trigger,
 472         .driver_module          = THIS_MODULE,
 473 };
 474
 475 static irqreturn_t kxcjk1013_trigger_handler(int irq, void *p)
 476 {
 477         struct iio_poll_func *pf = p;
 478         struct iio_dev *indio_dev = pf->indio_dev;
 479         struct kxcjk1013_data *data = iio_priv(indio_dev);
 480         int bit, ret, i = 0;
 481
 482         mutex_lock(&data->mutex);
 483
 484         for_each_set_bit(bit, indio_dev->buffer->scan_mask,
 485                          indio_dev->masklength) {
 486                 ret = kxcjk1013_get_acc_reg(data, bit);
 487                 if (ret < 0) {
 488                         mutex_unlock(&data->mutex);
 489                         goto err;
 490                 }
 491                 data->buffer[i++] = ret;
 492         }
 493         mutex_unlock(&data->mutex);
 494
 495         iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
 496                                            pf->timestamp);
 497 err:
 498         iio_trigger_notify_done(indio_dev->trig);
 499
 500         return IRQ_HANDLED;
 501 }
 502
 503 static int kxcjk1013_trig_try_reen(struct iio_trigger *trig)
 504 {
 505         struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
 506         struct kxcjk1013_data *data = iio_priv(indio_dev);
 507         int ret;
 508
 509         ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_REL);
 510         if (ret < 0) {
 511                 dev_err(&data->client->dev, "Error reading reg_int_rel\n");
 512                 return ret;
 513         }
 514
 515         return 0;
 516 }
 517
 518 static int kxcjk1013_data_rdy_trigger_set_state(struct iio_trigger *trig,
 519                                                 bool state)
 520 {
 521         struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
 522         struct kxcjk1013_data *data = iio_priv(indio_dev);
 523
 524         mutex_lock(&data->mutex);
 525         if (state) {
 526                 kxcjk1013_chip_setup_interrupt(data, true);
 527                 kxcjk1013_set_mode(data, OPERATION);
 528                 ++data->power_state;
 529         } else {
 530                 if (--data->power_state) {
 531                         mutex_unlock(&data->mutex);
 532                         return 0;
 533                 }
 534                 kxcjk1013_chip_setup_interrupt(data, false);
 535                 kxcjk1013_set_mode(data, STANDBY);
 536         }
 537         mutex_unlock(&data->mutex);
 538
 539         return 0;
 540 }
 541
 542 static const struct iio_trigger_ops kxcjk1013_trigger_ops = {
 543         .set_trigger_state = kxcjk1013_data_rdy_trigger_set_state,
 544         .try_reenable = kxcjk1013_trig_try_reen,
 545         .owner = THIS_MODULE,
 546 };
 547
 548 static int kxcjk1013_acpi_gpio_probe(struct i2c_client *client,
 549                                      struct kxcjk1013_data *data)
 550 {
 551         const struct acpi_device_id *id;
 552         struct device *dev;
 553         struct gpio_desc *gpio;
 554         int ret;
 555
 556         if (!client)
 557                 return -EINVAL;
 558
 559         dev = &client->dev;
 560         if (!ACPI_HANDLE(dev))
 561                 return -ENODEV;
 562
 563         id = acpi_match_device(dev->driver->acpi_match_table, dev);
 564         if (!id)
 565                 return -ENODEV;
 566
 567         /* data ready gpio interrupt pin */
 568         gpio = devm_gpiod_get_index(dev, "kxcjk1013_int", 0);
 569         if (IS_ERR(gpio)) {
 570                 dev_err(dev, "acpi gpio get index failed\n");
 571                 return PTR_ERR(gpio);
 572         }
 573
 574         ret = gpiod_direction_input(gpio);
 575         if (ret)
 576                 return ret;
 577
 578         ret = gpiod_to_irq(gpio);
 579
 580         dev_dbg(dev, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio), ret);
 581
 582         return ret;
 583 }
 584
 585 static int kxcjk1013_probe(struct i2c_client *client,
 586                            const struct i2c_device_id *id)
 587 {
 588         struct kxcjk1013_data *data;
 589         struct iio_dev *indio_dev;
 590         struct iio_trigger *trig = NULL;
 591         struct kxcjk_1013_platform_data *pdata;
 592         int ret;
 593
 594         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 595         if (!indio_dev)
 596                 return -ENOMEM;
 597
 598         data = iio_priv(indio_dev);
 599         i2c_set_clientdata(client, indio_dev);
 600         data->client = client;
 601
 602         pdata = dev_get_platdata(&client->dev);
 603         if (pdata)
 604                 data->active_high_intr = pdata->active_high_intr;
 605         else
 606                 data->active_high_intr = true; /* default polarity */
 607
 608         ret = kxcjk1013_chip_init(data);
 609         if (ret < 0)
 610                 return ret;
 611
 612         mutex_init(&data->mutex);
 613
 614         indio_dev->dev.parent = &client->dev;
 615         indio_dev->channels = kxcjk1013_channels;
 616         indio_dev->num_channels = ARRAY_SIZE(kxcjk1013_channels);
 617         indio_dev->name = KXCJK1013_DRV_NAME;
 618         indio_dev->modes = INDIO_DIRECT_MODE;
 619         indio_dev->info = &kxcjk1013_info;
 620
 621         if (client->irq < 0)
 622                 client->irq = kxcjk1013_acpi_gpio_probe(client, data);
 623
 624         if (client->irq >= 0) {
 625                 trig = iio_trigger_alloc("%s-dev%d", indio_dev->name,
 626                                          indio_dev->id);
 627                 if (!trig)
 628                         return -ENOMEM;
 629
 630                 data->trig_mode = true;
 631
 632                 ret = devm_request_irq(&client->dev, client->irq,
 633                                         iio_trigger_generic_data_rdy_poll,
 634                                         IRQF_TRIGGER_RISING,
 635                                         KXCJK1013_IRQ_NAME,
 636                                         trig);
 637                 if (ret) {
 638                         dev_err(&client->dev, "unable to request IRQ\n");
 639                         goto err_trigger_free;
 640                 }
 641
 642                 trig->dev.parent = &client->dev;
 643                 trig->ops = &kxcjk1013_trigger_ops;
 644                 iio_trigger_set_drvdata(trig, indio_dev);
 645                 data->trig = trig;
 646                 indio_dev->trig = trig;
 647                 iio_trigger_get(indio_dev->trig);
 648
 649                 ret = iio_trigger_register(trig);
 650                 if (ret)
 651                         goto err_trigger_free;
 652
 653                 ret = iio_triggered_buffer_setup(indio_dev,
 654                                                 &iio_pollfunc_store_time,
 655                                                 kxcjk1013_trigger_handler,
 656                                                 NULL);
 657                 if (ret < 0) {
 658                         dev_err(&client->dev,
 659                                         "iio triggered buffer setup failed\n");
 660                         goto err_trigger_unregister;
 661                 }
 662         }
 663
 664         ret = devm_iio_device_register(&client->dev, indio_dev);
 665         if (ret < 0) {
 666                 dev_err(&client->dev, "unable to register iio device\n");
 667                 goto err_buffer_cleanup;
 668         }
 669
 670         return 0;
 671
 672 err_buffer_cleanup:
 673         if (data->trig_mode)
 674                 iio_triggered_buffer_cleanup(indio_dev);
 675 err_trigger_unregister:
 676         if (data->trig_mode)
 677                 iio_trigger_unregister(trig);
 678 err_trigger_free:
 679         if (data->trig_mode)
 680                 iio_trigger_free(trig);
 681
 682         return ret;
 683 }
 684
 685 static int kxcjk1013_remove(struct i2c_client *client)
 686 {
 687         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 688         struct kxcjk1013_data *data = iio_priv(indio_dev);
 689
 690         if (data->trig_mode) {
 691                 iio_triggered_buffer_cleanup(indio_dev);
 692                 iio_trigger_unregister(data->trig);
 693                 iio_trigger_free(data->trig);
 694         }
 695
 696         mutex_lock(&data->mutex);
 697         kxcjk1013_set_mode(data, STANDBY);
 698         mutex_unlock(&data->mutex);
 699
 700         return 0;
 701 }
 702
 703 #ifdef CONFIG_PM_SLEEP
 704 static int kxcjk1013_suspend(struct device *dev)
 705 {
 706         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
 707         struct kxcjk1013_data *data = iio_priv(indio_dev);
 708
 709         mutex_lock(&data->mutex);
 710         kxcjk1013_set_mode(data, STANDBY);
 711         mutex_unlock(&data->mutex);
 712
 713         return 0;
 714 }
 715
 716 static int kxcjk1013_resume(struct device *dev)
 717 {
 718         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
 719         struct kxcjk1013_data *data = iio_priv(indio_dev);
 720
 721         mutex_lock(&data->mutex);
 722
 723         if (data->power_state)
 724                 kxcjk1013_set_mode(data, OPERATION);
 725
 726         mutex_unlock(&data->mutex);
 727
 728         return 0;
 729 }
 730
 731 static SIMPLE_DEV_PM_OPS(kxcjk1013_pm_ops, kxcjk1013_suspend, kxcjk1013_resume);
 732 #define KXCJK1013_PM_OPS (&kxcjk1013_pm_ops)
 733 #else
 734 #define KXCJK1013_PM_OPS NULL
 735 #endif
 736
 737 static const struct acpi_device_id kx_acpi_match[] = {
 738         {"KXCJ1013", 0},
 739         { },
 740 };
 741 MODULE_DEVICE_TABLE(acpi, kx_acpi_match);
 742
 743 static const struct i2c_device_id kxcjk1013_id[] = {
 744         {"kxcjk1013", 0},
 745         {}
 746 };
 747
 748 MODULE_DEVICE_TABLE(i2c, kxcjk1013_id);
 749
 750 static struct i2c_driver kxcjk1013_driver = {
 751         .driver = {
 752                 .name   = KXCJK1013_DRV_NAME,
 753                 .acpi_match_table = ACPI_PTR(kx_acpi_match),
 754                 .pm     = KXCJK1013_PM_OPS,
 755         },
 756         .probe          = kxcjk1013_probe,
 757         .remove         = kxcjk1013_remove,
 758         .id_table       = kxcjk1013_id,
 759 };
 760 module_i2c_driver(kxcjk1013_driver);
 761
 762 MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
 763 MODULE_LICENSE("GPL v2");
 764 MODULE_DESCRIPTION("KXCJK1013 accelerometer driver");