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"); 204