xref: /linux/drivers/iio/dac/mcp4725.c (revision 791d3ef2e11100449837dc0b6fe884e60ca3a484)
1 /*
2  * mcp4725.c - Support for Microchip MCP4725/6
3  *
4  * Copyright (C) 2012 Peter Meerwald <pmeerw@pmeerw.net>
5  *
6  * Based on max517 by Roland Stigge <stigge@antcom.de>
7  *
8  * This file is subject to the terms and conditions of version 2 of
9  * the GNU General Public License.  See the file COPYING in the main
10  * directory of this archive for more details.
11  *
12  * driver for the Microchip I2C 12-bit digital-to-analog converter (DAC)
13  * (7-bit I2C slave address 0x60, the three LSBs can be configured in
14  * hardware)
15  */
16 
17 #include <linux/module.h>
18 #include <linux/i2c.h>
19 #include <linux/err.h>
20 #include <linux/delay.h>
21 #include <linux/regulator/consumer.h>
22 #include <linux/of_device.h>
23 #include <linux/of.h>
24 
25 #include <linux/iio/iio.h>
26 #include <linux/iio/sysfs.h>
27 
28 #include <linux/iio/dac/mcp4725.h>
29 
30 #define MCP4725_DRV_NAME "mcp4725"
31 
32 #define MCP472X_REF_VDD			0x00
33 #define MCP472X_REF_VREF_UNBUFFERED	0x02
34 #define MCP472X_REF_VREF_BUFFERED	0x03
35 
36 struct mcp4725_data {
37 	struct i2c_client *client;
38 	int id;
39 	unsigned ref_mode;
40 	bool vref_buffered;
41 	u16 dac_value;
42 	bool powerdown;
43 	unsigned powerdown_mode;
44 	struct regulator *vdd_reg;
45 	struct regulator *vref_reg;
46 };
47 
48 static int mcp4725_suspend(struct device *dev)
49 {
50 	struct mcp4725_data *data = iio_priv(i2c_get_clientdata(
51 		to_i2c_client(dev)));
52 	u8 outbuf[2];
53 
54 	outbuf[0] = (data->powerdown_mode + 1) << 4;
55 	outbuf[1] = 0;
56 	data->powerdown = true;
57 
58 	return i2c_master_send(data->client, outbuf, 2);
59 }
60 
61 static int mcp4725_resume(struct device *dev)
62 {
63 	struct mcp4725_data *data = iio_priv(i2c_get_clientdata(
64 		to_i2c_client(dev)));
65 	u8 outbuf[2];
66 
67 	/* restore previous DAC value */
68 	outbuf[0] = (data->dac_value >> 8) & 0xf;
69 	outbuf[1] = data->dac_value & 0xff;
70 	data->powerdown = false;
71 
72 	return i2c_master_send(data->client, outbuf, 2);
73 }
74 
75 #ifdef CONFIG_PM_SLEEP
76 static SIMPLE_DEV_PM_OPS(mcp4725_pm_ops, mcp4725_suspend, mcp4725_resume);
77 #define MCP4725_PM_OPS (&mcp4725_pm_ops)
78 #else
79 #define MCP4725_PM_OPS NULL
80 #endif
81 
82 static ssize_t mcp4725_store_eeprom(struct device *dev,
83 	struct device_attribute *attr, const char *buf, size_t len)
84 {
85 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
86 	struct mcp4725_data *data = iio_priv(indio_dev);
87 	int tries = 20;
88 	u8 inoutbuf[3];
89 	bool state;
90 	int ret;
91 
92 	ret = strtobool(buf, &state);
93 	if (ret < 0)
94 		return ret;
95 
96 	if (!state)
97 		return 0;
98 
99 	inoutbuf[0] = 0x60; /* write EEPROM */
100 	inoutbuf[0] |= data->ref_mode << 3;
101 	inoutbuf[1] = data->dac_value >> 4;
102 	inoutbuf[2] = (data->dac_value & 0xf) << 4;
103 
104 	ret = i2c_master_send(data->client, inoutbuf, 3);
105 	if (ret < 0)
106 		return ret;
107 	else if (ret != 3)
108 		return -EIO;
109 
110 	/* wait for write complete, takes up to 50ms */
111 	while (tries--) {
112 		msleep(20);
113 		ret = i2c_master_recv(data->client, inoutbuf, 3);
114 		if (ret < 0)
115 			return ret;
116 		else if (ret != 3)
117 			return -EIO;
118 
119 		if (inoutbuf[0] & 0x80)
120 			break;
121 	}
122 
123 	if (tries < 0) {
124 		dev_err(&data->client->dev,
125 			"mcp4725_store_eeprom() failed, incomplete\n");
126 		return -EIO;
127 	}
128 
129 	return len;
130 }
131 
132 static IIO_DEVICE_ATTR(store_eeprom, S_IWUSR, NULL, mcp4725_store_eeprom, 0);
133 
134 static struct attribute *mcp4725_attributes[] = {
135 	&iio_dev_attr_store_eeprom.dev_attr.attr,
136 	NULL,
137 };
138 
139 static const struct attribute_group mcp4725_attribute_group = {
140 	.attrs = mcp4725_attributes,
141 };
142 
143 static const char * const mcp4725_powerdown_modes[] = {
144 	"1kohm_to_gnd",
145 	"100kohm_to_gnd",
146 	"500kohm_to_gnd"
147 };
148 
149 static const char * const mcp4726_powerdown_modes[] = {
150 	"1kohm_to_gnd",
151 	"125kohm_to_gnd",
152 	"640kohm_to_gnd"
153 };
154 
155 static int mcp4725_get_powerdown_mode(struct iio_dev *indio_dev,
156 	const struct iio_chan_spec *chan)
157 {
158 	struct mcp4725_data *data = iio_priv(indio_dev);
159 
160 	return data->powerdown_mode;
161 }
162 
163 static int mcp4725_set_powerdown_mode(struct iio_dev *indio_dev,
164 	const struct iio_chan_spec *chan, unsigned mode)
165 {
166 	struct mcp4725_data *data = iio_priv(indio_dev);
167 
168 	data->powerdown_mode = mode;
169 
170 	return 0;
171 }
172 
173 static ssize_t mcp4725_read_powerdown(struct iio_dev *indio_dev,
174 	uintptr_t private, const struct iio_chan_spec *chan, char *buf)
175 {
176 	struct mcp4725_data *data = iio_priv(indio_dev);
177 
178 	return sprintf(buf, "%d\n", data->powerdown);
179 }
180 
181 static ssize_t mcp4725_write_powerdown(struct iio_dev *indio_dev,
182 	 uintptr_t private, const struct iio_chan_spec *chan,
183 	 const char *buf, size_t len)
184 {
185 	struct mcp4725_data *data = iio_priv(indio_dev);
186 	bool state;
187 	int ret;
188 
189 	ret = strtobool(buf, &state);
190 	if (ret)
191 		return ret;
192 
193 	if (state)
194 		ret = mcp4725_suspend(&data->client->dev);
195 	else
196 		ret = mcp4725_resume(&data->client->dev);
197 	if (ret < 0)
198 		return ret;
199 
200 	return len;
201 }
202 
203 enum chip_id {
204 	MCP4725,
205 	MCP4726,
206 };
207 
208 static const struct iio_enum mcp472x_powerdown_mode_enum[] = {
209 	[MCP4725] = {
210 		.items = mcp4725_powerdown_modes,
211 		.num_items = ARRAY_SIZE(mcp4725_powerdown_modes),
212 		.get = mcp4725_get_powerdown_mode,
213 		.set = mcp4725_set_powerdown_mode,
214 	},
215 	[MCP4726] = {
216 		.items = mcp4726_powerdown_modes,
217 		.num_items = ARRAY_SIZE(mcp4726_powerdown_modes),
218 		.get = mcp4725_get_powerdown_mode,
219 		.set = mcp4725_set_powerdown_mode,
220 	},
221 };
222 
223 static const struct iio_chan_spec_ext_info mcp4725_ext_info[] = {
224 	{
225 		.name = "powerdown",
226 		.read = mcp4725_read_powerdown,
227 		.write = mcp4725_write_powerdown,
228 		.shared = IIO_SEPARATE,
229 	},
230 	IIO_ENUM("powerdown_mode", IIO_SEPARATE,
231 			&mcp472x_powerdown_mode_enum[MCP4725]),
232 	IIO_ENUM_AVAILABLE("powerdown_mode",
233 			&mcp472x_powerdown_mode_enum[MCP4725]),
234 	{ },
235 };
236 
237 static const struct iio_chan_spec_ext_info mcp4726_ext_info[] = {
238 	{
239 		.name = "powerdown",
240 		.read = mcp4725_read_powerdown,
241 		.write = mcp4725_write_powerdown,
242 		.shared = IIO_SEPARATE,
243 	},
244 	IIO_ENUM("powerdown_mode", IIO_SEPARATE,
245 			&mcp472x_powerdown_mode_enum[MCP4726]),
246 	IIO_ENUM_AVAILABLE("powerdown_mode",
247 			&mcp472x_powerdown_mode_enum[MCP4726]),
248 	{ },
249 };
250 
251 static const struct iio_chan_spec mcp472x_channel[] = {
252 	[MCP4725] = {
253 		.type		= IIO_VOLTAGE,
254 		.indexed	= 1,
255 		.output		= 1,
256 		.channel	= 0,
257 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
258 		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
259 		.ext_info	= mcp4725_ext_info,
260 	},
261 	[MCP4726] = {
262 		.type		= IIO_VOLTAGE,
263 		.indexed	= 1,
264 		.output		= 1,
265 		.channel	= 0,
266 		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
267 		.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
268 		.ext_info	= mcp4726_ext_info,
269 	},
270 };
271 
272 static int mcp4725_set_value(struct iio_dev *indio_dev, int val)
273 {
274 	struct mcp4725_data *data = iio_priv(indio_dev);
275 	u8 outbuf[2];
276 	int ret;
277 
278 	if (val >= (1 << 12) || val < 0)
279 		return -EINVAL;
280 
281 	outbuf[0] = (val >> 8) & 0xf;
282 	outbuf[1] = val & 0xff;
283 
284 	ret = i2c_master_send(data->client, outbuf, 2);
285 	if (ret < 0)
286 		return ret;
287 	else if (ret != 2)
288 		return -EIO;
289 	else
290 		return 0;
291 }
292 
293 static int mcp4726_set_cfg(struct iio_dev *indio_dev)
294 {
295 	struct mcp4725_data *data = iio_priv(indio_dev);
296 	u8 outbuf[3];
297 	int ret;
298 
299 	outbuf[0] = 0x40;
300 	outbuf[0] |= data->ref_mode << 3;
301 	if (data->powerdown)
302 		outbuf[0] |= data->powerdown << 1;
303 	outbuf[1] = data->dac_value >> 4;
304 	outbuf[2] = (data->dac_value & 0xf) << 4;
305 
306 	ret = i2c_master_send(data->client, outbuf, 3);
307 	if (ret < 0)
308 		return ret;
309 	else if (ret != 3)
310 		return -EIO;
311 	else
312 		return 0;
313 }
314 
315 static int mcp4725_read_raw(struct iio_dev *indio_dev,
316 			   struct iio_chan_spec const *chan,
317 			   int *val, int *val2, long mask)
318 {
319 	struct mcp4725_data *data = iio_priv(indio_dev);
320 	int ret;
321 
322 	switch (mask) {
323 	case IIO_CHAN_INFO_RAW:
324 		*val = data->dac_value;
325 		return IIO_VAL_INT;
326 	case IIO_CHAN_INFO_SCALE:
327 		if (data->ref_mode == MCP472X_REF_VDD)
328 			ret = regulator_get_voltage(data->vdd_reg);
329 		else
330 			ret = regulator_get_voltage(data->vref_reg);
331 
332 		if (ret < 0)
333 			return ret;
334 
335 		*val = ret / 1000;
336 		*val2 = 12;
337 		return IIO_VAL_FRACTIONAL_LOG2;
338 	}
339 	return -EINVAL;
340 }
341 
342 static int mcp4725_write_raw(struct iio_dev *indio_dev,
343 			       struct iio_chan_spec const *chan,
344 			       int val, int val2, long mask)
345 {
346 	struct mcp4725_data *data = iio_priv(indio_dev);
347 	int ret;
348 
349 	switch (mask) {
350 	case IIO_CHAN_INFO_RAW:
351 		ret = mcp4725_set_value(indio_dev, val);
352 		data->dac_value = val;
353 		break;
354 	default:
355 		ret = -EINVAL;
356 		break;
357 	}
358 
359 	return ret;
360 }
361 
362 static const struct iio_info mcp4725_info = {
363 	.read_raw = mcp4725_read_raw,
364 	.write_raw = mcp4725_write_raw,
365 	.attrs = &mcp4725_attribute_group,
366 };
367 
368 #ifdef CONFIG_OF
369 static int mcp4725_probe_dt(struct device *dev,
370 			    struct mcp4725_platform_data *pdata)
371 {
372 	struct device_node *np = dev->of_node;
373 
374 	if (!np)
375 		return -ENODEV;
376 
377 	/* check if is the vref-supply defined */
378 	pdata->use_vref = of_property_read_bool(np, "vref-supply");
379 	pdata->vref_buffered =
380 		of_property_read_bool(np, "microchip,vref-buffered");
381 
382 	return 0;
383 }
384 #else
385 static int mcp4725_probe_dt(struct device *dev,
386 			    struct mcp4725_platform_data *platform_data)
387 {
388 	return -ENODEV;
389 }
390 #endif
391 
392 static int mcp4725_probe(struct i2c_client *client,
393 			 const struct i2c_device_id *id)
394 {
395 	struct mcp4725_data *data;
396 	struct iio_dev *indio_dev;
397 	struct mcp4725_platform_data *pdata, pdata_dt;
398 	u8 inbuf[4];
399 	u8 pd;
400 	u8 ref;
401 	int err;
402 
403 	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
404 	if (indio_dev == NULL)
405 		return -ENOMEM;
406 	data = iio_priv(indio_dev);
407 	i2c_set_clientdata(client, indio_dev);
408 	data->client = client;
409 	if (client->dev.of_node)
410 		data->id = (enum chip_id)of_device_get_match_data(&client->dev);
411 	else
412 		data->id = id->driver_data;
413 	pdata = dev_get_platdata(&client->dev);
414 
415 	if (!pdata) {
416 		err = mcp4725_probe_dt(&client->dev, &pdata_dt);
417 		if (err) {
418 			dev_err(&client->dev,
419 				"invalid platform or devicetree data");
420 			return err;
421 		}
422 		pdata = &pdata_dt;
423 	}
424 
425 	if (data->id == MCP4725 && pdata->use_vref) {
426 		dev_err(&client->dev,
427 			"external reference is unavailable on MCP4725");
428 		return -EINVAL;
429 	}
430 
431 	if (!pdata->use_vref && pdata->vref_buffered) {
432 		dev_err(&client->dev,
433 			"buffering is unavailable on the internal reference");
434 		return -EINVAL;
435 	}
436 
437 	if (!pdata->use_vref)
438 		data->ref_mode = MCP472X_REF_VDD;
439 	else
440 		data->ref_mode = pdata->vref_buffered ?
441 			MCP472X_REF_VREF_BUFFERED :
442 			MCP472X_REF_VREF_UNBUFFERED;
443 
444 	data->vdd_reg = devm_regulator_get(&client->dev, "vdd");
445 	if (IS_ERR(data->vdd_reg))
446 		return PTR_ERR(data->vdd_reg);
447 
448 	err = regulator_enable(data->vdd_reg);
449 	if (err)
450 		return err;
451 
452 	if (pdata->use_vref) {
453 		data->vref_reg = devm_regulator_get(&client->dev, "vref");
454 		if (IS_ERR(data->vref_reg)) {
455 			err = PTR_ERR(data->vref_reg);
456 			goto err_disable_vdd_reg;
457 		}
458 
459 		err = regulator_enable(data->vref_reg);
460 		if (err)
461 			goto err_disable_vdd_reg;
462 	}
463 
464 	indio_dev->dev.parent = &client->dev;
465 	indio_dev->name = id->name;
466 	indio_dev->info = &mcp4725_info;
467 	indio_dev->channels = &mcp472x_channel[id->driver_data];
468 	indio_dev->num_channels = 1;
469 	indio_dev->modes = INDIO_DIRECT_MODE;
470 
471 	/* read current DAC value and settings */
472 	err = i2c_master_recv(client, inbuf, data->id == MCP4725 ? 3 : 4);
473 
474 	if (err < 0) {
475 		dev_err(&client->dev, "failed to read DAC value");
476 		goto err_disable_vref_reg;
477 	}
478 	pd = (inbuf[0] >> 1) & 0x3;
479 	data->powerdown = pd > 0;
480 	data->powerdown_mode = pd ? pd - 1 : 2; /* largest resistor to gnd */
481 	data->dac_value = (inbuf[1] << 4) | (inbuf[2] >> 4);
482 	if (data->id == MCP4726)
483 		ref = (inbuf[3] >> 3) & 0x3;
484 
485 	if (data->id == MCP4726 && ref != data->ref_mode) {
486 		dev_info(&client->dev,
487 			"voltage reference mode differs (conf: %u, eeprom: %u), setting %u",
488 			data->ref_mode, ref, data->ref_mode);
489 		err = mcp4726_set_cfg(indio_dev);
490 		if (err < 0)
491 			goto err_disable_vref_reg;
492 	}
493 
494 	err = iio_device_register(indio_dev);
495 	if (err)
496 		goto err_disable_vref_reg;
497 
498 	return 0;
499 
500 err_disable_vref_reg:
501 	if (data->vref_reg)
502 		regulator_disable(data->vref_reg);
503 
504 err_disable_vdd_reg:
505 	regulator_disable(data->vdd_reg);
506 
507 	return err;
508 }
509 
510 static int mcp4725_remove(struct i2c_client *client)
511 {
512 	struct iio_dev *indio_dev = i2c_get_clientdata(client);
513 	struct mcp4725_data *data = iio_priv(indio_dev);
514 
515 	iio_device_unregister(indio_dev);
516 
517 	if (data->vref_reg)
518 		regulator_disable(data->vref_reg);
519 	regulator_disable(data->vdd_reg);
520 
521 	return 0;
522 }
523 
524 static const struct i2c_device_id mcp4725_id[] = {
525 	{ "mcp4725", MCP4725 },
526 	{ "mcp4726", MCP4726 },
527 	{ }
528 };
529 MODULE_DEVICE_TABLE(i2c, mcp4725_id);
530 
531 #ifdef CONFIG_OF
532 static const struct of_device_id mcp4725_of_match[] = {
533 	{
534 		.compatible = "microchip,mcp4725",
535 		.data = (void *)MCP4725
536 	},
537 	{
538 		.compatible = "microchip,mcp4726",
539 		.data = (void *)MCP4726
540 	},
541 	{ }
542 };
543 MODULE_DEVICE_TABLE(of, mcp4725_of_match);
544 #endif
545 
546 static struct i2c_driver mcp4725_driver = {
547 	.driver = {
548 		.name	= MCP4725_DRV_NAME,
549 		.of_match_table = of_match_ptr(mcp4725_of_match),
550 		.pm	= MCP4725_PM_OPS,
551 	},
552 	.probe		= mcp4725_probe,
553 	.remove		= mcp4725_remove,
554 	.id_table	= mcp4725_id,
555 };
556 module_i2c_driver(mcp4725_driver);
557 
558 MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>");
559 MODULE_DESCRIPTION("MCP4725/6 12-bit DAC");
560 MODULE_LICENSE("GPL");
561