Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Analog devices AD5380, AD5381, AD5382, AD5383, AD5390, AD5391, AD5392
0004  * multi-channel Digital to Analog Converters driver
0005  *
0006  * Copyright 2011 Analog Devices Inc.
0007  */
0008 
0009 #include <linux/device.h>
0010 #include <linux/err.h>
0011 #include <linux/i2c.h>
0012 #include <linux/kernel.h>
0013 #include <linux/module.h>
0014 #include <linux/spi/spi.h>
0015 #include <linux/slab.h>
0016 #include <linux/sysfs.h>
0017 #include <linux/regmap.h>
0018 #include <linux/regulator/consumer.h>
0019 
0020 #include <linux/iio/iio.h>
0021 #include <linux/iio/sysfs.h>
0022 
0023 #define AD5380_REG_DATA(x)  (((x) << 2) | 3)
0024 #define AD5380_REG_OFFSET(x)    (((x) << 2) | 2)
0025 #define AD5380_REG_GAIN(x)  (((x) << 2) | 1)
0026 #define AD5380_REG_SF_PWR_DOWN  (8 << 2)
0027 #define AD5380_REG_SF_PWR_UP    (9 << 2)
0028 #define AD5380_REG_SF_CTRL  (12 << 2)
0029 
0030 #define AD5380_CTRL_PWR_DOWN_MODE_OFFSET    13
0031 #define AD5380_CTRL_INT_VREF_2V5        BIT(12)
0032 #define AD5380_CTRL_INT_VREF_EN         BIT(10)
0033 
0034 /**
0035  * struct ad5380_chip_info - chip specific information
0036  * @channel_template:   channel specification template
0037  * @num_channels:   number of channels
0038  * @int_vref:       internal vref in uV
0039  */
0040 struct ad5380_chip_info {
0041     struct iio_chan_spec    channel_template;
0042     unsigned int        num_channels;
0043     unsigned int        int_vref;
0044 };
0045 
0046 /**
0047  * struct ad5380_state - driver instance specific data
0048  * @regmap:     regmap instance used by the device
0049  * @chip_info:      chip model specific constants, available modes etc
0050  * @vref_reg:       vref supply regulator
0051  * @vref:       actual reference voltage used in uA
0052  * @pwr_down:       whether the chip is currently in power down mode
0053  * @lock:       lock to protect the data buffer during regmap ops
0054  */
0055 struct ad5380_state {
0056     struct regmap           *regmap;
0057     const struct ad5380_chip_info   *chip_info;
0058     struct regulator        *vref_reg;
0059     int             vref;
0060     bool                pwr_down;
0061     struct mutex            lock;
0062 };
0063 
0064 enum ad5380_type {
0065     ID_AD5380_3,
0066     ID_AD5380_5,
0067     ID_AD5381_3,
0068     ID_AD5381_5,
0069     ID_AD5382_3,
0070     ID_AD5382_5,
0071     ID_AD5383_3,
0072     ID_AD5383_5,
0073     ID_AD5390_3,
0074     ID_AD5390_5,
0075     ID_AD5391_3,
0076     ID_AD5391_5,
0077     ID_AD5392_3,
0078     ID_AD5392_5,
0079 };
0080 
0081 static ssize_t ad5380_read_dac_powerdown(struct iio_dev *indio_dev,
0082     uintptr_t private, const struct iio_chan_spec *chan, char *buf)
0083 {
0084     struct ad5380_state *st = iio_priv(indio_dev);
0085 
0086     return sysfs_emit(buf, "%d\n", st->pwr_down);
0087 }
0088 
0089 static ssize_t ad5380_write_dac_powerdown(struct iio_dev *indio_dev,
0090      uintptr_t private, const struct iio_chan_spec *chan, const char *buf,
0091      size_t len)
0092 {
0093     struct ad5380_state *st = iio_priv(indio_dev);
0094     bool pwr_down;
0095     int ret;
0096 
0097     ret = kstrtobool(buf, &pwr_down);
0098     if (ret)
0099         return ret;
0100 
0101     mutex_lock(&st->lock);
0102 
0103     if (pwr_down)
0104         ret = regmap_write(st->regmap, AD5380_REG_SF_PWR_DOWN, 0);
0105     else
0106         ret = regmap_write(st->regmap, AD5380_REG_SF_PWR_UP, 0);
0107 
0108     st->pwr_down = pwr_down;
0109 
0110     mutex_unlock(&st->lock);
0111 
0112     return ret ? ret : len;
0113 }
0114 
0115 static const char * const ad5380_powerdown_modes[] = {
0116     "100kohm_to_gnd",
0117     "three_state",
0118 };
0119 
0120 static int ad5380_get_powerdown_mode(struct iio_dev *indio_dev,
0121     const struct iio_chan_spec *chan)
0122 {
0123     struct ad5380_state *st = iio_priv(indio_dev);
0124     unsigned int mode;
0125     int ret;
0126 
0127     ret = regmap_read(st->regmap, AD5380_REG_SF_CTRL, &mode);
0128     if (ret)
0129         return ret;
0130 
0131     mode = (mode >> AD5380_CTRL_PWR_DOWN_MODE_OFFSET) & 1;
0132 
0133     return mode;
0134 }
0135 
0136 static int ad5380_set_powerdown_mode(struct iio_dev *indio_dev,
0137     const struct iio_chan_spec *chan, unsigned int mode)
0138 {
0139     struct ad5380_state *st = iio_priv(indio_dev);
0140     int ret;
0141 
0142     ret = regmap_update_bits(st->regmap, AD5380_REG_SF_CTRL,
0143         1 << AD5380_CTRL_PWR_DOWN_MODE_OFFSET,
0144         mode << AD5380_CTRL_PWR_DOWN_MODE_OFFSET);
0145 
0146     return ret;
0147 }
0148 
0149 static const struct iio_enum ad5380_powerdown_mode_enum = {
0150     .items = ad5380_powerdown_modes,
0151     .num_items = ARRAY_SIZE(ad5380_powerdown_modes),
0152     .get = ad5380_get_powerdown_mode,
0153     .set = ad5380_set_powerdown_mode,
0154 };
0155 
0156 static unsigned int ad5380_info_to_reg(struct iio_chan_spec const *chan,
0157     long info)
0158 {
0159     switch (info) {
0160     case IIO_CHAN_INFO_RAW:
0161         return AD5380_REG_DATA(chan->address);
0162     case IIO_CHAN_INFO_CALIBBIAS:
0163         return AD5380_REG_OFFSET(chan->address);
0164     case IIO_CHAN_INFO_CALIBSCALE:
0165         return AD5380_REG_GAIN(chan->address);
0166     default:
0167         break;
0168     }
0169 
0170     return 0;
0171 }
0172 
0173 static int ad5380_write_raw(struct iio_dev *indio_dev,
0174     struct iio_chan_spec const *chan, int val, int val2, long info)
0175 {
0176     const unsigned int max_val = (1 << chan->scan_type.realbits);
0177     struct ad5380_state *st = iio_priv(indio_dev);
0178 
0179     switch (info) {
0180     case IIO_CHAN_INFO_RAW:
0181     case IIO_CHAN_INFO_CALIBSCALE:
0182         if (val >= max_val || val < 0)
0183             return -EINVAL;
0184 
0185         return regmap_write(st->regmap,
0186             ad5380_info_to_reg(chan, info),
0187             val << chan->scan_type.shift);
0188     case IIO_CHAN_INFO_CALIBBIAS:
0189         val += (1 << chan->scan_type.realbits) / 2;
0190         if (val >= max_val || val < 0)
0191             return -EINVAL;
0192 
0193         return regmap_write(st->regmap,
0194             AD5380_REG_OFFSET(chan->address),
0195             val << chan->scan_type.shift);
0196     default:
0197         break;
0198     }
0199     return -EINVAL;
0200 }
0201 
0202 static int ad5380_read_raw(struct iio_dev *indio_dev,
0203     struct iio_chan_spec const *chan, int *val, int *val2, long info)
0204 {
0205     struct ad5380_state *st = iio_priv(indio_dev);
0206     int ret;
0207 
0208     switch (info) {
0209     case IIO_CHAN_INFO_RAW:
0210     case IIO_CHAN_INFO_CALIBSCALE:
0211         ret = regmap_read(st->regmap, ad5380_info_to_reg(chan, info),
0212                     val);
0213         if (ret)
0214             return ret;
0215         *val >>= chan->scan_type.shift;
0216         return IIO_VAL_INT;
0217     case IIO_CHAN_INFO_CALIBBIAS:
0218         ret = regmap_read(st->regmap, AD5380_REG_OFFSET(chan->address),
0219                     val);
0220         if (ret)
0221             return ret;
0222         *val >>= chan->scan_type.shift;
0223         *val -= (1 << chan->scan_type.realbits) / 2;
0224         return IIO_VAL_INT;
0225     case IIO_CHAN_INFO_SCALE:
0226         *val = 2 * st->vref;
0227         *val2 = chan->scan_type.realbits;
0228         return IIO_VAL_FRACTIONAL_LOG2;
0229     default:
0230         break;
0231     }
0232 
0233     return -EINVAL;
0234 }
0235 
0236 static const struct iio_info ad5380_info = {
0237     .read_raw = ad5380_read_raw,
0238     .write_raw = ad5380_write_raw,
0239 };
0240 
0241 static const struct iio_chan_spec_ext_info ad5380_ext_info[] = {
0242     {
0243         .name = "powerdown",
0244         .read = ad5380_read_dac_powerdown,
0245         .write = ad5380_write_dac_powerdown,
0246         .shared = IIO_SEPARATE,
0247     },
0248     IIO_ENUM("powerdown_mode", IIO_SHARED_BY_TYPE,
0249          &ad5380_powerdown_mode_enum),
0250     IIO_ENUM_AVAILABLE("powerdown_mode", IIO_SHARED_BY_TYPE, &ad5380_powerdown_mode_enum),
0251     { },
0252 };
0253 
0254 #define AD5380_CHANNEL(_bits) {                 \
0255     .type = IIO_VOLTAGE,                    \
0256     .indexed = 1,                       \
0257     .output = 1,                        \
0258     .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |      \
0259         BIT(IIO_CHAN_INFO_CALIBSCALE) |         \
0260         BIT(IIO_CHAN_INFO_CALIBBIAS),           \
0261     .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),   \
0262     .scan_type = {                      \
0263         .sign = 'u',                    \
0264         .realbits = (_bits),                \
0265         .storagebits =  16,             \
0266         .shift = 14 - (_bits),              \
0267     },                          \
0268     .ext_info = ad5380_ext_info,                \
0269 }
0270 
0271 static const struct ad5380_chip_info ad5380_chip_info_tbl[] = {
0272     [ID_AD5380_3] = {
0273         .channel_template = AD5380_CHANNEL(14),
0274         .num_channels = 40,
0275         .int_vref = 1250,
0276     },
0277     [ID_AD5380_5] = {
0278         .channel_template = AD5380_CHANNEL(14),
0279         .num_channels = 40,
0280         .int_vref = 2500,
0281     },
0282     [ID_AD5381_3] = {
0283         .channel_template = AD5380_CHANNEL(12),
0284         .num_channels = 16,
0285         .int_vref = 1250,
0286     },
0287     [ID_AD5381_5] = {
0288         .channel_template = AD5380_CHANNEL(12),
0289         .num_channels = 16,
0290         .int_vref = 2500,
0291     },
0292     [ID_AD5382_3] = {
0293         .channel_template = AD5380_CHANNEL(14),
0294         .num_channels = 32,
0295         .int_vref = 1250,
0296     },
0297     [ID_AD5382_5] = {
0298         .channel_template = AD5380_CHANNEL(14),
0299         .num_channels = 32,
0300         .int_vref = 2500,
0301     },
0302     [ID_AD5383_3] = {
0303         .channel_template = AD5380_CHANNEL(12),
0304         .num_channels = 32,
0305         .int_vref = 1250,
0306     },
0307     [ID_AD5383_5] = {
0308         .channel_template = AD5380_CHANNEL(12),
0309         .num_channels = 32,
0310         .int_vref = 2500,
0311     },
0312     [ID_AD5390_3] = {
0313         .channel_template = AD5380_CHANNEL(14),
0314         .num_channels = 16,
0315         .int_vref = 1250,
0316     },
0317     [ID_AD5390_5] = {
0318         .channel_template = AD5380_CHANNEL(14),
0319         .num_channels = 16,
0320         .int_vref = 2500,
0321     },
0322     [ID_AD5391_3] = {
0323         .channel_template = AD5380_CHANNEL(12),
0324         .num_channels = 16,
0325         .int_vref = 1250,
0326     },
0327     [ID_AD5391_5] = {
0328         .channel_template = AD5380_CHANNEL(12),
0329         .num_channels = 16,
0330         .int_vref = 2500,
0331     },
0332     [ID_AD5392_3] = {
0333         .channel_template = AD5380_CHANNEL(14),
0334         .num_channels = 8,
0335         .int_vref = 1250,
0336     },
0337     [ID_AD5392_5] = {
0338         .channel_template = AD5380_CHANNEL(14),
0339         .num_channels = 8,
0340         .int_vref = 2500,
0341     },
0342 };
0343 
0344 static int ad5380_alloc_channels(struct iio_dev *indio_dev)
0345 {
0346     struct ad5380_state *st = iio_priv(indio_dev);
0347     struct iio_chan_spec *channels;
0348     unsigned int i;
0349 
0350     channels = kcalloc(st->chip_info->num_channels,
0351                sizeof(struct iio_chan_spec), GFP_KERNEL);
0352 
0353     if (!channels)
0354         return -ENOMEM;
0355 
0356     for (i = 0; i < st->chip_info->num_channels; ++i) {
0357         channels[i] = st->chip_info->channel_template;
0358         channels[i].channel = i;
0359         channels[i].address = i;
0360     }
0361 
0362     indio_dev->channels = channels;
0363 
0364     return 0;
0365 }
0366 
0367 static int ad5380_probe(struct device *dev, struct regmap *regmap,
0368             enum ad5380_type type, const char *name)
0369 {
0370     struct iio_dev *indio_dev;
0371     struct ad5380_state *st;
0372     unsigned int ctrl = 0;
0373     int ret;
0374 
0375     indio_dev = devm_iio_device_alloc(dev, sizeof(*st));
0376     if (indio_dev == NULL) {
0377         dev_err(dev, "Failed to allocate iio device\n");
0378         return -ENOMEM;
0379     }
0380 
0381     st = iio_priv(indio_dev);
0382     dev_set_drvdata(dev, indio_dev);
0383 
0384     st->chip_info = &ad5380_chip_info_tbl[type];
0385     st->regmap = regmap;
0386 
0387     indio_dev->name = name;
0388     indio_dev->info = &ad5380_info;
0389     indio_dev->modes = INDIO_DIRECT_MODE;
0390     indio_dev->num_channels = st->chip_info->num_channels;
0391 
0392     mutex_init(&st->lock);
0393 
0394     ret = ad5380_alloc_channels(indio_dev);
0395     if (ret) {
0396         dev_err(dev, "Failed to allocate channel spec: %d\n", ret);
0397         return ret;
0398     }
0399 
0400     if (st->chip_info->int_vref == 2500)
0401         ctrl |= AD5380_CTRL_INT_VREF_2V5;
0402 
0403     st->vref_reg = devm_regulator_get(dev, "vref");
0404     if (!IS_ERR(st->vref_reg)) {
0405         ret = regulator_enable(st->vref_reg);
0406         if (ret) {
0407             dev_err(dev, "Failed to enable vref regulators: %d\n",
0408                 ret);
0409             goto error_free_reg;
0410         }
0411 
0412         ret = regulator_get_voltage(st->vref_reg);
0413         if (ret < 0)
0414             goto error_disable_reg;
0415 
0416         st->vref = ret / 1000;
0417     } else {
0418         st->vref = st->chip_info->int_vref;
0419         ctrl |= AD5380_CTRL_INT_VREF_EN;
0420     }
0421 
0422     ret = regmap_write(st->regmap, AD5380_REG_SF_CTRL, ctrl);
0423     if (ret) {
0424         dev_err(dev, "Failed to write to device: %d\n", ret);
0425         goto error_disable_reg;
0426     }
0427 
0428     ret = iio_device_register(indio_dev);
0429     if (ret) {
0430         dev_err(dev, "Failed to register iio device: %d\n", ret);
0431         goto error_disable_reg;
0432     }
0433 
0434     return 0;
0435 
0436 error_disable_reg:
0437     if (!IS_ERR(st->vref_reg))
0438         regulator_disable(st->vref_reg);
0439 error_free_reg:
0440     kfree(indio_dev->channels);
0441 
0442     return ret;
0443 }
0444 
0445 static void ad5380_remove(struct device *dev)
0446 {
0447     struct iio_dev *indio_dev = dev_get_drvdata(dev);
0448     struct ad5380_state *st = iio_priv(indio_dev);
0449 
0450     iio_device_unregister(indio_dev);
0451 
0452     kfree(indio_dev->channels);
0453 
0454     if (!IS_ERR(st->vref_reg))
0455         regulator_disable(st->vref_reg);
0456 }
0457 
0458 static bool ad5380_reg_false(struct device *dev, unsigned int reg)
0459 {
0460     return false;
0461 }
0462 
0463 static const struct regmap_config ad5380_regmap_config = {
0464     .reg_bits = 10,
0465     .val_bits = 14,
0466 
0467     .max_register = AD5380_REG_DATA(40),
0468     .cache_type = REGCACHE_RBTREE,
0469 
0470     .volatile_reg = ad5380_reg_false,
0471     .readable_reg = ad5380_reg_false,
0472 };
0473 
0474 #if IS_ENABLED(CONFIG_SPI_MASTER)
0475 
0476 static int ad5380_spi_probe(struct spi_device *spi)
0477 {
0478     const struct spi_device_id *id = spi_get_device_id(spi);
0479     struct regmap *regmap;
0480 
0481     regmap = devm_regmap_init_spi(spi, &ad5380_regmap_config);
0482 
0483     if (IS_ERR(regmap))
0484         return PTR_ERR(regmap);
0485 
0486     return ad5380_probe(&spi->dev, regmap, id->driver_data, id->name);
0487 }
0488 
0489 static void ad5380_spi_remove(struct spi_device *spi)
0490 {
0491     ad5380_remove(&spi->dev);
0492 }
0493 
0494 static const struct spi_device_id ad5380_spi_ids[] = {
0495     { "ad5380-3", ID_AD5380_3 },
0496     { "ad5380-5", ID_AD5380_5 },
0497     { "ad5381-3", ID_AD5381_3 },
0498     { "ad5381-5", ID_AD5381_5 },
0499     { "ad5382-3", ID_AD5382_3 },
0500     { "ad5382-5", ID_AD5382_5 },
0501     { "ad5383-3", ID_AD5383_3 },
0502     { "ad5383-5", ID_AD5383_5 },
0503     { "ad5384-3", ID_AD5380_3 },
0504     { "ad5384-5", ID_AD5380_5 },
0505     { "ad5390-3", ID_AD5390_3 },
0506     { "ad5390-5", ID_AD5390_5 },
0507     { "ad5391-3", ID_AD5391_3 },
0508     { "ad5391-5", ID_AD5391_5 },
0509     { "ad5392-3", ID_AD5392_3 },
0510     { "ad5392-5", ID_AD5392_5 },
0511     { }
0512 };
0513 MODULE_DEVICE_TABLE(spi, ad5380_spi_ids);
0514 
0515 static struct spi_driver ad5380_spi_driver = {
0516     .driver = {
0517            .name = "ad5380",
0518     },
0519     .probe = ad5380_spi_probe,
0520     .remove = ad5380_spi_remove,
0521     .id_table = ad5380_spi_ids,
0522 };
0523 
0524 static inline int ad5380_spi_register_driver(void)
0525 {
0526     return spi_register_driver(&ad5380_spi_driver);
0527 }
0528 
0529 static inline void ad5380_spi_unregister_driver(void)
0530 {
0531     spi_unregister_driver(&ad5380_spi_driver);
0532 }
0533 
0534 #else
0535 
0536 static inline int ad5380_spi_register_driver(void)
0537 {
0538     return 0;
0539 }
0540 
0541 static inline void ad5380_spi_unregister_driver(void)
0542 {
0543 }
0544 
0545 #endif
0546 
0547 #if IS_ENABLED(CONFIG_I2C)
0548 
0549 static int ad5380_i2c_probe(struct i2c_client *i2c,
0550                 const struct i2c_device_id *id)
0551 {
0552     struct regmap *regmap;
0553 
0554     regmap = devm_regmap_init_i2c(i2c, &ad5380_regmap_config);
0555 
0556     if (IS_ERR(regmap))
0557         return PTR_ERR(regmap);
0558 
0559     return ad5380_probe(&i2c->dev, regmap, id->driver_data, id->name);
0560 }
0561 
0562 static int ad5380_i2c_remove(struct i2c_client *i2c)
0563 {
0564     ad5380_remove(&i2c->dev);
0565 
0566     return 0;
0567 }
0568 
0569 static const struct i2c_device_id ad5380_i2c_ids[] = {
0570     { "ad5380-3", ID_AD5380_3 },
0571     { "ad5380-5", ID_AD5380_5 },
0572     { "ad5381-3", ID_AD5381_3 },
0573     { "ad5381-5", ID_AD5381_5 },
0574     { "ad5382-3", ID_AD5382_3 },
0575     { "ad5382-5", ID_AD5382_5 },
0576     { "ad5383-3", ID_AD5383_3 },
0577     { "ad5383-5", ID_AD5383_5 },
0578     { "ad5384-3", ID_AD5380_3 },
0579     { "ad5384-5", ID_AD5380_5 },
0580     { "ad5390-3", ID_AD5390_3 },
0581     { "ad5390-5", ID_AD5390_5 },
0582     { "ad5391-3", ID_AD5391_3 },
0583     { "ad5391-5", ID_AD5391_5 },
0584     { "ad5392-3", ID_AD5392_3 },
0585     { "ad5392-5", ID_AD5392_5 },
0586     { }
0587 };
0588 MODULE_DEVICE_TABLE(i2c, ad5380_i2c_ids);
0589 
0590 static struct i2c_driver ad5380_i2c_driver = {
0591     .driver = {
0592            .name = "ad5380",
0593     },
0594     .probe = ad5380_i2c_probe,
0595     .remove = ad5380_i2c_remove,
0596     .id_table = ad5380_i2c_ids,
0597 };
0598 
0599 static inline int ad5380_i2c_register_driver(void)
0600 {
0601     return i2c_add_driver(&ad5380_i2c_driver);
0602 }
0603 
0604 static inline void ad5380_i2c_unregister_driver(void)
0605 {
0606     i2c_del_driver(&ad5380_i2c_driver);
0607 }
0608 
0609 #else
0610 
0611 static inline int ad5380_i2c_register_driver(void)
0612 {
0613     return 0;
0614 }
0615 
0616 static inline void ad5380_i2c_unregister_driver(void)
0617 {
0618 }
0619 
0620 #endif
0621 
0622 static int __init ad5380_spi_init(void)
0623 {
0624     int ret;
0625 
0626     ret = ad5380_spi_register_driver();
0627     if (ret)
0628         return ret;
0629 
0630     ret = ad5380_i2c_register_driver();
0631     if (ret) {
0632         ad5380_spi_unregister_driver();
0633         return ret;
0634     }
0635 
0636     return 0;
0637 }
0638 module_init(ad5380_spi_init);
0639 
0640 static void __exit ad5380_spi_exit(void)
0641 {
0642     ad5380_i2c_unregister_driver();
0643     ad5380_spi_unregister_driver();
0644 
0645 }
0646 module_exit(ad5380_spi_exit);
0647 
0648 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
0649 MODULE_DESCRIPTION("Analog Devices AD5380/81/82/83/84/90/91/92 DAC");
0650 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!