1/*
2 * AD5446 SPI DAC driver
3 *
4 * Copyright 2010 Analog Devices Inc.
5 *
6 * Licensed under the GPL-2 or later.
7 */
8
9#include <linux/interrupt.h>
10#include <linux/workqueue.h>
11#include <linux/device.h>
12#include <linux/kernel.h>
13#include <linux/slab.h>
14#include <linux/sysfs.h>
15#include <linux/list.h>
16#include <linux/spi/spi.h>
17#include <linux/i2c.h>
18#include <linux/regulator/consumer.h>
19#include <linux/err.h>
20#include <linux/module.h>
21
22#include <linux/iio/iio.h>
23#include <linux/iio/sysfs.h>
24
25#define MODE_PWRDWN_1k		0x1
26#define MODE_PWRDWN_100k	0x2
27#define MODE_PWRDWN_TRISTATE	0x3
28
29/**
30 * struct ad5446_state - driver instance specific data
31 * @spi:		spi_device
32 * @chip_info:		chip model specific constants, available modes etc
33 * @reg:		supply regulator
34 * @vref_mv:		actual reference voltage used
35 */
36
37struct ad5446_state {
38	struct device		*dev;
39	const struct ad5446_chip_info	*chip_info;
40	struct regulator		*reg;
41	unsigned short			vref_mv;
42	unsigned			cached_val;
43	unsigned			pwr_down_mode;
44	unsigned			pwr_down;
45};
46
47/**
48 * struct ad5446_chip_info - chip specific information
49 * @channel:		channel spec for the DAC
50 * @int_vref_mv:	AD5620/40/60: the internal reference voltage
51 * @write:		chip specific helper function to write to the register
52 */
53
54struct ad5446_chip_info {
55	struct iio_chan_spec	channel;
56	u16			int_vref_mv;
57	int			(*write)(struct ad5446_state *st, unsigned val);
58};
59
60static const char * const ad5446_powerdown_modes[] = {
61	"1kohm_to_gnd", "100kohm_to_gnd", "three_state"
62};
63
64static int ad5446_set_powerdown_mode(struct iio_dev *indio_dev,
65	const struct iio_chan_spec *chan, unsigned int mode)
66{
67	struct ad5446_state *st = iio_priv(indio_dev);
68
69	st->pwr_down_mode = mode + 1;
70
71	return 0;
72}
73
74static int ad5446_get_powerdown_mode(struct iio_dev *indio_dev,
75	const struct iio_chan_spec *chan)
76{
77	struct ad5446_state *st = iio_priv(indio_dev);
78
79	return st->pwr_down_mode - 1;
80}
81
82static const struct iio_enum ad5446_powerdown_mode_enum = {
83	.items = ad5446_powerdown_modes,
84	.num_items = ARRAY_SIZE(ad5446_powerdown_modes),
85	.get = ad5446_get_powerdown_mode,
86	.set = ad5446_set_powerdown_mode,
87};
88
89static ssize_t ad5446_read_dac_powerdown(struct iio_dev *indio_dev,
90					   uintptr_t private,
91					   const struct iio_chan_spec *chan,
92					   char *buf)
93{
94	struct ad5446_state *st = iio_priv(indio_dev);
95
96	return sprintf(buf, "%d\n", st->pwr_down);
97}
98
99static ssize_t ad5446_write_dac_powerdown(struct iio_dev *indio_dev,
100					    uintptr_t private,
101					    const struct iio_chan_spec *chan,
102					    const char *buf, size_t len)
103{
104	struct ad5446_state *st = iio_priv(indio_dev);
105	unsigned int shift;
106	unsigned int val;
107	bool powerdown;
108	int ret;
109
110	ret = strtobool(buf, &powerdown);
111	if (ret)
112		return ret;
113
114	mutex_lock(&indio_dev->mlock);
115	st->pwr_down = powerdown;
116
117	if (st->pwr_down) {
118		shift = chan->scan_type.realbits + chan->scan_type.shift;
119		val = st->pwr_down_mode << shift;
120	} else {
121		val = st->cached_val;
122	}
123
124	ret = st->chip_info->write(st, val);
125	mutex_unlock(&indio_dev->mlock);
126
127	return ret ? ret : len;
128}
129
130static const struct iio_chan_spec_ext_info ad5446_ext_info_powerdown[] = {
131	{
132		.name = "powerdown",
133		.read = ad5446_read_dac_powerdown,
134		.write = ad5446_write_dac_powerdown,
135		.shared = IIO_SEPARATE,
136	},
137	IIO_ENUM("powerdown_mode", IIO_SEPARATE, &ad5446_powerdown_mode_enum),
138	IIO_ENUM_AVAILABLE("powerdown_mode", &ad5446_powerdown_mode_enum),
139	{ },
140};
141
142#define _AD5446_CHANNEL(bits, storage, _shift, ext) { \
143	.type = IIO_VOLTAGE, \
144	.indexed = 1, \
145	.output = 1, \
146	.channel = 0, \
147	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
148	.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
149	.scan_type = { \
150		.sign = 'u', \
151		.realbits = (bits), \
152		.storagebits = (storage), \
153		.shift = (_shift), \
154		}, \
155	.ext_info = (ext), \
156}
157
158#define AD5446_CHANNEL(bits, storage, shift) \
159	_AD5446_CHANNEL(bits, storage, shift, NULL)
160
161#define AD5446_CHANNEL_POWERDOWN(bits, storage, shift) \
162	_AD5446_CHANNEL(bits, storage, shift, ad5446_ext_info_powerdown)
163
164static int ad5446_read_raw(struct iio_dev *indio_dev,
165			   struct iio_chan_spec const *chan,
166			   int *val,
167			   int *val2,
168			   long m)
169{
170	struct ad5446_state *st = iio_priv(indio_dev);
171
172	switch (m) {
173	case IIO_CHAN_INFO_RAW:
174		*val = st->cached_val;
175		return IIO_VAL_INT;
176	case IIO_CHAN_INFO_SCALE:
177		*val = st->vref_mv;
178		*val2 = chan->scan_type.realbits;
179		return IIO_VAL_FRACTIONAL_LOG2;
180	}
181	return -EINVAL;
182}
183
184static int ad5446_write_raw(struct iio_dev *indio_dev,
185			       struct iio_chan_spec const *chan,
186			       int val,
187			       int val2,
188			       long mask)
189{
190	struct ad5446_state *st = iio_priv(indio_dev);
191	int ret = 0;
192
193	switch (mask) {
194	case IIO_CHAN_INFO_RAW:
195		if (val >= (1 << chan->scan_type.realbits) || val < 0)
196			return -EINVAL;
197
198		val <<= chan->scan_type.shift;
199		mutex_lock(&indio_dev->mlock);
200		st->cached_val = val;
201		if (!st->pwr_down)
202			ret = st->chip_info->write(st, val);
203		mutex_unlock(&indio_dev->mlock);
204		break;
205	default:
206		ret = -EINVAL;
207	}
208
209	return ret;
210}
211
212static const struct iio_info ad5446_info = {
213	.read_raw = ad5446_read_raw,
214	.write_raw = ad5446_write_raw,
215	.driver_module = THIS_MODULE,
216};
217
218static int ad5446_probe(struct device *dev, const char *name,
219			const struct ad5446_chip_info *chip_info)
220{
221	struct ad5446_state *st;
222	struct iio_dev *indio_dev;
223	struct regulator *reg;
224	int ret, voltage_uv = 0;
225
226	reg = devm_regulator_get(dev, "vcc");
227	if (!IS_ERR(reg)) {
228		ret = regulator_enable(reg);
229		if (ret)
230			return ret;
231
232		ret = regulator_get_voltage(reg);
233		if (ret < 0)
234			goto error_disable_reg;
235
236		voltage_uv = ret;
237	}
238
239	indio_dev = devm_iio_device_alloc(dev, sizeof(*st));
240	if (indio_dev == NULL) {
241		ret = -ENOMEM;
242		goto error_disable_reg;
243	}
244	st = iio_priv(indio_dev);
245	st->chip_info = chip_info;
246
247	dev_set_drvdata(dev, indio_dev);
248	st->reg = reg;
249	st->dev = dev;
250
251	/* Establish that the iio_dev is a child of the device */
252	indio_dev->dev.parent = dev;
253	indio_dev->name = name;
254	indio_dev->info = &ad5446_info;
255	indio_dev->modes = INDIO_DIRECT_MODE;
256	indio_dev->channels = &st->chip_info->channel;
257	indio_dev->num_channels = 1;
258
259	st->pwr_down_mode = MODE_PWRDWN_1k;
260
261	if (st->chip_info->int_vref_mv)
262		st->vref_mv = st->chip_info->int_vref_mv;
263	else if (voltage_uv)
264		st->vref_mv = voltage_uv / 1000;
265	else
266		dev_warn(dev, "reference voltage unspecified\n");
267
268	ret = iio_device_register(indio_dev);
269	if (ret)
270		goto error_disable_reg;
271
272	return 0;
273
274error_disable_reg:
275	if (!IS_ERR(reg))
276		regulator_disable(reg);
277	return ret;
278}
279
280static int ad5446_remove(struct device *dev)
281{
282	struct iio_dev *indio_dev = dev_get_drvdata(dev);
283	struct ad5446_state *st = iio_priv(indio_dev);
284
285	iio_device_unregister(indio_dev);
286	if (!IS_ERR(st->reg))
287		regulator_disable(st->reg);
288
289	return 0;
290}
291
292#if IS_ENABLED(CONFIG_SPI_MASTER)
293
294static int ad5446_write(struct ad5446_state *st, unsigned val)
295{
296	struct spi_device *spi = to_spi_device(st->dev);
297	__be16 data = cpu_to_be16(val);
298
299	return spi_write(spi, &data, sizeof(data));
300}
301
302static int ad5660_write(struct ad5446_state *st, unsigned val)
303{
304	struct spi_device *spi = to_spi_device(st->dev);
305	uint8_t data[3];
306
307	data[0] = (val >> 16) & 0xFF;
308	data[1] = (val >> 8) & 0xFF;
309	data[2] = val & 0xFF;
310
311	return spi_write(spi, data, sizeof(data));
312}
313
314/**
315 * ad5446_supported_spi_device_ids:
316 * The AD5620/40/60 parts are available in different fixed internal reference
317 * voltage options. The actual part numbers may look differently
318 * (and a bit cryptic), however this style is used to make clear which
319 * parts are supported here.
320 */
321enum ad5446_supported_spi_device_ids {
322	ID_AD5300,
323	ID_AD5310,
324	ID_AD5320,
325	ID_AD5444,
326	ID_AD5446,
327	ID_AD5450,
328	ID_AD5451,
329	ID_AD5541A,
330	ID_AD5512A,
331	ID_AD5553,
332	ID_AD5601,
333	ID_AD5611,
334	ID_AD5621,
335	ID_AD5641,
336	ID_AD5620_2500,
337	ID_AD5620_1250,
338	ID_AD5640_2500,
339	ID_AD5640_1250,
340	ID_AD5660_2500,
341	ID_AD5660_1250,
342	ID_AD5662,
343};
344
345static const struct ad5446_chip_info ad5446_spi_chip_info[] = {
346	[ID_AD5300] = {
347		.channel = AD5446_CHANNEL_POWERDOWN(8, 16, 4),
348		.write = ad5446_write,
349	},
350	[ID_AD5310] = {
351		.channel = AD5446_CHANNEL_POWERDOWN(10, 16, 2),
352		.write = ad5446_write,
353	},
354	[ID_AD5320] = {
355		.channel = AD5446_CHANNEL_POWERDOWN(12, 16, 0),
356		.write = ad5446_write,
357	},
358	[ID_AD5444] = {
359		.channel = AD5446_CHANNEL(12, 16, 2),
360		.write = ad5446_write,
361	},
362	[ID_AD5446] = {
363		.channel = AD5446_CHANNEL(14, 16, 0),
364		.write = ad5446_write,
365	},
366	[ID_AD5450] = {
367		.channel = AD5446_CHANNEL(8, 16, 6),
368		.write = ad5446_write,
369	},
370	[ID_AD5451] = {
371		.channel = AD5446_CHANNEL(10, 16, 4),
372		.write = ad5446_write,
373	},
374	[ID_AD5541A] = {
375		.channel = AD5446_CHANNEL(16, 16, 0),
376		.write = ad5446_write,
377	},
378	[ID_AD5512A] = {
379		.channel = AD5446_CHANNEL(12, 16, 4),
380		.write = ad5446_write,
381	},
382	[ID_AD5553] = {
383		.channel = AD5446_CHANNEL(14, 16, 0),
384		.write = ad5446_write,
385	},
386	[ID_AD5601] = {
387		.channel = AD5446_CHANNEL_POWERDOWN(8, 16, 6),
388		.write = ad5446_write,
389	},
390	[ID_AD5611] = {
391		.channel = AD5446_CHANNEL_POWERDOWN(10, 16, 4),
392		.write = ad5446_write,
393	},
394	[ID_AD5621] = {
395		.channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
396		.write = ad5446_write,
397	},
398	[ID_AD5641] = {
399		.channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
400		.write = ad5446_write,
401	},
402	[ID_AD5620_2500] = {
403		.channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
404		.int_vref_mv = 2500,
405		.write = ad5446_write,
406	},
407	[ID_AD5620_1250] = {
408		.channel = AD5446_CHANNEL_POWERDOWN(12, 16, 2),
409		.int_vref_mv = 1250,
410		.write = ad5446_write,
411	},
412	[ID_AD5640_2500] = {
413		.channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
414		.int_vref_mv = 2500,
415		.write = ad5446_write,
416	},
417	[ID_AD5640_1250] = {
418		.channel = AD5446_CHANNEL_POWERDOWN(14, 16, 0),
419		.int_vref_mv = 1250,
420		.write = ad5446_write,
421	},
422	[ID_AD5660_2500] = {
423		.channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
424		.int_vref_mv = 2500,
425		.write = ad5660_write,
426	},
427	[ID_AD5660_1250] = {
428		.channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
429		.int_vref_mv = 1250,
430		.write = ad5660_write,
431	},
432	[ID_AD5662] = {
433		.channel = AD5446_CHANNEL_POWERDOWN(16, 16, 0),
434		.write = ad5660_write,
435	},
436};
437
438static const struct spi_device_id ad5446_spi_ids[] = {
439	{"ad5300", ID_AD5300},
440	{"ad5310", ID_AD5310},
441	{"ad5320", ID_AD5320},
442	{"ad5444", ID_AD5444},
443	{"ad5446", ID_AD5446},
444	{"ad5450", ID_AD5450},
445	{"ad5451", ID_AD5451},
446	{"ad5452", ID_AD5444}, /* ad5452 is compatible to the ad5444 */
447	{"ad5453", ID_AD5446}, /* ad5453 is compatible to the ad5446 */
448	{"ad5512a", ID_AD5512A},
449	{"ad5541a", ID_AD5541A},
450	{"ad5542a", ID_AD5541A}, /* ad5541a and ad5542a are compatible */
451	{"ad5543", ID_AD5541A}, /* ad5541a and ad5543 are compatible */
452	{"ad5553", ID_AD5553},
453	{"ad5601", ID_AD5601},
454	{"ad5611", ID_AD5611},
455	{"ad5621", ID_AD5621},
456	{"ad5641", ID_AD5641},
457	{"ad5620-2500", ID_AD5620_2500}, /* AD5620/40/60: */
458	{"ad5620-1250", ID_AD5620_1250}, /* part numbers may look differently */
459	{"ad5640-2500", ID_AD5640_2500},
460	{"ad5640-1250", ID_AD5640_1250},
461	{"ad5660-2500", ID_AD5660_2500},
462	{"ad5660-1250", ID_AD5660_1250},
463	{"ad5662", ID_AD5662},
464	{}
465};
466MODULE_DEVICE_TABLE(spi, ad5446_spi_ids);
467
468static int ad5446_spi_probe(struct spi_device *spi)
469{
470	const struct spi_device_id *id = spi_get_device_id(spi);
471
472	return ad5446_probe(&spi->dev, id->name,
473		&ad5446_spi_chip_info[id->driver_data]);
474}
475
476static int ad5446_spi_remove(struct spi_device *spi)
477{
478	return ad5446_remove(&spi->dev);
479}
480
481static struct spi_driver ad5446_spi_driver = {
482	.driver = {
483		.name	= "ad5446",
484	},
485	.probe		= ad5446_spi_probe,
486	.remove		= ad5446_spi_remove,
487	.id_table	= ad5446_spi_ids,
488};
489
490static int __init ad5446_spi_register_driver(void)
491{
492	return spi_register_driver(&ad5446_spi_driver);
493}
494
495static void ad5446_spi_unregister_driver(void)
496{
497	spi_unregister_driver(&ad5446_spi_driver);
498}
499
500#else
501
502static inline int ad5446_spi_register_driver(void) { return 0; }
503static inline void ad5446_spi_unregister_driver(void) { }
504
505#endif
506
507#if IS_ENABLED(CONFIG_I2C)
508
509static int ad5622_write(struct ad5446_state *st, unsigned val)
510{
511	struct i2c_client *client = to_i2c_client(st->dev);
512	__be16 data = cpu_to_be16(val);
513
514	return i2c_master_send(client, (char *)&data, sizeof(data));
515}
516
517/**
518 * ad5446_supported_i2c_device_ids:
519 * The AD5620/40/60 parts are available in different fixed internal reference
520 * voltage options. The actual part numbers may look differently
521 * (and a bit cryptic), however this style is used to make clear which
522 * parts are supported here.
523 */
524enum ad5446_supported_i2c_device_ids {
525	ID_AD5602,
526	ID_AD5612,
527	ID_AD5622,
528};
529
530static const struct ad5446_chip_info ad5446_i2c_chip_info[] = {
531	[ID_AD5602] = {
532		.channel = AD5446_CHANNEL_POWERDOWN(8, 16, 4),
533		.write = ad5622_write,
534	},
535	[ID_AD5612] = {
536		.channel = AD5446_CHANNEL_POWERDOWN(10, 16, 2),
537		.write = ad5622_write,
538	},
539	[ID_AD5622] = {
540		.channel = AD5446_CHANNEL_POWERDOWN(12, 16, 0),
541		.write = ad5622_write,
542	},
543};
544
545static int ad5446_i2c_probe(struct i2c_client *i2c,
546			    const struct i2c_device_id *id)
547{
548	return ad5446_probe(&i2c->dev, id->name,
549		&ad5446_i2c_chip_info[id->driver_data]);
550}
551
552static int ad5446_i2c_remove(struct i2c_client *i2c)
553{
554	return ad5446_remove(&i2c->dev);
555}
556
557static const struct i2c_device_id ad5446_i2c_ids[] = {
558	{"ad5301", ID_AD5602},
559	{"ad5311", ID_AD5612},
560	{"ad5321", ID_AD5622},
561	{"ad5602", ID_AD5602},
562	{"ad5612", ID_AD5612},
563	{"ad5622", ID_AD5622},
564	{}
565};
566MODULE_DEVICE_TABLE(i2c, ad5446_i2c_ids);
567
568static struct i2c_driver ad5446_i2c_driver = {
569	.driver = {
570		   .name = "ad5446",
571	},
572	.probe = ad5446_i2c_probe,
573	.remove = ad5446_i2c_remove,
574	.id_table = ad5446_i2c_ids,
575};
576
577static int __init ad5446_i2c_register_driver(void)
578{
579	return i2c_add_driver(&ad5446_i2c_driver);
580}
581
582static void __exit ad5446_i2c_unregister_driver(void)
583{
584	i2c_del_driver(&ad5446_i2c_driver);
585}
586
587#else
588
589static inline int ad5446_i2c_register_driver(void) { return 0; }
590static inline void ad5446_i2c_unregister_driver(void) { }
591
592#endif
593
594static int __init ad5446_init(void)
595{
596	int ret;
597
598	ret = ad5446_spi_register_driver();
599	if (ret)
600		return ret;
601
602	ret = ad5446_i2c_register_driver();
603	if (ret) {
604		ad5446_spi_unregister_driver();
605		return ret;
606	}
607
608	return 0;
609}
610module_init(ad5446_init);
611
612static void __exit ad5446_exit(void)
613{
614	ad5446_i2c_unregister_driver();
615	ad5446_spi_unregister_driver();
616}
617module_exit(ad5446_exit);
618
619MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
620MODULE_DESCRIPTION("Analog Devices AD5444/AD5446 DAC");
621MODULE_LICENSE("GPL v2");
622