3 * Copyright (C) 2010 Michael Hennerich, Analog Devices Inc.
5 * based on iio/adc/max1363
6 * Copyright (C) 2008-2010 Jonathan Cameron
8 * based on linux/drivers/i2c/chips/max123x
9 * Copyright (C) 2002-2004 Stefan Eletzhofer
11 * based on linux/drivers/acron/char/pcf8583.c
12 * Copyright (C) 2000 Russell King
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License version 2 as
16 * published by the Free Software Foundation.
20 * Support for ad7991, ad7995, ad7999, ad7992, ad7993, ad7994, ad7997,
21 * ad7998 and similar chips.
25 #include <linux/interrupt.h>
26 #include <linux/workqueue.h>
27 #include <linux/device.h>
28 #include <linux/kernel.h>
29 #include <linux/sysfs.h>
30 #include <linux/list.h>
31 #include <linux/i2c.h>
32 #include <linux/regulator/consumer.h>
33 #include <linux/slab.h>
34 #include <linux/types.h>
35 #include <linux/err.h>
40 #include "../ring_generic.h"
45 * ad799x register access by I2C
47 static int ad799x_i2c_read16(struct ad799x_state
*st
, u8 reg
, u16
*data
)
49 struct i2c_client
*client
= st
->client
;
52 ret
= i2c_smbus_read_word_data(client
, reg
);
54 dev_err(&client
->dev
, "I2C read error\n");
58 *data
= swab16((u16
)ret
);
63 static int ad799x_i2c_read8(struct ad799x_state
*st
, u8 reg
, u8
*data
)
65 struct i2c_client
*client
= st
->client
;
68 ret
= i2c_smbus_read_byte_data(client
, reg
);
70 dev_err(&client
->dev
, "I2C read error\n");
79 static int ad799x_i2c_write16(struct ad799x_state
*st
, u8 reg
, u16 data
)
81 struct i2c_client
*client
= st
->client
;
84 ret
= i2c_smbus_write_word_data(client
, reg
, swab16(data
));
86 dev_err(&client
->dev
, "I2C write error\n");
91 static int ad799x_i2c_write8(struct ad799x_state
*st
, u8 reg
, u8 data
)
93 struct i2c_client
*client
= st
->client
;
96 ret
= i2c_smbus_write_byte_data(client
, reg
, data
);
98 dev_err(&client
->dev
, "I2C write error\n");
103 static int ad799x_scan_el_set_state(struct iio_scan_el
*scan_el
,
104 struct iio_dev
*indio_dev
,
107 struct ad799x_state
*st
= indio_dev
->dev_data
;
108 return ad799x_set_scan_mode(st
, st
->indio_dev
->ring
->scan_mask
);
111 /* Here we claim all are 16 bits. This currently does no harm and saves
112 * us a lot of scan element listings */
114 #define AD799X_SCAN_EL(number) \
115 IIO_SCAN_EL_C(in##number, number, 0, ad799x_scan_el_set_state);
117 static AD799X_SCAN_EL(0);
118 static AD799X_SCAN_EL(1);
119 static AD799X_SCAN_EL(2);
120 static AD799X_SCAN_EL(3);
121 static AD799X_SCAN_EL(4);
122 static AD799X_SCAN_EL(5);
123 static AD799X_SCAN_EL(6);
124 static AD799X_SCAN_EL(7);
126 static ssize_t
ad799x_show_type(struct device
*dev
,
127 struct device_attribute
*attr
,
130 struct iio_ring_buffer
*ring
= dev_get_drvdata(dev
);
131 struct iio_dev
*indio_dev
= ring
->indio_dev
;
132 struct ad799x_state
*st
= indio_dev
->dev_data
;
134 return sprintf(buf
, "%c%d/%d\n", st
->chip_info
->sign
,
135 st
->chip_info
->bits
, AD799X_STORAGEBITS
);
137 static IIO_DEVICE_ATTR(in_type
, S_IRUGO
, ad799x_show_type
, NULL
, 0);
139 static int ad7991_5_9_set_scan_mode(struct ad799x_state
*st
, unsigned mask
)
141 return i2c_smbus_write_byte(st
->client
,
142 st
->config
| (mask
<< AD799X_CHANNEL_SHIFT
));
145 static int ad7992_3_4_set_scan_mode(struct ad799x_state
*st
, unsigned mask
)
147 return ad799x_i2c_write8(st
, AD7998_CONF_REG
,
148 st
->config
| (mask
<< AD799X_CHANNEL_SHIFT
));
151 static int ad7997_8_set_scan_mode(struct ad799x_state
*st
, unsigned mask
)
153 return ad799x_i2c_write16(st
, AD7998_CONF_REG
,
154 st
->config
| (mask
<< AD799X_CHANNEL_SHIFT
));
157 int ad799x_set_scan_mode(struct ad799x_state
*st
, unsigned mask
)
161 if (st
->chip_info
->ad799x_set_scan_mode
!= NULL
) {
162 ret
= st
->chip_info
->ad799x_set_scan_mode(st
, mask
);
163 return (ret
> 0) ? 0 : ret
;
169 static ssize_t
ad799x_read_single_channel(struct device
*dev
,
170 struct device_attribute
*attr
,
173 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
174 struct ad799x_state
*st
= iio_dev_get_devdata(dev_info
);
175 struct iio_dev_attr
*this_attr
= to_iio_dev_attr(attr
);
176 int ret
= 0, len
= 0;
182 mutex_lock(&dev_info
->mlock
);
183 mask
= 1 << this_attr
->address
;
184 /* If ring buffer capture is occuring, query the buffer */
185 if (iio_ring_enabled(dev_info
)) {
186 data
= ret
= ad799x_single_channel_from_ring(st
, mask
);
195 cmd
= st
->config
| (mask
<< AD799X_CHANNEL_SHIFT
);
200 cmd
= mask
<< AD799X_CHANNEL_SHIFT
;
204 cmd
= (this_attr
->address
<<
205 AD799X_CHANNEL_SHIFT
) | AD7997_8_READ_SINGLE
;
211 ret
= ad799x_i2c_read16(st
, cmd
, rxbuf
);
218 /* Pretty print the result */
219 len
= sprintf(buf
, "%u\n", data
& ((1 << (st
->chip_info
->bits
)) - 1));
222 mutex_unlock(&dev_info
->mlock
);
223 return ret
? ret
: len
;
226 static ssize_t
ad799x_read_frequency(struct device
*dev
,
227 struct device_attribute
*attr
,
230 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
231 struct ad799x_state
*st
= iio_dev_get_devdata(dev_info
);
235 ret
= ad799x_i2c_read8(st
, AD7998_CYCLE_TMR_REG
, &val
);
239 val
&= AD7998_CYC_MASK
;
243 len
= sprintf(buf
, "0\n");
245 case AD7998_CYC_TCONF_32
:
246 len
= sprintf(buf
, "15625\n");
248 case AD7998_CYC_TCONF_64
:
249 len
= sprintf(buf
, "7812\n");
251 case AD7998_CYC_TCONF_128
:
252 len
= sprintf(buf
, "3906\n");
254 case AD7998_CYC_TCONF_256
:
255 len
= sprintf(buf
, "1953\n");
257 case AD7998_CYC_TCONF_512
:
258 len
= sprintf(buf
, "976\n");
260 case AD7998_CYC_TCONF_1024
:
261 len
= sprintf(buf
, "488\n");
263 case AD7998_CYC_TCONF_2048
:
264 len
= sprintf(buf
, "244\n");
270 static ssize_t
ad799x_write_frequency(struct device
*dev
,
271 struct device_attribute
*attr
,
275 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
276 struct ad799x_state
*st
= iio_dev_get_devdata(dev_info
);
282 ret
= strict_strtol(buf
, 10, &val
);
286 mutex_lock(&dev_info
->mlock
);
287 ret
= ad799x_i2c_read8(st
, AD7998_CYCLE_TMR_REG
, &t
);
289 goto error_ret_mutex
;
290 /* Wipe the bits clean */
291 t
&= ~AD7998_CYC_MASK
;
295 t
|= AD7998_CYC_TCONF_32
;
298 t
|= AD7998_CYC_TCONF_64
;
301 t
|= AD7998_CYC_TCONF_128
;
304 t
|= AD7998_CYC_TCONF_256
;
307 t
|= AD7998_CYC_TCONF_512
;
310 t
|= AD7998_CYC_TCONF_1024
;
313 t
|= AD7998_CYC_TCONF_2048
;
320 goto error_ret_mutex
;
323 ret
= ad799x_i2c_write8(st
, AD7998_CYCLE_TMR_REG
, t
);
326 mutex_unlock(&dev_info
->mlock
);
328 return ret
? ret
: len
;
332 static ssize_t
ad799x_read_channel_config(struct device
*dev
,
333 struct device_attribute
*attr
,
336 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
337 struct ad799x_state
*st
= iio_dev_get_devdata(dev_info
);
338 struct iio_event_attr
*this_attr
= to_iio_event_attr(attr
);
342 ret
= ad799x_i2c_read16(st
, this_attr
->mask
, &val
);
346 return sprintf(buf
, "%d\n", val
);
349 static ssize_t
ad799x_write_channel_config(struct device
*dev
,
350 struct device_attribute
*attr
,
354 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
355 struct ad799x_state
*st
= iio_dev_get_devdata(dev_info
);
356 struct iio_event_attr
*this_attr
= to_iio_event_attr(attr
);
361 ret
= strict_strtol(buf
, 10, &val
);
365 mutex_lock(&dev_info
->mlock
);
366 ret
= ad799x_i2c_write16(st
, this_attr
->mask
, val
);
367 mutex_unlock(&dev_info
->mlock
);
369 return ret
? ret
: len
;
372 static void ad799x_interrupt_bh(struct work_struct
*work_s
)
374 struct ad799x_state
*st
= container_of(work_s
,
375 struct ad799x_state
, work_thresh
);
379 if (ad799x_i2c_read8(st
, AD7998_ALERT_STAT_REG
, &status
))
385 ad799x_i2c_write8(st
, AD7998_ALERT_STAT_REG
, AD7998_ALERT_STAT_CLEAR
);
387 for (i
= 0; i
< 8; i
++) {
388 if (status
& (1 << i
))
389 iio_push_event(st
->indio_dev
, 0,
391 IIO_EVENT_CODE_IN_HIGH_THRESH(i
>> 1) :
392 IIO_EVENT_CODE_IN_LOW_THRESH(i
>> 1),
397 enable_irq(st
->client
->irq
);
400 static int ad799x_interrupt(struct iio_dev
*dev_info
,
405 struct ad799x_state
*st
= dev_info
->dev_data
;
407 st
->last_timestamp
= timestamp
;
408 schedule_work(&st
->work_thresh
);
412 IIO_EVENT_SH(ad799x
, &ad799x_interrupt
);
414 /* Direct read attribtues */
415 static IIO_DEV_ATTR_IN_RAW(0, ad799x_read_single_channel
, 0);
416 static IIO_DEV_ATTR_IN_RAW(1, ad799x_read_single_channel
, 1);
417 static IIO_DEV_ATTR_IN_RAW(2, ad799x_read_single_channel
, 2);
418 static IIO_DEV_ATTR_IN_RAW(3, ad799x_read_single_channel
, 3);
419 static IIO_DEV_ATTR_IN_RAW(4, ad799x_read_single_channel
, 4);
420 static IIO_DEV_ATTR_IN_RAW(5, ad799x_read_single_channel
, 5);
421 static IIO_DEV_ATTR_IN_RAW(6, ad799x_read_single_channel
, 6);
422 static IIO_DEV_ATTR_IN_RAW(7, ad799x_read_single_channel
, 7);
424 static ssize_t
ad799x_show_scale(struct device
*dev
,
425 struct device_attribute
*attr
,
428 /* Driver currently only support internal vref */
429 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
430 struct ad799x_state
*st
= iio_dev_get_devdata(dev_info
);
432 /* Corresponds to Vref / 2^(bits) */
433 unsigned int scale_uv
= (st
->int_vref_mv
* 1000) >> st
->chip_info
->bits
;
435 return sprintf(buf
, "%d.%03d\n", scale_uv
/ 1000, scale_uv
% 1000);
438 static IIO_DEVICE_ATTR(in_scale
, S_IRUGO
, ad799x_show_scale
, NULL
, 0);
440 static ssize_t
ad799x_show_name(struct device
*dev
,
441 struct device_attribute
*attr
,
444 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
445 struct ad799x_state
*st
= iio_dev_get_devdata(dev_info
);
446 return sprintf(buf
, "%s\n", st
->client
->name
);
449 static IIO_DEVICE_ATTR(name
, S_IRUGO
, ad799x_show_name
, NULL
, 0);
451 static struct attribute
*ad7991_5_9_3_4_device_attrs
[] = {
452 &iio_dev_attr_in0_raw
.dev_attr
.attr
,
453 &iio_dev_attr_in1_raw
.dev_attr
.attr
,
454 &iio_dev_attr_in2_raw
.dev_attr
.attr
,
455 &iio_dev_attr_in3_raw
.dev_attr
.attr
,
456 &iio_dev_attr_name
.dev_attr
.attr
,
457 &iio_dev_attr_in_scale
.dev_attr
.attr
,
461 static struct attribute_group ad7991_5_9_3_4_dev_attr_group
= {
462 .attrs
= ad7991_5_9_3_4_device_attrs
,
465 static struct attribute
*ad7991_5_9_3_4_scan_el_attrs
[] = {
466 &iio_scan_el_in0
.dev_attr
.attr
,
467 &iio_const_attr_in0_index
.dev_attr
.attr
,
468 &iio_scan_el_in1
.dev_attr
.attr
,
469 &iio_const_attr_in1_index
.dev_attr
.attr
,
470 &iio_scan_el_in2
.dev_attr
.attr
,
471 &iio_const_attr_in2_index
.dev_attr
.attr
,
472 &iio_scan_el_in3
.dev_attr
.attr
,
473 &iio_const_attr_in3_index
.dev_attr
.attr
,
474 &iio_dev_attr_in_type
.dev_attr
.attr
,
478 static struct attribute_group ad7991_5_9_3_4_scan_el_group
= {
479 .name
= "scan_elements",
480 .attrs
= ad7991_5_9_3_4_scan_el_attrs
,
483 static struct attribute
*ad7992_device_attrs
[] = {
484 &iio_dev_attr_in0_raw
.dev_attr
.attr
,
485 &iio_dev_attr_in1_raw
.dev_attr
.attr
,
486 &iio_dev_attr_name
.dev_attr
.attr
,
487 &iio_dev_attr_in_scale
.dev_attr
.attr
,
491 static struct attribute_group ad7992_dev_attr_group
= {
492 .attrs
= ad7992_device_attrs
,
495 static struct attribute
*ad7992_scan_el_attrs
[] = {
496 &iio_scan_el_in0
.dev_attr
.attr
,
497 &iio_const_attr_in0_index
.dev_attr
.attr
,
498 &iio_scan_el_in1
.dev_attr
.attr
,
499 &iio_const_attr_in1_index
.dev_attr
.attr
,
500 &iio_dev_attr_in_type
.dev_attr
.attr
,
504 static struct attribute_group ad7992_scan_el_group
= {
505 .name
= "scan_elements",
506 .attrs
= ad7992_scan_el_attrs
,
509 static struct attribute
*ad7997_8_device_attrs
[] = {
510 &iio_dev_attr_in0_raw
.dev_attr
.attr
,
511 &iio_dev_attr_in1_raw
.dev_attr
.attr
,
512 &iio_dev_attr_in2_raw
.dev_attr
.attr
,
513 &iio_dev_attr_in3_raw
.dev_attr
.attr
,
514 &iio_dev_attr_in4_raw
.dev_attr
.attr
,
515 &iio_dev_attr_in5_raw
.dev_attr
.attr
,
516 &iio_dev_attr_in6_raw
.dev_attr
.attr
,
517 &iio_dev_attr_in7_raw
.dev_attr
.attr
,
518 &iio_dev_attr_name
.dev_attr
.attr
,
519 &iio_dev_attr_in_scale
.dev_attr
.attr
,
523 static struct attribute_group ad7997_8_dev_attr_group
= {
524 .attrs
= ad7997_8_device_attrs
,
527 static struct attribute
*ad7997_8_scan_el_attrs
[] = {
528 &iio_scan_el_in0
.dev_attr
.attr
,
529 &iio_const_attr_in0_index
.dev_attr
.attr
,
530 &iio_scan_el_in1
.dev_attr
.attr
,
531 &iio_const_attr_in1_index
.dev_attr
.attr
,
532 &iio_scan_el_in2
.dev_attr
.attr
,
533 &iio_const_attr_in2_index
.dev_attr
.attr
,
534 &iio_scan_el_in3
.dev_attr
.attr
,
535 &iio_const_attr_in3_index
.dev_attr
.attr
,
536 &iio_scan_el_in4
.dev_attr
.attr
,
537 &iio_const_attr_in4_index
.dev_attr
.attr
,
538 &iio_scan_el_in5
.dev_attr
.attr
,
539 &iio_const_attr_in5_index
.dev_attr
.attr
,
540 &iio_scan_el_in6
.dev_attr
.attr
,
541 &iio_const_attr_in6_index
.dev_attr
.attr
,
542 &iio_scan_el_in7
.dev_attr
.attr
,
543 &iio_const_attr_in7_index
.dev_attr
.attr
,
544 &iio_dev_attr_in_type
.dev_attr
.attr
,
548 static struct attribute_group ad7997_8_scan_el_group
= {
549 .name
= "scan_elements",
550 .attrs
= ad7997_8_scan_el_attrs
,
553 IIO_EVENT_ATTR_SH(in0_thresh_low_value
,
555 ad799x_read_channel_config
,
556 ad799x_write_channel_config
,
557 AD7998_DATALOW_CH1_REG
);
559 IIO_EVENT_ATTR_SH(in0_thresh_high_value
,
561 ad799x_read_channel_config
,
562 ad799x_write_channel_config
,
563 AD7998_DATAHIGH_CH1_REG
);
565 IIO_EVENT_ATTR_SH(in0_thresh_both_hyst_raw
,
567 ad799x_read_channel_config
,
568 ad799x_write_channel_config
,
569 AD7998_HYST_CH1_REG
);
571 IIO_EVENT_ATTR_SH(in1_thresh_low_value
,
573 ad799x_read_channel_config
,
574 ad799x_write_channel_config
,
575 AD7998_DATALOW_CH2_REG
);
577 IIO_EVENT_ATTR_SH(in1_thresh_high_value
,
579 ad799x_read_channel_config
,
580 ad799x_write_channel_config
,
581 AD7998_DATAHIGH_CH2_REG
);
583 IIO_EVENT_ATTR_SH(in1_thresh_both_hyst_raw
,
585 ad799x_read_channel_config
,
586 ad799x_write_channel_config
,
587 AD7998_HYST_CH2_REG
);
589 IIO_EVENT_ATTR_SH(in2_thresh_low_value
,
591 ad799x_read_channel_config
,
592 ad799x_write_channel_config
,
593 AD7998_DATALOW_CH3_REG
);
595 IIO_EVENT_ATTR_SH(in2_thresh_high_value
,
597 ad799x_read_channel_config
,
598 ad799x_write_channel_config
,
599 AD7998_DATAHIGH_CH3_REG
);
601 IIO_EVENT_ATTR_SH(in2_thresh_both_hyst_raw
,
603 ad799x_read_channel_config
,
604 ad799x_write_channel_config
,
605 AD7998_HYST_CH3_REG
);
607 IIO_EVENT_ATTR_SH(in3_thresh_low_value
,
609 ad799x_read_channel_config
,
610 ad799x_write_channel_config
,
611 AD7998_DATALOW_CH4_REG
);
613 IIO_EVENT_ATTR_SH(in3_thresh_high_value
,
615 ad799x_read_channel_config
,
616 ad799x_write_channel_config
,
617 AD7998_DATAHIGH_CH4_REG
);
619 IIO_EVENT_ATTR_SH(in3_thresh_both_hyst_raw
,
621 ad799x_read_channel_config
,
622 ad799x_write_channel_config
,
623 AD7998_HYST_CH4_REG
);
625 static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR
| S_IRUGO
,
626 ad799x_read_frequency
,
627 ad799x_write_frequency
);
628 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("15625 7812 3906 1953 976 488 244 0");
630 static struct attribute
*ad7993_4_7_8_event_attributes
[] = {
631 &iio_event_attr_in0_thresh_low_value
.dev_attr
.attr
,
632 &iio_event_attr_in0_thresh_high_value
.dev_attr
.attr
,
633 &iio_event_attr_in0_thresh_both_hyst_raw
.dev_attr
.attr
,
634 &iio_event_attr_in1_thresh_low_value
.dev_attr
.attr
,
635 &iio_event_attr_in1_thresh_high_value
.dev_attr
.attr
,
636 &iio_event_attr_in1_thresh_both_hyst_raw
.dev_attr
.attr
,
637 &iio_event_attr_in2_thresh_low_value
.dev_attr
.attr
,
638 &iio_event_attr_in2_thresh_high_value
.dev_attr
.attr
,
639 &iio_event_attr_in2_thresh_both_hyst_raw
.dev_attr
.attr
,
640 &iio_event_attr_in3_thresh_low_value
.dev_attr
.attr
,
641 &iio_event_attr_in3_thresh_high_value
.dev_attr
.attr
,
642 &iio_event_attr_in3_thresh_both_hyst_raw
.dev_attr
.attr
,
643 &iio_dev_attr_sampling_frequency
.dev_attr
.attr
,
644 &iio_const_attr_sampling_frequency_available
.dev_attr
.attr
,
648 static struct attribute_group ad7993_4_7_8_event_attrs_group
= {
649 .attrs
= ad7993_4_7_8_event_attributes
,
652 static struct attribute
*ad7992_event_attributes
[] = {
653 &iio_event_attr_in0_thresh_low_value
.dev_attr
.attr
,
654 &iio_event_attr_in0_thresh_high_value
.dev_attr
.attr
,
655 &iio_event_attr_in0_thresh_both_hyst_raw
.dev_attr
.attr
,
656 &iio_event_attr_in1_thresh_low_value
.dev_attr
.attr
,
657 &iio_event_attr_in1_thresh_high_value
.dev_attr
.attr
,
658 &iio_event_attr_in1_thresh_both_hyst_raw
.dev_attr
.attr
,
659 &iio_dev_attr_sampling_frequency
.dev_attr
.attr
,
660 &iio_const_attr_sampling_frequency_available
.dev_attr
.attr
,
664 static struct attribute_group ad7992_event_attrs_group
= {
665 .attrs
= ad7992_event_attributes
,
668 static const struct ad799x_chip_info ad799x_chip_info_tbl
[] = {
672 .sign
= IIO_SCAN_EL_TYPE_UNSIGNED
,
674 .dev_attrs
= &ad7991_5_9_3_4_dev_attr_group
,
675 .scan_attrs
= &ad7991_5_9_3_4_scan_el_group
,
676 .ad799x_set_scan_mode
= ad7991_5_9_set_scan_mode
,
681 .sign
= IIO_SCAN_EL_TYPE_UNSIGNED
,
683 .dev_attrs
= &ad7991_5_9_3_4_dev_attr_group
,
684 .scan_attrs
= &ad7991_5_9_3_4_scan_el_group
,
685 .ad799x_set_scan_mode
= ad7991_5_9_set_scan_mode
,
690 .sign
= IIO_SCAN_EL_TYPE_UNSIGNED
,
692 .dev_attrs
= &ad7991_5_9_3_4_dev_attr_group
,
693 .scan_attrs
= &ad7991_5_9_3_4_scan_el_group
,
694 .ad799x_set_scan_mode
= ad7991_5_9_set_scan_mode
,
699 .sign
= IIO_SCAN_EL_TYPE_UNSIGNED
,
701 .monitor_mode
= true,
702 .default_config
= AD7998_ALERT_EN
,
703 .dev_attrs
= &ad7992_dev_attr_group
,
704 .scan_attrs
= &ad7992_scan_el_group
,
705 .event_attrs
= &ad7992_event_attrs_group
,
706 .ad799x_set_scan_mode
= ad7992_3_4_set_scan_mode
,
711 .sign
= IIO_SCAN_EL_TYPE_UNSIGNED
,
713 .monitor_mode
= true,
714 .default_config
= AD7998_ALERT_EN
,
715 .dev_attrs
= &ad7991_5_9_3_4_dev_attr_group
,
716 .scan_attrs
= &ad7991_5_9_3_4_scan_el_group
,
717 .event_attrs
= &ad7993_4_7_8_event_attrs_group
,
718 .ad799x_set_scan_mode
= ad7992_3_4_set_scan_mode
,
723 .sign
= IIO_SCAN_EL_TYPE_UNSIGNED
,
725 .monitor_mode
= true,
726 .default_config
= AD7998_ALERT_EN
,
727 .dev_attrs
= &ad7991_5_9_3_4_dev_attr_group
,
728 .scan_attrs
= &ad7991_5_9_3_4_scan_el_group
,
729 .event_attrs
= &ad7993_4_7_8_event_attrs_group
,
730 .ad799x_set_scan_mode
= ad7992_3_4_set_scan_mode
,
735 .sign
= IIO_SCAN_EL_TYPE_UNSIGNED
,
737 .monitor_mode
= true,
738 .default_config
= AD7998_ALERT_EN
,
739 .dev_attrs
= &ad7997_8_dev_attr_group
,
740 .scan_attrs
= &ad7997_8_scan_el_group
,
741 .event_attrs
= &ad7993_4_7_8_event_attrs_group
,
742 .ad799x_set_scan_mode
= ad7997_8_set_scan_mode
,
747 .sign
= IIO_SCAN_EL_TYPE_UNSIGNED
,
749 .monitor_mode
= true,
750 .default_config
= AD7998_ALERT_EN
,
751 .dev_attrs
= &ad7997_8_dev_attr_group
,
752 .scan_attrs
= &ad7997_8_scan_el_group
,
753 .event_attrs
= &ad7993_4_7_8_event_attrs_group
,
754 .ad799x_set_scan_mode
= ad7997_8_set_scan_mode
,
758 static int __devinit
ad799x_probe(struct i2c_client
*client
,
759 const struct i2c_device_id
*id
)
761 int ret
, regdone
= 0;
762 struct ad799x_platform_data
*pdata
= client
->dev
.platform_data
;
763 struct ad799x_state
*st
= kzalloc(sizeof(*st
), GFP_KERNEL
);
769 /* this is only used for device removal purposes */
770 i2c_set_clientdata(client
, st
);
772 atomic_set(&st
->protect_ring
, 0);
773 st
->id
= id
->driver_data
;
774 st
->chip_info
= &ad799x_chip_info_tbl
[st
->id
];
775 st
->config
= st
->chip_info
->default_config
;
777 /* TODO: Add pdata options for filtering and bit delay */
780 st
->int_vref_mv
= pdata
->vref_mv
;
782 st
->int_vref_mv
= st
->chip_info
->int_vref_mv
;
784 st
->reg
= regulator_get(&client
->dev
, "vcc");
785 if (!IS_ERR(st
->reg
)) {
786 ret
= regulator_enable(st
->reg
);
792 st
->indio_dev
= iio_allocate_device();
793 if (st
->indio_dev
== NULL
) {
795 goto error_disable_reg
;
798 /* Estabilish that the iio_dev is a child of the i2c device */
799 st
->indio_dev
->dev
.parent
= &client
->dev
;
800 st
->indio_dev
->attrs
= st
->chip_info
->dev_attrs
;
801 st
->indio_dev
->event_attrs
= st
->chip_info
->event_attrs
;
803 st
->indio_dev
->dev_data
= (void *)(st
);
804 st
->indio_dev
->driver_module
= THIS_MODULE
;
805 st
->indio_dev
->modes
= INDIO_DIRECT_MODE
;
806 st
->indio_dev
->num_interrupt_lines
= 1;
808 ret
= ad799x_set_scan_mode(st
, 0);
810 goto error_free_device
;
812 ret
= ad799x_register_ring_funcs_and_init(st
->indio_dev
);
814 goto error_free_device
;
816 ret
= iio_device_register(st
->indio_dev
);
818 goto error_cleanup_ring
;
821 ret
= iio_ring_buffer_register(st
->indio_dev
->ring
, 0);
823 goto error_cleanup_ring
;
825 if (client
->irq
> 0 && st
->chip_info
->monitor_mode
) {
826 INIT_WORK(&st
->work_thresh
, ad799x_interrupt_bh
);
828 ret
= iio_register_interrupt_line(client
->irq
,
831 IRQF_TRIGGER_FALLING
,
834 goto error_cleanup_ring
;
837 * The event handler list element refer to iio_event_ad799x.
838 * All event attributes bind to the same event handler.
839 * So, only register event handler once.
841 iio_add_event_to_list(&iio_event_ad799x
,
842 &st
->indio_dev
->interrupts
[0]->ev_list
);
847 ad799x_ring_cleanup(st
->indio_dev
);
850 iio_free_device(st
->indio_dev
);
852 iio_device_unregister(st
->indio_dev
);
854 if (!IS_ERR(st
->reg
))
855 regulator_disable(st
->reg
);
857 if (!IS_ERR(st
->reg
))
858 regulator_put(st
->reg
);
864 static __devexit
int ad799x_remove(struct i2c_client
*client
)
866 struct ad799x_state
*st
= i2c_get_clientdata(client
);
867 struct iio_dev
*indio_dev
= st
->indio_dev
;
869 if (client
->irq
> 0 && st
->chip_info
->monitor_mode
)
870 iio_unregister_interrupt_line(indio_dev
, 0);
872 iio_ring_buffer_unregister(indio_dev
->ring
);
873 ad799x_ring_cleanup(indio_dev
);
874 iio_device_unregister(indio_dev
);
875 if (!IS_ERR(st
->reg
)) {
876 regulator_disable(st
->reg
);
877 regulator_put(st
->reg
);
884 static const struct i2c_device_id ad799x_id
[] = {
885 { "ad7991", ad7991
},
886 { "ad7995", ad7995
},
887 { "ad7999", ad7999
},
888 { "ad7992", ad7992
},
889 { "ad7993", ad7993
},
890 { "ad7994", ad7994
},
891 { "ad7997", ad7997
},
892 { "ad7998", ad7998
},
896 MODULE_DEVICE_TABLE(i2c
, ad799x_id
);
898 static struct i2c_driver ad799x_driver
= {
902 .probe
= ad799x_probe
,
903 .remove
= __devexit_p(ad799x_remove
),
904 .id_table
= ad799x_id
,
907 static __init
int ad799x_init(void)
909 return i2c_add_driver(&ad799x_driver
);
912 static __exit
void ad799x_exit(void)
914 i2c_del_driver(&ad799x_driver
);
917 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
918 MODULE_DESCRIPTION("Analog Devices AD799x ADC");
919 MODULE_LICENSE("GPL v2");
920 MODULE_ALIAS("i2c:ad799x");
922 module_init(ad799x_init
);
923 module_exit(ad799x_exit
);