2 * AD7298 SPI ADC driver
4 * Copyright 2011 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/sysfs.h>
13 #include <linux/spi/spi.h>
14 #include <linux/regulator/consumer.h>
15 #include <linux/err.h>
16 #include <linux/delay.h>
17 #include <linux/module.h>
21 #include "../buffer_generic.h"
25 static struct iio_chan_spec ad7298_channels
[] = {
26 IIO_CHAN(IIO_TEMP
, 0, 1, 0, NULL
, 0, 0,
27 (1 << IIO_CHAN_INFO_SCALE_SEPARATE
),
28 9, AD7298_CH_TEMP
, IIO_ST('s', 32, 32, 0), 0),
29 IIO_CHAN(IIO_IN
, 0, 1, 0, NULL
, 0, 0,
30 (1 << IIO_CHAN_INFO_SCALE_SHARED
),
31 0, 0, IIO_ST('u', 12, 16, 0), 0),
32 IIO_CHAN(IIO_IN
, 0, 1, 0, NULL
, 1, 0,
33 (1 << IIO_CHAN_INFO_SCALE_SHARED
),
34 1, 1, IIO_ST('u', 12, 16, 0), 0),
35 IIO_CHAN(IIO_IN
, 0, 1, 0, NULL
, 2, 0,
36 (1 << IIO_CHAN_INFO_SCALE_SHARED
),
37 2, 2, IIO_ST('u', 12, 16, 0), 0),
38 IIO_CHAN(IIO_IN
, 0, 1, 0, NULL
, 3, 0,
39 (1 << IIO_CHAN_INFO_SCALE_SHARED
),
40 3, 3, IIO_ST('u', 12, 16, 0), 0),
41 IIO_CHAN(IIO_IN
, 0, 1, 0, NULL
, 4, 0,
42 (1 << IIO_CHAN_INFO_SCALE_SHARED
),
43 4, 4, IIO_ST('u', 12, 16, 0), 0),
44 IIO_CHAN(IIO_IN
, 0, 1, 0, NULL
, 5, 0,
45 (1 << IIO_CHAN_INFO_SCALE_SHARED
),
46 5, 5, IIO_ST('u', 12, 16, 0), 0),
47 IIO_CHAN(IIO_IN
, 0, 1, 0, NULL
, 6, 0,
48 (1 << IIO_CHAN_INFO_SCALE_SHARED
),
49 6, 6, IIO_ST('u', 12, 16, 0), 0),
50 IIO_CHAN(IIO_IN
, 0, 1, 0, NULL
, 7, 0,
51 (1 << IIO_CHAN_INFO_SCALE_SHARED
),
52 7, 7, IIO_ST('u', 12, 16, 0), 0),
53 IIO_CHAN_SOFT_TIMESTAMP(8),
56 static int ad7298_scan_direct(struct ad7298_state
*st
, unsigned ch
)
59 st
->tx_buf
[0] = cpu_to_be16(AD7298_WRITE
| st
->ext_ref
|
60 (AD7298_CH(0) >> ch
));
62 ret
= spi_sync(st
->spi
, &st
->scan_single_msg
);
66 return be16_to_cpu(st
->rx_buf
[0]);
69 static int ad7298_scan_temp(struct ad7298_state
*st
, int *val
)
73 tmp
= cpu_to_be16(AD7298_WRITE
| AD7298_TSENSE
|
74 AD7298_TAVG
| st
->ext_ref
);
76 ret
= spi_write(st
->spi
, (u8
*)&tmp
, 2);
82 ret
= spi_write(st
->spi
, (u8
*)&tmp
, 2);
86 usleep_range(101, 1000); /* sleep > 100us */
88 ret
= spi_read(st
->spi
, (u8
*)&tmp
, 2);
92 tmp
= be16_to_cpu(tmp
) & RES_MASK(AD7298_BITS
);
95 * One LSB of the ADC corresponds to 0.25 deg C.
96 * The temperature reading is in 12-bit twos complement format
99 if (tmp
& (1 << (AD7298_BITS
- 1))) {
100 tmp
= (4096 - tmp
) * 250;
104 tmp
*= 250; /* temperature in milli degrees Celsius */
112 static int ad7298_read_raw(struct iio_dev
*dev_info
,
113 struct iio_chan_spec
const *chan
,
119 struct ad7298_state
*st
= iio_priv(dev_info
);
120 unsigned int scale_uv
;
124 mutex_lock(&dev_info
->mlock
);
125 if (iio_buffer_enabled(dev_info
)) {
126 if (chan
->address
== AD7298_CH_TEMP
)
129 ret
= ad7298_scan_from_ring(dev_info
,
132 if (chan
->address
== AD7298_CH_TEMP
)
133 ret
= ad7298_scan_temp(st
, val
);
135 ret
= ad7298_scan_direct(st
, chan
->address
);
137 mutex_unlock(&dev_info
->mlock
);
142 if (chan
->address
!= AD7298_CH_TEMP
)
143 *val
= ret
& RES_MASK(AD7298_BITS
);
146 case (1 << IIO_CHAN_INFO_SCALE_SHARED
):
147 scale_uv
= (st
->int_vref_mv
* 1000) >> AD7298_BITS
;
148 *val
= scale_uv
/ 1000;
149 *val2
= (scale_uv
% 1000) * 1000;
150 return IIO_VAL_INT_PLUS_MICRO
;
151 case (1 << IIO_CHAN_INFO_SCALE_SEPARATE
):
154 return IIO_VAL_INT_PLUS_MICRO
;
159 static const struct iio_info ad7298_info
= {
160 .read_raw
= &ad7298_read_raw
,
161 .driver_module
= THIS_MODULE
,
164 static int __devinit
ad7298_probe(struct spi_device
*spi
)
166 struct ad7298_platform_data
*pdata
= spi
->dev
.platform_data
;
167 struct ad7298_state
*st
;
169 struct iio_dev
*indio_dev
= iio_allocate_device(sizeof(*st
));
171 if (indio_dev
== NULL
)
174 st
= iio_priv(indio_dev
);
176 st
->reg
= regulator_get(&spi
->dev
, "vcc");
177 if (!IS_ERR(st
->reg
)) {
178 ret
= regulator_enable(st
->reg
);
183 spi_set_drvdata(spi
, indio_dev
);
187 indio_dev
->name
= spi_get_device_id(spi
)->name
;
188 indio_dev
->dev
.parent
= &spi
->dev
;
189 indio_dev
->modes
= INDIO_DIRECT_MODE
;
190 indio_dev
->channels
= ad7298_channels
;
191 indio_dev
->num_channels
= ARRAY_SIZE(ad7298_channels
);
192 indio_dev
->info
= &ad7298_info
;
194 /* Setup default message */
196 st
->scan_single_xfer
[0].tx_buf
= &st
->tx_buf
[0];
197 st
->scan_single_xfer
[0].len
= 2;
198 st
->scan_single_xfer
[0].cs_change
= 1;
199 st
->scan_single_xfer
[1].tx_buf
= &st
->tx_buf
[1];
200 st
->scan_single_xfer
[1].len
= 2;
201 st
->scan_single_xfer
[1].cs_change
= 1;
202 st
->scan_single_xfer
[2].rx_buf
= &st
->rx_buf
[0];
203 st
->scan_single_xfer
[2].len
= 2;
205 spi_message_init(&st
->scan_single_msg
);
206 spi_message_add_tail(&st
->scan_single_xfer
[0], &st
->scan_single_msg
);
207 spi_message_add_tail(&st
->scan_single_xfer
[1], &st
->scan_single_msg
);
208 spi_message_add_tail(&st
->scan_single_xfer
[2], &st
->scan_single_msg
);
210 if (pdata
&& pdata
->vref_mv
) {
211 st
->int_vref_mv
= pdata
->vref_mv
;
212 st
->ext_ref
= AD7298_EXTREF
;
214 st
->int_vref_mv
= AD7298_INTREF_mV
;
217 ret
= ad7298_register_ring_funcs_and_init(indio_dev
);
219 goto error_disable_reg
;
221 ret
= iio_buffer_register(indio_dev
,
222 &ad7298_channels
[1], /* skip temp0 */
223 ARRAY_SIZE(ad7298_channels
) - 1);
225 goto error_cleanup_ring
;
226 ret
= iio_device_register(indio_dev
);
228 goto error_unregister_ring
;
232 error_unregister_ring
:
233 iio_buffer_unregister(indio_dev
);
235 ad7298_ring_cleanup(indio_dev
);
237 if (!IS_ERR(st
->reg
))
238 regulator_disable(st
->reg
);
240 if (!IS_ERR(st
->reg
))
241 regulator_put(st
->reg
);
242 iio_free_device(indio_dev
);
247 static int __devexit
ad7298_remove(struct spi_device
*spi
)
249 struct iio_dev
*indio_dev
= spi_get_drvdata(spi
);
250 struct ad7298_state
*st
= iio_priv(indio_dev
);
252 iio_buffer_unregister(indio_dev
);
253 ad7298_ring_cleanup(indio_dev
);
254 iio_device_unregister(indio_dev
);
255 if (!IS_ERR(st
->reg
)) {
256 regulator_disable(st
->reg
);
257 regulator_put(st
->reg
);
259 iio_device_unregister(indio_dev
);
264 static const struct spi_device_id ad7298_id
[] = {
269 static struct spi_driver ad7298_driver
= {
272 .bus
= &spi_bus_type
,
273 .owner
= THIS_MODULE
,
275 .probe
= ad7298_probe
,
276 .remove
= __devexit_p(ad7298_remove
),
277 .id_table
= ad7298_id
,
280 static int __init
ad7298_init(void)
282 return spi_register_driver(&ad7298_driver
);
284 module_init(ad7298_init
);
286 static void __exit
ad7298_exit(void)
288 spi_unregister_driver(&ad7298_driver
);
290 module_exit(ad7298_exit
);
292 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
293 MODULE_DESCRIPTION("Analog Devices AD7298 ADC");
294 MODULE_LICENSE("GPL v2");
295 MODULE_ALIAS("spi:ad7298");