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