2 * AD5760, AD5780, AD5781, AD5790, AD5791 Voltage Output Digital to Analog
5 * Copyright 2011 Analog Devices Inc.
7 * Licensed under the GPL-2.
10 #include <linux/interrupt.h>
12 #include <linux/device.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>
18 #include <linux/module.h>
20 #include <linux/iio/iio.h>
21 #include <linux/iio/sysfs.h>
22 #include <linux/iio/dac/ad5791.h>
24 #define AD5791_RES_MASK(x) ((1 << (x)) - 1)
25 #define AD5791_DAC_MASK AD5791_RES_MASK(20)
26 #define AD5791_DAC_MSB (1 << 19)
28 #define AD5791_CMD_READ (1 << 23)
29 #define AD5791_CMD_WRITE (0 << 23)
30 #define AD5791_ADDR(addr) ((addr) << 20)
33 #define AD5791_ADDR_NOOP 0
34 #define AD5791_ADDR_DAC0 1
35 #define AD5791_ADDR_CTRL 2
36 #define AD5791_ADDR_CLRCODE 3
37 #define AD5791_ADDR_SW_CTRL 4
39 /* Control Register */
40 #define AD5791_CTRL_RBUF (1 << 1)
41 #define AD5791_CTRL_OPGND (1 << 2)
42 #define AD5791_CTRL_DACTRI (1 << 3)
43 #define AD5791_CTRL_BIN2SC (1 << 4)
44 #define AD5791_CTRL_SDODIS (1 << 5)
45 #define AD5761_CTRL_LINCOMP(x) ((x) << 6)
47 #define AD5791_LINCOMP_0_10 0
48 #define AD5791_LINCOMP_10_12 1
49 #define AD5791_LINCOMP_12_16 2
50 #define AD5791_LINCOMP_16_19 3
51 #define AD5791_LINCOMP_19_20 12
53 #define AD5780_LINCOMP_0_10 0
54 #define AD5780_LINCOMP_10_20 12
56 /* Software Control Register */
57 #define AD5791_SWCTRL_LDAC (1 << 0)
58 #define AD5791_SWCTRL_CLR (1 << 1)
59 #define AD5791_SWCTRL_RESET (1 << 2)
61 #define AD5791_DAC_PWRDN_6K 0
62 #define AD5791_DAC_PWRDN_3STATE 1
65 * struct ad5791_chip_info - chip specific information
66 * @get_lin_comp: function pointer to the device specific function
69 struct ad5791_chip_info
{
70 int (*get_lin_comp
) (unsigned int span
);
74 * struct ad5791_state - driver instance specific data
76 * @reg_vdd: positive supply regulator
77 * @reg_vss: negative supply regulator
78 * @chip_info: chip model specific constants
79 * @vref_mv: actual reference voltage used
80 * @vref_neg_mv: voltage of the negative supply
81 * @pwr_down_mode current power down mode
85 struct spi_device
*spi
;
86 struct regulator
*reg_vdd
;
87 struct regulator
*reg_vss
;
88 const struct ad5791_chip_info
*chip_info
;
89 unsigned short vref_mv
;
90 unsigned int vref_neg_mv
;
92 unsigned pwr_down_mode
;
97 * ad5791_supported_device_ids:
100 enum ad5791_supported_device_ids
{
107 static int ad5791_spi_write(struct spi_device
*spi
, u8 addr
, u32 val
)
114 data
.d32
= cpu_to_be32(AD5791_CMD_WRITE
|
116 (val
& AD5791_DAC_MASK
));
118 return spi_write(spi
, &data
.d8
[1], 3);
121 static int ad5791_spi_read(struct spi_device
*spi
, u8 addr
, u32
*val
)
128 struct spi_message msg
;
129 struct spi_transfer xfers
[] = {
131 .tx_buf
= &data
[0].d8
[1],
136 .tx_buf
= &data
[1].d8
[1],
137 .rx_buf
= &data
[2].d8
[1],
143 data
[0].d32
= cpu_to_be32(AD5791_CMD_READ
|
145 data
[1].d32
= cpu_to_be32(AD5791_ADDR(AD5791_ADDR_NOOP
));
147 spi_message_init(&msg
);
148 spi_message_add_tail(&xfers
[0], &msg
);
149 spi_message_add_tail(&xfers
[1], &msg
);
150 ret
= spi_sync(spi
, &msg
);
152 *val
= be32_to_cpu(data
[2].d32
);
157 static const char * const ad5791_powerdown_modes
[] = {
162 static int ad5791_get_powerdown_mode(struct iio_dev
*indio_dev
,
163 const struct iio_chan_spec
*chan
)
165 struct ad5791_state
*st
= iio_priv(indio_dev
);
167 return st
->pwr_down_mode
;
170 static int ad5791_set_powerdown_mode(struct iio_dev
*indio_dev
,
171 const struct iio_chan_spec
*chan
, unsigned int mode
)
173 struct ad5791_state
*st
= iio_priv(indio_dev
);
175 st
->pwr_down_mode
= mode
;
180 static const struct iio_enum ad5791_powerdown_mode_enum
= {
181 .items
= ad5791_powerdown_modes
,
182 .num_items
= ARRAY_SIZE(ad5791_powerdown_modes
),
183 .get
= ad5791_get_powerdown_mode
,
184 .set
= ad5791_set_powerdown_mode
,
187 static ssize_t
ad5791_read_dac_powerdown(struct iio_dev
*indio_dev
,
188 uintptr_t private, const struct iio_chan_spec
*chan
, char *buf
)
190 struct ad5791_state
*st
= iio_priv(indio_dev
);
192 return sprintf(buf
, "%d\n", st
->pwr_down
);
195 static ssize_t
ad5791_write_dac_powerdown(struct iio_dev
*indio_dev
,
196 uintptr_t private, const struct iio_chan_spec
*chan
, const char *buf
,
201 struct ad5791_state
*st
= iio_priv(indio_dev
);
203 ret
= strtobool(buf
, &pwr_down
);
208 st
->ctrl
&= ~(AD5791_CTRL_OPGND
| AD5791_CTRL_DACTRI
);
210 if (st
->pwr_down_mode
== AD5791_DAC_PWRDN_6K
)
211 st
->ctrl
|= AD5791_CTRL_OPGND
;
212 else if (st
->pwr_down_mode
== AD5791_DAC_PWRDN_3STATE
)
213 st
->ctrl
|= AD5791_CTRL_DACTRI
;
215 st
->pwr_down
= pwr_down
;
217 ret
= ad5791_spi_write(st
->spi
, AD5791_ADDR_CTRL
, st
->ctrl
);
219 return ret
? ret
: len
;
222 static int ad5791_get_lin_comp(unsigned int span
)
225 return AD5791_LINCOMP_0_10
;
226 else if (span
<= 12000)
227 return AD5791_LINCOMP_10_12
;
228 else if (span
<= 16000)
229 return AD5791_LINCOMP_12_16
;
230 else if (span
<= 19000)
231 return AD5791_LINCOMP_16_19
;
233 return AD5791_LINCOMP_19_20
;
236 static int ad5780_get_lin_comp(unsigned int span
)
239 return AD5780_LINCOMP_0_10
;
241 return AD5780_LINCOMP_10_20
;
243 static const struct ad5791_chip_info ad5791_chip_info_tbl
[] = {
245 .get_lin_comp
= ad5780_get_lin_comp
,
248 .get_lin_comp
= ad5780_get_lin_comp
,
251 .get_lin_comp
= ad5791_get_lin_comp
,
254 .get_lin_comp
= ad5791_get_lin_comp
,
258 static int ad5791_read_raw(struct iio_dev
*indio_dev
,
259 struct iio_chan_spec
const *chan
,
264 struct ad5791_state
*st
= iio_priv(indio_dev
);
269 case IIO_CHAN_INFO_RAW
:
270 ret
= ad5791_spi_read(st
->spi
, chan
->address
, val
);
273 *val
&= AD5791_DAC_MASK
;
274 *val
>>= chan
->scan_type
.shift
;
276 case IIO_CHAN_INFO_SCALE
:
278 *val2
= (((u64
)st
->vref_mv
) * 1000000ULL) >> chan
->scan_type
.realbits
;
279 return IIO_VAL_INT_PLUS_MICRO
;
280 case IIO_CHAN_INFO_OFFSET
:
281 val64
= (((u64
)st
->vref_neg_mv
) << chan
->scan_type
.realbits
);
282 do_div(val64
, st
->vref_mv
);
291 static const struct iio_chan_spec_ext_info ad5791_ext_info
[] = {
295 .read
= ad5791_read_dac_powerdown
,
296 .write
= ad5791_write_dac_powerdown
,
298 IIO_ENUM("powerdown_mode", true, &ad5791_powerdown_mode_enum
),
299 IIO_ENUM_AVAILABLE("powerdown_mode", &ad5791_powerdown_mode_enum
),
303 #define AD5791_CHAN(bits, shift) { \
304 .type = IIO_VOLTAGE, \
307 .address = AD5791_ADDR_DAC0, \
309 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
310 IIO_CHAN_INFO_SCALE_SHARED_BIT | \
311 IIO_CHAN_INFO_OFFSET_SHARED_BIT, \
312 .scan_type = IIO_ST('u', bits, 24, shift), \
313 .ext_info = ad5791_ext_info, \
316 static const struct iio_chan_spec ad5791_channels
[] = {
317 [ID_AD5760
] = AD5791_CHAN(16, 4),
318 [ID_AD5780
] = AD5791_CHAN(18, 2),
319 [ID_AD5781
] = AD5791_CHAN(18, 2),
320 [ID_AD5791
] = AD5791_CHAN(20, 0)
323 static int ad5791_write_raw(struct iio_dev
*indio_dev
,
324 struct iio_chan_spec
const *chan
,
329 struct ad5791_state
*st
= iio_priv(indio_dev
);
332 case IIO_CHAN_INFO_RAW
:
333 val
&= AD5791_RES_MASK(chan
->scan_type
.realbits
);
334 val
<<= chan
->scan_type
.shift
;
336 return ad5791_spi_write(st
->spi
, chan
->address
, val
);
343 static const struct iio_info ad5791_info
= {
344 .read_raw
= &ad5791_read_raw
,
345 .write_raw
= &ad5791_write_raw
,
346 .driver_module
= THIS_MODULE
,
349 static int __devinit
ad5791_probe(struct spi_device
*spi
)
351 struct ad5791_platform_data
*pdata
= spi
->dev
.platform_data
;
352 struct iio_dev
*indio_dev
;
353 struct ad5791_state
*st
;
354 int ret
, pos_voltage_uv
= 0, neg_voltage_uv
= 0;
356 indio_dev
= iio_device_alloc(sizeof(*st
));
357 if (indio_dev
== NULL
) {
361 st
= iio_priv(indio_dev
);
362 st
->reg_vdd
= regulator_get(&spi
->dev
, "vdd");
363 if (!IS_ERR(st
->reg_vdd
)) {
364 ret
= regulator_enable(st
->reg_vdd
);
366 goto error_put_reg_pos
;
368 pos_voltage_uv
= regulator_get_voltage(st
->reg_vdd
);
371 st
->reg_vss
= regulator_get(&spi
->dev
, "vss");
372 if (!IS_ERR(st
->reg_vss
)) {
373 ret
= regulator_enable(st
->reg_vss
);
375 goto error_put_reg_neg
;
377 neg_voltage_uv
= regulator_get_voltage(st
->reg_vss
);
383 if (!IS_ERR(st
->reg_vss
) && !IS_ERR(st
->reg_vdd
)) {
384 st
->vref_mv
= (pos_voltage_uv
+ neg_voltage_uv
) / 1000;
385 st
->vref_neg_mv
= neg_voltage_uv
/ 1000;
387 st
->vref_mv
= pdata
->vref_pos_mv
+ pdata
->vref_neg_mv
;
388 st
->vref_neg_mv
= pdata
->vref_neg_mv
;
390 dev_warn(&spi
->dev
, "reference voltage unspecified\n");
393 ret
= ad5791_spi_write(spi
, AD5791_ADDR_SW_CTRL
, AD5791_SWCTRL_RESET
);
395 goto error_disable_reg_neg
;
397 st
->chip_info
= &ad5791_chip_info_tbl
[spi_get_device_id(spi
)
401 st
->ctrl
= AD5761_CTRL_LINCOMP(st
->chip_info
->get_lin_comp(st
->vref_mv
))
402 | ((pdata
&& pdata
->use_rbuf_gain2
) ? 0 : AD5791_CTRL_RBUF
) |
405 ret
= ad5791_spi_write(spi
, AD5791_ADDR_CTRL
, st
->ctrl
|
406 AD5791_CTRL_OPGND
| AD5791_CTRL_DACTRI
);
408 goto error_disable_reg_neg
;
410 spi_set_drvdata(spi
, indio_dev
);
411 indio_dev
->dev
.parent
= &spi
->dev
;
412 indio_dev
->info
= &ad5791_info
;
413 indio_dev
->modes
= INDIO_DIRECT_MODE
;
415 = &ad5791_channels
[spi_get_device_id(spi
)->driver_data
];
416 indio_dev
->num_channels
= 1;
417 indio_dev
->name
= spi_get_device_id(st
->spi
)->name
;
418 ret
= iio_device_register(indio_dev
);
420 goto error_disable_reg_neg
;
424 error_disable_reg_neg
:
425 if (!IS_ERR(st
->reg_vss
))
426 regulator_disable(st
->reg_vss
);
428 if (!IS_ERR(st
->reg_vss
))
429 regulator_put(st
->reg_vss
);
431 if (!IS_ERR(st
->reg_vdd
))
432 regulator_disable(st
->reg_vdd
);
434 if (!IS_ERR(st
->reg_vdd
))
435 regulator_put(st
->reg_vdd
);
436 iio_device_free(indio_dev
);
442 static int __devexit
ad5791_remove(struct spi_device
*spi
)
444 struct iio_dev
*indio_dev
= spi_get_drvdata(spi
);
445 struct ad5791_state
*st
= iio_priv(indio_dev
);
447 iio_device_unregister(indio_dev
);
448 if (!IS_ERR(st
->reg_vdd
)) {
449 regulator_disable(st
->reg_vdd
);
450 regulator_put(st
->reg_vdd
);
453 if (!IS_ERR(st
->reg_vss
)) {
454 regulator_disable(st
->reg_vss
);
455 regulator_put(st
->reg_vss
);
457 iio_device_free(indio_dev
);
462 static const struct spi_device_id ad5791_id
[] = {
463 {"ad5760", ID_AD5760
},
464 {"ad5780", ID_AD5780
},
465 {"ad5781", ID_AD5781
},
466 {"ad5790", ID_AD5791
},
467 {"ad5791", ID_AD5791
},
470 MODULE_DEVICE_TABLE(spi
, ad5791_id
);
472 static struct spi_driver ad5791_driver
= {
475 .owner
= THIS_MODULE
,
477 .probe
= ad5791_probe
,
478 .remove
= __devexit_p(ad5791_remove
),
479 .id_table
= ad5791_id
,
481 module_spi_driver(ad5791_driver
);
483 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
484 MODULE_DESCRIPTION("Analog Devices AD5760/AD5780/AD5781/AD5790/AD5791 DAC");
485 MODULE_LICENSE("GPL v2");