xref: /openbmc/linux/drivers/iio/proximity/sx9500.c (revision 92a2c6b2)
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 
22 #include <linux/iio/iio.h>
23 #include <linux/iio/buffer.h>
24 #include <linux/iio/sysfs.h>
25 #include <linux/iio/events.h>
26 #include <linux/iio/trigger.h>
27 #include <linux/iio/triggered_buffer.h>
28 #include <linux/iio/trigger_consumer.h>
29 
30 #define SX9500_DRIVER_NAME		"sx9500"
31 #define SX9500_IRQ_NAME			"sx9500_event"
32 #define SX9500_GPIO_NAME		"sx9500_gpio"
33 
34 /* Register definitions. */
35 #define SX9500_REG_IRQ_SRC		0x00
36 #define SX9500_REG_STAT			0x01
37 #define SX9500_REG_IRQ_MSK		0x03
38 
39 #define SX9500_REG_PROX_CTRL0		0x06
40 #define SX9500_REG_PROX_CTRL1		0x07
41 #define SX9500_REG_PROX_CTRL2		0x08
42 #define SX9500_REG_PROX_CTRL3		0x09
43 #define SX9500_REG_PROX_CTRL4		0x0a
44 #define SX9500_REG_PROX_CTRL5		0x0b
45 #define SX9500_REG_PROX_CTRL6		0x0c
46 #define SX9500_REG_PROX_CTRL7		0x0d
47 #define SX9500_REG_PROX_CTRL8		0x0e
48 
49 #define SX9500_REG_SENSOR_SEL		0x20
50 #define SX9500_REG_USE_MSB		0x21
51 #define SX9500_REG_USE_LSB		0x22
52 #define SX9500_REG_AVG_MSB		0x23
53 #define SX9500_REG_AVG_LSB		0x24
54 #define SX9500_REG_DIFF_MSB		0x25
55 #define SX9500_REG_DIFF_LSB		0x26
56 #define SX9500_REG_OFFSET_MSB		0x27
57 #define SX9500_REG_OFFSET_LSB		0x28
58 
59 #define SX9500_REG_RESET		0x7f
60 
61 /* Write this to REG_RESET to do a soft reset. */
62 #define SX9500_SOFT_RESET		0xde
63 
64 #define SX9500_SCAN_PERIOD_MASK		GENMASK(6, 4)
65 #define SX9500_SCAN_PERIOD_SHIFT	4
66 
67 /*
68  * These serve for identifying IRQ source in the IRQ_SRC register, and
69  * also for masking the IRQs in the IRQ_MSK register.
70  */
71 #define SX9500_CLOSE_IRQ		BIT(6)
72 #define SX9500_FAR_IRQ			BIT(5)
73 #define SX9500_CONVDONE_IRQ		BIT(3)
74 
75 #define SX9500_PROXSTAT_SHIFT		4
76 
77 #define SX9500_NUM_CHANNELS		4
78 
79 struct sx9500_data {
80 	struct mutex mutex;
81 	struct i2c_client *client;
82 	struct iio_trigger *trig;
83 	struct regmap *regmap;
84 	/*
85 	 * Last reading of the proximity status for each channel.  We
86 	 * only send an event to user space when this changes.
87 	 */
88 	bool prox_stat[SX9500_NUM_CHANNELS];
89 	bool event_enabled[SX9500_NUM_CHANNELS];
90 	bool trigger_enabled;
91 	u16 *buffer;
92 };
93 
94 static const struct iio_event_spec sx9500_events[] = {
95 	{
96 		.type = IIO_EV_TYPE_THRESH,
97 		.dir = IIO_EV_DIR_EITHER,
98 		.mask_separate = BIT(IIO_EV_INFO_ENABLE),
99 	},
100 };
101 
102 #define SX9500_CHANNEL(idx)					\
103 	{							\
104 		.type = IIO_PROXIMITY,				\
105 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),	\
106 		.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
107 		.indexed = 1,					\
108 		.channel = idx,					\
109 		.event_spec = sx9500_events,			\
110 		.num_event_specs = ARRAY_SIZE(sx9500_events),	\
111 		.scan_index = idx,				\
112 		.scan_type = {					\
113 			.sign = 'u',				\
114 			.realbits = 16,				\
115 			.storagebits = 16,			\
116 			.shift = 0,				\
117 		},						\
118 	}
119 
120 static const struct iio_chan_spec sx9500_channels[] = {
121 	SX9500_CHANNEL(0),
122 	SX9500_CHANNEL(1),
123 	SX9500_CHANNEL(2),
124 	SX9500_CHANNEL(3),
125 	IIO_CHAN_SOFT_TIMESTAMP(4),
126 };
127 
128 static const struct {
129 	int val;
130 	int val2;
131 } sx9500_samp_freq_table[] = {
132 	{33, 333333},
133 	{16, 666666},
134 	{11, 111111},
135 	{8, 333333},
136 	{6, 666666},
137 	{5, 0},
138 	{3, 333333},
139 	{2, 500000},
140 };
141 
142 static const struct regmap_range sx9500_writable_reg_ranges[] = {
143 	regmap_reg_range(SX9500_REG_IRQ_MSK, SX9500_REG_IRQ_MSK),
144 	regmap_reg_range(SX9500_REG_PROX_CTRL0, SX9500_REG_PROX_CTRL8),
145 	regmap_reg_range(SX9500_REG_SENSOR_SEL, SX9500_REG_SENSOR_SEL),
146 	regmap_reg_range(SX9500_REG_OFFSET_MSB, SX9500_REG_OFFSET_LSB),
147 	regmap_reg_range(SX9500_REG_RESET, SX9500_REG_RESET),
148 };
149 
150 static const struct regmap_access_table sx9500_writeable_regs = {
151 	.yes_ranges = sx9500_writable_reg_ranges,
152 	.n_yes_ranges = ARRAY_SIZE(sx9500_writable_reg_ranges),
153 };
154 
155 /*
156  * All allocated registers are readable, so we just list unallocated
157  * ones.
158  */
159 static const struct regmap_range sx9500_non_readable_reg_ranges[] = {
160 	regmap_reg_range(SX9500_REG_STAT + 1, SX9500_REG_STAT + 1),
161 	regmap_reg_range(SX9500_REG_IRQ_MSK + 1, SX9500_REG_PROX_CTRL0 - 1),
162 	regmap_reg_range(SX9500_REG_PROX_CTRL8 + 1, SX9500_REG_SENSOR_SEL - 1),
163 	regmap_reg_range(SX9500_REG_OFFSET_LSB + 1, SX9500_REG_RESET - 1),
164 };
165 
166 static const struct regmap_access_table sx9500_readable_regs = {
167 	.no_ranges = sx9500_non_readable_reg_ranges,
168 	.n_no_ranges = ARRAY_SIZE(sx9500_non_readable_reg_ranges),
169 };
170 
171 static const struct regmap_range sx9500_volatile_reg_ranges[] = {
172 	regmap_reg_range(SX9500_REG_IRQ_SRC, SX9500_REG_STAT),
173 	regmap_reg_range(SX9500_REG_USE_MSB, SX9500_REG_OFFSET_LSB),
174 	regmap_reg_range(SX9500_REG_RESET, SX9500_REG_RESET),
175 };
176 
177 static const struct regmap_access_table sx9500_volatile_regs = {
178 	.yes_ranges = sx9500_volatile_reg_ranges,
179 	.n_yes_ranges = ARRAY_SIZE(sx9500_volatile_reg_ranges),
180 };
181 
182 static const struct regmap_config sx9500_regmap_config = {
183 	.reg_bits = 8,
184 	.val_bits = 8,
185 
186 	.max_register = SX9500_REG_RESET,
187 	.cache_type = REGCACHE_RBTREE,
188 
189 	.wr_table = &sx9500_writeable_regs,
190 	.rd_table = &sx9500_readable_regs,
191 	.volatile_table = &sx9500_volatile_regs,
192 };
193 
194 static int sx9500_read_proximity(struct sx9500_data *data,
195 				 const struct iio_chan_spec *chan,
196 				 int *val)
197 {
198 	int ret;
199 	__be16 regval;
200 
201 	ret = regmap_write(data->regmap, SX9500_REG_SENSOR_SEL, chan->channel);
202 	if (ret < 0)
203 		return ret;
204 
205 	ret = regmap_bulk_read(data->regmap, SX9500_REG_USE_MSB, &regval, 2);
206 	if (ret < 0)
207 		return ret;
208 
209 	*val = 32767 - (s16)be16_to_cpu(regval);
210 
211 	return IIO_VAL_INT;
212 }
213 
214 static int sx9500_read_samp_freq(struct sx9500_data *data,
215 				 int *val, int *val2)
216 {
217 	int ret;
218 	unsigned int regval;
219 
220 	mutex_lock(&data->mutex);
221 	ret = regmap_read(data->regmap, SX9500_REG_PROX_CTRL0, &regval);
222 	mutex_unlock(&data->mutex);
223 
224 	if (ret < 0)
225 		return ret;
226 
227 	regval = (regval & SX9500_SCAN_PERIOD_MASK) >> SX9500_SCAN_PERIOD_SHIFT;
228 	*val = sx9500_samp_freq_table[regval].val;
229 	*val2 = sx9500_samp_freq_table[regval].val2;
230 
231 	return IIO_VAL_INT_PLUS_MICRO;
232 }
233 
234 static int sx9500_read_raw(struct iio_dev *indio_dev,
235 			   const struct iio_chan_spec *chan,
236 			   int *val, int *val2, long mask)
237 {
238 	struct sx9500_data *data = iio_priv(indio_dev);
239 	int ret;
240 
241 	switch (chan->type) {
242 	case IIO_PROXIMITY:
243 		switch (mask) {
244 		case IIO_CHAN_INFO_RAW:
245 			if (iio_buffer_enabled(indio_dev))
246 				return -EBUSY;
247 			mutex_lock(&data->mutex);
248 			ret = sx9500_read_proximity(data, chan, val);
249 			mutex_unlock(&data->mutex);
250 			return ret;
251 		case IIO_CHAN_INFO_SAMP_FREQ:
252 			return sx9500_read_samp_freq(data, val, val2);
253 		default:
254 			return -EINVAL;
255 		}
256 	default:
257 		return -EINVAL;
258 	}
259 }
260 
261 static int sx9500_set_samp_freq(struct sx9500_data *data,
262 				int val, int val2)
263 {
264 	int i, ret;
265 
266 	for (i = 0; i < ARRAY_SIZE(sx9500_samp_freq_table); i++)
267 		if (val == sx9500_samp_freq_table[i].val &&
268 		    val2 == sx9500_samp_freq_table[i].val2)
269 			break;
270 
271 	if (i == ARRAY_SIZE(sx9500_samp_freq_table))
272 		return -EINVAL;
273 
274 	mutex_lock(&data->mutex);
275 
276 	ret = regmap_update_bits(data->regmap, SX9500_REG_PROX_CTRL0,
277 				 SX9500_SCAN_PERIOD_MASK,
278 				 i << SX9500_SCAN_PERIOD_SHIFT);
279 
280 	mutex_unlock(&data->mutex);
281 
282 	return ret;
283 }
284 
285 static int sx9500_write_raw(struct iio_dev *indio_dev,
286 			    const struct iio_chan_spec *chan,
287 			    int val, int val2, long mask)
288 {
289 	struct sx9500_data *data = iio_priv(indio_dev);
290 
291 	switch (chan->type) {
292 	case IIO_PROXIMITY:
293 		switch (mask) {
294 		case IIO_CHAN_INFO_SAMP_FREQ:
295 			return sx9500_set_samp_freq(data, val, val2);
296 		default:
297 			return -EINVAL;
298 		}
299 	default:
300 		return -EINVAL;
301 	}
302 }
303 
304 static irqreturn_t sx9500_irq_handler(int irq, void *private)
305 {
306 	struct iio_dev *indio_dev = private;
307 	struct sx9500_data *data = iio_priv(indio_dev);
308 
309 	if (data->trigger_enabled)
310 		iio_trigger_poll(data->trig);
311 
312 	/*
313 	 * Even if no event is enabled, we need to wake the thread to
314 	 * clear the interrupt state by reading SX9500_REG_IRQ_SRC.  It
315 	 * is not possible to do that here because regmap_read takes a
316 	 * mutex.
317 	 */
318 	return IRQ_WAKE_THREAD;
319 }
320 
321 static irqreturn_t sx9500_irq_thread_handler(int irq, void *private)
322 {
323 	struct iio_dev *indio_dev = private;
324 	struct sx9500_data *data = iio_priv(indio_dev);
325 	int ret;
326 	unsigned int val, chan;
327 
328 	mutex_lock(&data->mutex);
329 
330 	ret = regmap_read(data->regmap, SX9500_REG_IRQ_SRC, &val);
331 	if (ret < 0) {
332 		dev_err(&data->client->dev, "i2c transfer error in irq\n");
333 		goto out;
334 	}
335 
336 	if (!(val & (SX9500_CLOSE_IRQ | SX9500_FAR_IRQ)))
337 		goto out;
338 
339 	ret = regmap_read(data->regmap, SX9500_REG_STAT, &val);
340 	if (ret < 0) {
341 		dev_err(&data->client->dev, "i2c transfer error in irq\n");
342 		goto out;
343 	}
344 
345 	val >>= SX9500_PROXSTAT_SHIFT;
346 	for (chan = 0; chan < SX9500_NUM_CHANNELS; chan++) {
347 		int dir;
348 		u64 ev;
349 		bool new_prox = val & BIT(chan);
350 
351 		if (!data->event_enabled[chan])
352 			continue;
353 		if (new_prox == data->prox_stat[chan])
354 			/* No change on this channel. */
355 			continue;
356 
357 		dir = new_prox ? IIO_EV_DIR_FALLING :
358 			IIO_EV_DIR_RISING;
359 		ev = IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY,
360 					  chan,
361 					  IIO_EV_TYPE_THRESH,
362 					  dir);
363 		iio_push_event(indio_dev, ev, iio_get_time_ns());
364 		data->prox_stat[chan] = new_prox;
365 	}
366 
367 out:
368 	mutex_unlock(&data->mutex);
369 
370 	return IRQ_HANDLED;
371 }
372 
373 static int sx9500_read_event_config(struct iio_dev *indio_dev,
374 				    const struct iio_chan_spec *chan,
375 				    enum iio_event_type type,
376 				    enum iio_event_direction dir)
377 {
378 	struct sx9500_data *data = iio_priv(indio_dev);
379 
380 	if (chan->type != IIO_PROXIMITY || type != IIO_EV_TYPE_THRESH ||
381 	    dir != IIO_EV_DIR_EITHER)
382 		return -EINVAL;
383 
384 	return data->event_enabled[chan->channel];
385 }
386 
387 static int sx9500_write_event_config(struct iio_dev *indio_dev,
388 				     const struct iio_chan_spec *chan,
389 				     enum iio_event_type type,
390 				     enum iio_event_direction dir,
391 				     int state)
392 {
393 	struct sx9500_data *data = iio_priv(indio_dev);
394 	int ret, i;
395 	bool any_active = false;
396 	unsigned int irqmask;
397 
398 	if (chan->type != IIO_PROXIMITY || type != IIO_EV_TYPE_THRESH ||
399 	    dir != IIO_EV_DIR_EITHER)
400 		return -EINVAL;
401 
402 	mutex_lock(&data->mutex);
403 
404 	data->event_enabled[chan->channel] = state;
405 
406 	for (i = 0; i < SX9500_NUM_CHANNELS; i++)
407 		if (data->event_enabled[i]) {
408 			any_active = true;
409 			break;
410 		}
411 
412 	irqmask = SX9500_CLOSE_IRQ | SX9500_FAR_IRQ;
413 	if (any_active)
414 		ret = regmap_update_bits(data->regmap, SX9500_REG_IRQ_MSK,
415 					 irqmask, irqmask);
416 	else
417 		ret = regmap_update_bits(data->regmap, SX9500_REG_IRQ_MSK,
418 					 irqmask, 0);
419 
420 	mutex_unlock(&data->mutex);
421 
422 	return ret;
423 }
424 
425 static int sx9500_update_scan_mode(struct iio_dev *indio_dev,
426 				   const unsigned long *scan_mask)
427 {
428 	struct sx9500_data *data = iio_priv(indio_dev);
429 
430 	mutex_lock(&data->mutex);
431 	kfree(data->buffer);
432 	data->buffer = kzalloc(indio_dev->scan_bytes, GFP_KERNEL);
433 	mutex_unlock(&data->mutex);
434 
435 	if (data->buffer == NULL)
436 		return -ENOMEM;
437 
438 	return 0;
439 }
440 
441 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(
442 	"2.500000 3.333333 5 6.666666 8.333333 11.111111 16.666666 33.333333");
443 
444 static struct attribute *sx9500_attributes[] = {
445 	&iio_const_attr_sampling_frequency_available.dev_attr.attr,
446 	NULL,
447 };
448 
449 static const struct attribute_group sx9500_attribute_group = {
450 	.attrs = sx9500_attributes,
451 };
452 
453 static const struct iio_info sx9500_info = {
454 	.driver_module = THIS_MODULE,
455 	.attrs = &sx9500_attribute_group,
456 	.read_raw = &sx9500_read_raw,
457 	.write_raw = &sx9500_write_raw,
458 	.read_event_config = &sx9500_read_event_config,
459 	.write_event_config = &sx9500_write_event_config,
460 	.update_scan_mode = &sx9500_update_scan_mode,
461 };
462 
463 static int sx9500_set_trigger_state(struct iio_trigger *trig,
464 				    bool state)
465 {
466 	struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
467 	struct sx9500_data *data = iio_priv(indio_dev);
468 	int ret;
469 
470 	mutex_lock(&data->mutex);
471 
472 	ret = regmap_update_bits(data->regmap, SX9500_REG_IRQ_MSK,
473 				 SX9500_CONVDONE_IRQ,
474 				 state ? SX9500_CONVDONE_IRQ : 0);
475 	if (ret == 0)
476 		data->trigger_enabled = state;
477 
478 	mutex_unlock(&data->mutex);
479 
480 	return ret;
481 }
482 
483 static const struct iio_trigger_ops sx9500_trigger_ops = {
484 	.set_trigger_state = sx9500_set_trigger_state,
485 	.owner = THIS_MODULE,
486 };
487 
488 static irqreturn_t sx9500_trigger_handler(int irq, void *private)
489 {
490 	struct iio_poll_func *pf = private;
491 	struct iio_dev *indio_dev = pf->indio_dev;
492 	struct sx9500_data *data = iio_priv(indio_dev);
493 	int val, bit, ret, i = 0;
494 
495 	mutex_lock(&data->mutex);
496 
497 	for_each_set_bit(bit, indio_dev->buffer->scan_mask,
498 			 indio_dev->masklength) {
499 		ret = sx9500_read_proximity(data, &indio_dev->channels[bit],
500 					    &val);
501 		if (ret < 0)
502 			goto out;
503 
504 		data->buffer[i++] = val;
505 	}
506 
507 	iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
508 					   iio_get_time_ns());
509 
510 out:
511 	mutex_unlock(&data->mutex);
512 
513 	iio_trigger_notify_done(indio_dev->trig);
514 
515 	return IRQ_HANDLED;
516 }
517 
518 struct sx9500_reg_default {
519 	u8 reg;
520 	u8 def;
521 };
522 
523 static const struct sx9500_reg_default sx9500_default_regs[] = {
524 	{
525 		.reg = SX9500_REG_PROX_CTRL1,
526 		/* Shield enabled, small range. */
527 		.def = 0x43,
528 	},
529 	{
530 		.reg = SX9500_REG_PROX_CTRL2,
531 		/* x8 gain, 167kHz frequency, finest resolution. */
532 		.def = 0x77,
533 	},
534 	{
535 		.reg = SX9500_REG_PROX_CTRL3,
536 		/* Doze enabled, 2x scan period doze, no raw filter. */
537 		.def = 0x40,
538 	},
539 	{
540 		.reg = SX9500_REG_PROX_CTRL4,
541 		/* Average threshold. */
542 		.def = 0x30,
543 	},
544 	{
545 		.reg = SX9500_REG_PROX_CTRL5,
546 		/*
547 		 * Debouncer off, lowest average negative filter,
548 		 * highest average postive filter.
549 		 */
550 		.def = 0x0f,
551 	},
552 	{
553 		.reg = SX9500_REG_PROX_CTRL6,
554 		/* Proximity detection threshold: 280 */
555 		.def = 0x0e,
556 	},
557 	{
558 		.reg = SX9500_REG_PROX_CTRL7,
559 		/*
560 		 * No automatic compensation, compensate each pin
561 		 * independently, proximity hysteresis: 32, close
562 		 * debouncer off, far debouncer off.
563 		 */
564 		.def = 0x00,
565 	},
566 	{
567 		.reg = SX9500_REG_PROX_CTRL8,
568 		/* No stuck timeout, no periodic compensation. */
569 		.def = 0x00,
570 	},
571 	{
572 		.reg = SX9500_REG_PROX_CTRL0,
573 		/* Scan period: 30ms, all sensors enabled. */
574 		.def = 0x0f,
575 	},
576 };
577 
578 static int sx9500_init_device(struct iio_dev *indio_dev)
579 {
580 	struct sx9500_data *data = iio_priv(indio_dev);
581 	int ret, i;
582 	unsigned int val;
583 
584 	ret = regmap_write(data->regmap, SX9500_REG_IRQ_MSK, 0);
585 	if (ret < 0)
586 		return ret;
587 
588 	ret = regmap_write(data->regmap, SX9500_REG_RESET,
589 			   SX9500_SOFT_RESET);
590 	if (ret < 0)
591 		return ret;
592 
593 	ret = regmap_read(data->regmap, SX9500_REG_IRQ_SRC, &val);
594 	if (ret < 0)
595 		return ret;
596 
597 	for (i = 0; i < ARRAY_SIZE(sx9500_default_regs); i++) {
598 		ret = regmap_write(data->regmap,
599 				   sx9500_default_regs[i].reg,
600 				   sx9500_default_regs[i].def);
601 		if (ret < 0)
602 			return ret;
603 	}
604 
605 	return 0;
606 }
607 
608 static int sx9500_gpio_probe(struct i2c_client *client,
609 			     struct sx9500_data *data)
610 {
611 	struct device *dev;
612 	struct gpio_desc *gpio;
613 	int ret;
614 
615 	if (!client)
616 		return -EINVAL;
617 
618 	dev = &client->dev;
619 
620 	/* data ready gpio interrupt pin */
621 	gpio = devm_gpiod_get_index(dev, SX9500_GPIO_NAME, 0);
622 	if (IS_ERR(gpio)) {
623 		dev_err(dev, "acpi gpio get index failed\n");
624 		return PTR_ERR(gpio);
625 	}
626 
627 	ret = gpiod_direction_input(gpio);
628 	if (ret)
629 		return ret;
630 
631 	ret = gpiod_to_irq(gpio);
632 
633 	dev_dbg(dev, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio), ret);
634 
635 	return ret;
636 }
637 
638 static int sx9500_probe(struct i2c_client *client,
639 			const struct i2c_device_id *id)
640 {
641 	int ret;
642 	struct iio_dev *indio_dev;
643 	struct sx9500_data *data;
644 
645 	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
646 	if (indio_dev == NULL)
647 		return -ENOMEM;
648 
649 	data = iio_priv(indio_dev);
650 	data->client = client;
651 	mutex_init(&data->mutex);
652 	data->trigger_enabled = false;
653 
654 	data->regmap = devm_regmap_init_i2c(client, &sx9500_regmap_config);
655 	if (IS_ERR(data->regmap))
656 		return PTR_ERR(data->regmap);
657 
658 	sx9500_init_device(indio_dev);
659 
660 	indio_dev->dev.parent = &client->dev;
661 	indio_dev->name = SX9500_DRIVER_NAME;
662 	indio_dev->channels = sx9500_channels;
663 	indio_dev->num_channels = ARRAY_SIZE(sx9500_channels);
664 	indio_dev->info = &sx9500_info;
665 	indio_dev->modes = INDIO_DIRECT_MODE;
666 	i2c_set_clientdata(client, indio_dev);
667 
668 	if (client->irq <= 0)
669 		client->irq = sx9500_gpio_probe(client, data);
670 
671 	if (client->irq > 0) {
672 		ret = devm_request_threaded_irq(&client->dev, client->irq,
673 				sx9500_irq_handler, sx9500_irq_thread_handler,
674 				IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
675 				SX9500_IRQ_NAME, indio_dev);
676 		if (ret < 0)
677 			return ret;
678 
679 		data->trig = devm_iio_trigger_alloc(&client->dev,
680 				"%s-dev%d", indio_dev->name, indio_dev->id);
681 		if (!data->trig)
682 			return -ENOMEM;
683 
684 		data->trig->dev.parent = &client->dev;
685 		data->trig->ops = &sx9500_trigger_ops;
686 		iio_trigger_set_drvdata(data->trig, indio_dev);
687 
688 		ret = iio_trigger_register(data->trig);
689 		if (ret)
690 			return ret;
691 	}
692 
693 	ret = iio_triggered_buffer_setup(indio_dev, NULL,
694 					 sx9500_trigger_handler, NULL);
695 	if (ret < 0)
696 		goto out_trigger_unregister;
697 
698 	ret = iio_device_register(indio_dev);
699 	if (ret < 0)
700 		goto out_buffer_cleanup;
701 
702 	return 0;
703 
704 out_buffer_cleanup:
705 	iio_triggered_buffer_cleanup(indio_dev);
706 out_trigger_unregister:
707 	if (client->irq > 0)
708 		iio_trigger_unregister(data->trig);
709 
710 	return ret;
711 }
712 
713 static int sx9500_remove(struct i2c_client *client)
714 {
715 	struct iio_dev *indio_dev = i2c_get_clientdata(client);
716 	struct sx9500_data *data = iio_priv(indio_dev);
717 
718 	iio_device_unregister(indio_dev);
719 	iio_triggered_buffer_cleanup(indio_dev);
720 	if (client->irq > 0)
721 		iio_trigger_unregister(data->trig);
722 	kfree(data->buffer);
723 
724 	return 0;
725 }
726 
727 static const struct acpi_device_id sx9500_acpi_match[] = {
728 	{"SSX9500", 0},
729 	{ },
730 };
731 MODULE_DEVICE_TABLE(acpi, sx9500_acpi_match);
732 
733 static const struct i2c_device_id sx9500_id[] = {
734 	{"sx9500", 0},
735 	{}
736 };
737 MODULE_DEVICE_TABLE(i2c, sx9500_id);
738 
739 static struct i2c_driver sx9500_driver = {
740 	.driver = {
741 		.name	= SX9500_DRIVER_NAME,
742 		.acpi_match_table = ACPI_PTR(sx9500_acpi_match),
743 	},
744 	.probe		= sx9500_probe,
745 	.remove		= sx9500_remove,
746 	.id_table	= sx9500_id,
747 };
748 module_i2c_driver(sx9500_driver);
749 
750 MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>");
751 MODULE_DESCRIPTION("Driver for Semtech SX9500 proximity sensor");
752 MODULE_LICENSE("GPL v2");
753