1 /*
2 * AD5760, AD5780, AD5781, AD5790, AD5791 Voltage Output Digital to Analog
3 * Converter
4 *
5 * Copyright 2011 Analog Devices Inc.
6 *
7 * Licensed under the GPL-2.
8 */
9
10 #include <linux/interrupt.h>
11 #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>
18 #include <linux/module.h>
19 #include <linux/bitops.h>
20
21 #include <linux/iio/iio.h>
22 #include <linux/iio/sysfs.h>
23 #include <linux/iio/dac/ad5791.h>
24
25 #define AD5791_DAC_MASK GENMASK(19, 0)
26
27 #define AD5791_CMD_READ BIT(23)
28 #define AD5791_CMD_WRITE 0
29 #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 */
39 #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)
44 #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 */
56 #define AD5791_SWCTRL_LDAC BIT(0)
57 #define AD5791_SWCTRL_CLR BIT(1)
58 #define AD5791_SWCTRL_RESET BIT(2)
59
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
68 struct ad5791_chip_info {
69 int (*get_lin_comp) (unsigned int span);
70 };
71
72 /**
73 * struct ad5791_state - driver instance specific data
74 * @spi: spi_device
75 * @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
83 struct 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;
93
94 union {
95 __be32 d32;
96 u8 d8[4];
97 } data[3] ____cacheline_aligned;
98 };
99
100 /**
101 * ad5791_supported_device_ids:
102 */
103
104 enum ad5791_supported_device_ids {
105 ID_AD5760,
106 ID_AD5780,
107 ID_AD5781,
108 ID_AD5791,
109 };
110
ad5791_spi_write(struct ad5791_state * st,u8 addr,u32 val)111 static int ad5791_spi_write(struct ad5791_state *st, u8 addr, u32 val)
112 {
113 st->data[0].d32 = cpu_to_be32(AD5791_CMD_WRITE |
114 AD5791_ADDR(addr) |
115 (val & AD5791_DAC_MASK));
116
117 return spi_write(st->spi, &st->data[0].d8[1], 3);
118 }
119
ad5791_spi_read(struct ad5791_state * st,u8 addr,u32 * val)120 static int ad5791_spi_read(struct ad5791_state *st, u8 addr, u32 *val)
121 {
122 int ret;
123 struct spi_transfer xfers[] = {
124 {
125 .tx_buf = &st->data[0].d8[1],
126 .bits_per_word = 8,
127 .len = 3,
128 .cs_change = 1,
129 }, {
130 .tx_buf = &st->data[1].d8[1],
131 .rx_buf = &st->data[2].d8[1],
132 .bits_per_word = 8,
133 .len = 3,
134 },
135 };
136
137 st->data[0].d32 = cpu_to_be32(AD5791_CMD_READ |
138 AD5791_ADDR(addr));
139 st->data[1].d32 = cpu_to_be32(AD5791_ADDR(AD5791_ADDR_NOOP));
140
141 ret = spi_sync_transfer(st->spi, xfers, ARRAY_SIZE(xfers));
142
143 *val = be32_to_cpu(st->data[2].d32);
144
145 return ret;
146 }
147
148 static const char * const ad5791_powerdown_modes[] = {
149 "6kohm_to_gnd",
150 "three_state",
151 };
152
ad5791_get_powerdown_mode(struct iio_dev * indio_dev,const struct iio_chan_spec * chan)153 static int ad5791_get_powerdown_mode(struct iio_dev *indio_dev,
154 const struct iio_chan_spec *chan)
155 {
156 struct ad5791_state *st = iio_priv(indio_dev);
157
158 return st->pwr_down_mode;
159 }
160
ad5791_set_powerdown_mode(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,unsigned int mode)161 static int ad5791_set_powerdown_mode(struct iio_dev *indio_dev,
162 const struct iio_chan_spec *chan, unsigned int mode)
163 {
164 struct ad5791_state *st = iio_priv(indio_dev);
165
166 st->pwr_down_mode = mode;
167
168 return 0;
169 }
170
171 static 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
ad5791_read_dac_powerdown(struct iio_dev * indio_dev,uintptr_t private,const struct iio_chan_spec * chan,char * buf)178 static ssize_t ad5791_read_dac_powerdown(struct iio_dev *indio_dev,
179 uintptr_t private, const struct iio_chan_spec *chan, char *buf)
180 {
181 struct ad5791_state *st = iio_priv(indio_dev);
182
183 return sprintf(buf, "%d\n", st->pwr_down);
184 }
185
ad5791_write_dac_powerdown(struct iio_dev * indio_dev,uintptr_t private,const struct iio_chan_spec * chan,const char * buf,size_t len)186 static 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)
189 {
190 bool pwr_down;
191 int ret;
192 struct ad5791_state *st = iio_priv(indio_dev);
193
194 ret = strtobool(buf, &pwr_down);
195 if (ret)
196 return ret;
197
198 if (!pwr_down) {
199 st->ctrl &= ~(AD5791_CTRL_OPGND | AD5791_CTRL_DACTRI);
200 } else {
201 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;
205 }
206 st->pwr_down = pwr_down;
207
208 ret = ad5791_spi_write(st, AD5791_ADDR_CTRL, st->ctrl);
209
210 return ret ? ret : len;
211 }
212
ad5791_get_lin_comp(unsigned int span)213 static 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
ad5780_get_lin_comp(unsigned int span)227 static 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 }
234 static const struct ad5791_chip_info ad5791_chip_info_tbl[] = {
235 [ID_AD5760] = {
236 .get_lin_comp = ad5780_get_lin_comp,
237 },
238 [ID_AD5780] = {
239 .get_lin_comp = ad5780_get_lin_comp,
240 },
241 [ID_AD5781] = {
242 .get_lin_comp = ad5791_get_lin_comp,
243 },
244 [ID_AD5791] = {
245 .get_lin_comp = ad5791_get_lin_comp,
246 },
247 };
248
ad5791_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long m)249 static 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);
256 u64 val64;
257 int ret;
258
259 switch (m) {
260 case IIO_CHAN_INFO_RAW:
261 ret = ad5791_spi_read(st, chan->address, val);
262 if (ret)
263 return ret;
264 *val &= AD5791_DAC_MASK;
265 *val >>= chan->scan_type.shift;
266 return IIO_VAL_INT;
267 case IIO_CHAN_INFO_SCALE:
268 *val = st->vref_mv;
269 *val2 = (1 << chan->scan_type.realbits) - 1;
270 return IIO_VAL_FRACTIONAL;
271 case IIO_CHAN_INFO_OFFSET:
272 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;
276 default:
277 return -EINVAL;
278 }
279
280 };
281
282 static const struct iio_chan_spec_ext_info ad5791_ext_info[] = {
283 {
284 .name = "powerdown",
285 .shared = IIO_SHARED_BY_TYPE,
286 .read = ad5791_read_dac_powerdown,
287 .write = ad5791_write_dac_powerdown,
288 },
289 IIO_ENUM("powerdown_mode", IIO_SHARED_BY_TYPE,
290 &ad5791_powerdown_mode_enum),
291 IIO_ENUM_AVAILABLE("powerdown_mode", &ad5791_powerdown_mode_enum),
292 { },
293 };
294
295 #define AD5791_CHAN(bits, _shift) { \
296 .type = IIO_VOLTAGE, \
297 .output = 1, \
298 .indexed = 1, \
299 .address = AD5791_ADDR_DAC0, \
300 .channel = 0, \
301 .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), \
304 .scan_type = { \
305 .sign = 'u', \
306 .realbits = (bits), \
307 .storagebits = 24, \
308 .shift = (_shift), \
309 }, \
310 .ext_info = ad5791_ext_info, \
311 }
312
313 static 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 };
319
ad5791_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)320 static 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) {
329 case IIO_CHAN_INFO_RAW:
330 val &= GENMASK(chan->scan_type.realbits - 1, 0);
331 val <<= chan->scan_type.shift;
332
333 return ad5791_spi_write(st, chan->address, val);
334
335 default:
336 return -EINVAL;
337 }
338 }
339
340 static const struct iio_info ad5791_info = {
341 .read_raw = &ad5791_read_raw,
342 .write_raw = &ad5791_write_raw,
343 };
344
ad5791_probe(struct spi_device * spi)345 static int ad5791_probe(struct spi_device *spi)
346 {
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;
351
352 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
353 if (!indio_dev)
354 return -ENOMEM;
355 st = iio_priv(indio_dev);
356 st->reg_vdd = devm_regulator_get(&spi->dev, "vdd");
357 if (!IS_ERR(st->reg_vdd)) {
358 ret = regulator_enable(st->reg_vdd);
359 if (ret)
360 return ret;
361
362 ret = regulator_get_voltage(st->reg_vdd);
363 if (ret < 0)
364 goto error_disable_reg_pos;
365
366 pos_voltage_uv = ret;
367 }
368
369 st->reg_vss = devm_regulator_get(&spi->dev, "vss");
370 if (!IS_ERR(st->reg_vss)) {
371 ret = regulator_enable(st->reg_vss);
372 if (ret)
373 goto error_disable_reg_pos;
374
375 ret = regulator_get_voltage(st->reg_vss);
376 if (ret < 0)
377 goto error_disable_reg_neg;
378
379 neg_voltage_uv = ret;
380 }
381
382 st->pwr_down = true;
383 st->spi = spi;
384
385 if (!IS_ERR(st->reg_vss) && !IS_ERR(st->reg_vdd)) {
386 st->vref_mv = (pos_voltage_uv + neg_voltage_uv) / 1000;
387 st->vref_neg_mv = neg_voltage_uv / 1000;
388 } else if (pdata) {
389 st->vref_mv = pdata->vref_pos_mv + pdata->vref_neg_mv;
390 st->vref_neg_mv = pdata->vref_neg_mv;
391 } else {
392 dev_warn(&spi->dev, "reference voltage unspecified\n");
393 }
394
395 ret = ad5791_spi_write(st, AD5791_ADDR_SW_CTRL, AD5791_SWCTRL_RESET);
396 if (ret)
397 goto error_disable_reg_neg;
398
399 st->chip_info = &ad5791_chip_info_tbl[spi_get_device_id(spi)
400 ->driver_data];
401
402
403 st->ctrl = AD5761_CTRL_LINCOMP(st->chip_info->get_lin_comp(st->vref_mv))
404 | ((pdata && pdata->use_rbuf_gain2) ? 0 : AD5791_CTRL_RBUF) |
405 AD5791_CTRL_BIN2SC;
406
407 ret = ad5791_spi_write(st, AD5791_ADDR_CTRL, st->ctrl |
408 AD5791_CTRL_OPGND | AD5791_CTRL_DACTRI);
409 if (ret)
410 goto error_disable_reg_neg;
411
412 spi_set_drvdata(spi, indio_dev);
413 indio_dev->dev.parent = &spi->dev;
414 indio_dev->info = &ad5791_info;
415 indio_dev->modes = INDIO_DIRECT_MODE;
416 indio_dev->channels
417 = &ad5791_channels[spi_get_device_id(spi)->driver_data];
418 indio_dev->num_channels = 1;
419 indio_dev->name = spi_get_device_id(st->spi)->name;
420 ret = iio_device_register(indio_dev);
421 if (ret)
422 goto error_disable_reg_neg;
423
424 return 0;
425
426 error_disable_reg_neg:
427 if (!IS_ERR(st->reg_vss))
428 regulator_disable(st->reg_vss);
429 error_disable_reg_pos:
430 if (!IS_ERR(st->reg_vdd))
431 regulator_disable(st->reg_vdd);
432 return ret;
433 }
434
ad5791_remove(struct spi_device * spi)435 static int ad5791_remove(struct spi_device *spi)
436 {
437 struct iio_dev *indio_dev = spi_get_drvdata(spi);
438 struct ad5791_state *st = iio_priv(indio_dev);
439
440 iio_device_unregister(indio_dev);
441 if (!IS_ERR(st->reg_vdd))
442 regulator_disable(st->reg_vdd);
443
444 if (!IS_ERR(st->reg_vss))
445 regulator_disable(st->reg_vss);
446
447 return 0;
448 }
449
450 static const struct spi_device_id ad5791_id[] = {
451 {"ad5760", ID_AD5760},
452 {"ad5780", ID_AD5780},
453 {"ad5781", ID_AD5781},
454 {"ad5790", ID_AD5791},
455 {"ad5791", ID_AD5791},
456 {}
457 };
458 MODULE_DEVICE_TABLE(spi, ad5791_id);
459
460 static struct spi_driver ad5791_driver = {
461 .driver = {
462 .name = "ad5791",
463 },
464 .probe = ad5791_probe,
465 .remove = ad5791_remove,
466 .id_table = ad5791_id,
467 };
468 module_spi_driver(ad5791_driver);
469
470 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
471 MODULE_DESCRIPTION("Analog Devices AD5760/AD5780/AD5781/AD5790/AD5791 DAC");
472 MODULE_LICENSE("GPL v2");
473