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