xref: /openbmc/linux/drivers/iio/proximity/sx9500.c (revision 7cf15f42)
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 
sx9500_inc_users(struct sx9500_data * data,int * counter,unsigned int reg,unsigned int bitmask)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 
sx9500_dec_users(struct sx9500_data * data,int * counter,unsigned int reg,unsigned int bitmask)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 
sx9500_inc_chan_users(struct sx9500_data * data,int chan)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 
sx9500_dec_chan_users(struct sx9500_data * data,int chan)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 
sx9500_inc_data_rdy_users(struct sx9500_data * data)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 
sx9500_dec_data_rdy_users(struct sx9500_data * data)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 
sx9500_inc_close_far_users(struct sx9500_data * data)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 
sx9500_dec_close_far_users(struct sx9500_data * data)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 
sx9500_read_prox_data(struct sx9500_data * data,const struct iio_chan_spec * chan,int * val)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  */
sx9500_wait_for_sample(struct sx9500_data * data)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 
sx9500_read_proximity(struct sx9500_data * data,const struct iio_chan_spec * chan,int * val)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 
sx9500_read_samp_freq(struct sx9500_data * data,int * val,int * val2)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 
sx9500_read_raw(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,int * val,int * val2,long mask)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 
sx9500_set_samp_freq(struct sx9500_data * data,int val,int val2)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 
sx9500_write_raw(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,int val,int val2,long mask)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 
sx9500_irq_handler(int irq,void * private)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 
sx9500_push_events(struct iio_dev * indio_dev)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 
sx9500_irq_thread_handler(int irq,void * private)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 
sx9500_read_event_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir)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 
sx9500_write_event_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,int state)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 
sx9500_update_scan_mode(struct iio_dev * indio_dev,const unsigned long * scan_mask)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 
sx9500_set_trigger_state(struct iio_trigger * trig,bool state)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 
sx9500_trigger_handler(int irq,void * private)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 
sx9500_buffer_postenable(struct iio_dev * indio_dev)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, 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 
sx9500_buffer_predisable(struct iio_dev * indio_dev)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, 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, i);
720 
721 	mutex_unlock(&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. */
sx9500_init_compensation(struct iio_dev * indio_dev)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(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(10000, 20000);
805 		ret = regmap_read(data->regmap, SX9500_REG_STAT, &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(data->regmap, SX9500_REG_PROX_CTRL0,
819 			   SX9500_CHAN_MASK, 0);
820 	return ret;
821 }
822 
sx9500_init_device(struct iio_dev * indio_dev)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(data->gpiod_rst, 0);
831 		usleep_range(1000, 2000);
832 		gpiod_set_value_cansleep(data->gpiod_rst, 1);
833 		usleep_range(1000, 2000);
834 	}
835 
836 	ret = regmap_write(data->regmap, SX9500_REG_IRQ_MSK, 0);
837 	if (ret < 0)
838 		return ret;
839 
840 	ret = regmap_write(data->regmap, SX9500_REG_RESET,
841 			   SX9500_SOFT_RESET);
842 	if (ret < 0)
843 		return ret;
844 
845 	ret = regmap_read(data->regmap, SX9500_REG_IRQ_SRC, &val);
846 	if (ret < 0)
847 		return ret;
848 
849 	for (i = 0; i < ARRAY_SIZE(sx9500_default_regs); i++) {
850 		ret = regmap_write(data->regmap,
851 				   sx9500_default_regs[i].reg,
852 				   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 
sx9500_gpio_probe(struct i2c_client * client,struct sx9500_data * data)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, 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, "interrupt", GPIOD_IN);
891 		if (IS_ERR(gpiod_int))
892 			dev_err(dev, "gpio get irq failed\n");
893 		else
894 			client->irq = gpiod_to_irq(gpiod_int);
895 	}
896 
897 	data->gpiod_rst = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
898 	if (IS_ERR(data->gpiod_rst)) {
899 		dev_warn(dev, "gpio get reset pin failed\n");
900 		data->gpiod_rst = NULL;
901 	}
902 }
903 
sx9500_probe(struct i2c_client * client)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(&client->dev, 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(&data->completion);
918 	data->trigger_enabled = false;
919 
920 	data->regmap = devm_regmap_init_i2c(client, &sx9500_regmap_config);
921 	if (IS_ERR(data->regmap))
922 		return PTR_ERR(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, 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(&client->dev, client->irq,
941 				sx9500_irq_handler, sx9500_irq_thread_handler,
942 				IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
943 				SX9500_IRQ_NAME, 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(data->trig, indio_dev);
954 
955 		ret = iio_trigger_register(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(data->trig);
977 
978 	return ret;
979 }
980 
sx9500_remove(struct i2c_client * client)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(data->trig);
990 	kfree(data->buffer);
991 }
992 
sx9500_suspend(struct device * dev)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(data->regmap, SX9500_REG_PROX_CTRL0,
1001 			  &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(data->regmap, SX9500_REG_PROX_CTRL0, 0);
1010 
1011 out:
1012 	mutex_unlock(&data->mutex);
1013 	return ret;
1014 }
1015 
sx9500_resume(struct device * dev)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(data->regmap, SX9500_REG_PROX_CTRL0,
1024 			   data->suspend_ctrl0);
1025 	mutex_unlock(&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