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