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