2 * AD7606 SPI ADC driver
4 * Copyright 2011 Analog Devices Inc.
6 * Licensed under the GPL-2.
9 #include <linux/interrupt.h>
10 #include <linux/device.h>
11 #include <linux/kernel.h>
12 #include <linux/slab.h>
13 #include <linux/sysfs.h>
14 #include <linux/regulator/consumer.h>
15 #include <linux/err.h>
16 #include <linux/gpio.h>
17 #include <linux/delay.h>
18 #include <linux/sched.h>
19 #include <linux/module.h>
21 #include <linux/iio/iio.h>
22 #include <linux/iio/sysfs.h>
23 #include <linux/iio/buffer.h>
27 int ad7606_reset(struct ad7606_state
*st
)
29 if (gpio_is_valid(st
->pdata
->gpio_reset
)) {
30 gpio_set_value(st
->pdata
->gpio_reset
, 1);
31 ndelay(100); /* t_reset >= 100ns */
32 gpio_set_value(st
->pdata
->gpio_reset
, 0);
39 static int ad7606_scan_direct(struct iio_dev
*indio_dev
, unsigned ch
)
41 struct ad7606_state
*st
= iio_priv(indio_dev
);
45 gpio_set_value(st
->pdata
->gpio_convst
, 1);
47 ret
= wait_event_interruptible(st
->wq_data_avail
, st
->done
);
51 if (gpio_is_valid(st
->pdata
->gpio_frstdata
)) {
52 ret
= st
->bops
->read_block(st
->dev
, 1, st
->data
);
55 if (!gpio_get_value(st
->pdata
->gpio_frstdata
)) {
56 /* This should never happen */
61 ret
= st
->bops
->read_block(st
->dev
,
62 st
->chip_info
->num_channels
- 1, &st
->data
[1]);
66 ret
= st
->bops
->read_block(st
->dev
,
67 st
->chip_info
->num_channels
, st
->data
);
75 gpio_set_value(st
->pdata
->gpio_convst
, 0);
80 static int ad7606_read_raw(struct iio_dev
*indio_dev
,
81 struct iio_chan_spec
const *chan
,
87 struct ad7606_state
*st
= iio_priv(indio_dev
);
88 unsigned int scale_uv
;
91 case IIO_CHAN_INFO_RAW
:
92 mutex_lock(&indio_dev
->mlock
);
93 if (iio_buffer_enabled(indio_dev
))
96 ret
= ad7606_scan_direct(indio_dev
, chan
->address
);
97 mutex_unlock(&indio_dev
->mlock
);
103 case IIO_CHAN_INFO_SCALE
:
104 scale_uv
= (st
->range
* 1000 * 2)
105 >> st
->chip_info
->channels
[0].scan_type
.realbits
;
106 *val
= scale_uv
/ 1000;
107 *val2
= (scale_uv
% 1000) * 1000;
108 return IIO_VAL_INT_PLUS_MICRO
;
113 static ssize_t
ad7606_show_range(struct device
*dev
,
114 struct device_attribute
*attr
, char *buf
)
116 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
117 struct ad7606_state
*st
= iio_priv(indio_dev
);
119 return sprintf(buf
, "%u\n", st
->range
);
122 static ssize_t
ad7606_store_range(struct device
*dev
,
123 struct device_attribute
*attr
, const char *buf
, size_t count
)
125 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
126 struct ad7606_state
*st
= iio_priv(indio_dev
);
129 if (strict_strtoul(buf
, 10, &lval
))
131 if (!(lval
== 5000 || lval
== 10000)) {
132 dev_err(dev
, "range is not supported\n");
135 mutex_lock(&indio_dev
->mlock
);
136 gpio_set_value(st
->pdata
->gpio_range
, lval
== 10000);
138 mutex_unlock(&indio_dev
->mlock
);
143 static IIO_DEVICE_ATTR(in_voltage_range
, S_IRUGO
| S_IWUSR
, \
144 ad7606_show_range
, ad7606_store_range
, 0);
145 static IIO_CONST_ATTR(in_voltage_range_available
, "5000 10000");
147 static ssize_t
ad7606_show_oversampling_ratio(struct device
*dev
,
148 struct device_attribute
*attr
, char *buf
)
150 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
151 struct ad7606_state
*st
= iio_priv(indio_dev
);
153 return sprintf(buf
, "%u\n", st
->oversampling
);
156 static int ad7606_oversampling_get_index(unsigned val
)
158 unsigned char supported
[] = {0, 2, 4, 8, 16, 32, 64};
161 for (i
= 0; i
< ARRAY_SIZE(supported
); i
++)
162 if (val
== supported
[i
])
168 static ssize_t
ad7606_store_oversampling_ratio(struct device
*dev
,
169 struct device_attribute
*attr
, const char *buf
, size_t count
)
171 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
172 struct ad7606_state
*st
= iio_priv(indio_dev
);
176 if (strict_strtoul(buf
, 10, &lval
))
179 ret
= ad7606_oversampling_get_index(lval
);
181 dev_err(dev
, "oversampling %lu is not supported\n", lval
);
185 mutex_lock(&indio_dev
->mlock
);
186 gpio_set_value(st
->pdata
->gpio_os0
, (ret
>> 0) & 1);
187 gpio_set_value(st
->pdata
->gpio_os1
, (ret
>> 1) & 1);
188 gpio_set_value(st
->pdata
->gpio_os1
, (ret
>> 2) & 1);
189 st
->oversampling
= lval
;
190 mutex_unlock(&indio_dev
->mlock
);
195 static IIO_DEVICE_ATTR(oversampling_ratio
, S_IRUGO
| S_IWUSR
,
196 ad7606_show_oversampling_ratio
,
197 ad7606_store_oversampling_ratio
, 0);
198 static IIO_CONST_ATTR(oversampling_ratio_available
, "0 2 4 8 16 32 64");
200 static struct attribute
*ad7606_attributes_os_and_range
[] = {
201 &iio_dev_attr_in_voltage_range
.dev_attr
.attr
,
202 &iio_const_attr_in_voltage_range_available
.dev_attr
.attr
,
203 &iio_dev_attr_oversampling_ratio
.dev_attr
.attr
,
204 &iio_const_attr_oversampling_ratio_available
.dev_attr
.attr
,
208 static const struct attribute_group ad7606_attribute_group_os_and_range
= {
209 .attrs
= ad7606_attributes_os_and_range
,
212 static struct attribute
*ad7606_attributes_os
[] = {
213 &iio_dev_attr_oversampling_ratio
.dev_attr
.attr
,
214 &iio_const_attr_oversampling_ratio_available
.dev_attr
.attr
,
218 static const struct attribute_group ad7606_attribute_group_os
= {
219 .attrs
= ad7606_attributes_os
,
222 static struct attribute
*ad7606_attributes_range
[] = {
223 &iio_dev_attr_in_voltage_range
.dev_attr
.attr
,
224 &iio_const_attr_in_voltage_range_available
.dev_attr
.attr
,
228 static const struct attribute_group ad7606_attribute_group_range
= {
229 .attrs
= ad7606_attributes_range
,
232 #define AD7606_CHANNEL(num) \
234 .type = IIO_VOLTAGE, \
238 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
239 IIO_CHAN_INFO_SCALE_SHARED_BIT, \
241 .scan_type = IIO_ST('s', 16, 16, 0), \
244 static struct iio_chan_spec ad7606_8_channels
[] = {
253 IIO_CHAN_SOFT_TIMESTAMP(8),
256 static struct iio_chan_spec ad7606_6_channels
[] = {
263 IIO_CHAN_SOFT_TIMESTAMP(6),
266 static struct iio_chan_spec ad7606_4_channels
[] = {
271 IIO_CHAN_SOFT_TIMESTAMP(4),
274 static const struct ad7606_chip_info ad7606_chip_info_tbl
[] = {
276 * More devices added in future
281 .channels
= ad7606_8_channels
,
287 .channels
= ad7606_6_channels
,
293 .channels
= ad7606_4_channels
,
298 static int ad7606_request_gpios(struct ad7606_state
*st
)
300 struct gpio gpio_array
[3] = {
302 .gpio
= st
->pdata
->gpio_os0
,
303 .flags
= GPIOF_DIR_OUT
| ((st
->oversampling
& 1) ?
304 GPIOF_INIT_HIGH
: GPIOF_INIT_LOW
),
305 .label
= "AD7606_OS0",
308 .gpio
= st
->pdata
->gpio_os1
,
309 .flags
= GPIOF_DIR_OUT
| ((st
->oversampling
& 2) ?
310 GPIOF_INIT_HIGH
: GPIOF_INIT_LOW
),
311 .label
= "AD7606_OS1",
314 .gpio
= st
->pdata
->gpio_os2
,
315 .flags
= GPIOF_DIR_OUT
| ((st
->oversampling
& 4) ?
316 GPIOF_INIT_HIGH
: GPIOF_INIT_LOW
),
317 .label
= "AD7606_OS2",
322 if (gpio_is_valid(st
->pdata
->gpio_convst
)) {
323 ret
= gpio_request_one(st
->pdata
->gpio_convst
,
327 dev_err(st
->dev
, "failed to request GPIO CONVST\n");
335 if (gpio_is_valid(st
->pdata
->gpio_os0
) &&
336 gpio_is_valid(st
->pdata
->gpio_os1
) &&
337 gpio_is_valid(st
->pdata
->gpio_os2
)) {
338 ret
= gpio_request_array(gpio_array
, ARRAY_SIZE(gpio_array
));
340 goto error_free_convst
;
343 if (gpio_is_valid(st
->pdata
->gpio_reset
)) {
344 ret
= gpio_request_one(st
->pdata
->gpio_reset
,
351 if (gpio_is_valid(st
->pdata
->gpio_range
)) {
352 ret
= gpio_request_one(st
->pdata
->gpio_range
, GPIOF_DIR_OUT
|
353 ((st
->range
== 10000) ? GPIOF_INIT_HIGH
:
354 GPIOF_INIT_LOW
), "AD7606_RANGE");
356 goto error_free_reset
;
358 if (gpio_is_valid(st
->pdata
->gpio_stby
)) {
359 ret
= gpio_request_one(st
->pdata
->gpio_stby
,
363 goto error_free_range
;
366 if (gpio_is_valid(st
->pdata
->gpio_frstdata
)) {
367 ret
= gpio_request_one(st
->pdata
->gpio_frstdata
, GPIOF_IN
,
370 goto error_free_stby
;
376 if (gpio_is_valid(st
->pdata
->gpio_stby
))
377 gpio_free(st
->pdata
->gpio_stby
);
379 if (gpio_is_valid(st
->pdata
->gpio_range
))
380 gpio_free(st
->pdata
->gpio_range
);
382 if (gpio_is_valid(st
->pdata
->gpio_reset
))
383 gpio_free(st
->pdata
->gpio_reset
);
385 if (gpio_is_valid(st
->pdata
->gpio_os0
) &&
386 gpio_is_valid(st
->pdata
->gpio_os1
) &&
387 gpio_is_valid(st
->pdata
->gpio_os2
))
388 gpio_free_array(gpio_array
, ARRAY_SIZE(gpio_array
));
390 gpio_free(st
->pdata
->gpio_convst
);
395 static void ad7606_free_gpios(struct ad7606_state
*st
)
397 if (gpio_is_valid(st
->pdata
->gpio_frstdata
))
398 gpio_free(st
->pdata
->gpio_frstdata
);
399 if (gpio_is_valid(st
->pdata
->gpio_stby
))
400 gpio_free(st
->pdata
->gpio_stby
);
401 if (gpio_is_valid(st
->pdata
->gpio_range
))
402 gpio_free(st
->pdata
->gpio_range
);
403 if (gpio_is_valid(st
->pdata
->gpio_reset
))
404 gpio_free(st
->pdata
->gpio_reset
);
405 if (gpio_is_valid(st
->pdata
->gpio_os0
) &&
406 gpio_is_valid(st
->pdata
->gpio_os1
) &&
407 gpio_is_valid(st
->pdata
->gpio_os2
)) {
408 gpio_free(st
->pdata
->gpio_os2
);
409 gpio_free(st
->pdata
->gpio_os1
);
410 gpio_free(st
->pdata
->gpio_os0
);
412 gpio_free(st
->pdata
->gpio_convst
);
418 static irqreturn_t
ad7606_interrupt(int irq
, void *dev_id
)
420 struct iio_dev
*indio_dev
= dev_id
;
421 struct ad7606_state
*st
= iio_priv(indio_dev
);
423 if (iio_buffer_enabled(indio_dev
)) {
424 if (!work_pending(&st
->poll_work
))
425 schedule_work(&st
->poll_work
);
428 wake_up_interruptible(&st
->wq_data_avail
);
434 static const struct iio_info ad7606_info_no_os_or_range
= {
435 .driver_module
= THIS_MODULE
,
436 .read_raw
= &ad7606_read_raw
,
439 static const struct iio_info ad7606_info_os_and_range
= {
440 .driver_module
= THIS_MODULE
,
441 .read_raw
= &ad7606_read_raw
,
442 .attrs
= &ad7606_attribute_group_os_and_range
,
445 static const struct iio_info ad7606_info_os
= {
446 .driver_module
= THIS_MODULE
,
447 .read_raw
= &ad7606_read_raw
,
448 .attrs
= &ad7606_attribute_group_os
,
451 static const struct iio_info ad7606_info_range
= {
452 .driver_module
= THIS_MODULE
,
453 .read_raw
= &ad7606_read_raw
,
454 .attrs
= &ad7606_attribute_group_range
,
457 struct iio_dev
*ad7606_probe(struct device
*dev
, int irq
,
458 void __iomem
*base_address
,
460 const struct ad7606_bus_ops
*bops
)
462 struct ad7606_platform_data
*pdata
= dev
->platform_data
;
463 struct ad7606_state
*st
;
465 struct iio_dev
*indio_dev
= iio_device_alloc(sizeof(*st
));
467 if (indio_dev
== NULL
) {
472 st
= iio_priv(indio_dev
);
476 st
->base_address
= base_address
;
477 st
->range
= pdata
->default_range
== 10000 ? 10000 : 5000;
479 ret
= ad7606_oversampling_get_index(pdata
->default_os
);
481 dev_warn(dev
, "oversampling %d is not supported\n",
483 st
->oversampling
= 0;
485 st
->oversampling
= pdata
->default_os
;
488 st
->reg
= regulator_get(dev
, "vcc");
489 if (!IS_ERR(st
->reg
)) {
490 ret
= regulator_enable(st
->reg
);
496 st
->chip_info
= &ad7606_chip_info_tbl
[id
];
498 indio_dev
->dev
.parent
= dev
;
499 if (gpio_is_valid(st
->pdata
->gpio_os0
) &&
500 gpio_is_valid(st
->pdata
->gpio_os1
) &&
501 gpio_is_valid(st
->pdata
->gpio_os2
)) {
502 if (gpio_is_valid(st
->pdata
->gpio_range
))
503 indio_dev
->info
= &ad7606_info_os_and_range
;
505 indio_dev
->info
= &ad7606_info_os
;
507 if (gpio_is_valid(st
->pdata
->gpio_range
))
508 indio_dev
->info
= &ad7606_info_range
;
510 indio_dev
->info
= &ad7606_info_no_os_or_range
;
512 indio_dev
->modes
= INDIO_DIRECT_MODE
;
513 indio_dev
->name
= st
->chip_info
->name
;
514 indio_dev
->channels
= st
->chip_info
->channels
;
515 indio_dev
->num_channels
= st
->chip_info
->num_channels
;
517 init_waitqueue_head(&st
->wq_data_avail
);
519 ret
= ad7606_request_gpios(st
);
521 goto error_disable_reg
;
523 ret
= ad7606_reset(st
);
525 dev_warn(st
->dev
, "failed to RESET: no RESET GPIO specified\n");
527 ret
= request_irq(irq
, ad7606_interrupt
,
528 IRQF_TRIGGER_FALLING
, st
->chip_info
->name
, indio_dev
);
530 goto error_free_gpios
;
532 ret
= ad7606_register_ring_funcs_and_init(indio_dev
);
536 ret
= iio_buffer_register(indio_dev
,
538 indio_dev
->num_channels
);
540 goto error_cleanup_ring
;
541 ret
= iio_device_register(indio_dev
);
543 goto error_unregister_ring
;
546 error_unregister_ring
:
547 iio_buffer_unregister(indio_dev
);
550 ad7606_ring_cleanup(indio_dev
);
553 free_irq(irq
, indio_dev
);
556 ad7606_free_gpios(st
);
559 if (!IS_ERR(st
->reg
))
560 regulator_disable(st
->reg
);
562 if (!IS_ERR(st
->reg
))
563 regulator_put(st
->reg
);
564 iio_device_free(indio_dev
);
569 int ad7606_remove(struct iio_dev
*indio_dev
, int irq
)
571 struct ad7606_state
*st
= iio_priv(indio_dev
);
573 iio_device_unregister(indio_dev
);
574 iio_buffer_unregister(indio_dev
);
575 ad7606_ring_cleanup(indio_dev
);
577 free_irq(irq
, indio_dev
);
578 if (!IS_ERR(st
->reg
)) {
579 regulator_disable(st
->reg
);
580 regulator_put(st
->reg
);
583 ad7606_free_gpios(st
);
584 iio_device_free(indio_dev
);
589 void ad7606_suspend(struct iio_dev
*indio_dev
)
591 struct ad7606_state
*st
= iio_priv(indio_dev
);
593 if (gpio_is_valid(st
->pdata
->gpio_stby
)) {
594 if (gpio_is_valid(st
->pdata
->gpio_range
))
595 gpio_set_value(st
->pdata
->gpio_range
, 1);
596 gpio_set_value(st
->pdata
->gpio_stby
, 0);
600 void ad7606_resume(struct iio_dev
*indio_dev
)
602 struct ad7606_state
*st
= iio_priv(indio_dev
);
604 if (gpio_is_valid(st
->pdata
->gpio_stby
)) {
605 if (gpio_is_valid(st
->pdata
->gpio_range
))
606 gpio_set_value(st
->pdata
->gpio_range
,
609 gpio_set_value(st
->pdata
->gpio_stby
, 1);
614 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
615 MODULE_DESCRIPTION("Analog Devices AD7606 ADC");
616 MODULE_LICENSE("GPL v2");