Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ad7150.c
Go to the documentation of this file.
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 <linux/iio/iio.h>
17 #include <linux/iio/sysfs.h>
18 #include <linux/iio/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 
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 
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 IIO_CHAN_INFO_RAW:
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 
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 */
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_CHAN(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 
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 
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_CHAN(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 
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_CHAN(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 
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_to_iio_dev(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_CHAN(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 
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_to_iio_dev(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_CHAN(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_RAW_SEPARATE_BIT |
433  IIO_CHAN_INFO_AVERAGE_RAW_SEPARATE_BIT,
434  .event_mask =
435  IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING) |
436  IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING) |
437  IIO_EV_BIT(IIO_EV_TYPE_THRESH_ADAPTIVE, IIO_EV_DIR_RISING) |
438  IIO_EV_BIT(IIO_EV_TYPE_THRESH_ADAPTIVE, IIO_EV_DIR_FALLING) |
439  IIO_EV_BIT(IIO_EV_TYPE_MAG_ADAPTIVE, IIO_EV_DIR_RISING) |
440  IIO_EV_BIT(IIO_EV_TYPE_MAG_ADAPTIVE, IIO_EV_DIR_FALLING)
441  }, {
442  .type = IIO_CAPACITANCE,
443  .indexed = 1,
444  .channel = 1,
445  .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT |
446  IIO_CHAN_INFO_AVERAGE_RAW_SEPARATE_BIT,
447  .event_mask =
448  IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING) |
449  IIO_EV_BIT(IIO_EV_TYPE_THRESH, IIO_EV_DIR_FALLING) |
450  IIO_EV_BIT(IIO_EV_TYPE_THRESH_ADAPTIVE, IIO_EV_DIR_RISING) |
451  IIO_EV_BIT(IIO_EV_TYPE_THRESH_ADAPTIVE, IIO_EV_DIR_FALLING) |
452  IIO_EV_BIT(IIO_EV_TYPE_MAG_ADAPTIVE, IIO_EV_DIR_RISING) |
453  IIO_EV_BIT(IIO_EV_TYPE_MAG_ADAPTIVE, IIO_EV_DIR_FALLING)
454  },
455 };
456 
457 /*
458  * threshold events
459  */
460 
461 static irqreturn_t ad7150_event_handler(int irq, void *private)
462 {
463  struct iio_dev *indio_dev = private;
464  struct ad7150_chip_info *chip = iio_priv(indio_dev);
465  u8 int_status;
466  s64 timestamp = iio_get_time_ns();
467  int ret;
468 
469  ret = i2c_smbus_read_byte_data(chip->client, AD7150_STATUS);
470  if (ret < 0)
471  return IRQ_HANDLED;
472 
473  int_status = ret;
474 
475  if ((int_status & AD7150_STATUS_OUT1) &&
476  !(chip->old_state & AD7150_STATUS_OUT1))
477  iio_push_event(indio_dev,
478  IIO_UNMOD_EVENT_CODE(IIO_CAPACITANCE,
479  0,
480  IIO_EV_TYPE_THRESH,
481  IIO_EV_DIR_RISING),
482  timestamp);
483  else if ((!(int_status & AD7150_STATUS_OUT1)) &&
484  (chip->old_state & AD7150_STATUS_OUT1))
485  iio_push_event(indio_dev,
486  IIO_UNMOD_EVENT_CODE(IIO_CAPACITANCE,
487  0,
488  IIO_EV_TYPE_THRESH,
489  IIO_EV_DIR_FALLING),
490  timestamp);
491 
492  if ((int_status & AD7150_STATUS_OUT2) &&
493  !(chip->old_state & AD7150_STATUS_OUT2))
494  iio_push_event(indio_dev,
495  IIO_UNMOD_EVENT_CODE(IIO_CAPACITANCE,
496  1,
497  IIO_EV_TYPE_THRESH,
498  IIO_EV_DIR_RISING),
499  timestamp);
500  else if ((!(int_status & AD7150_STATUS_OUT2)) &&
501  (chip->old_state & AD7150_STATUS_OUT2))
502  iio_push_event(indio_dev,
503  IIO_UNMOD_EVENT_CODE(IIO_CAPACITANCE,
504  1,
505  IIO_EV_TYPE_THRESH,
506  IIO_EV_DIR_FALLING),
507  timestamp);
508  /* store the status to avoid repushing same events */
509  chip->old_state = int_status;
510 
511  return IRQ_HANDLED;
512 }
513 
514 /* Timeouts not currently handled by core */
515 static struct attribute *ad7150_event_attributes[] = {
516  &iio_dev_attr_in_capacitance0_mag_adaptive_rising_timeout
517  .dev_attr.attr,
518  &iio_dev_attr_in_capacitance0_mag_adaptive_falling_timeout
519  .dev_attr.attr,
520  &iio_dev_attr_in_capacitance1_mag_adaptive_rising_timeout
521  .dev_attr.attr,
522  &iio_dev_attr_in_capacitance1_mag_adaptive_falling_timeout
523  .dev_attr.attr,
524  &iio_dev_attr_in_capacitance0_thresh_adaptive_rising_timeout
525  .dev_attr.attr,
526  &iio_dev_attr_in_capacitance0_thresh_adaptive_falling_timeout
527  .dev_attr.attr,
528  &iio_dev_attr_in_capacitance1_thresh_adaptive_rising_timeout
529  .dev_attr.attr,
530  &iio_dev_attr_in_capacitance1_thresh_adaptive_falling_timeout
531  .dev_attr.attr,
532  NULL,
533 };
534 
535 static struct attribute_group ad7150_event_attribute_group = {
536  .attrs = ad7150_event_attributes,
537  .name = "events",
538 };
539 
540 static const struct iio_info ad7150_info = {
541  .event_attrs = &ad7150_event_attribute_group,
542  .driver_module = THIS_MODULE,
543  .read_raw = &ad7150_read_raw,
544  .read_event_config = &ad7150_read_event_config,
545  .write_event_config = &ad7150_write_event_config,
546  .read_event_value = &ad7150_read_event_value,
547  .write_event_value = &ad7150_write_event_value,
548 };
549 
550 /*
551  * device probe and remove
552  */
553 
554 static int __devinit ad7150_probe(struct i2c_client *client,
555  const struct i2c_device_id *id)
556 {
557  int ret;
558  struct ad7150_chip_info *chip;
559  struct iio_dev *indio_dev;
560 
561  indio_dev = iio_device_alloc(sizeof(*chip));
562  if (indio_dev == NULL) {
563  ret = -ENOMEM;
564  goto error_ret;
565  }
566  chip = iio_priv(indio_dev);
567  mutex_init(&chip->state_lock);
568  /* this is only used for device removal purposes */
569  i2c_set_clientdata(client, indio_dev);
570 
571  chip->client = client;
572 
573  indio_dev->name = id->name;
574  indio_dev->channels = ad7150_channels;
575  indio_dev->num_channels = ARRAY_SIZE(ad7150_channels);
576  /* Establish that the iio_dev is a child of the i2c device */
577  indio_dev->dev.parent = &client->dev;
578 
579  indio_dev->info = &ad7150_info;
580 
581  indio_dev->modes = INDIO_DIRECT_MODE;
582 
583  if (client->irq) {
584  ret = request_threaded_irq(client->irq,
585  NULL,
586  &ad7150_event_handler,
587  IRQF_TRIGGER_RISING |
588  IRQF_TRIGGER_FALLING |
589  IRQF_ONESHOT,
590  "ad7150_irq1",
591  indio_dev);
592  if (ret)
593  goto error_free_dev;
594  }
595 
596  if (client->dev.platform_data) {
597  ret = request_threaded_irq(*(unsigned int *)
598  client->dev.platform_data,
599  NULL,
600  &ad7150_event_handler,
601  IRQF_TRIGGER_RISING |
602  IRQF_TRIGGER_FALLING |
603  IRQF_ONESHOT,
604  "ad7150_irq2",
605  indio_dev);
606  if (ret)
607  goto error_free_irq;
608  }
609 
610  ret = iio_device_register(indio_dev);
611  if (ret)
612  goto error_free_irq2;
613 
614  dev_info(&client->dev, "%s capacitive sensor registered,irq: %d\n",
615  id->name, client->irq);
616 
617  return 0;
618 error_free_irq2:
619  if (client->dev.platform_data)
620  free_irq(*(unsigned int *)client->dev.platform_data,
621  indio_dev);
622 error_free_irq:
623  if (client->irq)
624  free_irq(client->irq, indio_dev);
625 error_free_dev:
626  iio_device_free(indio_dev);
627 error_ret:
628  return ret;
629 }
630 
631 static int __devexit ad7150_remove(struct i2c_client *client)
632 {
633  struct iio_dev *indio_dev = i2c_get_clientdata(client);
634 
635  iio_device_unregister(indio_dev);
636  if (client->irq)
637  free_irq(client->irq, indio_dev);
638 
639  if (client->dev.platform_data)
640  free_irq(*(unsigned int *)client->dev.platform_data, indio_dev);
641 
642  iio_device_free(indio_dev);
643 
644  return 0;
645 }
646 
647 static const struct i2c_device_id ad7150_id[] = {
648  { "ad7150", 0 },
649  { "ad7151", 0 },
650  { "ad7156", 0 },
651  {}
652 };
653 
654 MODULE_DEVICE_TABLE(i2c, ad7150_id);
655 
656 static struct i2c_driver ad7150_driver = {
657  .driver = {
658  .name = "ad7150",
659  },
660  .probe = ad7150_probe,
661  .remove = __devexit_p(ad7150_remove),
662  .id_table = ad7150_id,
663 };
664 module_i2c_driver(ad7150_driver);
665 
666 MODULE_AUTHOR("Barry Song <[email protected]>");
667 MODULE_DESCRIPTION("Analog Devices AD7150/1/6 capacitive sensor driver");
668 MODULE_LICENSE("GPL v2");
Generated on Thu Jan 10 2013 14:28:41 for Linux Kernel by   doxygen 1.8.2