[linux.git] / drivers / iio / dac / max5821.c

 /*
  * iio/dac/max5821.c
  * Copyright (C) 2014 Philippe Reynes
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/iio/iio.h>
#include <linux/regulator/consumer.h>

#define MAX5821_MAX_DAC_CHANNELS		2

/* command bytes */
#define MAX5821_LOAD_DAC_A_IN_REG_B		0x00
#define MAX5821_LOAD_DAC_B_IN_REG_A		0x10
#define MAX5821_EXTENDED_COMMAND_MODE		0xf0
#define MAX5821_READ_DAC_A_COMMAND		0xf1
#define MAX5821_READ_DAC_B_COMMAND		0xf2

#define MAX5821_EXTENDED_POWER_UP		0x00
#define MAX5821_EXTENDED_POWER_DOWN_MODE0	0x01
#define MAX5821_EXTENDED_POWER_DOWN_MODE1	0x02
#define MAX5821_EXTENDED_POWER_DOWN_MODE2	0x03
#define MAX5821_EXTENDED_DAC_A			0x04
#define MAX5821_EXTENDED_DAC_B			0x08

enum max5821_device_ids {
	ID_MAX5821,
};

struct max5821_data {
	struct i2c_client	*client;
	struct regulator	*vref_reg;
	unsigned short		vref_mv;
	bool			powerdown[MAX5821_MAX_DAC_CHANNELS];
	u8			powerdown_mode[MAX5821_MAX_DAC_CHANNELS];
	struct mutex		lock;
};

static const char * const max5821_powerdown_modes[] = {
	"three_state",
	"1kohm_to_gnd",
	"100kohm_to_gnd",
};

enum {
	MAX5821_THREE_STATE,
	MAX5821_1KOHM_TO_GND,
	MAX5821_100KOHM_TO_GND
};

static int max5821_get_powerdown_mode(struct iio_dev *indio_dev,
				      const struct iio_chan_spec *chan)
{
	struct max5821_data *st = iio_priv(indio_dev);

	return st->powerdown_mode[chan->channel];
}

static int max5821_set_powerdown_mode(struct iio_dev *indio_dev,
				      const struct iio_chan_spec *chan,
				      unsigned int mode)
{
	struct max5821_data *st = iio_priv(indio_dev);

	st->powerdown_mode[chan->channel] = mode;

	return 0;
}

static const struct iio_enum max5821_powerdown_mode_enum = {
	.items = max5821_powerdown_modes,
	.num_items = ARRAY_SIZE(max5821_powerdown_modes),
	.get = max5821_get_powerdown_mode,
	.set = max5821_set_powerdown_mode,
};

static ssize_t max5821_read_dac_powerdown(struct iio_dev *indio_dev,
					  uintptr_t private,
					  const struct iio_chan_spec *chan,
					  char *buf)
{
	struct max5821_data *st = iio_priv(indio_dev);

	return sprintf(buf, "%d\n", st->powerdown[chan->channel]);
}

static int max5821_sync_powerdown_mode(struct max5821_data *data,
				       const struct iio_chan_spec *chan)
{
	u8 outbuf[2];

	outbuf[0] = MAX5821_EXTENDED_COMMAND_MODE;

	if (chan->channel == 0)
		outbuf[1] = MAX5821_EXTENDED_DAC_A;
	else
		outbuf[1] = MAX5821_EXTENDED_DAC_B;

	if (data->powerdown[chan->channel])
		outbuf[1] |= data->powerdown_mode[chan->channel] + 1;
	else
		outbuf[1] |= MAX5821_EXTENDED_POWER_UP;

	return i2c_master_send(data->client, outbuf, 2);
}

static ssize_t max5821_write_dac_powerdown(struct iio_dev *indio_dev,
					   uintptr_t private,
					   const struct iio_chan_spec *chan,
					   const char *buf, size_t len)
{
	struct max5821_data *data = iio_priv(indio_dev);
	bool powerdown;
	int ret;

	ret = strtobool(buf, &powerdown);
	if (ret)
		return ret;

	data->powerdown[chan->channel] = powerdown;

	ret = max5821_sync_powerdown_mode(data, chan);
	if (ret < 0)
		return ret;

	return len;
}

