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