1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2014 Intel Corporation 4 * 5 * Driver for Semtech's SX9500 capacitive proximity/button solution. 6 * Datasheet available at 7 * <http://www.semtech.com/images/datasheet/sx9500.pdf>. 8 */ 9 10 #include <linux/kernel.h> 11 #include <linux/slab.h> 12 #include <linux/module.h> 13 #include <linux/i2c.h> 14 #include <linux/irq.h> 15 #include <linux/acpi.h> 16 #include <linux/gpio/consumer.h> 17 #include <linux/regmap.h> 18 #include <linux/pm.h> 19 #include <linux/delay.h> 20 21 #include <linux/iio/iio.h> 22 #include <linux/iio/buffer.h> 23 #include <linux/iio/sysfs.h> 24 #include <linux/iio/events.h> 25 #include <linux/iio/trigger.h> 26 #include <linux/iio/triggered_buffer.h> 27 #include <linux/iio/trigger_consumer.h> 28 29 #define SX9500_DRIVER_NAME "sx9500" 30 31 /* Register definitions. */ 32 #define SX9500_REG_IRQ_SRC 0x00 33 #define SX9500_REG_STAT 0x01 34 #define SX9500_REG_IRQ_MSK 0x03 35 36 #define SX9500_REG_PROX_CTRL0 0x06 37 #define SX9500_REG_PROX_CTRL1 0x07 38 #define SX9500_REG_PROX_CTRL2 0x08 39 #define SX9500_REG_PROX_CTRL3 0x09 40 #define SX9500_REG_PROX_CTRL4 0x0a 41 #define SX9500_REG_PROX_CTRL5 0x0b 42 #define SX9500_REG_PROX_CTRL6 0x0c 43 #define SX9500_REG_PROX_CTRL7 0x0d 44 #define SX9500_REG_PROX_CTRL8 0x0e 45 46 #define SX9500_REG_SENSOR_SEL 0x20 47 #define SX9500_REG_USE_MSB 0x21 48 #define SX9500_REG_USE_LSB 0x22 49 #define SX9500_REG_AVG_MSB 0x23 50 #define SX9500_REG_AVG_LSB 0x24 51 #define SX9500_REG_DIFF_MSB 0x25 52 #define SX9500_REG_DIFF_LSB 0x26 53 #define SX9500_REG_OFFSET_MSB 0x27 54 #define SX9500_REG_OFFSET_LSB 0x28 55 56 #define SX9500_REG_RESET 0x7f 57 58 /* Write this to REG_RESET to do a soft reset. */ 59 #define SX9500_SOFT_RESET 0xde 60 61 #define SX9500_SCAN_PERIOD_MASK GENMASK(6, 4) 62 #define SX9500_SCAN_PERIOD_SHIFT 4 63 64 /* 65 * These serve for identifying IRQ source in the IRQ_SRC register, and 66 * also for masking the IRQs in the IRQ_MSK register. 67 */ 68 #define SX9500_CLOSE_IRQ BIT(6) 69 #define SX9500_FAR_IRQ BIT(5) 70 #define SX9500_CONVDONE_IRQ BIT(3) 71 72 #define SX9500_PROXSTAT_SHIFT 4 73 #define SX9500_COMPSTAT_MASK GENMASK(3, 0) 74 75 #define SX9500_NUM_CHANNELS 4 76 #define SX9500_CHAN_MASK GENMASK(SX9500_NUM_CHANNELS - 1, 0) 77 78 struct sx9500_data { 79 struct mutex mutex; 80 struct i2c_client *client; 81 struct iio_trigger *trig; 82 struct regmap *regmap; 83 struct gpio_desc *gpiod_rst; 84 /* 85 * Last reading of the proximity status for each channel. We 86 * only send an event to user space when this changes. 87 */ 88 bool prox_stat[SX9500_NUM_CHANNELS]; 89 bool event_enabled[SX9500_NUM_CHANNELS]; 90 bool trigger_enabled; 91 /* Remember enabled channels and sample rate during suspend. */ 92 unsigned int suspend_ctrl0; 93 struct completion completion; 94 int data_rdy_users, close_far_users; 95 int channel_users[SX9500_NUM_CHANNELS]; 96 }; 97 98 static const struct iio_event_spec sx9500_events[] = { 99 { 100 .type = IIO_EV_TYPE_THRESH, 101 .dir = IIO_EV_DIR_EITHER, 102 .mask_separate = BIT(IIO_EV_INFO_ENABLE), 103 }, 104 }; 105 106 #define SX9500_CHANNEL(idx) \ 107 { \ 108 .type = IIO_PROXIMITY, \ 109 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 110 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \ 111 .indexed = 1, \ 112 .channel = idx, \ 113 .event_spec = sx9500_events, \ 114 .num_event_specs = ARRAY_SIZE(sx9500_events), \ 115 .scan_index = idx, \ 116 .scan_type = { \ 117 .sign = 'u', \ 118 .realbits = 16, \ 119 .storagebits = 16, \ 120 .shift = 0, \ 121 }, \ 122 } 123 124 static const struct iio_chan_spec sx9500_channels[] = { 125 SX9500_CHANNEL(0), 126 SX9500_CHANNEL(1), 127 SX9500_CHANNEL(2), 128 SX9500_CHANNEL(3), 129 IIO_CHAN_SOFT_TIMESTAMP(4), 130 }; 131 132 static const struct { 133 int val; 134 int val2; 135 } sx9500_samp_freq_table[] = { 136 {33, 333333}, 137 {16, 666666}, 138 {11, 111111}, 139 {8, 333333}, 140 {6, 666666}, 141 {5, 0}, 142 {3, 333333}, 143 {2, 500000}, 144 }; 145 146 static const unsigned int sx9500_scan_period_table[] = { 147 30, 60, 90, 120, 150, 200, 300, 400, 148 }; 149 150 static const struct regmap_range sx9500_writable_reg_ranges[] = { 151 regmap_reg_range(SX9500_REG_IRQ_MSK, SX9500_REG_IRQ_MSK), 152 regmap_reg_range(SX9500_REG_PROX_CTRL0, SX9500_REG_PROX_CTRL8), 153 regmap_reg_range(SX9500_REG_SENSOR_SEL, SX9500_REG_SENSOR_SEL), 154 regmap_reg_range(SX9500_REG_OFFSET_MSB, SX9500_REG_OFFSET_LSB), 155 regmap_reg_range(SX9500_REG_RESET, SX9500_REG_RESET), 156 }; 157 158 static const struct regmap_access_table sx9500_writeable_regs = { 159 .yes_ranges = sx9500_writable_reg_ranges, 160 .n_yes_ranges = ARRAY_SIZE(sx9500_writable_reg_ranges), 161 }; 162 163 /* 164 * All allocated registers are readable, so we just list unallocated 165 * ones. 166 */ 167 static const struct regmap_range sx9500_non_readable_reg_ranges[] = { 168 regmap_reg_range(SX9500_REG_STAT + 1, SX9500_REG_STAT + 1), 169 regmap_reg_range(SX9500_REG_IRQ_MSK + 1, SX9500_REG_PROX_CTRL0 - 1), 170 regmap_reg_range(SX9500_REG_PROX_CTRL8 + 1, SX9500_REG_SENSOR_SEL - 1), 171 regmap_reg_range(SX9500_REG_OFFSET_LSB + 1, SX9500_REG_RESET - 1), 172 }; 173 174 static const struct regmap_access_table sx9500_readable_regs = { 175 .no_ranges = sx9500_non_readable_reg_ranges, 176 .n_no_ranges = ARRAY_SIZE(sx9500_non_readable_reg_ranges), 177 }; 178 179 static const struct regmap_range sx9500_volatile_reg_ranges[] = { 180 regmap_reg_range(SX9500_REG_IRQ_SRC, SX9500_REG_STAT), 181 regmap_reg_range(SX9500_REG_USE_MSB, SX9500_REG_OFFSET_LSB), 182 regmap_reg_range(SX9500_REG_RESET, SX9500_REG_RESET), 183 }; 184 185 static const struct regmap_access_table sx9500_volatile_regs = { 186 .yes_ranges = sx9500_volatile_reg_ranges, 187 .n_yes_ranges = ARRAY_SIZE(sx9500_volatile_reg_ranges), 188 }; 189 190 static const struct regmap_config sx9500_regmap_config = { 191 .reg_bits = 8, 192 .val_bits = 8, 193 194 .max_register = SX9500_REG_RESET, 195 .cache_type = REGCACHE_RBTREE, 196 197 .wr_table = &sx9500_writeable_regs, 198 .rd_table = &sx9500_readable_regs, 199 .volatile_table = &sx9500_volatile_regs, 200 }; 201 202 static int sx9500_inc_users(struct sx9500_data *data, int *counter, 203 unsigned int reg, unsigned int bitmask) 204 { 205 (*counter)++; 206 if (*counter != 1) 207 /* Bit is already active, nothing to do. */ 208 return 0; 209 210 return regmap_set_bits(data->regmap, reg, bitmask); 211 } 212 213 static int sx9500_dec_users(struct sx9500_data *data, int *counter, 214 unsigned int reg, unsigned int bitmask) 215 { 216 (*counter)--; 217 if (*counter != 0) 218 /* There are more users, do not deactivate. */ 219 return 0; 220 221 return regmap_clear_bits(data->regmap, reg, bitmask); 222 } 223 224 static int sx9500_inc_chan_users(struct sx9500_data *data, int chan) 225 { 226 return sx9500_inc_users(data, &data->channel_users[chan], 227 SX9500_REG_PROX_CTRL0, BIT(chan)); 228 } 229 230 static int sx9500_dec_chan_users(struct sx9500_data *data, int chan) 231 { 232 return sx9500_dec_users(data, &data->channel_users[chan], 233 SX9500_REG_PROX_CTRL0, BIT(chan)); 234 } 235 236 static int sx9500_inc_data_rdy_users(struct sx9500_data *data) 237 { 238 return sx9500_inc_users(data, &data->data_rdy_users, 239 SX9500_REG_IRQ_MSK, SX9500_CONVDONE_IRQ); 240 } 241 242 static int sx9500_dec_data_rdy_users(struct sx9500_data *data) 243 { 244 return sx9500_dec_users(data, &data->data_rdy_users, 245 SX9500_REG_IRQ_MSK, SX9500_CONVDONE_IRQ); 246 } 247 248 static int sx9500_inc_close_far_users(struct sx9500_data *data) 249 { 250 return sx9500_inc_users(data, &data->close_far_users, 251 SX9500_REG_IRQ_MSK, 252 SX9500_CLOSE_IRQ | SX9500_FAR_IRQ); 253 } 254 255 static int sx9500_dec_close_far_users(struct sx9500_data *data) 256 { 257 return sx9500_dec_users(data, &data->close_far_users, 258 SX9500_REG_IRQ_MSK, 259 SX9500_CLOSE_IRQ | SX9500_FAR_IRQ); 260 } 261 262 static int sx9500_read_prox_data(struct sx9500_data *data, 263 const struct iio_chan_spec *chan, 264 int *val) 265 { 266 int ret; 267 __be16 regval; 268 269 ret = regmap_write(data->regmap, SX9500_REG_SENSOR_SEL, chan->channel); 270 if (ret < 0) 271 return ret; 272 273 ret = regmap_bulk_read(data->regmap, SX9500_REG_USE_MSB, ®val, 2); 274 if (ret < 0) 275 return ret; 276 277 *val = be16_to_cpu(regval); 278 279 return IIO_VAL_INT; 280 } 281 282 /* 283 * If we have no interrupt support, we have to wait for a scan period 284 * after enabling a channel to get a result. 285 */ 286 static int sx9500_wait_for_sample(struct sx9500_data *data) 287 { 288 int ret; 289 unsigned int val; 290 291 ret = regmap_read(data->regmap, SX9500_REG_PROX_CTRL0, &val); 292 if (ret < 0) 293 return ret; 294 295 val = (val & SX9500_SCAN_PERIOD_MASK) >> SX9500_SCAN_PERIOD_SHIFT; 296 297 msleep(sx9500_scan_period_table[val]); 298 299 return 0; 300 } 301 302 static int sx9500_read_proximity(struct sx9500_data *data, 303 const struct iio_chan_spec *chan, 304 int *val) 305 { 306 int ret; 307 308 mutex_lock(&data->mutex); 309 310 ret = sx9500_inc_chan_users(data, chan->channel); 311 if (ret < 0) 312 goto out; 313 314 ret = sx9500_inc_data_rdy_users(data); 315 if (ret < 0) 316 goto out_dec_chan; 317 318 mutex_unlock(&data->mutex); 319 320 if (data->client->irq > 0) 321 ret = wait_for_completion_interruptible(&data->completion); 322 else 323 ret = sx9500_wait_for_sample(data); 324 325 mutex_lock(&data->mutex); 326 327 if (ret < 0) 328 goto out_dec_data_rdy; 329 330 ret = sx9500_read_prox_data(data, chan, val); 331 if (ret < 0) 332 goto out_dec_data_rdy; 333 334 ret = sx9500_dec_data_rdy_users(data); 335 if (ret < 0) 336 goto out_dec_chan; 337 338 ret = sx9500_dec_chan_users(data, chan->channel); 339 if (ret < 0) 340 goto out; 341 342 ret = IIO_VAL_INT; 343 344 goto out; 345 346 out_dec_data_rdy: 347 sx9500_dec_data_rdy_users(data); 348 out_dec_chan: 349 sx9500_dec_chan_users(data, chan->channel); 350 out: 351 mutex_unlock(&data->mutex); 352 reinit_completion(&data->completion); 353 354 return ret; 355 } 356 357 static int sx9500_read_samp_freq(struct sx9500_data *data, 358 int *val, int *val2) 359 { 360 int ret; 361 unsigned int regval; 362 363 mutex_lock(&data->mutex); 364 ret = regmap_read(data->regmap, SX9500_REG_PROX_CTRL0, ®val); 365 mutex_unlock(&data->mutex); 366 367 if (ret < 0) 368 return ret; 369 370 regval = (regval & SX9500_SCAN_PERIOD_MASK) >> SX9500_SCAN_PERIOD_SHIFT; 371 *val = sx9500_samp_freq_table[regval].val; 372 *val2 = sx9500_samp_freq_table[regval].val2; 373 374 return IIO_VAL_INT_PLUS_MICRO; 375 } 376 377 static int sx9500_read_raw(struct iio_dev *indio_dev, 378 const struct iio_chan_spec *chan, 379 int *val, int *val2, long mask) 380 { 381 struct sx9500_data *data = iio_priv(indio_dev); 382 int ret; 383 384 switch (chan->type) { 385 case IIO_PROXIMITY: 386 switch (mask) { 387 case IIO_CHAN_INFO_RAW: 388 if (!iio_device_claim_direct(indio_dev)) 389 return -EBUSY; 390 ret = sx9500_read_proximity(data, chan, val); 391 iio_device_release_direct(indio_dev); 392 return ret; 393 case IIO_CHAN_INFO_SAMP_FREQ: 394 return sx9500_read_samp_freq(data, val, val2); 395 default: 396 return -EINVAL; 397 } 398 default: 399 return -EINVAL; 400 } 401 } 402 403 static int sx9500_set_samp_freq(struct sx9500_data *data, 404 int val, int val2) 405 { 406 int i, ret; 407 408 for (i = 0; i < ARRAY_SIZE(sx9500_samp_freq_table); i++) 409 if (val == sx9500_samp_freq_table[i].val && 410 val2 == sx9500_samp_freq_table[i].val2) 411 break; 412 413 if (i == ARRAY_SIZE(sx9500_samp_freq_table)) 414 return -EINVAL; 415 416 mutex_lock(&data->mutex); 417 418 ret = regmap_update_bits(data->regmap, SX9500_REG_PROX_CTRL0, 419 SX9500_SCAN_PERIOD_MASK, 420 i << SX9500_SCAN_PERIOD_SHIFT); 421 422 mutex_unlock(&data->mutex); 423 424 return ret; 425 } 426 427 static int sx9500_write_raw(struct iio_dev *indio_dev, 428 const struct iio_chan_spec *chan, 429 int val, int val2, long mask) 430 { 431 struct sx9500_data *data = iio_priv(indio_dev); 432 433 switch (chan->type) { 434 case IIO_PROXIMITY: 435 switch (mask) { 436 case IIO_CHAN_INFO_SAMP_FREQ: 437 return sx9500_set_samp_freq(data, val, val2); 438 default: 439 return -EINVAL; 440 } 441 default: 442 return -EINVAL; 443 } 444 } 445 446 static irqreturn_t sx9500_irq_handler(int irq, void *private) 447 { 448 struct iio_dev *indio_dev = private; 449 struct sx9500_data *data = iio_priv(indio_dev); 450 451 if (data->trigger_enabled) 452 iio_trigger_poll(data->trig); 453 454 /* 455 * Even if no event is enabled, we need to wake the thread to 456 * clear the interrupt state by reading SX9500_REG_IRQ_SRC. It 457 * is not possible to do that here because regmap_read takes a 458 * mutex. 459 */ 460 return IRQ_WAKE_THREAD; 461 } 462 463 static void sx9500_push_events(struct iio_dev *indio_dev) 464 { 465 int ret; 466 unsigned int val, chan; 467 struct sx9500_data *data = iio_priv(indio_dev); 468 469 ret = regmap_read(data->regmap, SX9500_REG_STAT, &val); 470 if (ret < 0) { 471 dev_err(&data->client->dev, "i2c transfer error in irq\n"); 472 return; 473 } 474 475 val >>= SX9500_PROXSTAT_SHIFT; 476 for (chan = 0; chan < SX9500_NUM_CHANNELS; chan++) { 477 int dir; 478 u64 ev; 479 bool new_prox = val & BIT(chan); 480 481 if (!data->event_enabled[chan]) 482 continue; 483 if (new_prox == data->prox_stat[chan]) 484 /* No change on this channel. */ 485 continue; 486 487 dir = new_prox ? IIO_EV_DIR_FALLING : IIO_EV_DIR_RISING; 488 ev = IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, chan, 489 IIO_EV_TYPE_THRESH, dir); 490 iio_push_event(indio_dev, ev, iio_get_time_ns(indio_dev)); 491 data->prox_stat[chan] = new_prox; 492 } 493 } 494 495 static irqreturn_t sx9500_irq_thread_handler(int irq, void *private) 496 { 497 struct iio_dev *indio_dev = private; 498 struct sx9500_data *data = iio_priv(indio_dev); 499 int ret; 500 unsigned int val; 501 502 mutex_lock(&data->mutex); 503 504 ret = regmap_read(data->regmap, SX9500_REG_IRQ_SRC, &val); 505 if (ret < 0) { 506 dev_err(&data->client->dev, "i2c transfer error in irq\n"); 507 goto out; 508 } 509 510 if (val & (SX9500_CLOSE_IRQ | SX9500_FAR_IRQ)) 511 sx9500_push_events(indio_dev); 512 513 if (val & SX9500_CONVDONE_IRQ) 514 complete(&data->completion); 515 516 out: 517 mutex_unlock(&data->mutex); 518 519 return IRQ_HANDLED; 520 } 521 522 static int sx9500_read_event_config(struct iio_dev *indio_dev, 523 const struct iio_chan_spec *chan, 524 enum iio_event_type type, 525 enum iio_event_direction dir) 526 { 527 struct sx9500_data *data = iio_priv(indio_dev); 528 529 if (chan->type != IIO_PROXIMITY || type != IIO_EV_TYPE_THRESH || 530 dir != IIO_EV_DIR_EITHER) 531 return -EINVAL; 532 533 return data->event_enabled[chan->channel]; 534 } 535 536 static int sx9500_write_event_config(struct iio_dev *indio_dev, 537 const struct iio_chan_spec *chan, 538 enum iio_event_type type, 539 enum iio_event_direction dir, 540 bool state) 541 { 542 struct sx9500_data *data = iio_priv(indio_dev); 543 int ret; 544 545 if (chan->type != IIO_PROXIMITY || type != IIO_EV_TYPE_THRESH || 546 dir != IIO_EV_DIR_EITHER) 547 return -EINVAL; 548 549 mutex_lock(&data->mutex); 550 551 if (state) { 552 ret = sx9500_inc_chan_users(data, chan->channel); 553 if (ret < 0) 554 goto out_unlock; 555 ret = sx9500_inc_close_far_users(data); 556 if (ret < 0) 557 goto out_undo_chan; 558 } else { 559 ret = sx9500_dec_chan_users(data, chan->channel); 560 if (ret < 0) 561 goto out_unlock; 562 ret = sx9500_dec_close_far_users(data); 563 if (ret < 0) 564 goto out_undo_chan; 565 } 566 567 data->event_enabled[chan->channel] = state; 568 goto out_unlock; 569 570 out_undo_chan: 571 if (state) 572 sx9500_dec_chan_users(data, chan->channel); 573 else 574 sx9500_inc_chan_users(data, chan->channel); 575 out_unlock: 576 mutex_unlock(&data->mutex); 577 return ret; 578 } 579 580 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL( 581 "2.500000 3.333333 5 6.666666 8.333333 11.111111 16.666666 33.333333"); 582 583 static struct attribute *sx9500_attributes[] = { 584 &iio_const_attr_sampling_frequency_available.dev_attr.attr, 585 NULL, 586 }; 587 588 static const struct attribute_group sx9500_attribute_group = { 589 .attrs = sx9500_attributes, 590 }; 591 592 static const struct iio_info sx9500_info = { 593 .attrs = &sx9500_attribute_group, 594 .read_raw = &sx9500_read_raw, 595 .write_raw = &sx9500_write_raw, 596 .read_event_config = &sx9500_read_event_config, 597 .write_event_config = &sx9500_write_event_config, 598 }; 599 600 static int sx9500_set_trigger_state(struct iio_trigger *trig, 601 bool state) 602 { 603 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig); 604 struct sx9500_data *data = iio_priv(indio_dev); 605 int ret; 606 607 mutex_lock(&data->mutex); 608 609 if (state) 610 ret = sx9500_inc_data_rdy_users(data); 611 else 612 ret = sx9500_dec_data_rdy_users(data); 613 if (ret < 0) 614 goto out; 615 616 data->trigger_enabled = state; 617 618 out: 619 mutex_unlock(&data->mutex); 620 621 return ret; 622 } 623 624 static const struct iio_trigger_ops sx9500_trigger_ops = { 625 .set_trigger_state = sx9500_set_trigger_state, 626 }; 627 628 static irqreturn_t sx9500_trigger_handler(int irq, void *private) 629 { 630 struct iio_poll_func *pf = private; 631 struct iio_dev *indio_dev = pf->indio_dev; 632 struct sx9500_data *data = iio_priv(indio_dev); 633 int val, bit, ret, i = 0; 634 struct { 635 u16 chan[SX9500_NUM_CHANNELS]; 636 aligned_s64 timestamp; 637 } scan = { }; 638 639 mutex_lock(&data->mutex); 640 641 iio_for_each_active_channel(indio_dev, bit) { 642 ret = sx9500_read_prox_data(data, &indio_dev->channels[bit], 643 &val); 644 if (ret < 0) 645 goto out; 646 647 scan.chan[i++] = val; 648 } 649 650 iio_push_to_buffers_with_timestamp(indio_dev, &scan, 651 iio_get_time_ns(indio_dev)); 652 653 out: 654 mutex_unlock(&data->mutex); 655 656 iio_trigger_notify_done(indio_dev->trig); 657 658 return IRQ_HANDLED; 659 } 660 661 static int sx9500_buffer_postenable(struct iio_dev *indio_dev) 662 { 663 struct sx9500_data *data = iio_priv(indio_dev); 664 int ret = 0, i; 665 666 mutex_lock(&data->mutex); 667 668 for (i = 0; i < SX9500_NUM_CHANNELS; i++) 669 if (test_bit(i, indio_dev->active_scan_mask)) { 670 ret = sx9500_inc_chan_users(data, i); 671 if (ret) 672 break; 673 } 674 675 if (ret) 676 for (i = i - 1; i >= 0; i--) 677 if (test_bit(i, indio_dev->active_scan_mask)) 678 sx9500_dec_chan_users(data, i); 679 680 mutex_unlock(&data->mutex); 681 682 return ret; 683 } 684 685 static int sx9500_buffer_predisable(struct iio_dev *indio_dev) 686 { 687 struct sx9500_data *data = iio_priv(indio_dev); 688 int ret = 0, i; 689 690 mutex_lock(&data->mutex); 691 692 for (i = 0; i < SX9500_NUM_CHANNELS; i++) 693 if (test_bit(i, indio_dev->active_scan_mask)) { 694 ret = sx9500_dec_chan_users(data, i); 695 if (ret) 696 break; 697 } 698 699 if (ret) 700 for (i = i - 1; i >= 0; i--) 701 if (test_bit(i, indio_dev->active_scan_mask)) 702 sx9500_inc_chan_users(data, i); 703 704 mutex_unlock(&data->mutex); 705 706 return ret; 707 } 708 709 static const struct iio_buffer_setup_ops sx9500_buffer_setup_ops = { 710 .postenable = sx9500_buffer_postenable, 711 .predisable = sx9500_buffer_predisable, 712 }; 713 714 struct sx9500_reg_default { 715 u8 reg; 716 u8 def; 717 }; 718 719 static const struct sx9500_reg_default sx9500_default_regs[] = { 720 { 721 .reg = SX9500_REG_PROX_CTRL1, 722 /* Shield enabled, small range. */ 723 .def = 0x43, 724 }, 725 { 726 .reg = SX9500_REG_PROX_CTRL2, 727 /* x8 gain, 167kHz frequency, finest resolution. */ 728 .def = 0x77, 729 }, 730 { 731 .reg = SX9500_REG_PROX_CTRL3, 732 /* Doze enabled, 2x scan period doze, no raw filter. */ 733 .def = 0x40, 734 }, 735 { 736 .reg = SX9500_REG_PROX_CTRL4, 737 /* Average threshold. */ 738 .def = 0x30, 739 }, 740 { 741 .reg = SX9500_REG_PROX_CTRL5, 742 /* 743 * Debouncer off, lowest average negative filter, 744 * highest average positive filter. 745 */ 746 .def = 0x0f, 747 }, 748 { 749 .reg = SX9500_REG_PROX_CTRL6, 750 /* Proximity detection threshold: 280 */ 751 .def = 0x0e, 752 }, 753 { 754 .reg = SX9500_REG_PROX_CTRL7, 755 /* 756 * No automatic compensation, compensate each pin 757 * independently, proximity hysteresis: 32, close 758 * debouncer off, far debouncer off. 759 */ 760 .def = 0x00, 761 }, 762 { 763 .reg = SX9500_REG_PROX_CTRL8, 764 /* No stuck timeout, no periodic compensation. */ 765 .def = 0x00, 766 }, 767 { 768 .reg = SX9500_REG_PROX_CTRL0, 769 /* Scan period: 30ms, all sensors disabled. */ 770 .def = 0x00, 771 }, 772 }; 773 774 /* Activate all channels and perform an initial compensation. */ 775 static int sx9500_init_compensation(struct iio_dev *indio_dev) 776 { 777 struct sx9500_data *data = iio_priv(indio_dev); 778 int i, ret; 779 unsigned int val; 780 781 ret = regmap_set_bits(data->regmap, SX9500_REG_PROX_CTRL0, 782 SX9500_CHAN_MASK); 783 if (ret < 0) 784 return ret; 785 786 for (i = 10; i >= 0; i--) { 787 usleep_range(10000, 20000); 788 ret = regmap_read(data->regmap, SX9500_REG_STAT, &val); 789 if (ret < 0) 790 goto out; 791 if (!(val & SX9500_COMPSTAT_MASK)) 792 break; 793 } 794 795 if (i < 0) { 796 dev_err(&data->client->dev, "initial compensation timed out"); 797 ret = -ETIMEDOUT; 798 } 799 800 out: 801 regmap_clear_bits(data->regmap, SX9500_REG_PROX_CTRL0, 802 SX9500_CHAN_MASK); 803 return ret; 804 } 805 806 static int sx9500_init_device(struct iio_dev *indio_dev) 807 { 808 struct sx9500_data *data = iio_priv(indio_dev); 809 int ret, i; 810 unsigned int val; 811 812 if (data->gpiod_rst) { 813 gpiod_set_value_cansleep(data->gpiod_rst, 0); 814 usleep_range(1000, 2000); 815 gpiod_set_value_cansleep(data->gpiod_rst, 1); 816 usleep_range(1000, 2000); 817 } 818 819 ret = regmap_write(data->regmap, SX9500_REG_IRQ_MSK, 0); 820 if (ret < 0) 821 return ret; 822 823 ret = regmap_write(data->regmap, SX9500_REG_RESET, 824 SX9500_SOFT_RESET); 825 if (ret < 0) 826 return ret; 827 828 ret = regmap_read(data->regmap, SX9500_REG_IRQ_SRC, &val); 829 if (ret < 0) 830 return ret; 831 832 for (i = 0; i < ARRAY_SIZE(sx9500_default_regs); i++) { 833 ret = regmap_write(data->regmap, 834 sx9500_default_regs[i].reg, 835 sx9500_default_regs[i].def); 836 if (ret < 0) 837 return ret; 838 } 839 840 return sx9500_init_compensation(indio_dev); 841 } 842 843 static const struct acpi_gpio_params reset_gpios = { 0, 0, false }; 844 static const struct acpi_gpio_params interrupt_gpios = { 2, 0, false }; 845 846 static const struct acpi_gpio_mapping acpi_sx9500_gpios[] = { 847 { "reset-gpios", &reset_gpios, 1 }, 848 /* 849 * Some platforms have a bug in ACPI GPIO description making IRQ 850 * GPIO to be output only. Ask the GPIO core to ignore this limit. 851 */ 852 { "interrupt-gpios", &interrupt_gpios, 1, ACPI_GPIO_QUIRK_NO_IO_RESTRICTION }, 853 { } 854 }; 855 856 static void sx9500_gpio_probe(struct i2c_client *client, 857 struct sx9500_data *data) 858 { 859 struct gpio_desc *gpiod_int; 860 struct device *dev; 861 int ret; 862 863 if (!client) 864 return; 865 866 dev = &client->dev; 867 868 ret = devm_acpi_dev_add_driver_gpios(dev, acpi_sx9500_gpios); 869 if (ret) 870 dev_dbg(dev, "Unable to add GPIO mapping table\n"); 871 872 if (client->irq <= 0) { 873 gpiod_int = devm_gpiod_get(dev, "interrupt", GPIOD_IN); 874 if (IS_ERR(gpiod_int)) 875 dev_err(dev, "gpio get irq failed\n"); 876 else 877 client->irq = gpiod_to_irq(gpiod_int); 878 } 879 880 data->gpiod_rst = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH); 881 if (IS_ERR(data->gpiod_rst)) { 882 dev_warn(dev, "gpio get reset pin failed\n"); 883 data->gpiod_rst = NULL; 884 } 885 } 886 887 static int sx9500_probe(struct i2c_client *client) 888 { 889 int ret; 890 struct iio_dev *indio_dev; 891 struct sx9500_data *data; 892 893 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 894 if (indio_dev == NULL) 895 return -ENOMEM; 896 897 data = iio_priv(indio_dev); 898 data->client = client; 899 mutex_init(&data->mutex); 900 init_completion(&data->completion); 901 data->trigger_enabled = false; 902 903 data->regmap = devm_regmap_init_i2c(client, &sx9500_regmap_config); 904 if (IS_ERR(data->regmap)) 905 return PTR_ERR(data->regmap); 906 907 indio_dev->name = SX9500_DRIVER_NAME; 908 indio_dev->channels = sx9500_channels; 909 indio_dev->num_channels = ARRAY_SIZE(sx9500_channels); 910 indio_dev->info = &sx9500_info; 911 indio_dev->modes = INDIO_DIRECT_MODE; 912 i2c_set_clientdata(client, indio_dev); 913 914 sx9500_gpio_probe(client, data); 915 916 ret = sx9500_init_device(indio_dev); 917 if (ret < 0) 918 return ret; 919 920 if (client->irq <= 0) 921 dev_warn(&client->dev, "no valid irq found\n"); 922 else { 923 ret = devm_request_threaded_irq(&client->dev, client->irq, 924 sx9500_irq_handler, sx9500_irq_thread_handler, 925 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 926 "sx9500_event", indio_dev); 927 if (ret < 0) 928 return ret; 929 930 data->trig = devm_iio_trigger_alloc(&client->dev, 931 "%s-dev%d", indio_dev->name, iio_device_id(indio_dev)); 932 if (!data->trig) 933 return -ENOMEM; 934 935 data->trig->ops = &sx9500_trigger_ops; 936 iio_trigger_set_drvdata(data->trig, indio_dev); 937 938 ret = iio_trigger_register(data->trig); 939 if (ret) 940 return ret; 941 } 942 943 ret = iio_triggered_buffer_setup(indio_dev, NULL, 944 sx9500_trigger_handler, 945 &sx9500_buffer_setup_ops); 946 if (ret < 0) 947 goto out_trigger_unregister; 948 949 ret = iio_device_register(indio_dev); 950 if (ret < 0) 951 goto out_buffer_cleanup; 952 953 return 0; 954 955 out_buffer_cleanup: 956 iio_triggered_buffer_cleanup(indio_dev); 957 out_trigger_unregister: 958 if (client->irq > 0) 959 iio_trigger_unregister(data->trig); 960 961 return ret; 962 } 963 964 static void sx9500_remove(struct i2c_client *client) 965 { 966 struct iio_dev *indio_dev = i2c_get_clientdata(client); 967 struct sx9500_data *data = iio_priv(indio_dev); 968 969 iio_device_unregister(indio_dev); 970 iio_triggered_buffer_cleanup(indio_dev); 971 if (client->irq > 0) 972 iio_trigger_unregister(data->trig); 973 } 974 975 static int sx9500_suspend(struct device *dev) 976 { 977 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 978 struct sx9500_data *data = iio_priv(indio_dev); 979 int ret; 980 981 mutex_lock(&data->mutex); 982 ret = regmap_read(data->regmap, SX9500_REG_PROX_CTRL0, 983 &data->suspend_ctrl0); 984 if (ret < 0) 985 goto out; 986 987 /* 988 * Scan period doesn't matter because when all the sensors are 989 * deactivated the device is in sleep mode. 990 */ 991 ret = regmap_write(data->regmap, SX9500_REG_PROX_CTRL0, 0); 992 993 out: 994 mutex_unlock(&data->mutex); 995 return ret; 996 } 997 998 static int sx9500_resume(struct device *dev) 999 { 1000 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 1001 struct sx9500_data *data = iio_priv(indio_dev); 1002 int ret; 1003 1004 mutex_lock(&data->mutex); 1005 ret = regmap_write(data->regmap, SX9500_REG_PROX_CTRL0, 1006 data->suspend_ctrl0); 1007 mutex_unlock(&data->mutex); 1008 1009 return ret; 1010 } 1011 1012 static DEFINE_SIMPLE_DEV_PM_OPS(sx9500_pm_ops, sx9500_suspend, sx9500_resume); 1013 1014 static const struct acpi_device_id sx9500_acpi_match[] = { 1015 {"SSX9500", 0}, 1016 {"SASX9500", 0}, 1017 { } 1018 }; 1019 MODULE_DEVICE_TABLE(acpi, sx9500_acpi_match); 1020 1021 static const struct of_device_id sx9500_of_match[] = { 1022 { .compatible = "semtech,sx9500", }, 1023 { } 1024 }; 1025 MODULE_DEVICE_TABLE(of, sx9500_of_match); 1026 1027 static const struct i2c_device_id sx9500_id[] = { 1028 { "sx9500" }, 1029 { } 1030 }; 1031 MODULE_DEVICE_TABLE(i2c, sx9500_id); 1032 1033 static struct i2c_driver sx9500_driver = { 1034 .driver = { 1035 .name = SX9500_DRIVER_NAME, 1036 .acpi_match_table = sx9500_acpi_match, 1037 .of_match_table = sx9500_of_match, 1038 .pm = pm_sleep_ptr(&sx9500_pm_ops), 1039 }, 1040 .probe = sx9500_probe, 1041 .remove = sx9500_remove, 1042 .id_table = sx9500_id, 1043 }; 1044 module_i2c_driver(sx9500_driver); 1045 1046 MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>"); 1047 MODULE_DESCRIPTION("Driver for Semtech SX9500 proximity sensor"); 1048 MODULE_LICENSE("GPL v2"); 1049