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