iio/dac/ad8801.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * IIO DAC driver for Analog Devices AD8801 DAC
0004  *
0005  * Copyright (C) 2016 Gwenhael Goavec-Merou
0006  */
0007
0008 #include <linux/iio/iio.h>
0009 #include <linux/module.h>
0010 #include <linux/regulator/consumer.h>
0011 #include <linux/spi/spi.h>
0012 #include <linux/sysfs.h>
0013
0014 #define AD8801_CFG_ADDR_OFFSET 8
0015
0016 enum ad8801_device_ids {
0017     ID_AD8801,
0018     ID_AD8803,
0019 };
0020
0021 struct ad8801_state {
0022     struct spi_device *spi;
0023     unsigned char dac_cache[8]; /* Value write on each channel */
0024     unsigned int vrefh_mv;
0025     unsigned int vrefl_mv;
0026     struct regulator *vrefh_reg;
0027     struct regulator *vrefl_reg;
0028
0029     __be16 data __aligned(IIO_DMA_MINALIGN);
0030 };
0031
0032 static int ad8801_spi_write(struct ad8801_state *state,
0033     u8 channel, unsigned char value)
0034 {
0035     state->data = cpu_to_be16((channel << AD8801_CFG_ADDR_OFFSET) | value);
0036     return spi_write(state->spi, &state->data, sizeof(state->data));
0037 }
0038
0039 static int ad8801_write_raw(struct iio_dev *indio_dev,
0040     struct iio_chan_spec const *chan, int val, int val2, long mask)
0041 {
0042     struct ad8801_state *state = iio_priv(indio_dev);
0043     int ret;
0044
0045     switch (mask) {
0046     case IIO_CHAN_INFO_RAW:
0047         if (val >= 256 || val < 0)
0048             return -EINVAL;
0049
0050         ret = ad8801_spi_write(state, chan->channel, val);
0051         if (ret == 0)
0052             state->dac_cache[chan->channel] = val;
0053         break;
0054     default:
0055         ret = -EINVAL;
0056     }
0057
0058     return ret;
0059 }
0060
0061 static int ad8801_read_raw(struct iio_dev *indio_dev,
0062     struct iio_chan_spec const *chan, int *val, int *val2, long info)
0063 {
0064     struct ad8801_state *state = iio_priv(indio_dev);
0065
0066     switch (info) {
0067     case IIO_CHAN_INFO_RAW:
0068         *val = state->dac_cache[chan->channel];
0069         return IIO_VAL_INT;
0070     case IIO_CHAN_INFO_SCALE:
0071         *val = state->vrefh_mv - state->vrefl_mv;
0072         *val2 = 8;
0073         return IIO_VAL_FRACTIONAL_LOG2;
0074     case IIO_CHAN_INFO_OFFSET:
0075         *val = state->vrefl_mv;
0076         return IIO_VAL_INT;
0077     default:
0078         return -EINVAL;
0079     }
0080
0081     return -EINVAL;
0082 }
0083
0084 static const struct iio_info ad8801_info = {
0085     .read_raw = ad8801_read_raw,
0086     .write_raw = ad8801_write_raw,
0087 };
0088
0089 #define AD8801_CHANNEL(chan) {      \
0090     .type = IIO_VOLTAGE,            \
0091     .indexed = 1,               \
0092     .output = 1,                \
0093     .channel = chan,            \
0094     .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
0095     .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |  \
0096         BIT(IIO_CHAN_INFO_OFFSET), \
0097 }
0098
0099 static const struct iio_chan_spec ad8801_channels[] = {
0100     AD8801_CHANNEL(0),
0101     AD8801_CHANNEL(1),
0102     AD8801_CHANNEL(2),
0103     AD8801_CHANNEL(3),
0104     AD8801_CHANNEL(4),
0105     AD8801_CHANNEL(5),
0106     AD8801_CHANNEL(6),
0107     AD8801_CHANNEL(7),
0108 };
0109
0110 static int ad8801_probe(struct spi_device *spi)
0111 {
0112     struct iio_dev *indio_dev;
0113     struct ad8801_state *state;
0114     const struct spi_device_id *id;
0115     int ret;
0116
0117     indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*state));
0118     if (indio_dev == NULL)
0119         return -ENOMEM;
0120
0121     state = iio_priv(indio_dev);
0122     state->spi = spi;
0123     id = spi_get_device_id(spi);
0124
0125     state->vrefh_reg = devm_regulator_get(&spi->dev, "vrefh");
0126     if (IS_ERR(state->vrefh_reg))
0127         return dev_err_probe(&spi->dev, PTR_ERR(state->vrefh_reg),
0128                      "Vrefh regulator not specified\n");
0129
0130     ret = regulator_enable(state->vrefh_reg);
0131     if (ret) {
0132         dev_err(&spi->dev, "Failed to enable vrefh regulator: %d\n",
0133                 ret);
0134         return ret;
0135     }
0136
0137     ret = regulator_get_voltage(state->vrefh_reg);
0138     if (ret < 0) {
0139         dev_err(&spi->dev, "Failed to read vrefh regulator: %d\n",
0140                 ret);
0141         goto error_disable_vrefh_reg;
0142     }
0143     state->vrefh_mv = ret / 1000;
0144
0145     if (id->driver_data == ID_AD8803) {
0146         state->vrefl_reg = devm_regulator_get(&spi->dev, "vrefl");
0147         if (IS_ERR(state->vrefl_reg)) {
0148             ret = dev_err_probe(&spi->dev, PTR_ERR(state->vrefl_reg),
0149                         "Vrefl regulator not specified\n");
0150             goto error_disable_vrefh_reg;
0151         }
0152
0153         ret = regulator_enable(state->vrefl_reg);
0154         if (ret) {
0155             dev_err(&spi->dev, "Failed to enable vrefl regulator: %d\n",
0156                     ret);
0157             goto error_disable_vrefh_reg;
0158         }
0159
0160         ret = regulator_get_voltage(state->vrefl_reg);
0161         if (ret < 0) {
0162             dev_err(&spi->dev, "Failed to read vrefl regulator: %d\n",
0163                     ret);
0164             goto error_disable_vrefl_reg;
0165         }
0166         state->vrefl_mv = ret / 1000;
0167     } else {
0168         state->vrefl_mv = 0;
0169         state->vrefl_reg = NULL;
0170     }
0171
0172     spi_set_drvdata(spi, indio_dev);
0173     indio_dev->info = &ad8801_info;
0174     indio_dev->modes = INDIO_DIRECT_MODE;
0175     indio_dev->channels = ad8801_channels;
0176     indio_dev->num_channels = ARRAY_SIZE(ad8801_channels);
0177     indio_dev->name = id->name;
0178
0179     ret = iio_device_register(indio_dev);
0180     if (ret) {
0181         dev_err(&spi->dev, "Failed to register iio device: %d\n",
0182                 ret);
0183         goto error_disable_vrefl_reg;
0184     }
0185
0186     return 0;
0187
0188 error_disable_vrefl_reg:
0189     if (state->vrefl_reg)
0190         regulator_disable(state->vrefl_reg);
0191 error_disable_vrefh_reg:
0192     regulator_disable(state->vrefh_reg);
0193     return ret;
0194 }
0195
0196 static void ad8801_remove(struct spi_device *spi)
0197 {
0198     struct iio_dev *indio_dev = spi_get_drvdata(spi);
0199     struct ad8801_state *state = iio_priv(indio_dev);
0200
0201     iio_device_unregister(indio_dev);
0202     if (state->vrefl_reg)
0203         regulator_disable(state->vrefl_reg);
0204     regulator_disable(state->vrefh_reg);
0205 }
0206
0207 static const struct spi_device_id ad8801_ids[] = {
0208     {"ad8801", ID_AD8801},
0209     {"ad8803", ID_AD8803},
0210     {}
0211 };
0212 MODULE_DEVICE_TABLE(spi, ad8801_ids);
0213
0214 static struct spi_driver ad8801_driver = {
0215     .driver = {
0216         .name   = "ad8801",
0217     },
0218     .probe      = ad8801_probe,
0219     .remove     = ad8801_remove,
0220     .id_table   = ad8801_ids,
0221 };
0222 module_spi_driver(ad8801_driver);
0223
0224 MODULE_AUTHOR("Gwenhael Goavec-Merou <gwenhael.goavec-merou@trabucayre.com>");
0225 MODULE_DESCRIPTION("Analog Devices AD8801/AD8803 DAC");
0226 MODULE_LICENSE("GPL v2");