1 // SPDX-License-Identifier: GPL-2.0
3 * LTC2688 16 channel, 16 bit Voltage Output SoftSpan DAC driver
5 * Copyright 2022 Analog Devices Inc.
7 #include <linux/bitfield.h>
8 #include <linux/bits.h>
10 #include <linux/device.h>
11 #include <linux/gpio/consumer.h>
12 #include <linux/iio/iio.h>
13 #include <linux/limits.h>
14 #include <linux/kernel.h>
15 #include <linux/module.h>
16 #include <linux/mod_devicetable.h>
17 #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>
24 #define LTC2688_DAC_CHANNELS 16
26 #define LTC2688_CMD_CH_CODE(x) (0x00 + (x))
27 #define LTC2688_CMD_CH_SETTING(x) (0x10 + (x))
28 #define LTC2688_CMD_CH_OFFSET(x) (0X20 + (x))
29 #define LTC2688_CMD_CH_GAIN(x) (0x30 + (x))
30 #define LTC2688_CMD_CH_CODE_UPDATE(x) (0x40 + (x))
32 #define LTC2688_CMD_CONFIG 0x70
33 #define LTC2688_CMD_POWERDOWN 0x71
34 #define LTC2688_CMD_A_B_SELECT 0x72
35 #define LTC2688_CMD_SW_TOGGLE 0x73
36 #define LTC2688_CMD_TOGGLE_DITHER_EN 0x74
37 #define LTC2688_CMD_THERMAL_STAT 0x77
38 #define LTC2688_CMD_UPDATE_ALL 0x7C
39 #define LTC2688_CMD_NOOP 0xFF
41 #define LTC2688_READ_OPERATION 0x80
43 /* Channel Settings */
44 #define LTC2688_CH_SPAN_MSK GENMASK(2, 0)
45 #define LTC2688_CH_OVERRANGE_MSK BIT(3)
46 #define LTC2688_CH_TD_SEL_MSK GENMASK(5, 4)
47 #define LTC2688_CH_TGP_MAX 3
48 #define LTC2688_CH_DIT_PER_MSK GENMASK(8, 6)
49 #define LTC2688_CH_DIT_PH_MSK GENMASK(10, 9)
50 #define LTC2688_CH_MODE_MSK BIT(11)
52 #define LTC2688_DITHER_RAW_MASK GENMASK(15, 2)
53 #define LTC2688_CH_CALIBBIAS_MASK GENMASK(15, 2)
54 #define LTC2688_DITHER_RAW_MAX_VAL (BIT(14) - 1)
55 #define LTC2688_CH_CALIBBIAS_MAX_VAL (BIT(14) - 1)
57 /* Configuration register */
58 #define LTC2688_CONFIG_RST BIT(15)
59 #define LTC2688_CONFIG_EXT_REF BIT(1)
61 #define LTC2688_DITHER_FREQ_AVAIL_N 5
64 LTC2688_SPAN_RANGE_0V_5V,
65 LTC2688_SPAN_RANGE_0V_10V,
66 LTC2688_SPAN_RANGE_M5V_5V,
67 LTC2688_SPAN_RANGE_M10V_10V,
68 LTC2688_SPAN_RANGE_M15V_15V,
69 LTC2688_SPAN_RANGE_MAX
74 LTC2688_MODE_DITHER_TOGGLE,
78 long dither_frequency[LTC2688_DITHER_FREQ_AVAIL_N];
84 struct ltc2688_state {
85 struct spi_device *spi;
86 struct regmap *regmap;
87 struct ltc2688_chan channels[LTC2688_DAC_CHANNELS];
88 struct iio_chan_spec *iio_chan;
89 /* lock to protect against multiple access to the device and shared data */
93 * DMA (thus cache coherency maintenance) may require the
94 * transfer buffers to live in their own cache lines.
96 u8 tx_data[6] __aligned(IIO_DMA_MINALIGN);
100 static int ltc2688_spi_read(void *context, const void *reg, size_t reg_size,
101 void *val, size_t val_size)
103 struct ltc2688_state *st = context;
104 struct spi_transfer xfers[] = {
106 .tx_buf = st->tx_data,
108 .len = reg_size + val_size,
111 .tx_buf = st->tx_data + 3,
112 .rx_buf = st->rx_data,
114 .len = reg_size + val_size,
119 memcpy(st->tx_data, reg, reg_size);
121 ret = spi_sync_transfer(st->spi, xfers, ARRAY_SIZE(xfers));
125 memcpy(val, &st->rx_data[1], val_size);
130 static int ltc2688_spi_write(void *context, const void *data, size_t count)
132 struct ltc2688_state *st = context;
134 return spi_write(st->spi, data, count);
137 static int ltc2688_span_get(const struct ltc2688_state *st, int c)
141 ret = regmap_read(st->regmap, LTC2688_CMD_CH_SETTING(c), ®);
145 span = FIELD_GET(LTC2688_CH_SPAN_MSK, reg);
146 /* sanity check to make sure we don't get any weird value from the HW */
147 if (span >= LTC2688_SPAN_RANGE_MAX)
153 static const int ltc2688_span_helper[LTC2688_SPAN_RANGE_MAX][2] = {
154 {0, 5000}, {0, 10000}, {-5000, 5000}, {-10000, 10000}, {-15000, 15000},
157 static int ltc2688_scale_get(const struct ltc2688_state *st, int c, int *val)
159 const struct ltc2688_chan *chan = &st->channels[c];
162 span = ltc2688_span_get(st, c);
166 fs = ltc2688_span_helper[span][1] - ltc2688_span_helper[span][0];
168 fs = mult_frac(fs, 105, 100);
170 *val = DIV_ROUND_CLOSEST(fs * st->vref, 4096);
175 static int ltc2688_offset_get(const struct ltc2688_state *st, int c, int *val)
179 span = ltc2688_span_get(st, c);
183 if (ltc2688_span_helper[span][0] < 0)
194 LTC2688_INPUT_B_AVAIL,
196 LTC2688_DITHER_FREQ_AVAIL,
199 static int ltc2688_dac_code_write(struct ltc2688_state *st, u32 chan, u32 input,
202 struct ltc2688_chan *c = &st->channels[chan];
205 /* 2 LSBs set to 0 if writing dither amplitude */
206 if (!c->toggle_chan && input == LTC2688_INPUT_B) {
207 if (code > LTC2688_DITHER_RAW_MAX_VAL)
210 code = FIELD_PREP(LTC2688_DITHER_RAW_MASK, code);
213 mutex_lock(&st->lock);
214 /* select the correct input register to read from */
215 ret = regmap_update_bits(st->regmap, LTC2688_CMD_A_B_SELECT, BIT(chan),
221 * If in dither/toggle mode the dac should be updated by an
222 * external signal (or sw toggle) and not here.
224 if (c->mode == LTC2688_MODE_DEFAULT)
225 reg = LTC2688_CMD_CH_CODE_UPDATE(chan);
227 reg = LTC2688_CMD_CH_CODE(chan);
229 ret = regmap_write(st->regmap, reg, code);
231 mutex_unlock(&st->lock);
235 static int ltc2688_dac_code_read(struct ltc2688_state *st, u32 chan, u32 input,
238 struct ltc2688_chan *c = &st->channels[chan];
241 mutex_lock(&st->lock);
242 ret = regmap_update_bits(st->regmap, LTC2688_CMD_A_B_SELECT, BIT(chan),
247 ret = regmap_read(st->regmap, LTC2688_CMD_CH_CODE(chan), code);
249 mutex_unlock(&st->lock);
251 if (!c->toggle_chan && input == LTC2688_INPUT_B)
252 *code = FIELD_GET(LTC2688_DITHER_RAW_MASK, *code);
257 static const int ltc2688_raw_range[] = {0, 1, U16_MAX};
259 static int ltc2688_read_avail(struct iio_dev *indio_dev,
260 struct iio_chan_spec const *chan,
261 const int **vals, int *type, int *length,
265 case IIO_CHAN_INFO_RAW:
266 *vals = ltc2688_raw_range;
268 return IIO_AVAIL_RANGE;
274 static int ltc2688_read_raw(struct iio_dev *indio_dev,
275 struct iio_chan_spec const *chan, int *val,
276 int *val2, long info)
278 struct ltc2688_state *st = iio_priv(indio_dev);
282 case IIO_CHAN_INFO_RAW:
283 ret = ltc2688_dac_code_read(st, chan->channel, LTC2688_INPUT_A,
289 case IIO_CHAN_INFO_OFFSET:
290 ret = ltc2688_offset_get(st, chan->channel, val);
295 case IIO_CHAN_INFO_SCALE:
296 ret = ltc2688_scale_get(st, chan->channel, val);
301 return IIO_VAL_FRACTIONAL_LOG2;
302 case IIO_CHAN_INFO_CALIBBIAS:
303 ret = regmap_read(st->regmap,
304 LTC2688_CMD_CH_OFFSET(chan->channel), val);
308 *val = FIELD_GET(LTC2688_CH_CALIBBIAS_MASK, *val);
310 case IIO_CHAN_INFO_CALIBSCALE:
311 ret = regmap_read(st->regmap,
312 LTC2688_CMD_CH_GAIN(chan->channel), val);
322 static int ltc2688_write_raw(struct iio_dev *indio_dev,
323 struct iio_chan_spec const *chan, int val,
326 struct ltc2688_state *st = iio_priv(indio_dev);
329 case IIO_CHAN_INFO_RAW:
330 if (val > U16_MAX || val < 0)
333 return ltc2688_dac_code_write(st, chan->channel,
334 LTC2688_INPUT_A, val);
335 case IIO_CHAN_INFO_CALIBBIAS:
336 if (val > LTC2688_CH_CALIBBIAS_MAX_VAL)
339 return regmap_write(st->regmap,
340 LTC2688_CMD_CH_OFFSET(chan->channel),
341 FIELD_PREP(LTC2688_CH_CALIBBIAS_MASK, val));
342 case IIO_CHAN_INFO_CALIBSCALE:
343 return regmap_write(st->regmap,
344 LTC2688_CMD_CH_GAIN(chan->channel), val);
350 static ssize_t ltc2688_dither_toggle_set(struct iio_dev *indio_dev,
352 const struct iio_chan_spec *chan,
353 const char *buf, size_t len)
355 struct ltc2688_state *st = iio_priv(indio_dev);
356 struct ltc2688_chan *c = &st->channels[chan->channel];
360 ret = kstrtobool(buf, &en);
364 mutex_lock(&st->lock);
365 ret = regmap_update_bits(st->regmap, LTC2688_CMD_TOGGLE_DITHER_EN,
366 BIT(chan->channel), en << chan->channel);
370 c->mode = en ? LTC2688_MODE_DITHER_TOGGLE : LTC2688_MODE_DEFAULT;
372 mutex_unlock(&st->lock);
377 static ssize_t ltc2688_reg_bool_get(struct iio_dev *indio_dev,
379 const struct iio_chan_spec *chan,
382 const struct ltc2688_state *st = iio_priv(indio_dev);
386 ret = regmap_read(st->regmap, private, &val);
390 return sysfs_emit(buf, "%u\n", !!(val & BIT(chan->channel)));
393 static ssize_t ltc2688_reg_bool_set(struct iio_dev *indio_dev,
395 const struct iio_chan_spec *chan,
396 const char *buf, size_t len)
398 const struct ltc2688_state *st = iio_priv(indio_dev);
402 ret = kstrtobool(buf, &en);
406 ret = regmap_update_bits(st->regmap, private, BIT(chan->channel),
407 en << chan->channel);
414 static ssize_t ltc2688_dither_freq_avail(const struct ltc2688_state *st,
415 const struct ltc2688_chan *chan,
421 for (f = 0; f < ARRAY_SIZE(chan->dither_frequency); f++)
422 sz += sysfs_emit_at(buf, sz, "%ld ", chan->dither_frequency[f]);
429 static ssize_t ltc2688_dither_freq_get(struct iio_dev *indio_dev,
431 const struct iio_chan_spec *chan,
434 const struct ltc2688_state *st = iio_priv(indio_dev);
435 const struct ltc2688_chan *c = &st->channels[chan->channel];
439 if (private == LTC2688_DITHER_FREQ_AVAIL)
440 return ltc2688_dither_freq_avail(st, c, buf);
442 ret = regmap_read(st->regmap, LTC2688_CMD_CH_SETTING(chan->channel),
447 freq = FIELD_GET(LTC2688_CH_DIT_PER_MSK, reg);
448 if (freq >= ARRAY_SIZE(c->dither_frequency))
451 return sysfs_emit(buf, "%ld\n", c->dither_frequency[freq]);
454 static ssize_t ltc2688_dither_freq_set(struct iio_dev *indio_dev,
456 const struct iio_chan_spec *chan,
457 const char *buf, size_t len)
459 const struct ltc2688_state *st = iio_priv(indio_dev);
460 const struct ltc2688_chan *c = &st->channels[chan->channel];
465 if (private == LTC2688_DITHER_FREQ_AVAIL)
468 ret = kstrtol(buf, 10, &val);
472 for (freq = 0; freq < ARRAY_SIZE(c->dither_frequency); freq++) {
473 if (val == c->dither_frequency[freq])
477 if (freq == ARRAY_SIZE(c->dither_frequency))
480 ret = regmap_update_bits(st->regmap,
481 LTC2688_CMD_CH_SETTING(chan->channel),
482 LTC2688_CH_DIT_PER_MSK,
483 FIELD_PREP(LTC2688_CH_DIT_PER_MSK, freq));
490 static ssize_t ltc2688_dac_input_read(struct iio_dev *indio_dev,
492 const struct iio_chan_spec *chan,
495 struct ltc2688_state *st = iio_priv(indio_dev);
499 if (private == LTC2688_INPUT_B_AVAIL)
500 return sysfs_emit(buf, "[%u %u %u]\n", ltc2688_raw_range[0],
501 ltc2688_raw_range[1],
502 ltc2688_raw_range[2] / 4);
504 if (private == LTC2688_DITHER_OFF)
505 return sysfs_emit(buf, "0\n");
507 ret = ltc2688_dac_code_read(st, chan->channel, private, &val);
511 return sysfs_emit(buf, "%u\n", val);
514 static ssize_t ltc2688_dac_input_write(struct iio_dev *indio_dev,
516 const struct iio_chan_spec *chan,
517 const char *buf, size_t len)
519 struct ltc2688_state *st = iio_priv(indio_dev);
523 if (private == LTC2688_INPUT_B_AVAIL || private == LTC2688_DITHER_OFF)
526 ret = kstrtou16(buf, 10, &val);
530 ret = ltc2688_dac_code_write(st, chan->channel, private, val);
537 static int ltc2688_get_dither_phase(struct iio_dev *dev,
538 const struct iio_chan_spec *chan)
540 struct ltc2688_state *st = iio_priv(dev);
543 ret = regmap_read(st->regmap, LTC2688_CMD_CH_SETTING(chan->channel),
548 return FIELD_GET(LTC2688_CH_DIT_PH_MSK, regval);
551 static int ltc2688_set_dither_phase(struct iio_dev *dev,
552 const struct iio_chan_spec *chan,
555 struct ltc2688_state *st = iio_priv(dev);
557 return regmap_update_bits(st->regmap,
558 LTC2688_CMD_CH_SETTING(chan->channel),
559 LTC2688_CH_DIT_PH_MSK,
560 FIELD_PREP(LTC2688_CH_DIT_PH_MSK, phase));
563 static int ltc2688_reg_access(struct iio_dev *indio_dev,
565 unsigned int writeval,
566 unsigned int *readval)
568 struct ltc2688_state *st = iio_priv(indio_dev);
571 return regmap_read(st->regmap, reg, readval);
573 return regmap_write(st->regmap, reg, writeval);
576 static const char * const ltc2688_dither_phase[] = {
577 "0", "1.5708", "3.14159", "4.71239",
580 static const struct iio_enum ltc2688_dither_phase_enum = {
581 .items = ltc2688_dither_phase,
582 .num_items = ARRAY_SIZE(ltc2688_dither_phase),
583 .set = ltc2688_set_dither_phase,
584 .get = ltc2688_get_dither_phase,
587 #define LTC2688_CHAN_EXT_INFO(_name, _what, _shared, _read, _write) { \
591 .private = (_what), \
592 .shared = (_shared), \
596 * For toggle mode we only expose the symbol attr (sw_toggle) in case a TGPx is
597 * not provided in dts.
599 static const struct iio_chan_spec_ext_info ltc2688_toggle_sym_ext_info[] = {
600 LTC2688_CHAN_EXT_INFO("raw0", LTC2688_INPUT_A, IIO_SEPARATE,
601 ltc2688_dac_input_read, ltc2688_dac_input_write),
602 LTC2688_CHAN_EXT_INFO("raw1", LTC2688_INPUT_B, IIO_SEPARATE,
603 ltc2688_dac_input_read, ltc2688_dac_input_write),
604 LTC2688_CHAN_EXT_INFO("toggle_en", LTC2688_CMD_TOGGLE_DITHER_EN,
605 IIO_SEPARATE, ltc2688_reg_bool_get,
606 ltc2688_dither_toggle_set),
607 LTC2688_CHAN_EXT_INFO("powerdown", LTC2688_CMD_POWERDOWN, IIO_SEPARATE,
608 ltc2688_reg_bool_get, ltc2688_reg_bool_set),
609 LTC2688_CHAN_EXT_INFO("symbol", LTC2688_CMD_SW_TOGGLE, IIO_SEPARATE,
610 ltc2688_reg_bool_get, ltc2688_reg_bool_set),
614 static const struct iio_chan_spec_ext_info ltc2688_toggle_ext_info[] = {
615 LTC2688_CHAN_EXT_INFO("raw0", LTC2688_INPUT_A, IIO_SEPARATE,
616 ltc2688_dac_input_read, ltc2688_dac_input_write),
617 LTC2688_CHAN_EXT_INFO("raw1", LTC2688_INPUT_B, IIO_SEPARATE,
618 ltc2688_dac_input_read, ltc2688_dac_input_write),
619 LTC2688_CHAN_EXT_INFO("toggle_en", LTC2688_CMD_TOGGLE_DITHER_EN,
620 IIO_SEPARATE, ltc2688_reg_bool_get,
621 ltc2688_dither_toggle_set),
622 LTC2688_CHAN_EXT_INFO("powerdown", LTC2688_CMD_POWERDOWN, IIO_SEPARATE,
623 ltc2688_reg_bool_get, ltc2688_reg_bool_set),
627 static struct iio_chan_spec_ext_info ltc2688_dither_ext_info[] = {
628 LTC2688_CHAN_EXT_INFO("dither_raw", LTC2688_INPUT_B, IIO_SEPARATE,
629 ltc2688_dac_input_read, ltc2688_dac_input_write),
630 LTC2688_CHAN_EXT_INFO("dither_raw_available", LTC2688_INPUT_B_AVAIL,
631 IIO_SEPARATE, ltc2688_dac_input_read,
632 ltc2688_dac_input_write),
633 LTC2688_CHAN_EXT_INFO("dither_offset", LTC2688_DITHER_OFF, IIO_SEPARATE,
634 ltc2688_dac_input_read, ltc2688_dac_input_write),
636 * Not IIO_ENUM because the available freq needs to be computed at
637 * probe. We could still use it, but it didn't felt much right.
639 LTC2688_CHAN_EXT_INFO("dither_frequency", 0, IIO_SEPARATE,
640 ltc2688_dither_freq_get, ltc2688_dither_freq_set),
641 LTC2688_CHAN_EXT_INFO("dither_frequency_available",
642 LTC2688_DITHER_FREQ_AVAIL, IIO_SEPARATE,
643 ltc2688_dither_freq_get, ltc2688_dither_freq_set),
644 IIO_ENUM("dither_phase", IIO_SEPARATE, <c2688_dither_phase_enum),
645 IIO_ENUM_AVAILABLE("dither_phase", IIO_SEPARATE,
646 <c2688_dither_phase_enum),
647 LTC2688_CHAN_EXT_INFO("dither_en", LTC2688_CMD_TOGGLE_DITHER_EN,
648 IIO_SEPARATE, ltc2688_reg_bool_get,
649 ltc2688_dither_toggle_set),
650 LTC2688_CHAN_EXT_INFO("powerdown", LTC2688_CMD_POWERDOWN, IIO_SEPARATE,
651 ltc2688_reg_bool_get, ltc2688_reg_bool_set),
655 static const struct iio_chan_spec_ext_info ltc2688_ext_info[] = {
656 LTC2688_CHAN_EXT_INFO("powerdown", LTC2688_CMD_POWERDOWN, IIO_SEPARATE,
657 ltc2688_reg_bool_get, ltc2688_reg_bool_set),
661 #define LTC2688_CHANNEL(_chan) { \
662 .type = IIO_VOLTAGE, \
665 .channel = (_chan), \
666 .info_mask_separate = BIT(IIO_CHAN_INFO_CALIBSCALE) | \
667 BIT(IIO_CHAN_INFO_SCALE) | BIT(IIO_CHAN_INFO_OFFSET) | \
668 BIT(IIO_CHAN_INFO_CALIBBIAS) | BIT(IIO_CHAN_INFO_RAW), \
669 .info_mask_separate_available = BIT(IIO_CHAN_INFO_RAW), \
670 .ext_info = ltc2688_ext_info, \
673 static const struct iio_chan_spec ltc2688_channels[] = {
692 static void ltc2688_clk_disable(void *clk)
694 clk_disable_unprepare(clk);
697 static const int ltc2688_period[LTC2688_DITHER_FREQ_AVAIL_N] = {
701 static int ltc2688_tgp_clk_setup(struct ltc2688_state *st,
702 struct ltc2688_chan *chan,
703 struct fwnode_handle *node, int tgp)
705 struct device *dev = &st->spi->dev;
710 clk = devm_get_clk_from_child(dev, to_of_node(node), NULL);
712 return dev_err_probe(dev, PTR_ERR(clk), "failed to get tgp clk.\n");
714 ret = clk_prepare_enable(clk);
716 return dev_err_probe(dev, ret, "failed to enable tgp clk.\n");
718 ret = devm_add_action_or_reset(dev, ltc2688_clk_disable, clk);
722 if (chan->toggle_chan)
725 /* calculate available dither frequencies */
726 rate = clk_get_rate(clk);
727 for (f = 0; f < ARRAY_SIZE(chan->dither_frequency); f++)
728 chan->dither_frequency[f] = DIV_ROUND_CLOSEST(rate, ltc2688_period[f]);
733 static int ltc2688_span_lookup(const struct ltc2688_state *st, int min, int max)
737 for (span = 0; span < ARRAY_SIZE(ltc2688_span_helper); span++) {
738 if (min == ltc2688_span_helper[span][0] &&
739 max == ltc2688_span_helper[span][1])
746 static int ltc2688_channel_config(struct ltc2688_state *st)
748 struct device *dev = &st->spi->dev;
749 struct fwnode_handle *child;
750 u32 reg, clk_input, val, tmp[2];
753 device_for_each_child_node(dev, child) {
754 struct ltc2688_chan *chan;
756 ret = fwnode_property_read_u32(child, "reg", ®);
758 fwnode_handle_put(child);
759 return dev_err_probe(dev, ret,
760 "Failed to get reg property\n");
763 if (reg >= LTC2688_DAC_CHANNELS) {
764 fwnode_handle_put(child);
765 return dev_err_probe(dev, -EINVAL,
766 "reg bigger than: %d\n",
767 LTC2688_DAC_CHANNELS);
771 chan = &st->channels[reg];
772 if (fwnode_property_read_bool(child, "adi,toggle-mode")) {
773 chan->toggle_chan = true;
774 /* assume sw toggle ABI */
775 st->iio_chan[reg].ext_info = ltc2688_toggle_sym_ext_info;
777 * Clear IIO_CHAN_INFO_RAW bit as toggle channels expose
778 * out_voltage_raw{0|1} files.
780 __clear_bit(IIO_CHAN_INFO_RAW,
781 &st->iio_chan[reg].info_mask_separate);
784 ret = fwnode_property_read_u32_array(child, "adi,output-range-microvolt",
785 tmp, ARRAY_SIZE(tmp));
787 span = ltc2688_span_lookup(st, (int)tmp[0] / 1000,
790 fwnode_handle_put(child);
791 return dev_err_probe(dev, -EINVAL,
792 "output range not valid:[%d %d]\n",
796 val |= FIELD_PREP(LTC2688_CH_SPAN_MSK, span);
799 ret = fwnode_property_read_u32(child, "adi,toggle-dither-input",
802 if (clk_input >= LTC2688_CH_TGP_MAX) {
803 fwnode_handle_put(child);
804 return dev_err_probe(dev, -EINVAL,
805 "toggle-dither-input inv value(%d)\n",
809 ret = ltc2688_tgp_clk_setup(st, chan, child, clk_input);
811 fwnode_handle_put(child);
816 * 0 means software toggle which is the default mode.
819 val |= FIELD_PREP(LTC2688_CH_TD_SEL_MSK, clk_input + 1);
822 * If a TGPx is given, we automatically assume a dither
823 * capable channel (unless toggle is already enabled).
824 * On top of this we just set here the dither bit in the
825 * channel settings. It won't have any effect until the
826 * global toggle/dither bit is enabled.
828 if (!chan->toggle_chan) {
829 val |= FIELD_PREP(LTC2688_CH_MODE_MSK, 1);
830 st->iio_chan[reg].ext_info = ltc2688_dither_ext_info;
832 /* wait, no sw toggle after all */
833 st->iio_chan[reg].ext_info = ltc2688_toggle_ext_info;
837 if (fwnode_property_read_bool(child, "adi,overrange")) {
838 chan->overrange = true;
839 val |= LTC2688_CH_OVERRANGE_MSK;
845 ret = regmap_write(st->regmap, LTC2688_CMD_CH_SETTING(reg),
848 fwnode_handle_put(child);
849 return dev_err_probe(dev, -EINVAL,
850 "failed to set chan settings\n");
857 static int ltc2688_setup(struct ltc2688_state *st, struct regulator *vref)
859 struct device *dev = &st->spi->dev;
860 struct gpio_desc *gpio;
864 * If we have a reset pin, use that to reset the board, If not, use
867 gpio = devm_gpiod_get_optional(dev, "clr", GPIOD_OUT_HIGH);
869 return dev_err_probe(dev, PTR_ERR(gpio), "Failed to get reset gpio");
871 usleep_range(1000, 1200);
872 /* bring device out of reset */
873 gpiod_set_value_cansleep(gpio, 0);
875 ret = regmap_update_bits(st->regmap, LTC2688_CMD_CONFIG,
882 usleep_range(10000, 12000);
885 * Duplicate the default channel configuration as it can change during
886 * @ltc2688_channel_config()
888 st->iio_chan = devm_kmemdup(dev, ltc2688_channels,
889 sizeof(ltc2688_channels), GFP_KERNEL);
893 ret = ltc2688_channel_config(st);
900 return regmap_set_bits(st->regmap, LTC2688_CMD_CONFIG,
901 LTC2688_CONFIG_EXT_REF);
904 static void ltc2688_disable_regulator(void *regulator)
906 regulator_disable(regulator);
909 static bool ltc2688_reg_readable(struct device *dev, unsigned int reg)
912 case LTC2688_CMD_CH_CODE(0) ... LTC2688_CMD_CH_GAIN(15):
914 case LTC2688_CMD_CONFIG ... LTC2688_CMD_THERMAL_STAT:
921 static bool ltc2688_reg_writable(struct device *dev, unsigned int reg)
924 * There's a jump from 0x76 to 0x78 in the write codes and the thermal
925 * status code is 0x77 (which is read only) so that we need to check
926 * that special condition.
928 if (reg <= LTC2688_CMD_UPDATE_ALL && reg != LTC2688_CMD_THERMAL_STAT)
934 static struct regmap_bus ltc2688_regmap_bus = {
935 .read = ltc2688_spi_read,
936 .write = ltc2688_spi_write,
937 .read_flag_mask = LTC2688_READ_OPERATION,
938 .reg_format_endian_default = REGMAP_ENDIAN_BIG,
939 .val_format_endian_default = REGMAP_ENDIAN_BIG,
942 static const struct regmap_config ltc2688_regmap_config = {
945 .readable_reg = ltc2688_reg_readable,
946 .writeable_reg = ltc2688_reg_writable,
947 /* ignoring the no op command */
948 .max_register = LTC2688_CMD_UPDATE_ALL,
951 static const struct iio_info ltc2688_info = {
952 .write_raw = ltc2688_write_raw,
953 .read_raw = ltc2688_read_raw,
954 .read_avail = ltc2688_read_avail,
955 .debugfs_reg_access = ltc2688_reg_access,
958 static int ltc2688_probe(struct spi_device *spi)
960 static const char * const regulators[] = { "vcc", "iovcc" };
961 struct ltc2688_state *st;
962 struct iio_dev *indio_dev;
963 struct regulator *vref_reg;
964 struct device *dev = &spi->dev;
967 indio_dev = devm_iio_device_alloc(dev, sizeof(*st));
971 st = iio_priv(indio_dev);
974 /* Just write this once. No need to do it in every regmap read. */
975 st->tx_data[3] = LTC2688_CMD_NOOP;
976 mutex_init(&st->lock);
978 st->regmap = devm_regmap_init(dev, <c2688_regmap_bus, st,
979 <c2688_regmap_config);
980 if (IS_ERR(st->regmap))
981 return dev_err_probe(dev, PTR_ERR(st->regmap),
982 "Failed to init regmap");
984 ret = devm_regulator_bulk_get_enable(dev, ARRAY_SIZE(regulators),
987 return dev_err_probe(dev, ret, "Failed to enable regulators\n");
989 vref_reg = devm_regulator_get_optional(dev, "vref");
990 if (IS_ERR(vref_reg)) {
991 if (PTR_ERR(vref_reg) != -ENODEV)
992 return dev_err_probe(dev, PTR_ERR(vref_reg),
993 "Failed to get vref regulator");
996 /* internal reference */
999 ret = regulator_enable(vref_reg);
1001 return dev_err_probe(dev, ret,
1002 "Failed to enable vref regulators\n");
1004 ret = devm_add_action_or_reset(dev, ltc2688_disable_regulator,
1009 ret = regulator_get_voltage(vref_reg);
1011 return dev_err_probe(dev, ret, "Failed to get vref\n");
1013 st->vref = ret / 1000;
1016 ret = ltc2688_setup(st, vref_reg);
1020 indio_dev->name = "ltc2688";
1021 indio_dev->info = <c2688_info;
1022 indio_dev->modes = INDIO_DIRECT_MODE;
1023 indio_dev->channels = st->iio_chan;
1024 indio_dev->num_channels = ARRAY_SIZE(ltc2688_channels);
1026 return devm_iio_device_register(dev, indio_dev);
1029 static const struct of_device_id ltc2688_of_id[] = {
1030 { .compatible = "adi,ltc2688" },
1033 MODULE_DEVICE_TABLE(of, ltc2688_of_id);
1035 static const struct spi_device_id ltc2688_id[] = {
1039 MODULE_DEVICE_TABLE(spi, ltc2688_id);
1041 static struct spi_driver ltc2688_driver = {
1044 .of_match_table = ltc2688_of_id,
1046 .probe = ltc2688_probe,
1047 .id_table = ltc2688_id,
1049 module_spi_driver(ltc2688_driver);
1051 MODULE_AUTHOR("Nuno Sá <nuno.sa@analog.com>");
1052 MODULE_DESCRIPTION("Analog Devices LTC2688 DAC");
1053 MODULE_LICENSE("GPL");