2 * AD5686R, AD5685R, AD5684R Digital to analog converters driver
4 * Copyright 2011 Analog Devices Inc.
6 * Licensed under the GPL-2.
9 #include <linux/interrupt.h>
11 #include <linux/device.h>
12 #include <linux/module.h>
13 #include <linux/kernel.h>
14 #include <linux/spi/spi.h>
15 #include <linux/slab.h>
16 #include <linux/sysfs.h>
17 #include <linux/regulator/consumer.h>
19 #include <linux/iio/iio.h>
20 #include <linux/iio/sysfs.h>
22 #define AD5686_DAC_CHANNELS 4
24 #define AD5686_ADDR(x) ((x) << 16)
25 #define AD5686_CMD(x) ((x) << 20)
27 #define AD5686_ADDR_DAC(chan) (0x1 << (chan))
28 #define AD5686_ADDR_ALL_DAC 0xF
30 #define AD5686_CMD_NOOP 0x0
31 #define AD5686_CMD_WRITE_INPUT_N 0x1
32 #define AD5686_CMD_UPDATE_DAC_N 0x2
33 #define AD5686_CMD_WRITE_INPUT_N_UPDATE_N 0x3
34 #define AD5686_CMD_POWERDOWN_DAC 0x4
35 #define AD5686_CMD_LDAC_MASK 0x5
36 #define AD5686_CMD_RESET 0x6
37 #define AD5686_CMD_INTERNAL_REFER_SETUP 0x7
38 #define AD5686_CMD_DAISY_CHAIN_ENABLE 0x8
39 #define AD5686_CMD_READBACK_ENABLE 0x9
41 #define AD5686_LDAC_PWRDN_NONE 0x0
42 #define AD5686_LDAC_PWRDN_1K 0x1
43 #define AD5686_LDAC_PWRDN_100K 0x2
44 #define AD5686_LDAC_PWRDN_3STATE 0x3
47 * struct ad5686_chip_info - chip specific information
48 * @int_vref_mv: AD5620/40/60: the internal reference voltage
49 * @channel: channel specification
52 struct ad5686_chip_info
{
54 struct iio_chan_spec channel
[AD5686_DAC_CHANNELS
];
58 * struct ad5446_state - driver instance specific data
60 * @chip_info: chip model specific constants, available modes etc
61 * @reg: supply regulator
62 * @vref_mv: actual reference voltage used
63 * @pwr_down_mask: power down mask
64 * @pwr_down_mode: current power down mode
65 * @data: spi transfer buffers
69 struct spi_device
*spi
;
70 const struct ad5686_chip_info
*chip_info
;
71 struct regulator
*reg
;
72 unsigned short vref_mv
;
73 unsigned pwr_down_mask
;
74 unsigned pwr_down_mode
;
76 * DMA (thus cache coherency maintenance) requires the
77 * transfer buffers to live in their own cache lines.
83 } data
[3] ____cacheline_aligned
;
87 * ad5686_supported_device_ids:
90 enum ad5686_supported_device_ids
{
95 static int ad5686_spi_write(struct ad5686_state
*st
,
96 u8 cmd
, u8 addr
, u16 val
, u8 shift
)
100 st
->data
[0].d32
= cpu_to_be32(AD5686_CMD(cmd
) |
104 return spi_write(st
->spi
, &st
->data
[0].d8
[1], 3);
107 static int ad5686_spi_read(struct ad5686_state
*st
, u8 addr
)
109 struct spi_transfer t
[] = {
111 .tx_buf
= &st
->data
[0].d8
[1],
115 .tx_buf
= &st
->data
[1].d8
[1],
116 .rx_buf
= &st
->data
[2].d8
[1],
120 struct spi_message m
;
123 spi_message_init(&m
);
124 spi_message_add_tail(&t
[0], &m
);
125 spi_message_add_tail(&t
[1], &m
);
127 st
->data
[0].d32
= cpu_to_be32(AD5686_CMD(AD5686_CMD_READBACK_ENABLE
) |
129 st
->data
[1].d32
= cpu_to_be32(AD5686_CMD(AD5686_CMD_NOOP
));
131 ret
= spi_sync(st
->spi
, &m
);
135 return be32_to_cpu(st
->data
[2].d32
);
138 static const char * const ad5686_powerdown_modes
[] = {
144 static int ad5686_get_powerdown_mode(struct iio_dev
*indio_dev
,
145 const struct iio_chan_spec
*chan
)
147 struct ad5686_state
*st
= iio_priv(indio_dev
);
149 return ((st
->pwr_down_mode
>> (chan
->channel
* 2)) & 0x3) - 1;
152 static int ad5686_set_powerdown_mode(struct iio_dev
*indio_dev
,
153 const struct iio_chan_spec
*chan
, unsigned int mode
)
155 struct ad5686_state
*st
= iio_priv(indio_dev
);
157 st
->pwr_down_mode
&= ~(0x3 << (chan
->channel
* 2));
158 st
->pwr_down_mode
|= ((mode
+ 1) << (chan
->channel
* 2));
163 static const struct iio_enum ad5686_powerdown_mode_enum
= {
164 .items
= ad5686_powerdown_modes
,
165 .num_items
= ARRAY_SIZE(ad5686_powerdown_modes
),
166 .get
= ad5686_get_powerdown_mode
,
167 .set
= ad5686_set_powerdown_mode
,
170 static ssize_t
ad5686_read_dac_powerdown(struct iio_dev
*indio_dev
,
171 uintptr_t private, const struct iio_chan_spec
*chan
, char *buf
)
173 struct ad5686_state
*st
= iio_priv(indio_dev
);
175 return sprintf(buf
, "%d\n", !!(st
->pwr_down_mask
&
176 (0x3 << (chan
->channel
* 2))));
179 static ssize_t
ad5686_write_dac_powerdown(struct iio_dev
*indio_dev
,
180 uintptr_t private, const struct iio_chan_spec
*chan
, const char *buf
,
185 struct ad5686_state
*st
= iio_priv(indio_dev
);
187 ret
= strtobool(buf
, &readin
);
192 st
->pwr_down_mask
|= (0x3 << (chan
->channel
* 2));
194 st
->pwr_down_mask
&= ~(0x3 << (chan
->channel
* 2));
196 ret
= ad5686_spi_write(st
, AD5686_CMD_POWERDOWN_DAC
, 0,
197 st
->pwr_down_mask
& st
->pwr_down_mode
, 0);
199 return ret
? ret
: len
;
202 static int ad5686_read_raw(struct iio_dev
*indio_dev
,
203 struct iio_chan_spec
const *chan
,
208 struct ad5686_state
*st
= iio_priv(indio_dev
);
209 unsigned long scale_uv
;
213 case IIO_CHAN_INFO_RAW
:
214 mutex_lock(&indio_dev
->mlock
);
215 ret
= ad5686_spi_read(st
, chan
->address
);
216 mutex_unlock(&indio_dev
->mlock
);
222 case IIO_CHAN_INFO_SCALE
:
223 scale_uv
= (st
->vref_mv
* 100000)
224 >> (chan
->scan_type
.realbits
);
225 *val
= scale_uv
/ 100000;
226 *val2
= (scale_uv
% 100000) * 10;
227 return IIO_VAL_INT_PLUS_MICRO
;
233 static int ad5686_write_raw(struct iio_dev
*indio_dev
,
234 struct iio_chan_spec
const *chan
,
239 struct ad5686_state
*st
= iio_priv(indio_dev
);
243 case IIO_CHAN_INFO_RAW
:
244 if (val
> (1 << chan
->scan_type
.realbits
) || val
< 0)
247 mutex_lock(&indio_dev
->mlock
);
248 ret
= ad5686_spi_write(st
,
249 AD5686_CMD_WRITE_INPUT_N_UPDATE_N
,
252 chan
->scan_type
.shift
);
253 mutex_unlock(&indio_dev
->mlock
);
262 static const struct iio_info ad5686_info
= {
263 .read_raw
= ad5686_read_raw
,
264 .write_raw
= ad5686_write_raw
,
265 .driver_module
= THIS_MODULE
,
268 static const struct iio_chan_spec_ext_info ad5686_ext_info
[] = {
271 .read
= ad5686_read_dac_powerdown
,
272 .write
= ad5686_write_dac_powerdown
,
274 IIO_ENUM("powerdown_mode", false, &ad5686_powerdown_mode_enum
),
275 IIO_ENUM_AVAILABLE("powerdown_mode", &ad5686_powerdown_mode_enum
),
279 #define AD5868_CHANNEL(chan, bits, shift) { \
280 .type = IIO_VOLTAGE, \
284 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
285 IIO_CHAN_INFO_SCALE_SHARED_BIT, \
286 .address = AD5686_ADDR_DAC(chan), \
287 .scan_type = IIO_ST('u', bits, 16, shift), \
288 .ext_info = ad5686_ext_info, \
291 static const struct ad5686_chip_info ad5686_chip_info_tbl
[] = {
293 .channel
[0] = AD5868_CHANNEL(0, 12, 4),
294 .channel
[1] = AD5868_CHANNEL(1, 12, 4),
295 .channel
[2] = AD5868_CHANNEL(2, 12, 4),
296 .channel
[3] = AD5868_CHANNEL(3, 12, 4),
300 .channel
[0] = AD5868_CHANNEL(0, 14, 2),
301 .channel
[1] = AD5868_CHANNEL(1, 14, 2),
302 .channel
[2] = AD5868_CHANNEL(2, 14, 2),
303 .channel
[3] = AD5868_CHANNEL(3, 14, 2),
307 .channel
[0] = AD5868_CHANNEL(0, 16, 0),
308 .channel
[1] = AD5868_CHANNEL(1, 16, 0),
309 .channel
[2] = AD5868_CHANNEL(2, 16, 0),
310 .channel
[3] = AD5868_CHANNEL(3, 16, 0),
316 static int __devinit
ad5686_probe(struct spi_device
*spi
)
318 struct ad5686_state
*st
;
319 struct iio_dev
*indio_dev
;
320 int ret
, regdone
= 0, voltage_uv
= 0;
322 indio_dev
= iio_device_alloc(sizeof(*st
));
323 if (indio_dev
== NULL
)
326 st
= iio_priv(indio_dev
);
327 spi_set_drvdata(spi
, indio_dev
);
329 st
->reg
= regulator_get(&spi
->dev
, "vcc");
330 if (!IS_ERR(st
->reg
)) {
331 ret
= regulator_enable(st
->reg
);
335 voltage_uv
= regulator_get_voltage(st
->reg
);
339 &ad5686_chip_info_tbl
[spi_get_device_id(spi
)->driver_data
];
342 st
->vref_mv
= voltage_uv
/ 1000;
344 st
->vref_mv
= st
->chip_info
->int_vref_mv
;
348 /* Set all the power down mode for all channels to 1K pulldown */
349 st
->pwr_down_mode
= 0x55;
351 indio_dev
->dev
.parent
= &spi
->dev
;
352 indio_dev
->name
= spi_get_device_id(spi
)->name
;
353 indio_dev
->info
= &ad5686_info
;
354 indio_dev
->modes
= INDIO_DIRECT_MODE
;
355 indio_dev
->channels
= st
->chip_info
->channel
;
356 indio_dev
->num_channels
= AD5686_DAC_CHANNELS
;
359 ret
= ad5686_spi_write(st
, AD5686_CMD_INTERNAL_REFER_SETUP
, 0,
362 goto error_disable_reg
;
364 ret
= iio_device_register(indio_dev
);
366 goto error_disable_reg
;
371 if (!IS_ERR(st
->reg
))
372 regulator_disable(st
->reg
);
374 if (!IS_ERR(st
->reg
))
375 regulator_put(st
->reg
);
377 iio_device_free(indio_dev
);
382 static int __devexit
ad5686_remove(struct spi_device
*spi
)
384 struct iio_dev
*indio_dev
= spi_get_drvdata(spi
);
385 struct ad5686_state
*st
= iio_priv(indio_dev
);
387 iio_device_unregister(indio_dev
);
388 if (!IS_ERR(st
->reg
)) {
389 regulator_disable(st
->reg
);
390 regulator_put(st
->reg
);
392 iio_device_free(indio_dev
);
397 static const struct spi_device_id ad5686_id
[] = {
398 {"ad5684", ID_AD5684
},
399 {"ad5685", ID_AD5685
},
400 {"ad5686", ID_AD5686
},
403 MODULE_DEVICE_TABLE(spi
, ad5686_id
);
405 static struct spi_driver ad5686_driver
= {
408 .owner
= THIS_MODULE
,
410 .probe
= ad5686_probe
,
411 .remove
= __devexit_p(ad5686_remove
),
412 .id_table
= ad5686_id
,
414 module_spi_driver(ad5686_driver
);
416 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
417 MODULE_DESCRIPTION("Analog Devices AD5686/85/84 DAC");
418 MODULE_LICENSE("GPL v2");