ltc2664.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * LTC2664 4 channel, 12-/16-Bit Voltage Output SoftSpan DAC driver
  4 * LTC2672 5 channel, 12-/16-Bit Current Output Softspan DAC driver
  5 *
  6 * Copyright 2024 Analog Devices Inc.
  7 */
  8
  9#include <linux/bitfield.h>
 10#include <linux/cleanup.h>
 11#include <linux/device.h>
 12#include <linux/gpio/consumer.h>
 13#include <linux/iio/iio.h>
 14#include <linux/kernel.h>
 15#include <linux/math64.h>
 16#include <linux/module.h>
 17#include <linux/mod_devicetable.h>
 18#include <linux/mutex.h>
 19#include <linux/property.h>
 20#include <linux/regmap.h>
 21#include <linux/regulator/consumer.h>
 22#include <linux/spi/spi.h>
 23
 24#define LTC2664_CMD_WRITE_N(n)		(0x00 + (n))
 25#define LTC2664_CMD_UPDATE_N(n)		(0x10 + (n))
 26#define LTC2664_CMD_WRITE_N_UPDATE_ALL	0x20
 27#define LTC2664_CMD_WRITE_N_UPDATE_N(n)	(0x30 + (n))
 28#define LTC2664_CMD_POWER_DOWN_N(n)	(0x40 + (n))
 29#define LTC2664_CMD_POWER_DOWN_ALL	0x50
 30#define LTC2664_CMD_SPAN_N(n)		(0x60 + (n))
 31#define LTC2664_CMD_CONFIG		0x70
 32#define LTC2664_CMD_MUX			0xB0
 33#define LTC2664_CMD_TOGGLE_SEL		0xC0
 34#define LTC2664_CMD_GLOBAL_TOGGLE	0xD0
 35#define LTC2664_CMD_NO_OPERATION	0xF0
 36#define LTC2664_REF_DISABLE		0x0001
 37#define LTC2664_MSPAN_SOFTSPAN		7
 38
 39#define LTC2672_MAX_CHANNEL		5
 40#define LTC2672_MAX_SPAN		7
 41#define LTC2672_SCALE_MULTIPLIER(n)	(50 * BIT(n))
 42
 43enum {
 44	LTC2664_SPAN_RANGE_0V_5V,
 45	LTC2664_SPAN_RANGE_0V_10V,
 46	LTC2664_SPAN_RANGE_M5V_5V,
 47	LTC2664_SPAN_RANGE_M10V_10V,
 48	LTC2664_SPAN_RANGE_M2V5_2V5,
 49};
 50
 51enum {
 52	LTC2664_INPUT_A,
 53	LTC2664_INPUT_B,
 54	LTC2664_INPUT_B_AVAIL,
 55	LTC2664_POWERDOWN,
 56	LTC2664_POWERDOWN_MODE,
 57	LTC2664_TOGGLE_EN,
 58	LTC2664_GLOBAL_TOGGLE,
 59};
 60
 61static const u16 ltc2664_mspan_lut[8][2] = {
 62	{ LTC2664_SPAN_RANGE_M10V_10V, 32768 }, /* MPS2=0, MPS1=0, MSP0=0 (0)*/
 63	{ LTC2664_SPAN_RANGE_M5V_5V, 32768 }, /* MPS2=0, MPS1=0, MSP0=1 (1)*/
 64	{ LTC2664_SPAN_RANGE_M2V5_2V5, 32768 }, /* MPS2=0, MPS1=1, MSP0=0 (2)*/
 65	{ LTC2664_SPAN_RANGE_0V_10V, 0 }, /* MPS2=0, MPS1=1, MSP0=1 (3)*/
 66	{ LTC2664_SPAN_RANGE_0V_10V, 32768 }, /* MPS2=1, MPS1=0, MSP0=0 (4)*/
 67	{ LTC2664_SPAN_RANGE_0V_5V, 0 }, /* MPS2=1, MPS1=0, MSP0=1 (5)*/
 68	{ LTC2664_SPAN_RANGE_0V_5V, 32768 }, /* MPS2=1, MPS1=1, MSP0=0 (6)*/
 69	{ LTC2664_SPAN_RANGE_0V_5V, 0 } /* MPS2=1, MPS1=1, MSP0=1 (7)*/
 70};
 71
 72struct ltc2664_state;
 73
 74struct ltc2664_chip_info {
 75	const char *name;
 76	int (*scale_get)(const struct ltc2664_state *st, int c);
 77	int (*offset_get)(const struct ltc2664_state *st, int c);
 78	int measurement_type;
 79	unsigned int num_channels;
 80	const int (*span_helper)[2];
 81	unsigned int num_span;
 82	unsigned int internal_vref_mv;
 83	bool manual_span_support;
 84	bool rfsadj_support;
 85};
 86
 87struct ltc2664_chan {
 88	/* indicates if the channel should be toggled */
 89	bool toggle_chan;
 90	/* indicates if the channel is in powered down state */
 91	bool powerdown;
 92	/* span code of the channel */
 93	u8 span;
 94	/* raw data of the current state of the chip registers (A/B) */
 95	u16 raw[2];
 96};
 97
 98struct ltc2664_state {
 99	struct spi_device *spi;
100	struct regmap *regmap;
101	struct ltc2664_chan channels[LTC2672_MAX_CHANNEL];
102	/* lock to protect against multiple access to the device and shared data */
103	struct mutex lock;
104	const struct ltc2664_chip_info *chip_info;
105	struct iio_chan_spec *iio_channels;
106	int vref_mv;
107	u32 rfsadj_ohms;
108	u32 toggle_sel;
109	bool global_toggle;
110};
111
112static const int ltc2664_span_helper[][2] = {
113	{ 0, 5000 },
114	{ 0, 10000 },
115	{ -5000, 5000 },
116	{ -10000, 10000 },
117	{ -2500, 2500 },
118};
119
120static const int ltc2672_span_helper[][2] = {
121	{ 0, 0 },
122	{ 0, 3125 },
123	{ 0, 6250 },
124	{ 0, 12500 },
125	{ 0, 25000 },
126	{ 0, 50000 },
127	{ 0, 100000 },
128	{ 0, 200000 },
129	{ 0, 300000 },
130};
131
132static int ltc2664_scale_get(const struct ltc2664_state *st, int c)
133{
134	const struct ltc2664_chan *chan = &st->channels[c];
135	const int (*span_helper)[2] = st->chip_info->span_helper;
136	int span, fs;
137
138	span = chan->span;
139	if (span < 0)
140		return span;
141
142	fs = span_helper[span][1] - span_helper[span][0];
143
144	return fs * st->vref_mv / 2500;
145}
146
147static int ltc2672_scale_get(const struct ltc2664_state *st, int c)
148{
149	const struct ltc2664_chan *chan = &st->channels[c];
150	int span, fs;
151
152	span = chan->span - 1;
153	if (span < 0)
154		return span;
155
156	fs = 1000 * st->vref_mv;
157
158	if (span == LTC2672_MAX_SPAN)
159		return mul_u64_u32_div(4800, fs, st->rfsadj_ohms);
160
161	return mul_u64_u32_div(LTC2672_SCALE_MULTIPLIER(span), fs, st->rfsadj_ohms);
162}
163
164static int ltc2664_offset_get(const struct ltc2664_state *st, int c)
165{
166	const struct ltc2664_chan *chan = &st->channels[c];
167	int span;
168
169	span = chan->span;
170	if (span < 0)
171		return span;
172
173	if (st->chip_info->span_helper[span][0] < 0)
174		return -32768;
175
176	return 0;
177}
178
179static int ltc2664_dac_code_write(struct ltc2664_state *st, u32 chan, u32 input,
180				  u16 code)
181{
182	struct ltc2664_chan *c = &st->channels[chan];
183	int ret, reg;
184
185	guard(mutex)(&st->lock);
186	/* select the correct input register to write to */
187	if (c->toggle_chan) {
188		ret = regmap_write(st->regmap, LTC2664_CMD_TOGGLE_SEL,
189				   input << chan);
190		if (ret)
191			return ret;
192	}
193	/*
194	 * If in toggle mode the dac should be updated by an
195	 * external signal (or sw toggle) and not here.
196	 */
197	if (st->toggle_sel & BIT(chan))
198		reg = LTC2664_CMD_WRITE_N(chan);
199	else
200		reg = LTC2664_CMD_WRITE_N_UPDATE_N(chan);
201
202	ret = regmap_write(st->regmap, reg, code);
203	if (ret)
204		return ret;
205
206	c->raw[input] = code;
207
208	if (c->toggle_chan) {
209		ret = regmap_write(st->regmap, LTC2664_CMD_TOGGLE_SEL,
210				   st->toggle_sel);
211		if (ret)
212			return ret;
213	}
214
215	return 0;
216}
217
218static void ltc2664_dac_code_read(struct ltc2664_state *st, u32 chan, u32 input,
219				  u32 *code)
220{
221	guard(mutex)(&st->lock);
222	*code = st->channels[chan].raw[input];
223}
224
225static const int ltc2664_raw_range[] = { 0, 1, U16_MAX };
226
227static int ltc2664_read_avail(struct iio_dev *indio_dev,
228			      struct iio_chan_spec const *chan,
229			      const int **vals, int *type, int *length,
230			      long info)
231{
232	switch (info) {
233	case IIO_CHAN_INFO_RAW:
234		*vals = ltc2664_raw_range;
235		*type = IIO_VAL_INT;
236
237		return IIO_AVAIL_RANGE;
238	default:
239		return -EINVAL;
240	}
241}
242
243static int ltc2664_read_raw(struct iio_dev *indio_dev,
244			    struct iio_chan_spec const *chan, int *val,
245			    int *val2, long info)
246{
247	struct ltc2664_state *st = iio_priv(indio_dev);
248
249	switch (info) {
250	case IIO_CHAN_INFO_RAW:
251		ltc2664_dac_code_read(st, chan->channel, LTC2664_INPUT_A, val);
252
253		return IIO_VAL_INT;
254	case IIO_CHAN_INFO_OFFSET:
255		*val = st->chip_info->offset_get(st, chan->channel);
256
257		return IIO_VAL_INT;
258	case IIO_CHAN_INFO_SCALE:
259		*val = st->chip_info->scale_get(st, chan->channel);
260
261		*val2 = 16;
262		return IIO_VAL_FRACTIONAL_LOG2;
263	default:
264		return -EINVAL;
265	}
266}
267
268static int ltc2664_write_raw(struct iio_dev *indio_dev,
269			     struct iio_chan_spec const *chan, int val,
270			     int val2, long info)
271{
272	struct ltc2664_state *st = iio_priv(indio_dev);
273
274	switch (info) {
275	case IIO_CHAN_INFO_RAW:
276		if (val > U16_MAX || val < 0)
277			return -EINVAL;
278
279		return ltc2664_dac_code_write(st, chan->channel,
280					      LTC2664_INPUT_A, val);
281	default:
282		return -EINVAL;
283	}
284}
285
286static ssize_t ltc2664_reg_bool_get(struct iio_dev *indio_dev,
287				    uintptr_t private,
288				    const struct iio_chan_spec *chan,
289				    char *buf)
290{
291	struct ltc2664_state *st = iio_priv(indio_dev);
292	u32 val;
293
294	guard(mutex)(&st->lock);
295	switch (private) {
296	case LTC2664_POWERDOWN:
297		val = st->channels[chan->channel].powerdown;
298
299		return sysfs_emit(buf, "%u\n", val);
300	case LTC2664_POWERDOWN_MODE:
301		return sysfs_emit(buf, "42kohm_to_gnd\n");
302	case LTC2664_TOGGLE_EN:
303		val = !!(st->toggle_sel & BIT(chan->channel));
304
305		return sysfs_emit(buf, "%u\n", val);
306	case LTC2664_GLOBAL_TOGGLE:
307		val = st->global_toggle;
308
309		return sysfs_emit(buf, "%u\n", val);
310	default:
311		return -EINVAL;
312	}
313}
314
315static ssize_t ltc2664_reg_bool_set(struct iio_dev *indio_dev,
316				    uintptr_t private,
317				    const struct iio_chan_spec *chan,
318				    const char *buf, size_t len)
319{
320	struct ltc2664_state *st = iio_priv(indio_dev);
321	int ret;
322	bool en;
323
324	ret = kstrtobool(buf, &en);
325	if (ret)
326		return ret;
327
328	guard(mutex)(&st->lock);
329	switch (private) {
330	case LTC2664_POWERDOWN:
331		ret = regmap_write(st->regmap,
332				   en ? LTC2664_CMD_POWER_DOWN_N(chan->channel) :
333				   LTC2664_CMD_UPDATE_N(chan->channel), en);
334		if (ret)
335			return ret;
336
337		st->channels[chan->channel].powerdown = en;
338
339		return len;
340	case LTC2664_TOGGLE_EN:
341		if (en)
342			st->toggle_sel |= BIT(chan->channel);
343		else
344			st->toggle_sel &= ~BIT(chan->channel);
345
346		ret = regmap_write(st->regmap, LTC2664_CMD_TOGGLE_SEL,
347				   st->toggle_sel);
348		if (ret)
349			return ret;
350
351		return len;
352	case LTC2664_GLOBAL_TOGGLE:
353		ret = regmap_write(st->regmap, LTC2664_CMD_GLOBAL_TOGGLE, en);
354		if (ret)
355			return ret;
356
357		st->global_toggle = en;
358
359		return len;
360	default:
361		return -EINVAL;
362	}
363}
364
365static ssize_t ltc2664_dac_input_read(struct iio_dev *indio_dev,
366				      uintptr_t private,
367				      const struct iio_chan_spec *chan,
368				      char *buf)
369{
370	struct ltc2664_state *st = iio_priv(indio_dev);
371	u32 val;
372
373	if (private == LTC2664_INPUT_B_AVAIL)
374		return sysfs_emit(buf, "[%u %u %u]\n", ltc2664_raw_range[0],
375				  ltc2664_raw_range[1],
376				  ltc2664_raw_range[2] / 4);
377
378	ltc2664_dac_code_read(st, chan->channel, private, &val);
379
380	return sysfs_emit(buf, "%u\n", val);
381}
382
383static ssize_t ltc2664_dac_input_write(struct iio_dev *indio_dev,
384				       uintptr_t private,
385				       const struct iio_chan_spec *chan,
386				       const char *buf, size_t len)
387{
388	struct ltc2664_state *st = iio_priv(indio_dev);
389	int ret;
390	u16 val;
391
392	if (private == LTC2664_INPUT_B_AVAIL)
393		return -EINVAL;
394
395	ret = kstrtou16(buf, 10, &val);
396	if (ret)
397		return ret;
398
399	ret = ltc2664_dac_code_write(st, chan->channel, private, val);
400	if (ret)
401		return ret;
402
403	return len;
404}
405
406static int ltc2664_reg_access(struct iio_dev *indio_dev,
407			      unsigned int reg,
408			      unsigned int writeval,
409			      unsigned int *readval)
410{
411	struct ltc2664_state *st = iio_priv(indio_dev);
412
413	if (readval)
414		return -EOPNOTSUPP;
415
416	return regmap_write(st->regmap, reg, writeval);
417}
418
419#define LTC2664_CHAN_EXT_INFO(_name, _what, _shared, _read, _write) {	\
420	.name = _name,							\
421	.read = (_read),						\
422	.write = (_write),						\
423	.private = (_what),						\
424	.shared = (_shared),						\
425}
426
427/*
428 * For toggle mode we only expose the symbol attr (sw_toggle) in case a TGPx is
429 * not provided in dts.
430 */
431static const struct iio_chan_spec_ext_info ltc2664_toggle_sym_ext_info[] = {
432	LTC2664_CHAN_EXT_INFO("raw0", LTC2664_INPUT_A, IIO_SEPARATE,
433			      ltc2664_dac_input_read, ltc2664_dac_input_write),
434	LTC2664_CHAN_EXT_INFO("raw1", LTC2664_INPUT_B, IIO_SEPARATE,
435			      ltc2664_dac_input_read, ltc2664_dac_input_write),
436	LTC2664_CHAN_EXT_INFO("powerdown", LTC2664_POWERDOWN, IIO_SEPARATE,
437			      ltc2664_reg_bool_get, ltc2664_reg_bool_set),
438	LTC2664_CHAN_EXT_INFO("powerdown_mode", LTC2664_POWERDOWN_MODE,
439			      IIO_SEPARATE, ltc2664_reg_bool_get, NULL),
440	LTC2664_CHAN_EXT_INFO("symbol", LTC2664_GLOBAL_TOGGLE, IIO_SEPARATE,
441			      ltc2664_reg_bool_get, ltc2664_reg_bool_set),
442	LTC2664_CHAN_EXT_INFO("toggle_en", LTC2664_TOGGLE_EN,
443			      IIO_SEPARATE, ltc2664_reg_bool_get,
444			      ltc2664_reg_bool_set),
445	{ }
446};
447
448static const struct iio_chan_spec_ext_info ltc2664_ext_info[] = {
449	LTC2664_CHAN_EXT_INFO("powerdown", LTC2664_POWERDOWN, IIO_SEPARATE,
450			      ltc2664_reg_bool_get, ltc2664_reg_bool_set),
451	LTC2664_CHAN_EXT_INFO("powerdown_mode", LTC2664_POWERDOWN_MODE,
452			      IIO_SEPARATE, ltc2664_reg_bool_get, NULL),
453	{ }
454};
455
456static const struct iio_chan_spec ltc2664_channel_template = {
457	.indexed = 1,
458	.output = 1,
459	.info_mask_separate = BIT(IIO_CHAN_INFO_SCALE) |
460			      BIT(IIO_CHAN_INFO_OFFSET) |
461			      BIT(IIO_CHAN_INFO_RAW),
462	.info_mask_separate_available = BIT(IIO_CHAN_INFO_RAW),
463	.ext_info = ltc2664_ext_info,
464};
465
466static const struct ltc2664_chip_info ltc2664_chip = {
467	.name = "ltc2664",
468	.scale_get = ltc2664_scale_get,
469	.offset_get = ltc2664_offset_get,
470	.measurement_type = IIO_VOLTAGE,
471	.num_channels = 4,
472	.span_helper = ltc2664_span_helper,
473	.num_span = ARRAY_SIZE(ltc2664_span_helper),
474	.internal_vref_mv = 2500,
475	.manual_span_support = true,
476	.rfsadj_support = false,
477};
478
479static const struct ltc2664_chip_info ltc2672_chip = {
480	.name = "ltc2672",
481	.scale_get = ltc2672_scale_get,
482	.offset_get = ltc2664_offset_get,
483	.measurement_type = IIO_CURRENT,
484	.num_channels = 5,
485	.span_helper = ltc2672_span_helper,
486	.num_span = ARRAY_SIZE(ltc2672_span_helper),
487	.internal_vref_mv = 1250,
488	.manual_span_support = false,
489	.rfsadj_support = true,
490};
491
492static int ltc2664_set_span(const struct ltc2664_state *st, int min, int max,
493			    int chan)
494{
495	const struct ltc2664_chip_info *chip_info = st->chip_info;
496	const int (*span_helper)[2] = chip_info->span_helper;
497	int span, ret;
498
499	for (span = 0; span < chip_info->num_span; span++) {
500		if (min == span_helper[span][0] && max == span_helper[span][1])
501			break;
502	}
503
504	if (span == chip_info->num_span)
505		return -EINVAL;
506
507	ret = regmap_write(st->regmap, LTC2664_CMD_SPAN_N(chan), span);
508	if (ret)
509		return ret;
510
511	return span;
512}
513
514static int ltc2664_channel_config(struct ltc2664_state *st)
515{
516	const struct ltc2664_chip_info *chip_info = st->chip_info;
517	struct device *dev = &st->spi->dev;
518	u32 reg, tmp[2], mspan;
519	int ret;
520
521	mspan = LTC2664_MSPAN_SOFTSPAN;
522	ret = device_property_read_u32(dev, "adi,manual-span-operation-config",
523				       &mspan);
524	if (!ret) {
525		if (!chip_info->manual_span_support)
526			return dev_err_probe(dev, -EINVAL,
527			       "adi,manual-span-operation-config not supported\n");
528
529		if (mspan >= ARRAY_SIZE(ltc2664_mspan_lut))
530			return dev_err_probe(dev, -EINVAL,
531			       "adi,manual-span-operation-config not in range\n");
532	}
533
534	st->rfsadj_ohms = 20000;
535	ret = device_property_read_u32(dev, "adi,rfsadj-ohms", &st->rfsadj_ohms);
536	if (!ret) {
537		if (!chip_info->rfsadj_support)
538			return dev_err_probe(dev, -EINVAL,
539					     "adi,rfsadj-ohms not supported\n");
540
541		if (st->rfsadj_ohms < 19000 || st->rfsadj_ohms > 41000)
542			return dev_err_probe(dev, -EINVAL,
543					     "adi,rfsadj-ohms not in range\n");
544	}
545
546	device_for_each_child_node_scoped(dev, child) {
547		struct ltc2664_chan *chan;
548
549		ret = fwnode_property_read_u32(child, "reg", &reg);
550		if (ret)
551			return dev_err_probe(dev, ret,
552					     "Failed to get reg property\n");
553
554		if (reg >= chip_info->num_channels)
555			return dev_err_probe(dev, -EINVAL,
556					     "reg bigger than: %d\n",
557					     chip_info->num_channels);
558
559		chan = &st->channels[reg];
560
561		if (fwnode_property_read_bool(child, "adi,toggle-mode")) {
562			chan->toggle_chan = true;
563			/* assume sw toggle ABI */
564			st->iio_channels[reg].ext_info = ltc2664_toggle_sym_ext_info;
565
566			/*
567			 * Clear IIO_CHAN_INFO_RAW bit as toggle channels expose
568			 * out_voltage/current_raw{0|1} files.
569			 */
570			__clear_bit(IIO_CHAN_INFO_RAW,
571				    &st->iio_channels[reg].info_mask_separate);
572		}
573
574		chan->raw[0] = ltc2664_mspan_lut[mspan][1];
575		chan->raw[1] = ltc2664_mspan_lut[mspan][1];
576
577		chan->span = ltc2664_mspan_lut[mspan][0];
578
579		ret = fwnode_property_read_u32_array(child, "output-range-microvolt",
580						     tmp, ARRAY_SIZE(tmp));
581		if (!ret && mspan == LTC2664_MSPAN_SOFTSPAN) {
582			ret = ltc2664_set_span(st, tmp[0] / 1000, tmp[1] / 1000, reg);
583			if (ret < 0)
584				return dev_err_probe(dev, ret,
585						     "Failed to set span\n");
586			chan->span = ret;
587		}
588
589		ret = fwnode_property_read_u32_array(child, "output-range-microamp",
590						     tmp, ARRAY_SIZE(tmp));
591		if (!ret) {
592			ret = ltc2664_set_span(st, 0, tmp[1] / 1000, reg);
593			if (ret < 0)
594				return dev_err_probe(dev, ret,
595						     "Failed to set span\n");
596			chan->span = ret;
597		}
598	}
599
600	return 0;
601}
602
603static int ltc2664_setup(struct ltc2664_state *st)
604{
605	const struct ltc2664_chip_info *chip_info = st->chip_info;
606	struct gpio_desc *gpio;
607	int ret, i;
608
609	/* If we have a clr/reset pin, use that to reset the chip. */
610	gpio = devm_gpiod_get_optional(&st->spi->dev, "reset", GPIOD_OUT_HIGH);
611	if (IS_ERR(gpio))
612		return dev_err_probe(&st->spi->dev, PTR_ERR(gpio),
613				     "Failed to get reset gpio");
614	if (gpio) {
615		fsleep(1000);
616		gpiod_set_value_cansleep(gpio, 0);
617	}
618
619	/*
620	 * Duplicate the default channel configuration as it can change during
621	 * @ltc2664_channel_config()
622	 */
623	st->iio_channels = devm_kcalloc(&st->spi->dev,
624					chip_info->num_channels,
625					sizeof(struct iio_chan_spec),
626					GFP_KERNEL);
627	if (!st->iio_channels)
628		return -ENOMEM;
629
630	for (i = 0; i < chip_info->num_channels; i++) {
631		st->iio_channels[i] = ltc2664_channel_template;
632		st->iio_channels[i].type = chip_info->measurement_type;
633		st->iio_channels[i].channel = i;
634	}
635
636	ret = ltc2664_channel_config(st);
637	if (ret)
638		return ret;
639
640	return regmap_set_bits(st->regmap, LTC2664_CMD_CONFIG, LTC2664_REF_DISABLE);
641}
642
643static const struct regmap_config ltc2664_regmap_config = {
644	.reg_bits = 8,
645	.val_bits = 16,
646	.max_register = LTC2664_CMD_NO_OPERATION,
647};
648
649static const struct iio_info ltc2664_info = {
650	.write_raw = ltc2664_write_raw,
651	.read_raw = ltc2664_read_raw,
652	.read_avail = ltc2664_read_avail,
653	.debugfs_reg_access = ltc2664_reg_access,
654};
655
656static int ltc2664_probe(struct spi_device *spi)
657{
658	static const char * const regulators[] = { "vcc", "iovcc", "v-neg" };
659	const struct ltc2664_chip_info *chip_info;
660	struct device *dev = &spi->dev;
661	struct iio_dev *indio_dev;
662	struct ltc2664_state *st;
663	int ret;
664
665	indio_dev = devm_iio_device_alloc(dev, sizeof(*st));
666	if (!indio_dev)
667		return -ENOMEM;
668
669	st = iio_priv(indio_dev);
670	st->spi = spi;
671
672	chip_info = spi_get_device_match_data(spi);
673	if (!chip_info)
674		return -ENODEV;
675
676	st->chip_info = chip_info;
677
678	mutex_init(&st->lock);
679
680	st->regmap = devm_regmap_init_spi(spi, &ltc2664_regmap_config);
681	if (IS_ERR(st->regmap))
682		return dev_err_probe(dev, PTR_ERR(st->regmap),
683				     "Failed to init regmap");
684
685	ret = devm_regulator_bulk_get_enable(dev, ARRAY_SIZE(regulators),
686					     regulators);
687	if (ret)
688		return dev_err_probe(dev, ret, "Failed to enable regulators\n");
689
690	ret = devm_regulator_get_enable_read_voltage(dev, "ref");
691	if (ret < 0 && ret != -ENODEV)
692		return ret;
693
694	st->vref_mv = ret > 0 ? ret / 1000 :  chip_info->internal_vref_mv;
695
696	ret = ltc2664_setup(st);
697	if (ret)
698		return ret;
699
700	indio_dev->name = chip_info->name;
701	indio_dev->info = &ltc2664_info;
702	indio_dev->modes = INDIO_DIRECT_MODE;
703	indio_dev->channels = st->iio_channels;
704	indio_dev->num_channels = chip_info->num_channels;
705
706	return devm_iio_device_register(dev, indio_dev);
707}
708
709static const struct spi_device_id ltc2664_id[] = {
710	{ "ltc2664", (kernel_ulong_t)&ltc2664_chip },
711	{ "ltc2672", (kernel_ulong_t)&ltc2672_chip },
712	{ }
713};
714MODULE_DEVICE_TABLE(spi, ltc2664_id);
715
716static const struct of_device_id ltc2664_of_id[] = {
717	{ .compatible = "adi,ltc2664", .data = &ltc2664_chip },
718	{ .compatible = "adi,ltc2672", .data = &ltc2672_chip },
719	{ }
720};
721MODULE_DEVICE_TABLE(of, ltc2664_of_id);
722
723static struct spi_driver ltc2664_driver = {
724	.driver = {
725		.name = "ltc2664",
726		.of_match_table = ltc2664_of_id,
727	},
728	.probe = ltc2664_probe,
729	.id_table = ltc2664_id,
730};
731module_spi_driver(ltc2664_driver);
732
733MODULE_AUTHOR("Michael Hennerich <michael.hennerich@analog.com>");
734MODULE_AUTHOR("Kim Seer Paller <kimseer.paller@analog.com>");
735MODULE_DESCRIPTION("Analog Devices LTC2664 and LTC2672 DAC");
736MODULE_LICENSE("GPL");