projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
MAINTAINERS: Add phy-miphy28lp.c and phy-miphy365x.c to ARCH/STI architecture
[deliverable/linux.git] / drivers / iio / proximity / sx9500.c
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");
Linux kernel - Deliverables
This page took 0.046 seconds and 5 git commands to generate.