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>
19 #include <linux/iio/iio.h>
20 #include <linux/iio/sysfs.h>
21 #include <linux/iio/buffer.h>
25 #define AD7298_V_CHAN(index) \
27 .type = IIO_VOLTAGE, \
30 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
31 IIO_CHAN_INFO_SCALE_SHARED_BIT, \
33 .scan_index = index, \
41 static struct iio_chan_spec ad7298_channels
[] = {
46 .info_mask
= IIO_CHAN_INFO_RAW_SEPARATE_BIT
|
47 IIO_CHAN_INFO_SCALE_SEPARATE_BIT
,
49 .scan_index
= AD7298_CH_TEMP
,
64 IIO_CHAN_SOFT_TIMESTAMP(8),
67 static int ad7298_scan_direct(struct ad7298_state
*st
, unsigned ch
)
70 st
->tx_buf
[0] = cpu_to_be16(AD7298_WRITE
| st
->ext_ref
|
71 (AD7298_CH(0) >> ch
));
73 ret
= spi_sync(st
->spi
, &st
->scan_single_msg
);
77 return be16_to_cpu(st
->rx_buf
[0]);
80 static int ad7298_scan_temp(struct ad7298_state
*st
, int *val
)
85 buf
= cpu_to_be16(AD7298_WRITE
| AD7298_TSENSE
|
86 AD7298_TAVG
| st
->ext_ref
);
88 ret
= spi_write(st
->spi
, (u8
*)&buf
, 2);
94 ret
= spi_write(st
->spi
, (u8
*)&buf
, 2);
98 usleep_range(101, 1000); /* sleep > 100us */
100 ret
= spi_read(st
->spi
, (u8
*)&buf
, 2);
104 tmp
= be16_to_cpu(buf
) & RES_MASK(AD7298_BITS
);
107 * One LSB of the ADC corresponds to 0.25 deg C.
108 * The temperature reading is in 12-bit twos complement format
111 if (tmp
& (1 << (AD7298_BITS
- 1))) {
112 tmp
= (4096 - tmp
) * 250;
116 tmp
*= 250; /* temperature in milli degrees Celsius */
124 static int ad7298_read_raw(struct iio_dev
*indio_dev
,
125 struct iio_chan_spec
const *chan
,
131 struct ad7298_state
*st
= iio_priv(indio_dev
);
132 unsigned int scale_uv
;
135 case IIO_CHAN_INFO_RAW
:
136 mutex_lock(&indio_dev
->mlock
);
137 if (indio_dev
->currentmode
== INDIO_BUFFER_TRIGGERED
) {
140 if (chan
->address
== AD7298_CH_TEMP
)
141 ret
= ad7298_scan_temp(st
, val
);
143 ret
= ad7298_scan_direct(st
, chan
->address
);
145 mutex_unlock(&indio_dev
->mlock
);
150 if (chan
->address
!= AD7298_CH_TEMP
)
151 *val
= ret
& RES_MASK(AD7298_BITS
);
154 case IIO_CHAN_INFO_SCALE
:
155 switch (chan
->type
) {
157 scale_uv
= (st
->int_vref_mv
* 1000) >> AD7298_BITS
;
158 *val
= scale_uv
/ 1000;
159 *val2
= (scale_uv
% 1000) * 1000;
160 return IIO_VAL_INT_PLUS_MICRO
;
164 return IIO_VAL_INT_PLUS_MICRO
;
172 static const struct iio_info ad7298_info
= {
173 .read_raw
= &ad7298_read_raw
,
174 .driver_module
= THIS_MODULE
,
177 static int __devinit
ad7298_probe(struct spi_device
*spi
)
179 struct ad7298_platform_data
*pdata
= spi
->dev
.platform_data
;
180 struct ad7298_state
*st
;
182 struct iio_dev
*indio_dev
= iio_allocate_device(sizeof(*st
));
184 if (indio_dev
== NULL
)
187 st
= iio_priv(indio_dev
);
189 st
->reg
= regulator_get(&spi
->dev
, "vcc");
190 if (!IS_ERR(st
->reg
)) {
191 ret
= regulator_enable(st
->reg
);
196 spi_set_drvdata(spi
, indio_dev
);
200 indio_dev
->name
= spi_get_device_id(spi
)->name
;
201 indio_dev
->dev
.parent
= &spi
->dev
;
202 indio_dev
->modes
= INDIO_DIRECT_MODE
;
203 indio_dev
->channels
= ad7298_channels
;
204 indio_dev
->num_channels
= ARRAY_SIZE(ad7298_channels
);
205 indio_dev
->info
= &ad7298_info
;
207 /* Setup default message */
209 st
->scan_single_xfer
[0].tx_buf
= &st
->tx_buf
[0];
210 st
->scan_single_xfer
[0].len
= 2;
211 st
->scan_single_xfer
[0].cs_change
= 1;
212 st
->scan_single_xfer
[1].tx_buf
= &st
->tx_buf
[1];
213 st
->scan_single_xfer
[1].len
= 2;
214 st
->scan_single_xfer
[1].cs_change
= 1;
215 st
->scan_single_xfer
[2].rx_buf
= &st
->rx_buf
[0];
216 st
->scan_single_xfer
[2].len
= 2;
218 spi_message_init(&st
->scan_single_msg
);
219 spi_message_add_tail(&st
->scan_single_xfer
[0], &st
->scan_single_msg
);
220 spi_message_add_tail(&st
->scan_single_xfer
[1], &st
->scan_single_msg
);
221 spi_message_add_tail(&st
->scan_single_xfer
[2], &st
->scan_single_msg
);
223 if (pdata
&& pdata
->vref_mv
) {
224 st
->int_vref_mv
= pdata
->vref_mv
;
225 st
->ext_ref
= AD7298_EXTREF
;
227 st
->int_vref_mv
= AD7298_INTREF_mV
;
230 ret
= ad7298_register_ring_funcs_and_init(indio_dev
);
232 goto error_disable_reg
;
234 ret
= iio_buffer_register(indio_dev
,
235 &ad7298_channels
[1], /* skip temp0 */
236 ARRAY_SIZE(ad7298_channels
) - 1);
238 goto error_cleanup_ring
;
239 ret
= iio_device_register(indio_dev
);
241 goto error_unregister_ring
;
245 error_unregister_ring
:
246 iio_buffer_unregister(indio_dev
);
248 ad7298_ring_cleanup(indio_dev
);
250 if (!IS_ERR(st
->reg
))
251 regulator_disable(st
->reg
);
253 if (!IS_ERR(st
->reg
))
254 regulator_put(st
->reg
);
255 iio_free_device(indio_dev
);
260 static int __devexit
ad7298_remove(struct spi_device
*spi
)
262 struct iio_dev
*indio_dev
= spi_get_drvdata(spi
);
263 struct ad7298_state
*st
= iio_priv(indio_dev
);
265 iio_device_unregister(indio_dev
);
266 iio_buffer_unregister(indio_dev
);
267 ad7298_ring_cleanup(indio_dev
);
268 if (!IS_ERR(st
->reg
)) {
269 regulator_disable(st
->reg
);
270 regulator_put(st
->reg
);
272 iio_free_device(indio_dev
);
277 static const struct spi_device_id ad7298_id
[] = {
281 MODULE_DEVICE_TABLE(spi
, ad7298_id
);
283 static struct spi_driver ad7298_driver
= {
286 .owner
= THIS_MODULE
,
288 .probe
= ad7298_probe
,
289 .remove
= __devexit_p(ad7298_remove
),
290 .id_table
= ad7298_id
,
292 module_spi_driver(ad7298_driver
);
294 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
295 MODULE_DESCRIPTION("Analog Devices AD7298 ADC");
296 MODULE_LICENSE("GPL v2");