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