?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'for-linus-20190706' of git://git.kernel.dk/linux-block
[linux/fpc-iii.git] / drivers / iio / proximity / sx9500.c
blob612f79c53cfc6dbc22ef4029f815756b0ba7c4ed
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(data->regmap, reg, bitmask, 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(data->regmap, reg, bitmask, 0);
224 }
225
226 static 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
232 static 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
238 static 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
244 static 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
250 static 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
257 static 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
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(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, &regval, 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(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
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->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 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->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->channel);
352 out:
353 mutex_unlock(&data->mutex);
354 reinit_completion(&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(data->regmap, SX9500_REG_PROX_CTRL0, &regval);
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
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(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
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(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(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
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(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
519 out:
520 mutex_unlock(&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->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
573 out_undo_chan:
574 if (state == 1)
575 sx9500_dec_chan_users(data, chan->channel);
576 else
577 sx9500_inc_chan_users(data, chan->channel);
578 out_unlock:
579 mutex_unlock(&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(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
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(&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, &indio_dev->channels[bit],
660 &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->buffer,
668 iio_get_time_ns(indio_dev));
669
670 out:
671 mutex_unlock(&data->mutex);
672
673 iio_trigger_notify_done(indio_dev->trig);
674
675 return IRQ_HANDLED;
676 }
677
678 static int sx9500_buffer_preenable(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, 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, i);
696
697 mutex_unlock(&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 iio_triggered_buffer_predisable(indio_dev);
708
709 mutex_lock(&data->mutex);
710
711 for (i = 0; i < SX9500_NUM_CHANNELS; i++)
712 if (test_bit(i, indio_dev->active_scan_mask)) {
713 ret = sx9500_dec_chan_users(data, i);
714 if (ret)
715 break;
716 }
717
718 if (ret)
719 for (i = i - 1; i >= 0; i--)
720 if (test_bit(i, indio_dev->active_scan_mask))
721 sx9500_inc_chan_users(data, i);
722
723 mutex_unlock(&data->mutex);
724
725 return ret;
726 }
727
728 static const struct iio_buffer_setup_ops sx9500_buffer_setup_ops = {
729 .preenable = sx9500_buffer_preenable,
730 .postenable = iio_triggered_buffer_postenable,
731 .predisable = sx9500_buffer_predisable,
732 };
733
734 struct sx9500_reg_default {
735 u8 reg;
736 u8 def;
737 };
738
739 static const struct sx9500_reg_default sx9500_default_regs[] = {
740 {
741 .reg = SX9500_REG_PROX_CTRL1,
742 /* Shield enabled, small range. */
743 .def = 0x43,
744 },
745 {
746 .reg = SX9500_REG_PROX_CTRL2,
747 /* x8 gain, 167kHz frequency, finest resolution. */
748 .def = 0x77,
749 },
750 {
751 .reg = SX9500_REG_PROX_CTRL3,
752 /* Doze enabled, 2x scan period doze, no raw filter. */
753 .def = 0x40,
754 },
755 {
756 .reg = SX9500_REG_PROX_CTRL4,
757 /* Average threshold. */
758 .def = 0x30,
759 },
760 {
761 .reg = SX9500_REG_PROX_CTRL5,
762 /*
763 * Debouncer off, lowest average negative filter,
764 * highest average postive filter.
765 */
766 .def = 0x0f,
767 },
768 {
769 .reg = SX9500_REG_PROX_CTRL6,
770 /* Proximity detection threshold: 280 */
771 .def = 0x0e,
772 },
773 {
774 .reg = SX9500_REG_PROX_CTRL7,
775 /*
776 * No automatic compensation, compensate each pin
777 * independently, proximity hysteresis: 32, close
778 * debouncer off, far debouncer off.
779 */
780 .def = 0x00,
781 },
782 {
783 .reg = SX9500_REG_PROX_CTRL8,
784 /* No stuck timeout, no periodic compensation. */
785 .def = 0x00,
786 },
787 {
788 .reg = SX9500_REG_PROX_CTRL0,
789 /* Scan period: 30ms, all sensors disabled. */
790 .def = 0x00,
791 },
792 };
793
794 /* Activate all channels and perform an initial compensation. */
795 static int sx9500_init_compensation(struct iio_dev *indio_dev)
796 {
797 struct sx9500_data *data = iio_priv(indio_dev);
798 int i, ret;
799 unsigned int val;
800
801 ret = regmap_update_bits(data->regmap, SX9500_REG_PROX_CTRL0,
802 SX9500_CHAN_MASK, SX9500_CHAN_MASK);
803 if (ret < 0)
804 return ret;
805
806 for (i = 10; i >= 0; i--) {
807 usleep_range(10000, 20000);
808 ret = regmap_read(data->regmap, SX9500_REG_STAT, &val);
809 if (ret < 0)
810 goto out;
811 if (!(val & SX9500_COMPSTAT_MASK))
812 break;
813 }
814
815 if (i < 0) {
816 dev_err(&data->client->dev, "initial compensation timed out");
817 ret = -ETIMEDOUT;
818 }
819
820 out:
821 regmap_update_bits(data->regmap, SX9500_REG_PROX_CTRL0,
822 SX9500_CHAN_MASK, 0);
823 return ret;
824 }
825
826 static int sx9500_init_device(struct iio_dev *indio_dev)
827 {
828 struct sx9500_data *data = iio_priv(indio_dev);
829 int ret, i;
830 unsigned int val;
831
832 if (data->gpiod_rst) {
833 gpiod_set_value_cansleep(data->gpiod_rst, 0);
834 usleep_range(1000, 2000);
835 gpiod_set_value_cansleep(data->gpiod_rst, 1);
836 usleep_range(1000, 2000);
837 }
838
839 ret = regmap_write(data->regmap, SX9500_REG_IRQ_MSK, 0);
840 if (ret < 0)
841 return ret;
842
843 ret = regmap_write(data->regmap, SX9500_REG_RESET,
844 SX9500_SOFT_RESET);
845 if (ret < 0)
846 return ret;
847
848 ret = regmap_read(data->regmap, SX9500_REG_IRQ_SRC, &val);
849 if (ret < 0)
850 return ret;
851
852 for (i = 0; i < ARRAY_SIZE(sx9500_default_regs); i++) {
853 ret = regmap_write(data->regmap,
854 sx9500_default_regs[i].reg,
855 sx9500_default_regs[i].def);
856 if (ret < 0)
857 return ret;
858 }
859
860 return sx9500_init_compensation(indio_dev);
861 }
862
863 static const struct acpi_gpio_params reset_gpios = { 0, 0, false };
864 static const struct acpi_gpio_params interrupt_gpios = { 2, 0, false };
865
866 static const struct acpi_gpio_mapping acpi_sx9500_gpios[] = {
867 { "reset-gpios", &reset_gpios, 1 },
868 /*
869 * Some platforms have a bug in ACPI GPIO description making IRQ
870 * GPIO to be output only. Ask the GPIO core to ignore this limit.
871 */
872 { "interrupt-gpios", &interrupt_gpios, 1, ACPI_GPIO_QUIRK_NO_IO_RESTRICTION },
873 { },
874 };
875
876 static void sx9500_gpio_probe(struct i2c_client *client,
877 struct sx9500_data *data)
878 {
879 struct gpio_desc *gpiod_int;
880 struct device *dev;
881 int ret;
882
883 if (!client)
884 return;
885
886 dev = &client->dev;
887
888 ret = devm_acpi_dev_add_driver_gpios(dev, acpi_sx9500_gpios);
889 if (ret)
890 dev_dbg(dev, "Unable to add GPIO mapping table\n");
891
892 if (client->irq <= 0) {
893 gpiod_int = devm_gpiod_get(dev, "interrupt", GPIOD_IN);
894 if (IS_ERR(gpiod_int))
895 dev_err(dev, "gpio get irq failed\n");
896 else
897 client->irq = gpiod_to_irq(gpiod_int);
898 }
899
900 data->gpiod_rst = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
901 if (IS_ERR(data->gpiod_rst)) {
902 dev_warn(dev, "gpio get reset pin failed\n");
903 data->gpiod_rst = NULL;
904 }
905 }
906
907 static int sx9500_probe(struct i2c_client *client,
908 const struct i2c_device_id *id)
909 {
910 int ret;
911 struct iio_dev *indio_dev;
912 struct sx9500_data *data;
913
914 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
915 if (indio_dev == NULL)
916 return -ENOMEM;
917
918 data = iio_priv(indio_dev);
919 data->client = client;
920 mutex_init(&data->mutex);
921 init_completion(&data->completion);
922 data->trigger_enabled = false;
923
924 data->regmap = devm_regmap_init_i2c(client, &sx9500_regmap_config);
925 if (IS_ERR(data->regmap))
926 return PTR_ERR(data->regmap);
927
928 indio_dev->dev.parent = &client->dev;
929 indio_dev->name = SX9500_DRIVER_NAME;
930 indio_dev->channels = sx9500_channels;
931 indio_dev->num_channels = ARRAY_SIZE(sx9500_channels);
932 indio_dev->info = &sx9500_info;
933 indio_dev->modes = INDIO_DIRECT_MODE;
934 i2c_set_clientdata(client, indio_dev);
935
936 sx9500_gpio_probe(client, data);
937
938 ret = sx9500_init_device(indio_dev);
939 if (ret < 0)
940 return ret;
941
942 if (client->irq <= 0)
943 dev_warn(&client->dev, "no valid irq found\n");
944 else {
945 ret = devm_request_threaded_irq(&client->dev, client->irq,
946 sx9500_irq_handler, sx9500_irq_thread_handler,
947 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
948 SX9500_IRQ_NAME, indio_dev);
949 if (ret < 0)
950 return ret;
951
952 data->trig = devm_iio_trigger_alloc(&client->dev,
953 "%s-dev%d", indio_dev->name, indio_dev->id);
954 if (!data->trig)
955 return -ENOMEM;
956
957 data->trig->dev.parent = &client->dev;
958 data->trig->ops = &sx9500_trigger_ops;
959 iio_trigger_set_drvdata(data->trig, indio_dev);
960
961 ret = iio_trigger_register(data->trig);
962 if (ret)
963 return ret;
964 }
965
966 ret = iio_triggered_buffer_setup(indio_dev, NULL,
967 sx9500_trigger_handler,
968 &sx9500_buffer_setup_ops);
969 if (ret < 0)
970 goto out_trigger_unregister;
971
972 ret = iio_device_register(indio_dev);
973 if (ret < 0)
974 goto out_buffer_cleanup;
975
976 return 0;
977
978 out_buffer_cleanup:
979 iio_triggered_buffer_cleanup(indio_dev);
980 out_trigger_unregister:
981 if (client->irq > 0)
982 iio_trigger_unregister(data->trig);
983
984 return ret;
985 }
986
987 static int sx9500_remove(struct i2c_client *client)
988 {
989 struct iio_dev *indio_dev = i2c_get_clientdata(client);
990 struct sx9500_data *data = iio_priv(indio_dev);
991
992 iio_device_unregister(indio_dev);
993 iio_triggered_buffer_cleanup(indio_dev);
994 if (client->irq > 0)
995 iio_trigger_unregister(data->trig);
996 kfree(data->buffer);
997
998 return 0;
999 }
1000
1001 #ifdef CONFIG_PM_SLEEP
1002 static int sx9500_suspend(struct device *dev)
1003 {
1004 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1005 struct sx9500_data *data = iio_priv(indio_dev);
1006 int ret;
1007
1008 mutex_lock(&data->mutex);
1009 ret = regmap_read(data->regmap, SX9500_REG_PROX_CTRL0,
1010 &data->suspend_ctrl0);
1011 if (ret < 0)
1012 goto out;
1013
1014 /*
1015 * Scan period doesn't matter because when all the sensors are
1016 * deactivated the device is in sleep mode.
1017 */
1018 ret = regmap_write(data->regmap, SX9500_REG_PROX_CTRL0, 0);
1019
1020 out:
1021 mutex_unlock(&data->mutex);
1022 return ret;
1023 }
1024
1025 static int sx9500_resume(struct device *dev)
1026 {
1027 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1028 struct sx9500_data *data = iio_priv(indio_dev);
1029 int ret;
1030
1031 mutex_lock(&data->mutex);
1032 ret = regmap_write(data->regmap, SX9500_REG_PROX_CTRL0,
1033 data->suspend_ctrl0);
1034 mutex_unlock(&data->mutex);
1035
1036 return ret;
1037 }
1038 #endif /* CONFIG_PM_SLEEP */
1039
1040 static const struct dev_pm_ops sx9500_pm_ops = {
1041 SET_SYSTEM_SLEEP_PM_OPS(sx9500_suspend, sx9500_resume)
1042 };
1043
1044 static const struct acpi_device_id sx9500_acpi_match[] = {
1045 {"SSX9500", 0},
1046 {"SASX9500", 0},
1047 { },
1048 };
1049 MODULE_DEVICE_TABLE(acpi, sx9500_acpi_match);
1050
1051 static const struct of_device_id sx9500_of_match[] = {
1052 { .compatible = "semtech,sx9500", },
1053 { }
1054 };
1055 MODULE_DEVICE_TABLE(of, sx9500_of_match);
1056
1057 static const struct i2c_device_id sx9500_id[] = {
1058 {"sx9500", 0},
1059 { },
1060 };
1061 MODULE_DEVICE_TABLE(i2c, sx9500_id);
1062
1063 static struct i2c_driver sx9500_driver = {
1064 .driver = {
1065 .name = SX9500_DRIVER_NAME,
1066 .acpi_match_table = ACPI_PTR(sx9500_acpi_match),
1067 .of_match_table = of_match_ptr(sx9500_of_match),
1068 .pm = &sx9500_pm_ops,
1069 },
1070 .probe = sx9500_probe,
1071 .remove = sx9500_remove,
1072 .id_table = sx9500_id,
1073 };
1074 module_i2c_driver(sx9500_driver);
1075
1076 MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>");
1077 MODULE_DESCRIPTION("Driver for Semtech SX9500 proximity sensor");
1078 MODULE_LICENSE("GPL v2");
Linux with added FPC-III support