1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/kernel.h>
14#include <linux/slab.h>
15#include <linux/module.h>
16#include <linux/i2c.h>
17#include <linux/irq.h>
18#include <linux/acpi.h>
19#include <linux/gpio/consumer.h>
20#include <linux/regmap.h>
21#include <linux/pm.h>
22#include <linux/delay.h>
23
24#include <linux/iio/iio.h>
25#include <linux/iio/buffer.h>
26#include <linux/iio/sysfs.h>
27#include <linux/iio/events.h>
28#include <linux/iio/trigger.h>
29#include <linux/iio/triggered_buffer.h>
30#include <linux/iio/trigger_consumer.h>
31
32#define SX9500_DRIVER_NAME "sx9500"
33#define SX9500_IRQ_NAME "sx9500_event"
34
35
36#define SX9500_REG_IRQ_SRC 0x00
37#define SX9500_REG_STAT 0x01
38#define SX9500_REG_IRQ_MSK 0x03
39
40#define SX9500_REG_PROX_CTRL0 0x06
41#define SX9500_REG_PROX_CTRL1 0x07
42#define SX9500_REG_PROX_CTRL2 0x08
43#define SX9500_REG_PROX_CTRL3 0x09
44#define SX9500_REG_PROX_CTRL4 0x0a
45#define SX9500_REG_PROX_CTRL5 0x0b
46#define SX9500_REG_PROX_CTRL6 0x0c
47#define SX9500_REG_PROX_CTRL7 0x0d
48#define SX9500_REG_PROX_CTRL8 0x0e
49
50#define SX9500_REG_SENSOR_SEL 0x20
51#define SX9500_REG_USE_MSB 0x21
52#define SX9500_REG_USE_LSB 0x22
53#define SX9500_REG_AVG_MSB 0x23
54#define SX9500_REG_AVG_LSB 0x24
55#define SX9500_REG_DIFF_MSB 0x25
56#define SX9500_REG_DIFF_LSB 0x26
57#define SX9500_REG_OFFSET_MSB 0x27
58#define SX9500_REG_OFFSET_LSB 0x28
59
60#define SX9500_REG_RESET 0x7f
61
62
63#define SX9500_SOFT_RESET 0xde
64
65#define SX9500_SCAN_PERIOD_MASK GENMASK(6, 4)
66#define SX9500_SCAN_PERIOD_SHIFT 4
67
68
69
70
71
72#define SX9500_CLOSE_IRQ BIT(6)
73#define SX9500_FAR_IRQ BIT(5)
74#define SX9500_CONVDONE_IRQ BIT(3)
75
76#define SX9500_PROXSTAT_SHIFT 4
77#define SX9500_COMPSTAT_MASK GENMASK(3, 0)
78
79#define SX9500_NUM_CHANNELS 4
80#define SX9500_CHAN_MASK GENMASK(SX9500_NUM_CHANNELS - 1, 0)
81
82struct sx9500_data {
83 struct mutex mutex;
84 struct i2c_client *client;
85 struct iio_trigger *trig;
86 struct regmap *regmap;
87 struct gpio_desc *gpiod_rst;
88
89
90
91
92 bool prox_stat[SX9500_NUM_CHANNELS];
93 bool event_enabled[SX9500_NUM_CHANNELS];
94 bool trigger_enabled;
95 u16 *buffer;
96
97 unsigned int suspend_ctrl0;
98 struct completion completion;
99 int data_rdy_users, close_far_users;
100 int channel_users[SX9500_NUM_CHANNELS];
101};
102
103static const struct iio_event_spec sx9500_events[] = {
104 {
105 .type = IIO_EV_TYPE_THRESH,
106 .dir = IIO_EV_DIR_EITHER,
107 .mask_separate = BIT(IIO_EV_INFO_ENABLE),
108 },
109};
110
111#define SX9500_CHANNEL(idx) \
112 { \
113 .type = IIO_PROXIMITY, \
114 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
115 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
116 .indexed = 1, \
117 .channel = idx, \
118 .event_spec = sx9500_events, \
119 .num_event_specs = ARRAY_SIZE(sx9500_events), \
120 .scan_index = idx, \
121 .scan_type = { \
122 .sign = 'u', \
123 .realbits = 16, \
124 .storagebits = 16, \
125 .shift = 0, \
126 }, \
127 }
128
129static const struct iio_chan_spec sx9500_channels[] = {
130 SX9500_CHANNEL(0),
131 SX9500_CHANNEL(1),
132 SX9500_CHANNEL(2),
133 SX9500_CHANNEL(3),
134 IIO_CHAN_SOFT_TIMESTAMP(4),
135};
136
137static const struct {
138 int val;
139 int val2;
140} sx9500_samp_freq_table[] = {
141 {33, 333333},
142 {16, 666666},
143 {11, 111111},
144 {8, 333333},
145 {6, 666666},
146 {5, 0},
147 {3, 333333},
148 {2, 500000},
149};
150
151static const unsigned int sx9500_scan_period_table[] = {
152 30, 60, 90, 120, 150, 200, 300, 400,
153};
154
155static const struct regmap_range sx9500_writable_reg_ranges[] = {
156 regmap_reg_range(SX9500_REG_IRQ_MSK, SX9500_REG_IRQ_MSK),
157 regmap_reg_range(SX9500_REG_PROX_CTRL0, SX9500_REG_PROX_CTRL8),
158 regmap_reg_range(SX9500_REG_SENSOR_SEL, SX9500_REG_SENSOR_SEL),
159 regmap_reg_range(SX9500_REG_OFFSET_MSB, SX9500_REG_OFFSET_LSB),
160 regmap_reg_range(SX9500_REG_RESET, SX9500_REG_RESET),
161};
162
163static const struct regmap_access_table sx9500_writeable_regs = {
164 .yes_ranges = sx9500_writable_reg_ranges,
165 .n_yes_ranges = ARRAY_SIZE(sx9500_writable_reg_ranges),
166};
167
168
169
170
171
172static const struct regmap_range sx9500_non_readable_reg_ranges[] = {
173 regmap_reg_range(SX9500_REG_STAT + 1, SX9500_REG_STAT + 1),
174 regmap_reg_range(SX9500_REG_IRQ_MSK + 1, SX9500_REG_PROX_CTRL0 - 1),
175 regmap_reg_range(SX9500_REG_PROX_CTRL8 + 1, SX9500_REG_SENSOR_SEL - 1),
176 regmap_reg_range(SX9500_REG_OFFSET_LSB + 1, SX9500_REG_RESET - 1),
177};
178
179static const struct regmap_access_table sx9500_readable_regs = {
180 .no_ranges = sx9500_non_readable_reg_ranges,
181 .n_no_ranges = ARRAY_SIZE(sx9500_non_readable_reg_ranges),
182};
183
184static const struct regmap_range sx9500_volatile_reg_ranges[] = {
185 regmap_reg_range(SX9500_REG_IRQ_SRC, SX9500_REG_STAT),
186 regmap_reg_range(SX9500_REG_USE_MSB, SX9500_REG_OFFSET_LSB),
187 regmap_reg_range(SX9500_REG_RESET, SX9500_REG_RESET),
188};
189
190static const struct regmap_access_table sx9500_volatile_regs = {
191 .yes_ranges = sx9500_volatile_reg_ranges,
192 .n_yes_ranges = ARRAY_SIZE(sx9500_volatile_reg_ranges),
193};
194
195static const struct regmap_config sx9500_regmap_config = {
196 .reg_bits = 8,
197 .val_bits = 8,
198
199 .max_register = SX9500_REG_RESET,
200 .cache_type = REGCACHE_RBTREE,
201
202 .wr_table = &sx9500_writeable_regs,
203 .rd_table = &sx9500_readable_regs,
204 .volatile_table = &sx9500_volatile_regs,
205};
206
207static int sx9500_inc_users(struct sx9500_data *data, int *counter,
208 unsigned int reg, unsigned int bitmask)
209{
210 (*counter)++;
211 if (*counter != 1)
212
213 return 0;
214
215 return regmap_update_bits(data->regmap, reg, bitmask, bitmask);
216}
217
218static int sx9500_dec_users(struct sx9500_data *data, int *counter,
219 unsigned int reg, unsigned int bitmask)
220{
221 (*counter)--;
222 if (*counter != 0)
223
224 return 0;
225
226 return regmap_update_bits(data->regmap, reg, bitmask, 0);
227}
228
229static int sx9500_inc_chan_users(struct sx9500_data *data, int chan)
230{
231 return sx9500_inc_users(data, &data->channel_users[chan],
232 SX9500_REG_PROX_CTRL0, BIT(chan));
233}
234
235static int sx9500_dec_chan_users(struct sx9500_data *data, int chan)
236{
237 return sx9500_dec_users(data, &data->channel_users[chan],
238 SX9500_REG_PROX_CTRL0, BIT(chan));
239}
240
241static int sx9500_inc_data_rdy_users(struct sx9500_data *data)
242{
243 return sx9500_inc_users(data, &data->data_rdy_users,
244 SX9500_REG_IRQ_MSK, SX9500_CONVDONE_IRQ);
245}
246
247static int sx9500_dec_data_rdy_users(struct sx9500_data *data)
248{
249 return sx9500_dec_users(data, &data->data_rdy_users,
250 SX9500_REG_IRQ_MSK, SX9500_CONVDONE_IRQ);
251}
252
253static int sx9500_inc_close_far_users(struct sx9500_data *data)
254{
255 return sx9500_inc_users(data, &data->close_far_users,
256 SX9500_REG_IRQ_MSK,
257 SX9500_CLOSE_IRQ | SX9500_FAR_IRQ);
258}
259
260static int sx9500_dec_close_far_users(struct sx9500_data *data)
261{
262 return sx9500_dec_users(data, &data->close_far_users,
263 SX9500_REG_IRQ_MSK,
264 SX9500_CLOSE_IRQ | SX9500_FAR_IRQ);
265}
266
267static int sx9500_read_prox_data(struct sx9500_data *data,
268 const struct iio_chan_spec *chan,
269 int *val)
270{
271 int ret;
272 __be16 regval;
273
274 ret = regmap_write(data->regmap, SX9500_REG_SENSOR_SEL, chan->channel);
275 if (ret < 0)
276 return ret;
277
278 ret = regmap_bulk_read(data->regmap, SX9500_REG_USE_MSB, ®val, 2);
279 if (ret < 0)
280 return ret;
281
282 *val = be16_to_cpu(regval);
283
284 return IIO_VAL_INT;
285}
286
287
288
289
290
291static int sx9500_wait_for_sample(struct sx9500_data *data)
292{
293 int ret;
294 unsigned int val;
295
296 ret = regmap_read(data->regmap, SX9500_REG_PROX_CTRL0, &val);
297 if (ret < 0)
298 return ret;
299
300 val = (val & SX9500_SCAN_PERIOD_MASK) >> SX9500_SCAN_PERIOD_SHIFT;
301
302 msleep(sx9500_scan_period_table[val]);
303
304 return 0;
305}
306
307static int sx9500_read_proximity(struct sx9500_data *data,
308 const struct iio_chan_spec *chan,
309 int *val)
310{
311 int ret;
312
313 mutex_lock(&data->mutex);
314
315 ret = sx9500_inc_chan_users(data, chan->channel);
316 if (ret < 0)
317 goto out;
318
319 ret = sx9500_inc_data_rdy_users(data);
320 if (ret < 0)
321 goto out_dec_chan;
322
323 mutex_unlock(&data->mutex);
324
325 if (data->client->irq > 0)
326 ret = wait_for_completion_interruptible(&data->completion);
327 else
328 ret = sx9500_wait_for_sample(data);
329
330 mutex_lock(&data->mutex);
331
332 if (ret < 0)
333 goto out_dec_data_rdy;
334
335 ret = sx9500_read_prox_data(data, chan, val);
336 if (ret < 0)
337 goto out_dec_data_rdy;
338
339 ret = sx9500_dec_data_rdy_users(data);
340 if (ret < 0)
341 goto out_dec_chan;
342
343 ret = sx9500_dec_chan_users(data, chan->channel);
344 if (ret < 0)
345 goto out;
346
347 ret = IIO_VAL_INT;
348
349 goto out;
350
351out_dec_data_rdy:
352 sx9500_dec_data_rdy_users(data);
353out_dec_chan:
354 sx9500_dec_chan_users(data, chan->channel);
355out:
356 mutex_unlock(&data->mutex);
357 reinit_completion(&data->completion);
358
359 return ret;
360}
361
362static int sx9500_read_samp_freq(struct sx9500_data *data,
363 int *val, int *val2)
364{
365 int ret;
366 unsigned int regval;
367
368 mutex_lock(&data->mutex);
369 ret = regmap_read(data->regmap, SX9500_REG_PROX_CTRL0, ®val);
370 mutex_unlock(&data->mutex);
371
372 if (ret < 0)
373 return ret;
374
375 regval = (regval & SX9500_SCAN_PERIOD_MASK) >> SX9500_SCAN_PERIOD_SHIFT;
376 *val = sx9500_samp_freq_table[regval].val;
377 *val2 = sx9500_samp_freq_table[regval].val2;
378
379 return IIO_VAL_INT_PLUS_MICRO;
380}
381
382static int sx9500_read_raw(struct iio_dev *indio_dev,
383 const struct iio_chan_spec *chan,
384 int *val, int *val2, long mask)
385{
386 struct sx9500_data *data = iio_priv(indio_dev);
387 int ret;
388
389 switch (chan->type) {
390 case IIO_PROXIMITY:
391 switch (mask) {
392 case IIO_CHAN_INFO_RAW:
393 ret = iio_device_claim_direct_mode(indio_dev);
394 if (ret)
395 return ret;
396 ret = sx9500_read_proximity(data, chan, val);
397 iio_device_release_direct_mode(indio_dev);
398 return ret;
399 case IIO_CHAN_INFO_SAMP_FREQ:
400 return sx9500_read_samp_freq(data, val, val2);
401 default:
402 return -EINVAL;
403 }
404 default:
405 return -EINVAL;
406 }
407}
408
409static int sx9500_set_samp_freq(struct sx9500_data *data,
410 int val, int val2)
411{
412 int i, ret;
413
414 for (i = 0; i < ARRAY_SIZE(sx9500_samp_freq_table); i++)
415 if (val == sx9500_samp_freq_table[i].val &&
416 val2 == sx9500_samp_freq_table[i].val2)
417 break;
418
419 if (i == ARRAY_SIZE(sx9500_samp_freq_table))
420 return -EINVAL;
421
422 mutex_lock(&data->mutex);
423
424 ret = regmap_update_bits(data->regmap, SX9500_REG_PROX_CTRL0,
425 SX9500_SCAN_PERIOD_MASK,
426 i << SX9500_SCAN_PERIOD_SHIFT);
427
428 mutex_unlock(&data->mutex);
429
430 return ret;
431}
432
433static int sx9500_write_raw(struct iio_dev *indio_dev,
434 const struct iio_chan_spec *chan,
435 int val, int val2, long mask)
436{
437 struct sx9500_data *data = iio_priv(indio_dev);
438
439 switch (chan->type) {
440 case IIO_PROXIMITY:
441 switch (mask) {
442 case IIO_CHAN_INFO_SAMP_FREQ:
443 return sx9500_set_samp_freq(data, val, val2);
444 default:
445 return -EINVAL;
446 }
447 default:
448 return -EINVAL;
449 }
450}
451
452static irqreturn_t sx9500_irq_handler(int irq, void *private)
453{
454 struct iio_dev *indio_dev = private;
455 struct sx9500_data *data = iio_priv(indio_dev);
456
457 if (data->trigger_enabled)
458 iio_trigger_poll(data->trig);
459
460
461
462
463
464
465
466 return IRQ_WAKE_THREAD;
467}
468
469static void sx9500_push_events(struct iio_dev *indio_dev)
470{
471 int ret;
472 unsigned int val, chan;
473 struct sx9500_data *data = iio_priv(indio_dev);
474
475 ret = regmap_read(data->regmap, SX9500_REG_STAT, &val);
476 if (ret < 0) {
477 dev_err(&data->client->dev, "i2c transfer error in irq\n");
478 return;
479 }
480
481 val >>= SX9500_PROXSTAT_SHIFT;
482 for (chan = 0; chan < SX9500_NUM_CHANNELS; chan++) {
483 int dir;
484 u64 ev;
485 bool new_prox = val & BIT(chan);
486
487 if (!data->event_enabled[chan])
488 continue;
489 if (new_prox == data->prox_stat[chan])
490
491 continue;
492
493 dir = new_prox ? IIO_EV_DIR_FALLING : IIO_EV_DIR_RISING;
494 ev = IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, chan,
495 IIO_EV_TYPE_THRESH, dir);
496 iio_push_event(indio_dev, ev, iio_get_time_ns(indio_dev));
497 data->prox_stat[chan] = new_prox;
498 }
499}
500
501static irqreturn_t sx9500_irq_thread_handler(int irq, void *private)
502{
503 struct iio_dev *indio_dev = private;
504 struct sx9500_data *data = iio_priv(indio_dev);
505 int ret;
506 unsigned int val;
507
508 mutex_lock(&data->mutex);
509
510 ret = regmap_read(data->regmap, SX9500_REG_IRQ_SRC, &val);
511 if (ret < 0) {
512 dev_err(&data->client->dev, "i2c transfer error in irq\n");
513 goto out;
514 }
515
516 if (val & (SX9500_CLOSE_IRQ | SX9500_FAR_IRQ))
517 sx9500_push_events(indio_dev);
518
519 if (val & SX9500_CONVDONE_IRQ)
520 complete(&data->completion);
521
522out:
523 mutex_unlock(&data->mutex);
524
525 return IRQ_HANDLED;
526}
527
528static int sx9500_read_event_config(struct iio_dev *indio_dev,
529 const struct iio_chan_spec *chan,
530 enum iio_event_type type,
531 enum iio_event_direction dir)
532{
533 struct sx9500_data *data = iio_priv(indio_dev);
534
535 if (chan->type != IIO_PROXIMITY || type != IIO_EV_TYPE_THRESH ||
536 dir != IIO_EV_DIR_EITHER)
537 return -EINVAL;
538
539 return data->event_enabled[chan->channel];
540}
541
542static int sx9500_write_event_config(struct iio_dev *indio_dev,
543 const struct iio_chan_spec *chan,
544 enum iio_event_type type,
545 enum iio_event_direction dir,
546 int state)
547{
548 struct sx9500_data *data = iio_priv(indio_dev);
549 int ret;
550
551 if (chan->type != IIO_PROXIMITY || type != IIO_EV_TYPE_THRESH ||
552 dir != IIO_EV_DIR_EITHER)
553 return -EINVAL;
554
555 mutex_lock(&data->mutex);
556
557 if (state == 1) {
558 ret = sx9500_inc_chan_users(data, chan->channel);
559 if (ret < 0)
560 goto out_unlock;
561 ret = sx9500_inc_close_far_users(data);
562 if (ret < 0)
563 goto out_undo_chan;
564 } else {
565 ret = sx9500_dec_chan_users(data, chan->channel);
566 if (ret < 0)
567 goto out_unlock;
568 ret = sx9500_dec_close_far_users(data);
569 if (ret < 0)
570 goto out_undo_chan;
571 }
572
573 data->event_enabled[chan->channel] = state;
574 goto out_unlock;
575
576out_undo_chan:
577 if (state == 1)
578 sx9500_dec_chan_users(data, chan->channel);
579 else
580 sx9500_inc_chan_users(data, chan->channel);
581out_unlock:
582 mutex_unlock(&data->mutex);
583 return ret;
584}
585
586static int sx9500_update_scan_mode(struct iio_dev *indio_dev,
587 const unsigned long *scan_mask)
588{
589 struct sx9500_data *data = iio_priv(indio_dev);
590
591 mutex_lock(&data->mutex);
592 kfree(data->buffer);
593 data->buffer = kzalloc(indio_dev->scan_bytes, GFP_KERNEL);
594 mutex_unlock(&data->mutex);
595
596 if (data->buffer == NULL)
597 return -ENOMEM;
598
599 return 0;
600}
601
602static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(
603 "2.500000 3.333333 5 6.666666 8.333333 11.111111 16.666666 33.333333");
604
605static struct attribute *sx9500_attributes[] = {
606 &iio_const_attr_sampling_frequency_available.dev_attr.attr,
607 NULL,
608};
609
610static const struct attribute_group sx9500_attribute_group = {
611 .attrs = sx9500_attributes,
612};
613
614static const struct iio_info sx9500_info = {
615 .attrs = &sx9500_attribute_group,
616 .read_raw = &sx9500_read_raw,
617 .write_raw = &sx9500_write_raw,
618 .read_event_config = &sx9500_read_event_config,
619 .write_event_config = &sx9500_write_event_config,
620 .update_scan_mode = &sx9500_update_scan_mode,
621};
622
623static int sx9500_set_trigger_state(struct iio_trigger *trig,
624 bool state)
625{
626 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
627 struct sx9500_data *data = iio_priv(indio_dev);
628 int ret;
629
630 mutex_lock(&data->mutex);
631
632 if (state)
633 ret = sx9500_inc_data_rdy_users(data);
634 else
635 ret = sx9500_dec_data_rdy_users(data);
636 if (ret < 0)
637 goto out;
638
639 data->trigger_enabled = state;
640
641out:
642 mutex_unlock(&data->mutex);
643
644 return ret;
645}
646
647static const struct iio_trigger_ops sx9500_trigger_ops = {
648 .set_trigger_state = sx9500_set_trigger_state,
649};
650
651static irqreturn_t sx9500_trigger_handler(int irq, void *private)
652{
653 struct iio_poll_func *pf = private;
654 struct iio_dev *indio_dev = pf->indio_dev;
655 struct sx9500_data *data = iio_priv(indio_dev);
656 int val, bit, ret, i = 0;
657
658 mutex_lock(&data->mutex);
659
660 for_each_set_bit(bit, indio_dev->active_scan_mask,
661 indio_dev->masklength) {
662 ret = sx9500_read_prox_data(data, &indio_dev->channels[bit],
663 &val);
664 if (ret < 0)
665 goto out;
666
667 data->buffer[i++] = val;
668 }
669
670 iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
671 iio_get_time_ns(indio_dev));
672
673out:
674 mutex_unlock(&data->mutex);
675
676 iio_trigger_notify_done(indio_dev->trig);
677
678 return IRQ_HANDLED;
679}
680
681static int sx9500_buffer_preenable(struct iio_dev *indio_dev)
682{
683 struct sx9500_data *data = iio_priv(indio_dev);
684 int ret = 0, i;
685
686 mutex_lock(&data->mutex);
687
688 for (i = 0; i < SX9500_NUM_CHANNELS; i++)
689 if (test_bit(i, indio_dev->active_scan_mask)) {
690 ret = sx9500_inc_chan_users(data, i);
691 if (ret)
692 break;
693 }
694
695 if (ret)
696 for (i = i - 1; i >= 0; i--)
697 if (test_bit(i, indio_dev->active_scan_mask))
698 sx9500_dec_chan_users(data, i);
699
700 mutex_unlock(&data->mutex);
701
702 return ret;
703}
704
705static int sx9500_buffer_predisable(struct iio_dev *indio_dev)
706{
707 struct sx9500_data *data = iio_priv(indio_dev);
708 int ret = 0, i;
709
710 iio_triggered_buffer_predisable(indio_dev);
711
712 mutex_lock(&data->mutex);
713
714 for (i = 0; i < SX9500_NUM_CHANNELS; i++)
715 if (test_bit(i, indio_dev->active_scan_mask)) {
716 ret = sx9500_dec_chan_users(data, i);
717 if (ret)
718 break;
719 }
720
721 if (ret)
722 for (i = i - 1; i >= 0; i--)
723 if (test_bit(i, indio_dev->active_scan_mask))
724 sx9500_inc_chan_users(data, i);
725
726 mutex_unlock(&data->mutex);
727
728 return ret;
729}
730
731static const struct iio_buffer_setup_ops sx9500_buffer_setup_ops = {
732 .preenable = sx9500_buffer_preenable,
733 .postenable = iio_triggered_buffer_postenable,
734 .predisable = sx9500_buffer_predisable,
735};
736
737struct sx9500_reg_default {
738 u8 reg;
739 u8 def;
740};
741
742static const struct sx9500_reg_default sx9500_default_regs[] = {
743 {
744 .reg = SX9500_REG_PROX_CTRL1,
745
746 .def = 0x43,
747 },
748 {
749 .reg = SX9500_REG_PROX_CTRL2,
750
751 .def = 0x77,
752 },
753 {
754 .reg = SX9500_REG_PROX_CTRL3,
755
756 .def = 0x40,
757 },
758 {
759 .reg = SX9500_REG_PROX_CTRL4,
760
761 .def = 0x30,
762 },
763 {
764 .reg = SX9500_REG_PROX_CTRL5,
765
766
767
768
769 .def = 0x0f,
770 },
771 {
772 .reg = SX9500_REG_PROX_CTRL6,
773
774 .def = 0x0e,
775 },
776 {
777 .reg = SX9500_REG_PROX_CTRL7,
778
779
780
781
782
783 .def = 0x00,
784 },
785 {
786 .reg = SX9500_REG_PROX_CTRL8,
787
788 .def = 0x00,
789 },
790 {
791 .reg = SX9500_REG_PROX_CTRL0,
792
793 .def = 0x00,
794 },
795};
796
797
798static int sx9500_init_compensation(struct iio_dev *indio_dev)
799{
800 struct sx9500_data *data = iio_priv(indio_dev);
801 int i, ret;
802 unsigned int val;
803
804 ret = regmap_update_bits(data->regmap, SX9500_REG_PROX_CTRL0,
805 SX9500_CHAN_MASK, SX9500_CHAN_MASK);
806 if (ret < 0)
807 return ret;
808
809 for (i = 10; i >= 0; i--) {
810 usleep_range(10000, 20000);
811 ret = regmap_read(data->regmap, SX9500_REG_STAT, &val);
812 if (ret < 0)
813 goto out;
814 if (!(val & SX9500_COMPSTAT_MASK))
815 break;
816 }
817
818 if (i < 0) {
819 dev_err(&data->client->dev, "initial compensation timed out");
820 ret = -ETIMEDOUT;
821 }
822
823out:
824 regmap_update_bits(data->regmap, SX9500_REG_PROX_CTRL0,
825 SX9500_CHAN_MASK, 0);
826 return ret;
827}
828
829static int sx9500_init_device(struct iio_dev *indio_dev)
830{
831 struct sx9500_data *data = iio_priv(indio_dev);
832 int ret, i;
833 unsigned int val;
834
835 if (data->gpiod_rst) {
836 gpiod_set_value_cansleep(data->gpiod_rst, 0);
837 usleep_range(1000, 2000);
838 gpiod_set_value_cansleep(data->gpiod_rst, 1);
839 usleep_range(1000, 2000);
840 }
841
842 ret = regmap_write(data->regmap, SX9500_REG_IRQ_MSK, 0);
843 if (ret < 0)
844 return ret;
845
846 ret = regmap_write(data->regmap, SX9500_REG_RESET,
847 SX9500_SOFT_RESET);
848 if (ret < 0)
849 return ret;
850
851 ret = regmap_read(data->regmap, SX9500_REG_IRQ_SRC, &val);
852 if (ret < 0)
853 return ret;
854
855 for (i = 0; i < ARRAY_SIZE(sx9500_default_regs); i++) {
856 ret = regmap_write(data->regmap,
857 sx9500_default_regs[i].reg,
858 sx9500_default_regs[i].def);
859 if (ret < 0)
860 return ret;
861 }
862
863 return sx9500_init_compensation(indio_dev);
864}
865
866static const struct acpi_gpio_params reset_gpios = { 0, 0, false };
867static const struct acpi_gpio_params interrupt_gpios = { 2, 0, false };
868
869static const struct acpi_gpio_mapping acpi_sx9500_gpios[] = {
870 { "reset-gpios", &reset_gpios, 1 },
871
872
873
874
875 { "interrupt-gpios", &interrupt_gpios, 1, ACPI_GPIO_QUIRK_NO_IO_RESTRICTION },
876 { },
877};
878
879static void sx9500_gpio_probe(struct i2c_client *client,
880 struct sx9500_data *data)
881{
882 struct gpio_desc *gpiod_int;
883 struct device *dev;
884 int ret;
885
886 if (!client)
887 return;
888
889 dev = &client->dev;
890
891 ret = devm_acpi_dev_add_driver_gpios(dev, acpi_sx9500_gpios);
892 if (ret)
893 dev_dbg(dev, "Unable to add GPIO mapping table\n");
894
895 if (client->irq <= 0) {
896 gpiod_int = devm_gpiod_get(dev, "interrupt", GPIOD_IN);
897 if (IS_ERR(gpiod_int))
898 dev_err(dev, "gpio get irq failed\n");
899 else
900 client->irq = gpiod_to_irq(gpiod_int);
901 }
902
903 data->gpiod_rst = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
904 if (IS_ERR(data->gpiod_rst)) {
905 dev_warn(dev, "gpio get reset pin failed\n");
906 data->gpiod_rst = NULL;
907 }
908}
909
910static int sx9500_probe(struct i2c_client *client,
911 const struct i2c_device_id *id)
912{
913 int ret;
914 struct iio_dev *indio_dev;
915 struct sx9500_data *data;
916
917 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
918 if (indio_dev == NULL)
919 return -ENOMEM;
920
921 data = iio_priv(indio_dev);
922 data->client = client;
923 mutex_init(&data->mutex);
924 init_completion(&data->completion);
925 data->trigger_enabled = false;
926
927 data->regmap = devm_regmap_init_i2c(client, &sx9500_regmap_config);
928 if (IS_ERR(data->regmap))
929 return PTR_ERR(data->regmap);
930
931 indio_dev->dev.parent = &client->dev;
932 indio_dev->name = SX9500_DRIVER_NAME;
933 indio_dev->channels = sx9500_channels;
934 indio_dev->num_channels = ARRAY_SIZE(sx9500_channels);
935 indio_dev->info = &sx9500_info;
936 indio_dev->modes = INDIO_DIRECT_MODE;
937 i2c_set_clientdata(client, indio_dev);
938
939 sx9500_gpio_probe(client, data);
940
941 ret = sx9500_init_device(indio_dev);
942 if (ret < 0)
943 return ret;
944
945 if (client->irq <= 0)
946 dev_warn(&client->dev, "no valid irq found\n");
947 else {
948 ret = devm_request_threaded_irq(&client->dev, client->irq,
949 sx9500_irq_handler, sx9500_irq_thread_handler,
950 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
951 SX9500_IRQ_NAME, indio_dev);
952 if (ret < 0)
953 return ret;
954
955 data->trig = devm_iio_trigger_alloc(&client->dev,
956 "%s-dev%d", indio_dev->name, indio_dev->id);
957 if (!data->trig)
958 return -ENOMEM;
959
960 data->trig->dev.parent = &client->dev;
961 data->trig->ops = &sx9500_trigger_ops;
962 iio_trigger_set_drvdata(data->trig, indio_dev);
963
964 ret = iio_trigger_register(data->trig);
965 if (ret)
966 return ret;
967 }
968
969 ret = iio_triggered_buffer_setup(indio_dev, NULL,
970 sx9500_trigger_handler,
971 &sx9500_buffer_setup_ops);
972 if (ret < 0)
973 goto out_trigger_unregister;
974
975 ret = iio_device_register(indio_dev);
976 if (ret < 0)
977 goto out_buffer_cleanup;
978
979 return 0;
980
981out_buffer_cleanup:
982 iio_triggered_buffer_cleanup(indio_dev);
983out_trigger_unregister:
984 if (client->irq > 0)
985 iio_trigger_unregister(data->trig);
986
987 return ret;
988}
989
990static int sx9500_remove(struct i2c_client *client)
991{
992 struct iio_dev *indio_dev = i2c_get_clientdata(client);
993 struct sx9500_data *data = iio_priv(indio_dev);
994
995 iio_device_unregister(indio_dev);
996 iio_triggered_buffer_cleanup(indio_dev);
997 if (client->irq > 0)
998 iio_trigger_unregister(data->trig);
999 kfree(data->buffer);
1000
1001 return 0;
1002}
1003
1004#ifdef CONFIG_PM_SLEEP
1005static int sx9500_suspend(struct device *dev)
1006{
1007 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1008 struct sx9500_data *data = iio_priv(indio_dev);
1009 int ret;
1010
1011 mutex_lock(&data->mutex);
1012 ret = regmap_read(data->regmap, SX9500_REG_PROX_CTRL0,
1013 &data->suspend_ctrl0);
1014 if (ret < 0)
1015 goto out;
1016
1017
1018
1019
1020
1021 ret = regmap_write(data->regmap, SX9500_REG_PROX_CTRL0, 0);
1022
1023out:
1024 mutex_unlock(&data->mutex);
1025 return ret;
1026}
1027
1028static int sx9500_resume(struct device *dev)
1029{
1030 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1031 struct sx9500_data *data = iio_priv(indio_dev);
1032 int ret;
1033
1034 mutex_lock(&data->mutex);
1035 ret = regmap_write(data->regmap, SX9500_REG_PROX_CTRL0,
1036 data->suspend_ctrl0);
1037 mutex_unlock(&data->mutex);
1038
1039 return ret;
1040}
1041#endif
1042
1043static const struct dev_pm_ops sx9500_pm_ops = {
1044 SET_SYSTEM_SLEEP_PM_OPS(sx9500_suspend, sx9500_resume)
1045};
1046
1047static const struct acpi_device_id sx9500_acpi_match[] = {
1048 {"SSX9500", 0},
1049 {"SASX9500", 0},
1050 { },
1051};
1052MODULE_DEVICE_TABLE(acpi, sx9500_acpi_match);
1053
1054static const struct of_device_id sx9500_of_match[] = {
1055 { .compatible = "semtech,sx9500", },
1056 { }
1057};
1058MODULE_DEVICE_TABLE(of, sx9500_of_match);
1059
1060static const struct i2c_device_id sx9500_id[] = {
1061 {"sx9500", 0},
1062 { },
1063};
1064MODULE_DEVICE_TABLE(i2c, sx9500_id);
1065
1066static struct i2c_driver sx9500_driver = {
1067 .driver = {
1068 .name = SX9500_DRIVER_NAME,
1069 .acpi_match_table = ACPI_PTR(sx9500_acpi_match),
1070 .of_match_table = of_match_ptr(sx9500_of_match),
1071 .pm = &sx9500_pm_ops,
1072 },
1073 .probe = sx9500_probe,
1074 .remove = sx9500_remove,
1075 .id_table = sx9500_id,
1076};
1077module_i2c_driver(sx9500_driver);
1078
1079MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>");
1080MODULE_DESCRIPTION("Driver for Semtech SX9500 proximity sensor");
1081MODULE_LICENSE("GPL v2");
1082
