iio/potentiometer/ad5110.c

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * Analog Devices AD5110 digital potentiometer driver
0004  *
0005  * Copyright (C) 2021 Mugilraj Dhavachelvan <dmugil2000@gmail.com>
0006  *
0007  * Datasheet: https://www.analog.com/media/en/technical-documentation/data-sheets/AD5110_5112_5114.pdf
0008  */
0009
0010 #include <linux/bitfield.h>
0011 #include <linux/delay.h>
0012 #include <linux/device.h>
0013 #include <linux/i2c.h>
0014 #include <linux/module.h>
0015
0016 #include <linux/iio/iio.h>
0017 #include <linux/iio/sysfs.h>
0018
0019 /* AD5110 commands */
0020 #define AD5110_EEPROM_WR    1
0021 #define AD5110_RDAC_WR      2
0022 #define AD5110_SHUTDOWN 3
0023 #define AD5110_RESET        4
0024 #define AD5110_RDAC_RD      5
0025 #define AD5110_EEPROM_RD    6
0026
0027 /* AD5110_EEPROM_RD data */
0028 #define AD5110_WIPER_POS    0
0029 #define AD5110_RESISTOR_TOL 1
0030
0031 #define AD5110_WIPER_RESISTANCE 70
0032
0033 struct ad5110_cfg {
0034     int max_pos;
0035     int kohms;
0036     int shift;
0037 };
0038
0039 enum ad5110_type {
0040     AD5110_10,
0041     AD5110_80,
0042     AD5112_05,
0043     AD5112_10,
0044     AD5112_80,
0045     AD5114_10,
0046     AD5114_80,
0047 };
0048
0049 static const struct ad5110_cfg ad5110_cfg[] = {
0050     [AD5110_10] = { .max_pos = 128, .kohms = 10 },
0051     [AD5110_80] = { .max_pos = 128, .kohms = 80 },
0052     [AD5112_05] = { .max_pos = 64, .kohms = 5, .shift = 1 },
0053     [AD5112_10] = { .max_pos = 64, .kohms = 10, .shift = 1 },
0054     [AD5112_80] = { .max_pos = 64, .kohms = 80, .shift = 1 },
0055     [AD5114_10] = { .max_pos = 32, .kohms = 10, .shift = 2 },
0056     [AD5114_80] = { .max_pos = 32, .kohms = 80, .shift = 2 },
0057 };
0058
0059 struct ad5110_data {
0060     struct i2c_client       *client;
0061     s16         tol;        /* resistor tolerance */
0062     bool            enable;
0063     struct mutex            lock;
0064     const struct ad5110_cfg *cfg;
0065     /*
0066      * DMA (thus cache coherency maintenance) may require the
0067      * transfer buffers to live in their own cache lines.
0068      */
0069     u8          buf[2] __aligned(IIO_DMA_MINALIGN);
0070 };
0071
0072 static const struct iio_chan_spec ad5110_channels[] = {
0073     {
0074         .type = IIO_RESISTANCE,
0075         .output = 1,
0076         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_OFFSET) |
0077                     BIT(IIO_CHAN_INFO_SCALE) | BIT(IIO_CHAN_INFO_ENABLE),
0078     },
0079 };
0080
0081 static int ad5110_read(struct ad5110_data *data, u8 cmd, int *val)
0082 {
0083     int ret;
0084
0085     mutex_lock(&data->lock);
0086     data->buf[0] = cmd;
0087     data->buf[1] = *val;
0088
0089     ret = i2c_master_send_dmasafe(data->client, data->buf, sizeof(data->buf));
0090     if (ret < 0) {
0091         goto error;
0092     } else if (ret != sizeof(data->buf)) {
0093         ret = -EIO;
0094         goto error;
0095     }
0096
0097     ret = i2c_master_recv_dmasafe(data->client, data->buf, 1);
0098     if (ret < 0) {
0099         goto error;
0100     } else if (ret != 1) {
0101         ret = -EIO;
0102         goto error;
0103     }
0104
0105     *val = data->buf[0];
0106     ret = 0;
0107
0108 error:
0109     mutex_unlock(&data->lock);
0110     return ret;
0111 }
0112
0113 static int ad5110_write(struct ad5110_data *data, u8 cmd, u8 val)
0114 {
0115     int ret;
0116
0117     mutex_lock(&data->lock);
0118     data->buf[0] = cmd;
0119     data->buf[1] = val;
0120
0121     ret = i2c_master_send_dmasafe(data->client, data->buf, sizeof(data->buf));
0122     if (ret < 0) {
0123         goto error;
0124     } else if (ret != sizeof(data->buf)) {
0125         ret = -EIO;
0126         goto error;
0127     }
0128
0129     ret = 0;
0130
0131 error:
0132     mutex_unlock(&data->lock);
0133     return ret;
0134 }
0135
0136 static int ad5110_resistor_tol(struct ad5110_data *data, u8 cmd, int val)
0137 {
0138     int ret;
0139
0140     ret = ad5110_read(data, cmd, &val);
0141     if (ret)
0142         return ret;
0143
0144     data->tol = data->cfg->kohms * (val & GENMASK(6, 0)) * 10 / 8;
0145     if (!(val & BIT(7)))
0146         data->tol *= -1;
0147
0148     return 0;
0149 }
0150
0151 static ssize_t store_eeprom_show(struct device *dev,
0152                   struct device_attribute *attr,
0153                   char *buf)
0154 {
0155     struct iio_dev *indio_dev = dev_to_iio_dev(dev);
0156     struct ad5110_data *data = iio_priv(indio_dev);
0157     int val = AD5110_WIPER_POS;
0158     int ret;
0159
0160     ret = ad5110_read(data, AD5110_EEPROM_RD, &val);
0161     if (ret)
0162         return ret;
0163
0164     val = val >> data->cfg->shift;
0165     return iio_format_value(buf, IIO_VAL_INT, 1, &val);
0166 }
0167
0168 static ssize_t store_eeprom_store(struct device *dev,
0169                    struct device_attribute *attr,
0170                    const char *buf, size_t len)
0171 {
0172     struct iio_dev *indio_dev = dev_to_iio_dev(dev);
0173     struct ad5110_data *data = iio_priv(indio_dev);
0174     int ret;
0175
0176     ret = ad5110_write(data, AD5110_EEPROM_WR, 0);
0177     if (ret) {
0178         dev_err(&data->client->dev, "RDAC to EEPROM write failed\n");
0179         return ret;
0180     }
0181
0182     /* The storing of EEPROM data takes approximately 18 ms. */
0183     msleep(20);
0184
0185     return len;
0186 }
0187
0188 static IIO_DEVICE_ATTR_RW(store_eeprom, 0);
0189
0190 static struct attribute *ad5110_attributes[] = {
0191     &iio_dev_attr_store_eeprom.dev_attr.attr,
0192     NULL
0193 };
0194
0195 static const struct attribute_group ad5110_attribute_group = {
0196     .attrs = ad5110_attributes,
0197 };
0198
0199 static int ad5110_read_raw(struct iio_dev *indio_dev,
0200                struct iio_chan_spec const *chan,
0201                int *val, int *val2, long mask)
0202 {
0203     struct ad5110_data *data = iio_priv(indio_dev);
0204     int ret;
0205
0206     switch (mask) {
0207     case IIO_CHAN_INFO_RAW:
0208         ret = ad5110_read(data, AD5110_RDAC_RD, val);
0209         if (ret)
0210             return ret;
0211
0212         *val = *val >> data->cfg->shift;
0213         return IIO_VAL_INT;
0214     case IIO_CHAN_INFO_OFFSET:
0215         *val = AD5110_WIPER_RESISTANCE * data->cfg->max_pos;
0216         *val2 = 1000 * data->cfg->kohms + data->tol;
0217         return IIO_VAL_FRACTIONAL;
0218     case IIO_CHAN_INFO_SCALE:
0219         *val = 1000 * data->cfg->kohms + data->tol;
0220         *val2 = data->cfg->max_pos;
0221         return IIO_VAL_FRACTIONAL;
0222     case IIO_CHAN_INFO_ENABLE:
0223         *val = data->enable;
0224         return IIO_VAL_INT;
0225     default:
0226         return -EINVAL;
0227     }
0228 }
0229
0230 static int ad5110_write_raw(struct iio_dev *indio_dev,
0231                 struct iio_chan_spec const *chan,
0232                 int val, int val2, long mask)
0233 {
0234     struct ad5110_data *data = iio_priv(indio_dev);
0235     int ret;
0236
0237     switch (mask) {
0238     case IIO_CHAN_INFO_RAW:
0239         if (val > data->cfg->max_pos || val < 0)
0240             return -EINVAL;
0241
0242         return ad5110_write(data, AD5110_RDAC_WR, val << data->cfg->shift);
0243     case IIO_CHAN_INFO_ENABLE:
0244         if (val < 0 || val > 1)
0245             return -EINVAL;
0246         if (data->enable == val)
0247             return 0;
0248         ret = ad5110_write(data, AD5110_SHUTDOWN, val ? 0 : 1);
0249         if (ret)
0250             return ret;
0251         data->enable = val;
0252         return 0;
0253     default:
0254         return -EINVAL;
0255     }
0256 }
0257
0258 static const struct iio_info ad5110_info = {
0259     .read_raw = ad5110_read_raw,
0260     .write_raw = ad5110_write_raw,
0261     .attrs = &ad5110_attribute_group,
0262 };
0263
0264 #define AD5110_COMPATIBLE(of_compatible, cfg) { \
0265             .compatible = of_compatible,    \
0266             .data = &ad5110_cfg[cfg],   \
0267 }
0268
0269 static const struct of_device_id ad5110_of_match[] = {
0270     AD5110_COMPATIBLE("adi,ad5110-10", AD5110_10),
0271     AD5110_COMPATIBLE("adi,ad5110-80", AD5110_80),
0272     AD5110_COMPATIBLE("adi,ad5112-05", AD5112_05),
0273     AD5110_COMPATIBLE("adi,ad5112-10", AD5112_10),
0274     AD5110_COMPATIBLE("adi,ad5112-80", AD5112_80),
0275     AD5110_COMPATIBLE("adi,ad5114-10", AD5114_10),
0276     AD5110_COMPATIBLE("adi,ad5114-80", AD5114_80),
0277     { }
0278 };
0279 MODULE_DEVICE_TABLE(of, ad5110_of_match);
0280
0281 static const struct i2c_device_id ad5110_id[] = {
0282     { "ad5110-10", AD5110_10 },
0283     { "ad5110-80", AD5110_80 },
0284     { "ad5112-05", AD5112_05 },
0285     { "ad5112-10", AD5112_10 },
0286     { "ad5112-80", AD5112_80 },
0287     { "ad5114-10", AD5114_10 },
0288     { "ad5114-80", AD5114_80 },
0289     { }
0290 };
0291 MODULE_DEVICE_TABLE(i2c, ad5110_id);
0292
0293 static int ad5110_probe(struct i2c_client *client)
0294 {
0295     struct device *dev = &client->dev;
0296     struct iio_dev *indio_dev;
0297     struct ad5110_data *data;
0298     int ret;
0299
0300     indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
0301     if (!indio_dev)
0302         return -ENOMEM;
0303
0304     data = iio_priv(indio_dev);
0305     data->client = client;
0306     mutex_init(&data->lock);
0307     data->enable = 1;
0308     data->cfg = device_get_match_data(dev);
0309
0310     /* refresh RDAC register with EEPROM */
0311     ret = ad5110_write(data, AD5110_RESET, 0);
0312     if (ret) {
0313         dev_err(dev, "Refresh RDAC with EEPROM failed\n");
0314         return ret;
0315     }
0316
0317     ret = ad5110_resistor_tol(data, AD5110_EEPROM_RD, AD5110_RESISTOR_TOL);
0318     if (ret) {
0319         dev_err(dev, "Read resistor tolerance failed\n");
0320         return ret;
0321     }
0322
0323     indio_dev->modes = INDIO_DIRECT_MODE;
0324     indio_dev->info = &ad5110_info;
0325     indio_dev->channels = ad5110_channels;
0326     indio_dev->num_channels = ARRAY_SIZE(ad5110_channels);
0327     indio_dev->name = client->name;
0328
0329     return devm_iio_device_register(dev, indio_dev);
0330 }
0331
0332 static struct i2c_driver ad5110_driver = {
0333     .driver = {
0334         .name   = "ad5110",
0335         .of_match_table = ad5110_of_match,
0336     },
0337     .probe_new  = ad5110_probe,
0338     .id_table   = ad5110_id,
0339 };
0340 module_i2c_driver(ad5110_driver);
0341
0342 MODULE_AUTHOR("Mugilraj Dhavachelvan <dmugil2000@gmail.com>");
0343 MODULE_DESCRIPTION("AD5110 digital potentiometer");
0344 MODULE_LICENSE("GPL v2");