blob: 5ba785f1858988b6cef32e3dc79b78e171da3bfe [file] [log] [blame]
Michael Hennerich69d900a2011-04-18 09:40:58 +02001/*
Lars-Peter Clausen9d41c5b2011-12-09 17:12:42 +01002 * AD5760, AD5780, AD5781, AD5790, AD5791 Voltage Output Digital to Analog
3 * Converter
Michael Hennerich69d900a2011-04-18 09:40:58 +02004 *
5 * Copyright 2011 Analog Devices Inc.
6 *
7 * Licensed under the GPL-2.
8 */
9
10#include <linux/interrupt.h>
Michael Hennerich69d900a2011-04-18 09:40:58 +020011#include <linux/fs.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>
Paul Gortmaker99c97852011-07-03 15:49:50 -040018#include <linux/module.h>
Peter Meerwaldff96bf52014-12-06 06:00:00 +000019#include <linux/bitops.h>
Michael Hennerich69d900a2011-04-18 09:40:58 +020020
Jonathan Cameron06458e22012-04-25 15:54:58 +010021#include <linux/iio/iio.h>
22#include <linux/iio/sysfs.h>
Lars-Peter Clausendbdc0252012-06-04 11:36:28 +020023#include <linux/iio/dac/ad5791.h>
Michael Hennerich69d900a2011-04-18 09:40:58 +020024
Peter Meerwaldff96bf52014-12-06 06:00:00 +000025#define AD5791_DAC_MASK GENMASK(19, 0)
Lars-Peter Clausen20374d12012-06-04 11:36:27 +020026
Peter Meerwaldff96bf52014-12-06 06:00:00 +000027#define AD5791_CMD_READ BIT(23)
28#define AD5791_CMD_WRITE 0
Lars-Peter Clausen20374d12012-06-04 11:36:27 +020029#define AD5791_ADDR(addr) ((addr) << 20)
30
31/* Registers */
32#define AD5791_ADDR_NOOP 0
33#define AD5791_ADDR_DAC0 1
34#define AD5791_ADDR_CTRL 2
35#define AD5791_ADDR_CLRCODE 3
36#define AD5791_ADDR_SW_CTRL 4
37
38/* Control Register */
Peter Meerwaldff96bf52014-12-06 06:00:00 +000039#define AD5791_CTRL_RBUF BIT(1)
40#define AD5791_CTRL_OPGND BIT(2)
41#define AD5791_CTRL_DACTRI BIT(3)
42#define AD5791_CTRL_BIN2SC BIT(4)
43#define AD5791_CTRL_SDODIS BIT(5)
Lars-Peter Clausen20374d12012-06-04 11:36:27 +020044#define AD5761_CTRL_LINCOMP(x) ((x) << 6)
45
46#define AD5791_LINCOMP_0_10 0
47#define AD5791_LINCOMP_10_12 1
48#define AD5791_LINCOMP_12_16 2
49#define AD5791_LINCOMP_16_19 3
50#define AD5791_LINCOMP_19_20 12
51
52#define AD5780_LINCOMP_0_10 0
53#define AD5780_LINCOMP_10_20 12
54
55/* Software Control Register */
Peter Meerwaldff96bf52014-12-06 06:00:00 +000056#define AD5791_SWCTRL_LDAC BIT(0)
57#define AD5791_SWCTRL_CLR BIT(1)
58#define AD5791_SWCTRL_RESET BIT(2)
Lars-Peter Clausen20374d12012-06-04 11:36:27 +020059
60#define AD5791_DAC_PWRDN_6K 0
61#define AD5791_DAC_PWRDN_3STATE 1
62
63/**
64 * struct ad5791_chip_info - chip specific information
65 * @get_lin_comp: function pointer to the device specific function
66 */
67
68struct ad5791_chip_info {
69 int (*get_lin_comp) (unsigned int span);
70};
71
72/**
73 * struct ad5791_state - driver instance specific data
Peter Meerwaldff96bf52014-12-06 06:00:00 +000074 * @spi: spi_device
Lars-Peter Clausen20374d12012-06-04 11:36:27 +020075 * @reg_vdd: positive supply regulator
76 * @reg_vss: negative supply regulator
77 * @chip_info: chip model specific constants
78 * @vref_mv: actual reference voltage used
79 * @vref_neg_mv: voltage of the negative supply
80 * @pwr_down_mode current power down mode
81 */
82
83struct ad5791_state {
84 struct spi_device *spi;
85 struct regulator *reg_vdd;
86 struct regulator *reg_vss;
87 const struct ad5791_chip_info *chip_info;
88 unsigned short vref_mv;
89 unsigned int vref_neg_mv;
90 unsigned ctrl;
91 unsigned pwr_down_mode;
92 bool pwr_down;
Lars-Peter Clausen791bb522013-11-25 12:41:00 +000093
94 union {
95 __be32 d32;
96 u8 d8[4];
97 } data[3] ____cacheline_aligned;
Lars-Peter Clausen20374d12012-06-04 11:36:27 +020098};
99
100/**
101 * ad5791_supported_device_ids:
102 */
103
104enum ad5791_supported_device_ids {
105 ID_AD5760,
106 ID_AD5780,
107 ID_AD5781,
108 ID_AD5791,
109};
110
Lars-Peter Clausen791bb522013-11-25 12:41:00 +0000111static int ad5791_spi_write(struct ad5791_state *st, u8 addr, u32 val)
Michael Hennerich69d900a2011-04-18 09:40:58 +0200112{
Lars-Peter Clausen791bb522013-11-25 12:41:00 +0000113 st->data[0].d32 = cpu_to_be32(AD5791_CMD_WRITE |
Michael Hennerich69d900a2011-04-18 09:40:58 +0200114 AD5791_ADDR(addr) |
115 (val & AD5791_DAC_MASK));
116
Lars-Peter Clausen791bb522013-11-25 12:41:00 +0000117 return spi_write(st->spi, &st->data[0].d8[1], 3);
Michael Hennerich69d900a2011-04-18 09:40:58 +0200118}
119
Lars-Peter Clausen791bb522013-11-25 12:41:00 +0000120static int ad5791_spi_read(struct ad5791_state *st, u8 addr, u32 *val)
Michael Hennerich69d900a2011-04-18 09:40:58 +0200121{
Michael Hennerich69d900a2011-04-18 09:40:58 +0200122 int ret;
Michael Hennerich69d900a2011-04-18 09:40:58 +0200123 struct spi_transfer xfers[] = {
124 {
Lars-Peter Clausen791bb522013-11-25 12:41:00 +0000125 .tx_buf = &st->data[0].d8[1],
Michael Hennerich69d900a2011-04-18 09:40:58 +0200126 .bits_per_word = 8,
127 .len = 3,
128 .cs_change = 1,
129 }, {
Lars-Peter Clausen791bb522013-11-25 12:41:00 +0000130 .tx_buf = &st->data[1].d8[1],
131 .rx_buf = &st->data[2].d8[1],
Michael Hennerich69d900a2011-04-18 09:40:58 +0200132 .bits_per_word = 8,
133 .len = 3,
134 },
135 };
136
Lars-Peter Clausen791bb522013-11-25 12:41:00 +0000137 st->data[0].d32 = cpu_to_be32(AD5791_CMD_READ |
Michael Hennerich69d900a2011-04-18 09:40:58 +0200138 AD5791_ADDR(addr));
Lars-Peter Clausen791bb522013-11-25 12:41:00 +0000139 st->data[1].d32 = cpu_to_be32(AD5791_ADDR(AD5791_ADDR_NOOP));
Michael Hennerich69d900a2011-04-18 09:40:58 +0200140
Lars-Peter Clausen791bb522013-11-25 12:41:00 +0000141 ret = spi_sync_transfer(st->spi, xfers, ARRAY_SIZE(xfers));
Michael Hennerich69d900a2011-04-18 09:40:58 +0200142
Lars-Peter Clausen791bb522013-11-25 12:41:00 +0000143 *val = be32_to_cpu(st->data[2].d32);
Michael Hennerich69d900a2011-04-18 09:40:58 +0200144
145 return ret;
146}
147
Lars-Peter Clausen4571b392012-06-04 11:36:18 +0200148static const char * const ad5791_powerdown_modes[] = {
149 "6kohm_to_gnd",
150 "three_state",
Jonathan Cameronc5b99392011-09-02 17:25:19 +0100151};
Michael Hennerich69d900a2011-04-18 09:40:58 +0200152
Lars-Peter Clausen4571b392012-06-04 11:36:18 +0200153static int ad5791_get_powerdown_mode(struct iio_dev *indio_dev,
154 const struct iio_chan_spec *chan)
Michael Hennerich69d900a2011-04-18 09:40:58 +0200155{
Jonathan Cameronf5730d52011-06-27 13:07:34 +0100156 struct ad5791_state *st = iio_priv(indio_dev);
Michael Hennerich69d900a2011-04-18 09:40:58 +0200157
Lars-Peter Clausen4571b392012-06-04 11:36:18 +0200158 return st->pwr_down_mode;
Michael Hennerich69d900a2011-04-18 09:40:58 +0200159}
160
Lars-Peter Clausen4571b392012-06-04 11:36:18 +0200161static int ad5791_set_powerdown_mode(struct iio_dev *indio_dev,
162 const struct iio_chan_spec *chan, unsigned int mode)
Michael Hennerich69d900a2011-04-18 09:40:58 +0200163{
Jonathan Cameronf5730d52011-06-27 13:07:34 +0100164 struct ad5791_state *st = iio_priv(indio_dev);
Michael Hennerich69d900a2011-04-18 09:40:58 +0200165
Lars-Peter Clausen4571b392012-06-04 11:36:18 +0200166 st->pwr_down_mode = mode;
Michael Hennerich69d900a2011-04-18 09:40:58 +0200167
Lars-Peter Clausen4571b392012-06-04 11:36:18 +0200168 return 0;
Michael Hennerich69d900a2011-04-18 09:40:58 +0200169}
170
Lars-Peter Clausen4571b392012-06-04 11:36:18 +0200171static const struct iio_enum ad5791_powerdown_mode_enum = {
172 .items = ad5791_powerdown_modes,
173 .num_items = ARRAY_SIZE(ad5791_powerdown_modes),
174 .get = ad5791_get_powerdown_mode,
175 .set = ad5791_set_powerdown_mode,
176};
177
178static ssize_t ad5791_read_dac_powerdown(struct iio_dev *indio_dev,
179 uintptr_t private, const struct iio_chan_spec *chan, char *buf)
Michael Hennerich69d900a2011-04-18 09:40:58 +0200180{
Jonathan Cameronf5730d52011-06-27 13:07:34 +0100181 struct ad5791_state *st = iio_priv(indio_dev);
Michael Hennerich69d900a2011-04-18 09:40:58 +0200182
183 return sprintf(buf, "%d\n", st->pwr_down);
184}
185
Lars-Peter Clausen4571b392012-06-04 11:36:18 +0200186static ssize_t ad5791_write_dac_powerdown(struct iio_dev *indio_dev,
187 uintptr_t private, const struct iio_chan_spec *chan, const char *buf,
188 size_t len)
Michael Hennerich69d900a2011-04-18 09:40:58 +0200189{
Lars-Peter Clausen4468cb552012-06-04 11:36:24 +0200190 bool pwr_down;
Michael Hennerich69d900a2011-04-18 09:40:58 +0200191 int ret;
Jonathan Cameronf5730d52011-06-27 13:07:34 +0100192 struct ad5791_state *st = iio_priv(indio_dev);
Michael Hennerich69d900a2011-04-18 09:40:58 +0200193
Lars-Peter Clausen4468cb552012-06-04 11:36:24 +0200194 ret = strtobool(buf, &pwr_down);
Michael Hennerich69d900a2011-04-18 09:40:58 +0200195 if (ret)
196 return ret;
197
Lars-Peter Clausen4468cb552012-06-04 11:36:24 +0200198 if (!pwr_down) {
Michael Hennerich69d900a2011-04-18 09:40:58 +0200199 st->ctrl &= ~(AD5791_CTRL_OPGND | AD5791_CTRL_DACTRI);
Lars-Peter Clausen4468cb552012-06-04 11:36:24 +0200200 } else {
Michael Hennerich69d900a2011-04-18 09:40:58 +0200201 if (st->pwr_down_mode == AD5791_DAC_PWRDN_6K)
202 st->ctrl |= AD5791_CTRL_OPGND;
203 else if (st->pwr_down_mode == AD5791_DAC_PWRDN_3STATE)
204 st->ctrl |= AD5791_CTRL_DACTRI;
Lars-Peter Clausen4468cb552012-06-04 11:36:24 +0200205 }
206 st->pwr_down = pwr_down;
Michael Hennerich69d900a2011-04-18 09:40:58 +0200207
Lars-Peter Clausen791bb522013-11-25 12:41:00 +0000208 ret = ad5791_spi_write(st, AD5791_ADDR_CTRL, st->ctrl);
Michael Hennerich69d900a2011-04-18 09:40:58 +0200209
210 return ret ? ret : len;
211}
212
Michael Hennerich69d900a2011-04-18 09:40:58 +0200213static int ad5791_get_lin_comp(unsigned int span)
214{
215 if (span <= 10000)
216 return AD5791_LINCOMP_0_10;
217 else if (span <= 12000)
218 return AD5791_LINCOMP_10_12;
219 else if (span <= 16000)
220 return AD5791_LINCOMP_12_16;
221 else if (span <= 19000)
222 return AD5791_LINCOMP_16_19;
223 else
224 return AD5791_LINCOMP_19_20;
225}
226
Michael Hennerichba1c2bb2011-04-27 17:13:58 +0200227static int ad5780_get_lin_comp(unsigned int span)
228{
229 if (span <= 10000)
230 return AD5780_LINCOMP_0_10;
231 else
232 return AD5780_LINCOMP_10_20;
233}
Michael Hennerichba1c2bb2011-04-27 17:13:58 +0200234static const struct ad5791_chip_info ad5791_chip_info_tbl[] = {
235 [ID_AD5760] = {
Michael Hennerichba1c2bb2011-04-27 17:13:58 +0200236 .get_lin_comp = ad5780_get_lin_comp,
237 },
238 [ID_AD5780] = {
Michael Hennerichba1c2bb2011-04-27 17:13:58 +0200239 .get_lin_comp = ad5780_get_lin_comp,
240 },
241 [ID_AD5781] = {
Michael Hennerichba1c2bb2011-04-27 17:13:58 +0200242 .get_lin_comp = ad5791_get_lin_comp,
243 },
244 [ID_AD5791] = {
Michael Hennerichba1c2bb2011-04-27 17:13:58 +0200245 .get_lin_comp = ad5791_get_lin_comp,
246 },
247};
248
Jonathan Cameronc5b99392011-09-02 17:25:19 +0100249static int ad5791_read_raw(struct iio_dev *indio_dev,
250 struct iio_chan_spec const *chan,
251 int *val,
252 int *val2,
253 long m)
254{
255 struct ad5791_state *st = iio_priv(indio_dev);
Lars-Peter Clausen9dc99612011-10-19 17:47:50 +0200256 u64 val64;
Jonathan Cameronc5b99392011-09-02 17:25:19 +0100257 int ret;
258
259 switch (m) {
Jonathan Cameron09f4eb42012-04-15 17:41:19 +0100260 case IIO_CHAN_INFO_RAW:
Lars-Peter Clausen791bb522013-11-25 12:41:00 +0000261 ret = ad5791_spi_read(st, chan->address, val);
Jonathan Cameronc5b99392011-09-02 17:25:19 +0100262 if (ret)
263 return ret;
264 *val &= AD5791_DAC_MASK;
265 *val >>= chan->scan_type.shift;
Jonathan Cameronc5b99392011-09-02 17:25:19 +0100266 return IIO_VAL_INT;
Jonathan Cameronc8a9f802011-10-26 17:41:36 +0100267 case IIO_CHAN_INFO_SCALE:
Lars-Peter Clausen213983c2013-09-28 10:31:00 +0100268 *val = st->vref_mv;
269 *val2 = (1 << chan->scan_type.realbits) - 1;
270 return IIO_VAL_FRACTIONAL;
Jonathan Cameronc8a9f802011-10-26 17:41:36 +0100271 case IIO_CHAN_INFO_OFFSET:
Lars-Peter Clausen9dc99612011-10-19 17:47:50 +0200272 val64 = (((u64)st->vref_neg_mv) << chan->scan_type.realbits);
273 do_div(val64, st->vref_mv);
274 *val = -val64;
275 return IIO_VAL_INT;
Jonathan Cameronc5b99392011-09-02 17:25:19 +0100276 default:
277 return -EINVAL;
278 }
279
280};
281
Lars-Peter Clausen4571b392012-06-04 11:36:18 +0200282static const struct iio_chan_spec_ext_info ad5791_ext_info[] = {
283 {
284 .name = "powerdown",
Jonathan Cameron37044322013-09-08 14:57:00 +0100285 .shared = IIO_SHARED_BY_TYPE,
Lars-Peter Clausen4571b392012-06-04 11:36:18 +0200286 .read = ad5791_read_dac_powerdown,
287 .write = ad5791_write_dac_powerdown,
288 },
Jonathan Cameron37044322013-09-08 14:57:00 +0100289 IIO_ENUM("powerdown_mode", IIO_SHARED_BY_TYPE,
290 &ad5791_powerdown_mode_enum),
Lars-Peter Clausen4571b392012-06-04 11:36:18 +0200291 IIO_ENUM_AVAILABLE("powerdown_mode", &ad5791_powerdown_mode_enum),
292 { },
293};
294
Jonathan Cameroncb9d90f2013-12-11 18:45:00 +0000295#define AD5791_CHAN(bits, _shift) { \
Lars-Peter Clausen4571b392012-06-04 11:36:18 +0200296 .type = IIO_VOLTAGE, \
297 .output = 1, \
298 .indexed = 1, \
299 .address = AD5791_ADDR_DAC0, \
300 .channel = 0, \
Jonathan Cameron76112942013-02-27 19:28:12 +0000301 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
302 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
303 BIT(IIO_CHAN_INFO_OFFSET), \
Jonathan Cameroncb9d90f2013-12-11 18:45:00 +0000304 .scan_type = { \
305 .sign = 'u', \
306 .realbits = (bits), \
307 .storagebits = 24, \
308 .shift = (_shift), \
309 }, \
Lars-Peter Clausen4571b392012-06-04 11:36:18 +0200310 .ext_info = ad5791_ext_info, \
311}
312
313static const struct iio_chan_spec ad5791_channels[] = {
314 [ID_AD5760] = AD5791_CHAN(16, 4),
315 [ID_AD5780] = AD5791_CHAN(18, 2),
316 [ID_AD5781] = AD5791_CHAN(18, 2),
317 [ID_AD5791] = AD5791_CHAN(20, 0)
318};
Jonathan Cameronc5b99392011-09-02 17:25:19 +0100319
320static int ad5791_write_raw(struct iio_dev *indio_dev,
321 struct iio_chan_spec const *chan,
322 int val,
323 int val2,
324 long mask)
325{
326 struct ad5791_state *st = iio_priv(indio_dev);
327
328 switch (mask) {
Jonathan Cameron09f4eb42012-04-15 17:41:19 +0100329 case IIO_CHAN_INFO_RAW:
Peter Meerwaldff96bf52014-12-06 06:00:00 +0000330 val &= GENMASK(chan->scan_type.realbits - 1, 0);
Jonathan Cameronc5b99392011-09-02 17:25:19 +0100331 val <<= chan->scan_type.shift;
332
Lars-Peter Clausen791bb522013-11-25 12:41:00 +0000333 return ad5791_spi_write(st, chan->address, val);
Jonathan Cameronc5b99392011-09-02 17:25:19 +0100334
335 default:
336 return -EINVAL;
337 }
338}
339
Jonathan Cameron6fe81352011-05-18 14:42:37 +0100340static const struct iio_info ad5791_info = {
Jonathan Cameronc5b99392011-09-02 17:25:19 +0100341 .read_raw = &ad5791_read_raw,
342 .write_raw = &ad5791_write_raw,
Jonathan Cameron6fe81352011-05-18 14:42:37 +0100343 .driver_module = THIS_MODULE,
344};
345
Greg Kroah-Hartmanfc526922012-12-21 13:21:43 -0800346static int ad5791_probe(struct spi_device *spi)
Michael Hennerich69d900a2011-04-18 09:40:58 +0200347{
348 struct ad5791_platform_data *pdata = spi->dev.platform_data;
Jonathan Cameronf5730d52011-06-27 13:07:34 +0100349 struct iio_dev *indio_dev;
Michael Hennerich69d900a2011-04-18 09:40:58 +0200350 struct ad5791_state *st;
351 int ret, pos_voltage_uv = 0, neg_voltage_uv = 0;
352
Sachin Kamat0d7c04d2013-08-19 12:38:00 +0100353 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
354 if (!indio_dev)
355 return -ENOMEM;
Jonathan Cameronf5730d52011-06-27 13:07:34 +0100356 st = iio_priv(indio_dev);
Sachin Kamat0d7c04d2013-08-19 12:38:00 +0100357 st->reg_vdd = devm_regulator_get(&spi->dev, "vdd");
Jonathan Cameron26a54792011-08-30 12:41:19 +0100358 if (!IS_ERR(st->reg_vdd)) {
359 ret = regulator_enable(st->reg_vdd);
360 if (ret)
Sachin Kamat0d7c04d2013-08-19 12:38:00 +0100361 return ret;
Jonathan Cameron26a54792011-08-30 12:41:19 +0100362
Axel Lin7e2dcc62012-12-14 07:55:00 +0000363 ret = regulator_get_voltage(st->reg_vdd);
364 if (ret < 0)
365 goto error_disable_reg_pos;
366
367 pos_voltage_uv = ret;
Jonathan Cameron26a54792011-08-30 12:41:19 +0100368 }
369
Sachin Kamat0d7c04d2013-08-19 12:38:00 +0100370 st->reg_vss = devm_regulator_get(&spi->dev, "vss");
Jonathan Cameron26a54792011-08-30 12:41:19 +0100371 if (!IS_ERR(st->reg_vss)) {
372 ret = regulator_enable(st->reg_vss);
373 if (ret)
Sachin Kamat0d7c04d2013-08-19 12:38:00 +0100374 goto error_disable_reg_pos;
Jonathan Cameron26a54792011-08-30 12:41:19 +0100375
Axel Lin7e2dcc62012-12-14 07:55:00 +0000376 ret = regulator_get_voltage(st->reg_vss);
377 if (ret < 0)
378 goto error_disable_reg_neg;
379
380 neg_voltage_uv = ret;
Jonathan Cameron26a54792011-08-30 12:41:19 +0100381 }
382
Jonathan Cameronf5730d52011-06-27 13:07:34 +0100383 st->pwr_down = true;
384 st->spi = spi;
385
Lars-Peter Clausen9dc99612011-10-19 17:47:50 +0200386 if (!IS_ERR(st->reg_vss) && !IS_ERR(st->reg_vdd)) {
387 st->vref_mv = (pos_voltage_uv + neg_voltage_uv) / 1000;
388 st->vref_neg_mv = neg_voltage_uv / 1000;
389 } else if (pdata) {
390 st->vref_mv = pdata->vref_pos_mv + pdata->vref_neg_mv;
391 st->vref_neg_mv = pdata->vref_neg_mv;
392 } else {
Michael Hennerich69d900a2011-04-18 09:40:58 +0200393 dev_warn(&spi->dev, "reference voltage unspecified\n");
Lars-Peter Clausen9dc99612011-10-19 17:47:50 +0200394 }
Michael Hennerich69d900a2011-04-18 09:40:58 +0200395
Lars-Peter Clausen791bb522013-11-25 12:41:00 +0000396 ret = ad5791_spi_write(st, AD5791_ADDR_SW_CTRL, AD5791_SWCTRL_RESET);
Michael Hennerich69d900a2011-04-18 09:40:58 +0200397 if (ret)
Jonathan Cameron26a54792011-08-30 12:41:19 +0100398 goto error_disable_reg_neg;
Michael Hennerich69d900a2011-04-18 09:40:58 +0200399
Jonathan Cameronc5b99392011-09-02 17:25:19 +0100400 st->chip_info = &ad5791_chip_info_tbl[spi_get_device_id(spi)
401 ->driver_data];
Michael Hennerich69d900a2011-04-18 09:40:58 +0200402
403
Michael Hennerichba1c2bb2011-04-27 17:13:58 +0200404 st->ctrl = AD5761_CTRL_LINCOMP(st->chip_info->get_lin_comp(st->vref_mv))
405 | ((pdata && pdata->use_rbuf_gain2) ? 0 : AD5791_CTRL_RBUF) |
Michael Hennerich69d900a2011-04-18 09:40:58 +0200406 AD5791_CTRL_BIN2SC;
407
Lars-Peter Clausen791bb522013-11-25 12:41:00 +0000408 ret = ad5791_spi_write(st, AD5791_ADDR_CTRL, st->ctrl |
Michael Hennerich69d900a2011-04-18 09:40:58 +0200409 AD5791_CTRL_OPGND | AD5791_CTRL_DACTRI);
410 if (ret)
Jonathan Cameron26a54792011-08-30 12:41:19 +0100411 goto error_disable_reg_neg;
Michael Hennerich69d900a2011-04-18 09:40:58 +0200412
Jonathan Cameronf5730d52011-06-27 13:07:34 +0100413 spi_set_drvdata(spi, indio_dev);
414 indio_dev->dev.parent = &spi->dev;
415 indio_dev->info = &ad5791_info;
416 indio_dev->modes = INDIO_DIRECT_MODE;
Jonathan Cameronc5b99392011-09-02 17:25:19 +0100417 indio_dev->channels
418 = &ad5791_channels[spi_get_device_id(spi)->driver_data];
419 indio_dev->num_channels = 1;
420 indio_dev->name = spi_get_device_id(st->spi)->name;
Jonathan Cameronf5730d52011-06-27 13:07:34 +0100421 ret = iio_device_register(indio_dev);
Michael Hennerich69d900a2011-04-18 09:40:58 +0200422 if (ret)
Jonathan Cameron26a54792011-08-30 12:41:19 +0100423 goto error_disable_reg_neg;
Michael Hennerich69d900a2011-04-18 09:40:58 +0200424
425 return 0;
426
Michael Hennerich69d900a2011-04-18 09:40:58 +0200427error_disable_reg_neg:
Jonathan Cameron26a54792011-08-30 12:41:19 +0100428 if (!IS_ERR(st->reg_vss))
429 regulator_disable(st->reg_vss);
Axel Lin7e2dcc62012-12-14 07:55:00 +0000430error_disable_reg_pos:
Jonathan Cameron26a54792011-08-30 12:41:19 +0100431 if (!IS_ERR(st->reg_vdd))
432 regulator_disable(st->reg_vdd);
Michael Hennerich69d900a2011-04-18 09:40:58 +0200433 return ret;
434}
435
Greg Kroah-Hartmanfc526922012-12-21 13:21:43 -0800436static int ad5791_remove(struct spi_device *spi)
Michael Hennerich69d900a2011-04-18 09:40:58 +0200437{
Jonathan Cameronf5730d52011-06-27 13:07:34 +0100438 struct iio_dev *indio_dev = spi_get_drvdata(spi);
439 struct ad5791_state *st = iio_priv(indio_dev);
Michael Hennerich69d900a2011-04-18 09:40:58 +0200440
Jonathan Camerond2fffd62011-10-14 14:46:58 +0100441 iio_device_unregister(indio_dev);
Sachin Kamat0d7c04d2013-08-19 12:38:00 +0100442 if (!IS_ERR(st->reg_vdd))
Jonathan Cameron26a54792011-08-30 12:41:19 +0100443 regulator_disable(st->reg_vdd);
Michael Hennerich69d900a2011-04-18 09:40:58 +0200444
Sachin Kamat0d7c04d2013-08-19 12:38:00 +0100445 if (!IS_ERR(st->reg_vss))
Jonathan Cameron26a54792011-08-30 12:41:19 +0100446 regulator_disable(st->reg_vss);
Jonathan Cameron26d25ae2011-09-02 17:14:40 +0100447
Michael Hennerich69d900a2011-04-18 09:40:58 +0200448 return 0;
449}
450
451static const struct spi_device_id ad5791_id[] = {
Michael Hennerichba1c2bb2011-04-27 17:13:58 +0200452 {"ad5760", ID_AD5760},
453 {"ad5780", ID_AD5780},
Michael Hennerich69d900a2011-04-18 09:40:58 +0200454 {"ad5781", ID_AD5781},
Lars-Peter Clausen9d41c5b2011-12-09 17:12:42 +0100455 {"ad5790", ID_AD5791},
Michael Hennerichba1c2bb2011-04-27 17:13:58 +0200456 {"ad5791", ID_AD5791},
Michael Hennerich69d900a2011-04-18 09:40:58 +0200457 {}
458};
Lars-Peter Clausen55e43902011-11-16 08:53:31 +0100459MODULE_DEVICE_TABLE(spi, ad5791_id);
Michael Hennerich69d900a2011-04-18 09:40:58 +0200460
461static struct spi_driver ad5791_driver = {
462 .driver = {
463 .name = "ad5791",
464 .owner = THIS_MODULE,
465 },
466 .probe = ad5791_probe,
Greg Kroah-Hartmanfc526922012-12-21 13:21:43 -0800467 .remove = ad5791_remove,
Michael Hennerich69d900a2011-04-18 09:40:58 +0200468 .id_table = ad5791_id,
469};
Lars-Peter Clausenae6ae6f2011-11-16 10:13:39 +0100470module_spi_driver(ad5791_driver);
Michael Hennerich69d900a2011-04-18 09:40:58 +0200471
472MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
Lars-Peter Clausen9d41c5b2011-12-09 17:12:42 +0100473MODULE_DESCRIPTION("Analog Devices AD5760/AD5780/AD5781/AD5790/AD5791 DAC");
Michael Hennerich69d900a2011-04-18 09:40:58 +0200474MODULE_LICENSE("GPL v2");