1 /*
2 * AD7150 capacitive sensor driver supporting AD7150/1/6
3 *
4 * Copyright 2010-2011 Analog Devices Inc.
5 *
6 * Licensed under the GPL-2 or later.
7 */
8
9 #include <linux/interrupt.h>
10 #include <linux/device.h>
11 #include <linux/kernel.h>
12 #include <linux/slab.h>
13 #include <linux/i2c.h>
14 #include <linux/module.h>
15
16 #include "../iio.h"
17 #include "../sysfs.h"
18 #include "../events.h"
19 /*
20 * AD7150 registers definition
21 */
22
23 #define AD7150_STATUS 0
24 #define AD7150_STATUS_OUT1 (1 << 3)
25 #define AD7150_STATUS_OUT2 (1 << 5)
26 #define AD7150_CH1_DATA_HIGH 1
27 #define AD7150_CH2_DATA_HIGH 3
28 #define AD7150_CH1_AVG_HIGH 5
29 #define AD7150_CH2_AVG_HIGH 7
30 #define AD7150_CH1_SENSITIVITY 9
31 #define AD7150_CH1_THR_HOLD_H 9
32 #define AD7150_CH1_TIMEOUT 10
33 #define AD7150_CH1_SETUP 11
34 #define AD7150_CH2_SENSITIVITY 12
35 #define AD7150_CH2_THR_HOLD_H 12
36 #define AD7150_CH2_TIMEOUT 13
37 #define AD7150_CH2_SETUP 14
38 #define AD7150_CFG 15
39 #define AD7150_CFG_FIX (1 << 7)
40 #define AD7150_PD_TIMER 16
41 #define AD7150_CH1_CAPDAC 17
42 #define AD7150_CH2_CAPDAC 18
43 #define AD7150_SN3 19
44 #define AD7150_SN2 20
45 #define AD7150_SN1 21
46 #define AD7150_SN0 22
47 #define AD7150_ID 23
48
49 /**
50 * struct ad7150_chip_info - instance specific chip data
51 * @client: i2c client for this device
52 * @current_event: device always has one type of event enabled.
53 * This element stores the event code of the current one.
54 * @threshold: thresholds for simple capacitance value events
55 * @thresh_sensitivity: threshold for simple capacitance offset
56 * from 'average' value.
57 * @mag_sensitity: threshold for magnitude of capacitance offset from
58 * from 'average' value.
59 * @thresh_timeout: a timeout, in samples from the moment an
60 * adaptive threshold event occurs to when the average
61 * value jumps to current value.
62 * @mag_timeout: a timeout, in sample from the moment an
63 * adaptive magnitude event occurs to when the average
64 * value jumps to the current value.
65 * @old_state: store state from previous event, allowing confirmation
66 * of new condition.
67 * @conversion_mode: the current conversion mode.
68 * @state_lock: ensure consistent state of this structure wrt the
69 * hardware.
70 */
71 struct ad7150_chip_info {
72 struct i2c_client *client;
73 u64 current_event;
74 u16 threshold[2][2];
75 u8 thresh_sensitivity[2][2];
76 u8 mag_sensitivity[2][2];
77 u8 thresh_timeout[2][2];
78 u8 mag_timeout[2][2];
79 int old_state;
80 char *conversion_mode;
81 struct mutex state_lock;
82 };
83
84 /*
85 * sysfs nodes
86 */
87
88 static const u8 ad7150_addresses[][6] = {
89 { AD7150_CH1_DATA_HIGH, AD7150_CH1_AVG_HIGH,
90 AD7150_CH1_SETUP, AD7150_CH1_THR_HOLD_H,
91 AD7150_CH1_SENSITIVITY, AD7150_CH1_TIMEOUT },
92 { AD7150_CH2_DATA_HIGH, AD7150_CH2_AVG_HIGH,
93 AD7150_CH2_SETUP, AD7150_CH2_THR_HOLD_H,
94 AD7150_CH2_SENSITIVITY, AD7150_CH2_TIMEOUT },
95 };
96
ad7150_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)97 static int ad7150_read_raw(struct iio_dev *indio_dev,
98 struct iio_chan_spec const *chan,
99 int *val,
100 int *val2,
101 long mask)
102 {
103 int ret;
104 struct ad7150_chip_info *chip = iio_priv(indio_dev);
105
106 switch (mask) {
107 case 0:
108 ret = i2c_smbus_read_word_data(chip->client,
109 ad7150_addresses[chan->channel][0]);
110 if (ret < 0)
111 return ret;
112 *val = swab16(ret);
113 return IIO_VAL_INT;
114 case IIO_CHAN_INFO_AVERAGE_RAW:
115 ret = i2c_smbus_read_word_data(chip->client,
116 ad7150_addresses[chan->channel][1]);
117 if (ret < 0)
118 return ret;
119 *val = swab16(ret);
120 return IIO_VAL_INT;
121 default:
122 return -EINVAL;
123 }
124 }
125
ad7150_read_event_config(struct iio_dev * indio_dev,u64 event_code)126 static int ad7150_read_event_config(struct iio_dev *indio_dev, u64 event_code)
127 {
128 int ret;
129 u8 threshtype;
130 bool adaptive;
131 struct ad7150_chip_info *chip = iio_priv(indio_dev);
132 int rising = !!(IIO_EVENT_CODE_EXTRACT_DIR(event_code) ==
133 IIO_EV_DIR_RISING);
134
135 ret = i2c_smbus_read_byte_data(chip->client, AD7150_CFG);
136 if (ret < 0)
137 return ret;
138
139 threshtype = (ret >> 5) & 0x03;
140 adaptive = !!(ret & 0x80);
141
142 switch (IIO_EVENT_CODE_EXTRACT_TYPE(event_code)) {
143 case IIO_EV_TYPE_MAG_ADAPTIVE:
144 if (rising)
145 return adaptive && (threshtype == 0x1);
146 else
147 return adaptive && (threshtype == 0x0);
148 case IIO_EV_TYPE_THRESH_ADAPTIVE:
149 if (rising)
150 return adaptive && (threshtype == 0x3);
151 else
152 return adaptive && (threshtype == 0x2);
153
154 case IIO_EV_TYPE_THRESH:
155 if (rising)
156 return !adaptive && (threshtype == 0x1);
157 else
158 return !adaptive && (threshtype == 0x0);
159 };
160 return -EINVAL;
161 }
162
163 /* lock should be held */
ad7150_write_event_params(struct iio_dev * indio_dev,u64 event_code)164 static int ad7150_write_event_params(struct iio_dev *indio_dev, u64 event_code)
165 {
166 int ret;
167 u16 value;
168 u8 sens, timeout;
169 struct ad7150_chip_info *chip = iio_priv(indio_dev);
170 int chan = IIO_EVENT_CODE_EXTRACT_NUM(event_code);
171 int rising = !!(IIO_EVENT_CODE_EXTRACT_DIR(event_code) ==
172 IIO_EV_DIR_RISING);
173
174 if (event_code != chip->current_event)
175 return 0;
176
177 switch (IIO_EVENT_CODE_EXTRACT_TYPE(event_code)) {
178 /* Note completely different from the adaptive versions */
179 case IIO_EV_TYPE_THRESH:
180 value = chip->threshold[rising][chan];
181 ret = i2c_smbus_write_word_data(chip->client,
182 ad7150_addresses[chan][3],
183 swab16(value));
184 if (ret < 0)
185 return ret;
186 return 0;
187 case IIO_EV_TYPE_MAG_ADAPTIVE:
188 sens = chip->mag_sensitivity[rising][chan];
189 timeout = chip->mag_timeout[rising][chan];
190 break;
191 case IIO_EV_TYPE_THRESH_ADAPTIVE:
192 sens = chip->thresh_sensitivity[rising][chan];
193 timeout = chip->thresh_timeout[rising][chan];
194 break;
195 default:
196 return -EINVAL;
197 };
198 ret = i2c_smbus_write_byte_data(chip->client,
199 ad7150_addresses[chan][4],
200 sens);
201 if (ret < 0)
202 return ret;
203
204 ret = i2c_smbus_write_byte_data(chip->client,
205 ad7150_addresses[chan][5],
206 timeout);
207 if (ret < 0)
208 return ret;
209
210 return 0;
211 }
212
ad7150_write_event_config(struct iio_dev * indio_dev,u64 event_code,int state)213 static int ad7150_write_event_config(struct iio_dev *indio_dev,
214 u64 event_code, int state)
215 {
216 u8 thresh_type, cfg, adaptive;
217 int ret;
218 struct ad7150_chip_info *chip = iio_priv(indio_dev);
219 int rising = !!(IIO_EVENT_CODE_EXTRACT_DIR(event_code) ==
220 IIO_EV_DIR_RISING);
221
222 /* Something must always be turned on */
223 if (state == 0)
224 return -EINVAL;
225
226 if (event_code == chip->current_event)
227 return 0;
228 mutex_lock(&chip->state_lock);
229 ret = i2c_smbus_read_byte_data(chip->client, AD7150_CFG);
230 if (ret < 0)
231 goto error_ret;
232
233 cfg = ret & ~((0x03 << 5) | (0x1 << 7));
234
235 switch (IIO_EVENT_CODE_EXTRACT_TYPE(event_code)) {
236 case IIO_EV_TYPE_MAG_ADAPTIVE:
237 adaptive = 1;
238 if (rising)
239 thresh_type = 0x1;
240 else
241 thresh_type = 0x0;
242 break;
243 case IIO_EV_TYPE_THRESH_ADAPTIVE:
244 adaptive = 1;
245 if (rising)
246 thresh_type = 0x3;
247 else
248 thresh_type = 0x2;
249 break;
250 case IIO_EV_TYPE_THRESH:
251 adaptive = 0;
252 if (rising)
253 thresh_type = 0x1;
254 else
255 thresh_type = 0x0;
256 break;
257 default:
258 ret = -EINVAL;
259 goto error_ret;
260 };
261
262 cfg |= (!adaptive << 7) | (thresh_type << 5);
263
264 ret = i2c_smbus_write_byte_data(chip->client, AD7150_CFG, cfg);
265 if (ret < 0)
266 goto error_ret;
267
268 chip->current_event = event_code;
269
270 /* update control attributes */
271 ret = ad7150_write_event_params(indio_dev, event_code);
272 error_ret:
273 mutex_unlock(&chip->state_lock);
274
275 return 0;
276 }
277
ad7150_read_event_value(struct iio_dev * indio_dev,u64 event_code,int * val)278 static int ad7150_read_event_value(struct iio_dev *indio_dev,
279 u64 event_code,
280 int *val)
281 {
282 int chan = IIO_EVENT_CODE_EXTRACT_NUM(event_code);
283 struct ad7150_chip_info *chip = iio_priv(indio_dev);
284 int rising = !!(IIO_EVENT_CODE_EXTRACT_DIR(event_code) ==
285 IIO_EV_DIR_RISING);
286
287 /* Complex register sharing going on here */
288 switch (IIO_EVENT_CODE_EXTRACT_TYPE(event_code)) {
289 case IIO_EV_TYPE_MAG_ADAPTIVE:
290 *val = chip->mag_sensitivity[rising][chan];
291 return 0;
292
293 case IIO_EV_TYPE_THRESH_ADAPTIVE:
294 *val = chip->thresh_sensitivity[rising][chan];
295 return 0;
296
297 case IIO_EV_TYPE_THRESH:
298 *val = chip->threshold[rising][chan];
299 return 0;
300
301 default:
302 return -EINVAL;
303 };
304 }
305
ad7150_write_event_value(struct iio_dev * indio_dev,u64 event_code,int val)306 static int ad7150_write_event_value(struct iio_dev *indio_dev,
307 u64 event_code,
308 int val)
309 {
310 int ret;
311 struct ad7150_chip_info *chip = iio_priv(indio_dev);
312 int chan = IIO_EVENT_CODE_EXTRACT_NUM(event_code);
313 int rising = !!(IIO_EVENT_CODE_EXTRACT_DIR(event_code) ==
314 IIO_EV_DIR_RISING);
315
316 mutex_lock(&chip->state_lock);
317 switch (IIO_EVENT_CODE_EXTRACT_TYPE(event_code)) {
318 case IIO_EV_TYPE_MAG_ADAPTIVE:
319 chip->mag_sensitivity[rising][chan] = val;
320 break;
321 case IIO_EV_TYPE_THRESH_ADAPTIVE:
322 chip->thresh_sensitivity[rising][chan] = val;
323 break;
324 case IIO_EV_TYPE_THRESH:
325 chip->threshold[rising][chan] = val;
326 break;
327 default:
328 ret = -EINVAL;
329 goto error_ret;
330 };
331
332 /* write back if active */
333 ret = ad7150_write_event_params(indio_dev, event_code);
334
335 error_ret:
336 mutex_unlock(&chip->state_lock);
337 return ret;
338 }
339
ad7150_show_timeout(struct device * dev,struct device_attribute * attr,char * buf)340 static ssize_t ad7150_show_timeout(struct device *dev,
341 struct device_attribute *attr,
342 char *buf)
343 {
344 struct iio_dev *indio_dev = dev_get_drvdata(dev);
345 struct ad7150_chip_info *chip = iio_priv(indio_dev);
346 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
347 u8 value;
348
349 /* use the event code for consistency reasons */
350 int chan = IIO_EVENT_CODE_EXTRACT_NUM(this_attr->address);
351 int rising = !!(IIO_EVENT_CODE_EXTRACT_DIR(this_attr->address)
352 == IIO_EV_DIR_RISING);
353
354 switch (IIO_EVENT_CODE_EXTRACT_TYPE(this_attr->address)) {
355 case IIO_EV_TYPE_MAG_ADAPTIVE:
356 value = chip->mag_timeout[rising][chan];
357 break;
358 case IIO_EV_TYPE_THRESH_ADAPTIVE:
359 value = chip->thresh_timeout[rising][chan];
360 break;
361 default:
362 return -EINVAL;
363 };
364
365 return sprintf(buf, "%d\n", value);
366 }
367
ad7150_store_timeout(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)368 static ssize_t ad7150_store_timeout(struct device *dev,
369 struct device_attribute *attr,
370 const char *buf,
371 size_t len)
372 {
373 struct iio_dev *indio_dev = dev_get_drvdata(dev);
374 struct ad7150_chip_info *chip = iio_priv(indio_dev);
375 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
376 int chan = IIO_EVENT_CODE_EXTRACT_NUM(this_attr->address);
377 int rising = !!(IIO_EVENT_CODE_EXTRACT_DIR(this_attr->address) ==
378 IIO_EV_DIR_RISING);
379 u8 data;
380 int ret;
381
382 ret = kstrtou8(buf, 10, &data);
383 if (ret < 0)
384 return ret;
385
386 mutex_lock(&chip->state_lock);
387 switch (IIO_EVENT_CODE_EXTRACT_TYPE(this_attr->address)) {
388 case IIO_EV_TYPE_MAG_ADAPTIVE:
389 chip->mag_timeout[rising][chan] = data;
390 break;
391 case IIO_EV_TYPE_THRESH_ADAPTIVE:
392 chip->thresh_timeout[rising][chan] = data;
393 break;
394 default:
395 ret = -EINVAL;
396 goto error_ret;
397 };
398
399 ret = ad7150_write_event_params(indio_dev, this_attr->address);
400 error_ret:
401 mutex_unlock(&chip->state_lock);
402
403 if (ret < 0)
404 return ret;
405
406 return len;
407 }
408
409 #define AD7150_TIMEOUT(chan, type, dir, ev_type, ev_dir) \
410 IIO_DEVICE_ATTR(in_capacitance##chan##_##type##_##dir##_timeout, \
411 S_IRUGO | S_IWUSR, \
412 &ad7150_show_timeout, \
413 &ad7150_store_timeout, \
414 IIO_UNMOD_EVENT_CODE(IIO_CAPACITANCE, \
415 chan, \
416 IIO_EV_TYPE_##ev_type, \
417 IIO_EV_DIR_##ev_dir))
418 static AD7150_TIMEOUT(0, mag_adaptive, rising, MAG_ADAPTIVE, RISING);
419 static AD7150_TIMEOUT(0, mag_adaptive, falling, MAG_ADAPTIVE, FALLING);
420 static AD7150_TIMEOUT(1, mag_adaptive, rising, MAG_ADAPTIVE, RISING);
421 static AD7150_TIMEOUT(1, mag_adaptive, falling, MAG_ADAPTIVE, FALLING);
422 static AD7150_TIMEOUT(0, thresh_adaptive, rising, THRESH_ADAPTIVE, RISING);
423 static AD7150_TIMEOUT(0, thresh_adaptive, falling, THRESH_ADAPTIVE, FALLING);
424 static AD7150_TIMEOUT(1, thresh_adaptive, rising, THRESH_ADAPTIVE, RISING);
425 static AD7150_TIMEOUT(1, thresh_adaptive, falling, THRESH_ADAPTIVE, FALLING);
426
427 static const struct iio_chan_spec ad7150_channels[] = {
428 {
429 .type = IIO_CAPACITANCE,
430 .indexed = 1,
431 .channel = 0,
432 .info_mask = IIO_CHAN_INFO_AVERAGE_RAW_SEPARATE_BIT,
433 .event_mask =
434 IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING) |
435 IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING) |
436 IIO_EV_BIT(IIO_EV_TYPE_THRESH_ADAPTIVE, IIO_EV_DIR_RISING) |
437 IIO_EV_BIT(IIO_EV_TYPE_THRESH_ADAPTIVE, IIO_EV_DIR_FALLING) |
438 IIO_EV_BIT(IIO_EV_TYPE_MAG_ADAPTIVE, IIO_EV_DIR_RISING) |
439 IIO_EV_BIT(IIO_EV_TYPE_MAG_ADAPTIVE, IIO_EV_DIR_FALLING)
440 }, {
441 .type = IIO_CAPACITANCE,
442 .indexed = 1,
443 .channel = 1,
444 .info_mask = IIO_CHAN_INFO_AVERAGE_RAW_SEPARATE_BIT,
445 .event_mask =
446 IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING) |
447 IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING) |
448 IIO_EV_BIT(IIO_EV_TYPE_THRESH_ADAPTIVE, IIO_EV_DIR_RISING) |
449 IIO_EV_BIT(IIO_EV_TYPE_THRESH_ADAPTIVE, IIO_EV_DIR_FALLING) |
450 IIO_EV_BIT(IIO_EV_TYPE_MAG_ADAPTIVE, IIO_EV_DIR_RISING) |
451 IIO_EV_BIT(IIO_EV_TYPE_MAG_ADAPTIVE, IIO_EV_DIR_FALLING)
452 },
453 };
454
455 /*
456 * threshold events
457 */
458
ad7150_event_handler(int irq,void * private)459 static irqreturn_t ad7150_event_handler(int irq, void *private)
460 {
461 struct iio_dev *indio_dev = private;
462 struct ad7150_chip_info *chip = iio_priv(indio_dev);
463 u8 int_status;
464 s64 timestamp = iio_get_time_ns();
465 int ret;
466
467 ret = i2c_smbus_read_byte_data(chip->client, AD7150_STATUS);
468 if (ret < 0)
469 return IRQ_HANDLED;
470
471 int_status = ret;
472
473 if ((int_status & AD7150_STATUS_OUT1) &&
474 !(chip->old_state & AD7150_STATUS_OUT1))
475 iio_push_event(indio_dev,
476 IIO_UNMOD_EVENT_CODE(IIO_CAPACITANCE,
477 0,
478 IIO_EV_TYPE_THRESH,
479 IIO_EV_DIR_RISING),
480 timestamp);
481 else if ((!(int_status & AD7150_STATUS_OUT1)) &&
482 (chip->old_state & AD7150_STATUS_OUT1))
483 iio_push_event(indio_dev,
484 IIO_UNMOD_EVENT_CODE(IIO_CAPACITANCE,
485 0,
486 IIO_EV_TYPE_THRESH,
487 IIO_EV_DIR_FALLING),
488 timestamp);
489
490 if ((int_status & AD7150_STATUS_OUT2) &&
491 !(chip->old_state & AD7150_STATUS_OUT2))
492 iio_push_event(indio_dev,
493 IIO_UNMOD_EVENT_CODE(IIO_CAPACITANCE,
494 1,
495 IIO_EV_TYPE_THRESH,
496 IIO_EV_DIR_RISING),
497 timestamp);
498 else if ((!(int_status & AD7150_STATUS_OUT2)) &&
499 (chip->old_state & AD7150_STATUS_OUT2))
500 iio_push_event(indio_dev,
501 IIO_UNMOD_EVENT_CODE(IIO_CAPACITANCE,
502 1,
503 IIO_EV_TYPE_THRESH,
504 IIO_EV_DIR_FALLING),
505 timestamp);
506 /* store the status to avoid repushing same events */
507 chip->old_state = int_status;
508
509 return IRQ_HANDLED;
510 }
511
512 /* Timeouts not currently handled by core */
513 static struct attribute *ad7150_event_attributes[] = {
514 &iio_dev_attr_in_capacitance0_mag_adaptive_rising_timeout
515 .dev_attr.attr,
516 &iio_dev_attr_in_capacitance0_mag_adaptive_falling_timeout
517 .dev_attr.attr,
518 &iio_dev_attr_in_capacitance1_mag_adaptive_rising_timeout
519 .dev_attr.attr,
520 &iio_dev_attr_in_capacitance1_mag_adaptive_falling_timeout
521 .dev_attr.attr,
522 &iio_dev_attr_in_capacitance0_thresh_adaptive_rising_timeout
523 .dev_attr.attr,
524 &iio_dev_attr_in_capacitance0_thresh_adaptive_falling_timeout
525 .dev_attr.attr,
526 &iio_dev_attr_in_capacitance1_thresh_adaptive_rising_timeout
527 .dev_attr.attr,
528 &iio_dev_attr_in_capacitance1_thresh_adaptive_falling_timeout
529 .dev_attr.attr,
530 NULL,
531 };
532
533 static struct attribute_group ad7150_event_attribute_group = {
534 .attrs = ad7150_event_attributes,
535 .name = "events",
536 };
537
538 static const struct iio_info ad7150_info = {
539 .event_attrs = &ad7150_event_attribute_group,
540 .driver_module = THIS_MODULE,
541 .read_raw = &ad7150_read_raw,
542 .read_event_config = &ad7150_read_event_config,
543 .write_event_config = &ad7150_write_event_config,
544 .read_event_value = &ad7150_read_event_value,
545 .write_event_value = &ad7150_write_event_value,
546 };
547
548 /*
549 * device probe and remove
550 */
551
ad7150_probe(struct i2c_client * client,const struct i2c_device_id * id)552 static int __devinit ad7150_probe(struct i2c_client *client,
553 const struct i2c_device_id *id)
554 {
555 int ret;
556 struct ad7150_chip_info *chip;
557 struct iio_dev *indio_dev;
558
559 indio_dev = iio_allocate_device(sizeof(*chip));
560 if (indio_dev == NULL) {
561 ret = -ENOMEM;
562 goto error_ret;
563 }
564 chip = iio_priv(indio_dev);
565 mutex_init(&chip->state_lock);
566 /* this is only used for device removal purposes */
567 i2c_set_clientdata(client, indio_dev);
568
569 chip->client = client;
570
571 indio_dev->name = id->name;
572 indio_dev->channels = ad7150_channels;
573 indio_dev->num_channels = ARRAY_SIZE(ad7150_channels);
574 /* Establish that the iio_dev is a child of the i2c device */
575 indio_dev->dev.parent = &client->dev;
576
577 indio_dev->info = &ad7150_info;
578
579 indio_dev->modes = INDIO_DIRECT_MODE;
580
581 if (client->irq) {
582 ret = request_threaded_irq(client->irq,
583 NULL,
584 &ad7150_event_handler,
585 IRQF_TRIGGER_RISING |
586 IRQF_TRIGGER_FALLING,
587 "ad7150_irq1",
588 indio_dev);
589 if (ret)
590 goto error_free_dev;
591 }
592
593 if (client->dev.platform_data) {
594 ret = request_threaded_irq(*(unsigned int *)
595 client->dev.platform_data,
596 NULL,
597 &ad7150_event_handler,
598 IRQF_TRIGGER_RISING |
599 IRQF_TRIGGER_FALLING,
600 "ad7150_irq2",
601 indio_dev);
602 if (ret)
603 goto error_free_irq;
604 }
605
606 ret = iio_device_register(indio_dev);
607 if (ret)
608 goto error_free_irq2;
609
610 dev_info(&client->dev, "%s capacitive sensor registered,irq: %d\n",
611 id->name, client->irq);
612
613 return 0;
614 error_free_irq2:
615 if (client->dev.platform_data)
616 free_irq(*(unsigned int *)client->dev.platform_data,
617 indio_dev);
618 error_free_irq:
619 if (client->irq)
620 free_irq(client->irq, indio_dev);
621 error_free_dev:
622 iio_free_device(indio_dev);
623 error_ret:
624 return ret;
625 }
626
ad7150_remove(struct i2c_client * client)627 static int __devexit ad7150_remove(struct i2c_client *client)
628 {
629 struct iio_dev *indio_dev = i2c_get_clientdata(client);
630
631 iio_device_unregister(indio_dev);
632 if (client->irq)
633 free_irq(client->irq, indio_dev);
634
635 if (client->dev.platform_data)
636 free_irq(*(unsigned int *)client->dev.platform_data, indio_dev);
637
638 iio_free_device(indio_dev);
639
640 return 0;
641 }
642
643 static const struct i2c_device_id ad7150_id[] = {
644 { "ad7150", 0 },
645 { "ad7151", 0 },
646 { "ad7156", 0 },
647 {}
648 };
649
650 MODULE_DEVICE_TABLE(i2c, ad7150_id);
651
652 static struct i2c_driver ad7150_driver = {
653 .driver = {
654 .name = "ad7150",
655 },
656 .probe = ad7150_probe,
657 .remove = __devexit_p(ad7150_remove),
658 .id_table = ad7150_id,
659 };
660 module_i2c_driver(ad7150_driver);
661
662 MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
663 MODULE_DESCRIPTION("Analog Devices AD7150/1/6 capacitive sensor driver");
664 MODULE_LICENSE("GPL v2");
665