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/i2c.h>
18 #include <linux/regulator/consumer.h>
19 #include <linux/err.h>
20 #include <linux/module.h>
22 #include <linux/iio/iio.h>
23 #include <linux/iio/sysfs.h>
25 #define MODE_PWRDWN_1k 0x1
26 #define MODE_PWRDWN_100k 0x2
27 #define MODE_PWRDWN_TRISTATE 0x3
30 * struct ad5446_state - driver instance specific data
32 * @chip_info: chip model specific constants, available modes etc
33 * @reg: supply regulator
34 * @vref_mv: actual reference voltage used
39 const struct ad5446_chip_info *chip_info;
40 struct regulator *reg;
41 unsigned short vref_mv;
43 unsigned pwr_down_mode;
48 * struct ad5446_chip_info - chip specific information
49 * @channel: channel spec for the DAC
50 * @int_vref_mv: AD5620/40/60: the internal reference voltage
51 * @write: chip specific helper function to write to the register
54 struct ad5446_chip_info {
55 struct iio_chan_spec channel;
57 int (*write)(struct ad5446_state *st, unsigned val);
60 static const char * const ad5446_powerdown_modes[] = {
61 "1kohm_to_gnd", "100kohm_to_gnd", "three_state"
64 static int ad5446_set_powerdown_mode(struct iio_dev *indio_dev,
65 const struct iio_chan_spec *chan, unsigned int mode)
67 struct ad5446_state *st = iio_priv(indio_dev);
69 st->pwr_down_mode = mode + 1;
74 static int ad5446_get_powerdown_mode(struct iio_dev *indio_dev,
75 const struct iio_chan_spec *chan)
77 struct ad5446_state *st = iio_priv(indio_dev);
79 return st->pwr_down_mode - 1;
82 static const struct iio_enum ad5446_powerdown_mode_enum = {
83 .items = ad5446_powerdown_modes,
84 .num_items = ARRAY_SIZE(ad5446_powerdown_modes),
85 .get = ad5446_get_powerdown_mode,
86 .set = ad5446_set_powerdown_mode,
89 static ssize_t ad5446_read_dac_powerdown(struct iio_dev *indio_dev,
91 const struct iio_chan_spec *chan,
94 struct ad5446_state *st = iio_priv(indio_dev);
96 return sprintf(buf, "%d\n", st->pwr_down);
99 static ssize_t ad5446_write_dac_powerdown(struct iio_dev *indio_dev,
101 const struct iio_chan_spec *chan,
102 const char *buf, size_t len)
104 struct ad5446_state *st = iio_priv(indio_dev);
110 ret = strtobool(buf, &powerdown);
114 mutex_lock(&indio_dev->mlock);
115 st->pwr_down = powerdown;
118 shift = chan->scan_type.realbits + chan->scan_type.shift;
119 val = st->pwr_down_mode << shift;
121 val = st->cached_val;
124 ret = st->chip_info->write(st, val);
125 mutex_unlock(&indio_dev->mlock);
127 return ret ? ret : len;
130 static const struct iio_chan_spec_ext_info ad5446_ext_info_powerdown[] = {
133 .read = ad5446_read_dac_powerdown,
134 .write = ad5446_write_dac_powerdown,
135 .shared = IIO_SEPARATE,
137 IIO_ENUM("powerdown_mode", IIO_SEPARATE, &ad5446_powerdown_mode_enum),
138 IIO_ENUM_AVAILABLE("powerdown_mode", &ad5446_powerdown_mode_enum),
142 #define _AD5446_CHANNEL(bits, storage, shift, ext) { \
143 .type = IIO_VOLTAGE, \
147 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
148 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
149 .scan_type = IIO_ST('u', (bits), (storage), (shift)), \
153 #define AD5446_CHANNEL(bits, storage, shift) \
154 _AD5446_CHANNEL(bits, storage, shift, NULL)
156 #define AD5446_CHANNEL_POWERDOWN(bits, storage, shift) \
157 _AD5446_CHANNEL(bits, storage, shift, ad5446_ext_info_powerdown)
159 static int ad5446_read_raw(struct iio_dev *indio_dev,
160 struct iio_chan_spec const *chan,
165 struct ad5446_state *st = iio_priv(indio_dev);
168 case IIO_CHAN_INFO_RAW:
169 *val = st->cached_val;
171 case IIO_CHAN_INFO_SCALE:
173 *val2 = chan->scan_type.realbits;
174 return IIO_VAL_FRACTIONAL_LOG2;
179 static int ad5446_write_raw(struct iio_dev *indio_dev,
180 struct iio_chan_spec const *chan,
185 struct ad5446_state *st = iio_priv(indio_dev);
189 case IIO_CHAN_INFO_RAW:
190 if (val >= (1 << chan->scan_type.realbits) || val < 0)
193 val <<= chan->scan_type.shift;
194 mutex_lock(&indio_dev->mlock);
195 st->cached_val = val;
197 ret = st->chip_info->write(st, val);
198 mutex_unlock(&indio_dev->mlock);
207 static const struct iio_info ad5446_info = {
208 .read_raw = ad5446_read_raw,
209 .write_raw = ad5446_write_raw,
210 .driver_module = THIS_MODULE,
213 static int ad5446_probe(struct device *dev, const char *name,
214 const struct ad5446_chip_info *chip_info)
216 struct ad5446_state *st;
217 struct iio_dev *indio_dev;
218 struct regulator *reg;
219 int ret, voltage_uv = 0;
221 reg = devm_regulator_get(dev, "vcc");
223 ret = regulator_enable(reg);
227 ret = regulator_get_voltage(reg);
229 goto error_disable_reg;
234 indio_dev = devm_iio_device_alloc(dev, sizeof(*st));
235 if (indio_dev == NULL) {
237 goto error_disable_reg;
239 st = iio_priv(indio_dev);
240 st->chip_info = chip_info;
242 dev_set_drvdata(dev, indio_dev);
246 /* Establish that the iio_dev is a child of the device */
247 indio_dev->dev.parent = dev;
248 indio_dev->name = name;
249 indio_dev->info = &ad5446_info;
250 indio_dev->modes = INDIO_DIRECT_MODE;
251 indio_dev->channels = &st->chip_info->channel;
252 indio_dev->num_channels = 1;
254 st->pwr_down_mode = MODE_PWRDWN_1k;
256 if (st->chip_info->int_vref_mv)
257 st->vref_mv = st->chip_info->int_vref_mv;
259 st->vref_mv = voltage_uv / 1000;
261 dev_warn(dev, "reference voltage unspecified\n");
263 ret = iio_device_register(indio_dev);
265 goto error_disable_reg;
271 regulator_disable(reg);
275 static int ad5446_remove(struct device *dev)
277 struct iio_dev *indio_dev = dev_get_drvdata(dev);
278 struct ad5446_state *st = iio_priv(indio_dev);
280 iio_device_unregister(indio_dev);
281 if (!IS_ERR(st->reg))
282 regulator_disable(st->reg);
287 #if IS_ENABLED(CONFIG_SPI_MASTER)
289 static int ad5446_write(struct ad5446_state *st, unsigned val)
291 struct spi_device *spi = to_spi_device(st->dev);
292 __be16 data = cpu_to_be16(val);
294 return spi_write(spi, &data, sizeof(data));
297 static int ad5660_write(struct ad5446_state *st, unsigned val)
299 struct spi_device *spi = to_spi_device(st->dev);
302 data[0] = (val >> 16) & 0xFF;
303 data[1] = (val >> 8) & 0xFF;
304 data[2] = val & 0xFF;
306 return spi_write(spi, data, sizeof(data));
310 * ad5446_supported_spi_device_ids:
311 * The AD5620/40/60 parts are available in different fixed internal reference
312 * voltage options. The actual part numbers may look differently
313 * (and a bit cryptic), however this style is used to make clear which
314 * parts are supported here.
316 enum ad5446_supported_spi_device_ids {
340 static const struct ad5446_chip_info ad5446_spi_chip_info[] = {
342 .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 4),
343 .write = ad5446_write,
346 .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 2),
347 .write = ad5446_write,
350 .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 0),
351 .write = ad5446_write,
354 .channel = AD5446_CHANNEL(12, 16, 2),
355 .write = ad5446_write,
358 .channel = AD5446_CHANNEL(14, 16, 0),
359 .write = ad5446_write,
362 .channel = AD5446_CHANNEL(8, 16, 6),
363 .write = ad5446_write,
366 .channel = AD5446_CHANNEL(10, 16, 4),
367 .write = ad5446_write,
370 .channel = AD5446_CHANNEL(16, 16, 0),
371 .write = ad5446_write,
374 .channel = AD5446_CHANNEL(12, 16, 4),
375 .write = ad5446_write,
378 .channel = AD5446_CHANNEL(14, 16, 0),
379 .write = ad5446_write,
382 .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 6),
383 .write = ad5446_write,
386 .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 4),
387 .write = ad5446_write,
390 .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
391 .write = ad5446_write,
394 .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
395 .write = ad5446_write,
398 .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
400 .write = ad5446_write,
403 .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
405 .write = ad5446_write,
408 .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
410 .write = ad5446_write,
413 .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
415 .write = ad5446_write,
418 .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
420 .write = ad5660_write,
423 .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
425 .write = ad5660_write,
428 .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
429 .write = ad5660_write,
433 static const struct spi_device_id ad5446_spi_ids[] = {
434 {"ad5300", ID_AD5300},
435 {"ad5310", ID_AD5310},
436 {"ad5320", ID_AD5320},
437 {"ad5444", ID_AD5444},
438 {"ad5446", ID_AD5446},
439 {"ad5450", ID_AD5450},
440 {"ad5451", ID_AD5451},
441 {"ad5452", ID_AD5444}, /* ad5452 is compatible to the ad5444 */
442 {"ad5453", ID_AD5446}, /* ad5453 is compatible to the ad5446 */
443 {"ad5512a", ID_AD5512A},
444 {"ad5541a", ID_AD5541A},
445 {"ad5542a", ID_AD5541A}, /* ad5541a and ad5542a are compatible */
446 {"ad5543", ID_AD5541A}, /* ad5541a and ad5543 are compatible */
447 {"ad5553", ID_AD5553},
448 {"ad5601", ID_AD5601},
449 {"ad5611", ID_AD5611},
450 {"ad5621", ID_AD5621},
451 {"ad5641", ID_AD5641},
452 {"ad5620-2500", ID_AD5620_2500}, /* AD5620/40/60: */
453 {"ad5620-1250", ID_AD5620_1250}, /* part numbers may look differently */
454 {"ad5640-2500", ID_AD5640_2500},
455 {"ad5640-1250", ID_AD5640_1250},
456 {"ad5660-2500", ID_AD5660_2500},
457 {"ad5660-1250", ID_AD5660_1250},
458 {"ad5662", ID_AD5662},
461 MODULE_DEVICE_TABLE(spi, ad5446_spi_ids);
463 static int ad5446_spi_probe(struct spi_device *spi)
465 const struct spi_device_id *id = spi_get_device_id(spi);
467 return ad5446_probe(&spi->dev, id->name,
468 &ad5446_spi_chip_info[id->driver_data]);
471 static int ad5446_spi_remove(struct spi_device *spi)
473 return ad5446_remove(&spi->dev);
476 static struct spi_driver ad5446_spi_driver = {
479 .owner = THIS_MODULE,
481 .probe = ad5446_spi_probe,
482 .remove = ad5446_spi_remove,
483 .id_table = ad5446_spi_ids,
486 static int __init ad5446_spi_register_driver(void)
488 return spi_register_driver(&ad5446_spi_driver);
491 static void ad5446_spi_unregister_driver(void)
493 spi_unregister_driver(&ad5446_spi_driver);
498 static inline int ad5446_spi_register_driver(void) { return 0; }
499 static inline void ad5446_spi_unregister_driver(void) { }
503 #if IS_ENABLED(CONFIG_I2C)
505 static int ad5622_write(struct ad5446_state *st, unsigned val)
507 struct i2c_client *client = to_i2c_client(st->dev);
508 __be16 data = cpu_to_be16(val);
510 return i2c_master_send(client, (char *)&data, sizeof(data));
514 * ad5446_supported_i2c_device_ids:
515 * The AD5620/40/60 parts are available in different fixed internal reference
516 * voltage options. The actual part numbers may look differently
517 * (and a bit cryptic), however this style is used to make clear which
518 * parts are supported here.
520 enum ad5446_supported_i2c_device_ids {
526 static const struct ad5446_chip_info ad5446_i2c_chip_info[] = {
528 .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 4),
529 .write = ad5622_write,
532 .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 2),
533 .write = ad5622_write,
536 .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 0),
537 .write = ad5622_write,
541 static int ad5446_i2c_probe(struct i2c_client *i2c,
542 const struct i2c_device_id *id)
544 return ad5446_probe(&i2c->dev, id->name,
545 &ad5446_i2c_chip_info[id->driver_data]);
548 static int ad5446_i2c_remove(struct i2c_client *i2c)
550 return ad5446_remove(&i2c->dev);
553 static const struct i2c_device_id ad5446_i2c_ids[] = {
554 {"ad5301", ID_AD5602},
555 {"ad5311", ID_AD5612},
556 {"ad5321", ID_AD5622},
557 {"ad5602", ID_AD5602},
558 {"ad5612", ID_AD5612},
559 {"ad5622", ID_AD5622},
562 MODULE_DEVICE_TABLE(i2c, ad5446_i2c_ids);
564 static struct i2c_driver ad5446_i2c_driver = {
567 .owner = THIS_MODULE,
569 .probe = ad5446_i2c_probe,
570 .remove = ad5446_i2c_remove,
571 .id_table = ad5446_i2c_ids,
574 static int __init ad5446_i2c_register_driver(void)
576 return i2c_add_driver(&ad5446_i2c_driver);
579 static void __exit ad5446_i2c_unregister_driver(void)
581 i2c_del_driver(&ad5446_i2c_driver);
586 static inline int ad5446_i2c_register_driver(void) { return 0; }
587 static inline void ad5446_i2c_unregister_driver(void) { }
591 static int __init ad5446_init(void)
595 ret = ad5446_spi_register_driver();
599 ret = ad5446_i2c_register_driver();
601 ad5446_spi_unregister_driver();
607 module_init(ad5446_init);
609 static void __exit ad5446_exit(void)
611 ad5446_i2c_unregister_driver();
612 ad5446_spi_unregister_driver();
614 module_exit(ad5446_exit);
616 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
617 MODULE_DESCRIPTION("Analog Devices AD5444/AD5446 DAC");
618 MODULE_LICENSE("GPL v2");