iio/potentiometer/ds1803.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Maxim Integrated DS1803 and similar digital potentiometer driver
0004  * Copyright (c) 2016 Slawomir Stepien
0005  * Copyright (c) 2022 Jagath Jog J
0006  *
0007  * Datasheet: https://datasheets.maximintegrated.com/en/ds/DS1803.pdf
0008  * Datasheet: https://datasheets.maximintegrated.com/en/ds/DS3502.pdf
0009  *
0010  * DEVID    #Wipers #Positions  Resistor Opts (kOhm)    i2c address
0011  * ds1803   2   256     10, 50, 100     0101xxx
0012  * ds3502   1   128     10          01010xx
0013  */
0014
0015 #include <linux/err.h>
0016 #include <linux/export.h>
0017 #include <linux/i2c.h>
0018 #include <linux/iio/iio.h>
0019 #include <linux/module.h>
0020 #include <linux/mod_devicetable.h>
0021 #include <linux/property.h>
0022
0023 #define DS1803_WIPER_0         0xA9
0024 #define DS1803_WIPER_1         0xAA
0025 #define DS3502_WR_IVR          0x00
0026
0027 enum ds1803_type {
0028     DS1803_010,
0029     DS1803_050,
0030     DS1803_100,
0031     DS3502,
0032 };
0033
0034 struct ds1803_cfg {
0035     int wipers;
0036     int avail[3];
0037     int kohms;
0038     const struct iio_chan_spec *channels;
0039     u8 num_channels;
0040     int (*read)(struct iio_dev *indio_dev,
0041             struct iio_chan_spec const *chan, int *val);
0042 };
0043
0044 struct ds1803_data {
0045     struct i2c_client *client;
0046     const struct ds1803_cfg *cfg;
0047 };
0048
0049 #define DS1803_CHANNEL(ch, addr) {                  \
0050     .type = IIO_RESISTANCE,                     \
0051     .indexed = 1,                           \
0052     .output = 1,                            \
0053     .channel = (ch),                        \
0054     .address = (addr),                      \
0055     .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),           \
0056     .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),       \
0057     .info_mask_shared_by_type_available = BIT(IIO_CHAN_INFO_RAW),   \
0058 }
0059
0060 static const struct iio_chan_spec ds1803_channels[] = {
0061     DS1803_CHANNEL(0, DS1803_WIPER_0),
0062     DS1803_CHANNEL(1, DS1803_WIPER_1),
0063 };
0064
0065 static const struct iio_chan_spec ds3502_channels[] = {
0066     DS1803_CHANNEL(0, DS3502_WR_IVR),
0067 };
0068
0069 static int ds1803_read(struct iio_dev *indio_dev,
0070                struct iio_chan_spec const *chan,
0071                int *val)
0072 {
0073     struct ds1803_data *data = iio_priv(indio_dev);
0074     int ret;
0075     u8 result[ARRAY_SIZE(ds1803_channels)];
0076
0077     ret = i2c_master_recv(data->client, result, indio_dev->num_channels);
0078     if (ret < 0)
0079         return ret;
0080
0081     *val = result[chan->channel];
0082     return ret;
0083 }
0084
0085 static int ds3502_read(struct iio_dev *indio_dev,
0086                struct iio_chan_spec const *chan,
0087                int *val)
0088 {
0089     struct ds1803_data *data = iio_priv(indio_dev);
0090     int ret;
0091
0092     ret = i2c_smbus_read_byte_data(data->client, chan->address);
0093     if (ret < 0)
0094         return ret;
0095
0096     *val = ret;
0097     return ret;
0098 }
0099
0100 static const struct ds1803_cfg ds1803_cfg[] = {
0101     [DS1803_010] = {
0102         .wipers = 2,
0103         .avail = { 0, 1, 255 },
0104         .kohms =  10,
0105         .channels = ds1803_channels,
0106         .num_channels = ARRAY_SIZE(ds1803_channels),
0107         .read = ds1803_read,
0108     },
0109     [DS1803_050] = {
0110         .wipers = 2,
0111         .avail = { 0, 1, 255 },
0112         .kohms =  50,
0113         .channels = ds1803_channels,
0114         .num_channels = ARRAY_SIZE(ds1803_channels),
0115         .read = ds1803_read,
0116     },
0117     [DS1803_100] = {
0118         .wipers = 2,
0119         .avail = { 0, 1, 255 },
0120         .kohms = 100,
0121         .channels = ds1803_channels,
0122         .num_channels = ARRAY_SIZE(ds1803_channels),
0123         .read = ds1803_read,
0124     },
0125     [DS3502] = {
0126       .wipers = 1,
0127       .avail = { 0, 1, 127 },
0128       .kohms =  10,
0129       .channels = ds3502_channels,
0130       .num_channels = ARRAY_SIZE(ds3502_channels),
0131       .read = ds3502_read,
0132     },
0133 };
0134
0135 static int ds1803_read_raw(struct iio_dev *indio_dev,
0136                struct iio_chan_spec const *chan,
0137                int *val, int *val2, long mask)
0138 {
0139     struct ds1803_data *data = iio_priv(indio_dev);
0140     int ret;
0141
0142     switch (mask) {
0143     case IIO_CHAN_INFO_RAW:
0144         ret = data->cfg->read(indio_dev, chan, val);
0145         if (ret < 0)
0146             return ret;
0147
0148         return IIO_VAL_INT;
0149
0150     case IIO_CHAN_INFO_SCALE:
0151         *val = 1000 * data->cfg->kohms;
0152         *val2 = data->cfg->avail[2]; /* Max wiper position */
0153         return IIO_VAL_FRACTIONAL;
0154     }
0155
0156     return -EINVAL;
0157 }
0158
0159 static int ds1803_write_raw(struct iio_dev *indio_dev,
0160                 struct iio_chan_spec const *chan,
0161                 int val, int val2, long mask)
0162 {
0163     struct ds1803_data *data = iio_priv(indio_dev);
0164     u8 addr = chan->address;
0165     int max_pos = data->cfg->avail[2];
0166
0167     if (val2 != 0)
0168         return -EINVAL;
0169
0170     switch (mask) {
0171     case IIO_CHAN_INFO_RAW:
0172         if (val > max_pos || val < 0)
0173             return -EINVAL;
0174         break;
0175     default:
0176         return -EINVAL;
0177     }
0178
0179     return i2c_smbus_write_byte_data(data->client, addr, val);
0180 }
0181
0182 static int ds1803_read_avail(struct iio_dev *indio_dev,
0183                  struct iio_chan_spec const *chan,
0184                  const int **vals, int *type,
0185                  int *length, long mask)
0186 {
0187     struct ds1803_data *data = iio_priv(indio_dev);
0188
0189     switch (mask) {
0190     case IIO_CHAN_INFO_RAW:
0191         *vals = data->cfg->avail;
0192         *length = ARRAY_SIZE(data->cfg->avail);
0193         *type = IIO_VAL_INT;
0194         return IIO_AVAIL_RANGE;
0195     }
0196     return -EINVAL;
0197 }
0198
0199 static const struct iio_info ds1803_info = {
0200     .read_raw = ds1803_read_raw,
0201     .write_raw = ds1803_write_raw,
0202     .read_avail = ds1803_read_avail,
0203 };
0204
0205 static int ds1803_probe(struct i2c_client *client, const struct i2c_device_id *id)
0206 {
0207     struct device *dev = &client->dev;
0208     struct ds1803_data *data;
0209     struct iio_dev *indio_dev;
0210
0211     indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
0212     if (!indio_dev)
0213         return -ENOMEM;
0214
0215     i2c_set_clientdata(client, indio_dev);
0216
0217     data = iio_priv(indio_dev);
0218     data->client = client;
0219     data->cfg = device_get_match_data(dev);
0220     if (!data->cfg)
0221         data->cfg = &ds1803_cfg[id->driver_data];
0222
0223     indio_dev->info = &ds1803_info;
0224     indio_dev->channels = data->cfg->channels;
0225     indio_dev->num_channels = data->cfg->num_channels;
0226     indio_dev->name = client->name;
0227
0228     return devm_iio_device_register(dev, indio_dev);
0229 }
0230
0231 static const struct of_device_id ds1803_dt_ids[] = {
0232     { .compatible = "maxim,ds1803-010", .data = &ds1803_cfg[DS1803_010] },
0233     { .compatible = "maxim,ds1803-050", .data = &ds1803_cfg[DS1803_050] },
0234     { .compatible = "maxim,ds1803-100", .data = &ds1803_cfg[DS1803_100] },
0235     { .compatible = "maxim,ds3502", .data = &ds1803_cfg[DS3502] },
0236     {}
0237 };
0238 MODULE_DEVICE_TABLE(of, ds1803_dt_ids);
0239
0240 static const struct i2c_device_id ds1803_id[] = {
0241     { "ds1803-010", DS1803_010 },
0242     { "ds1803-050", DS1803_050 },
0243     { "ds1803-100", DS1803_100 },
0244     { "ds3502", DS3502 },
0245     {}
0246 };
0247 MODULE_DEVICE_TABLE(i2c, ds1803_id);
0248
0249 static struct i2c_driver ds1803_driver = {
0250     .driver = {
0251         .name   = "ds1803",
0252         .of_match_table = ds1803_dt_ids,
0253     },
0254     .probe      = ds1803_probe,
0255     .id_table   = ds1803_id,
0256 };
0257
0258 module_i2c_driver(ds1803_driver);
0259
0260 MODULE_AUTHOR("Slawomir Stepien <sst@poczta.fm>");
0261 MODULE_AUTHOR("Jagath Jog J <jagathjog1996@gmail.com>");
0262 MODULE_DESCRIPTION("DS1803 digital potentiometer");
0263 MODULE_LICENSE("GPL v2");