2 * AD7266/65 SPI ADC driver
4 * Copyright 2012 Analog Devices Inc.
6 * Licensed under the GPL-2.
9 #include <linux/device.h>
10 #include <linux/kernel.h>
11 #include <linux/slab.h>
12 #include <linux/spi/spi.h>
13 #include <linux/regulator/consumer.h>
14 #include <linux/err.h>
15 #include <linux/gpio.h>
16 #include <linux/module.h>
18 #include <linux/interrupt.h>
20 #include <linux/iio/iio.h>
21 #include <linux/iio/buffer.h>
22 #include <linux/iio/trigger_consumer.h>
23 #include <linux/iio/triggered_buffer.h>
25 #include <linux/platform_data/ad7266.h>
28 struct spi_device
*spi
;
29 struct regulator
*reg
;
30 unsigned long vref_uv
;
32 struct spi_transfer single_xfer
[3];
33 struct spi_message single_msg
;
35 enum ad7266_range range
;
36 enum ad7266_mode mode
;
41 * DMA (thus cache coherency maintenance) requires the
42 * transfer buffers to live in their own cache lines.
43 * The buffer needs to be large enough to hold two samples (4 bytes) and
44 * the naturally aligned timestamp (8 bytes).
46 uint8_t data
[ALIGN(4, sizeof(s64
)) + sizeof(s64
)] ____cacheline_aligned
;
49 static int ad7266_wakeup(struct ad7266_state
*st
)
51 /* Any read with >= 2 bytes will wake the device */
52 return spi_read(st
->spi
, st
->data
, 2);
55 static int ad7266_powerdown(struct ad7266_state
*st
)
57 /* Any read with < 2 bytes will powerdown the device */
58 return spi_read(st
->spi
, st
->data
, 1);
61 static int ad7266_preenable(struct iio_dev
*indio_dev
)
63 struct ad7266_state
*st
= iio_priv(indio_dev
);
66 ret
= ad7266_wakeup(st
);
70 ret
= iio_sw_buffer_preenable(indio_dev
);
77 static int ad7266_postdisable(struct iio_dev
*indio_dev
)
79 struct ad7266_state
*st
= iio_priv(indio_dev
);
80 return ad7266_powerdown(st
);
83 static const struct iio_buffer_setup_ops iio_triggered_buffer_setup_ops
= {
84 .preenable
= &ad7266_preenable
,
85 .postenable
= &iio_triggered_buffer_postenable
,
86 .predisable
= &iio_triggered_buffer_predisable
,
87 .postdisable
= &ad7266_postdisable
,
90 static irqreturn_t
ad7266_trigger_handler(int irq
, void *p
)
92 struct iio_poll_func
*pf
= p
;
93 struct iio_dev
*indio_dev
= pf
->indio_dev
;
94 struct ad7266_state
*st
= iio_priv(indio_dev
);
97 ret
= spi_read(st
->spi
, st
->data
, 4);
99 iio_push_to_buffers_with_timestamp(indio_dev
, st
->data
,
103 iio_trigger_notify_done(indio_dev
->trig
);
108 static void ad7266_select_input(struct ad7266_state
*st
, unsigned int nr
)
116 case AD7266_MODE_SINGLE_ENDED
:
119 case AD7266_MODE_PSEUDO_DIFF
:
122 case AD7266_MODE_DIFF
:
127 for (i
= 0; i
< 3; ++i
)
128 gpio_set_value(st
->gpios
[i
].gpio
, (bool)(nr
& BIT(i
)));
131 static int ad7266_update_scan_mode(struct iio_dev
*indio_dev
,
132 const unsigned long *scan_mask
)
134 struct ad7266_state
*st
= iio_priv(indio_dev
);
135 unsigned int nr
= find_first_bit(scan_mask
, indio_dev
->masklength
);
137 ad7266_select_input(st
, nr
);
142 static int ad7266_read_single(struct ad7266_state
*st
, int *val
,
143 unsigned int address
)
147 ad7266_select_input(st
, address
);
149 ret
= spi_sync(st
->spi
, &st
->single_msg
);
150 *val
= be16_to_cpu(st
->data
[address
% 2]);
155 static int ad7266_read_raw(struct iio_dev
*indio_dev
,
156 struct iio_chan_spec
const *chan
, int *val
, int *val2
, long m
)
158 struct ad7266_state
*st
= iio_priv(indio_dev
);
159 unsigned long scale_uv
;
163 case IIO_CHAN_INFO_RAW
:
164 if (iio_buffer_enabled(indio_dev
))
167 ret
= ad7266_read_single(st
, val
, chan
->address
);
171 *val
= (*val
>> 2) & 0xfff;
172 if (chan
->scan_type
.sign
== 's')
173 *val
= sign_extend32(*val
, 11);
176 case IIO_CHAN_INFO_SCALE
:
177 scale_uv
= (st
->vref_uv
* 100);
178 if (st
->mode
== AD7266_MODE_DIFF
)
180 if (st
->range
== AD7266_RANGE_2VREF
)
183 scale_uv
>>= chan
->scan_type
.realbits
;
184 *val
= scale_uv
/ 100000;
185 *val2
= (scale_uv
% 100000) * 10;
186 return IIO_VAL_INT_PLUS_MICRO
;
187 case IIO_CHAN_INFO_OFFSET
:
188 if (st
->range
== AD7266_RANGE_2VREF
&&
189 st
->mode
!= AD7266_MODE_DIFF
)
198 #define AD7266_CHAN(_chan, _sign) { \
199 .type = IIO_VOLTAGE, \
201 .channel = (_chan), \
202 .address = (_chan), \
203 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
204 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) \
205 | BIT(IIO_CHAN_INFO_OFFSET), \
206 .scan_index = (_chan), \
212 .endianness = IIO_BE, \
216 #define AD7266_DECLARE_SINGLE_ENDED_CHANNELS(_name, _sign) \
217 const struct iio_chan_spec ad7266_channels_##_name[] = { \
218 AD7266_CHAN(0, (_sign)), \
219 AD7266_CHAN(1, (_sign)), \
220 AD7266_CHAN(2, (_sign)), \
221 AD7266_CHAN(3, (_sign)), \
222 AD7266_CHAN(4, (_sign)), \
223 AD7266_CHAN(5, (_sign)), \
224 AD7266_CHAN(6, (_sign)), \
225 AD7266_CHAN(7, (_sign)), \
226 AD7266_CHAN(8, (_sign)), \
227 AD7266_CHAN(9, (_sign)), \
228 AD7266_CHAN(10, (_sign)), \
229 AD7266_CHAN(11, (_sign)), \
230 IIO_CHAN_SOFT_TIMESTAMP(13), \
233 #define AD7266_DECLARE_SINGLE_ENDED_CHANNELS_FIXED(_name, _sign) \
234 const struct iio_chan_spec ad7266_channels_##_name##_fixed[] = { \
235 AD7266_CHAN(0, (_sign)), \
236 AD7266_CHAN(1, (_sign)), \
237 IIO_CHAN_SOFT_TIMESTAMP(2), \
240 static AD7266_DECLARE_SINGLE_ENDED_CHANNELS(u
, 'u');
241 static AD7266_DECLARE_SINGLE_ENDED_CHANNELS(s
, 's');
242 static AD7266_DECLARE_SINGLE_ENDED_CHANNELS_FIXED(u
, 'u');
243 static AD7266_DECLARE_SINGLE_ENDED_CHANNELS_FIXED(s
, 's');
245 #define AD7266_CHAN_DIFF(_chan, _sign) { \
246 .type = IIO_VOLTAGE, \
248 .channel = (_chan) * 2, \
249 .channel2 = (_chan) * 2 + 1, \
250 .address = (_chan), \
251 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
252 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) \
253 | BIT(IIO_CHAN_INFO_OFFSET), \
254 .scan_index = (_chan), \
260 .endianness = IIO_BE, \
265 #define AD7266_DECLARE_DIFF_CHANNELS(_name, _sign) \
266 const struct iio_chan_spec ad7266_channels_diff_##_name[] = { \
267 AD7266_CHAN_DIFF(0, (_sign)), \
268 AD7266_CHAN_DIFF(1, (_sign)), \
269 AD7266_CHAN_DIFF(2, (_sign)), \
270 AD7266_CHAN_DIFF(3, (_sign)), \
271 AD7266_CHAN_DIFF(4, (_sign)), \
272 AD7266_CHAN_DIFF(5, (_sign)), \
273 IIO_CHAN_SOFT_TIMESTAMP(6), \
276 static AD7266_DECLARE_DIFF_CHANNELS(s
, 's');
277 static AD7266_DECLARE_DIFF_CHANNELS(u
, 'u');
279 #define AD7266_DECLARE_DIFF_CHANNELS_FIXED(_name, _sign) \
280 const struct iio_chan_spec ad7266_channels_diff_fixed_##_name[] = { \
281 AD7266_CHAN_DIFF(0, (_sign)), \
282 AD7266_CHAN_DIFF(1, (_sign)), \
283 IIO_CHAN_SOFT_TIMESTAMP(2), \
286 static AD7266_DECLARE_DIFF_CHANNELS_FIXED(s
, 's');
287 static AD7266_DECLARE_DIFF_CHANNELS_FIXED(u
, 'u');
289 static const struct iio_info ad7266_info
= {
290 .read_raw
= &ad7266_read_raw
,
291 .update_scan_mode
= &ad7266_update_scan_mode
,
292 .driver_module
= THIS_MODULE
,
295 static const unsigned long ad7266_available_scan_masks
[] = {
305 static const unsigned long ad7266_available_scan_masks_diff
[] = {
312 static const unsigned long ad7266_available_scan_masks_fixed
[] = {
317 struct ad7266_chan_info
{
318 const struct iio_chan_spec
*channels
;
319 unsigned int num_channels
;
320 const unsigned long *scan_masks
;
323 #define AD7266_CHAN_INFO_INDEX(_differential, _signed, _fixed) \
324 (((_differential) << 2) | ((_signed) << 1) | ((_fixed) << 0))
326 static const struct ad7266_chan_info ad7266_chan_infos
[] = {
327 [AD7266_CHAN_INFO_INDEX(0, 0, 0)] = {
328 .channels
= ad7266_channels_u
,
329 .num_channels
= ARRAY_SIZE(ad7266_channels_u
),
330 .scan_masks
= ad7266_available_scan_masks
,
332 [AD7266_CHAN_INFO_INDEX(0, 0, 1)] = {
333 .channels
= ad7266_channels_u_fixed
,
334 .num_channels
= ARRAY_SIZE(ad7266_channels_u_fixed
),
335 .scan_masks
= ad7266_available_scan_masks_fixed
,
337 [AD7266_CHAN_INFO_INDEX(0, 1, 0)] = {
338 .channels
= ad7266_channels_s
,
339 .num_channels
= ARRAY_SIZE(ad7266_channels_s
),
340 .scan_masks
= ad7266_available_scan_masks
,
342 [AD7266_CHAN_INFO_INDEX(0, 1, 1)] = {
343 .channels
= ad7266_channels_s_fixed
,
344 .num_channels
= ARRAY_SIZE(ad7266_channels_s_fixed
),
345 .scan_masks
= ad7266_available_scan_masks_fixed
,
347 [AD7266_CHAN_INFO_INDEX(1, 0, 0)] = {
348 .channels
= ad7266_channels_diff_u
,
349 .num_channels
= ARRAY_SIZE(ad7266_channels_diff_u
),
350 .scan_masks
= ad7266_available_scan_masks_diff
,
352 [AD7266_CHAN_INFO_INDEX(1, 0, 1)] = {
353 .channels
= ad7266_channels_diff_fixed_u
,
354 .num_channels
= ARRAY_SIZE(ad7266_channels_diff_fixed_u
),
355 .scan_masks
= ad7266_available_scan_masks_fixed
,
357 [AD7266_CHAN_INFO_INDEX(1, 1, 0)] = {
358 .channels
= ad7266_channels_diff_s
,
359 .num_channels
= ARRAY_SIZE(ad7266_channels_diff_s
),
360 .scan_masks
= ad7266_available_scan_masks_diff
,
362 [AD7266_CHAN_INFO_INDEX(1, 1, 1)] = {
363 .channels
= ad7266_channels_diff_fixed_s
,
364 .num_channels
= ARRAY_SIZE(ad7266_channels_diff_fixed_s
),
365 .scan_masks
= ad7266_available_scan_masks_fixed
,
369 static void ad7266_init_channels(struct iio_dev
*indio_dev
)
371 struct ad7266_state
*st
= iio_priv(indio_dev
);
372 bool is_differential
, is_signed
;
373 const struct ad7266_chan_info
*chan_info
;
376 is_differential
= st
->mode
!= AD7266_MODE_SINGLE_ENDED
;
377 is_signed
= (st
->range
== AD7266_RANGE_2VREF
) |
378 (st
->mode
== AD7266_MODE_DIFF
);
380 i
= AD7266_CHAN_INFO_INDEX(is_differential
, is_signed
, st
->fixed_addr
);
381 chan_info
= &ad7266_chan_infos
[i
];
383 indio_dev
->channels
= chan_info
->channels
;
384 indio_dev
->num_channels
= chan_info
->num_channels
;
385 indio_dev
->available_scan_masks
= chan_info
->scan_masks
;
386 indio_dev
->masklength
= chan_info
->num_channels
- 1;
389 static const char * const ad7266_gpio_labels
[] = {
393 static int ad7266_probe(struct spi_device
*spi
)
395 struct ad7266_platform_data
*pdata
= spi
->dev
.platform_data
;
396 struct iio_dev
*indio_dev
;
397 struct ad7266_state
*st
;
401 indio_dev
= devm_iio_device_alloc(&spi
->dev
, sizeof(*st
));
402 if (indio_dev
== NULL
)
405 st
= iio_priv(indio_dev
);
407 st
->reg
= devm_regulator_get(&spi
->dev
, "vref");
408 if (!IS_ERR_OR_NULL(st
->reg
)) {
409 ret
= regulator_enable(st
->reg
);
413 ret
= regulator_get_voltage(st
->reg
);
415 goto error_disable_reg
;
419 /* Use internal reference */
420 st
->vref_uv
= 2500000;
424 st
->fixed_addr
= pdata
->fixed_addr
;
425 st
->mode
= pdata
->mode
;
426 st
->range
= pdata
->range
;
428 if (!st
->fixed_addr
) {
429 for (i
= 0; i
< ARRAY_SIZE(st
->gpios
); ++i
) {
430 st
->gpios
[i
].gpio
= pdata
->addr_gpios
[i
];
431 st
->gpios
[i
].flags
= GPIOF_OUT_INIT_LOW
;
432 st
->gpios
[i
].label
= ad7266_gpio_labels
[i
];
434 ret
= gpio_request_array(st
->gpios
,
435 ARRAY_SIZE(st
->gpios
));
437 goto error_disable_reg
;
440 st
->fixed_addr
= true;
441 st
->range
= AD7266_RANGE_VREF
;
442 st
->mode
= AD7266_MODE_DIFF
;
445 spi_set_drvdata(spi
, indio_dev
);
448 indio_dev
->dev
.parent
= &spi
->dev
;
449 indio_dev
->name
= spi_get_device_id(spi
)->name
;
450 indio_dev
->modes
= INDIO_DIRECT_MODE
;
451 indio_dev
->info
= &ad7266_info
;
453 ad7266_init_channels(indio_dev
);
456 st
->single_xfer
[0].rx_buf
= &st
->data
;
457 st
->single_xfer
[0].len
= 2;
458 st
->single_xfer
[0].cs_change
= 1;
460 st
->single_xfer
[1].rx_buf
= &st
->data
;
461 st
->single_xfer
[1].len
= 4;
462 st
->single_xfer
[1].cs_change
= 1;
464 st
->single_xfer
[2].tx_buf
= &st
->data
;
465 st
->single_xfer
[2].len
= 1;
467 spi_message_init(&st
->single_msg
);
468 spi_message_add_tail(&st
->single_xfer
[0], &st
->single_msg
);
469 spi_message_add_tail(&st
->single_xfer
[1], &st
->single_msg
);
470 spi_message_add_tail(&st
->single_xfer
[2], &st
->single_msg
);
472 ret
= iio_triggered_buffer_setup(indio_dev
, &iio_pollfunc_store_time
,
473 &ad7266_trigger_handler
, &iio_triggered_buffer_setup_ops
);
475 goto error_free_gpios
;
477 ret
= iio_device_register(indio_dev
);
479 goto error_buffer_cleanup
;
483 error_buffer_cleanup
:
484 iio_triggered_buffer_cleanup(indio_dev
);
487 gpio_free_array(st
->gpios
, ARRAY_SIZE(st
->gpios
));
489 if (!IS_ERR_OR_NULL(st
->reg
))
490 regulator_disable(st
->reg
);
495 static int ad7266_remove(struct spi_device
*spi
)
497 struct iio_dev
*indio_dev
= spi_get_drvdata(spi
);
498 struct ad7266_state
*st
= iio_priv(indio_dev
);
500 iio_device_unregister(indio_dev
);
501 iio_triggered_buffer_cleanup(indio_dev
);
503 gpio_free_array(st
->gpios
, ARRAY_SIZE(st
->gpios
));
504 if (!IS_ERR_OR_NULL(st
->reg
))
505 regulator_disable(st
->reg
);
510 static const struct spi_device_id ad7266_id
[] = {
515 MODULE_DEVICE_TABLE(spi
, ad7266_id
);
517 static struct spi_driver ad7266_driver
= {
520 .owner
= THIS_MODULE
,
522 .probe
= ad7266_probe
,
523 .remove
= ad7266_remove
,
524 .id_table
= ad7266_id
,
526 module_spi_driver(ad7266_driver
);
528 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
529 MODULE_DESCRIPTION("Analog Devices AD7266/65 ADC");
530 MODULE_LICENSE("GPL v2");