1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright 2018 Google LLC.
5 * Driver for Semtech's SX9310/SX9311 capacitive proximity/button solution.
6 * Based on SX9500 driver and Semtech driver using the input framework
7 * <https://my.syncplicity.com/share/teouwsim8niiaud/
8 * linux-driver-SX9310_NoSmartHSensing>.
9 * Reworked in April 2019 by Evan Green <evgreen@chromium.org>
10 * and in January 2020 by Daniel Campello <campello@chromium.org>.
13 #include <linux/acpi.h>
14 #include <linux/bitfield.h>
15 #include <linux/delay.h>
16 #include <linux/i2c.h>
17 #include <linux/irq.h>
18 #include <linux/kernel.h>
19 #include <linux/log2.h>
20 #include <linux/mod_devicetable.h>
21 #include <linux/module.h>
23 #include <linux/property.h>
24 #include <linux/regmap.h>
25 #include <linux/regulator/consumer.h>
26 #include <linux/slab.h>
28 #include <linux/iio/buffer.h>
29 #include <linux/iio/events.h>
30 #include <linux/iio/iio.h>
31 #include <linux/iio/sysfs.h>
32 #include <linux/iio/trigger.h>
33 #include <linux/iio/triggered_buffer.h>
34 #include <linux/iio/trigger_consumer.h>
36 /* Register definitions. */
37 #define SX9310_REG_IRQ_SRC 0x00
38 #define SX9310_REG_STAT0 0x01
39 #define SX9310_REG_STAT1 0x02
40 #define SX9310_REG_STAT1_COMPSTAT_MASK GENMASK(3, 0)
41 #define SX9310_REG_IRQ_MSK 0x03
42 #define SX9310_CONVDONE_IRQ BIT(3)
43 #define SX9310_FAR_IRQ BIT(5)
44 #define SX9310_CLOSE_IRQ BIT(6)
45 #define SX9310_REG_IRQ_FUNC 0x04
47 #define SX9310_REG_PROX_CTRL0 0x10
48 #define SX9310_REG_PROX_CTRL0_SENSOREN_MASK GENMASK(3, 0)
49 #define SX9310_REG_PROX_CTRL0_SCANPERIOD_MASK GENMASK(7, 4)
50 #define SX9310_REG_PROX_CTRL0_SCANPERIOD_15MS 0x01
51 #define SX9310_REG_PROX_CTRL1 0x11
52 #define SX9310_REG_PROX_CTRL2 0x12
53 #define SX9310_REG_PROX_CTRL2_COMBMODE_MASK GENMASK(7, 6)
54 #define SX9310_REG_PROX_CTRL2_COMBMODE_CS0_CS1_CS2_CS3 (0x03 << 6)
55 #define SX9310_REG_PROX_CTRL2_COMBMODE_CS1_CS2 (0x02 << 6)
56 #define SX9310_REG_PROX_CTRL2_COMBMODE_CS0_CS1 (0x01 << 6)
57 #define SX9310_REG_PROX_CTRL2_COMBMODE_CS3 (0x00 << 6)
58 #define SX9310_REG_PROX_CTRL2_SHIELDEN_MASK GENMASK(3, 2)
59 #define SX9310_REG_PROX_CTRL2_SHIELDEN_DYNAMIC (0x01 << 2)
60 #define SX9310_REG_PROX_CTRL2_SHIELDEN_GROUND (0x02 << 2)
61 #define SX9310_REG_PROX_CTRL3 0x13
62 #define SX9310_REG_PROX_CTRL3_GAIN0_MASK GENMASK(3, 2)
63 #define SX9310_REG_PROX_CTRL3_GAIN0_X8 (0x03 << 2)
64 #define SX9310_REG_PROX_CTRL3_GAIN12_MASK GENMASK(1, 0)
65 #define SX9310_REG_PROX_CTRL3_GAIN12_X4 0x02
66 #define SX9310_REG_PROX_CTRL4 0x14
67 #define SX9310_REG_PROX_CTRL4_RESOLUTION_MASK GENMASK(2, 0)
68 #define SX9310_REG_PROX_CTRL4_RESOLUTION_FINEST 0x07
69 #define SX9310_REG_PROX_CTRL4_RESOLUTION_VERY_FINE 0x06
70 #define SX9310_REG_PROX_CTRL4_RESOLUTION_FINE 0x05
71 #define SX9310_REG_PROX_CTRL4_RESOLUTION_MEDIUM 0x04
72 #define SX9310_REG_PROX_CTRL4_RESOLUTION_MEDIUM_COARSE 0x03
73 #define SX9310_REG_PROX_CTRL4_RESOLUTION_COARSE 0x02
74 #define SX9310_REG_PROX_CTRL4_RESOLUTION_VERY_COARSE 0x01
75 #define SX9310_REG_PROX_CTRL4_RESOLUTION_COARSEST 0x00
76 #define SX9310_REG_PROX_CTRL5 0x15
77 #define SX9310_REG_PROX_CTRL5_RANGE_SMALL (0x03 << 6)
78 #define SX9310_REG_PROX_CTRL5_STARTUPSENS_MASK GENMASK(3, 2)
79 #define SX9310_REG_PROX_CTRL5_STARTUPSENS_CS1 (0x01 << 2)
80 #define SX9310_REG_PROX_CTRL5_RAWFILT_MASK GENMASK(1, 0)
81 #define SX9310_REG_PROX_CTRL5_RAWFILT_SHIFT 0
82 #define SX9310_REG_PROX_CTRL5_RAWFILT_1P25 0x02
83 #define SX9310_REG_PROX_CTRL6 0x16
84 #define SX9310_REG_PROX_CTRL6_AVGTHRESH_DEFAULT 0x20
85 #define SX9310_REG_PROX_CTRL7 0x17
86 #define SX9310_REG_PROX_CTRL7_AVGNEGFILT_2 (0x01 << 3)
87 #define SX9310_REG_PROX_CTRL7_AVGPOSFILT_MASK GENMASK(2, 0)
88 #define SX9310_REG_PROX_CTRL7_AVGPOSFILT_SHIFT 0
89 #define SX9310_REG_PROX_CTRL7_AVGPOSFILT_512 0x05
90 #define SX9310_REG_PROX_CTRL8 0x18
91 #define SX9310_REG_PROX_CTRL8_9_PTHRESH_MASK GENMASK(7, 3)
92 #define SX9310_REG_PROX_CTRL9 0x19
93 #define SX9310_REG_PROX_CTRL8_9_PTHRESH_28 (0x08 << 3)
94 #define SX9310_REG_PROX_CTRL8_9_PTHRESH_96 (0x11 << 3)
95 #define SX9310_REG_PROX_CTRL8_9_BODYTHRESH_900 0x03
96 #define SX9310_REG_PROX_CTRL8_9_BODYTHRESH_1500 0x05
97 #define SX9310_REG_PROX_CTRL10 0x1a
98 #define SX9310_REG_PROX_CTRL10_HYST_MASK GENMASK(5, 4)
99 #define SX9310_REG_PROX_CTRL10_HYST_6PCT (0x01 << 4)
100 #define SX9310_REG_PROX_CTRL10_CLOSE_DEBOUNCE_MASK GENMASK(3, 2)
101 #define SX9310_REG_PROX_CTRL10_FAR_DEBOUNCE_MASK GENMASK(1, 0)
102 #define SX9310_REG_PROX_CTRL10_FAR_DEBOUNCE_2 0x01
103 #define SX9310_REG_PROX_CTRL11 0x1b
104 #define SX9310_REG_PROX_CTRL12 0x1c
105 #define SX9310_REG_PROX_CTRL13 0x1d
106 #define SX9310_REG_PROX_CTRL14 0x1e
107 #define SX9310_REG_PROX_CTRL15 0x1f
108 #define SX9310_REG_PROX_CTRL16 0x20
109 #define SX9310_REG_PROX_CTRL17 0x21
110 #define SX9310_REG_PROX_CTRL18 0x22
111 #define SX9310_REG_PROX_CTRL19 0x23
112 #define SX9310_REG_SAR_CTRL0 0x2a
113 #define SX9310_REG_SAR_CTRL0_SARDEB_4_SAMPLES (0x02 << 5)
114 #define SX9310_REG_SAR_CTRL0_SARHYST_8 (0x02 << 3)
115 #define SX9310_REG_SAR_CTRL1 0x2b
116 /* Each increment of the slope register is 0.0078125. */
117 #define SX9310_REG_SAR_CTRL1_SLOPE(_hnslope) (_hnslope / 78125)
118 #define SX9310_REG_SAR_CTRL2 0x2c
119 #define SX9310_REG_SAR_CTRL2_SAROFFSET_DEFAULT 0x3c
121 #define SX9310_REG_SENSOR_SEL 0x30
122 #define SX9310_REG_USE_MSB 0x31
123 #define SX9310_REG_USE_LSB 0x32
124 #define SX9310_REG_AVG_MSB 0x33
125 #define SX9310_REG_AVG_LSB 0x34
126 #define SX9310_REG_DIFF_MSB 0x35
127 #define SX9310_REG_DIFF_LSB 0x36
128 #define SX9310_REG_OFFSET_MSB 0x37
129 #define SX9310_REG_OFFSET_LSB 0x38
130 #define SX9310_REG_SAR_MSB 0x39
131 #define SX9310_REG_SAR_LSB 0x3a
132 #define SX9310_REG_I2C_ADDR 0x40
133 #define SX9310_REG_PAUSE 0x41
134 #define SX9310_REG_WHOAMI 0x42
135 #define SX9310_WHOAMI_VALUE 0x01
136 #define SX9311_WHOAMI_VALUE 0x02
137 #define SX9310_REG_RESET 0x7f
138 #define SX9310_SOFT_RESET 0xde
141 /* 4 hardware channels, as defined in STAT0: COMB, CS2, CS1 and CS0. */
142 #define SX9310_NUM_CHANNELS 4
143 static_assert(SX9310_NUM_CHANNELS < BITS_PER_LONG);
146 /* Serialize access to registers and channel configuration */
148 struct i2c_client *client;
149 struct iio_trigger *trig;
150 struct regmap *regmap;
151 struct regulator_bulk_data supplies[2];
153 * Last reading of the proximity status for each channel.
154 * We only send an event to user space when this changes.
156 unsigned long chan_prox_stat;
157 bool trigger_enabled;
158 /* Ensure correct alignment of timestamp when present. */
160 __be16 channels[SX9310_NUM_CHANNELS];
163 /* Remember enabled channels and sample rate during suspend. */
164 unsigned int suspend_ctrl0;
165 struct completion completion;
166 unsigned long chan_read;
167 unsigned long chan_event;
171 static const struct iio_event_spec sx9310_events[] = {
173 .type = IIO_EV_TYPE_THRESH,
174 .dir = IIO_EV_DIR_RISING,
175 .mask_shared_by_all = BIT(IIO_EV_INFO_PERIOD),
178 .type = IIO_EV_TYPE_THRESH,
179 .dir = IIO_EV_DIR_FALLING,
180 .mask_shared_by_all = BIT(IIO_EV_INFO_PERIOD),
183 .type = IIO_EV_TYPE_THRESH,
184 .dir = IIO_EV_DIR_EITHER,
185 .mask_separate = BIT(IIO_EV_INFO_ENABLE) |
186 BIT(IIO_EV_INFO_HYSTERESIS) |
187 BIT(IIO_EV_INFO_VALUE),
191 #define SX9310_NAMED_CHANNEL(idx, name) \
193 .type = IIO_PROXIMITY, \
194 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
195 BIT(IIO_CHAN_INFO_HARDWAREGAIN), \
196 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
197 .info_mask_separate_available = \
198 BIT(IIO_CHAN_INFO_HARDWAREGAIN), \
201 .extend_name = name, \
202 .address = SX9310_REG_DIFF_MSB, \
203 .event_spec = sx9310_events, \
204 .num_event_specs = ARRAY_SIZE(sx9310_events), \
210 .endianness = IIO_BE, \
213 #define SX9310_CHANNEL(idx) SX9310_NAMED_CHANNEL(idx, NULL)
215 static const struct iio_chan_spec sx9310_channels[] = {
216 SX9310_CHANNEL(0), /* CS0 */
217 SX9310_CHANNEL(1), /* CS1 */
218 SX9310_CHANNEL(2), /* CS2 */
219 SX9310_NAMED_CHANNEL(3, "comb"), /* COMB */
221 IIO_CHAN_SOFT_TIMESTAMP(4),
225 * Each entry contains the integer part (val) and the fractional part, in micro
226 * seconds. It conforms to the IIO output IIO_VAL_INT_PLUS_MICRO.
228 static const struct {
231 } sx9310_samp_freq_table[] = {
232 { 500, 0 }, /* 0000: Min (no idle time) */
233 { 66, 666666 }, /* 0001: 15 ms */
234 { 33, 333333 }, /* 0010: 30 ms (Typ.) */
235 { 22, 222222 }, /* 0011: 45 ms */
236 { 16, 666666 }, /* 0100: 60 ms */
237 { 11, 111111 }, /* 0101: 90 ms */
238 { 8, 333333 }, /* 0110: 120 ms */
239 { 5, 0 }, /* 0111: 200 ms */
240 { 2, 500000 }, /* 1000: 400 ms */
241 { 1, 666666 }, /* 1001: 600 ms */
242 { 1, 250000 }, /* 1010: 800 ms */
243 { 1, 0 }, /* 1011: 1 s */
244 { 0, 500000 }, /* 1100: 2 s */
245 { 0, 333333 }, /* 1101: 3 s */
246 { 0, 250000 }, /* 1110: 4 s */
247 { 0, 200000 }, /* 1111: 5 s */
249 static const unsigned int sx9310_scan_period_table[] = {
250 2, 15, 30, 45, 60, 90, 120, 200,
251 400, 600, 800, 1000, 2000, 3000, 4000, 5000,
254 static ssize_t sx9310_show_samp_freq_avail(struct device *dev,
255 struct device_attribute *attr,
261 for (i = 0; i < ARRAY_SIZE(sx9310_samp_freq_table); i++)
262 len += scnprintf(buf + len, PAGE_SIZE - len, "%d.%d ",
263 sx9310_samp_freq_table[i].val,
264 sx9310_samp_freq_table[i].val2);
268 static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(sx9310_show_samp_freq_avail);
270 static const struct regmap_range sx9310_writable_reg_ranges[] = {
271 regmap_reg_range(SX9310_REG_IRQ_MSK, SX9310_REG_IRQ_FUNC),
272 regmap_reg_range(SX9310_REG_PROX_CTRL0, SX9310_REG_PROX_CTRL19),
273 regmap_reg_range(SX9310_REG_SAR_CTRL0, SX9310_REG_SAR_CTRL2),
274 regmap_reg_range(SX9310_REG_SENSOR_SEL, SX9310_REG_SENSOR_SEL),
275 regmap_reg_range(SX9310_REG_OFFSET_MSB, SX9310_REG_OFFSET_LSB),
276 regmap_reg_range(SX9310_REG_PAUSE, SX9310_REG_PAUSE),
277 regmap_reg_range(SX9310_REG_RESET, SX9310_REG_RESET),
280 static const struct regmap_access_table sx9310_writeable_regs = {
281 .yes_ranges = sx9310_writable_reg_ranges,
282 .n_yes_ranges = ARRAY_SIZE(sx9310_writable_reg_ranges),
285 static const struct regmap_range sx9310_readable_reg_ranges[] = {
286 regmap_reg_range(SX9310_REG_IRQ_SRC, SX9310_REG_IRQ_FUNC),
287 regmap_reg_range(SX9310_REG_PROX_CTRL0, SX9310_REG_PROX_CTRL19),
288 regmap_reg_range(SX9310_REG_SAR_CTRL0, SX9310_REG_SAR_CTRL2),
289 regmap_reg_range(SX9310_REG_SENSOR_SEL, SX9310_REG_SAR_LSB),
290 regmap_reg_range(SX9310_REG_I2C_ADDR, SX9310_REG_WHOAMI),
291 regmap_reg_range(SX9310_REG_RESET, SX9310_REG_RESET),
294 static const struct regmap_access_table sx9310_readable_regs = {
295 .yes_ranges = sx9310_readable_reg_ranges,
296 .n_yes_ranges = ARRAY_SIZE(sx9310_readable_reg_ranges),
299 static const struct regmap_range sx9310_volatile_reg_ranges[] = {
300 regmap_reg_range(SX9310_REG_IRQ_SRC, SX9310_REG_STAT1),
301 regmap_reg_range(SX9310_REG_USE_MSB, SX9310_REG_DIFF_LSB),
302 regmap_reg_range(SX9310_REG_SAR_MSB, SX9310_REG_SAR_LSB),
303 regmap_reg_range(SX9310_REG_RESET, SX9310_REG_RESET),
306 static const struct regmap_access_table sx9310_volatile_regs = {
307 .yes_ranges = sx9310_volatile_reg_ranges,
308 .n_yes_ranges = ARRAY_SIZE(sx9310_volatile_reg_ranges),
311 static const struct regmap_config sx9310_regmap_config = {
315 .max_register = SX9310_REG_RESET,
316 .cache_type = REGCACHE_RBTREE,
318 .wr_table = &sx9310_writeable_regs,
319 .rd_table = &sx9310_readable_regs,
320 .volatile_table = &sx9310_volatile_regs,
323 static int sx9310_update_chan_en(struct sx9310_data *data,
324 unsigned long chan_read,
325 unsigned long chan_event)
328 unsigned long channels = chan_read | chan_event;
330 if ((data->chan_read | data->chan_event) != channels) {
331 ret = regmap_update_bits(data->regmap, SX9310_REG_PROX_CTRL0,
332 SX9310_REG_PROX_CTRL0_SENSOREN_MASK,
337 data->chan_read = chan_read;
338 data->chan_event = chan_event;
342 static int sx9310_get_read_channel(struct sx9310_data *data, int channel)
344 return sx9310_update_chan_en(data, data->chan_read | BIT(channel),
348 static int sx9310_put_read_channel(struct sx9310_data *data, int channel)
350 return sx9310_update_chan_en(data, data->chan_read & ~BIT(channel),
354 static int sx9310_get_event_channel(struct sx9310_data *data, int channel)
356 return sx9310_update_chan_en(data, data->chan_read,
357 data->chan_event | BIT(channel));
360 static int sx9310_put_event_channel(struct sx9310_data *data, int channel)
362 return sx9310_update_chan_en(data, data->chan_read,
363 data->chan_event & ~BIT(channel));
366 static int sx9310_enable_irq(struct sx9310_data *data, unsigned int irq)
368 if (!data->client->irq)
370 return regmap_update_bits(data->regmap, SX9310_REG_IRQ_MSK, irq, irq);
373 static int sx9310_disable_irq(struct sx9310_data *data, unsigned int irq)
375 if (!data->client->irq)
377 return regmap_update_bits(data->regmap, SX9310_REG_IRQ_MSK, irq, 0);
380 static int sx9310_read_prox_data(struct sx9310_data *data,
381 const struct iio_chan_spec *chan, __be16 *val)
385 ret = regmap_write(data->regmap, SX9310_REG_SENSOR_SEL, chan->channel);
389 return regmap_bulk_read(data->regmap, chan->address, val, sizeof(*val));
393 * If we have no interrupt support, we have to wait for a scan period
394 * after enabling a channel to get a result.
396 static int sx9310_wait_for_sample(struct sx9310_data *data)
401 ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL0, &val);
405 val = FIELD_GET(SX9310_REG_PROX_CTRL0_SCANPERIOD_MASK, val);
407 msleep(sx9310_scan_period_table[val]);
412 static int sx9310_read_proximity(struct sx9310_data *data,
413 const struct iio_chan_spec *chan, int *val)
418 mutex_lock(&data->mutex);
420 ret = sx9310_get_read_channel(data, chan->channel);
424 ret = sx9310_enable_irq(data, SX9310_CONVDONE_IRQ);
426 goto out_put_channel;
428 mutex_unlock(&data->mutex);
430 if (data->client->irq) {
431 ret = wait_for_completion_interruptible(&data->completion);
432 reinit_completion(&data->completion);
434 ret = sx9310_wait_for_sample(data);
437 mutex_lock(&data->mutex);
440 goto out_disable_irq;
442 ret = sx9310_read_prox_data(data, chan, &rawval);
444 goto out_disable_irq;
446 *val = sign_extend32(be16_to_cpu(rawval),
447 chan->address == SX9310_REG_DIFF_MSB ? 11 : 15);
449 ret = sx9310_disable_irq(data, SX9310_CONVDONE_IRQ);
451 goto out_put_channel;
453 ret = sx9310_put_read_channel(data, chan->channel);
457 mutex_unlock(&data->mutex);
462 sx9310_disable_irq(data, SX9310_CONVDONE_IRQ);
464 sx9310_put_read_channel(data, chan->channel);
466 mutex_unlock(&data->mutex);
471 static int sx9310_read_gain(struct sx9310_data *data,
472 const struct iio_chan_spec *chan, int *val)
474 unsigned int regval, gain;
477 ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL3, ®val);
481 switch (chan->channel) {
484 gain = FIELD_GET(SX9310_REG_PROX_CTRL3_GAIN0_MASK, regval);
488 gain = FIELD_GET(SX9310_REG_PROX_CTRL3_GAIN12_MASK, regval);
499 static int sx9310_read_samp_freq(struct sx9310_data *data, int *val, int *val2)
504 ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL0, ®val);
508 regval = FIELD_GET(SX9310_REG_PROX_CTRL0_SCANPERIOD_MASK, regval);
509 *val = sx9310_samp_freq_table[regval].val;
510 *val2 = sx9310_samp_freq_table[regval].val2;
512 return IIO_VAL_INT_PLUS_MICRO;
515 static int sx9310_read_raw(struct iio_dev *indio_dev,
516 const struct iio_chan_spec *chan, int *val,
517 int *val2, long mask)
519 struct sx9310_data *data = iio_priv(indio_dev);
522 if (chan->type != IIO_PROXIMITY)
526 case IIO_CHAN_INFO_RAW:
527 ret = iio_device_claim_direct_mode(indio_dev);
531 ret = sx9310_read_proximity(data, chan, val);
532 iio_device_release_direct_mode(indio_dev);
534 case IIO_CHAN_INFO_HARDWAREGAIN:
535 ret = iio_device_claim_direct_mode(indio_dev);
539 ret = sx9310_read_gain(data, chan, val);
540 iio_device_release_direct_mode(indio_dev);
542 case IIO_CHAN_INFO_SAMP_FREQ:
543 return sx9310_read_samp_freq(data, val, val2);
549 static const int sx9310_gain_vals[] = { 1, 2, 4, 8 };
551 static int sx9310_read_avail(struct iio_dev *indio_dev,
552 struct iio_chan_spec const *chan,
553 const int **vals, int *type, int *length,
556 if (chan->type != IIO_PROXIMITY)
560 case IIO_CHAN_INFO_HARDWAREGAIN:
562 *length = ARRAY_SIZE(sx9310_gain_vals);
563 *vals = sx9310_gain_vals;
564 return IIO_AVAIL_LIST;
570 static const unsigned int sx9310_pthresh_codes[] = {
571 2, 4, 6, 8, 12, 16, 20, 24, 28, 32, 40, 48, 56, 64, 72, 80, 88, 96, 112,
572 128, 144, 160, 192, 224, 256, 320, 384, 512, 640, 768, 1024, 1536
575 static int sx9310_get_thresh_reg(unsigned int channel)
580 return SX9310_REG_PROX_CTRL8;
583 return SX9310_REG_PROX_CTRL9;
589 static int sx9310_read_thresh(struct sx9310_data *data,
590 const struct iio_chan_spec *chan, int *val)
596 reg = ret = sx9310_get_thresh_reg(chan->channel);
600 ret = regmap_read(data->regmap, reg, ®val);
604 regval = FIELD_GET(SX9310_REG_PROX_CTRL8_9_PTHRESH_MASK, regval);
605 if (regval >= ARRAY_SIZE(sx9310_pthresh_codes))
608 *val = sx9310_pthresh_codes[regval];
612 static int sx9310_read_hysteresis(struct sx9310_data *data,
613 const struct iio_chan_spec *chan, int *val)
615 unsigned int regval, pthresh;
618 ret = sx9310_read_thresh(data, chan, &pthresh);
622 ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL10, ®val);
626 regval = FIELD_GET(SX9310_REG_PROX_CTRL10_HYST_MASK, regval);
630 /* regval is at most 5 */
631 *val = pthresh >> (5 - regval);
636 static int sx9310_read_far_debounce(struct sx9310_data *data, int *val)
641 ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL10, ®val);
645 regval = FIELD_GET(SX9310_REG_PROX_CTRL10_FAR_DEBOUNCE_MASK, regval);
654 static int sx9310_read_close_debounce(struct sx9310_data *data, int *val)
659 ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL10, ®val);
663 regval = FIELD_GET(SX9310_REG_PROX_CTRL10_CLOSE_DEBOUNCE_MASK, regval);
672 static int sx9310_read_event_val(struct iio_dev *indio_dev,
673 const struct iio_chan_spec *chan,
674 enum iio_event_type type,
675 enum iio_event_direction dir,
676 enum iio_event_info info, int *val, int *val2)
678 struct sx9310_data *data = iio_priv(indio_dev);
680 if (chan->type != IIO_PROXIMITY)
684 case IIO_EV_INFO_VALUE:
685 return sx9310_read_thresh(data, chan, val);
686 case IIO_EV_INFO_PERIOD:
688 case IIO_EV_DIR_RISING:
689 return sx9310_read_far_debounce(data, val);
690 case IIO_EV_DIR_FALLING:
691 return sx9310_read_close_debounce(data, val);
695 case IIO_EV_INFO_HYSTERESIS:
696 return sx9310_read_hysteresis(data, chan, val);
702 static int sx9310_write_thresh(struct sx9310_data *data,
703 const struct iio_chan_spec *chan, int val)
709 reg = ret = sx9310_get_thresh_reg(chan->channel);
713 for (i = 0; i < ARRAY_SIZE(sx9310_pthresh_codes); i++) {
714 if (sx9310_pthresh_codes[i] == val) {
720 if (i == ARRAY_SIZE(sx9310_pthresh_codes))
723 regval = FIELD_PREP(SX9310_REG_PROX_CTRL8_9_PTHRESH_MASK, regval);
724 mutex_lock(&data->mutex);
725 ret = regmap_update_bits(data->regmap, reg,
726 SX9310_REG_PROX_CTRL8_9_PTHRESH_MASK, regval);
727 mutex_unlock(&data->mutex);
732 static int sx9310_write_hysteresis(struct sx9310_data *data,
733 const struct iio_chan_spec *chan, int _val)
735 unsigned int hyst, val = _val;
738 ret = sx9310_read_thresh(data, chan, &pthresh);
744 else if (val == pthresh >> 2)
746 else if (val == pthresh >> 3)
748 else if (val == pthresh >> 4)
753 hyst = FIELD_PREP(SX9310_REG_PROX_CTRL10_HYST_MASK, hyst);
754 mutex_lock(&data->mutex);
755 ret = regmap_update_bits(data->regmap, SX9310_REG_PROX_CTRL10,
756 SX9310_REG_PROX_CTRL10_HYST_MASK, hyst);
757 mutex_unlock(&data->mutex);
762 static int sx9310_write_far_debounce(struct sx9310_data *data, int val)
769 if (!FIELD_FIT(SX9310_REG_PROX_CTRL10_FAR_DEBOUNCE_MASK, val))
772 regval = FIELD_PREP(SX9310_REG_PROX_CTRL10_FAR_DEBOUNCE_MASK, val);
774 mutex_lock(&data->mutex);
775 ret = regmap_update_bits(data->regmap, SX9310_REG_PROX_CTRL10,
776 SX9310_REG_PROX_CTRL10_FAR_DEBOUNCE_MASK,
778 mutex_unlock(&data->mutex);
783 static int sx9310_write_close_debounce(struct sx9310_data *data, int val)
790 if (!FIELD_FIT(SX9310_REG_PROX_CTRL10_CLOSE_DEBOUNCE_MASK, val))
793 regval = FIELD_PREP(SX9310_REG_PROX_CTRL10_CLOSE_DEBOUNCE_MASK, val);
795 mutex_lock(&data->mutex);
796 ret = regmap_update_bits(data->regmap, SX9310_REG_PROX_CTRL10,
797 SX9310_REG_PROX_CTRL10_CLOSE_DEBOUNCE_MASK,
799 mutex_unlock(&data->mutex);
804 static int sx9310_write_event_val(struct iio_dev *indio_dev,
805 const struct iio_chan_spec *chan,
806 enum iio_event_type type,
807 enum iio_event_direction dir,
808 enum iio_event_info info, int val, int val2)
810 struct sx9310_data *data = iio_priv(indio_dev);
812 if (chan->type != IIO_PROXIMITY)
816 case IIO_EV_INFO_VALUE:
817 return sx9310_write_thresh(data, chan, val);
818 case IIO_EV_INFO_PERIOD:
820 case IIO_EV_DIR_RISING:
821 return sx9310_write_far_debounce(data, val);
822 case IIO_EV_DIR_FALLING:
823 return sx9310_write_close_debounce(data, val);
827 case IIO_EV_INFO_HYSTERESIS:
828 return sx9310_write_hysteresis(data, chan, val);
834 static int sx9310_set_samp_freq(struct sx9310_data *data, int val, int val2)
838 for (i = 0; i < ARRAY_SIZE(sx9310_samp_freq_table); i++)
839 if (val == sx9310_samp_freq_table[i].val &&
840 val2 == sx9310_samp_freq_table[i].val2)
843 if (i == ARRAY_SIZE(sx9310_samp_freq_table))
846 mutex_lock(&data->mutex);
848 ret = regmap_update_bits(
849 data->regmap, SX9310_REG_PROX_CTRL0,
850 SX9310_REG_PROX_CTRL0_SCANPERIOD_MASK,
851 FIELD_PREP(SX9310_REG_PROX_CTRL0_SCANPERIOD_MASK, i));
853 mutex_unlock(&data->mutex);
858 static int sx9310_write_gain(struct sx9310_data *data,
859 const struct iio_chan_spec *chan, int val)
861 unsigned int gain, mask;
866 switch (chan->channel) {
869 mask = SX9310_REG_PROX_CTRL3_GAIN0_MASK;
870 gain = FIELD_PREP(SX9310_REG_PROX_CTRL3_GAIN0_MASK, gain);
874 mask = SX9310_REG_PROX_CTRL3_GAIN12_MASK;
875 gain = FIELD_PREP(SX9310_REG_PROX_CTRL3_GAIN12_MASK, gain);
881 mutex_lock(&data->mutex);
882 ret = regmap_update_bits(data->regmap, SX9310_REG_PROX_CTRL3, mask,
884 mutex_unlock(&data->mutex);
889 static int sx9310_write_raw(struct iio_dev *indio_dev,
890 const struct iio_chan_spec *chan, int val, int val2,
893 struct sx9310_data *data = iio_priv(indio_dev);
895 if (chan->type != IIO_PROXIMITY)
899 case IIO_CHAN_INFO_SAMP_FREQ:
900 return sx9310_set_samp_freq(data, val, val2);
901 case IIO_CHAN_INFO_HARDWAREGAIN:
902 return sx9310_write_gain(data, chan, val);
908 static irqreturn_t sx9310_irq_handler(int irq, void *private)
910 struct iio_dev *indio_dev = private;
911 struct sx9310_data *data = iio_priv(indio_dev);
913 if (data->trigger_enabled)
914 iio_trigger_poll(data->trig);
917 * Even if no event is enabled, we need to wake the thread to clear the
918 * interrupt state by reading SX9310_REG_IRQ_SRC.
919 * It is not possible to do that here because regmap_read takes a mutex.
921 return IRQ_WAKE_THREAD;
924 static void sx9310_push_events(struct iio_dev *indio_dev)
927 unsigned int val, chan;
928 struct sx9310_data *data = iio_priv(indio_dev);
929 s64 timestamp = iio_get_time_ns(indio_dev);
930 unsigned long prox_changed;
932 /* Read proximity state on all channels */
933 ret = regmap_read(data->regmap, SX9310_REG_STAT0, &val);
935 dev_err(&data->client->dev, "i2c transfer error in irq\n");
940 * Only iterate over channels with changes on proximity status that have
943 prox_changed = (data->chan_prox_stat ^ val) & data->chan_event;
945 for_each_set_bit(chan, &prox_changed, SX9310_NUM_CHANNELS) {
949 dir = (val & BIT(chan)) ? IIO_EV_DIR_FALLING : IIO_EV_DIR_RISING;
950 ev = IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, chan,
951 IIO_EV_TYPE_THRESH, dir);
953 iio_push_event(indio_dev, ev, timestamp);
955 data->chan_prox_stat = val;
958 static irqreturn_t sx9310_irq_thread_handler(int irq, void *private)
960 struct iio_dev *indio_dev = private;
961 struct sx9310_data *data = iio_priv(indio_dev);
965 mutex_lock(&data->mutex);
967 ret = regmap_read(data->regmap, SX9310_REG_IRQ_SRC, &val);
969 dev_err(&data->client->dev, "i2c transfer error in irq\n");
973 if (val & (SX9310_FAR_IRQ | SX9310_CLOSE_IRQ))
974 sx9310_push_events(indio_dev);
976 if (val & SX9310_CONVDONE_IRQ)
977 complete(&data->completion);
980 mutex_unlock(&data->mutex);
985 static int sx9310_read_event_config(struct iio_dev *indio_dev,
986 const struct iio_chan_spec *chan,
987 enum iio_event_type type,
988 enum iio_event_direction dir)
990 struct sx9310_data *data = iio_priv(indio_dev);
992 return !!(data->chan_event & BIT(chan->channel));
995 static int sx9310_write_event_config(struct iio_dev *indio_dev,
996 const struct iio_chan_spec *chan,
997 enum iio_event_type type,
998 enum iio_event_direction dir, int state)
1000 struct sx9310_data *data = iio_priv(indio_dev);
1001 unsigned int eventirq = SX9310_FAR_IRQ | SX9310_CLOSE_IRQ;
1004 /* If the state hasn't changed, there's nothing to do. */
1005 if (!!(data->chan_event & BIT(chan->channel)) == state)
1008 mutex_lock(&data->mutex);
1010 ret = sx9310_get_event_channel(data, chan->channel);
1013 if (!(data->chan_event & ~BIT(chan->channel))) {
1014 ret = sx9310_enable_irq(data, eventirq);
1016 sx9310_put_event_channel(data, chan->channel);
1019 ret = sx9310_put_event_channel(data, chan->channel);
1022 if (!data->chan_event) {
1023 ret = sx9310_disable_irq(data, eventirq);
1025 sx9310_get_event_channel(data, chan->channel);
1030 mutex_unlock(&data->mutex);
1034 static struct attribute *sx9310_attributes[] = {
1035 &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
1039 static const struct attribute_group sx9310_attribute_group = {
1040 .attrs = sx9310_attributes,
1043 static const struct iio_info sx9310_info = {
1044 .attrs = &sx9310_attribute_group,
1045 .read_raw = sx9310_read_raw,
1046 .read_avail = sx9310_read_avail,
1047 .read_event_value = sx9310_read_event_val,
1048 .write_event_value = sx9310_write_event_val,
1049 .write_raw = sx9310_write_raw,
1050 .read_event_config = sx9310_read_event_config,
1051 .write_event_config = sx9310_write_event_config,
1054 static int sx9310_set_trigger_state(struct iio_trigger *trig, bool state)
1056 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
1057 struct sx9310_data *data = iio_priv(indio_dev);
1060 mutex_lock(&data->mutex);
1063 ret = sx9310_enable_irq(data, SX9310_CONVDONE_IRQ);
1064 else if (!data->chan_read)
1065 ret = sx9310_disable_irq(data, SX9310_CONVDONE_IRQ);
1069 data->trigger_enabled = state;
1072 mutex_unlock(&data->mutex);
1077 static const struct iio_trigger_ops sx9310_trigger_ops = {
1078 .set_trigger_state = sx9310_set_trigger_state,
1081 static irqreturn_t sx9310_trigger_handler(int irq, void *private)
1083 struct iio_poll_func *pf = private;
1084 struct iio_dev *indio_dev = pf->indio_dev;
1085 struct sx9310_data *data = iio_priv(indio_dev);
1087 int bit, ret, i = 0;
1089 mutex_lock(&data->mutex);
1091 for_each_set_bit(bit, indio_dev->active_scan_mask,
1092 indio_dev->masklength) {
1093 ret = sx9310_read_prox_data(data, &indio_dev->channels[bit],
1098 data->buffer.channels[i++] = val;
1101 iio_push_to_buffers_with_timestamp(indio_dev, &data->buffer,
1105 mutex_unlock(&data->mutex);
1107 iio_trigger_notify_done(indio_dev->trig);
1112 static int sx9310_buffer_preenable(struct iio_dev *indio_dev)
1114 struct sx9310_data *data = iio_priv(indio_dev);
1115 unsigned long channels = 0;
1118 mutex_lock(&data->mutex);
1119 for_each_set_bit(bit, indio_dev->active_scan_mask,
1120 indio_dev->masklength)
1121 __set_bit(indio_dev->channels[bit].channel, &channels);
1123 ret = sx9310_update_chan_en(data, channels, data->chan_event);
1124 mutex_unlock(&data->mutex);
1128 static int sx9310_buffer_postdisable(struct iio_dev *indio_dev)
1130 struct sx9310_data *data = iio_priv(indio_dev);
1133 mutex_lock(&data->mutex);
1134 ret = sx9310_update_chan_en(data, 0, data->chan_event);
1135 mutex_unlock(&data->mutex);
1139 static const struct iio_buffer_setup_ops sx9310_buffer_setup_ops = {
1140 .preenable = sx9310_buffer_preenable,
1141 .postdisable = sx9310_buffer_postdisable,
1144 struct sx9310_reg_default {
1149 static const struct sx9310_reg_default sx9310_default_regs[] = {
1150 { SX9310_REG_IRQ_MSK, 0x00 },
1151 { SX9310_REG_IRQ_FUNC, 0x00 },
1153 * The lower 4 bits should not be set as it enable sensors measurements.
1154 * Turning the detection on before the configuration values are set to
1155 * good values can cause the device to return erroneous readings.
1157 { SX9310_REG_PROX_CTRL0, SX9310_REG_PROX_CTRL0_SCANPERIOD_15MS },
1158 { SX9310_REG_PROX_CTRL1, 0x00 },
1159 { SX9310_REG_PROX_CTRL2, SX9310_REG_PROX_CTRL2_COMBMODE_CS1_CS2 |
1160 SX9310_REG_PROX_CTRL2_SHIELDEN_DYNAMIC },
1161 { SX9310_REG_PROX_CTRL3, SX9310_REG_PROX_CTRL3_GAIN0_X8 |
1162 SX9310_REG_PROX_CTRL3_GAIN12_X4 },
1163 { SX9310_REG_PROX_CTRL4, SX9310_REG_PROX_CTRL4_RESOLUTION_FINEST },
1164 { SX9310_REG_PROX_CTRL5, SX9310_REG_PROX_CTRL5_RANGE_SMALL |
1165 SX9310_REG_PROX_CTRL5_STARTUPSENS_CS1 |
1166 SX9310_REG_PROX_CTRL5_RAWFILT_1P25 },
1167 { SX9310_REG_PROX_CTRL6, SX9310_REG_PROX_CTRL6_AVGTHRESH_DEFAULT },
1168 { SX9310_REG_PROX_CTRL7, SX9310_REG_PROX_CTRL7_AVGNEGFILT_2 |
1169 SX9310_REG_PROX_CTRL7_AVGPOSFILT_512 },
1170 { SX9310_REG_PROX_CTRL8, SX9310_REG_PROX_CTRL8_9_PTHRESH_96 |
1171 SX9310_REG_PROX_CTRL8_9_BODYTHRESH_1500 },
1172 { SX9310_REG_PROX_CTRL9, SX9310_REG_PROX_CTRL8_9_PTHRESH_28 |
1173 SX9310_REG_PROX_CTRL8_9_BODYTHRESH_900 },
1174 { SX9310_REG_PROX_CTRL10, SX9310_REG_PROX_CTRL10_HYST_6PCT |
1175 SX9310_REG_PROX_CTRL10_FAR_DEBOUNCE_2 },
1176 { SX9310_REG_PROX_CTRL11, 0x00 },
1177 { SX9310_REG_PROX_CTRL12, 0x00 },
1178 { SX9310_REG_PROX_CTRL13, 0x00 },
1179 { SX9310_REG_PROX_CTRL14, 0x00 },
1180 { SX9310_REG_PROX_CTRL15, 0x00 },
1181 { SX9310_REG_PROX_CTRL16, 0x00 },
1182 { SX9310_REG_PROX_CTRL17, 0x00 },
1183 { SX9310_REG_PROX_CTRL18, 0x00 },
1184 { SX9310_REG_PROX_CTRL19, 0x00 },
1185 { SX9310_REG_SAR_CTRL0, SX9310_REG_SAR_CTRL0_SARDEB_4_SAMPLES |
1186 SX9310_REG_SAR_CTRL0_SARHYST_8 },
1187 { SX9310_REG_SAR_CTRL1, SX9310_REG_SAR_CTRL1_SLOPE(10781250) },
1188 { SX9310_REG_SAR_CTRL2, SX9310_REG_SAR_CTRL2_SAROFFSET_DEFAULT },
1191 /* Activate all channels and perform an initial compensation. */
1192 static int sx9310_init_compensation(struct iio_dev *indio_dev)
1194 struct sx9310_data *data = iio_priv(indio_dev);
1199 ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL0, &ctrl0);
1203 /* run the compensation phase on all channels */
1204 ret = regmap_write(data->regmap, SX9310_REG_PROX_CTRL0,
1205 ctrl0 | SX9310_REG_PROX_CTRL0_SENSOREN_MASK);
1209 ret = regmap_read_poll_timeout(data->regmap, SX9310_REG_STAT1, val,
1210 !(val & SX9310_REG_STAT1_COMPSTAT_MASK),
1213 if (ret == -ETIMEDOUT)
1214 dev_err(&data->client->dev,
1215 "initial compensation timed out: 0x%02x\n",
1220 regmap_write(data->regmap, SX9310_REG_PROX_CTRL0, ctrl0);
1224 static const struct sx9310_reg_default *
1225 sx9310_get_default_reg(struct device *dev, int idx,
1226 struct sx9310_reg_default *reg_def)
1228 u32 combined[SX9310_NUM_CHANNELS];
1229 u32 start = 0, raw = 0, pos = 0;
1230 unsigned long comb_mask = 0;
1234 memcpy(reg_def, &sx9310_default_regs[idx], sizeof(*reg_def));
1235 switch (reg_def->reg) {
1236 case SX9310_REG_PROX_CTRL2:
1237 if (device_property_read_bool(dev, "semtech,cs0-ground")) {
1238 reg_def->def &= ~SX9310_REG_PROX_CTRL2_SHIELDEN_MASK;
1239 reg_def->def |= SX9310_REG_PROX_CTRL2_SHIELDEN_GROUND;
1242 count = device_property_count_u32(dev, "semtech,combined-sensors");
1243 if (count < 0 || count > ARRAY_SIZE(combined))
1245 ret = device_property_read_u32_array(dev, "semtech,combined-sensors",
1250 for (i = 0; i < count; i++)
1251 comb_mask |= BIT(combined[i]);
1253 reg_def->def &= ~SX9310_REG_PROX_CTRL2_COMBMODE_MASK;
1254 if (comb_mask == (BIT(3) | BIT(2) | BIT(1) | BIT(0)))
1255 reg_def->def |= SX9310_REG_PROX_CTRL2_COMBMODE_CS0_CS1_CS2_CS3;
1256 else if (comb_mask == (BIT(1) | BIT(2)))
1257 reg_def->def |= SX9310_REG_PROX_CTRL2_COMBMODE_CS1_CS2;
1258 else if (comb_mask == (BIT(0) | BIT(1)))
1259 reg_def->def |= SX9310_REG_PROX_CTRL2_COMBMODE_CS0_CS1;
1260 else if (comb_mask == BIT(3))
1261 reg_def->def |= SX9310_REG_PROX_CTRL2_COMBMODE_CS3;
1264 case SX9310_REG_PROX_CTRL4:
1265 ret = device_property_read_string(dev, "semtech,resolution", &res);
1269 reg_def->def &= ~SX9310_REG_PROX_CTRL4_RESOLUTION_MASK;
1270 if (!strcmp(res, "coarsest"))
1271 reg_def->def |= SX9310_REG_PROX_CTRL4_RESOLUTION_COARSEST;
1272 else if (!strcmp(res, "very-coarse"))
1273 reg_def->def |= SX9310_REG_PROX_CTRL4_RESOLUTION_VERY_COARSE;
1274 else if (!strcmp(res, "coarse"))
1275 reg_def->def |= SX9310_REG_PROX_CTRL4_RESOLUTION_COARSE;
1276 else if (!strcmp(res, "medium-coarse"))
1277 reg_def->def |= SX9310_REG_PROX_CTRL4_RESOLUTION_MEDIUM_COARSE;
1278 else if (!strcmp(res, "medium"))
1279 reg_def->def |= SX9310_REG_PROX_CTRL4_RESOLUTION_MEDIUM;
1280 else if (!strcmp(res, "fine"))
1281 reg_def->def |= SX9310_REG_PROX_CTRL4_RESOLUTION_FINE;
1282 else if (!strcmp(res, "very-fine"))
1283 reg_def->def |= SX9310_REG_PROX_CTRL4_RESOLUTION_VERY_FINE;
1284 else if (!strcmp(res, "finest"))
1285 reg_def->def |= SX9310_REG_PROX_CTRL4_RESOLUTION_FINEST;
1288 case SX9310_REG_PROX_CTRL5:
1289 ret = device_property_read_u32(dev, "semtech,startup-sensor", &start);
1291 start = FIELD_GET(SX9310_REG_PROX_CTRL5_STARTUPSENS_MASK,
1295 reg_def->def &= ~SX9310_REG_PROX_CTRL5_STARTUPSENS_MASK;
1296 reg_def->def |= FIELD_PREP(SX9310_REG_PROX_CTRL5_STARTUPSENS_MASK,
1299 ret = device_property_read_u32(dev, "semtech,proxraw-strength", &raw);
1301 raw = FIELD_GET(SX9310_REG_PROX_CTRL5_RAWFILT_MASK,
1307 reg_def->def &= ~SX9310_REG_PROX_CTRL5_RAWFILT_MASK;
1308 reg_def->def |= FIELD_PREP(SX9310_REG_PROX_CTRL5_RAWFILT_MASK,
1311 case SX9310_REG_PROX_CTRL7:
1312 ret = device_property_read_u32(dev, "semtech,avg-pos-strength", &pos);
1316 /* Powers of 2, except for a gap between 16 and 64 */
1317 pos = clamp(ilog2(pos), 3, 11) - (pos >= 32 ? 4 : 3);
1318 reg_def->def &= ~SX9310_REG_PROX_CTRL7_AVGPOSFILT_MASK;
1319 reg_def->def |= FIELD_PREP(SX9310_REG_PROX_CTRL7_AVGPOSFILT_MASK,
1327 static int sx9310_init_device(struct iio_dev *indio_dev)
1329 struct sx9310_data *data = iio_priv(indio_dev);
1330 struct sx9310_reg_default tmp;
1331 const struct sx9310_reg_default *initval;
1333 unsigned int i, val;
1335 ret = regmap_write(data->regmap, SX9310_REG_RESET, SX9310_SOFT_RESET);
1339 usleep_range(1000, 2000); /* power-up time is ~1ms. */
1341 /* Clear reset interrupt state by reading SX9310_REG_IRQ_SRC. */
1342 ret = regmap_read(data->regmap, SX9310_REG_IRQ_SRC, &val);
1346 /* Program some sane defaults. */
1347 for (i = 0; i < ARRAY_SIZE(sx9310_default_regs); i++) {
1348 initval = sx9310_get_default_reg(&indio_dev->dev, i, &tmp);
1349 ret = regmap_write(data->regmap, initval->reg, initval->def);
1354 return sx9310_init_compensation(indio_dev);
1357 static int sx9310_set_indio_dev_name(struct device *dev,
1358 struct iio_dev *indio_dev,
1359 unsigned int whoami)
1361 unsigned int long ddata;
1363 ddata = (uintptr_t)device_get_match_data(dev);
1364 if (ddata != whoami) {
1365 dev_err(dev, "WHOAMI does not match device data: %u\n", whoami);
1370 case SX9310_WHOAMI_VALUE:
1371 indio_dev->name = "sx9310";
1373 case SX9311_WHOAMI_VALUE:
1374 indio_dev->name = "sx9311";
1377 dev_err(dev, "unexpected WHOAMI response: %u\n", whoami);
1384 static void sx9310_regulator_disable(void *_data)
1386 struct sx9310_data *data = _data;
1388 regulator_bulk_disable(ARRAY_SIZE(data->supplies), data->supplies);
1391 static int sx9310_probe(struct i2c_client *client)
1394 struct device *dev = &client->dev;
1395 struct iio_dev *indio_dev;
1396 struct sx9310_data *data;
1398 indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
1402 data = iio_priv(indio_dev);
1403 data->client = client;
1404 data->supplies[0].supply = "vdd";
1405 data->supplies[1].supply = "svdd";
1406 mutex_init(&data->mutex);
1407 init_completion(&data->completion);
1409 data->regmap = devm_regmap_init_i2c(client, &sx9310_regmap_config);
1410 if (IS_ERR(data->regmap))
1411 return PTR_ERR(data->regmap);
1413 ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(data->supplies),
1418 ret = regulator_bulk_enable(ARRAY_SIZE(data->supplies), data->supplies);
1421 /* Must wait for Tpor time after initial power up */
1422 usleep_range(1000, 1100);
1424 ret = devm_add_action_or_reset(dev, sx9310_regulator_disable, data);
1428 ret = regmap_read(data->regmap, SX9310_REG_WHOAMI, &data->whoami);
1430 dev_err(dev, "error in reading WHOAMI register: %d", ret);
1434 ret = sx9310_set_indio_dev_name(dev, indio_dev, data->whoami);
1438 ACPI_COMPANION_SET(&indio_dev->dev, ACPI_COMPANION(dev));
1439 indio_dev->channels = sx9310_channels;
1440 indio_dev->num_channels = ARRAY_SIZE(sx9310_channels);
1441 indio_dev->info = &sx9310_info;
1442 indio_dev->modes = INDIO_DIRECT_MODE;
1443 i2c_set_clientdata(client, indio_dev);
1445 ret = sx9310_init_device(indio_dev);
1450 ret = devm_request_threaded_irq(dev, client->irq,
1452 sx9310_irq_thread_handler,
1454 "sx9310_event", indio_dev);
1458 data->trig = devm_iio_trigger_alloc(dev, "%s-dev%d",
1460 iio_device_id(indio_dev));
1464 data->trig->ops = &sx9310_trigger_ops;
1465 iio_trigger_set_drvdata(data->trig, indio_dev);
1467 ret = devm_iio_trigger_register(dev, data->trig);
1472 ret = devm_iio_triggered_buffer_setup(dev, indio_dev,
1473 iio_pollfunc_store_time,
1474 sx9310_trigger_handler,
1475 &sx9310_buffer_setup_ops);
1479 return devm_iio_device_register(dev, indio_dev);
1482 static int __maybe_unused sx9310_suspend(struct device *dev)
1484 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1485 struct sx9310_data *data = iio_priv(indio_dev);
1489 disable_irq_nosync(data->client->irq);
1491 mutex_lock(&data->mutex);
1492 ret = regmap_read(data->regmap, SX9310_REG_PROX_CTRL0,
1493 &data->suspend_ctrl0);
1497 ctrl0 = data->suspend_ctrl0 & ~SX9310_REG_PROX_CTRL0_SENSOREN_MASK;
1498 ret = regmap_write(data->regmap, SX9310_REG_PROX_CTRL0, ctrl0);
1502 ret = regmap_write(data->regmap, SX9310_REG_PAUSE, 0);
1505 mutex_unlock(&data->mutex);
1509 static int __maybe_unused sx9310_resume(struct device *dev)
1511 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1512 struct sx9310_data *data = iio_priv(indio_dev);
1515 mutex_lock(&data->mutex);
1516 ret = regmap_write(data->regmap, SX9310_REG_PAUSE, 1);
1520 ret = regmap_write(data->regmap, SX9310_REG_PROX_CTRL0,
1521 data->suspend_ctrl0);
1524 mutex_unlock(&data->mutex);
1528 enable_irq(data->client->irq);
1532 static const struct dev_pm_ops sx9310_pm_ops = {
1533 SET_SYSTEM_SLEEP_PM_OPS(sx9310_suspend, sx9310_resume)
1536 static const struct acpi_device_id sx9310_acpi_match[] = {
1537 { "STH9310", SX9310_WHOAMI_VALUE },
1538 { "STH9311", SX9311_WHOAMI_VALUE },
1541 MODULE_DEVICE_TABLE(acpi, sx9310_acpi_match);
1543 static const struct of_device_id sx9310_of_match[] = {
1544 { .compatible = "semtech,sx9310", (void *)SX9310_WHOAMI_VALUE },
1545 { .compatible = "semtech,sx9311", (void *)SX9311_WHOAMI_VALUE },
1548 MODULE_DEVICE_TABLE(of, sx9310_of_match);
1550 static const struct i2c_device_id sx9310_id[] = {
1551 { "sx9310", SX9310_WHOAMI_VALUE },
1552 { "sx9311", SX9311_WHOAMI_VALUE },
1555 MODULE_DEVICE_TABLE(i2c, sx9310_id);
1557 static struct i2c_driver sx9310_driver = {
1560 .acpi_match_table = sx9310_acpi_match,
1561 .of_match_table = sx9310_of_match,
1562 .pm = &sx9310_pm_ops,
1565 * Lots of i2c transfers in probe + over 200 ms waiting in
1566 * sx9310_init_compensation() mean a slow probe; prefer async
1567 * so we don't delay boot if we're builtin to the kernel.
1569 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
1571 .probe_new = sx9310_probe,
1572 .id_table = sx9310_id,
1574 module_i2c_driver(sx9310_driver);
1576 MODULE_AUTHOR("Gwendal Grignou <gwendal@chromium.org>");
1577 MODULE_AUTHOR("Daniel Campello <campello@chromium.org>");
1578 MODULE_DESCRIPTION("Driver for Semtech SX9310/SX9311 proximity sensor");
1579 MODULE_LICENSE("GPL v2");