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>
27 static int ad5446_write(struct ad5446_state *st, unsigned val)
29 __be16 data = cpu_to_be16(val);
30 return spi_write(st->spi, &data, sizeof(data));
33 static int ad5660_write(struct ad5446_state *st, unsigned val)
37 data[0] = (val >> 16) & 0xFF;
38 data[1] = (val >> 8) & 0xFF;
41 return spi_write(st->spi, data, sizeof(data));
44 static const char * const ad5446_powerdown_modes[] = {
45 "", "1kohm_to_gnd", "100kohm_to_gnd", "three_state"
48 static ssize_t ad5446_read_powerdown_mode_available(struct iio_dev *indio_dev,
49 const struct iio_chan_spec *chan, char *buf)
51 return sprintf(buf, "%s %s %s\n", ad5446_powerdown_modes[1],
52 ad5446_powerdown_modes[2], ad5446_powerdown_modes[3]);
55 static ssize_t ad5446_write_powerdown_mode(struct iio_dev *indio_dev,
56 const struct iio_chan_spec *chan,
57 const char *buf, size_t len)
59 struct ad5446_state *st = iio_priv(indio_dev);
62 for (i = 1; i < ARRAY_SIZE(ad5446_powerdown_modes); i++) {
63 if (sysfs_streq(buf, ad5446_powerdown_modes[i])) {
64 st->pwr_down_mode = i;
69 if (i == ARRAY_SIZE(ad5446_powerdown_modes))
75 static ssize_t ad5446_read_powerdown_mode(struct iio_dev *indio_dev,
76 const struct iio_chan_spec *chan,
79 struct ad5446_state *st = iio_priv(indio_dev);
81 return sprintf(buf, "%s\n", ad5446_powerdown_modes[st->pwr_down_mode]);
84 static ssize_t ad5446_read_dac_powerdown(struct iio_dev *indio_dev,
85 const struct iio_chan_spec *chan,
88 struct ad5446_state *st = iio_priv(indio_dev);
90 return sprintf(buf, "%d\n", st->pwr_down);
93 static ssize_t ad5446_write_dac_powerdown(struct iio_dev *indio_dev,
94 const struct iio_chan_spec *chan,
95 const char *buf, size_t len)
97 struct ad5446_state *st = iio_priv(indio_dev);
103 ret = strtobool(buf, &powerdown);
107 mutex_lock(&indio_dev->mlock);
108 st->pwr_down = powerdown;
111 shift = chan->scan_type.realbits + chan->scan_type.shift;
112 val = st->pwr_down_mode << shift;
114 val = st->cached_val;
117 ret = st->chip_info->write(st, val);
118 mutex_unlock(&indio_dev->mlock);
120 return ret ? ret : len;
123 static const struct iio_chan_spec_ext_info ad5064_ext_info_powerdown[] = {
126 .read = ad5446_read_dac_powerdown,
127 .write = ad5446_write_dac_powerdown,
129 .name = "powerdown_mode",
130 .read = ad5446_read_powerdown_mode,
131 .write = ad5446_write_powerdown_mode,
133 .name = "powerdown_mode_available",
135 .read = ad5446_read_powerdown_mode_available,
140 #define _AD5446_CHANNEL(bits, storage, shift, ext) { \
141 .type = IIO_VOLTAGE, \
145 .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
146 IIO_CHAN_INFO_SCALE_SHARED_BIT, \
147 .scan_type = IIO_ST('u', (bits), (storage), (shift)), \
151 #define AD5446_CHANNEL(bits, storage, shift) \
152 _AD5446_CHANNEL(bits, storage, shift, NULL)
154 #define AD5446_CHANNEL_POWERDOWN(bits, storage, shift) \
155 _AD5446_CHANNEL(bits, storage, shift, ad5064_ext_info_powerdown)
157 static const struct ad5446_chip_info ad5446_chip_info_tbl[] = {
159 .channel = AD5446_CHANNEL(12, 16, 2),
160 .write = ad5446_write,
163 .channel = AD5446_CHANNEL(14, 16, 0),
164 .write = ad5446_write,
167 .channel = AD5446_CHANNEL(16, 16, 0),
168 .write = ad5446_write,
171 .channel = AD5446_CHANNEL(12, 16, 4),
172 .write = ad5446_write,
175 .channel = AD5446_CHANNEL(14, 16, 0),
176 .write = ad5446_write,
179 .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 6),
180 .write = ad5446_write,
183 .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 4),
184 .write = ad5446_write,
187 .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
188 .write = ad5446_write,
191 .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
193 .write = ad5446_write,
196 .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
198 .write = ad5446_write,
201 .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
203 .write = ad5446_write,
206 .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
208 .write = ad5446_write,
211 .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
213 .write = ad5660_write,
216 .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
218 .write = ad5660_write,
221 .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
222 .write = ad5660_write,
226 static int ad5446_read_raw(struct iio_dev *indio_dev,
227 struct iio_chan_spec const *chan,
232 struct ad5446_state *st = iio_priv(indio_dev);
233 unsigned long scale_uv;
236 case IIO_CHAN_INFO_RAW:
237 *val = st->cached_val;
239 case IIO_CHAN_INFO_SCALE:
240 scale_uv = (st->vref_mv * 1000) >> chan->scan_type.realbits;
241 *val = scale_uv / 1000;
242 *val2 = (scale_uv % 1000) * 1000;
243 return IIO_VAL_INT_PLUS_MICRO;
249 static int ad5446_write_raw(struct iio_dev *indio_dev,
250 struct iio_chan_spec const *chan,
255 struct ad5446_state *st = iio_priv(indio_dev);
259 case IIO_CHAN_INFO_RAW:
260 if (val >= (1 << chan->scan_type.realbits) || val < 0)
263 val <<= chan->scan_type.shift;
264 mutex_lock(&indio_dev->mlock);
265 st->cached_val = val;
267 ret = st->chip_info->write(st, val);
268 mutex_unlock(&indio_dev->mlock);
277 static const struct iio_info ad5446_info = {
278 .read_raw = ad5446_read_raw,
279 .write_raw = ad5446_write_raw,
280 .driver_module = THIS_MODULE,
283 static int __devinit ad5446_probe(struct spi_device *spi)
285 struct ad5446_state *st;
286 struct iio_dev *indio_dev;
287 struct regulator *reg;
288 int ret, voltage_uv = 0;
290 reg = regulator_get(&spi->dev, "vcc");
292 ret = regulator_enable(reg);
296 voltage_uv = regulator_get_voltage(reg);
299 indio_dev = iio_allocate_device(sizeof(*st));
300 if (indio_dev == NULL) {
302 goto error_disable_reg;
304 st = iio_priv(indio_dev);
306 &ad5446_chip_info_tbl[spi_get_device_id(spi)->driver_data];
308 spi_set_drvdata(spi, indio_dev);
312 /* Establish that the iio_dev is a child of the spi device */
313 indio_dev->dev.parent = &spi->dev;
314 indio_dev->name = spi_get_device_id(spi)->name;
315 indio_dev->info = &ad5446_info;
316 indio_dev->modes = INDIO_DIRECT_MODE;
317 indio_dev->channels = &st->chip_info->channel;
318 indio_dev->num_channels = 1;
320 if (st->chip_info->int_vref_mv)
321 st->vref_mv = st->chip_info->int_vref_mv;
323 st->vref_mv = voltage_uv / 1000;
325 dev_warn(&spi->dev, "reference voltage unspecified\n");
327 ret = iio_device_register(indio_dev);
329 goto error_free_device;
334 iio_free_device(indio_dev);
337 regulator_disable(reg);
345 static int ad5446_remove(struct spi_device *spi)
347 struct iio_dev *indio_dev = spi_get_drvdata(spi);
348 struct ad5446_state *st = iio_priv(indio_dev);
350 iio_device_unregister(indio_dev);
351 if (!IS_ERR(st->reg)) {
352 regulator_disable(st->reg);
353 regulator_put(st->reg);
355 iio_free_device(indio_dev);
360 static const struct spi_device_id ad5446_id[] = {
361 {"ad5444", ID_AD5444},
362 {"ad5446", ID_AD5446},
363 {"ad5512a", ID_AD5512A},
364 {"ad5541a", ID_AD5541A},
365 {"ad5542a", ID_AD5541A}, /* ad5541a and ad5542a are compatible */
366 {"ad5543", ID_AD5541A}, /* ad5541a and ad5543 are compatible */
367 {"ad5553", ID_AD5553},
368 {"ad5601", ID_AD5601},
369 {"ad5611", ID_AD5611},
370 {"ad5621", ID_AD5621},
371 {"ad5620-2500", ID_AD5620_2500}, /* AD5620/40/60: */
372 {"ad5620-1250", ID_AD5620_1250}, /* part numbers may look differently */
373 {"ad5640-2500", ID_AD5640_2500},
374 {"ad5640-1250", ID_AD5640_1250},
375 {"ad5660-2500", ID_AD5660_2500},
376 {"ad5660-1250", ID_AD5660_1250},
377 {"ad5662", ID_AD5662},
380 MODULE_DEVICE_TABLE(spi, ad5446_id);
382 static struct spi_driver ad5446_driver = {
385 .owner = THIS_MODULE,
387 .probe = ad5446_probe,
388 .remove = __devexit_p(ad5446_remove),
389 .id_table = ad5446_id,
391 module_spi_driver(ad5446_driver);
393 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
394 MODULE_DESCRIPTION("Analog Devices AD5444/AD5446 DAC");
395 MODULE_LICENSE("GPL v2");