1/*
2 * mcp4725.c - Support for Microchip MCP4725
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
22#include <linux/iio/iio.h>
23#include <linux/iio/sysfs.h>
24
25#include <linux/iio/dac/mcp4725.h>
26
27#define MCP4725_DRV_NAME "mcp4725"
28
29struct mcp4725_data {
30	struct i2c_client *client;
31	u16 vref_mv;
32	u16 dac_value;
33	bool powerdown;
34	unsigned powerdown_mode;
35};
36
37static int mcp4725_suspend(struct device *dev)
38{
39	struct mcp4725_data *data = iio_priv(i2c_get_clientdata(
40		to_i2c_client(dev)));
41	u8 outbuf[2];
42
43	outbuf[0] = (data->powerdown_mode + 1) << 4;
44	outbuf[1] = 0;
45	data->powerdown = true;
46
47	return i2c_master_send(data->client, outbuf, 2);
48}
49
50static int mcp4725_resume(struct device *dev)
51{
52	struct mcp4725_data *data = iio_priv(i2c_get_clientdata(
53		to_i2c_client(dev)));
54	u8 outbuf[2];
55
56	/* restore previous DAC value */
57	outbuf[0] = (data->dac_value >> 8) & 0xf;
58	outbuf[1] = data->dac_value & 0xff;
59	data->powerdown = false;
60
61	return i2c_master_send(data->client, outbuf, 2);
62}
63
64#ifdef CONFIG_PM_SLEEP
65static SIMPLE_DEV_PM_OPS(mcp4725_pm_ops, mcp4725_suspend, mcp4725_resume);
66#define MCP4725_PM_OPS (&mcp4725_pm_ops)
67#else
68#define MCP4725_PM_OPS NULL
69#endif
70
71static ssize_t mcp4725_store_eeprom(struct device *dev,
72	struct device_attribute *attr, const char *buf, size_t len)
73{
74	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
75	struct mcp4725_data *data = iio_priv(indio_dev);
76	int tries = 20;
77	u8 inoutbuf[3];
78	bool state;
79	int ret;
80
81	ret = strtobool(buf, &state);
82	if (ret < 0)
83		return ret;
84
85	if (!state)
86		return 0;
87
88	inoutbuf[0] = 0x60; /* write EEPROM */
89	inoutbuf[1] = data->dac_value >> 4;
90	inoutbuf[2] = (data->dac_value & 0xf) << 4;
91
92	ret = i2c_master_send(data->client, inoutbuf, 3);
93	if (ret < 0)
94		return ret;
95	else if (ret != 3)
96		return -EIO;
97
98	/* wait for write complete, takes up to 50ms */
99	while (tries--) {
100		msleep(20);
101		ret = i2c_master_recv(data->client, inoutbuf, 3);
102		if (ret < 0)
103			return ret;
104		else if (ret != 3)
105			return -EIO;
106
107		if (inoutbuf[0] & 0x80)
108			break;
109	}
110
111	if (tries < 0) {
112		dev_err(&data->client->dev,
113			"mcp4725_store_eeprom() failed, incomplete\n");
114		return -EIO;
115	}
116
117	return len;
118}
119
120static IIO_DEVICE_ATTR(store_eeprom, S_IWUSR, NULL, mcp4725_store_eeprom, 0);
121
122static struct attribute *mcp4725_attributes[] = {
123	&iio_dev_attr_store_eeprom.dev_attr.attr,
124	NULL,
125};
126
127static const struct attribute_group mcp4725_attribute_group = {
128	.attrs = mcp4725_attributes,
129};
130
131static const char * const mcp4725_powerdown_modes[] = {
132	"1kohm_to_gnd",
133	"100kohm_to_gnd",
134	"500kohm_to_gnd"
135};
136
137static int mcp4725_get_powerdown_mode(struct iio_dev *indio_dev,
138	const struct iio_chan_spec *chan)
139{
140	struct mcp4725_data *data = iio_priv(indio_dev);
141
142	return data->powerdown_mode;
143}
144
145static int mcp4725_set_powerdown_mode(struct iio_dev *indio_dev,
146	const struct iio_chan_spec *chan, unsigned mode)
147{
148	struct mcp4725_data *data = iio_priv(indio_dev);
149
150	data->powerdown_mode = mode;
151
152	return 0;
153}
154
155static ssize_t mcp4725_read_powerdown(struct iio_dev *indio_dev,
156	uintptr_t private, const struct iio_chan_spec *chan, char *buf)
157{
158	struct mcp4725_data *data = iio_priv(indio_dev);
159
160	return sprintf(buf, "%d\n", data->powerdown);
161}
162
163static ssize_t mcp4725_write_powerdown(struct iio_dev *indio_dev,
164	 uintptr_t private, const struct iio_chan_spec *chan,
165	 const char *buf, size_t len)
166{
167	struct mcp4725_data *data = iio_priv(indio_dev);
168	bool state;
169	int ret;
170
171	ret = strtobool(buf, &state);
172	if (ret)
173		return ret;
174
175	if (state)
176		ret = mcp4725_suspend(&data->client->dev);
177	else
178		ret = mcp4725_resume(&data->client->dev);
179	if (ret < 0)
180		return ret;
181
182	return len;
183}
184
185static const struct iio_enum mcp4725_powerdown_mode_enum = {
186	.items = mcp4725_powerdown_modes,
187	.num_items = ARRAY_SIZE(mcp4725_powerdown_modes),
188	.get = mcp4725_get_powerdown_mode,
189	.set = mcp4725_set_powerdown_mode,
190};
191
192static const struct iio_chan_spec_ext_info mcp4725_ext_info[] = {
193	{
194		.name = "powerdown",
195		.read = mcp4725_read_powerdown,
196		.write = mcp4725_write_powerdown,
197		.shared = IIO_SEPARATE,
198	},
199	IIO_ENUM("powerdown_mode", IIO_SEPARATE, &mcp4725_powerdown_mode_enum),
200	IIO_ENUM_AVAILABLE("powerdown_mode", &mcp4725_powerdown_mode_enum),
201	{ },
202};
203
204static const struct iio_chan_spec mcp4725_channel = {
205	.type		= IIO_VOLTAGE,
206	.indexed	= 1,
207	.output		= 1,
208	.channel	= 0,
209	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
210	.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
211	.ext_info	= mcp4725_ext_info,
212};
213
214static int mcp4725_set_value(struct iio_dev *indio_dev, int val)
215{
216	struct mcp4725_data *data = iio_priv(indio_dev);
217	u8 outbuf[2];
218	int ret;
219
220	if (val >= (1 << 12) || val < 0)
221		return -EINVAL;
222
223	outbuf[0] = (val >> 8) & 0xf;
224	outbuf[1] = val & 0xff;
225
226	ret = i2c_master_send(data->client, outbuf, 2);
227	if (ret < 0)
228		return ret;
229	else if (ret != 2)
230		return -EIO;
231	else
232		return 0;
233}
234
235static int mcp4725_read_raw(struct iio_dev *indio_dev,
236			   struct iio_chan_spec const *chan,
237			   int *val, int *val2, long mask)
238{
239	struct mcp4725_data *data = iio_priv(indio_dev);
240
241	switch (mask) {
242	case IIO_CHAN_INFO_RAW:
243		*val = data->dac_value;
244		return IIO_VAL_INT;
245	case IIO_CHAN_INFO_SCALE:
246		*val = data->vref_mv;
247		*val2 = 12;
248		return IIO_VAL_FRACTIONAL_LOG2;
249	}
250	return -EINVAL;
251}
252
253static int mcp4725_write_raw(struct iio_dev *indio_dev,
254			       struct iio_chan_spec const *chan,
255			       int val, int val2, long mask)
256{
257	struct mcp4725_data *data = iio_priv(indio_dev);
258	int ret;
259
260	switch (mask) {
261	case IIO_CHAN_INFO_RAW:
262		ret = mcp4725_set_value(indio_dev, val);
263		data->dac_value = val;
264		break;
265	default:
266		ret = -EINVAL;
267		break;
268	}
269
270	return ret;
271}
272
273static const struct iio_info mcp4725_info = {
274	.read_raw = mcp4725_read_raw,
275	.write_raw = mcp4725_write_raw,
276	.attrs = &mcp4725_attribute_group,
277	.driver_module = THIS_MODULE,
278};
279
280static int mcp4725_probe(struct i2c_client *client,
281			 const struct i2c_device_id *id)
282{
283	struct mcp4725_data *data;
284	struct iio_dev *indio_dev;
285	struct mcp4725_platform_data *platform_data = client->dev.platform_data;
286	u8 inbuf[3];
287	u8 pd;
288	int err;
289
290	if (!platform_data || !platform_data->vref_mv) {
291		dev_err(&client->dev, "invalid platform data");
292		return -EINVAL;
293	}
294
295	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
296	if (indio_dev == NULL)
297		return -ENOMEM;
298	data = iio_priv(indio_dev);
299	i2c_set_clientdata(client, indio_dev);
300	data->client = client;
301
302	indio_dev->dev.parent = &client->dev;
303	indio_dev->name = id->name;
304	indio_dev->info = &mcp4725_info;
305	indio_dev->channels = &mcp4725_channel;
306	indio_dev->num_channels = 1;
307	indio_dev->modes = INDIO_DIRECT_MODE;
308
309	data->vref_mv = platform_data->vref_mv;
310
311	/* read current DAC value */
312	err = i2c_master_recv(client, inbuf, 3);
313	if (err < 0) {
314		dev_err(&client->dev, "failed to read DAC value");
315		return err;
316	}
317	pd = (inbuf[0] >> 1) & 0x3;
318	data->powerdown = pd > 0 ? true : false;
319	data->powerdown_mode = pd ? pd-1 : 2; /* 500kohm_to_gnd */
320	data->dac_value = (inbuf[1] << 4) | (inbuf[2] >> 4);
321
322	return iio_device_register(indio_dev);
323}
324
325static int mcp4725_remove(struct i2c_client *client)
326{
327	iio_device_unregister(i2c_get_clientdata(client));
328	return 0;
329}
330
331static const struct i2c_device_id mcp4725_id[] = {
332	{ "mcp4725", 0 },
333	{ }
334};
335MODULE_DEVICE_TABLE(i2c, mcp4725_id);
336
337static struct i2c_driver mcp4725_driver = {
338	.driver = {
339		.name	= MCP4725_DRV_NAME,
340		.pm	= MCP4725_PM_OPS,
341	},
342	.probe		= mcp4725_probe,
343	.remove		= mcp4725_remove,
344	.id_table	= mcp4725_id,
345};
346module_i2c_driver(mcp4725_driver);
347
348MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>");
349MODULE_DESCRIPTION("MCP4725 12-bit DAC");
350MODULE_LICENSE("GPL");
351