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_transfer xfers[] = {
130 .tx_buf = &data[0].d8[1],
135 .tx_buf = &data[1].d8[1],
136 .rx_buf = &data[2].d8[1],
142 data[0].d32 = cpu_to_be32(AD5791_CMD_READ |
144 data[1].d32 = cpu_to_be32(AD5791_ADDR(AD5791_ADDR_NOOP));
146 ret = spi_sync_transfer(spi, xfers, ARRAY_SIZE(xfers));
148 *val = be32_to_cpu(data[2].d32);
153 static const char * const ad5791_powerdown_modes[] = {
158 static int ad5791_get_powerdown_mode(struct iio_dev *indio_dev,
159 const struct iio_chan_spec *chan)
161 struct ad5791_state *st = iio_priv(indio_dev);
163 return st->pwr_down_mode;
166 static int ad5791_set_powerdown_mode(struct iio_dev *indio_dev,
167 const struct iio_chan_spec *chan, unsigned int mode)
169 struct ad5791_state *st = iio_priv(indio_dev);
171 st->pwr_down_mode = mode;
176 static const struct iio_enum ad5791_powerdown_mode_enum = {
177 .items = ad5791_powerdown_modes,
178 .num_items = ARRAY_SIZE(ad5791_powerdown_modes),
179 .get = ad5791_get_powerdown_mode,
180 .set = ad5791_set_powerdown_mode,
183 static ssize_t ad5791_read_dac_powerdown(struct iio_dev *indio_dev,
184 uintptr_t private, const struct iio_chan_spec *chan, char *buf)
186 struct ad5791_state *st = iio_priv(indio_dev);
188 return sprintf(buf, "%d\n", st->pwr_down);
191 static ssize_t ad5791_write_dac_powerdown(struct iio_dev *indio_dev,
192 uintptr_t private, const struct iio_chan_spec *chan, const char *buf,
197 struct ad5791_state *st = iio_priv(indio_dev);
199 ret = strtobool(buf, &pwr_down);
204 st->ctrl &= ~(AD5791_CTRL_OPGND | AD5791_CTRL_DACTRI);
206 if (st->pwr_down_mode == AD5791_DAC_PWRDN_6K)
207 st->ctrl |= AD5791_CTRL_OPGND;
208 else if (st->pwr_down_mode == AD5791_DAC_PWRDN_3STATE)
209 st->ctrl |= AD5791_CTRL_DACTRI;
211 st->pwr_down = pwr_down;
213 ret = ad5791_spi_write(st->spi, AD5791_ADDR_CTRL, st->ctrl);
215 return ret ? ret : len;
218 static int ad5791_get_lin_comp(unsigned int span)
221 return AD5791_LINCOMP_0_10;
222 else if (span <= 12000)
223 return AD5791_LINCOMP_10_12;
224 else if (span <= 16000)
225 return AD5791_LINCOMP_12_16;
226 else if (span <= 19000)
227 return AD5791_LINCOMP_16_19;
229 return AD5791_LINCOMP_19_20;
232 static int ad5780_get_lin_comp(unsigned int span)
235 return AD5780_LINCOMP_0_10;
237 return AD5780_LINCOMP_10_20;
239 static const struct ad5791_chip_info ad5791_chip_info_tbl[] = {
241 .get_lin_comp = ad5780_get_lin_comp,
244 .get_lin_comp = ad5780_get_lin_comp,
247 .get_lin_comp = ad5791_get_lin_comp,
250 .get_lin_comp = ad5791_get_lin_comp,
254 static int ad5791_read_raw(struct iio_dev *indio_dev,
255 struct iio_chan_spec const *chan,
260 struct ad5791_state *st = iio_priv(indio_dev);
265 case IIO_CHAN_INFO_RAW:
266 ret = ad5791_spi_read(st->spi, chan->address, val);
269 *val &= AD5791_DAC_MASK;
270 *val >>= chan->scan_type.shift;
272 case IIO_CHAN_INFO_SCALE:
274 *val2 = (((u64)st->vref_mv) * 1000000ULL) >> chan->scan_type.realbits;
275 return IIO_VAL_INT_PLUS_MICRO;
276 case IIO_CHAN_INFO_OFFSET:
277 val64 = (((u64)st->vref_neg_mv) << chan->scan_type.realbits);
278 do_div(val64, st->vref_mv);
287 static const struct iio_chan_spec_ext_info ad5791_ext_info[] = {
291 .read = ad5791_read_dac_powerdown,
292 .write = ad5791_write_dac_powerdown,
294 IIO_ENUM("powerdown_mode", true, &ad5791_powerdown_mode_enum),
295 IIO_ENUM_AVAILABLE("powerdown_mode", &ad5791_powerdown_mode_enum),
299 #define AD5791_CHAN(bits, shift) { \
300 .type = IIO_VOLTAGE, \
303 .address = AD5791_ADDR_DAC0, \
305 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
306 IIO_CHAN_INFO_SCALE_SHARED_BIT | \
307 IIO_CHAN_INFO_OFFSET_SHARED_BIT, \
308 .scan_type = IIO_ST('u', bits, 24, shift), \
309 .ext_info = ad5791_ext_info, \
312 static const struct iio_chan_spec ad5791_channels[] = {
313 [ID_AD5760] = AD5791_CHAN(16, 4),
314 [ID_AD5780] = AD5791_CHAN(18, 2),
315 [ID_AD5781] = AD5791_CHAN(18, 2),
316 [ID_AD5791] = AD5791_CHAN(20, 0)
319 static int ad5791_write_raw(struct iio_dev *indio_dev,
320 struct iio_chan_spec const *chan,
325 struct ad5791_state *st = iio_priv(indio_dev);
328 case IIO_CHAN_INFO_RAW:
329 val &= AD5791_RES_MASK(chan->scan_type.realbits);
330 val <<= chan->scan_type.shift;
332 return ad5791_spi_write(st->spi, chan->address, val);
339 static const struct iio_info ad5791_info = {
340 .read_raw = &ad5791_read_raw,
341 .write_raw = &ad5791_write_raw,
342 .driver_module = THIS_MODULE,
345 static int ad5791_probe(struct spi_device *spi)
347 struct ad5791_platform_data *pdata = spi->dev.platform_data;
348 struct iio_dev *indio_dev;
349 struct ad5791_state *st;
350 int ret, pos_voltage_uv = 0, neg_voltage_uv = 0;
352 indio_dev = iio_device_alloc(sizeof(*st));
353 if (indio_dev == NULL) {
357 st = iio_priv(indio_dev);
358 st->reg_vdd = regulator_get(&spi->dev, "vdd");
359 if (!IS_ERR(st->reg_vdd)) {
360 ret = regulator_enable(st->reg_vdd);
362 goto error_put_reg_pos;
364 ret = regulator_get_voltage(st->reg_vdd);
366 goto error_disable_reg_pos;
368 pos_voltage_uv = ret;
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 ret = regulator_get_voltage(st->reg_vss);
379 goto error_disable_reg_neg;
381 neg_voltage_uv = ret;
387 if (!IS_ERR(st->reg_vss) && !IS_ERR(st->reg_vdd)) {
388 st->vref_mv = (pos_voltage_uv + neg_voltage_uv) / 1000;
389 st->vref_neg_mv = neg_voltage_uv / 1000;
391 st->vref_mv = pdata->vref_pos_mv + pdata->vref_neg_mv;
392 st->vref_neg_mv = pdata->vref_neg_mv;
394 dev_warn(&spi->dev, "reference voltage unspecified\n");
397 ret = ad5791_spi_write(spi, AD5791_ADDR_SW_CTRL, AD5791_SWCTRL_RESET);
399 goto error_disable_reg_neg;
401 st->chip_info = &ad5791_chip_info_tbl[spi_get_device_id(spi)
405 st->ctrl = AD5761_CTRL_LINCOMP(st->chip_info->get_lin_comp(st->vref_mv))
406 | ((pdata && pdata->use_rbuf_gain2) ? 0 : AD5791_CTRL_RBUF) |
409 ret = ad5791_spi_write(spi, AD5791_ADDR_CTRL, st->ctrl |
410 AD5791_CTRL_OPGND | AD5791_CTRL_DACTRI);
412 goto error_disable_reg_neg;
414 spi_set_drvdata(spi, indio_dev);
415 indio_dev->dev.parent = &spi->dev;
416 indio_dev->info = &ad5791_info;
417 indio_dev->modes = INDIO_DIRECT_MODE;
419 = &ad5791_channels[spi_get_device_id(spi)->driver_data];
420 indio_dev->num_channels = 1;
421 indio_dev->name = spi_get_device_id(st->spi)->name;
422 ret = iio_device_register(indio_dev);
424 goto error_disable_reg_neg;
428 error_disable_reg_neg:
429 if (!IS_ERR(st->reg_vss))
430 regulator_disable(st->reg_vss);
432 if (!IS_ERR(st->reg_vss))
433 regulator_put(st->reg_vss);
435 error_disable_reg_pos:
436 if (!IS_ERR(st->reg_vdd))
437 regulator_disable(st->reg_vdd);
439 if (!IS_ERR(st->reg_vdd))
440 regulator_put(st->reg_vdd);
441 iio_device_free(indio_dev);
447 static int ad5791_remove(struct spi_device *spi)
449 struct iio_dev *indio_dev = spi_get_drvdata(spi);
450 struct ad5791_state *st = iio_priv(indio_dev);
452 iio_device_unregister(indio_dev);
453 if (!IS_ERR(st->reg_vdd)) {
454 regulator_disable(st->reg_vdd);
455 regulator_put(st->reg_vdd);
458 if (!IS_ERR(st->reg_vss)) {
459 regulator_disable(st->reg_vss);
460 regulator_put(st->reg_vss);
462 iio_device_free(indio_dev);
467 static const struct spi_device_id ad5791_id[] = {
468 {"ad5760", ID_AD5760},
469 {"ad5780", ID_AD5780},
470 {"ad5781", ID_AD5781},
471 {"ad5790", ID_AD5791},
472 {"ad5791", ID_AD5791},
475 MODULE_DEVICE_TABLE(spi, ad5791_id);
477 static struct spi_driver ad5791_driver = {
480 .owner = THIS_MODULE,
482 .probe = ad5791_probe,
483 .remove = ad5791_remove,
484 .id_table = ad5791_id,
486 module_spi_driver(ad5791_driver);
488 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
489 MODULE_DESCRIPTION("Analog Devices AD5760/AD5780/AD5781/AD5790/AD5791 DAC");
490 MODULE_LICENSE("GPL v2");