drivers/iio/potentiometer/mcp41010.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Industrial I/O driver for Microchip digital potentiometers
   4  *
   5  * Copyright (c) 2018 Chris Coffey <cmc@babblebit.net>
   6  * Based on: Slawomir Stepien's code from mcp4131.c
   7  *
   8  * Datasheet: http://ww1.microchip.com/downloads/en/devicedoc/11195c.pdf
   9  *
  10  * DEVID        #Wipers #Positions      Resistance (kOhm)
  11  * mcp41010     1       256             10
  12  * mcp41050     1       256             50
  13  * mcp41100     1       256             100
  14  * mcp42010     2       256             10
  15  * mcp42050     2       256             50
  16  * mcp42100     2       256             100
  17  */
  18
  19 #include <linux/cache.h>
  20 #include <linux/err.h>
  21 #include <linux/iio/iio.h>
  22 #include <linux/iio/types.h>
  23 #include <linux/module.h>
  24 #include <linux/mutex.h>
  25 #include <linux/of.h>
  26 #include <linux/of_device.h>
  27 #include <linux/spi/spi.h>
  28
  29 #define MCP41010_MAX_WIPERS     2
  30 #define MCP41010_WRITE          BIT(4)
  31 #define MCP41010_WIPER_MAX      255
  32 #define MCP41010_WIPER_CHANNEL  BIT(0)
  33
  34 struct mcp41010_cfg {
  35         char name[16];
  36         int wipers;
  37         int kohms;
  38 };
  39
  40 enum mcp41010_type {
  41         MCP41010,
  42         MCP41050,
  43         MCP41100,
  44         MCP42010,
  45         MCP42050,
  46         MCP42100,
  47 };
  48
  49 static const struct mcp41010_cfg mcp41010_cfg[] = {
  50         [MCP41010] = { .name = "mcp41010", .wipers = 1, .kohms =  10, },
  51         [MCP41050] = { .name = "mcp41050", .wipers = 1, .kohms =  50, },
  52         [MCP41100] = { .name = "mcp41100", .wipers = 1, .kohms = 100, },
  53         [MCP42010] = { .name = "mcp42010", .wipers = 2, .kohms =  10, },
  54         [MCP42050] = { .name = "mcp42050", .wipers = 2, .kohms =  50, },
  55         [MCP42100] = { .name = "mcp42100", .wipers = 2, .kohms = 100, },
  56 };
  57
  58 struct mcp41010_data {
  59         struct spi_device *spi;
  60         const struct mcp41010_cfg *cfg;
  61         struct mutex lock; /* Protect write sequences */
  62         unsigned int value[MCP41010_MAX_WIPERS]; /* Cache wiper values */
  63         u8 buf[2] ____cacheline_aligned;
  64 };
  65
  66 #define MCP41010_CHANNEL(ch) {                                  \
  67         .type = IIO_RESISTANCE,                                 \
  68         .indexed = 1,                                           \
  69         .output = 1,                                            \
  70         .channel = (ch),                                        \
  71         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),           \
  72         .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),   \
  73 }
  74
  75 static const struct iio_chan_spec mcp41010_channels[] = {
  76         MCP41010_CHANNEL(0),
  77         MCP41010_CHANNEL(1),
  78 };
  79
  80 static int mcp41010_read_raw(struct iio_dev *indio_dev,
  81                             struct iio_chan_spec const *chan,
  82                             int *val, int *val2, long mask)
  83 {
  84         struct mcp41010_data *data = iio_priv(indio_dev);
  85         int channel = chan->channel;
  86
  87         switch (mask) {
  88         case IIO_CHAN_INFO_RAW:
  89                 *val = data->value[channel];
  90                 return IIO_VAL_INT;
  91
  92         case IIO_CHAN_INFO_SCALE:
  93                 *val = 1000 * data->cfg->kohms;
  94                 *val2 = MCP41010_WIPER_MAX;
  95                 return IIO_VAL_FRACTIONAL;
  96         }
  97
  98         return -EINVAL;
  99 }
 100
 101 static int mcp41010_write_raw(struct iio_dev *indio_dev,
 102                              struct iio_chan_spec const *chan,
 103                              int val, int val2, long mask)
 104 {
 105         int err;
 106         struct mcp41010_data *data = iio_priv(indio_dev);
 107         int channel = chan->channel;
 108
 109         if (mask != IIO_CHAN_INFO_RAW)
 110                 return -EINVAL;
 111
 112         if (val > MCP41010_WIPER_MAX || val < 0)
 113                 return -EINVAL;
 114
 115         mutex_lock(&data->lock);
 116
 117         data->buf[0] = MCP41010_WIPER_CHANNEL << channel;
 118         data->buf[0] |= MCP41010_WRITE;
 119         data->buf[1] = val & 0xff;
 120
 121         err = spi_write(data->spi, data->buf, sizeof(data->buf));
 122         if (!err)
 123                 data->value[channel] = val;
 124
 125         mutex_unlock(&data->lock);
 126
 127         return err;
 128 }
 129
 130 static const struct iio_info mcp41010_info = {
 131         .read_raw = mcp41010_read_raw,
 132         .write_raw = mcp41010_write_raw,
 133 };
 134
 135 static int mcp41010_probe(struct spi_device *spi)
 136 {
 137         int err;
 138         struct device *dev = &spi->dev;
 139         struct mcp41010_data *data;
 140         struct iio_dev *indio_dev;
 141
 142         indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
 143         if (!indio_dev)
 144                 return -ENOMEM;
 145
 146         data = iio_priv(indio_dev);
 147         spi_set_drvdata(spi, indio_dev);
 148         data->spi = spi;
 149         data->cfg = of_device_get_match_data(&spi->dev);
 150         if (!data->cfg)
 151                 data->cfg = &mcp41010_cfg[spi_get_device_id(spi)->driver_data];
 152
 153         mutex_init(&data->lock);
 154
 155         indio_dev->dev.parent = dev;
 156         indio_dev->info = &mcp41010_info;
 157         indio_dev->channels = mcp41010_channels;
 158         indio_dev->num_channels = data->cfg->wipers;
 159         indio_dev->name = data->cfg->name;
 160
 161         err = devm_iio_device_register(dev, indio_dev);
 162         if (err)
 163                 dev_info(&spi->dev, "Unable to register %s\n", indio_dev->name);
 164
 165         return err;
 166 }
 167
 168 static const struct of_device_id mcp41010_match[] = {
 169         { .compatible = "microchip,mcp41010", .data = &mcp41010_cfg[MCP41010] },
 170         { .compatible = "microchip,mcp41050", .data = &mcp41010_cfg[MCP41050] },
 171         { .compatible = "microchip,mcp41100", .data = &mcp41010_cfg[MCP41100] },
 172         { .compatible = "microchip,mcp42010", .data = &mcp41010_cfg[MCP42010] },
 173         { .compatible = "microchip,mcp42050", .data = &mcp41010_cfg[MCP42050] },
 174         { .compatible = "microchip,mcp42100", .data = &mcp41010_cfg[MCP42100] },
 175         {}
 176 };
 177 MODULE_DEVICE_TABLE(of, mcp41010_match);
 178
 179 static const struct spi_device_id mcp41010_id[] = {
 180         { "mcp41010", MCP41010 },
 181         { "mcp41050", MCP41050 },
 182         { "mcp41100", MCP41100 },
 183         { "mcp42010", MCP42010 },
 184         { "mcp42050", MCP42050 },
 185         { "mcp42100", MCP42100 },
 186         {}
 187 };
 188 MODULE_DEVICE_TABLE(spi, mcp41010_id);
 189
 190 static struct spi_driver mcp41010_driver = {
 191         .driver = {
 192                 .name   = "mcp41010",
 193                 .of_match_table = mcp41010_match,
 194         },
 195         .probe          = mcp41010_probe,
 196         .id_table       = mcp41010_id,
 197 };
 198
 199 module_spi_driver(mcp41010_driver);
 200
 201 MODULE_AUTHOR("Chris Coffey <cmc@babblebit.net>");
 202 MODULE_DESCRIPTION("MCP41010 digital potentiometer");
 203 MODULE_LICENSE("GPL v2");