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), \
151 .realbits = (bits), \
152 .storagebits = (storage), \
158 #define AD5446_CHANNEL(bits, storage, shift) \
159 _AD5446_CHANNEL(bits, storage, shift, NULL)
161 #define AD5446_CHANNEL_POWERDOWN(bits, storage, shift) \
162 _AD5446_CHANNEL(bits, storage, shift, ad5446_ext_info_powerdown)
164 static int ad5446_read_raw(struct iio_dev *indio_dev,
165 struct iio_chan_spec const *chan,
170 struct ad5446_state *st = iio_priv(indio_dev);
173 case IIO_CHAN_INFO_RAW:
174 *val = st->cached_val >> chan->scan_type.shift;
176 case IIO_CHAN_INFO_SCALE:
178 *val2 = chan->scan_type.realbits;
179 return IIO_VAL_FRACTIONAL_LOG2;
184 static int ad5446_write_raw(struct iio_dev *indio_dev,
185 struct iio_chan_spec const *chan,
190 struct ad5446_state *st = iio_priv(indio_dev);
194 case IIO_CHAN_INFO_RAW:
195 if (val >= (1 << chan->scan_type.realbits) || val < 0)
198 val <<= chan->scan_type.shift;
199 mutex_lock(&indio_dev->mlock);
200 st->cached_val = val;
202 ret = st->chip_info->write(st, val);
203 mutex_unlock(&indio_dev->mlock);
212 static const struct iio_info ad5446_info = {
213 .read_raw = ad5446_read_raw,
214 .write_raw = ad5446_write_raw,
217 static int ad5446_probe(struct device *dev, const char *name,
218 const struct ad5446_chip_info *chip_info)
220 struct ad5446_state *st;
221 struct iio_dev *indio_dev;
222 struct regulator *reg;
223 int ret, voltage_uv = 0;
225 reg = devm_regulator_get(dev, "vcc");
227 ret = regulator_enable(reg);
231 ret = regulator_get_voltage(reg);
233 goto error_disable_reg;
238 indio_dev = devm_iio_device_alloc(dev, sizeof(*st));
239 if (indio_dev == NULL) {
241 goto error_disable_reg;
243 st = iio_priv(indio_dev);
244 st->chip_info = chip_info;
246 dev_set_drvdata(dev, indio_dev);
250 /* Establish that the iio_dev is a child of the device */
251 indio_dev->dev.parent = dev;
252 indio_dev->name = name;
253 indio_dev->info = &ad5446_info;
254 indio_dev->modes = INDIO_DIRECT_MODE;
255 indio_dev->channels = &st->chip_info->channel;
256 indio_dev->num_channels = 1;
258 st->pwr_down_mode = MODE_PWRDWN_1k;
260 if (st->chip_info->int_vref_mv)
261 st->vref_mv = st->chip_info->int_vref_mv;
263 st->vref_mv = voltage_uv / 1000;
265 dev_warn(dev, "reference voltage unspecified\n");
267 ret = iio_device_register(indio_dev);
269 goto error_disable_reg;
275 regulator_disable(reg);
279 static int ad5446_remove(struct device *dev)
281 struct iio_dev *indio_dev = dev_get_drvdata(dev);
282 struct ad5446_state *st = iio_priv(indio_dev);
284 iio_device_unregister(indio_dev);
285 if (!IS_ERR(st->reg))
286 regulator_disable(st->reg);
291 #if IS_ENABLED(CONFIG_SPI_MASTER)
293 static int ad5446_write(struct ad5446_state *st, unsigned val)
295 struct spi_device *spi = to_spi_device(st->dev);
296 __be16 data = cpu_to_be16(val);
298 return spi_write(spi, &data, sizeof(data));
301 static int ad5660_write(struct ad5446_state *st, unsigned val)
303 struct spi_device *spi = to_spi_device(st->dev);
306 data[0] = (val >> 16) & 0xFF;
307 data[1] = (val >> 8) & 0xFF;
308 data[2] = val & 0xFF;
310 return spi_write(spi, data, sizeof(data));
314 * ad5446_supported_spi_device_ids:
315 * The AD5620/40/60 parts are available in different fixed internal reference
316 * voltage options. The actual part numbers may look differently
317 * (and a bit cryptic), however this style is used to make clear which
318 * parts are supported here.
320 enum ad5446_supported_spi_device_ids {
345 static const struct ad5446_chip_info ad5446_spi_chip_info[] = {
347 .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 4),
348 .write = ad5446_write,
351 .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 2),
352 .write = ad5446_write,
355 .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 0),
356 .write = ad5446_write,
359 .channel = AD5446_CHANNEL(12, 16, 2),
360 .write = ad5446_write,
363 .channel = AD5446_CHANNEL(14, 16, 0),
364 .write = ad5446_write,
367 .channel = AD5446_CHANNEL(8, 16, 6),
368 .write = ad5446_write,
371 .channel = AD5446_CHANNEL(10, 16, 4),
372 .write = ad5446_write,
375 .channel = AD5446_CHANNEL(16, 16, 0),
376 .write = ad5446_write,
379 .channel = AD5446_CHANNEL(12, 16, 4),
380 .write = ad5446_write,
383 .channel = AD5446_CHANNEL(14, 16, 0),
384 .write = ad5446_write,
387 .channel = AD5446_CHANNEL(16, 16, 0),
388 .write = ad5446_write,
391 .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 6),
392 .write = ad5446_write,
395 .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 4),
396 .write = ad5446_write,
399 .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
400 .write = ad5446_write,
403 .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
404 .write = ad5446_write,
407 .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
409 .write = ad5446_write,
412 .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
414 .write = ad5446_write,
417 .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
419 .write = ad5446_write,
422 .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
424 .write = ad5446_write,
427 .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
429 .write = ad5660_write,
432 .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
434 .write = ad5660_write,
437 .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
438 .write = ad5660_write,
442 static const struct spi_device_id ad5446_spi_ids[] = {
443 {"ad5300", ID_AD5300},
444 {"ad5310", ID_AD5310},
445 {"ad5320", ID_AD5320},
446 {"ad5444", ID_AD5444},
447 {"ad5446", ID_AD5446},
448 {"ad5450", ID_AD5450},
449 {"ad5451", ID_AD5451},
450 {"ad5452", ID_AD5444}, /* ad5452 is compatible to the ad5444 */
451 {"ad5453", ID_AD5446}, /* ad5453 is compatible to the ad5446 */
452 {"ad5512a", ID_AD5512A},
453 {"ad5541a", ID_AD5541A},
454 {"ad5542a", ID_AD5541A}, /* ad5541a and ad5542a are compatible */
455 {"ad5543", ID_AD5541A}, /* ad5541a and ad5543 are compatible */
456 {"ad5553", ID_AD5553},
457 {"ad5600", ID_AD5600},
458 {"ad5601", ID_AD5601},
459 {"ad5611", ID_AD5611},
460 {"ad5621", ID_AD5621},
461 {"ad5641", ID_AD5641},
462 {"ad5620-2500", ID_AD5620_2500}, /* AD5620/40/60: */
463 {"ad5620-1250", ID_AD5620_1250}, /* part numbers may look differently */
464 {"ad5640-2500", ID_AD5640_2500},
465 {"ad5640-1250", ID_AD5640_1250},
466 {"ad5660-2500", ID_AD5660_2500},
467 {"ad5660-1250", ID_AD5660_1250},
468 {"ad5662", ID_AD5662},
469 {"dac081s101", ID_AD5300}, /* compatible Texas Instruments chips */
470 {"dac101s101", ID_AD5310},
471 {"dac121s101", ID_AD5320},
472 {"dac7512", ID_AD5320},
475 MODULE_DEVICE_TABLE(spi, ad5446_spi_ids);
478 static const struct of_device_id ad5446_of_ids[] = {
479 { .compatible = "ti,dac7512" },
482 MODULE_DEVICE_TABLE(of, ad5446_of_ids);
485 static int ad5446_spi_probe(struct spi_device *spi)
487 const struct spi_device_id *id = spi_get_device_id(spi);
489 return ad5446_probe(&spi->dev, id->name,
490 &ad5446_spi_chip_info[id->driver_data]);
493 static int ad5446_spi_remove(struct spi_device *spi)
495 return ad5446_remove(&spi->dev);
498 static struct spi_driver ad5446_spi_driver = {
501 .of_match_table = of_match_ptr(ad5446_of_ids),
503 .probe = ad5446_spi_probe,
504 .remove = ad5446_spi_remove,
505 .id_table = ad5446_spi_ids,
508 static int __init ad5446_spi_register_driver(void)
510 return spi_register_driver(&ad5446_spi_driver);
513 static void ad5446_spi_unregister_driver(void)
515 spi_unregister_driver(&ad5446_spi_driver);
520 static inline int ad5446_spi_register_driver(void) { return 0; }
521 static inline void ad5446_spi_unregister_driver(void) { }
525 #if IS_ENABLED(CONFIG_I2C)
527 static int ad5622_write(struct ad5446_state *st, unsigned val)
529 struct i2c_client *client = to_i2c_client(st->dev);
530 __be16 data = cpu_to_be16(val);
533 ret = i2c_master_send(client, (char *)&data, sizeof(data));
536 if (ret != sizeof(data))
543 * ad5446_supported_i2c_device_ids:
544 * The AD5620/40/60 parts are available in different fixed internal reference
545 * voltage options. The actual part numbers may look differently
546 * (and a bit cryptic), however this style is used to make clear which
547 * parts are supported here.
549 enum ad5446_supported_i2c_device_ids {
555 static const struct ad5446_chip_info ad5446_i2c_chip_info[] = {
557 .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 4),
558 .write = ad5622_write,
561 .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 2),
562 .write = ad5622_write,
565 .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 0),
566 .write = ad5622_write,
570 static int ad5446_i2c_probe(struct i2c_client *i2c,
571 const struct i2c_device_id *id)
573 return ad5446_probe(&i2c->dev, id->name,
574 &ad5446_i2c_chip_info[id->driver_data]);
577 static int ad5446_i2c_remove(struct i2c_client *i2c)
579 return ad5446_remove(&i2c->dev);
582 static const struct i2c_device_id ad5446_i2c_ids[] = {
583 {"ad5301", ID_AD5602},
584 {"ad5311", ID_AD5612},
585 {"ad5321", ID_AD5622},
586 {"ad5602", ID_AD5602},
587 {"ad5612", ID_AD5612},
588 {"ad5622", ID_AD5622},
591 MODULE_DEVICE_TABLE(i2c, ad5446_i2c_ids);
593 static struct i2c_driver ad5446_i2c_driver = {
597 .probe = ad5446_i2c_probe,
598 .remove = ad5446_i2c_remove,
599 .id_table = ad5446_i2c_ids,
602 static int __init ad5446_i2c_register_driver(void)
604 return i2c_add_driver(&ad5446_i2c_driver);
607 static void __exit ad5446_i2c_unregister_driver(void)
609 i2c_del_driver(&ad5446_i2c_driver);
614 static inline int ad5446_i2c_register_driver(void) { return 0; }
615 static inline void ad5446_i2c_unregister_driver(void) { }
619 static int __init ad5446_init(void)
623 ret = ad5446_spi_register_driver();
627 ret = ad5446_i2c_register_driver();
629 ad5446_spi_unregister_driver();
635 module_init(ad5446_init);
637 static void __exit ad5446_exit(void)
639 ad5446_i2c_unregister_driver();
640 ad5446_spi_unregister_driver();
642 module_exit(ad5446_exit);
644 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
645 MODULE_DESCRIPTION("Analog Devices AD5444/AD5446 DAC");
646 MODULE_LICENSE("GPL v2");