static const struct iio_chan_spec_ext_info max5821_ext_info[] = {
	{
		.name = "powerdown",
		.read = max5821_read_dac_powerdown,
		.write = max5821_write_dac_powerdown,
		.shared = IIO_SEPARATE,
	},
	IIO_ENUM("powerdown_mode", IIO_SEPARATE, &max5821_powerdown_mode_enum),
	IIO_ENUM_AVAILABLE("powerdown_mode", &max5821_powerdown_mode_enum),
	{ },
};

#define MAX5821_CHANNEL(chan) {					\
	.type = IIO_VOLTAGE,					\
	.indexed = 1,						\
	.output = 1,						\
	.channel = (chan),					\
	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW),		\
	.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SCALE),	\
	.ext_info = max5821_ext_info,				\
}

static const struct iio_chan_spec max5821_channels[] = {
	MAX5821_CHANNEL(0),
	MAX5821_CHANNEL(1)
};

static const u8 max5821_read_dac_command[] = {
	MAX5821_READ_DAC_A_COMMAND,
	MAX5821_READ_DAC_B_COMMAND
};

static const u8 max5821_load_dac_command[] = {
	MAX5821_LOAD_DAC_A_IN_REG_B,
	MAX5821_LOAD_DAC_B_IN_REG_A
};

static int max5821_get_value(struct iio_dev *indio_dev,
			     int *val, int channel)
{
	struct max5821_data *data = iio_priv(indio_dev);
	struct i2c_client *client = data->client;
	u8 outbuf[1];
	u8 inbuf[2];
	int ret;

	if ((channel != 0) && (channel != 1))
		return -EINVAL;

	outbuf[0] = max5821_read_dac_command[channel];

	mutex_lock(&data->lock);

	ret = i2c_master_send(client, outbuf, 1);
	if (ret < 0) {
		mutex_unlock(&data->lock);
		return ret;
	} else if (ret != 1) {
		mutex_unlock(&data->lock);
		return -EIO;
	}

	ret = i2c_master_recv(client, inbuf, 2);
	if (ret < 0) {
		mutex_unlock(&data->lock);
		return ret;
	} else if (ret != 2) {
		mutex_unlock(&data->lock);
		return -EIO;
	}

	mutex_unlock(&data->lock);

	*val = ((inbuf[0] & 0x0f) << 6) | (inbuf[1] >> 2);

	return IIO_VAL_INT;
}

static int max5821_set_value(struct iio_dev *indio_dev,
			     int val, int channel)
{
	struct max5821_data *data = iio_priv(indio_dev);
	struct i2c_client *client = data->client;
	u8 outbuf[2];
	int ret;

	if ((val < 0) || (val > 1023))
		return -EINVAL;

	if ((channel != 0) && (channel != 1))
		return -EINVAL;

	outbuf[0] = max5821_load_dac_command[channel];
	outbuf[0] |= val >> 6;
	outbuf[1] = (val & 0x3f) << 2;

	ret = i2c_master_send(client, outbuf, 2);
	if (ret < 0)
		return ret;
	else if (ret != 2)
		return -EIO;
	else
		return 0;
}

static int max5821_read_raw(struct iio_dev *indio_dev,
			   struct iio_chan_spec const *chan,
			   int *val, int *val2, long mask)
{
	struct max5821_data *data = iio_priv(indio_dev);

	switch (mask) {
	case IIO_CHAN_INFO_RAW:
		return max5821_get_value(indio_dev, val, chan->channel);
	case IIO_CHAN_INFO_SCALE:
		*val = data->vref_mv;
		*val2 = 10;
		return IIO_VAL_FRACTIONAL_LOG2;
	default:
		return -EINVAL;
	}
}

static int max5821_write_raw(struct iio_dev *indio_dev,
			     struct iio_chan_spec const *chan,
			     int val, int val2, long mask)
{
	if (val2 != 0)
		return -EINVAL;

	switch (mask) {
	case IIO_CHAN_INFO_RAW:
		return max5821_set_value(indio_dev, val, chan->channel);
	default:
		return -EINVAL;
	}
}

