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