1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Copyright (c) 2014 Intel Corporation |
4 | * |
5 | * Driver for Semtech's SX9500 capacitive proximity/button solution. |
6 | * Datasheet available at |
7 | * <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 0x00 |
34 | #define SX9500_REG_STAT 0x01 |
35 | #define SX9500_REG_IRQ_MSK 0x03 |
36 | |
37 | #define SX9500_REG_PROX_CTRL0 0x06 |
38 | #define SX9500_REG_PROX_CTRL1 0x07 |
39 | #define SX9500_REG_PROX_CTRL2 0x08 |
40 | #define SX9500_REG_PROX_CTRL3 0x09 |
41 | #define SX9500_REG_PROX_CTRL4 0x0a |
42 | #define SX9500_REG_PROX_CTRL5 0x0b |
43 | #define SX9500_REG_PROX_CTRL6 0x0c |
44 | #define SX9500_REG_PROX_CTRL7 0x0d |
45 | #define SX9500_REG_PROX_CTRL8 0x0e |
46 | |
47 | #define SX9500_REG_SENSOR_SEL 0x20 |
48 | #define SX9500_REG_USE_MSB 0x21 |
49 | #define SX9500_REG_USE_LSB 0x22 |
50 | #define SX9500_REG_AVG_MSB 0x23 |
51 | #define SX9500_REG_AVG_LSB 0x24 |
52 | #define SX9500_REG_DIFF_MSB 0x25 |
53 | #define SX9500_REG_DIFF_LSB 0x26 |
54 | #define SX9500_REG_OFFSET_MSB 0x27 |
55 | #define SX9500_REG_OFFSET_LSB 0x28 |
56 | |
57 | #define SX9500_REG_RESET 0x7f |
58 | |
59 | /* Write this to REG_RESET to do a soft reset. */ |
60 | #define SX9500_SOFT_RESET 0xde |
61 | |
62 | #define SX9500_SCAN_PERIOD_MASK GENMASK(6, 4) |
63 | #define SX9500_SCAN_PERIOD_SHIFT 4 |
64 | |
65 | /* |
66 | * These serve for identifying IRQ source in the IRQ_SRC register, and |
67 | * 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 4 |
74 | #define SX9500_COMPSTAT_MASK GENMASK(3, 0) |
75 | |
76 | #define SX9500_NUM_CHANNELS 4 |
77 | #define SX9500_CHAN_MASK GENMASK(SX9500_NUM_CHANNELS - 1, 0) |
78 | |
79 | struct 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. We |
87 | * 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 | |
100 | static 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 | |
126 | static 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 | |
134 | static 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 | |
148 | static const unsigned int sx9500_scan_period_table[] = { |
149 | 30, 60, 90, 120, 150, 200, 300, 400, |
150 | }; |
151 | |
152 | static 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 | |
160 | static 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 unallocated |
167 | * ones. |
168 | */ |
169 | static 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 | |
176 | static 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 | |
181 | static 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 | |
187 | static 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 | |
192 | static 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 | |
204 | static 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_update_bits(map: data->regmap, reg, mask: bitmask, val: bitmask); |
213 | } |
214 | |
215 | static 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_update_bits(map: data->regmap, reg, mask: bitmask, val: 0); |
224 | } |
225 | |
226 | static int sx9500_inc_chan_users(struct sx9500_data *data, int chan) |
227 | { |
228 | return sx9500_inc_users(data, counter: &data->channel_users[chan], |
229 | SX9500_REG_PROX_CTRL0, BIT(chan)); |
230 | } |
231 | |
232 | static int sx9500_dec_chan_users(struct sx9500_data *data, int chan) |
233 | { |
234 | return sx9500_dec_users(data, counter: &data->channel_users[chan], |
235 | SX9500_REG_PROX_CTRL0, BIT(chan)); |
236 | } |
237 | |
238 | static int sx9500_inc_data_rdy_users(struct sx9500_data *data) |
239 | { |
240 | return sx9500_inc_users(data, counter: &data->data_rdy_users, |
241 | SX9500_REG_IRQ_MSK, SX9500_CONVDONE_IRQ); |
242 | } |
243 | |
244 | static int sx9500_dec_data_rdy_users(struct sx9500_data *data) |
245 | { |
246 | return sx9500_dec_users(data, counter: &data->data_rdy_users, |
247 | SX9500_REG_IRQ_MSK, SX9500_CONVDONE_IRQ); |
248 | } |
249 | |
250 | static int sx9500_inc_close_far_users(struct sx9500_data *data) |
251 | { |
252 | return sx9500_inc_users(data, counter: &data->close_far_users, |
253 | SX9500_REG_IRQ_MSK, |
254 | SX9500_CLOSE_IRQ | SX9500_FAR_IRQ); |
255 | } |
256 | |
257 | static int sx9500_dec_close_far_users(struct sx9500_data *data) |
258 | { |
259 | return sx9500_dec_users(data, counter: &data->close_far_users, |
260 | SX9500_REG_IRQ_MSK, |
261 | SX9500_CLOSE_IRQ | SX9500_FAR_IRQ); |
262 | } |
263 | |
264 | static 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(map: data->regmap, SX9500_REG_SENSOR_SEL, val: chan->channel); |
272 | if (ret < 0) |
273 | return ret; |
274 | |
275 | ret = regmap_bulk_read(map: data->regmap, SX9500_REG_USE_MSB, val: ®val, val_count: 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 period |
286 | * after enabling a channel to get a result. |
287 | */ |
288 | static int sx9500_wait_for_sample(struct sx9500_data *data) |
289 | { |
290 | int ret; |
291 | unsigned int val; |
292 | |
293 | ret = regmap_read(map: data->regmap, SX9500_REG_PROX_CTRL0, val: &val); |
294 | if (ret < 0) |
295 | return ret; |
296 | |
297 | val = (val & SX9500_SCAN_PERIOD_MASK) >> SX9500_SCAN_PERIOD_SHIFT; |
298 | |
299 | msleep(msecs: sx9500_scan_period_table[val]); |
300 | |
301 | return 0; |
302 | } |
303 | |
304 | static 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: 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(lock: &data->mutex); |
321 | |
322 | if (data->client->irq > 0) |
323 | ret = wait_for_completion_interruptible(x: &data->completion); |
324 | else |
325 | 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: chan->channel); |
341 | if (ret < 0) |
342 | goto out; |
343 | |
344 | ret = IIO_VAL_INT; |
345 | |
346 | goto out; |
347 | |
348 | out_dec_data_rdy: |
349 | sx9500_dec_data_rdy_users(data); |
350 | out_dec_chan: |
351 | sx9500_dec_chan_users(data, chan: chan->channel); |
352 | out: |
353 | mutex_unlock(lock: &data->mutex); |
354 | reinit_completion(x: &data->completion); |
355 | |
356 | return ret; |
357 | } |
358 | |
359 | static 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(map: data->regmap, SX9500_REG_PROX_CTRL0, val: ®val); |
367 | mutex_unlock(lock: &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 | |
379 | static 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 | |
406 | static 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(map: data->regmap, SX9500_REG_PROX_CTRL0, |
422 | SX9500_SCAN_PERIOD_MASK, |
423 | val: i << SX9500_SCAN_PERIOD_SHIFT); |
424 | |
425 | mutex_unlock(lock: &data->mutex); |
426 | |
427 | return ret; |
428 | } |
429 | |
430 | static 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 | |
449 | static 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(trig: data->trig); |
456 | |
457 | /* |
458 | * Even if no event is enabled, we need to wake the thread to |
459 | * clear the interrupt state by reading SX9500_REG_IRQ_SRC. It |
460 | * is not possible to do that here because regmap_read takes a |
461 | * mutex. |
462 | */ |
463 | return IRQ_WAKE_THREAD; |
464 | } |
465 | |
466 | static 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(map: data->regmap, SX9500_REG_STAT, val: &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_code: ev, timestamp: iio_get_time_ns(indio_dev)); |
494 | data->prox_stat[chan] = new_prox; |
495 | } |
496 | } |
497 | |
498 | static 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(map: data->regmap, SX9500_REG_IRQ_SRC, val: &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 | |
519 | out: |
520 | mutex_unlock(lock: &data->mutex); |
521 | |
522 | return IRQ_HANDLED; |
523 | } |
524 | |
525 | static 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 | |
539 | static 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: 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: 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 | |
573 | out_undo_chan: |
574 | if (state == 1) |
575 | sx9500_dec_chan_users(data, chan: chan->channel); |
576 | else |
577 | sx9500_inc_chan_users(data, chan: chan->channel); |
578 | out_unlock: |
579 | mutex_unlock(lock: &data->mutex); |
580 | return ret; |
581 | } |
582 | |
583 | static 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(objp: data->buffer); |
590 | data->buffer = kzalloc(size: indio_dev->scan_bytes, GFP_KERNEL); |
591 | mutex_unlock(lock: &data->mutex); |
592 | |
593 | if (data->buffer == NULL) |
594 | return -ENOMEM; |
595 | |
596 | return 0; |
597 | } |
598 | |
599 | static IIO_CONST_ATTR_SAMP_FREQ_AVAIL( |
600 | "2.500000 3.333333 5 6.666666 8.333333 11.111111 16.666666 33.333333" ); |
601 | |
602 | static struct attribute *sx9500_attributes[] = { |
603 | &iio_const_attr_sampling_frequency_available.dev_attr.attr, |
604 | NULL, |
605 | }; |
606 | |
607 | static const struct attribute_group sx9500_attribute_group = { |
608 | .attrs = sx9500_attributes, |
609 | }; |
610 | |
611 | static 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 | |
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(lock: &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 | }; |
647 | |
648 | static 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 | for_each_set_bit(bit, indio_dev->active_scan_mask, |
658 | indio_dev->masklength) { |
659 | ret = sx9500_read_prox_data(data, chan: &indio_dev->channels[bit], |
660 | val: &val); |
661 | if (ret < 0) |
662 | goto out; |
663 | |
664 | data->buffer[i++] = val; |
665 | } |
666 | |
667 | iio_push_to_buffers_with_timestamp(indio_dev, data: data->buffer, |
668 | timestamp: iio_get_time_ns(indio_dev)); |
669 | |
670 | out: |
671 | mutex_unlock(lock: &data->mutex); |
672 | |
673 | iio_trigger_notify_done(trig: indio_dev->trig); |
674 | |
675 | return IRQ_HANDLED; |
676 | } |
677 | |
678 | static int sx9500_buffer_postenable(struct iio_dev *indio_dev) |
679 | { |
680 | struct sx9500_data *data = iio_priv(indio_dev); |
681 | int ret = 0, i; |
682 | |
683 | mutex_lock(&data->mutex); |
684 | |
685 | for (i = 0; i < SX9500_NUM_CHANNELS; i++) |
686 | if (test_bit(i, indio_dev->active_scan_mask)) { |
687 | ret = sx9500_inc_chan_users(data, chan: i); |
688 | if (ret) |
689 | break; |
690 | } |
691 | |
692 | if (ret) |
693 | for (i = i - 1; i >= 0; i--) |
694 | if (test_bit(i, indio_dev->active_scan_mask)) |
695 | sx9500_dec_chan_users(data, chan: i); |
696 | |
697 | mutex_unlock(lock: &data->mutex); |
698 | |
699 | return ret; |
700 | } |
701 | |
702 | static int sx9500_buffer_predisable(struct iio_dev *indio_dev) |
703 | { |
704 | struct sx9500_data *data = iio_priv(indio_dev); |
705 | int ret = 0, i; |
706 | |
707 | mutex_lock(&data->mutex); |
708 | |
709 | for (i = 0; i < SX9500_NUM_CHANNELS; i++) |
710 | if (test_bit(i, indio_dev->active_scan_mask)) { |
711 | ret = sx9500_dec_chan_users(data, chan: i); |
712 | if (ret) |
713 | break; |
714 | } |
715 | |
716 | if (ret) |
717 | for (i = i - 1; i >= 0; i--) |
718 | if (test_bit(i, indio_dev->active_scan_mask)) |
719 | sx9500_inc_chan_users(data, chan: i); |
720 | |
721 | mutex_unlock(lock: &data->mutex); |
722 | |
723 | return ret; |
724 | } |
725 | |
726 | static const struct iio_buffer_setup_ops sx9500_buffer_setup_ops = { |
727 | .postenable = sx9500_buffer_postenable, |
728 | .predisable = sx9500_buffer_predisable, |
729 | }; |
730 | |
731 | struct sx9500_reg_default { |
732 | u8 reg; |
733 | u8 def; |
734 | }; |
735 | |
736 | static const struct sx9500_reg_default sx9500_default_regs[] = { |
737 | { |
738 | .reg = SX9500_REG_PROX_CTRL1, |
739 | /* Shield enabled, small range. */ |
740 | .def = 0x43, |
741 | }, |
742 | { |
743 | .reg = SX9500_REG_PROX_CTRL2, |
744 | /* x8 gain, 167kHz frequency, finest resolution. */ |
745 | .def = 0x77, |
746 | }, |
747 | { |
748 | .reg = SX9500_REG_PROX_CTRL3, |
749 | /* Doze enabled, 2x scan period doze, no raw filter. */ |
750 | .def = 0x40, |
751 | }, |
752 | { |
753 | .reg = SX9500_REG_PROX_CTRL4, |
754 | /* Average threshold. */ |
755 | .def = 0x30, |
756 | }, |
757 | { |
758 | .reg = SX9500_REG_PROX_CTRL5, |
759 | /* |
760 | * Debouncer off, lowest average negative filter, |
761 | * highest average positive filter. |
762 | */ |
763 | .def = 0x0f, |
764 | }, |
765 | { |
766 | .reg = SX9500_REG_PROX_CTRL6, |
767 | /* Proximity detection threshold: 280 */ |
768 | .def = 0x0e, |
769 | }, |
770 | { |
771 | .reg = SX9500_REG_PROX_CTRL7, |
772 | /* |
773 | * No automatic compensation, compensate each pin |
774 | * independently, proximity hysteresis: 32, close |
775 | * debouncer off, far debouncer off. |
776 | */ |
777 | .def = 0x00, |
778 | }, |
779 | { |
780 | .reg = SX9500_REG_PROX_CTRL8, |
781 | /* No stuck timeout, no periodic compensation. */ |
782 | .def = 0x00, |
783 | }, |
784 | { |
785 | .reg = SX9500_REG_PROX_CTRL0, |
786 | /* Scan period: 30ms, all sensors disabled. */ |
787 | .def = 0x00, |
788 | }, |
789 | }; |
790 | |
791 | /* Activate all channels and perform an initial compensation. */ |
792 | static int sx9500_init_compensation(struct iio_dev *indio_dev) |
793 | { |
794 | struct sx9500_data *data = iio_priv(indio_dev); |
795 | int i, ret; |
796 | unsigned int val; |
797 | |
798 | ret = regmap_update_bits(map: data->regmap, SX9500_REG_PROX_CTRL0, |
799 | SX9500_CHAN_MASK, SX9500_CHAN_MASK); |
800 | if (ret < 0) |
801 | return ret; |
802 | |
803 | for (i = 10; i >= 0; i--) { |
804 | usleep_range(min: 10000, max: 20000); |
805 | ret = regmap_read(map: data->regmap, SX9500_REG_STAT, val: &val); |
806 | if (ret < 0) |
807 | goto out; |
808 | if (!(val & SX9500_COMPSTAT_MASK)) |
809 | break; |
810 | } |
811 | |
812 | if (i < 0) { |
813 | dev_err(&data->client->dev, "initial compensation timed out" ); |
814 | ret = -ETIMEDOUT; |
815 | } |
816 | |
817 | out: |
818 | regmap_update_bits(map: data->regmap, SX9500_REG_PROX_CTRL0, |
819 | SX9500_CHAN_MASK, val: 0); |
820 | return ret; |
821 | } |
822 | |
823 | static int sx9500_init_device(struct iio_dev *indio_dev) |
824 | { |
825 | struct sx9500_data *data = iio_priv(indio_dev); |
826 | int ret, i; |
827 | unsigned int val; |
828 | |
829 | if (data->gpiod_rst) { |
830 | gpiod_set_value_cansleep(desc: data->gpiod_rst, value: 0); |
831 | usleep_range(min: 1000, max: 2000); |
832 | gpiod_set_value_cansleep(desc: data->gpiod_rst, value: 1); |
833 | usleep_range(min: 1000, max: 2000); |
834 | } |
835 | |
836 | ret = regmap_write(map: data->regmap, SX9500_REG_IRQ_MSK, val: 0); |
837 | if (ret < 0) |
838 | return ret; |
839 | |
840 | ret = regmap_write(map: data->regmap, SX9500_REG_RESET, |
841 | SX9500_SOFT_RESET); |
842 | if (ret < 0) |
843 | return ret; |
844 | |
845 | ret = regmap_read(map: data->regmap, SX9500_REG_IRQ_SRC, val: &val); |
846 | if (ret < 0) |
847 | return ret; |
848 | |
849 | for (i = 0; i < ARRAY_SIZE(sx9500_default_regs); i++) { |
850 | ret = regmap_write(map: data->regmap, |
851 | reg: sx9500_default_regs[i].reg, |
852 | val: sx9500_default_regs[i].def); |
853 | if (ret < 0) |
854 | return ret; |
855 | } |
856 | |
857 | return sx9500_init_compensation(indio_dev); |
858 | } |
859 | |
860 | static const struct acpi_gpio_params reset_gpios = { 0, 0, false }; |
861 | static const struct acpi_gpio_params interrupt_gpios = { 2, 0, false }; |
862 | |
863 | static const struct acpi_gpio_mapping acpi_sx9500_gpios[] = { |
864 | { "reset-gpios" , &reset_gpios, 1 }, |
865 | /* |
866 | * Some platforms have a bug in ACPI GPIO description making IRQ |
867 | * GPIO to be output only. Ask the GPIO core to ignore this limit. |
868 | */ |
869 | { "interrupt-gpios" , &interrupt_gpios, 1, ACPI_GPIO_QUIRK_NO_IO_RESTRICTION }, |
870 | { }, |
871 | }; |
872 | |
873 | static void sx9500_gpio_probe(struct i2c_client *client, |
874 | struct sx9500_data *data) |
875 | { |
876 | struct gpio_desc *gpiod_int; |
877 | struct device *dev; |
878 | int ret; |
879 | |
880 | if (!client) |
881 | return; |
882 | |
883 | dev = &client->dev; |
884 | |
885 | ret = devm_acpi_dev_add_driver_gpios(dev, gpios: acpi_sx9500_gpios); |
886 | if (ret) |
887 | dev_dbg(dev, "Unable to add GPIO mapping table\n" ); |
888 | |
889 | if (client->irq <= 0) { |
890 | gpiod_int = devm_gpiod_get(dev, con_id: "interrupt" , flags: GPIOD_IN); |
891 | if (IS_ERR(ptr: gpiod_int)) |
892 | dev_err(dev, "gpio get irq failed\n" ); |
893 | else |
894 | client->irq = gpiod_to_irq(desc: gpiod_int); |
895 | } |
896 | |
897 | data->gpiod_rst = devm_gpiod_get(dev, con_id: "reset" , flags: GPIOD_OUT_HIGH); |
898 | if (IS_ERR(ptr: data->gpiod_rst)) { |
899 | dev_warn(dev, "gpio get reset pin failed\n" ); |
900 | data->gpiod_rst = NULL; |
901 | } |
902 | } |
903 | |
904 | static int sx9500_probe(struct i2c_client *client) |
905 | { |
906 | int ret; |
907 | struct iio_dev *indio_dev; |
908 | struct sx9500_data *data; |
909 | |
910 | indio_dev = devm_iio_device_alloc(parent: &client->dev, sizeof_priv: sizeof(*data)); |
911 | if (indio_dev == NULL) |
912 | return -ENOMEM; |
913 | |
914 | data = iio_priv(indio_dev); |
915 | data->client = client; |
916 | mutex_init(&data->mutex); |
917 | init_completion(x: &data->completion); |
918 | data->trigger_enabled = false; |
919 | |
920 | data->regmap = devm_regmap_init_i2c(client, &sx9500_regmap_config); |
921 | if (IS_ERR(ptr: data->regmap)) |
922 | return PTR_ERR(ptr: data->regmap); |
923 | |
924 | indio_dev->name = SX9500_DRIVER_NAME; |
925 | indio_dev->channels = sx9500_channels; |
926 | indio_dev->num_channels = ARRAY_SIZE(sx9500_channels); |
927 | indio_dev->info = &sx9500_info; |
928 | indio_dev->modes = INDIO_DIRECT_MODE; |
929 | i2c_set_clientdata(client, data: indio_dev); |
930 | |
931 | sx9500_gpio_probe(client, data); |
932 | |
933 | ret = sx9500_init_device(indio_dev); |
934 | if (ret < 0) |
935 | return ret; |
936 | |
937 | if (client->irq <= 0) |
938 | dev_warn(&client->dev, "no valid irq found\n" ); |
939 | else { |
940 | ret = devm_request_threaded_irq(dev: &client->dev, irq: client->irq, |
941 | handler: sx9500_irq_handler, thread_fn: sx9500_irq_thread_handler, |
942 | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, |
943 | SX9500_IRQ_NAME, dev_id: indio_dev); |
944 | if (ret < 0) |
945 | return ret; |
946 | |
947 | data->trig = devm_iio_trigger_alloc(&client->dev, |
948 | "%s-dev%d" , indio_dev->name, iio_device_id(indio_dev)); |
949 | if (!data->trig) |
950 | return -ENOMEM; |
951 | |
952 | data->trig->ops = &sx9500_trigger_ops; |
953 | iio_trigger_set_drvdata(trig: data->trig, data: indio_dev); |
954 | |
955 | ret = iio_trigger_register(trig_info: data->trig); |
956 | if (ret) |
957 | return ret; |
958 | } |
959 | |
960 | ret = iio_triggered_buffer_setup(indio_dev, NULL, |
961 | sx9500_trigger_handler, |
962 | &sx9500_buffer_setup_ops); |
963 | if (ret < 0) |
964 | goto out_trigger_unregister; |
965 | |
966 | ret = iio_device_register(indio_dev); |
967 | if (ret < 0) |
968 | goto out_buffer_cleanup; |
969 | |
970 | return 0; |
971 | |
972 | out_buffer_cleanup: |
973 | iio_triggered_buffer_cleanup(indio_dev); |
974 | out_trigger_unregister: |
975 | if (client->irq > 0) |
976 | iio_trigger_unregister(trig_info: data->trig); |
977 | |
978 | return ret; |
979 | } |
980 | |
981 | static void sx9500_remove(struct i2c_client *client) |
982 | { |
983 | struct iio_dev *indio_dev = i2c_get_clientdata(client); |
984 | struct sx9500_data *data = iio_priv(indio_dev); |
985 | |
986 | iio_device_unregister(indio_dev); |
987 | iio_triggered_buffer_cleanup(indio_dev); |
988 | if (client->irq > 0) |
989 | iio_trigger_unregister(trig_info: data->trig); |
990 | kfree(objp: data->buffer); |
991 | } |
992 | |
993 | static int sx9500_suspend(struct device *dev) |
994 | { |
995 | struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); |
996 | struct sx9500_data *data = iio_priv(indio_dev); |
997 | int ret; |
998 | |
999 | mutex_lock(&data->mutex); |
1000 | ret = regmap_read(map: data->regmap, SX9500_REG_PROX_CTRL0, |
1001 | val: &data->suspend_ctrl0); |
1002 | if (ret < 0) |
1003 | goto out; |
1004 | |
1005 | /* |
1006 | * Scan period doesn't matter because when all the sensors are |
1007 | * deactivated the device is in sleep mode. |
1008 | */ |
1009 | ret = regmap_write(map: data->regmap, SX9500_REG_PROX_CTRL0, val: 0); |
1010 | |
1011 | out: |
1012 | mutex_unlock(lock: &data->mutex); |
1013 | return ret; |
1014 | } |
1015 | |
1016 | static int sx9500_resume(struct device *dev) |
1017 | { |
1018 | struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev)); |
1019 | struct sx9500_data *data = iio_priv(indio_dev); |
1020 | int ret; |
1021 | |
1022 | mutex_lock(&data->mutex); |
1023 | ret = regmap_write(map: data->regmap, SX9500_REG_PROX_CTRL0, |
1024 | val: data->suspend_ctrl0); |
1025 | mutex_unlock(lock: &data->mutex); |
1026 | |
1027 | return ret; |
1028 | } |
1029 | |
1030 | static DEFINE_SIMPLE_DEV_PM_OPS(sx9500_pm_ops, sx9500_suspend, sx9500_resume); |
1031 | |
1032 | static const struct acpi_device_id sx9500_acpi_match[] = { |
1033 | {"SSX9500" , 0}, |
1034 | {"SASX9500" , 0}, |
1035 | { }, |
1036 | }; |
1037 | MODULE_DEVICE_TABLE(acpi, sx9500_acpi_match); |
1038 | |
1039 | static const struct of_device_id sx9500_of_match[] = { |
1040 | { .compatible = "semtech,sx9500" , }, |
1041 | { } |
1042 | }; |
1043 | MODULE_DEVICE_TABLE(of, sx9500_of_match); |
1044 | |
1045 | static const struct i2c_device_id sx9500_id[] = { |
1046 | {"sx9500" , 0}, |
1047 | { }, |
1048 | }; |
1049 | MODULE_DEVICE_TABLE(i2c, sx9500_id); |
1050 | |
1051 | static struct i2c_driver sx9500_driver = { |
1052 | .driver = { |
1053 | .name = SX9500_DRIVER_NAME, |
1054 | .acpi_match_table = sx9500_acpi_match, |
1055 | .of_match_table = sx9500_of_match, |
1056 | .pm = pm_sleep_ptr(&sx9500_pm_ops), |
1057 | }, |
1058 | .probe = sx9500_probe, |
1059 | .remove = sx9500_remove, |
1060 | .id_table = sx9500_id, |
1061 | }; |
1062 | module_i2c_driver(sx9500_driver); |
1063 | |
1064 | MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>" ); |
1065 | MODULE_DESCRIPTION("Driver for Semtech SX9500 proximity sensor" ); |
1066 | MODULE_LICENSE("GPL v2" ); |
1067 | |