static int __maybe_unused max5821_suspend(struct device *dev)
{
	u8 outbuf[2] = { MAX5821_EXTENDED_COMMAND_MODE,
			 MAX5821_EXTENDED_DAC_A |
			 MAX5821_EXTENDED_DAC_B |
			 MAX5821_EXTENDED_POWER_DOWN_MODE2 };

	return i2c_master_send(to_i2c_client(dev), outbuf, 2);
}

static int __maybe_unused max5821_resume(struct device *dev)
{
	u8 outbuf[2] = { MAX5821_EXTENDED_COMMAND_MODE,
			 MAX5821_EXTENDED_DAC_A |
			 MAX5821_EXTENDED_DAC_B |
			 MAX5821_EXTENDED_POWER_UP };

	return i2c_master_send(to_i2c_client(dev), outbuf, 2);
}

static SIMPLE_DEV_PM_OPS(max5821_pm_ops, max5821_suspend, max5821_resume);

static const struct iio_info max5821_info = {
	.read_raw = max5821_read_raw,
	.write_raw = max5821_write_raw,
};

static int max5821_probe(struct i2c_client *client,
			const struct i2c_device_id *id)
{
	struct max5821_data *data;
	struct iio_dev *indio_dev;
	u32 tmp;
	int ret;

	indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
	if (!indio_dev)
		return -ENOMEM;
	data = iio_priv(indio_dev);
	i2c_set_clientdata(client, indio_dev);
	data->client = client;
	mutex_init(&data->lock);

	/* max5821 start in powerdown mode 100Kohm to ground */
	for (tmp = 0; tmp < MAX5821_MAX_DAC_CHANNELS; tmp++) {
		data->powerdown[tmp] = true;
		data->powerdown_mode[tmp] = MAX5821_100KOHM_TO_GND;
	}

	data->vref_reg = devm_regulator_get(&client->dev, "vref");
	if (IS_ERR(data->vref_reg)) {
		ret = PTR_ERR(data->vref_reg);
		dev_err(&client->dev,
			"Failed to get vref regulator: %d\n", ret);
		goto error_free_reg;
	}

	ret = regulator_enable(data->vref_reg);
	if (ret) {
		dev_err(&client->dev,
			"Failed to enable vref regulator: %d\n", ret);
		goto error_free_reg;
	}

	ret = regulator_get_voltage(data->vref_reg);
	if (ret < 0) {
		dev_err(&client->dev,
			"Failed to get voltage on regulator: %d\n", ret);
		goto error_disable_reg;
	}

	data->vref_mv = ret / 1000;

	indio_dev->name = id->name;
	indio_dev->dev.parent = &client->dev;
	indio_dev->num_channels = ARRAY_SIZE(max5821_channels);
	indio_dev->channels = max5821_channels;
	indio_dev->modes = INDIO_DIRECT_MODE;
	indio_dev->info = &max5821_info;

	return iio_device_register(indio_dev);

error_disable_reg:
	regulator_disable(data->vref_reg);

error_free_reg:

	return ret;
}

static int max5821_remove(struct i2c_client *client)
{
	struct iio_dev *indio_dev = i2c_get_clientdata(client);
	struct max5821_data *data = iio_priv(indio_dev);

	iio_device_unregister(indio_dev);
	regulator_disable(data->vref_reg);

	return 0;
}

static const struct i2c_device_id max5821_id[] = {
	{ "max5821", ID_MAX5821 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, max5821_id);

static const struct of_device_id max5821_of_match[] = {
	{ .compatible = "maxim,max5821" },
	{ }
};
MODULE_DEVICE_TABLE(of, max5821_of_match);

static struct i2c_driver max5821_driver = {
	.driver = {
		.name	= "max5821",
		.of_match_table = max5821_of_match,
		.pm     = &max5821_pm_ops,
	},
	.probe		= max5821_probe,
	.remove		= max5821_remove,
	.id_table	= max5821_id,
};
module_i2c_driver(max5821_driver);

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