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