drivers/iio/accel/stk8312.c

   1 /**
   2  * Sensortek STK8312 3-Axis Accelerometer
   3  *
   4  * Copyright (c) 2015, 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 STK8312; 7-bit I2C address: 0x3D.
  11  */
  12
  13 #include <linux/acpi.h>
  14 #include <linux/gpio/consumer.h>
  15 #include <linux/i2c.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/kernel.h>
  18 #include <linux/module.h>
  19 #include <linux/delay.h>
  20 #include <linux/iio/buffer.h>
  21 #include <linux/iio/iio.h>
  22 #include <linux/iio/sysfs.h>
  23 #include <linux/iio/trigger.h>
  24 #include <linux/iio/triggered_buffer.h>
  25 #include <linux/iio/trigger_consumer.h>
  26
  27 #define STK8312_REG_XOUT                0x00
  28 #define STK8312_REG_YOUT                0x01
  29 #define STK8312_REG_ZOUT                0x02
  30 #define STK8312_REG_INTSU               0x06
  31 #define STK8312_REG_MODE                0x07
  32 #define STK8312_REG_SR                  0x08
  33 #define STK8312_REG_STH                 0x13
  34 #define STK8312_REG_RESET               0x20
  35 #define STK8312_REG_AFECTRL             0x24
  36 #define STK8312_REG_OTPADDR             0x3D
  37 #define STK8312_REG_OTPDATA             0x3E
  38 #define STK8312_REG_OTPCTRL             0x3F
  39
  40 #define STK8312_MODE_ACTIVE             BIT(0)
  41 #define STK8312_MODE_STANDBY            0x00
  42 #define STK8312_MODE_INT_AH_PP          0xC0    /* active-high, push-pull */
  43 #define STK8312_DREADY_BIT              BIT(4)
  44 #define STK8312_RNG_6G                  1
  45 #define STK8312_RNG_SHIFT               6
  46 #define STK8312_RNG_MASK                GENMASK(7, 6)
  47 #define STK8312_SR_MASK                 GENMASK(2, 0)
  48 #define STK8312_SR_400HZ_IDX            0
  49 #define STK8312_ALL_CHANNEL_MASK        GENMASK(2, 0)
  50 #define STK8312_ALL_CHANNEL_SIZE        3
  51
  52 #define STK8312_DRIVER_NAME             "stk8312"
  53 #define STK8312_GPIO                    "stk8312_gpio"
  54 #define STK8312_IRQ_NAME                "stk8312_event"
  55
  56 /*
  57  * The accelerometer has two measurement ranges:
  58  *
  59  * -6g - +6g (8-bit, signed)
  60  * -16g - +16g (8-bit, signed)
  61  *
  62  * scale1 = (6 + 6) * 9.81 / (2^8 - 1)     = 0.4616
  63  * scale2 = (16 + 16) * 9.81 / (2^8 - 1)   = 1.2311
  64  */
  65 #define STK8312_SCALE_AVAIL             "0.4616 1.2311"
  66
  67 static const int stk8312_scale_table[][2] = {
  68         {0, 461600}, {1, 231100}
  69 };
  70
  71 static const struct {
  72         u16 val;
  73         u32 val2;
  74 } stk8312_samp_freq_table[] = {
  75         {400, 0}, {200, 0}, {100, 0}, {50, 0}, {25, 0},
  76         {12, 500000}, {6, 250000}, {3, 125000}
  77 };
  78
  79 #define STK8312_ACCEL_CHANNEL(index, reg, axis) {                       \
  80         .type = IIO_ACCEL,                                              \
  81         .address = reg,                                                 \
  82         .modified = 1,                                                  \
  83         .channel2 = IIO_MOD_##axis,                                     \
  84         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),                   \
  85         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |          \
  86                                     BIT(IIO_CHAN_INFO_SAMP_FREQ),       \
  87         .scan_index = index,                                            \
  88         .scan_type = {                                                  \
  89                 .sign = 's',                                            \
  90                 .realbits = 8,                                          \
  91                 .storagebits = 8,                                       \
  92                 .endianness = IIO_CPU,                                  \
  93         },                                                              \
  94 }
  95
  96 static const struct iio_chan_spec stk8312_channels[] = {
  97         STK8312_ACCEL_CHANNEL(0, STK8312_REG_XOUT, X),
  98         STK8312_ACCEL_CHANNEL(1, STK8312_REG_YOUT, Y),
  99         STK8312_ACCEL_CHANNEL(2, STK8312_REG_ZOUT, Z),
 100         IIO_CHAN_SOFT_TIMESTAMP(3),
 101 };
 102
 103 struct stk8312_data {
 104         struct i2c_client *client;
 105         struct mutex lock;
 106         int range;
 107         u8 sample_rate_idx;
 108         u8 mode;
 109         struct iio_trigger *dready_trig;
 110         bool dready_trigger_on;
 111         s8 buffer[16]; /* 3x8-bit channels + 5x8 padding + 64-bit timestamp */
 112 };
 113
 114 static IIO_CONST_ATTR(in_accel_scale_available, STK8312_SCALE_AVAIL);
 115
 116 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("3.125 6.25 12.5 25 50 100 200 400");
 117
 118 static struct attribute *stk8312_attributes[] = {
 119         &iio_const_attr_in_accel_scale_available.dev_attr.attr,
 120         &iio_const_attr_sampling_frequency_available.dev_attr.attr,
 121         NULL,
 122 };
 123
 124 static const struct attribute_group stk8312_attribute_group = {
 125         .attrs = stk8312_attributes
 126 };
 127
 128 static int stk8312_otp_init(struct stk8312_data *data)
 129 {
 130         int ret;
 131         int count = 10;
 132         struct i2c_client *client = data->client;
 133
 134         ret = i2c_smbus_write_byte_data(client, STK8312_REG_OTPADDR, 0x70);
 135         if (ret < 0)
 136                 goto exit_err;
 137         ret = i2c_smbus_write_byte_data(client, STK8312_REG_OTPCTRL, 0x02);
 138         if (ret < 0)
 139                 goto exit_err;
 140
 141         do {
 142                 usleep_range(1000, 5000);
 143                 ret = i2c_smbus_read_byte_data(client, STK8312_REG_OTPCTRL);
 144                 if (ret < 0)
 145                         goto exit_err;
 146                 count--;
 147         } while (!(ret & BIT(7)) && count > 0);
 148
 149         if (count == 0) {
 150                 ret = -ETIMEDOUT;
 151                 goto exit_err;
 152         }
 153
 154         ret = i2c_smbus_read_byte_data(client, STK8312_REG_OTPDATA);
 155         if (ret == 0)
 156                 ret = -EINVAL;
 157         if (ret < 0)
 158                 goto exit_err;
 159
 160         ret = i2c_smbus_write_byte_data(data->client,
 161                         STK8312_REG_AFECTRL, ret);
 162         if (ret < 0)
 163                 goto exit_err;
 164         msleep(150);
 165
 166         return 0;
 167
 168 exit_err:
 169         dev_err(&client->dev, "failed to initialize sensor\n");
 170         return ret;
 171 }
 172
 173 static int stk8312_set_mode(struct stk8312_data *data, u8 mode)
 174 {
 175         int ret;
 176         struct i2c_client *client = data->client;
 177
 178         if (mode == data->mode)
 179                 return 0;
 180
 181         ret = i2c_smbus_write_byte_data(client, STK8312_REG_MODE, mode);
 182         if (ret < 0) {
 183                 dev_err(&client->dev, "failed to change sensor mode\n");
 184                 return ret;
 185         }
 186
 187         data->mode = mode;
 188         if (mode & STK8312_MODE_ACTIVE) {
 189                 /* Need to run OTP sequence before entering active mode */
 190                 usleep_range(1000, 5000);
 191                 ret = stk8312_otp_init(data);
 192         }
 193
 194         return ret;
 195 }
 196
 197 static int stk8312_set_interrupts(struct stk8312_data *data, u8 int_mask)
 198 {
 199         int ret;
 200         u8 mode;
 201         struct i2c_client *client = data->client;
 202
 203         mode = data->mode;
 204         /* We need to go in standby mode to modify registers */
 205         ret = stk8312_set_mode(data, STK8312_MODE_STANDBY);
 206         if (ret < 0)
 207                 return ret;
 208
 209         ret = i2c_smbus_write_byte_data(client, STK8312_REG_INTSU, int_mask);
 210         if (ret < 0) {
 211                 dev_err(&client->dev, "failed to set interrupts\n");
 212                 stk8312_set_mode(data, mode);
 213                 return ret;
 214         }
 215
 216         return stk8312_set_mode(data, mode);
 217 }
 218
 219 static int stk8312_data_rdy_trigger_set_state(struct iio_trigger *trig,
 220                                               bool state)
 221 {
 222         struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
 223         struct stk8312_data *data = iio_priv(indio_dev);
 224         int ret;
 225
 226         if (state)
 227                 ret = stk8312_set_interrupts(data, STK8312_DREADY_BIT);
 228         else
 229                 ret = stk8312_set_interrupts(data, 0x00);
 230
 231         if (ret < 0) {
 232                 dev_err(&data->client->dev, "failed to set trigger state\n");
 233                 return ret;
 234         }
 235
 236         data->dready_trigger_on = state;
 237
 238         return 0;
 239 }
 240
 241 static const struct iio_trigger_ops stk8312_trigger_ops = {
 242         .set_trigger_state = stk8312_data_rdy_trigger_set_state,
 243         .owner = THIS_MODULE,
 244 };
 245
 246 static int stk8312_set_sample_rate(struct stk8312_data *data, int rate)
 247 {
 248         int ret;
 249         u8 masked_reg;
 250         u8 mode;
 251         struct i2c_client *client = data->client;
 252
 253         if (rate == data->sample_rate_idx)
 254                 return 0;
 255
 256         mode = data->mode;
 257         /* We need to go in standby mode to modify registers */
 258         ret = stk8312_set_mode(data, STK8312_MODE_STANDBY);
 259         if (ret < 0)
 260                 return ret;
 261
 262         ret = i2c_smbus_read_byte_data(client, STK8312_REG_SR);
 263         if (ret < 0)
 264                 goto err_activate;
 265
 266         masked_reg = (ret & (~STK8312_SR_MASK)) | rate;
 267
 268         ret = i2c_smbus_write_byte_data(client, STK8312_REG_SR, masked_reg);
 269         if (ret < 0)
 270                 goto err_activate;
 271
 272         data->sample_rate_idx = rate;
 273
 274         return stk8312_set_mode(data, mode);
 275
 276 err_activate:
 277         dev_err(&client->dev, "failed to set sampling rate\n");
 278         stk8312_set_mode(data, mode);
 279
 280         return ret;
 281 }
 282
 283 static int stk8312_set_range(struct stk8312_data *data, u8 range)
 284 {
 285         int ret;
 286         u8 masked_reg;
 287         u8 mode;
 288         struct i2c_client *client = data->client;
 289
 290         if (range != 1 && range != 2)
 291                 return -EINVAL;
 292         else if (range == data->range)
 293                 return 0;
 294
 295         mode = data->mode;
 296         /* We need to go in standby mode to modify registers */
 297         ret = stk8312_set_mode(data, STK8312_MODE_STANDBY);
 298         if (ret < 0)
 299                 return ret;
 300
 301         ret = i2c_smbus_read_byte_data(client, STK8312_REG_STH);
 302         if (ret < 0)
 303                 goto err_activate;
 304
 305         masked_reg = ret & (~STK8312_RNG_MASK);
 306         masked_reg |= range << STK8312_RNG_SHIFT;
 307
 308         ret = i2c_smbus_write_byte_data(client, STK8312_REG_STH, masked_reg);
 309         if (ret < 0)
 310                 goto err_activate;
 311
 312         data->range = range;
 313
 314         return stk8312_set_mode(data, mode);
 315
 316 err_activate:
 317         dev_err(&client->dev, "failed to change sensor range\n");
 318         stk8312_set_mode(data, mode);
 319
 320         return ret;
 321 }
 322
 323 static int stk8312_read_accel(struct stk8312_data *data, u8 address)
 324 {
 325         int ret;
 326         struct i2c_client *client = data->client;
 327
 328         if (address > 2)
 329                 return -EINVAL;
 330
 331         ret = i2c_smbus_read_byte_data(client, address);
 332         if (ret < 0)
 333                 dev_err(&client->dev, "register read failed\n");
 334
 335         return ret;
 336 }
 337
 338 static int stk8312_read_raw(struct iio_dev *indio_dev,
 339                             struct iio_chan_spec const *chan,
 340                             int *val, int *val2, long mask)
 341 {
 342         struct stk8312_data *data = iio_priv(indio_dev);
 343         int ret;
 344
 345         switch (mask) {
 346         case IIO_CHAN_INFO_RAW:
 347                 if (iio_buffer_enabled(indio_dev))
 348                         return -EBUSY;
 349                 mutex_lock(&data->lock);
 350                 ret = stk8312_set_mode(data, data->mode | STK8312_MODE_ACTIVE);
 351                 if (ret < 0) {
 352                         mutex_unlock(&data->lock);
 353                         return ret;
 354                 }
 355                 ret = stk8312_read_accel(data, chan->address);
 356                 if (ret < 0) {
 357                         stk8312_set_mode(data,
 358                                          data->mode & (~STK8312_MODE_ACTIVE));
 359                         mutex_unlock(&data->lock);
 360                         return ret;
 361                 }
 362                 *val = sign_extend32(ret, 7);
 363                 ret = stk8312_set_mode(data,
 364                                        data->mode & (~STK8312_MODE_ACTIVE));
 365                 mutex_unlock(&data->lock);
 366                 if (ret < 0)
 367                         return ret;
 368                 return IIO_VAL_INT;
 369         case IIO_CHAN_INFO_SCALE:
 370                 *val = stk8312_scale_table[data->range - 1][0];
 371                 *val2 = stk8312_scale_table[data->range - 1][1];
 372                 return IIO_VAL_INT_PLUS_MICRO;
 373         case IIO_CHAN_INFO_SAMP_FREQ:
 374                 *val = stk8312_samp_freq_table[data->sample_rate_idx].val;
 375                 *val2 = stk8312_samp_freq_table[data->sample_rate_idx].val2;
 376                 return IIO_VAL_INT_PLUS_MICRO;
 377         }
 378
 379         return -EINVAL;
 380 }
 381
 382 static int stk8312_write_raw(struct iio_dev *indio_dev,
 383                              struct iio_chan_spec const *chan,
 384                              int val, int val2, long mask)
 385 {
 386         int i;
 387         int index = -1;
 388         int ret;
 389         struct stk8312_data *data = iio_priv(indio_dev);
 390
 391         switch (mask) {
 392         case IIO_CHAN_INFO_SCALE:
 393                 for (i = 0; i < ARRAY_SIZE(stk8312_scale_table); i++)
 394                         if (val == stk8312_scale_table[i][0] &&
 395                             val2 == stk8312_scale_table[i][1]) {
 396                                 index = i + 1;
 397                                 break;
 398                         }
 399                 if (index < 0)
 400                         return -EINVAL;
 401
 402                 mutex_lock(&data->lock);
 403                 ret = stk8312_set_range(data, index);
 404                 mutex_unlock(&data->lock);
 405
 406                 return ret;
 407         case IIO_CHAN_INFO_SAMP_FREQ:
 408                 for (i = 0; i < ARRAY_SIZE(stk8312_samp_freq_table); i++)
 409                         if (val == stk8312_samp_freq_table[i].val &&
 410                             val2 == stk8312_samp_freq_table[i].val2) {
 411                                 index = i;
 412                                 break;
 413                         }
 414                 if (index < 0)
 415                         return -EINVAL;
 416                 mutex_lock(&data->lock);
 417                 ret = stk8312_set_sample_rate(data, index);
 418                 mutex_unlock(&data->lock);
 419
 420                 return ret;
 421         }
 422
 423         return -EINVAL;
 424 }
 425
 426 static const struct iio_info stk8312_info = {
 427         .driver_module          = THIS_MODULE,
 428         .read_raw               = stk8312_read_raw,
 429         .write_raw              = stk8312_write_raw,
 430         .attrs                  = &stk8312_attribute_group,
 431 };
 432
 433 static irqreturn_t stk8312_trigger_handler(int irq, void *p)
 434 {
 435         struct iio_poll_func *pf = p;
 436         struct iio_dev *indio_dev = pf->indio_dev;
 437         struct stk8312_data *data = iio_priv(indio_dev);
 438         int bit, ret, i = 0;
 439         u8 buffer[STK8312_ALL_CHANNEL_SIZE];
 440
 441         mutex_lock(&data->lock);
 442         /*
 443          * Do a bulk read if all channels are requested,
 444          * from 0x00 (XOUT) to 0x02 (ZOUT)
 445          */
 446         if (*(indio_dev->active_scan_mask) == STK8312_ALL_CHANNEL_MASK) {
 447                 ret = i2c_smbus_read_i2c_block_data(data->client,
 448                                                     STK8312_REG_XOUT,
 449                                                     STK8312_ALL_CHANNEL_SIZE,
 450                                                     buffer);
 451                 if (ret < STK8312_ALL_CHANNEL_SIZE) {
 452                         dev_err(&data->client->dev, "register read failed\n");
 453                         mutex_unlock(&data->lock);
 454                         goto err;
 455                 }
 456                 data->buffer[0] = buffer[0];
 457                 data->buffer[1] = buffer[1];
 458                 data->buffer[2] = buffer[2];
 459         } else {
 460                 for_each_set_bit(bit, indio_dev->active_scan_mask,
 461                            indio_dev->masklength) {
 462                         ret = stk8312_read_accel(data, bit);
 463                         if (ret < 0) {
 464                                 mutex_unlock(&data->lock);
 465                                 goto err;
 466                         }
 467                         data->buffer[i++] = ret;
 468                 }
 469         }
 470         mutex_unlock(&data->lock);
 471
 472         iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
 473                                            pf->timestamp);
 474 err:
 475         iio_trigger_notify_done(indio_dev->trig);
 476
 477         return IRQ_HANDLED;
 478 }
 479
 480 static irqreturn_t stk8312_data_rdy_trig_poll(int irq, void *private)
 481 {
 482         struct iio_dev *indio_dev = private;
 483         struct stk8312_data *data = iio_priv(indio_dev);
 484
 485         if (data->dready_trigger_on)
 486                 iio_trigger_poll(data->dready_trig);
 487
 488         return IRQ_HANDLED;
 489 }
 490
 491 static int stk8312_buffer_preenable(struct iio_dev *indio_dev)
 492 {
 493         struct stk8312_data *data = iio_priv(indio_dev);
 494
 495         return stk8312_set_mode(data, data->mode | STK8312_MODE_ACTIVE);
 496 }
 497
 498 static int stk8312_buffer_postdisable(struct iio_dev *indio_dev)
 499 {
 500         struct stk8312_data *data = iio_priv(indio_dev);
 501
 502         return stk8312_set_mode(data, data->mode & (~STK8312_MODE_ACTIVE));
 503 }
 504
 505 static const struct iio_buffer_setup_ops stk8312_buffer_setup_ops = {
 506         .preenable   = stk8312_buffer_preenable,
 507         .postenable  = iio_triggered_buffer_postenable,
 508         .predisable  = iio_triggered_buffer_predisable,
 509         .postdisable = stk8312_buffer_postdisable,
 510 };
 511
 512 static int stk8312_gpio_probe(struct i2c_client *client)
 513 {
 514         struct device *dev;
 515         struct gpio_desc *gpio;
 516         int ret;
 517
 518         if (!client)
 519                 return -EINVAL;
 520
 521         dev = &client->dev;
 522
 523         /* data ready gpio interrupt pin */
 524         gpio = devm_gpiod_get_index(dev, STK8312_GPIO, 0, GPIOD_IN);
 525         if (IS_ERR(gpio)) {
 526                 dev_err(dev, "acpi gpio get index failed\n");
 527                 return PTR_ERR(gpio);
 528         }
 529
 530         ret = gpiod_to_irq(gpio);
 531         dev_dbg(dev, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio), ret);
 532
 533         return ret;
 534 }
 535
 536 static int stk8312_probe(struct i2c_client *client,
 537                          const struct i2c_device_id *id)
 538 {
 539         int ret;
 540         struct iio_dev *indio_dev;
 541         struct stk8312_data *data;
 542
 543         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
 544         if (!indio_dev) {
 545                 dev_err(&client->dev, "iio allocation failed!\n");
 546                 return -ENOMEM;
 547         }
 548
 549         data = iio_priv(indio_dev);
 550         data->client = client;
 551         i2c_set_clientdata(client, indio_dev);
 552         mutex_init(&data->lock);
 553
 554         indio_dev->dev.parent = &client->dev;
 555         indio_dev->info = &stk8312_info;
 556         indio_dev->name = STK8312_DRIVER_NAME;
 557         indio_dev->modes = INDIO_DIRECT_MODE;
 558         indio_dev->channels = stk8312_channels;
 559         indio_dev->num_channels = ARRAY_SIZE(stk8312_channels);
 560
 561         /* A software reset is recommended at power-on */
 562         ret = i2c_smbus_write_byte_data(data->client, STK8312_REG_RESET, 0x00);
 563         if (ret < 0) {
 564                 dev_err(&client->dev, "failed to reset sensor\n");
 565                 return ret;
 566         }
 567         data->sample_rate_idx = STK8312_SR_400HZ_IDX;
 568         ret = stk8312_set_range(data, STK8312_RNG_6G);
 569         if (ret < 0)
 570                 return ret;
 571
 572         ret = stk8312_set_mode(data,
 573                                STK8312_MODE_INT_AH_PP | STK8312_MODE_ACTIVE);
 574         if (ret < 0)
 575                 return ret;
 576
 577         if (client->irq < 0)
 578                 client->irq = stk8312_gpio_probe(client);
 579
 580         if (client->irq >= 0) {
 581                 ret = devm_request_threaded_irq(&client->dev, client->irq,
 582                                                 stk8312_data_rdy_trig_poll,
 583                                                 NULL,
 584                                                 IRQF_TRIGGER_RISING |
 585                                                 IRQF_ONESHOT,
 586                                                 STK8312_IRQ_NAME,
 587                                                 indio_dev);
 588                 if (ret < 0) {
 589                         dev_err(&client->dev, "request irq %d failed\n",
 590                                 client->irq);
 591                         goto err_power_off;
 592                 }
 593
 594                 data->dready_trig = devm_iio_trigger_alloc(&client->dev,
 595                                                            "%s-dev%d",
 596                                                            indio_dev->name,
 597                                                            indio_dev->id);
 598                 if (!data->dready_trig) {
 599                         ret = -ENOMEM;
 600                         goto err_power_off;
 601                 }
 602
 603                 data->dready_trig->dev.parent = &client->dev;
 604                 data->dready_trig->ops = &stk8312_trigger_ops;
 605                 iio_trigger_set_drvdata(data->dready_trig, indio_dev);
 606                 ret = iio_trigger_register(data->dready_trig);
 607                 if (ret) {
 608                         dev_err(&client->dev, "iio trigger register failed\n");
 609                         goto err_power_off;
 610                 }
 611         }
 612
 613         ret = iio_triggered_buffer_setup(indio_dev,
 614                                          iio_pollfunc_store_time,
 615                                          stk8312_trigger_handler,
 616                                          &stk8312_buffer_setup_ops);
 617         if (ret < 0) {
 618                 dev_err(&client->dev, "iio triggered buffer setup failed\n");
 619                 goto err_trigger_unregister;
 620         }
 621
 622         ret = iio_device_register(indio_dev);
 623         if (ret < 0) {
 624                 dev_err(&client->dev, "device_register failed\n");
 625                 goto err_buffer_cleanup;
 626         }
 627
 628         return 0;
 629
 630 err_buffer_cleanup:
 631         iio_triggered_buffer_cleanup(indio_dev);
 632 err_trigger_unregister:
 633         if (data->dready_trig)
 634                 iio_trigger_unregister(data->dready_trig);
 635 err_power_off:
 636         stk8312_set_mode(data, STK8312_MODE_STANDBY);
 637         return ret;
 638 }
 639
 640 static int stk8312_remove(struct i2c_client *client)
 641 {
 642         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 643         struct stk8312_data *data = iio_priv(indio_dev);
 644
 645         iio_device_unregister(indio_dev);
 646         iio_triggered_buffer_cleanup(indio_dev);
 647
 648         if (data->dready_trig)
 649                 iio_trigger_unregister(data->dready_trig);
 650
 651         return stk8312_set_mode(data, STK8312_MODE_STANDBY);
 652 }
 653
 654 #ifdef CONFIG_PM_SLEEP
 655 static int stk8312_suspend(struct device *dev)
 656 {
 657         struct stk8312_data *data;
 658
 659         data = iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
 660
 661         return stk8312_set_mode(data, data->mode & (~STK8312_MODE_ACTIVE));
 662 }
 663
 664 static int stk8312_resume(struct device *dev)
 665 {
 666         struct stk8312_data *data;
 667
 668         data = iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
 669
 670         return stk8312_set_mode(data, data->mode | STK8312_MODE_ACTIVE);
 671 }
 672
 673 static SIMPLE_DEV_PM_OPS(stk8312_pm_ops, stk8312_suspend, stk8312_resume);
 674
 675 #define STK8312_PM_OPS (&stk8312_pm_ops)
 676 #else
 677 #define STK8312_PM_OPS NULL
 678 #endif
 679
 680 static const struct i2c_device_id stk8312_i2c_id[] = {
 681         {"STK8312", 0},
 682         {}
 683 };
 684 MODULE_DEVICE_TABLE(i2c, stk8312_i2c_id);
 685
 686 static const struct acpi_device_id stk8312_acpi_id[] = {
 687         {"STK8312", 0},
 688         {}
 689 };
 690
 691 MODULE_DEVICE_TABLE(acpi, stk8312_acpi_id);
 692
 693 static struct i2c_driver stk8312_driver = {
 694         .driver = {
 695                 .name = STK8312_DRIVER_NAME,
 696                 .pm = STK8312_PM_OPS,
 697                 .acpi_match_table = ACPI_PTR(stk8312_acpi_id),
 698         },
 699         .probe =            stk8312_probe,
 700         .remove =           stk8312_remove,
 701         .id_table =         stk8312_i2c_id,
 702 };
 703
 704 module_i2c_driver(stk8312_driver);
 705
 706 MODULE_AUTHOR("Tiberiu Breana <tiberiu.a.breana@intel.com>");
 707 MODULE_DESCRIPTION("STK8312 3-Axis Accelerometer driver");
 708 MODULE_LICENSE("GPL v2");