1// SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * iio/dac/max5821.c
4  * Copyright (C) 2014 Philippe Reynes
5  */
6
7#include <linux/kernel.h>
8#include <linux/module.h>
9#include <linux/i2c.h>
10#include <linux/iio/iio.h>
11#include <linux/regulator/consumer.h>
12
13#define MAX5821_MAX_DAC_CHANNELS		2
14
15/* command bytes */
16#define MAX5821_LOAD_DAC_A_IN_REG_B		0x00
17#define MAX5821_LOAD_DAC_B_IN_REG_A		0x10
18#define MAX5821_EXTENDED_COMMAND_MODE		0xf0
19#define MAX5821_READ_DAC_A_COMMAND		0xf1
20#define MAX5821_READ_DAC_B_COMMAND		0xf2
21
22#define MAX5821_EXTENDED_POWER_UP		0x00
23#define MAX5821_EXTENDED_POWER_DOWN_MODE0	0x01
24#define MAX5821_EXTENDED_POWER_DOWN_MODE1	0x02
25#define MAX5821_EXTENDED_POWER_DOWN_MODE2	0x03
26#define MAX5821_EXTENDED_DAC_A			0x04
27#define MAX5821_EXTENDED_DAC_B			0x08
28
29enum max5821_device_ids {
30	ID_MAX5821,
31};
32
33struct max5821_data {
34	struct i2c_client	*client;
35	struct regulator	*vref_reg;
36	unsigned short		vref_mv;
37	bool			powerdown[MAX5821_MAX_DAC_CHANNELS];
38	u8			powerdown_mode[MAX5821_MAX_DAC_CHANNELS];
39	struct mutex		lock;
40};
41
42static const char * const max5821_powerdown_modes[] = {
43	"three_state",
44	"1kohm_to_gnd",
45	"100kohm_to_gnd",
46};
47
48enum {
49	MAX5821_THREE_STATE,
50	MAX5821_1KOHM_TO_GND,
51	MAX5821_100KOHM_TO_GND
52};
53
54static int max5821_get_powerdown_mode(struct iio_dev *indio_dev,
55				      const struct iio_chan_spec *chan)
56{
57	struct max5821_data *st = iio_priv(indio_dev);
58
59	return st->powerdown_mode[chan->channel];
60}
61
62static int max5821_set_powerdown_mode(struct iio_dev *indio_dev,
63				      const struct iio_chan_spec *chan,
64				      unsigned int mode)
65{
66	struct max5821_data *st = iio_priv(indio_dev);
67
68	st->powerdown_mode[chan->channel] = mode;
69
70	return 0;
71}
72
73static const struct iio_enum max5821_powerdown_mode_enum = {
74	.items = max5821_powerdown_modes,
75	.num_items = ARRAY_SIZE(max5821_powerdown_modes),
76	.get = max5821_get_powerdown_mode,
77	.set = max5821_set_powerdown_mode,
78};
79
80static ssize_t max5821_read_dac_powerdown(struct iio_dev *indio_dev,
81					  uintptr_t private,
82					  const struct iio_chan_spec *chan,
83					  char *buf)
84{
85	struct max5821_data *st = iio_priv(indio_dev);
86
87	return sprintf(buf, "%d\n", st->powerdown[chan->channel]);
88}
89
90static int max5821_sync_powerdown_mode(struct max5821_data *data,
91				       const struct iio_chan_spec *chan)
92{
93	u8 outbuf[2];
94
95	outbuf[0] = MAX5821_EXTENDED_COMMAND_MODE;
96
97	if (chan->channel == 0)
98		outbuf[1] = MAX5821_EXTENDED_DAC_A;
99	else
100		outbuf[1] = MAX5821_EXTENDED_DAC_B;
101
102	if (data->powerdown[chan->channel])
103		outbuf[1] |= data->powerdown_mode[chan->channel] + 1;
104	else
105		outbuf[1] |= MAX5821_EXTENDED_POWER_UP;
106
107	return i2c_master_send(data->client, outbuf, 2);
108}
109
110static ssize_t max5821_write_dac_powerdown(struct iio_dev *indio_dev,
111					   uintptr_t private,
112					   const struct iio_chan_spec *chan,
113					   const char *buf, size_t len)
114{
115	struct max5821_data *data = iio_priv(indio_dev);
116	bool powerdown;
117	int ret;
118
119	ret = strtobool(buf, &powerdown);
120	if (ret)
121		return ret;
122
123	data->powerdown[chan->channel] = powerdown;
124
125	ret = max5821_sync_powerdown_mode(data, chan);
126	if (ret < 0)
127		return ret;
128
129	return len;
130}
131
132static const struct iio_chan_spec_ext_info max5821_ext_info[] = {
133	{
134		.name = "powerdown",
135		.read = max5821_read_dac_powerdown,
136		.write = max5821_write_dac_powerdown,
137		.shared = IIO_SEPARATE,
138	},
139	IIO_ENUM("powerdown_mode", IIO_SEPARATE, &max5821_powerdown_mode_enum),
140	IIO_ENUM_AVAILABLE("powerdown_mode", &max5821_powerdown_mode_enum),
141	{ },
142};
143
144#define MAX5821_CHANNEL(chan) {					\
145	.type = IIO_VOLTAGE,					\
146	.indexed = 1,						\
147	.output = 1,						\
148	.channel = (chan),					\
149	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),		\
150	.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SCALE),	\
151	.ext_info = max5821_ext_info,				\
152}
153
154static const struct iio_chan_spec max5821_channels[] = {
155	MAX5821_CHANNEL(0),
156	MAX5821_CHANNEL(1)
157};
158
159static const u8 max5821_read_dac_command[] = {
160	MAX5821_READ_DAC_A_COMMAND,
161	MAX5821_READ_DAC_B_COMMAND
162};
163
164static const u8 max5821_load_dac_command[] = {
165	MAX5821_LOAD_DAC_A_IN_REG_B,
166	MAX5821_LOAD_DAC_B_IN_REG_A
167};
168
169static int max5821_get_value(struct iio_dev *indio_dev,
170			     int *val, int channel)
171{
172	struct max5821_data *data = iio_priv(indio_dev);
173	struct i2c_client *client = data->client;
174	u8 outbuf[1];
175	u8 inbuf[2];
176	int ret;
177
178	if ((channel != 0) && (channel != 1))
179		return -EINVAL;
180
181	outbuf[0] = max5821_read_dac_command[channel];
182
183	mutex_lock(&data->lock);
184
185	ret = i2c_master_send(client, outbuf, 1);
186	if (ret < 0) {
187		mutex_unlock(&data->lock);
188		return ret;
189	} else if (ret != 1) {
190		mutex_unlock(&data->lock);
191		return -EIO;
192	}
193
194	ret = i2c_master_recv(client, inbuf, 2);
195	if (ret < 0) {
196		mutex_unlock(&data->lock);
197		return ret;
198	} else if (ret != 2) {
199		mutex_unlock(&data->lock);
200		return -EIO;
201	}
202
203	mutex_unlock(&data->lock);
204
205	*val = ((inbuf[0] & 0x0f) << 6) | (inbuf[1] >> 2);
206
207	return IIO_VAL_INT;
208}
209
210static int max5821_set_value(struct iio_dev *indio_dev,
211			     int val, int channel)
212{
213	struct max5821_data *data = iio_priv(indio_dev);
214	struct i2c_client *client = data->client;
215	u8 outbuf[2];
216	int ret;
217
218	if ((val < 0) || (val > 1023))
219		return -EINVAL;
220
221	if ((channel != 0) && (channel != 1))
222		return -EINVAL;
223
224	outbuf[0] = max5821_load_dac_command[channel];
225	outbuf[0] |= val >> 6;
226	outbuf[1] = (val & 0x3f) << 2;
227
228	ret = i2c_master_send(client, outbuf, 2);
229	if (ret < 0)
230		return ret;
231	else if (ret != 2)
232		return -EIO;
233	else
234		return 0;
235}
236
237static int max5821_read_raw(struct iio_dev *indio_dev,
238			   struct iio_chan_spec const *chan,
239			   int *val, int *val2, long mask)
240{
241	struct max5821_data *data = iio_priv(indio_dev);
242
243	switch (mask) {
244	case IIO_CHAN_INFO_RAW:
245		return max5821_get_value(indio_dev, val, chan->channel);
246	case IIO_CHAN_INFO_SCALE:
247		*val = data->vref_mv;
248		*val2 = 10;
249		return IIO_VAL_FRACTIONAL_LOG2;
250	default:
251		return -EINVAL;
252	}
253}
254
255static int max5821_write_raw(struct iio_dev *indio_dev,
256			     struct iio_chan_spec const *chan,
257			     int val, int val2, long mask)
258{
259	if (val2 != 0)
260		return -EINVAL;
261
262	switch (mask) {
263	case IIO_CHAN_INFO_RAW:
264		return max5821_set_value(indio_dev, val, chan->channel);
265	default:
266		return -EINVAL;
267	}
268}
269
270static int __maybe_unused max5821_suspend(struct device *dev)
271{
272	u8 outbuf[2] = { MAX5821_EXTENDED_COMMAND_MODE,
273			 MAX5821_EXTENDED_DAC_A |
274			 MAX5821_EXTENDED_DAC_B |
275			 MAX5821_EXTENDED_POWER_DOWN_MODE2 };
276
277	return i2c_master_send(to_i2c_client(dev), outbuf, 2);
278}
279
280static int __maybe_unused max5821_resume(struct device *dev)
281{
282	u8 outbuf[2] = { MAX5821_EXTENDED_COMMAND_MODE,
283			 MAX5821_EXTENDED_DAC_A |
284			 MAX5821_EXTENDED_DAC_B |
285			 MAX5821_EXTENDED_POWER_UP };
286
287	return i2c_master_send(to_i2c_client(dev), outbuf, 2);
288}
289
290static SIMPLE_DEV_PM_OPS(max5821_pm_ops, max5821_suspend, max5821_resume);
291
292static const struct iio_info max5821_info = {
293	.read_raw = max5821_read_raw,
294	.write_raw = max5821_write_raw,
295};
296
297static int max5821_probe(struct i2c_client *client,
298			const struct i2c_device_id *id)
299{
300	struct max5821_data *data;
301	struct iio_dev *indio_dev;
302	u32 tmp;
303	int ret;
304
305	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
306	if (!indio_dev)
307		return -ENOMEM;
308	data = iio_priv(indio_dev);
309	i2c_set_clientdata(client, indio_dev);
310	data->client = client;
311	mutex_init(&data->lock);
312
313	/* max5821 start in powerdown mode 100Kohm to ground */
314	for (tmp = 0; tmp < MAX5821_MAX_DAC_CHANNELS; tmp++) {
315		data->powerdown[tmp] = true;
316		data->powerdown_mode[tmp] = MAX5821_100KOHM_TO_GND;
317	}
318
319	data->vref_reg = devm_regulator_get(&client->dev, "vref");
320	if (IS_ERR(data->vref_reg)) {
321		ret = PTR_ERR(data->vref_reg);
322		dev_err(&client->dev,
323			"Failed to get vref regulator: %d\n", ret);
324		goto error_free_reg;
325	}
326
327	ret = regulator_enable(data->vref_reg);
328	if (ret) {
329		dev_err(&client->dev,
330			"Failed to enable vref regulator: %d\n", ret);
331		goto error_free_reg;
332	}
333
334	ret = regulator_get_voltage(data->vref_reg);
335	if (ret < 0) {
336		dev_err(&client->dev,
337			"Failed to get voltage on regulator: %d\n", ret);
338		goto error_disable_reg;
339	}
340
341	data->vref_mv = ret / 1000;
342
343	indio_dev->name = id->name;
344	indio_dev->num_channels = ARRAY_SIZE(max5821_channels);
345	indio_dev->channels = max5821_channels;
346	indio_dev->modes = INDIO_DIRECT_MODE;
347	indio_dev->info = &max5821_info;
348
349	return iio_device_register(indio_dev);
350
351error_disable_reg:
352	regulator_disable(data->vref_reg);
353
354error_free_reg:
355
356	return ret;
357}
358
359static int max5821_remove(struct i2c_client *client)
360{
361	struct iio_dev *indio_dev = i2c_get_clientdata(client);
362	struct max5821_data *data = iio_priv(indio_dev);
363
364	iio_device_unregister(indio_dev);
365	regulator_disable(data->vref_reg);
366
367	return 0;
368}
369
370static const struct i2c_device_id max5821_id[] = {
371	{ "max5821", ID_MAX5821 },
372	{ }
373};
374MODULE_DEVICE_TABLE(i2c, max5821_id);
375
376static const struct of_device_id max5821_of_match[] = {
377	{ .compatible = "maxim,max5821" },
378	{ }
379};
380MODULE_DEVICE_TABLE(of, max5821_of_match);
381
382static struct i2c_driver max5821_driver = {
383	.driver = {
384		.name	= "max5821",
385		.of_match_table = max5821_of_match,
386		.pm     = &max5821_pm_ops,
387	},
388	.probe		= max5821_probe,
389	.remove		= max5821_remove,
390	.id_table	= max5821_id,
391};
392module_i2c_driver(max5821_driver);
393
394MODULE_AUTHOR("Philippe Reynes <tremyfr@yahoo.fr>");
395MODULE_DESCRIPTION("MAX5821 DAC");
396MODULE_LICENSE("GPL v2");
397