kxcjk-1013.c revision 59bfeaba3b62089f98952fe689d44a093275b1a0
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 74struct 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 85enum kxcjk1013_axis { 86 AXIS_X, 87 AXIS_Y, 88 AXIS_Z, 89}; 90 91enum kxcjk1013_mode { 92 STANDBY, 93 OPERATION, 94}; 95 96static 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 */ 107static 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 115static 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 141static 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 207static 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 256static 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 270static 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 304static 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 319static 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 334static 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 346static 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 400static 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 420static 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 431static 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 434static struct attribute *kxcjk1013_attributes[] = { 435 &iio_const_attr_sampling_frequency_available.dev_attr.attr, 436 NULL, 437}; 438 439static 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_LE, \ 457 }, \ 458} 459 460static 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 467static 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 475static 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); 497err: 498 iio_trigger_notify_done(indio_dev->trig); 499 500 return IRQ_HANDLED; 501} 502 503static 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 518static 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 542static 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 548static 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 585static 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 648 ret = iio_trigger_register(trig); 649 if (ret) 650 goto err_trigger_free; 651 652 ret = iio_triggered_buffer_setup(indio_dev, 653 &iio_pollfunc_store_time, 654 kxcjk1013_trigger_handler, 655 NULL); 656 if (ret < 0) { 657 dev_err(&client->dev, 658 "iio triggered buffer setup failed\n"); 659 goto err_trigger_unregister; 660 } 661 } 662 663 ret = devm_iio_device_register(&client->dev, indio_dev); 664 if (ret < 0) { 665 dev_err(&client->dev, "unable to register iio device\n"); 666 goto err_buffer_cleanup; 667 } 668 669 return 0; 670 671err_buffer_cleanup: 672 if (data->trig_mode) 673 iio_triggered_buffer_cleanup(indio_dev); 674err_trigger_unregister: 675 if (data->trig_mode) 676 iio_trigger_unregister(trig); 677err_trigger_free: 678 if (data->trig_mode) 679 iio_trigger_free(trig); 680 681 return ret; 682} 683 684static int kxcjk1013_remove(struct i2c_client *client) 685{ 686 struct iio_dev *indio_dev = i2c_get_clientdata(client); 687 struct kxcjk1013_data *data = iio_priv(indio_dev); 688 689 if (data->trig_mode) { 690 iio_triggered_buffer_cleanup(indio_dev); 691 iio_trigger_unregister(data->trig); 692 iio_trigger_free(data->trig); 693 } 694 695 mutex_lock(&data->mutex); 696 kxcjk1013_set_mode(data, STANDBY); 697 mutex_unlock(&data->mutex); 698 699 return 0; 700} 701 702#ifdef CONFIG_PM_SLEEP 703static int kxcjk1013_suspend(struct device *dev) 704{ 705 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 706 struct kxcjk1013_data *data = iio_priv(indio_dev); 707 708 mutex_lock(&data->mutex); 709 kxcjk1013_set_mode(data, STANDBY); 710 mutex_unlock(&data->mutex); 711 712 return 0; 713} 714 715static int kxcjk1013_resume(struct device *dev) 716{ 717 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 718 struct kxcjk1013_data *data = iio_priv(indio_dev); 719 720 mutex_lock(&data->mutex); 721 722 if (data->power_state) 723 kxcjk1013_set_mode(data, OPERATION); 724 725 mutex_unlock(&data->mutex); 726 727 return 0; 728} 729 730static SIMPLE_DEV_PM_OPS(kxcjk1013_pm_ops, kxcjk1013_suspend, kxcjk1013_resume); 731#define KXCJK1013_PM_OPS (&kxcjk1013_pm_ops) 732#else 733#define KXCJK1013_PM_OPS NULL 734#endif 735 736static const struct acpi_device_id kx_acpi_match[] = { 737 {"KXCJ1013", 0}, 738 { }, 739}; 740MODULE_DEVICE_TABLE(acpi, kx_acpi_match); 741 742static const struct i2c_device_id kxcjk1013_id[] = { 743 {"kxcjk1013", 0}, 744 {} 745}; 746 747MODULE_DEVICE_TABLE(i2c, kxcjk1013_id); 748 749static struct i2c_driver kxcjk1013_driver = { 750 .driver = { 751 .name = KXCJK1013_DRV_NAME, 752 .acpi_match_table = ACPI_PTR(kx_acpi_match), 753 .pm = KXCJK1013_PM_OPS, 754 }, 755 .probe = kxcjk1013_probe, 756 .remove = kxcjk1013_remove, 757 .id_table = kxcjk1013_id, 758}; 759module_i2c_driver(kxcjk1013_driver); 760 761MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>"); 762MODULE_LICENSE("GPL v2"); 763MODULE_DESCRIPTION("KXCJK1013 accelerometer driver"); 764