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_postenable(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 mutex_lock(&data->mutex); 708 709 for (i = 0; i < SX9500_NUM_CHANNELS; i++) 710 if (test_bit(i, indio_dev->active_scan_mask)) { 711 ret = sx9500_dec_chan_users(data, i); 712 if (ret) 713 break; 714 } 715 716 if (ret) 717 for (i = i - 1; i >= 0; i--) 718 if (test_bit(i, indio_dev->active_scan_mask)) 719 sx9500_inc_chan_users(data, i); 720 721 mutex_unlock(&data->mutex); 722 723 return ret; 724 } 725 726 static const struct iio_buffer_setup_ops sx9500_buffer_setup_ops = { 727 .postenable = sx9500_buffer_postenable, 728 .predisable = sx9500_buffer_predisable, 729 }; 730 731 struct sx9500_reg_default { 732 u8 reg; 733 u8 def; 734 }; 735 736 static const struct sx9500_reg_default sx9500_default_regs[] = { 737 { 738 .reg = SX9500_REG_PROX_CTRL1, 739 /* Shield enabled, small range. */ 740 .def = 0x43, 741 }, 742 { 743 .reg = SX9500_REG_PROX_CTRL2, 744 /* x8 gain, 167kHz frequency, finest resolution. */ 745 .def = 0x77, 746 }, 747 { 748 .reg = SX9500_REG_PROX_CTRL3, 749 /* Doze enabled, 2x scan period doze, no raw filter. */ 750 .def = 0x40, 751 }, 752 { 753 .reg = SX9500_REG_PROX_CTRL4, 754 /* Average threshold. */ 755 .def = 0x30, 756 }, 757 { 758 .reg = SX9500_REG_PROX_CTRL5, 759 /* 760 * Debouncer off, lowest average negative filter, 761 * highest average positive filter. 762 */ 763 .def = 0x0f, 764 }, 765 { 766 .reg = SX9500_REG_PROX_CTRL6, 767 /* Proximity detection threshold: 280 */ 768 .def = 0x0e, 769 }, 770 { 771 .reg = SX9500_REG_PROX_CTRL7, 772 /* 773 * No automatic compensation, compensate each pin 774 * independently, proximity hysteresis: 32, close 775 * debouncer off, far debouncer off. 776 */ 777 .def = 0x00, 778 }, 779 { 780 .reg = SX9500_REG_PROX_CTRL8, 781 /* No stuck timeout, no periodic compensation. */ 782 .def = 0x00, 783 }, 784 { 785 .reg = SX9500_REG_PROX_CTRL0, 786 /* Scan period: 30ms, all sensors disabled. */ 787 .def = 0x00, 788 }, 789 }; 790 791 /* Activate all channels and perform an initial compensation. */ 792 static int sx9500_init_compensation(struct iio_dev *indio_dev) 793 { 794 struct sx9500_data *data = iio_priv(indio_dev); 795 int i, ret; 796 unsigned int val; 797 798 ret = regmap_update_bits(data->regmap, SX9500_REG_PROX_CTRL0, 799 SX9500_CHAN_MASK, SX9500_CHAN_MASK); 800 if (ret < 0) 801 return ret; 802 803 for (i = 10; i >= 0; i--) { 804 usleep_range(10000, 20000); 805 ret = regmap_read(data->regmap, SX9500_REG_STAT, &val); 806 if (ret < 0) 807 goto out; 808 if (!(val & SX9500_COMPSTAT_MASK)) 809 break; 810 } 811 812 if (i < 0) { 813 dev_err(&data->client->dev, "initial compensation timed out"); 814 ret = -ETIMEDOUT; 815 } 816 817 out: 818 regmap_update_bits(data->regmap, SX9500_REG_PROX_CTRL0, 819 SX9500_CHAN_MASK, 0); 820 return ret; 821 } 822 823 static int sx9500_init_device(struct iio_dev *indio_dev) 824 { 825 struct sx9500_data *data = iio_priv(indio_dev); 826 int ret, i; 827 unsigned int val; 828 829 if (data->gpiod_rst) { 830 gpiod_set_value_cansleep(data->gpiod_rst, 0); 831 usleep_range(1000, 2000); 832 gpiod_set_value_cansleep(data->gpiod_rst, 1); 833 usleep_range(1000, 2000); 834 } 835 836 ret = regmap_write(data->regmap, SX9500_REG_IRQ_MSK, 0); 837 if (ret < 0) 838 return ret; 839 840 ret = regmap_write(data->regmap, SX9500_REG_RESET, 841 SX9500_SOFT_RESET); 842 if (ret < 0) 843 return ret; 844 845 ret = regmap_read(data->regmap, SX9500_REG_IRQ_SRC, &val); 846 if (ret < 0) 847 return ret; 848 849 for (i = 0; i < ARRAY_SIZE(sx9500_default_regs); i++) { 850 ret = regmap_write(data->regmap, 851 sx9500_default_regs[i].reg, 852 sx9500_default_regs[i].def); 853 if (ret < 0) 854 return ret; 855 } 856 857 return sx9500_init_compensation(indio_dev); 858 } 859 860 static const struct acpi_gpio_params reset_gpios = { 0, 0, false }; 861 static const struct acpi_gpio_params interrupt_gpios = { 2, 0, false }; 862 863 static const struct acpi_gpio_mapping acpi_sx9500_gpios[] = { 864 { "reset-gpios", &reset_gpios, 1 }, 865 /* 866 * Some platforms have a bug in ACPI GPIO description making IRQ 867 * GPIO to be output only. Ask the GPIO core to ignore this limit. 868 */ 869 { "interrupt-gpios", &interrupt_gpios, 1, ACPI_GPIO_QUIRK_NO_IO_RESTRICTION }, 870 { }, 871 }; 872 873 static void sx9500_gpio_probe(struct i2c_client *client, 874 struct sx9500_data *data) 875 { 876 struct gpio_desc *gpiod_int; 877 struct device *dev; 878 int ret; 879 880 if (!client) 881 return; 882 883 dev = &client->dev; 884 885 ret = devm_acpi_dev_add_driver_gpios(dev, acpi_sx9500_gpios); 886 if (ret) 887 dev_dbg(dev, "Unable to add GPIO mapping table\n"); 888 889 if (client->irq <= 0) { 890 gpiod_int = devm_gpiod_get(dev, "interrupt", GPIOD_IN); 891 if (IS_ERR(gpiod_int)) 892 dev_err(dev, "gpio get irq failed\n"); 893 else 894 client->irq = gpiod_to_irq(gpiod_int); 895 } 896 897 data->gpiod_rst = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH); 898 if (IS_ERR(data->gpiod_rst)) { 899 dev_warn(dev, "gpio get reset pin failed\n"); 900 data->gpiod_rst = NULL; 901 } 902 } 903 904 static int sx9500_probe(struct i2c_client *client) 905 { 906 int ret; 907 struct iio_dev *indio_dev; 908 struct sx9500_data *data; 909 910 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 911 if (indio_dev == NULL) 912 return -ENOMEM; 913 914 data = iio_priv(indio_dev); 915 data->client = client; 916 mutex_init(&data->mutex); 917 init_completion(&data->completion); 918 data->trigger_enabled = false; 919 920 data->regmap = devm_regmap_init_i2c(client, &sx9500_regmap_config); 921 if (IS_ERR(data->regmap)) 922 return PTR_ERR(data->regmap); 923 924 indio_dev->name = SX9500_DRIVER_NAME; 925 indio_dev->channels = sx9500_channels; 926 indio_dev->num_channels = ARRAY_SIZE(sx9500_channels); 927 indio_dev->info = &sx9500_info; 928 indio_dev->modes = INDIO_DIRECT_MODE; 929 i2c_set_clientdata(client, indio_dev); 930 931 sx9500_gpio_probe(client, data); 932 933 ret = sx9500_init_device(indio_dev); 934 if (ret < 0) 935 return ret; 936 937 if (client->irq <= 0) 938 dev_warn(&client->dev, "no valid irq found\n"); 939 else { 940 ret = devm_request_threaded_irq(&client->dev, client->irq, 941 sx9500_irq_handler, sx9500_irq_thread_handler, 942 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 943 SX9500_IRQ_NAME, indio_dev); 944 if (ret < 0) 945 return ret; 946 947 data->trig = devm_iio_trigger_alloc(&client->dev, 948 "%s-dev%d", indio_dev->name, iio_device_id(indio_dev)); 949 if (!data->trig) 950 return -ENOMEM; 951 952 data->trig->ops = &sx9500_trigger_ops; 953 iio_trigger_set_drvdata(data->trig, indio_dev); 954 955 ret = iio_trigger_register(data->trig); 956 if (ret) 957 return ret; 958 } 959 960 ret = iio_triggered_buffer_setup(indio_dev, NULL, 961 sx9500_trigger_handler, 962 &sx9500_buffer_setup_ops); 963 if (ret < 0) 964 goto out_trigger_unregister; 965 966 ret = iio_device_register(indio_dev); 967 if (ret < 0) 968 goto out_buffer_cleanup; 969 970 return 0; 971 972 out_buffer_cleanup: 973 iio_triggered_buffer_cleanup(indio_dev); 974 out_trigger_unregister: 975 if (client->irq > 0) 976 iio_trigger_unregister(data->trig); 977 978 return ret; 979 } 980 981 static void sx9500_remove(struct i2c_client *client) 982 { 983 struct iio_dev *indio_dev = i2c_get_clientdata(client); 984 struct sx9500_data *data = iio_priv(indio_dev); 985 986 iio_device_unregister(indio_dev); 987 iio_triggered_buffer_cleanup(indio_dev); 988 if (client->irq > 0) 989 iio_trigger_unregister(data->trig); 990 kfree(data->buffer); 991 } 992 993 static int sx9500_suspend(struct device *dev) 994 { 995 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 996 struct sx9500_data *data = iio_priv(indio_dev); 997 int ret; 998 999 mutex_lock(&data->mutex); 1000 ret = regmap_read(data->regmap, SX9500_REG_PROX_CTRL0, 1001 &data->suspend_ctrl0); 1002 if (ret < 0) 1003 goto out; 1004 1005 /* 1006 * Scan period doesn't matter because when all the sensors are 1007 * deactivated the device is in sleep mode. 1008 */ 1009 ret = regmap_write(data->regmap, SX9500_REG_PROX_CTRL0, 0); 1010 1011 out: 1012 mutex_unlock(&data->mutex); 1013 return ret; 1014 } 1015 1016 static int sx9500_resume(struct device *dev) 1017 { 1018 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); 1019 struct sx9500_data *data = iio_priv(indio_dev); 1020 int ret; 1021 1022 mutex_lock(&data->mutex); 1023 ret = regmap_write(data->regmap, SX9500_REG_PROX_CTRL0, 1024 data->suspend_ctrl0); 1025 mutex_unlock(&data->mutex); 1026 1027 return ret; 1028 } 1029 1030 static DEFINE_SIMPLE_DEV_PM_OPS(sx9500_pm_ops, sx9500_suspend, sx9500_resume); 1031 1032 static const struct acpi_device_id sx9500_acpi_match[] = { 1033 {"SSX9500", 0}, 1034 {"SASX9500", 0}, 1035 { }, 1036 }; 1037 MODULE_DEVICE_TABLE(acpi, sx9500_acpi_match); 1038 1039 static const struct of_device_id sx9500_of_match[] = { 1040 { .compatible = "semtech,sx9500", }, 1041 { } 1042 }; 1043 MODULE_DEVICE_TABLE(of, sx9500_of_match); 1044 1045 static const struct i2c_device_id sx9500_id[] = { 1046 {"sx9500", 0}, 1047 { }, 1048 }; 1049 MODULE_DEVICE_TABLE(i2c, sx9500_id); 1050 1051 static struct i2c_driver sx9500_driver = { 1052 .driver = { 1053 .name = SX9500_DRIVER_NAME, 1054 .acpi_match_table = ACPI_PTR(sx9500_acpi_match), 1055 .of_match_table = of_match_ptr(sx9500_of_match), 1056 .pm = pm_sleep_ptr(&sx9500_pm_ops), 1057 }, 1058 .probe_new = sx9500_probe, 1059 .remove = sx9500_remove, 1060 .id_table = sx9500_id, 1061 }; 1062 module_i2c_driver(sx9500_driver); 1063 1064 MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>"); 1065 MODULE_DESCRIPTION("Driver for Semtech SX9500 proximity sensor"); 1066 MODULE_LICENSE("GPL v2"); 1067