1066 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * Copyright (c) 2014 Intel Corporation4 *5 * Driver for Semtech's SX9500 capacitive proximity/button solution.6 * Datasheet available at7 * <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 0x0034#define SX9500_REG_STAT 0x0135#define SX9500_REG_IRQ_MSK 0x0336 37#define SX9500_REG_PROX_CTRL0 0x0638#define SX9500_REG_PROX_CTRL1 0x0739#define SX9500_REG_PROX_CTRL2 0x0840#define SX9500_REG_PROX_CTRL3 0x0941#define SX9500_REG_PROX_CTRL4 0x0a42#define SX9500_REG_PROX_CTRL5 0x0b43#define SX9500_REG_PROX_CTRL6 0x0c44#define SX9500_REG_PROX_CTRL7 0x0d45#define SX9500_REG_PROX_CTRL8 0x0e46 47#define SX9500_REG_SENSOR_SEL 0x2048#define SX9500_REG_USE_MSB 0x2149#define SX9500_REG_USE_LSB 0x2250#define SX9500_REG_AVG_MSB 0x2351#define SX9500_REG_AVG_LSB 0x2452#define SX9500_REG_DIFF_MSB 0x2553#define SX9500_REG_DIFF_LSB 0x2654#define SX9500_REG_OFFSET_MSB 0x2755#define SX9500_REG_OFFSET_LSB 0x2856 57#define SX9500_REG_RESET 0x7f58 59/* Write this to REG_RESET to do a soft reset. */60#define SX9500_SOFT_RESET 0xde61 62#define SX9500_SCAN_PERIOD_MASK GENMASK(6, 4)63#define SX9500_SCAN_PERIOD_SHIFT 464 65/*66 * These serve for identifying IRQ source in the IRQ_SRC register, and67 * 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 474#define SX9500_COMPSTAT_MASK GENMASK(3, 0)75 76#define SX9500_NUM_CHANNELS 477#define SX9500_CHAN_MASK GENMASK(SX9500_NUM_CHANNELS - 1, 0)78 79struct 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. We87 * 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 100static 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 126static 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 134static 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 148static const unsigned int sx9500_scan_period_table[] = {149 30, 60, 90, 120, 150, 200, 300, 400,150};151 152static 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 160static 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 unallocated167 * ones.168 */169static 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 176static 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 181static 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 187static 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 192static 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 204static 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 215static 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 226static 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 232static 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 238static 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 244static 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 250static 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 257static 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 264static 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 period286 * after enabling a channel to get a result.287 */288static 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 304static 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 else325 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 348out_dec_data_rdy:349 sx9500_dec_data_rdy_users(data);350out_dec_chan:351 sx9500_dec_chan_users(data, chan->channel);352out:353 mutex_unlock(&data->mutex);354 reinit_completion(&data->completion);355 356 return ret;357}358 359static 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 379static 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 406static 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 430static 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 449static 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 to459 * clear the interrupt state by reading SX9500_REG_IRQ_SRC. It460 * is not possible to do that here because regmap_read takes a461 * mutex.462 */463 return IRQ_WAKE_THREAD;464}465 466static 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 498static 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 519out:520 mutex_unlock(&data->mutex);521 522 return IRQ_HANDLED;523}524 525static 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 539static int sx9500_write_event_config(struct iio_dev *indio_dev,540 const struct iio_chan_spec *chan,541 enum iio_event_type type,542 enum iio_event_direction dir,543 int state)544{545 struct sx9500_data *data = iio_priv(indio_dev);546 int ret;547 548 if (chan->type != IIO_PROXIMITY || type != IIO_EV_TYPE_THRESH ||549 dir != IIO_EV_DIR_EITHER)550 return -EINVAL;551 552 mutex_lock(&data->mutex);553 554 if (state == 1) {555 ret = sx9500_inc_chan_users(data, chan->channel);556 if (ret < 0)557 goto out_unlock;558 ret = sx9500_inc_close_far_users(data);559 if (ret < 0)560 goto out_undo_chan;561 } else {562 ret = sx9500_dec_chan_users(data, chan->channel);563 if (ret < 0)564 goto out_unlock;565 ret = sx9500_dec_close_far_users(data);566 if (ret < 0)567 goto out_undo_chan;568 }569 570 data->event_enabled[chan->channel] = state;571 goto out_unlock;572 573out_undo_chan:574 if (state == 1)575 sx9500_dec_chan_users(data, chan->channel);576 else577 sx9500_inc_chan_users(data, chan->channel);578out_unlock:579 mutex_unlock(&data->mutex);580 return ret;581}582 583static 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 599static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(600 "2.500000 3.333333 5 6.666666 8.333333 11.111111 16.666666 33.333333");601 602static struct attribute *sx9500_attributes[] = {603 &iio_const_attr_sampling_frequency_available.dev_attr.attr,604 NULL,605};606 607static const struct attribute_group sx9500_attribute_group = {608 .attrs = sx9500_attributes,609};610 611static 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 620static 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 else632 ret = sx9500_dec_data_rdy_users(data);633 if (ret < 0)634 goto out;635 636 data->trigger_enabled = state;637 638out:639 mutex_unlock(&data->mutex);640 641 return ret;642}643 644static const struct iio_trigger_ops sx9500_trigger_ops = {645 .set_trigger_state = sx9500_set_trigger_state,646};647 648static 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 669out:670 mutex_unlock(&data->mutex);671 672 iio_trigger_notify_done(indio_dev->trig);673 674 return IRQ_HANDLED;675}676 677static 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 701static 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 725static const struct iio_buffer_setup_ops sx9500_buffer_setup_ops = {726 .postenable = sx9500_buffer_postenable,727 .predisable = sx9500_buffer_predisable,728};729 730struct sx9500_reg_default {731 u8 reg;732 u8 def;733};734 735static 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 pin773 * independently, proximity hysteresis: 32, close774 * 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. */791static 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 816out:817 regmap_clear_bits(data->regmap, SX9500_REG_PROX_CTRL0,818 SX9500_CHAN_MASK);819 return ret;820}821 822static 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 859static const struct acpi_gpio_params reset_gpios = { 0, 0, false };860static const struct acpi_gpio_params interrupt_gpios = { 2, 0, false };861 862static 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 IRQ866 * 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 872static 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 else893 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 903static 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 971out_buffer_cleanup:972 iio_triggered_buffer_cleanup(indio_dev);973out_trigger_unregister:974 if (client->irq > 0)975 iio_trigger_unregister(data->trig);976 977 return ret;978}979 980static 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 992static 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 are1006 * deactivated the device is in sleep mode.1007 */1008 ret = regmap_write(data->regmap, SX9500_REG_PROX_CTRL0, 0);1009 1010out:1011 mutex_unlock(&data->mutex);1012 return ret;1013}1014 1015static 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 1029static DEFINE_SIMPLE_DEV_PM_OPS(sx9500_pm_ops, sx9500_suspend, sx9500_resume);1030 1031static const struct acpi_device_id sx9500_acpi_match[] = {1032 {"SSX9500", 0},1033 {"SASX9500", 0},1034 { },1035};1036MODULE_DEVICE_TABLE(acpi, sx9500_acpi_match);1037 1038static const struct of_device_id sx9500_of_match[] = {1039 { .compatible = "semtech,sx9500", },1040 { }1041};1042MODULE_DEVICE_TABLE(of, sx9500_of_match);1043 1044static const struct i2c_device_id sx9500_id[] = {1045 { "sx9500" },1046 { }1047};1048MODULE_DEVICE_TABLE(i2c, sx9500_id);1049 1050static 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};1061module_i2c_driver(sx9500_driver);1062 1063MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>");1064MODULE_DESCRIPTION("Driver for Semtech SX9500 proximity sensor");1065MODULE_LICENSE("GPL v2");1066