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