2 * AD5446 SPI DAC driver
4 * Copyright 2010 Analog Devices Inc.
6 * Licensed under the GPL-2 or later.
9 #include <linux/interrupt.h>
10 #include <linux/workqueue.h>
11 #include <linux/device.h>
12 #include <linux/kernel.h>
13 #include <linux/slab.h>
14 #include <linux/sysfs.h>
15 #include <linux/list.h>
16 #include <linux/spi/spi.h>
17 #include <linux/regulator/consumer.h>
18 #include <linux/err.h>
19 #include <linux/module.h>
21 #include <linux/iio/iio.h>
22 #include <linux/iio/sysfs.h>
26 static int ad5446_write(struct ad5446_state *st, unsigned val)
28 __be16 data = cpu_to_be16(val);
29 return spi_write(st->spi, &data, sizeof(data));
32 static int ad5660_write(struct ad5446_state *st, unsigned val)
36 data[0] = (val >> 16) & 0xFF;
37 data[1] = (val >> 8) & 0xFF;
40 return spi_write(st->spi, data, sizeof(data));
43 static const char * const ad5446_powerdown_modes[] = {
44 "1kohm_to_gnd", "100kohm_to_gnd", "three_state"
47 static int ad5446_set_powerdown_mode(struct iio_dev *indio_dev,
48 const struct iio_chan_spec *chan, unsigned int mode)
50 struct ad5446_state *st = iio_priv(indio_dev);
52 st->pwr_down_mode = mode + 1;
57 static int ad5446_get_powerdown_mode(struct iio_dev *indio_dev,
58 const struct iio_chan_spec *chan)
60 struct ad5446_state *st = iio_priv(indio_dev);
62 return st->pwr_down_mode - 1;
65 static const struct iio_enum ad5446_powerdown_mode_enum = {
66 .items = ad5446_powerdown_modes,
67 .num_items = ARRAY_SIZE(ad5446_powerdown_modes),
68 .get = ad5446_get_powerdown_mode,
69 .set = ad5446_set_powerdown_mode,
72 static ssize_t ad5446_read_dac_powerdown(struct iio_dev *indio_dev,
74 const struct iio_chan_spec *chan,
77 struct ad5446_state *st = iio_priv(indio_dev);
79 return sprintf(buf, "%d\n", st->pwr_down);
82 static ssize_t ad5446_write_dac_powerdown(struct iio_dev *indio_dev,
84 const struct iio_chan_spec *chan,
85 const char *buf, size_t len)
87 struct ad5446_state *st = iio_priv(indio_dev);
93 ret = strtobool(buf, &powerdown);
97 mutex_lock(&indio_dev->mlock);
98 st->pwr_down = powerdown;
101 shift = chan->scan_type.realbits + chan->scan_type.shift;
102 val = st->pwr_down_mode << shift;
104 val = st->cached_val;
107 ret = st->chip_info->write(st, val);
108 mutex_unlock(&indio_dev->mlock);
110 return ret ? ret : len;
113 static const struct iio_chan_spec_ext_info ad5064_ext_info_powerdown[] = {
116 .read = ad5446_read_dac_powerdown,
117 .write = ad5446_write_dac_powerdown,
119 IIO_ENUM("powerdown_mode", false, &ad5446_powerdown_mode_enum),
120 IIO_ENUM_AVAILABLE("powerdown_mode", &ad5446_powerdown_mode_enum),
124 #define _AD5446_CHANNEL(bits, storage, shift, ext) { \
125 .type = IIO_VOLTAGE, \
129 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
130 IIO_CHAN_INFO_SCALE_SHARED_BIT, \
131 .scan_type = IIO_ST('u', (bits), (storage), (shift)), \
135 #define AD5446_CHANNEL(bits, storage, shift) \
136 _AD5446_CHANNEL(bits, storage, shift, NULL)
138 #define AD5446_CHANNEL_POWERDOWN(bits, storage, shift) \
139 _AD5446_CHANNEL(bits, storage, shift, ad5064_ext_info_powerdown)
141 static const struct ad5446_chip_info ad5446_chip_info_tbl[] = {
143 .channel = AD5446_CHANNEL(12, 16, 2),
144 .write = ad5446_write,
147 .channel = AD5446_CHANNEL(14, 16, 0),
148 .write = ad5446_write,
151 .channel = AD5446_CHANNEL(8, 16, 6),
152 .write = ad5446_write,
155 .channel = AD5446_CHANNEL(10, 16, 4),
156 .write = ad5446_write,
159 .channel = AD5446_CHANNEL(16, 16, 0),
160 .write = ad5446_write,
163 .channel = AD5446_CHANNEL(12, 16, 4),
164 .write = ad5446_write,
167 .channel = AD5446_CHANNEL(14, 16, 0),
168 .write = ad5446_write,
171 .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 6),
172 .write = ad5446_write,
175 .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 4),
176 .write = ad5446_write,
179 .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
180 .write = ad5446_write,
183 .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
185 .write = ad5446_write,
188 .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
190 .write = ad5446_write,
193 .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
195 .write = ad5446_write,
198 .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
200 .write = ad5446_write,
203 .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
205 .write = ad5660_write,
208 .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
210 .write = ad5660_write,
213 .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
214 .write = ad5660_write,
218 static int ad5446_read_raw(struct iio_dev *indio_dev,
219 struct iio_chan_spec const *chan,
224 struct ad5446_state *st = iio_priv(indio_dev);
225 unsigned long scale_uv;
228 case IIO_CHAN_INFO_RAW:
229 *val = st->cached_val;
231 case IIO_CHAN_INFO_SCALE:
232 scale_uv = (st->vref_mv * 1000) >> chan->scan_type.realbits;
233 *val = scale_uv / 1000;
234 *val2 = (scale_uv % 1000) * 1000;
235 return IIO_VAL_INT_PLUS_MICRO;
241 static int ad5446_write_raw(struct iio_dev *indio_dev,
242 struct iio_chan_spec const *chan,
247 struct ad5446_state *st = iio_priv(indio_dev);
251 case IIO_CHAN_INFO_RAW:
252 if (val >= (1 << chan->scan_type.realbits) || val < 0)
255 val <<= chan->scan_type.shift;
256 mutex_lock(&indio_dev->mlock);
257 st->cached_val = val;
259 ret = st->chip_info->write(st, val);
260 mutex_unlock(&indio_dev->mlock);
269 static const struct iio_info ad5446_info = {
270 .read_raw = ad5446_read_raw,
271 .write_raw = ad5446_write_raw,
272 .driver_module = THIS_MODULE,
275 static int __devinit ad5446_probe(struct spi_device *spi)
277 struct ad5446_state *st;
278 struct iio_dev *indio_dev;
279 struct regulator *reg;
280 int ret, voltage_uv = 0;
282 reg = regulator_get(&spi->dev, "vcc");
284 ret = regulator_enable(reg);
288 voltage_uv = regulator_get_voltage(reg);
291 indio_dev = iio_device_alloc(sizeof(*st));
292 if (indio_dev == NULL) {
294 goto error_disable_reg;
296 st = iio_priv(indio_dev);
298 &ad5446_chip_info_tbl[spi_get_device_id(spi)->driver_data];
300 spi_set_drvdata(spi, indio_dev);
304 /* Establish that the iio_dev is a child of the spi device */
305 indio_dev->dev.parent = &spi->dev;
306 indio_dev->name = spi_get_device_id(spi)->name;
307 indio_dev->info = &ad5446_info;
308 indio_dev->modes = INDIO_DIRECT_MODE;
309 indio_dev->channels = &st->chip_info->channel;
310 indio_dev->num_channels = 1;
312 st->pwr_down_mode = MODE_PWRDWN_1k;
314 if (st->chip_info->int_vref_mv)
315 st->vref_mv = st->chip_info->int_vref_mv;
317 st->vref_mv = voltage_uv / 1000;
319 dev_warn(&spi->dev, "reference voltage unspecified\n");
321 ret = iio_device_register(indio_dev);
323 goto error_free_device;
328 iio_device_free(indio_dev);
331 regulator_disable(reg);
339 static int ad5446_remove(struct spi_device *spi)
341 struct iio_dev *indio_dev = spi_get_drvdata(spi);
342 struct ad5446_state *st = iio_priv(indio_dev);
344 iio_device_unregister(indio_dev);
345 if (!IS_ERR(st->reg)) {
346 regulator_disable(st->reg);
347 regulator_put(st->reg);
349 iio_device_free(indio_dev);
354 static const struct spi_device_id ad5446_id[] = {
355 {"ad5444", ID_AD5444},
356 {"ad5446", ID_AD5446},
357 {"ad5450", ID_AD5450},
358 {"ad5451", ID_AD5451},
359 {"ad5452", ID_AD5444}, /* ad5452 is compatible to the ad5444 */
360 {"ad5453", ID_AD5446}, /* ad5453 is compatible to the ad5446 */
361 {"ad5512a", ID_AD5512A},
362 {"ad5541a", ID_AD5541A},
363 {"ad5542a", ID_AD5541A}, /* ad5541a and ad5542a are compatible */
364 {"ad5543", ID_AD5541A}, /* ad5541a and ad5543 are compatible */
365 {"ad5553", ID_AD5553},
366 {"ad5601", ID_AD5601},
367 {"ad5611", ID_AD5611},
368 {"ad5621", ID_AD5621},
369 {"ad5620-2500", ID_AD5620_2500}, /* AD5620/40/60: */
370 {"ad5620-1250", ID_AD5620_1250}, /* part numbers may look differently */
371 {"ad5640-2500", ID_AD5640_2500},
372 {"ad5640-1250", ID_AD5640_1250},
373 {"ad5660-2500", ID_AD5660_2500},
374 {"ad5660-1250", ID_AD5660_1250},
375 {"ad5662", ID_AD5662},
378 MODULE_DEVICE_TABLE(spi, ad5446_id);
380 static struct spi_driver ad5446_driver = {
383 .owner = THIS_MODULE,
385 .probe = ad5446_probe,
386 .remove = __devexit_p(ad5446_remove),
387 .id_table = ad5446_id,
389 module_spi_driver(ad5446_driver);
391 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
392 MODULE_DESCRIPTION("Analog Devices AD5444/AD5446 DAC");
393 MODULE_LICENSE("GPL v2");