Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * AD5446 SPI DAC driver
0004  *
0005  * Copyright 2010 Analog Devices Inc.
0006  */
0007 
0008 #include <linux/interrupt.h>
0009 #include <linux/workqueue.h>
0010 #include <linux/device.h>
0011 #include <linux/kernel.h>
0012 #include <linux/slab.h>
0013 #include <linux/sysfs.h>
0014 #include <linux/list.h>
0015 #include <linux/spi/spi.h>
0016 #include <linux/i2c.h>
0017 #include <linux/regulator/consumer.h>
0018 #include <linux/err.h>
0019 #include <linux/module.h>
0020 #include <linux/mod_devicetable.h>
0021 
0022 #include <linux/iio/iio.h>
0023 #include <linux/iio/sysfs.h>
0024 
0025 #include <asm/unaligned.h>
0026 
0027 #define MODE_PWRDWN_1k      0x1
0028 #define MODE_PWRDWN_100k    0x2
0029 #define MODE_PWRDWN_TRISTATE    0x3
0030 
0031 /**
0032  * struct ad5446_state - driver instance specific data
0033  * @dev:        this device
0034  * @chip_info:      chip model specific constants, available modes etc
0035  * @reg:        supply regulator
0036  * @vref_mv:        actual reference voltage used
0037  * @cached_val:     store/retrieve values during power down
0038  * @pwr_down_mode:  power down mode (1k, 100k or tristate)
0039  * @pwr_down:       true if the device is in power down
0040  * @lock:       lock to protect the data buffer during write ops
0041  */
0042 
0043 struct ad5446_state {
0044     struct device       *dev;
0045     const struct ad5446_chip_info   *chip_info;
0046     struct regulator        *reg;
0047     unsigned short          vref_mv;
0048     unsigned            cached_val;
0049     unsigned            pwr_down_mode;
0050     unsigned            pwr_down;
0051     struct mutex            lock;
0052 };
0053 
0054 /**
0055  * struct ad5446_chip_info - chip specific information
0056  * @channel:        channel spec for the DAC
0057  * @int_vref_mv:    AD5620/40/60: the internal reference voltage
0058  * @write:      chip specific helper function to write to the register
0059  */
0060 
0061 struct ad5446_chip_info {
0062     struct iio_chan_spec    channel;
0063     u16         int_vref_mv;
0064     int         (*write)(struct ad5446_state *st, unsigned val);
0065 };
0066 
0067 static const char * const ad5446_powerdown_modes[] = {
0068     "1kohm_to_gnd", "100kohm_to_gnd", "three_state"
0069 };
0070 
0071 static int ad5446_set_powerdown_mode(struct iio_dev *indio_dev,
0072     const struct iio_chan_spec *chan, unsigned int mode)
0073 {
0074     struct ad5446_state *st = iio_priv(indio_dev);
0075 
0076     st->pwr_down_mode = mode + 1;
0077 
0078     return 0;
0079 }
0080 
0081 static int ad5446_get_powerdown_mode(struct iio_dev *indio_dev,
0082     const struct iio_chan_spec *chan)
0083 {
0084     struct ad5446_state *st = iio_priv(indio_dev);
0085 
0086     return st->pwr_down_mode - 1;
0087 }
0088 
0089 static const struct iio_enum ad5446_powerdown_mode_enum = {
0090     .items = ad5446_powerdown_modes,
0091     .num_items = ARRAY_SIZE(ad5446_powerdown_modes),
0092     .get = ad5446_get_powerdown_mode,
0093     .set = ad5446_set_powerdown_mode,
0094 };
0095 
0096 static ssize_t ad5446_read_dac_powerdown(struct iio_dev *indio_dev,
0097                        uintptr_t private,
0098                        const struct iio_chan_spec *chan,
0099                        char *buf)
0100 {
0101     struct ad5446_state *st = iio_priv(indio_dev);
0102 
0103     return sysfs_emit(buf, "%d\n", st->pwr_down);
0104 }
0105 
0106 static ssize_t ad5446_write_dac_powerdown(struct iio_dev *indio_dev,
0107                         uintptr_t private,
0108                         const struct iio_chan_spec *chan,
0109                         const char *buf, size_t len)
0110 {
0111     struct ad5446_state *st = iio_priv(indio_dev);
0112     unsigned int shift;
0113     unsigned int val;
0114     bool powerdown;
0115     int ret;
0116 
0117     ret = kstrtobool(buf, &powerdown);
0118     if (ret)
0119         return ret;
0120 
0121     mutex_lock(&st->lock);
0122     st->pwr_down = powerdown;
0123 
0124     if (st->pwr_down) {
0125         shift = chan->scan_type.realbits + chan->scan_type.shift;
0126         val = st->pwr_down_mode << shift;
0127     } else {
0128         val = st->cached_val;
0129     }
0130 
0131     ret = st->chip_info->write(st, val);
0132     mutex_unlock(&st->lock);
0133 
0134     return ret ? ret : len;
0135 }
0136 
0137 static const struct iio_chan_spec_ext_info ad5446_ext_info_powerdown[] = {
0138     {
0139         .name = "powerdown",
0140         .read = ad5446_read_dac_powerdown,
0141         .write = ad5446_write_dac_powerdown,
0142         .shared = IIO_SEPARATE,
0143     },
0144     IIO_ENUM("powerdown_mode", IIO_SEPARATE, &ad5446_powerdown_mode_enum),
0145     IIO_ENUM_AVAILABLE("powerdown_mode", IIO_SHARED_BY_TYPE, &ad5446_powerdown_mode_enum),
0146     { },
0147 };
0148 
0149 #define _AD5446_CHANNEL(bits, storage, _shift, ext) { \
0150     .type = IIO_VOLTAGE, \
0151     .indexed = 1, \
0152     .output = 1, \
0153     .channel = 0, \
0154     .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
0155     .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
0156     .scan_type = { \
0157         .sign = 'u', \
0158         .realbits = (bits), \
0159         .storagebits = (storage), \
0160         .shift = (_shift), \
0161         }, \
0162     .ext_info = (ext), \
0163 }
0164 
0165 #define AD5446_CHANNEL(bits, storage, shift) \
0166     _AD5446_CHANNEL(bits, storage, shift, NULL)
0167 
0168 #define AD5446_CHANNEL_POWERDOWN(bits, storage, shift) \
0169     _AD5446_CHANNEL(bits, storage, shift, ad5446_ext_info_powerdown)
0170 
0171 static int ad5446_read_raw(struct iio_dev *indio_dev,
0172                struct iio_chan_spec const *chan,
0173                int *val,
0174                int *val2,
0175                long m)
0176 {
0177     struct ad5446_state *st = iio_priv(indio_dev);
0178 
0179     switch (m) {
0180     case IIO_CHAN_INFO_RAW:
0181         *val = st->cached_val >> chan->scan_type.shift;
0182         return IIO_VAL_INT;
0183     case IIO_CHAN_INFO_SCALE:
0184         *val = st->vref_mv;
0185         *val2 = chan->scan_type.realbits;
0186         return IIO_VAL_FRACTIONAL_LOG2;
0187     }
0188     return -EINVAL;
0189 }
0190 
0191 static int ad5446_write_raw(struct iio_dev *indio_dev,
0192                    struct iio_chan_spec const *chan,
0193                    int val,
0194                    int val2,
0195                    long mask)
0196 {
0197     struct ad5446_state *st = iio_priv(indio_dev);
0198     int ret = 0;
0199 
0200     switch (mask) {
0201     case IIO_CHAN_INFO_RAW:
0202         if (val >= (1 << chan->scan_type.realbits) || val < 0)
0203             return -EINVAL;
0204 
0205         val <<= chan->scan_type.shift;
0206         mutex_lock(&st->lock);
0207         st->cached_val = val;
0208         if (!st->pwr_down)
0209             ret = st->chip_info->write(st, val);
0210         mutex_unlock(&st->lock);
0211         break;
0212     default:
0213         ret = -EINVAL;
0214     }
0215 
0216     return ret;
0217 }
0218 
0219 static const struct iio_info ad5446_info = {
0220     .read_raw = ad5446_read_raw,
0221     .write_raw = ad5446_write_raw,
0222 };
0223 
0224 static int ad5446_probe(struct device *dev, const char *name,
0225             const struct ad5446_chip_info *chip_info)
0226 {
0227     struct ad5446_state *st;
0228     struct iio_dev *indio_dev;
0229     struct regulator *reg;
0230     int ret, voltage_uv = 0;
0231 
0232     reg = devm_regulator_get(dev, "vcc");
0233     if (!IS_ERR(reg)) {
0234         ret = regulator_enable(reg);
0235         if (ret)
0236             return ret;
0237 
0238         ret = regulator_get_voltage(reg);
0239         if (ret < 0)
0240             goto error_disable_reg;
0241 
0242         voltage_uv = ret;
0243     }
0244 
0245     indio_dev = devm_iio_device_alloc(dev, sizeof(*st));
0246     if (indio_dev == NULL) {
0247         ret = -ENOMEM;
0248         goto error_disable_reg;
0249     }
0250     st = iio_priv(indio_dev);
0251     st->chip_info = chip_info;
0252 
0253     dev_set_drvdata(dev, indio_dev);
0254     st->reg = reg;
0255     st->dev = dev;
0256 
0257     indio_dev->name = name;
0258     indio_dev->info = &ad5446_info;
0259     indio_dev->modes = INDIO_DIRECT_MODE;
0260     indio_dev->channels = &st->chip_info->channel;
0261     indio_dev->num_channels = 1;
0262 
0263     mutex_init(&st->lock);
0264 
0265     st->pwr_down_mode = MODE_PWRDWN_1k;
0266 
0267     if (st->chip_info->int_vref_mv)
0268         st->vref_mv = st->chip_info->int_vref_mv;
0269     else if (voltage_uv)
0270         st->vref_mv = voltage_uv / 1000;
0271     else
0272         dev_warn(dev, "reference voltage unspecified\n");
0273 
0274     ret = iio_device_register(indio_dev);
0275     if (ret)
0276         goto error_disable_reg;
0277 
0278     return 0;
0279 
0280 error_disable_reg:
0281     if (!IS_ERR(reg))
0282         regulator_disable(reg);
0283     return ret;
0284 }
0285 
0286 static void ad5446_remove(struct device *dev)
0287 {
0288     struct iio_dev *indio_dev = dev_get_drvdata(dev);
0289     struct ad5446_state *st = iio_priv(indio_dev);
0290 
0291     iio_device_unregister(indio_dev);
0292     if (!IS_ERR(st->reg))
0293         regulator_disable(st->reg);
0294 }
0295 
0296 #if IS_ENABLED(CONFIG_SPI_MASTER)
0297 
0298 static int ad5446_write(struct ad5446_state *st, unsigned val)
0299 {
0300     struct spi_device *spi = to_spi_device(st->dev);
0301     __be16 data = cpu_to_be16(val);
0302 
0303     return spi_write(spi, &data, sizeof(data));
0304 }
0305 
0306 static int ad5660_write(struct ad5446_state *st, unsigned val)
0307 {
0308     struct spi_device *spi = to_spi_device(st->dev);
0309     uint8_t data[3];
0310 
0311     put_unaligned_be24(val, &data[0]);
0312 
0313     return spi_write(spi, data, sizeof(data));
0314 }
0315 
0316 /*
0317  * ad5446_supported_spi_device_ids:
0318  * The AD5620/40/60 parts are available in different fixed internal reference
0319  * voltage options. The actual part numbers may look differently
0320  * (and a bit cryptic), however this style is used to make clear which
0321  * parts are supported here.
0322  */
0323 enum ad5446_supported_spi_device_ids {
0324     ID_AD5300,
0325     ID_AD5310,
0326     ID_AD5320,
0327     ID_AD5444,
0328     ID_AD5446,
0329     ID_AD5450,
0330     ID_AD5451,
0331     ID_AD5541A,
0332     ID_AD5512A,
0333     ID_AD5553,
0334     ID_AD5600,
0335     ID_AD5601,
0336     ID_AD5611,
0337     ID_AD5621,
0338     ID_AD5641,
0339     ID_AD5620_2500,
0340     ID_AD5620_1250,
0341     ID_AD5640_2500,
0342     ID_AD5640_1250,
0343     ID_AD5660_2500,
0344     ID_AD5660_1250,
0345     ID_AD5662,
0346 };
0347 
0348 static const struct ad5446_chip_info ad5446_spi_chip_info[] = {
0349     [ID_AD5300] = {
0350         .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 4),
0351         .write = ad5446_write,
0352     },
0353     [ID_AD5310] = {
0354         .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 2),
0355         .write = ad5446_write,
0356     },
0357     [ID_AD5320] = {
0358         .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 0),
0359         .write = ad5446_write,
0360     },
0361     [ID_AD5444] = {
0362         .channel = AD5446_CHANNEL(12, 16, 2),
0363         .write = ad5446_write,
0364     },
0365     [ID_AD5446] = {
0366         .channel = AD5446_CHANNEL(14, 16, 0),
0367         .write = ad5446_write,
0368     },
0369     [ID_AD5450] = {
0370         .channel = AD5446_CHANNEL(8, 16, 6),
0371         .write = ad5446_write,
0372     },
0373     [ID_AD5451] = {
0374         .channel = AD5446_CHANNEL(10, 16, 4),
0375         .write = ad5446_write,
0376     },
0377     [ID_AD5541A] = {
0378         .channel = AD5446_CHANNEL(16, 16, 0),
0379         .write = ad5446_write,
0380     },
0381     [ID_AD5512A] = {
0382         .channel = AD5446_CHANNEL(12, 16, 4),
0383         .write = ad5446_write,
0384     },
0385     [ID_AD5553] = {
0386         .channel = AD5446_CHANNEL(14, 16, 0),
0387         .write = ad5446_write,
0388     },
0389     [ID_AD5600] = {
0390         .channel = AD5446_CHANNEL(16, 16, 0),
0391         .write = ad5446_write,
0392     },
0393     [ID_AD5601] = {
0394         .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 6),
0395         .write = ad5446_write,
0396     },
0397     [ID_AD5611] = {
0398         .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 4),
0399         .write = ad5446_write,
0400     },
0401     [ID_AD5621] = {
0402         .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
0403         .write = ad5446_write,
0404     },
0405     [ID_AD5641] = {
0406         .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
0407         .write = ad5446_write,
0408     },
0409     [ID_AD5620_2500] = {
0410         .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
0411         .int_vref_mv = 2500,
0412         .write = ad5446_write,
0413     },
0414     [ID_AD5620_1250] = {
0415         .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
0416         .int_vref_mv = 1250,
0417         .write = ad5446_write,
0418     },
0419     [ID_AD5640_2500] = {
0420         .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
0421         .int_vref_mv = 2500,
0422         .write = ad5446_write,
0423     },
0424     [ID_AD5640_1250] = {
0425         .channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
0426         .int_vref_mv = 1250,
0427         .write = ad5446_write,
0428     },
0429     [ID_AD5660_2500] = {
0430         .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
0431         .int_vref_mv = 2500,
0432         .write = ad5660_write,
0433     },
0434     [ID_AD5660_1250] = {
0435         .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
0436         .int_vref_mv = 1250,
0437         .write = ad5660_write,
0438     },
0439     [ID_AD5662] = {
0440         .channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
0441         .write = ad5660_write,
0442     },
0443 };
0444 
0445 static const struct spi_device_id ad5446_spi_ids[] = {
0446     {"ad5300", ID_AD5300},
0447     {"ad5310", ID_AD5310},
0448     {"ad5320", ID_AD5320},
0449     {"ad5444", ID_AD5444},
0450     {"ad5446", ID_AD5446},
0451     {"ad5450", ID_AD5450},
0452     {"ad5451", ID_AD5451},
0453     {"ad5452", ID_AD5444}, /* ad5452 is compatible to the ad5444 */
0454     {"ad5453", ID_AD5446}, /* ad5453 is compatible to the ad5446 */
0455     {"ad5512a", ID_AD5512A},
0456     {"ad5541a", ID_AD5541A},
0457     {"ad5542a", ID_AD5541A}, /* ad5541a and ad5542a are compatible */
0458     {"ad5543", ID_AD5541A}, /* ad5541a and ad5543 are compatible */
0459     {"ad5553", ID_AD5553},
0460     {"ad5600", ID_AD5600},
0461     {"ad5601", ID_AD5601},
0462     {"ad5611", ID_AD5611},
0463     {"ad5621", ID_AD5621},
0464     {"ad5641", ID_AD5641},
0465     {"ad5620-2500", ID_AD5620_2500}, /* AD5620/40/60: */
0466     {"ad5620-1250", ID_AD5620_1250}, /* part numbers may look differently */
0467     {"ad5640-2500", ID_AD5640_2500},
0468     {"ad5640-1250", ID_AD5640_1250},
0469     {"ad5660-2500", ID_AD5660_2500},
0470     {"ad5660-1250", ID_AD5660_1250},
0471     {"ad5662", ID_AD5662},
0472     {"dac081s101", ID_AD5300}, /* compatible Texas Instruments chips */
0473     {"dac101s101", ID_AD5310},
0474     {"dac121s101", ID_AD5320},
0475     {"dac7512", ID_AD5320},
0476     {}
0477 };
0478 MODULE_DEVICE_TABLE(spi, ad5446_spi_ids);
0479 
0480 static const struct of_device_id ad5446_of_ids[] = {
0481     { .compatible = "ti,dac7512" },
0482     { }
0483 };
0484 MODULE_DEVICE_TABLE(of, ad5446_of_ids);
0485 
0486 static int ad5446_spi_probe(struct spi_device *spi)
0487 {
0488     const struct spi_device_id *id = spi_get_device_id(spi);
0489 
0490     return ad5446_probe(&spi->dev, id->name,
0491         &ad5446_spi_chip_info[id->driver_data]);
0492 }
0493 
0494 static void ad5446_spi_remove(struct spi_device *spi)
0495 {
0496     ad5446_remove(&spi->dev);
0497 }
0498 
0499 static struct spi_driver ad5446_spi_driver = {
0500     .driver = {
0501         .name   = "ad5446",
0502         .of_match_table = ad5446_of_ids,
0503     },
0504     .probe      = ad5446_spi_probe,
0505     .remove     = ad5446_spi_remove,
0506     .id_table   = ad5446_spi_ids,
0507 };
0508 
0509 static int __init ad5446_spi_register_driver(void)
0510 {
0511     return spi_register_driver(&ad5446_spi_driver);
0512 }
0513 
0514 static void ad5446_spi_unregister_driver(void)
0515 {
0516     spi_unregister_driver(&ad5446_spi_driver);
0517 }
0518 
0519 #else
0520 
0521 static inline int ad5446_spi_register_driver(void) { return 0; }
0522 static inline void ad5446_spi_unregister_driver(void) { }
0523 
0524 #endif
0525 
0526 #if IS_ENABLED(CONFIG_I2C)
0527 
0528 static int ad5622_write(struct ad5446_state *st, unsigned val)
0529 {
0530     struct i2c_client *client = to_i2c_client(st->dev);
0531     __be16 data = cpu_to_be16(val);
0532     int ret;
0533 
0534     ret = i2c_master_send(client, (char *)&data, sizeof(data));
0535     if (ret < 0)
0536         return ret;
0537     if (ret != sizeof(data))
0538         return -EIO;
0539 
0540     return 0;
0541 }
0542 
0543 /*
0544  * ad5446_supported_i2c_device_ids:
0545  * The AD5620/40/60 parts are available in different fixed internal reference
0546  * voltage options. The actual part numbers may look differently
0547  * (and a bit cryptic), however this style is used to make clear which
0548  * parts are supported here.
0549  */
0550 enum ad5446_supported_i2c_device_ids {
0551     ID_AD5602,
0552     ID_AD5612,
0553     ID_AD5622,
0554 };
0555 
0556 static const struct ad5446_chip_info ad5446_i2c_chip_info[] = {
0557     [ID_AD5602] = {
0558         .channel = AD5446_CHANNEL_POWERDOWN(8, 16, 4),
0559         .write = ad5622_write,
0560     },
0561     [ID_AD5612] = {
0562         .channel = AD5446_CHANNEL_POWERDOWN(10, 16, 2),
0563         .write = ad5622_write,
0564     },
0565     [ID_AD5622] = {
0566         .channel = AD5446_CHANNEL_POWERDOWN(12, 16, 0),
0567         .write = ad5622_write,
0568     },
0569 };
0570 
0571 static int ad5446_i2c_probe(struct i2c_client *i2c,
0572                 const struct i2c_device_id *id)
0573 {
0574     return ad5446_probe(&i2c->dev, id->name,
0575         &ad5446_i2c_chip_info[id->driver_data]);
0576 }
0577 
0578 static int ad5446_i2c_remove(struct i2c_client *i2c)
0579 {
0580     ad5446_remove(&i2c->dev);
0581 
0582     return 0;
0583 }
0584 
0585 static const struct i2c_device_id ad5446_i2c_ids[] = {
0586     {"ad5301", ID_AD5602},
0587     {"ad5311", ID_AD5612},
0588     {"ad5321", ID_AD5622},
0589     {"ad5602", ID_AD5602},
0590     {"ad5612", ID_AD5612},
0591     {"ad5622", ID_AD5622},
0592     {}
0593 };
0594 MODULE_DEVICE_TABLE(i2c, ad5446_i2c_ids);
0595 
0596 static struct i2c_driver ad5446_i2c_driver = {
0597     .driver = {
0598            .name = "ad5446",
0599     },
0600     .probe = ad5446_i2c_probe,
0601     .remove = ad5446_i2c_remove,
0602     .id_table = ad5446_i2c_ids,
0603 };
0604 
0605 static int __init ad5446_i2c_register_driver(void)
0606 {
0607     return i2c_add_driver(&ad5446_i2c_driver);
0608 }
0609 
0610 static void __exit ad5446_i2c_unregister_driver(void)
0611 {
0612     i2c_del_driver(&ad5446_i2c_driver);
0613 }
0614 
0615 #else
0616 
0617 static inline int ad5446_i2c_register_driver(void) { return 0; }
0618 static inline void ad5446_i2c_unregister_driver(void) { }
0619 
0620 #endif
0621 
0622 static int __init ad5446_init(void)
0623 {
0624     int ret;
0625 
0626     ret = ad5446_spi_register_driver();
0627     if (ret)
0628         return ret;
0629 
0630     ret = ad5446_i2c_register_driver();
0631     if (ret) {
0632         ad5446_spi_unregister_driver();
0633         return ret;
0634     }
0635 
0636     return 0;
0637 }
0638 module_init(ad5446_init);
0639 
0640 static void __exit ad5446_exit(void)
0641 {
0642     ad5446_i2c_unregister_driver();
0643     ad5446_spi_unregister_driver();
0644 }
0645 module_exit(ad5446_exit);
0646 
0647 MODULE_AUTHOR("Michael Hennerich <michael.hennerich@analog.com>");
0648 MODULE_DESCRIPTION("Analog Devices AD5444/AD5446 DAC");
0649 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!