iio/dac/ad5504.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * AD5504, AD5501 High Voltage Digital to Analog Converter
0004  *
0005  * Copyright 2011 Analog Devices Inc.
0006  */
0007
0008 #include <linux/interrupt.h>
0009 #include <linux/fs.h>
0010 #include <linux/device.h>
0011 #include <linux/kernel.h>
0012 #include <linux/spi/spi.h>
0013 #include <linux/slab.h>
0014 #include <linux/sysfs.h>
0015 #include <linux/regulator/consumer.h>
0016 #include <linux/module.h>
0017 #include <linux/bitops.h>
0018
0019 #include <linux/iio/iio.h>
0020 #include <linux/iio/sysfs.h>
0021 #include <linux/iio/events.h>
0022 #include <linux/iio/dac/ad5504.h>
0023
0024 #define AD5504_RES_MASK         GENMASK(11, 0)
0025 #define AD5504_CMD_READ         BIT(15)
0026 #define AD5504_CMD_WRITE        0
0027 #define AD5504_ADDR(addr)       ((addr) << 12)
0028
0029 /* Registers */
0030 #define AD5504_ADDR_NOOP        0
0031 #define AD5504_ADDR_DAC(x)      ((x) + 1)
0032 #define AD5504_ADDR_ALL_DAC     5
0033 #define AD5504_ADDR_CTRL        7
0034
0035 /* Control Register */
0036 #define AD5504_DAC_PWR(ch)      ((ch) << 2)
0037 #define AD5504_DAC_PWRDWN_MODE(mode)    ((mode) << 6)
0038 #define AD5504_DAC_PWRDN_20K        0
0039 #define AD5504_DAC_PWRDN_3STATE     1
0040
0041 /**
0042  * struct ad5504_state - driver instance specific data
0043  * @spi:            spi_device
0044  * @reg:        supply regulator
0045  * @vref_mv:        actual reference voltage used
0046  * @pwr_down_mask:  power down mask
0047  * @pwr_down_mode:  current power down mode
0048  * @data:       transfer buffer
0049  */
0050 struct ad5504_state {
0051     struct spi_device       *spi;
0052     struct regulator        *reg;
0053     unsigned short          vref_mv;
0054     unsigned            pwr_down_mask;
0055     unsigned            pwr_down_mode;
0056
0057     __be16              data[2] __aligned(IIO_DMA_MINALIGN);
0058 };
0059
0060 /*
0061  * ad5504_supported_device_ids:
0062  */
0063 enum ad5504_supported_device_ids {
0064     ID_AD5504,
0065     ID_AD5501,
0066 };
0067
0068 static int ad5504_spi_write(struct ad5504_state *st, u8 addr, u16 val)
0069 {
0070     st->data[0] = cpu_to_be16(AD5504_CMD_WRITE | AD5504_ADDR(addr) |
0071                   (val & AD5504_RES_MASK));
0072
0073     return spi_write(st->spi, &st->data[0], 2);
0074 }
0075
0076 static int ad5504_spi_read(struct ad5504_state *st, u8 addr)
0077 {
0078     int ret;
0079     struct spi_transfer t = {
0080         .tx_buf = &st->data[0],
0081         .rx_buf = &st->data[1],
0082         .len = 2,
0083     };
0084
0085     st->data[0] = cpu_to_be16(AD5504_CMD_READ | AD5504_ADDR(addr));
0086     ret = spi_sync_transfer(st->spi, &t, 1);
0087     if (ret < 0)
0088         return ret;
0089
0090     return be16_to_cpu(st->data[1]) & AD5504_RES_MASK;
0091 }
0092
0093 static int ad5504_read_raw(struct iio_dev *indio_dev,
0094                struct iio_chan_spec const *chan,
0095                int *val,
0096                int *val2,
0097                long m)
0098 {
0099     struct ad5504_state *st = iio_priv(indio_dev);
0100     int ret;
0101
0102     switch (m) {
0103     case IIO_CHAN_INFO_RAW:
0104         ret = ad5504_spi_read(st, chan->address);
0105         if (ret < 0)
0106             return ret;
0107
0108         *val = ret;
0109
0110         return IIO_VAL_INT;
0111     case IIO_CHAN_INFO_SCALE:
0112         *val = st->vref_mv;
0113         *val2 = chan->scan_type.realbits;
0114         return IIO_VAL_FRACTIONAL_LOG2;
0115     }
0116     return -EINVAL;
0117 }
0118
0119 static int ad5504_write_raw(struct iio_dev *indio_dev,
0120                    struct iio_chan_spec const *chan,
0121                    int val,
0122                    int val2,
0123                    long mask)
0124 {
0125     struct ad5504_state *st = iio_priv(indio_dev);
0126
0127     switch (mask) {
0128     case IIO_CHAN_INFO_RAW:
0129         if (val >= (1 << chan->scan_type.realbits) || val < 0)
0130             return -EINVAL;
0131
0132         return ad5504_spi_write(st, chan->address, val);
0133     default:
0134         return -EINVAL;
0135     }
0136 }
0137
0138 static const char * const ad5504_powerdown_modes[] = {
0139     "20kohm_to_gnd",
0140     "three_state",
0141 };
0142
0143 static int ad5504_get_powerdown_mode(struct iio_dev *indio_dev,
0144     const struct iio_chan_spec *chan)
0145 {
0146     struct ad5504_state *st = iio_priv(indio_dev);
0147
0148     return st->pwr_down_mode;
0149 }
0150
0151 static int ad5504_set_powerdown_mode(struct iio_dev *indio_dev,
0152     const struct iio_chan_spec *chan, unsigned int mode)
0153 {
0154     struct ad5504_state *st = iio_priv(indio_dev);
0155
0156     st->pwr_down_mode = mode;
0157
0158     return 0;
0159 }
0160
0161 static const struct iio_enum ad5504_powerdown_mode_enum = {
0162     .items = ad5504_powerdown_modes,
0163     .num_items = ARRAY_SIZE(ad5504_powerdown_modes),
0164     .get = ad5504_get_powerdown_mode,
0165     .set = ad5504_set_powerdown_mode,
0166 };
0167
0168 static ssize_t ad5504_read_dac_powerdown(struct iio_dev *indio_dev,
0169     uintptr_t private, const struct iio_chan_spec *chan, char *buf)
0170 {
0171     struct ad5504_state *st = iio_priv(indio_dev);
0172
0173     return sysfs_emit(buf, "%d\n",
0174               !(st->pwr_down_mask & (1 << chan->channel)));
0175 }
0176
0177 static ssize_t ad5504_write_dac_powerdown(struct iio_dev *indio_dev,
0178     uintptr_t private, const struct iio_chan_spec *chan, const char *buf,
0179     size_t len)
0180 {
0181     bool pwr_down;
0182     int ret;
0183     struct ad5504_state *st = iio_priv(indio_dev);
0184
0185     ret = kstrtobool(buf, &pwr_down);
0186     if (ret)
0187         return ret;
0188
0189     if (pwr_down)
0190         st->pwr_down_mask &= ~(1 << chan->channel);
0191     else
0192         st->pwr_down_mask |= (1 << chan->channel);
0193
0194     ret = ad5504_spi_write(st, AD5504_ADDR_CTRL,
0195                 AD5504_DAC_PWRDWN_MODE(st->pwr_down_mode) |
0196                 AD5504_DAC_PWR(st->pwr_down_mask));
0197
0198     /* writes to the CTRL register must be followed by a NOOP */
0199     ad5504_spi_write(st, AD5504_ADDR_NOOP, 0);
0200
0201     return ret ? ret : len;
0202 }
0203
0204 static IIO_CONST_ATTR(temp0_thresh_rising_value, "110000");
0205 static IIO_CONST_ATTR(temp0_thresh_rising_en, "1");
0206
0207 static struct attribute *ad5504_ev_attributes[] = {
0208     &iio_const_attr_temp0_thresh_rising_value.dev_attr.attr,
0209     &iio_const_attr_temp0_thresh_rising_en.dev_attr.attr,
0210     NULL,
0211 };
0212
0213 static const struct attribute_group ad5504_ev_attribute_group = {
0214     .attrs = ad5504_ev_attributes,
0215 };
0216
0217 static irqreturn_t ad5504_event_handler(int irq, void *private)
0218 {
0219     iio_push_event(private,
0220                IIO_UNMOD_EVENT_CODE(IIO_TEMP,
0221                         0,
0222                         IIO_EV_TYPE_THRESH,
0223                         IIO_EV_DIR_RISING),
0224                iio_get_time_ns(private));
0225
0226     return IRQ_HANDLED;
0227 }
0228
0229 static const struct iio_info ad5504_info = {
0230     .write_raw = ad5504_write_raw,
0231     .read_raw = ad5504_read_raw,
0232     .event_attrs = &ad5504_ev_attribute_group,
0233 };
0234
0235 static const struct iio_chan_spec_ext_info ad5504_ext_info[] = {
0236     {
0237         .name = "powerdown",
0238         .read = ad5504_read_dac_powerdown,
0239         .write = ad5504_write_dac_powerdown,
0240         .shared = IIO_SEPARATE,
0241     },
0242     IIO_ENUM("powerdown_mode", IIO_SHARED_BY_TYPE,
0243          &ad5504_powerdown_mode_enum),
0244     IIO_ENUM_AVAILABLE("powerdown_mode", IIO_SHARED_BY_TYPE, &ad5504_powerdown_mode_enum),
0245     { },
0246 };
0247
0248 #define AD5504_CHANNEL(_chan) { \
0249     .type = IIO_VOLTAGE, \
0250     .indexed = 1, \
0251     .output = 1, \
0252     .channel = (_chan), \
0253     .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
0254     .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
0255     .address = AD5504_ADDR_DAC(_chan), \
0256     .scan_type = { \
0257         .sign = 'u', \
0258         .realbits = 12, \
0259         .storagebits = 16, \
0260     }, \
0261     .ext_info = ad5504_ext_info, \
0262 }
0263
0264 static const struct iio_chan_spec ad5504_channels[] = {
0265     AD5504_CHANNEL(0),
0266     AD5504_CHANNEL(1),
0267     AD5504_CHANNEL(2),
0268     AD5504_CHANNEL(3),
0269 };
0270
0271 static int ad5504_probe(struct spi_device *spi)
0272 {
0273     struct ad5504_platform_data *pdata = spi->dev.platform_data;
0274     struct iio_dev *indio_dev;
0275     struct ad5504_state *st;
0276     struct regulator *reg;
0277     int ret, voltage_uv = 0;
0278
0279     indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
0280     if (!indio_dev)
0281         return -ENOMEM;
0282     reg = devm_regulator_get(&spi->dev, "vcc");
0283     if (!IS_ERR(reg)) {
0284         ret = regulator_enable(reg);
0285         if (ret)
0286             return ret;
0287
0288         ret = regulator_get_voltage(reg);
0289         if (ret < 0)
0290             goto error_disable_reg;
0291
0292         voltage_uv = ret;
0293     }
0294
0295     spi_set_drvdata(spi, indio_dev);
0296     st = iio_priv(indio_dev);
0297     if (voltage_uv)
0298         st->vref_mv = voltage_uv / 1000;
0299     else if (pdata)
0300         st->vref_mv = pdata->vref_mv;
0301     else
0302         dev_warn(&spi->dev, "reference voltage unspecified\n");
0303
0304     st->reg = reg;
0305     st->spi = spi;
0306     indio_dev->name = spi_get_device_id(st->spi)->name;
0307     indio_dev->info = &ad5504_info;
0308     if (spi_get_device_id(st->spi)->driver_data == ID_AD5501)
0309         indio_dev->num_channels = 1;
0310     else
0311         indio_dev->num_channels = 4;
0312     indio_dev->channels = ad5504_channels;
0313     indio_dev->modes = INDIO_DIRECT_MODE;
0314
0315     if (spi->irq) {
0316         ret = devm_request_threaded_irq(&spi->dev, spi->irq,
0317                        NULL,
0318                        &ad5504_event_handler,
0319                        IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
0320                        spi_get_device_id(st->spi)->name,
0321                        indio_dev);
0322         if (ret)
0323             goto error_disable_reg;
0324     }
0325
0326     ret = iio_device_register(indio_dev);
0327     if (ret)
0328         goto error_disable_reg;
0329
0330     return 0;
0331
0332 error_disable_reg:
0333     if (!IS_ERR(reg))
0334         regulator_disable(reg);
0335
0336     return ret;
0337 }
0338
0339 static void ad5504_remove(struct spi_device *spi)
0340 {
0341     struct iio_dev *indio_dev = spi_get_drvdata(spi);
0342     struct ad5504_state *st = iio_priv(indio_dev);
0343
0344     iio_device_unregister(indio_dev);
0345
0346     if (!IS_ERR(st->reg))
0347         regulator_disable(st->reg);
0348 }
0349
0350 static const struct spi_device_id ad5504_id[] = {
0351     {"ad5504", ID_AD5504},
0352     {"ad5501", ID_AD5501},
0353     {}
0354 };
0355 MODULE_DEVICE_TABLE(spi, ad5504_id);
0356
0357 static struct spi_driver ad5504_driver = {
0358     .driver = {
0359            .name = "ad5504",
0360            },
0361     .probe = ad5504_probe,
0362     .remove = ad5504_remove,
0363     .id_table = ad5504_id,
0364 };
0365 module_spi_driver(ad5504_driver);
0366
0367 MODULE_AUTHOR("Michael Hennerich <michael.hennerich@analog.com>");
0368 MODULE_DESCRIPTION("Analog Devices AD5501/AD5501 DAC");
0369 MODULE_LICENSE("GPL v2");