ds1803.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Maxim Integrated DS1803 and similar digital potentiometer driver
  4 * Copyright (c) 2016 Slawomir Stepien
  5 * Copyright (c) 2022 Jagath Jog J
  6 *
  7 * Datasheet: https://datasheets.maximintegrated.com/en/ds/DS1803.pdf
  8 * Datasheet: https://datasheets.maximintegrated.com/en/ds/DS3502.pdf
  9 *
 10 * DEVID	#Wipers	#Positions	Resistor Opts (kOhm)	i2c address
 11 * ds1803	2	256		10, 50, 100		0101xxx
 12 * ds3502	1	128		10			01010xx
 13 */
 14
 15#include <linux/err.h>
 16#include <linux/i2c.h>
 17#include <linux/iio/iio.h>
 18#include <linux/module.h>
 19#include <linux/mod_devicetable.h>
 20#include <linux/property.h>
 21
 22#define DS1803_WIPER_0         0xA9
 23#define DS1803_WIPER_1         0xAA
 24#define DS3502_WR_IVR          0x00
 25
 26enum ds1803_type {
 27	DS1803_010,
 28	DS1803_050,
 29	DS1803_100,
 30	DS3502,
 31};
 32
 33struct ds1803_cfg {
 34	int wipers;
 35	int avail[3];
 36	int kohms;
 37	const struct iio_chan_spec *channels;
 38	u8 num_channels;
 39	int (*read)(struct iio_dev *indio_dev,
 40		    struct iio_chan_spec const *chan, int *val);
 41};
 42
 43struct ds1803_data {
 44	struct i2c_client *client;
 45	const struct ds1803_cfg *cfg;
 46};
 47
 48#define DS1803_CHANNEL(ch, addr) {					\
 49	.type = IIO_RESISTANCE,						\
 50	.indexed = 1,							\
 51	.output = 1,							\
 52	.channel = (ch),						\
 53	.address = (addr),						\
 54	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),			\
 55	.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),		\
 56	.info_mask_shared_by_type_available = BIT(IIO_CHAN_INFO_RAW),   \
 57}
 58
 59static const struct iio_chan_spec ds1803_channels[] = {
 60	DS1803_CHANNEL(0, DS1803_WIPER_0),
 61	DS1803_CHANNEL(1, DS1803_WIPER_1),
 62};
 63
 64static const struct iio_chan_spec ds3502_channels[] = {
 65	DS1803_CHANNEL(0, DS3502_WR_IVR),
 66};
 67
 68static int ds1803_read(struct iio_dev *indio_dev,
 69		       struct iio_chan_spec const *chan,
 70		       int *val)
 71{
 72	struct ds1803_data *data = iio_priv(indio_dev);
 73	int ret;
 74	u8 result[ARRAY_SIZE(ds1803_channels)];
 75
 76	ret = i2c_master_recv(data->client, result, indio_dev->num_channels);
 77	if (ret < 0)
 78		return ret;
 79
 80	*val = result[chan->channel];
 81	return ret;
 82}
 83
 84static int ds3502_read(struct iio_dev *indio_dev,
 85		       struct iio_chan_spec const *chan,
 86		       int *val)
 87{
 88	struct ds1803_data *data = iio_priv(indio_dev);
 89	int ret;
 90
 91	ret = i2c_smbus_read_byte_data(data->client, chan->address);
 92	if (ret < 0)
 93		return ret;
 94
 95	*val = ret;
 96	return ret;
 97}
 98
 99static const struct ds1803_cfg ds1803_cfg[] = {
100	[DS1803_010] = {
101		.wipers = 2,
102		.avail = { 0, 1, 255 },
103		.kohms =  10,
104		.channels = ds1803_channels,
105		.num_channels = ARRAY_SIZE(ds1803_channels),
106		.read = ds1803_read,
107	},
108	[DS1803_050] = {
109		.wipers = 2,
110		.avail = { 0, 1, 255 },
111		.kohms =  50,
112		.channels = ds1803_channels,
113		.num_channels = ARRAY_SIZE(ds1803_channels),
114		.read = ds1803_read,
115	},
116	[DS1803_100] = {
117		.wipers = 2,
118		.avail = { 0, 1, 255 },
119		.kohms = 100,
120		.channels = ds1803_channels,
121		.num_channels = ARRAY_SIZE(ds1803_channels),
122		.read = ds1803_read,
123	},
124	[DS3502] = {
125	  .wipers = 1,
126	  .avail = { 0, 1, 127 },
127	  .kohms =  10,
128	  .channels = ds3502_channels,
129	  .num_channels = ARRAY_SIZE(ds3502_channels),
130	  .read = ds3502_read,
131	},
132};
133
134static int ds1803_read_raw(struct iio_dev *indio_dev,
135			   struct iio_chan_spec const *chan,
136			   int *val, int *val2, long mask)
137{
138	struct ds1803_data *data = iio_priv(indio_dev);
139	int ret;
140
141	switch (mask) {
142	case IIO_CHAN_INFO_RAW:
143		ret = data->cfg->read(indio_dev, chan, val);
144		if (ret < 0)
145			return ret;
146
147		return IIO_VAL_INT;
148
149	case IIO_CHAN_INFO_SCALE:
150		*val = 1000 * data->cfg->kohms;
151		*val2 = data->cfg->avail[2]; /* Max wiper position */
152		return IIO_VAL_FRACTIONAL;
153	}
154
155	return -EINVAL;
156}
157
158static int ds1803_write_raw(struct iio_dev *indio_dev,
159			    struct iio_chan_spec const *chan,
160			    int val, int val2, long mask)
161{
162	struct ds1803_data *data = iio_priv(indio_dev);
163	u8 addr = chan->address;
164	int max_pos = data->cfg->avail[2];
165
166	if (val2 != 0)
167		return -EINVAL;
168
169	switch (mask) {
170	case IIO_CHAN_INFO_RAW:
171		if (val > max_pos || val < 0)
172			return -EINVAL;
173		break;
174	default:
175		return -EINVAL;
176	}
177
178	return i2c_smbus_write_byte_data(data->client, addr, val);
179}
180
181static int ds1803_read_avail(struct iio_dev *indio_dev,
182			     struct iio_chan_spec const *chan,
183			     const int **vals, int *type,
184			     int *length, long mask)
185{
186	struct ds1803_data *data = iio_priv(indio_dev);
187
188	switch (mask) {
189	case IIO_CHAN_INFO_RAW:
190		*vals = data->cfg->avail;
191		*length = ARRAY_SIZE(data->cfg->avail);
192		*type = IIO_VAL_INT;
193		return IIO_AVAIL_RANGE;
194	}
195	return -EINVAL;
196}
197
198static const struct iio_info ds1803_info = {
199	.read_raw = ds1803_read_raw,
200	.write_raw = ds1803_write_raw,
201	.read_avail = ds1803_read_avail,
202};
203
204static int ds1803_probe(struct i2c_client *client)
205{
206	struct device *dev = &client->dev;
207	struct ds1803_data *data;
208	struct iio_dev *indio_dev;
209
210	indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
211	if (!indio_dev)
212		return -ENOMEM;
213
214	i2c_set_clientdata(client, indio_dev);
215
216	data = iio_priv(indio_dev);
217	data->client = client;
218	data->cfg = i2c_get_match_data(client);
219
220	indio_dev->info = &ds1803_info;
221	indio_dev->channels = data->cfg->channels;
222	indio_dev->num_channels = data->cfg->num_channels;
223	indio_dev->name = client->name;
224
225	return devm_iio_device_register(dev, indio_dev);
226}
227
228static const struct of_device_id ds1803_dt_ids[] = {
229	{ .compatible = "maxim,ds1803-010", .data = &ds1803_cfg[DS1803_010] },
230	{ .compatible = "maxim,ds1803-050", .data = &ds1803_cfg[DS1803_050] },
231	{ .compatible = "maxim,ds1803-100", .data = &ds1803_cfg[DS1803_100] },
232	{ .compatible = "maxim,ds3502", .data = &ds1803_cfg[DS3502] },
233	{ }
234};
235MODULE_DEVICE_TABLE(of, ds1803_dt_ids);
236
237static const struct i2c_device_id ds1803_id[] = {
238	{ "ds1803-010", (kernel_ulong_t)&ds1803_cfg[DS1803_010] },
239	{ "ds1803-050", (kernel_ulong_t)&ds1803_cfg[DS1803_050] },
240	{ "ds1803-100", (kernel_ulong_t)&ds1803_cfg[DS1803_100] },
241	{ "ds3502", (kernel_ulong_t)&ds1803_cfg[DS3502] },
242	{ }
243};
244MODULE_DEVICE_TABLE(i2c, ds1803_id);
245
246static struct i2c_driver ds1803_driver = {
247	.driver = {
248		.name	= "ds1803",
249		.of_match_table = ds1803_dt_ids,
250	},
251	.probe		= ds1803_probe,
252	.id_table	= ds1803_id,
253};
254
255module_i2c_driver(ds1803_driver);
256
257MODULE_AUTHOR("Slawomir Stepien <sst@poczta.fm>");
258MODULE_AUTHOR("Jagath Jog J <jagathjog1996@gmail.com>");
259MODULE_DESCRIPTION("DS1803 digital potentiometer");
260MODULE_LICENSE("GPL v2");