xref: /openbmc/linux/drivers/iio/dac/ti-dac5571.c (revision 7cf15f42)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * ti-dac5571.c - Texas Instruments 8/10/12-bit 1/4-channel DAC driver
4  *
5  * Copyright (C) 2018 Prevas A/S
6  *
7  * https://www.ti.com/lit/ds/symlink/dac5571.pdf
8  * https://www.ti.com/lit/ds/symlink/dac6571.pdf
9  * https://www.ti.com/lit/ds/symlink/dac7571.pdf
10  * https://www.ti.com/lit/ds/symlink/dac5574.pdf
11  * https://www.ti.com/lit/ds/symlink/dac6574.pdf
12  * https://www.ti.com/lit/ds/symlink/dac7574.pdf
13  * https://www.ti.com/lit/ds/symlink/dac5573.pdf
14  * https://www.ti.com/lit/ds/symlink/dac6573.pdf
15  * https://www.ti.com/lit/ds/symlink/dac7573.pdf
16  * https://www.ti.com/lit/ds/symlink/dac121c081.pdf
17  */
18 
19 #include <linux/iio/iio.h>
20 #include <linux/i2c.h>
21 #include <linux/module.h>
22 #include <linux/mod_devicetable.h>
23 #include <linux/property.h>
24 #include <linux/regulator/consumer.h>
25 
26 enum chip_id {
27 	single_8bit, single_10bit, single_12bit,
28 	quad_8bit, quad_10bit, quad_12bit
29 };
30 
31 struct dac5571_spec {
32 	u8 num_channels;
33 	u8 resolution;
34 };
35 
36 static const struct dac5571_spec dac5571_spec[] = {
37 	[single_8bit]  = {.num_channels = 1, .resolution =  8},
38 	[single_10bit] = {.num_channels = 1, .resolution = 10},
39 	[single_12bit] = {.num_channels = 1, .resolution = 12},
40 	[quad_8bit]    = {.num_channels = 4, .resolution =  8},
41 	[quad_10bit]   = {.num_channels = 4, .resolution = 10},
42 	[quad_12bit]   = {.num_channels = 4, .resolution = 12},
43 };
44 
45 struct dac5571_data {
46 	struct i2c_client *client;
47 	int id;
48 	struct mutex lock;
49 	struct regulator *vref;
50 	u16 val[4];
51 	bool powerdown[4];
52 	u8 powerdown_mode[4];
53 	struct dac5571_spec const *spec;
54 	int (*dac5571_cmd)(struct dac5571_data *data, int channel, u16 val);
55 	int (*dac5571_pwrdwn)(struct dac5571_data *data, int channel, u8 pwrdwn);
56 	u8 buf[3] __aligned(IIO_DMA_MINALIGN);
57 };
58 
59 #define DAC5571_POWERDOWN(mode)		((mode) + 1)
60 #define DAC5571_POWERDOWN_FLAG		BIT(0)
61 #define DAC5571_CHANNEL_SELECT		1
62 #define DAC5571_LOADMODE_DIRECT		BIT(4)
63 #define DAC5571_SINGLE_PWRDWN_BITS	4
64 #define DAC5571_QUAD_PWRDWN_BITS	6
65 
dac5571_cmd_single(struct dac5571_data * data,int channel,u16 val)66 static int dac5571_cmd_single(struct dac5571_data *data, int channel, u16 val)
67 {
68 	unsigned int shift;
69 
70 	shift = 12 - data->spec->resolution;
71 	data->buf[1] = val << shift;
72 	data->buf[0] = val >> (8 - shift);
73 
74 	if (i2c_master_send(data->client, data->buf, 2) != 2)
75 		return -EIO;
76 
77 	return 0;
78 }
79 
dac5571_cmd_quad(struct dac5571_data * data,int channel,u16 val)80 static int dac5571_cmd_quad(struct dac5571_data *data, int channel, u16 val)
81 {
82 	unsigned int shift;
83 
84 	shift = 16 - data->spec->resolution;
85 	data->buf[2] = val << shift;
86 	data->buf[1] = (val >> (8 - shift));
87 	data->buf[0] = (channel << DAC5571_CHANNEL_SELECT) |
88 		       DAC5571_LOADMODE_DIRECT;
89 
90 	if (i2c_master_send(data->client, data->buf, 3) != 3)
91 		return -EIO;
92 
93 	return 0;
94 }
95 
dac5571_pwrdwn_single(struct dac5571_data * data,int channel,u8 pwrdwn)96 static int dac5571_pwrdwn_single(struct dac5571_data *data, int channel, u8 pwrdwn)
97 {
98 	data->buf[1] = 0;
99 	data->buf[0] = pwrdwn << DAC5571_SINGLE_PWRDWN_BITS;
100 
101 	if (i2c_master_send(data->client, data->buf, 2) != 2)
102 		return -EIO;
103 
104 	return 0;
105 }
106 
dac5571_pwrdwn_quad(struct dac5571_data * data,int channel,u8 pwrdwn)107 static int dac5571_pwrdwn_quad(struct dac5571_data *data, int channel, u8 pwrdwn)
108 {
109 	data->buf[2] = 0;
110 	data->buf[1] = pwrdwn << DAC5571_QUAD_PWRDWN_BITS;
111 	data->buf[0] = (channel << DAC5571_CHANNEL_SELECT) |
112 		       DAC5571_LOADMODE_DIRECT | DAC5571_POWERDOWN_FLAG;
113 
114 	if (i2c_master_send(data->client, data->buf, 3) != 3)
115 		return -EIO;
116 
117 	return 0;
118 }
119 
120 static const char *const dac5571_powerdown_modes[] = {
121 	"1kohm_to_gnd", "100kohm_to_gnd", "three_state",
122 };
123 
dac5571_get_powerdown_mode(struct iio_dev * indio_dev,const struct iio_chan_spec * chan)124 static int dac5571_get_powerdown_mode(struct iio_dev *indio_dev,
125 				      const struct iio_chan_spec *chan)
126 {
127 	struct dac5571_data *data = iio_priv(indio_dev);
128 
129 	return data->powerdown_mode[chan->channel];
130 }
131 
dac5571_set_powerdown_mode(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,unsigned int mode)132 static int dac5571_set_powerdown_mode(struct iio_dev *indio_dev,
133 				      const struct iio_chan_spec *chan,
134 				      unsigned int mode)
135 {
136 	struct dac5571_data *data = iio_priv(indio_dev);
137 	int ret = 0;
138 
139 	if (data->powerdown_mode[chan->channel] == mode)
140 		return 0;
141 
142 	mutex_lock(&data->lock);
143 	if (data->powerdown[chan->channel]) {
144 		ret = data->dac5571_pwrdwn(data, chan->channel,
145 					   DAC5571_POWERDOWN(mode));
146 		if (ret)
147 			goto out;
148 	}
149 	data->powerdown_mode[chan->channel] = mode;
150 
151  out:
152 	mutex_unlock(&data->lock);
153 
154 	return ret;
155 }
156 
157 static const struct iio_enum dac5571_powerdown_mode = {
158 	.items = dac5571_powerdown_modes,
159 	.num_items = ARRAY_SIZE(dac5571_powerdown_modes),
160 	.get = dac5571_get_powerdown_mode,
161 	.set = dac5571_set_powerdown_mode,
162 };
163 
dac5571_read_powerdown(struct iio_dev * indio_dev,uintptr_t private,const struct iio_chan_spec * chan,char * buf)164 static ssize_t dac5571_read_powerdown(struct iio_dev *indio_dev,
165 				      uintptr_t private,
166 				      const struct iio_chan_spec *chan,
167 				      char *buf)
168 {
169 	struct dac5571_data *data = iio_priv(indio_dev);
170 
171 	return sysfs_emit(buf, "%d\n", data->powerdown[chan->channel]);
172 }
173 
dac5571_write_powerdown(struct iio_dev * indio_dev,uintptr_t private,const struct iio_chan_spec * chan,const char * buf,size_t len)174 static ssize_t dac5571_write_powerdown(struct iio_dev *indio_dev,
175 				       uintptr_t private,
176 				       const struct iio_chan_spec *chan,
177 				       const char *buf, size_t len)
178 {
179 	struct dac5571_data *data = iio_priv(indio_dev);
180 	bool powerdown;
181 	int ret;
182 
183 	ret = kstrtobool(buf, &powerdown);
184 	if (ret)
185 		return ret;
186 
187 	if (data->powerdown[chan->channel] == powerdown)
188 		return len;
189 
190 	mutex_lock(&data->lock);
191 	if (powerdown)
192 		ret = data->dac5571_pwrdwn(data, chan->channel,
193 			    DAC5571_POWERDOWN(data->powerdown_mode[chan->channel]));
194 	else
195 		ret = data->dac5571_cmd(data, chan->channel,
196 				data->val[chan->channel]);
197 	if (ret)
198 		goto out;
199 
200 	data->powerdown[chan->channel] = powerdown;
201 
202  out:
203 	mutex_unlock(&data->lock);
204 
205 	return ret ? ret : len;
206 }
207 
208 
209 static const struct iio_chan_spec_ext_info dac5571_ext_info[] = {
210 	{
211 		.name	   = "powerdown",
212 		.read	   = dac5571_read_powerdown,
213 		.write	   = dac5571_write_powerdown,
214 		.shared	   = IIO_SEPARATE,
215 	},
216 	IIO_ENUM("powerdown_mode", IIO_SEPARATE, &dac5571_powerdown_mode),
217 	IIO_ENUM_AVAILABLE("powerdown_mode", IIO_SHARED_BY_TYPE, &dac5571_powerdown_mode),
218 	{},
219 };
220 
221 #define dac5571_CHANNEL(chan, name) {				\
222 	.type = IIO_VOLTAGE,					\
223 	.channel = (chan),					\
224 	.address = (chan),					\
225 	.indexed = true,					\
226 	.output = true,						\
227 	.datasheet_name = name,					\
228 	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),		\
229 	.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),	\
230 	.ext_info = dac5571_ext_info,				\
231 }
232 
233 static const struct iio_chan_spec dac5571_channels[] = {
234 	dac5571_CHANNEL(0, "A"),
235 	dac5571_CHANNEL(1, "B"),
236 	dac5571_CHANNEL(2, "C"),
237 	dac5571_CHANNEL(3, "D"),
238 };
239 
dac5571_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)240 static int dac5571_read_raw(struct iio_dev *indio_dev,
241 			    struct iio_chan_spec const *chan,
242 			    int *val, int *val2, long mask)
243 {
244 	struct dac5571_data *data = iio_priv(indio_dev);
245 	int ret;
246 
247 	switch (mask) {
248 	case IIO_CHAN_INFO_RAW:
249 		*val = data->val[chan->channel];
250 		return IIO_VAL_INT;
251 
252 	case IIO_CHAN_INFO_SCALE:
253 		ret = regulator_get_voltage(data->vref);
254 		if (ret < 0)
255 			return ret;
256 
257 		*val = ret / 1000;
258 		*val2 = data->spec->resolution;
259 		return IIO_VAL_FRACTIONAL_LOG2;
260 
261 	default:
262 		return -EINVAL;
263 	}
264 }
265 
dac5571_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)266 static int dac5571_write_raw(struct iio_dev *indio_dev,
267 			     struct iio_chan_spec const *chan,
268 			     int val, int val2, long mask)
269 {
270 	struct dac5571_data *data = iio_priv(indio_dev);
271 	int ret;
272 
273 	switch (mask) {
274 	case IIO_CHAN_INFO_RAW:
275 		if (data->val[chan->channel] == val)
276 			return 0;
277 
278 		if (val >= (1 << data->spec->resolution) || val < 0)
279 			return -EINVAL;
280 
281 		if (data->powerdown[chan->channel])
282 			return -EBUSY;
283 
284 		mutex_lock(&data->lock);
285 		ret = data->dac5571_cmd(data, chan->channel, val);
286 		if (ret == 0)
287 			data->val[chan->channel] = val;
288 		mutex_unlock(&data->lock);
289 		return ret;
290 
291 	default:
292 		return -EINVAL;
293 	}
294 }
295 
dac5571_write_raw_get_fmt(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,long mask)296 static int dac5571_write_raw_get_fmt(struct iio_dev *indio_dev,
297 				     struct iio_chan_spec const *chan,
298 				     long mask)
299 {
300 	return IIO_VAL_INT;
301 }
302 
303 static const struct iio_info dac5571_info = {
304 	.read_raw = dac5571_read_raw,
305 	.write_raw = dac5571_write_raw,
306 	.write_raw_get_fmt = dac5571_write_raw_get_fmt,
307 };
308 
dac5571_probe(struct i2c_client * client)309 static int dac5571_probe(struct i2c_client *client)
310 {
311 	const struct i2c_device_id *id = i2c_client_get_device_id(client);
312 	struct device *dev = &client->dev;
313 	const struct dac5571_spec *spec;
314 	struct dac5571_data *data;
315 	struct iio_dev *indio_dev;
316 	enum chip_id chip_id;
317 	int ret, i;
318 
319 	indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
320 	if (!indio_dev)
321 		return -ENOMEM;
322 
323 	data = iio_priv(indio_dev);
324 	i2c_set_clientdata(client, indio_dev);
325 	data->client = client;
326 
327 	indio_dev->info = &dac5571_info;
328 	indio_dev->name = id->name;
329 	indio_dev->modes = INDIO_DIRECT_MODE;
330 	indio_dev->channels = dac5571_channels;
331 
332 	if (dev_fwnode(dev))
333 		chip_id = (uintptr_t)device_get_match_data(dev);
334 	else
335 		chip_id = id->driver_data;
336 
337 	spec = &dac5571_spec[chip_id];
338 
339 	indio_dev->num_channels = spec->num_channels;
340 	data->spec = spec;
341 
342 	data->vref = devm_regulator_get(dev, "vref");
343 	if (IS_ERR(data->vref))
344 		return PTR_ERR(data->vref);
345 
346 	ret = regulator_enable(data->vref);
347 	if (ret < 0)
348 		return ret;
349 
350 	mutex_init(&data->lock);
351 
352 	switch (spec->num_channels) {
353 	case 1:
354 		data->dac5571_cmd = dac5571_cmd_single;
355 		data->dac5571_pwrdwn = dac5571_pwrdwn_single;
356 		break;
357 	case 4:
358 		data->dac5571_cmd = dac5571_cmd_quad;
359 		data->dac5571_pwrdwn = dac5571_pwrdwn_quad;
360 		break;
361 	default:
362 		ret = -EINVAL;
363 		goto err;
364 	}
365 
366 	for (i = 0; i < spec->num_channels; i++) {
367 		ret = data->dac5571_cmd(data, i, 0);
368 		if (ret) {
369 			dev_err(dev, "failed to initialize channel %d to 0\n", i);
370 			goto err;
371 		}
372 	}
373 
374 	ret = iio_device_register(indio_dev);
375 	if (ret)
376 		goto err;
377 
378 	return 0;
379 
380  err:
381 	regulator_disable(data->vref);
382 	return ret;
383 }
384 
dac5571_remove(struct i2c_client * i2c)385 static void dac5571_remove(struct i2c_client *i2c)
386 {
387 	struct iio_dev *indio_dev = i2c_get_clientdata(i2c);
388 	struct dac5571_data *data = iio_priv(indio_dev);
389 
390 	iio_device_unregister(indio_dev);
391 	regulator_disable(data->vref);
392 }
393 
394 static const struct of_device_id dac5571_of_id[] = {
395 	{.compatible = "ti,dac5571", .data = (void *)single_8bit},
396 	{.compatible = "ti,dac6571", .data = (void *)single_10bit},
397 	{.compatible = "ti,dac7571", .data = (void *)single_12bit},
398 	{.compatible = "ti,dac5574", .data = (void *)quad_8bit},
399 	{.compatible = "ti,dac6574", .data = (void *)quad_10bit},
400 	{.compatible = "ti,dac7574", .data = (void *)quad_12bit},
401 	{.compatible = "ti,dac5573", .data = (void *)quad_8bit},
402 	{.compatible = "ti,dac6573", .data = (void *)quad_10bit},
403 	{.compatible = "ti,dac7573", .data = (void *)quad_12bit},
404 	{.compatible = "ti,dac121c081", .data = (void *)single_12bit},
405 	{}
406 };
407 MODULE_DEVICE_TABLE(of, dac5571_of_id);
408 
409 static const struct i2c_device_id dac5571_id[] = {
410 	{"dac5571", single_8bit},
411 	{"dac6571", single_10bit},
412 	{"dac7571", single_12bit},
413 	{"dac5574", quad_8bit},
414 	{"dac6574", quad_10bit},
415 	{"dac7574", quad_12bit},
416 	{"dac5573", quad_8bit},
417 	{"dac6573", quad_10bit},
418 	{"dac7573", quad_12bit},
419 	{"dac121c081", single_12bit},
420 	{}
421 };
422 MODULE_DEVICE_TABLE(i2c, dac5571_id);
423 
424 static struct i2c_driver dac5571_driver = {
425 	.driver = {
426 		   .name = "ti-dac5571",
427 		   .of_match_table = dac5571_of_id,
428 	},
429 	.probe = dac5571_probe,
430 	.remove   = dac5571_remove,
431 	.id_table = dac5571_id,
432 };
433 module_i2c_driver(dac5571_driver);
434 
435 MODULE_AUTHOR("Sean Nyekjaer <sean@geanix.dk>");
436 MODULE_DESCRIPTION("Texas Instruments 8/10/12-bit 1/4-channel DAC driver");
437 MODULE_LICENSE("GPL v2");
438