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
);
90 case IIO_CHAN_INFO_RAW
:
91 mutex_lock(&indio_dev
->mlock
);
92 if (iio_buffer_enabled(indio_dev
))
95 ret
= ad7606_scan_direct(indio_dev
, chan
->address
);
96 mutex_unlock(&indio_dev
->mlock
);
102 case IIO_CHAN_INFO_SCALE
:
103 *val
= st
->range
* 2;
104 *val2
= st
->chip_info
->channels
[0].scan_type
.realbits
;
105 return IIO_VAL_FRACTIONAL_LOG2
;
110 static ssize_t
ad7606_show_range(struct device
*dev
,
111 struct device_attribute
*attr
, char *buf
)
113 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
114 struct ad7606_state
*st
= iio_priv(indio_dev
);
116 return sprintf(buf
, "%u\n", st
->range
);
119 static ssize_t
ad7606_store_range(struct device
*dev
,
120 struct device_attribute
*attr
, const char *buf
, size_t count
)
122 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
123 struct ad7606_state
*st
= iio_priv(indio_dev
);
127 ret
= kstrtoul(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 ret
= kstrtoul(buf
, 10, &lval
);
180 ret
= ad7606_oversampling_get_index(lval
);
182 dev_err(dev
, "oversampling %lu is not supported\n", lval
);
186 mutex_lock(&indio_dev
->mlock
);
187 gpio_set_value(st
->pdata
->gpio_os0
, (ret
>> 0) & 1);
188 gpio_set_value(st
->pdata
->gpio_os1
, (ret
>> 1) & 1);
189 gpio_set_value(st
->pdata
->gpio_os1
, (ret
>> 2) & 1);
190 st
->oversampling
= lval
;
191 mutex_unlock(&indio_dev
->mlock
);
196 static IIO_DEVICE_ATTR(oversampling_ratio
, S_IRUGO
| S_IWUSR
,
197 ad7606_show_oversampling_ratio
,
198 ad7606_store_oversampling_ratio
, 0);
199 static IIO_CONST_ATTR(oversampling_ratio_available
, "0 2 4 8 16 32 64");
201 static struct attribute
*ad7606_attributes_os_and_range
[] = {
202 &iio_dev_attr_in_voltage_range
.dev_attr
.attr
,
203 &iio_const_attr_in_voltage_range_available
.dev_attr
.attr
,
204 &iio_dev_attr_oversampling_ratio
.dev_attr
.attr
,
205 &iio_const_attr_oversampling_ratio_available
.dev_attr
.attr
,
209 static const struct attribute_group ad7606_attribute_group_os_and_range
= {
210 .attrs
= ad7606_attributes_os_and_range
,
213 static struct attribute
*ad7606_attributes_os
[] = {
214 &iio_dev_attr_oversampling_ratio
.dev_attr
.attr
,
215 &iio_const_attr_oversampling_ratio_available
.dev_attr
.attr
,
219 static const struct attribute_group ad7606_attribute_group_os
= {
220 .attrs
= ad7606_attributes_os
,
223 static struct attribute
*ad7606_attributes_range
[] = {
224 &iio_dev_attr_in_voltage_range
.dev_attr
.attr
,
225 &iio_const_attr_in_voltage_range_available
.dev_attr
.attr
,
229 static const struct attribute_group ad7606_attribute_group_range
= {
230 .attrs
= ad7606_attributes_range
,
233 #define AD7606_CHANNEL(num) \
235 .type = IIO_VOLTAGE, \
239 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
240 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),\
246 .endianness = IIO_CPU, \
250 static const struct iio_chan_spec ad7606_8_channels
[] = {
259 IIO_CHAN_SOFT_TIMESTAMP(8),
262 static const struct iio_chan_spec ad7606_6_channels
[] = {
269 IIO_CHAN_SOFT_TIMESTAMP(6),
272 static const struct iio_chan_spec ad7606_4_channels
[] = {
277 IIO_CHAN_SOFT_TIMESTAMP(4),
280 static const struct ad7606_chip_info ad7606_chip_info_tbl
[] = {
282 * More devices added in future
287 .channels
= ad7606_8_channels
,
293 .channels
= ad7606_6_channels
,
299 .channels
= ad7606_4_channels
,
304 static int ad7606_request_gpios(struct ad7606_state
*st
)
306 struct gpio gpio_array
[3] = {
308 .gpio
= st
->pdata
->gpio_os0
,
309 .flags
= GPIOF_DIR_OUT
| ((st
->oversampling
& 1) ?
310 GPIOF_INIT_HIGH
: GPIOF_INIT_LOW
),
311 .label
= "AD7606_OS0",
314 .gpio
= st
->pdata
->gpio_os1
,
315 .flags
= GPIOF_DIR_OUT
| ((st
->oversampling
& 2) ?
316 GPIOF_INIT_HIGH
: GPIOF_INIT_LOW
),
317 .label
= "AD7606_OS1",
320 .gpio
= st
->pdata
->gpio_os2
,
321 .flags
= GPIOF_DIR_OUT
| ((st
->oversampling
& 4) ?
322 GPIOF_INIT_HIGH
: GPIOF_INIT_LOW
),
323 .label
= "AD7606_OS2",
328 if (gpio_is_valid(st
->pdata
->gpio_convst
)) {
329 ret
= gpio_request_one(st
->pdata
->gpio_convst
,
333 dev_err(st
->dev
, "failed to request GPIO CONVST\n");
341 if (gpio_is_valid(st
->pdata
->gpio_os0
) &&
342 gpio_is_valid(st
->pdata
->gpio_os1
) &&
343 gpio_is_valid(st
->pdata
->gpio_os2
)) {
344 ret
= gpio_request_array(gpio_array
, ARRAY_SIZE(gpio_array
));
346 goto error_free_convst
;
349 if (gpio_is_valid(st
->pdata
->gpio_reset
)) {
350 ret
= gpio_request_one(st
->pdata
->gpio_reset
,
357 if (gpio_is_valid(st
->pdata
->gpio_range
)) {
358 ret
= gpio_request_one(st
->pdata
->gpio_range
, GPIOF_DIR_OUT
|
359 ((st
->range
== 10000) ? GPIOF_INIT_HIGH
:
360 GPIOF_INIT_LOW
), "AD7606_RANGE");
362 goto error_free_reset
;
364 if (gpio_is_valid(st
->pdata
->gpio_stby
)) {
365 ret
= gpio_request_one(st
->pdata
->gpio_stby
,
369 goto error_free_range
;
372 if (gpio_is_valid(st
->pdata
->gpio_frstdata
)) {
373 ret
= gpio_request_one(st
->pdata
->gpio_frstdata
, GPIOF_IN
,
376 goto error_free_stby
;
382 if (gpio_is_valid(st
->pdata
->gpio_stby
))
383 gpio_free(st
->pdata
->gpio_stby
);
385 if (gpio_is_valid(st
->pdata
->gpio_range
))
386 gpio_free(st
->pdata
->gpio_range
);
388 if (gpio_is_valid(st
->pdata
->gpio_reset
))
389 gpio_free(st
->pdata
->gpio_reset
);
391 if (gpio_is_valid(st
->pdata
->gpio_os0
) &&
392 gpio_is_valid(st
->pdata
->gpio_os1
) &&
393 gpio_is_valid(st
->pdata
->gpio_os2
))
394 gpio_free_array(gpio_array
, ARRAY_SIZE(gpio_array
));
396 gpio_free(st
->pdata
->gpio_convst
);
401 static void ad7606_free_gpios(struct ad7606_state
*st
)
403 if (gpio_is_valid(st
->pdata
->gpio_frstdata
))
404 gpio_free(st
->pdata
->gpio_frstdata
);
405 if (gpio_is_valid(st
->pdata
->gpio_stby
))
406 gpio_free(st
->pdata
->gpio_stby
);
407 if (gpio_is_valid(st
->pdata
->gpio_range
))
408 gpio_free(st
->pdata
->gpio_range
);
409 if (gpio_is_valid(st
->pdata
->gpio_reset
))
410 gpio_free(st
->pdata
->gpio_reset
);
411 if (gpio_is_valid(st
->pdata
->gpio_os0
) &&
412 gpio_is_valid(st
->pdata
->gpio_os1
) &&
413 gpio_is_valid(st
->pdata
->gpio_os2
)) {
414 gpio_free(st
->pdata
->gpio_os2
);
415 gpio_free(st
->pdata
->gpio_os1
);
416 gpio_free(st
->pdata
->gpio_os0
);
418 gpio_free(st
->pdata
->gpio_convst
);
424 static irqreturn_t
ad7606_interrupt(int irq
, void *dev_id
)
426 struct iio_dev
*indio_dev
= dev_id
;
427 struct ad7606_state
*st
= iio_priv(indio_dev
);
429 if (iio_buffer_enabled(indio_dev
)) {
430 schedule_work(&st
->poll_work
);
433 wake_up_interruptible(&st
->wq_data_avail
);
439 static const struct iio_info ad7606_info_no_os_or_range
= {
440 .driver_module
= THIS_MODULE
,
441 .read_raw
= &ad7606_read_raw
,
444 static const struct iio_info ad7606_info_os_and_range
= {
445 .driver_module
= THIS_MODULE
,
446 .read_raw
= &ad7606_read_raw
,
447 .attrs
= &ad7606_attribute_group_os_and_range
,
450 static const struct iio_info ad7606_info_os
= {
451 .driver_module
= THIS_MODULE
,
452 .read_raw
= &ad7606_read_raw
,
453 .attrs
= &ad7606_attribute_group_os
,
456 static const struct iio_info ad7606_info_range
= {
457 .driver_module
= THIS_MODULE
,
458 .read_raw
= &ad7606_read_raw
,
459 .attrs
= &ad7606_attribute_group_range
,
462 struct iio_dev
*ad7606_probe(struct device
*dev
, int irq
,
463 void __iomem
*base_address
,
465 const struct ad7606_bus_ops
*bops
)
467 struct ad7606_platform_data
*pdata
= dev
->platform_data
;
468 struct ad7606_state
*st
;
470 struct iio_dev
*indio_dev
;
472 indio_dev
= devm_iio_device_alloc(dev
, sizeof(*st
));
474 return ERR_PTR(-ENOMEM
);
476 st
= iio_priv(indio_dev
);
480 st
->base_address
= base_address
;
481 st
->range
= pdata
->default_range
== 10000 ? 10000 : 5000;
483 ret
= ad7606_oversampling_get_index(pdata
->default_os
);
485 dev_warn(dev
, "oversampling %d is not supported\n",
487 st
->oversampling
= 0;
489 st
->oversampling
= pdata
->default_os
;
492 st
->reg
= devm_regulator_get(dev
, "vcc");
493 if (!IS_ERR(st
->reg
)) {
494 ret
= regulator_enable(st
->reg
);
500 st
->chip_info
= &ad7606_chip_info_tbl
[id
];
502 indio_dev
->dev
.parent
= dev
;
503 if (gpio_is_valid(st
->pdata
->gpio_os0
) &&
504 gpio_is_valid(st
->pdata
->gpio_os1
) &&
505 gpio_is_valid(st
->pdata
->gpio_os2
)) {
506 if (gpio_is_valid(st
->pdata
->gpio_range
))
507 indio_dev
->info
= &ad7606_info_os_and_range
;
509 indio_dev
->info
= &ad7606_info_os
;
511 if (gpio_is_valid(st
->pdata
->gpio_range
))
512 indio_dev
->info
= &ad7606_info_range
;
514 indio_dev
->info
= &ad7606_info_no_os_or_range
;
516 indio_dev
->modes
= INDIO_DIRECT_MODE
;
517 indio_dev
->name
= st
->chip_info
->name
;
518 indio_dev
->channels
= st
->chip_info
->channels
;
519 indio_dev
->num_channels
= st
->chip_info
->num_channels
;
521 init_waitqueue_head(&st
->wq_data_avail
);
523 ret
= ad7606_request_gpios(st
);
525 goto error_disable_reg
;
527 ret
= ad7606_reset(st
);
529 dev_warn(st
->dev
, "failed to RESET: no RESET GPIO specified\n");
531 ret
= request_irq(irq
, ad7606_interrupt
,
532 IRQF_TRIGGER_FALLING
, st
->chip_info
->name
, indio_dev
);
534 goto error_free_gpios
;
536 ret
= ad7606_register_ring_funcs_and_init(indio_dev
);
540 ret
= iio_device_register(indio_dev
);
542 goto error_unregister_ring
;
545 error_unregister_ring
:
546 ad7606_ring_cleanup(indio_dev
);
549 free_irq(irq
, indio_dev
);
552 ad7606_free_gpios(st
);
555 if (!IS_ERR(st
->reg
))
556 regulator_disable(st
->reg
);
560 int ad7606_remove(struct iio_dev
*indio_dev
, int irq
)
562 struct ad7606_state
*st
= iio_priv(indio_dev
);
564 iio_device_unregister(indio_dev
);
565 ad7606_ring_cleanup(indio_dev
);
567 free_irq(irq
, indio_dev
);
568 if (!IS_ERR(st
->reg
))
569 regulator_disable(st
->reg
);
571 ad7606_free_gpios(st
);
576 void ad7606_suspend(struct iio_dev
*indio_dev
)
578 struct ad7606_state
*st
= iio_priv(indio_dev
);
580 if (gpio_is_valid(st
->pdata
->gpio_stby
)) {
581 if (gpio_is_valid(st
->pdata
->gpio_range
))
582 gpio_set_value(st
->pdata
->gpio_range
, 1);
583 gpio_set_value(st
->pdata
->gpio_stby
, 0);
587 void ad7606_resume(struct iio_dev
*indio_dev
)
589 struct ad7606_state
*st
= iio_priv(indio_dev
);
591 if (gpio_is_valid(st
->pdata
->gpio_stby
)) {
592 if (gpio_is_valid(st
->pdata
->gpio_range
))
593 gpio_set_value(st
->pdata
->gpio_range
,
596 gpio_set_value(st
->pdata
->gpio_stby
, 1);
601 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
602 MODULE_DESCRIPTION("Analog Devices AD7606 ADC");
603 MODULE_LICENSE("GPL v2");