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 regulator_bulk_data regulators[2];
88 struct ltc2688_chan channels[LTC2688_DAC_CHANNELS];
89 struct iio_chan_spec *iio_chan;
90 /* lock to protect against multiple access to the device and shared data */
94 * DMA (thus cache coherency maintenance) requires the
95 * transfer buffers to live in their own cache lines.
97 u8 tx_data[6] ____cacheline_aligned;
101 static int ltc2688_spi_read(void *context, const void *reg, size_t reg_size,
102 void *val, size_t val_size)
104 struct ltc2688_state *st = context;
105 struct spi_transfer xfers[] = {
107 .tx_buf = st->tx_data,
109 .len = reg_size + val_size,
112 .tx_buf = st->tx_data + 3,
113 .rx_buf = st->rx_data,
115 .len = reg_size + val_size,
120 memcpy(st->tx_data, reg, reg_size);
122 ret = spi_sync_transfer(st->spi, xfers, ARRAY_SIZE(xfers));
126 memcpy(val, &st->rx_data[1], val_size);
131 static int ltc2688_spi_write(void *context, const void *data, size_t count)
133 struct ltc2688_state *st = context;
135 return spi_write(st->spi, data, count);
138 static int ltc2688_span_get(const struct ltc2688_state *st, int c)
142 ret = regmap_read(st->regmap, LTC2688_CMD_CH_SETTING(c), ®);
146 span = FIELD_GET(LTC2688_CH_SPAN_MSK, reg);
147 /* sanity check to make sure we don't get any weird value from the HW */
148 if (span >= LTC2688_SPAN_RANGE_MAX)
154 static const int ltc2688_span_helper[LTC2688_SPAN_RANGE_MAX][2] = {
155 {0, 5000}, {0, 10000}, {-5000, 5000}, {-10000, 10000}, {-15000, 15000},
158 static int ltc2688_scale_get(const struct ltc2688_state *st, int c, int *val)
160 const struct ltc2688_chan *chan = &st->channels[c];
163 span = ltc2688_span_get(st, c);
167 fs = ltc2688_span_helper[span][1] - ltc2688_span_helper[span][0];
169 fs = mult_frac(fs, 105, 100);
171 *val = DIV_ROUND_CLOSEST(fs * st->vref, 4096);
176 static int ltc2688_offset_get(const struct ltc2688_state *st, int c, int *val)
180 span = ltc2688_span_get(st, c);
184 if (ltc2688_span_helper[span][0] < 0)
195 LTC2688_INPUT_B_AVAIL,
197 LTC2688_DITHER_FREQ_AVAIL,
200 static int ltc2688_dac_code_write(struct ltc2688_state *st, u32 chan, u32 input,
203 struct ltc2688_chan *c = &st->channels[chan];
206 /* 2 LSBs set to 0 if writing dither amplitude */
207 if (!c->toggle_chan && input == LTC2688_INPUT_B) {
208 if (code > LTC2688_DITHER_RAW_MAX_VAL)
211 code = FIELD_PREP(LTC2688_DITHER_RAW_MASK, code);
214 mutex_lock(&st->lock);
215 /* select the correct input register to read from */
216 ret = regmap_update_bits(st->regmap, LTC2688_CMD_A_B_SELECT, BIT(chan),
222 * If in dither/toggle mode the dac should be updated by an
223 * external signal (or sw toggle) and not here.
225 if (c->mode == LTC2688_MODE_DEFAULT)
226 reg = LTC2688_CMD_CH_CODE_UPDATE(chan);
228 reg = LTC2688_CMD_CH_CODE(chan);
230 ret = regmap_write(st->regmap, reg, code);
232 mutex_unlock(&st->lock);
236 static int ltc2688_dac_code_read(struct ltc2688_state *st, u32 chan, u32 input,
239 struct ltc2688_chan *c = &st->channels[chan];
242 mutex_lock(&st->lock);
243 ret = regmap_update_bits(st->regmap, LTC2688_CMD_A_B_SELECT, BIT(chan),
248 ret = regmap_read(st->regmap, LTC2688_CMD_CH_CODE(chan), code);
250 mutex_unlock(&st->lock);
252 if (!c->toggle_chan && input == LTC2688_INPUT_B)
253 *code = FIELD_GET(LTC2688_DITHER_RAW_MASK, *code);
258 static const int ltc2688_raw_range[] = {0, 1, U16_MAX};
260 static int ltc2688_read_avail(struct iio_dev *indio_dev,
261 struct iio_chan_spec const *chan,
262 const int **vals, int *type, int *length,
266 case IIO_CHAN_INFO_RAW:
267 *vals = ltc2688_raw_range;
269 return IIO_AVAIL_RANGE;
275 static int ltc2688_read_raw(struct iio_dev *indio_dev,
276 struct iio_chan_spec const *chan, int *val,
277 int *val2, long info)
279 struct ltc2688_state *st = iio_priv(indio_dev);
283 case IIO_CHAN_INFO_RAW:
284 ret = ltc2688_dac_code_read(st, chan->channel, LTC2688_INPUT_A,
290 case IIO_CHAN_INFO_OFFSET:
291 ret = ltc2688_offset_get(st, chan->channel, val);
296 case IIO_CHAN_INFO_SCALE:
297 ret = ltc2688_scale_get(st, chan->channel, val);
302 return IIO_VAL_FRACTIONAL_LOG2;
303 case IIO_CHAN_INFO_CALIBBIAS:
304 ret = regmap_read(st->regmap,
305 LTC2688_CMD_CH_OFFSET(chan->channel), val);
309 *val = FIELD_GET(LTC2688_CH_CALIBBIAS_MASK, *val);
311 case IIO_CHAN_INFO_CALIBSCALE:
312 ret = regmap_read(st->regmap,
313 LTC2688_CMD_CH_GAIN(chan->channel), val);
323 static int ltc2688_write_raw(struct iio_dev *indio_dev,
324 struct iio_chan_spec const *chan, int val,
327 struct ltc2688_state *st = iio_priv(indio_dev);
330 case IIO_CHAN_INFO_RAW:
331 if (val > U16_MAX || val < 0)
334 return ltc2688_dac_code_write(st, chan->channel,
335 LTC2688_INPUT_A, val);
336 case IIO_CHAN_INFO_CALIBBIAS:
337 if (val > LTC2688_CH_CALIBBIAS_MAX_VAL)
340 return regmap_write(st->regmap,
341 LTC2688_CMD_CH_OFFSET(chan->channel),
342 FIELD_PREP(LTC2688_CH_CALIBBIAS_MASK, val));
343 case IIO_CHAN_INFO_CALIBSCALE:
344 return regmap_write(st->regmap,
345 LTC2688_CMD_CH_GAIN(chan->channel), val);
351 static ssize_t ltc2688_dither_toggle_set(struct iio_dev *indio_dev,
353 const struct iio_chan_spec *chan,
354 const char *buf, size_t len)
356 struct ltc2688_state *st = iio_priv(indio_dev);
357 struct ltc2688_chan *c = &st->channels[chan->channel];
361 ret = kstrtobool(buf, &en);
365 mutex_lock(&st->lock);
366 ret = regmap_update_bits(st->regmap, LTC2688_CMD_TOGGLE_DITHER_EN,
367 BIT(chan->channel), en << chan->channel);
371 c->mode = en ? LTC2688_MODE_DITHER_TOGGLE : LTC2688_MODE_DEFAULT;
373 mutex_unlock(&st->lock);
378 static ssize_t ltc2688_reg_bool_get(struct iio_dev *indio_dev,
380 const struct iio_chan_spec *chan,
383 const struct ltc2688_state *st = iio_priv(indio_dev);
387 ret = regmap_read(st->regmap, private, &val);
391 return sysfs_emit(buf, "%u\n", !!(val & BIT(chan->channel)));
394 static ssize_t ltc2688_reg_bool_set(struct iio_dev *indio_dev,
396 const struct iio_chan_spec *chan,
397 const char *buf, size_t len)
399 const struct ltc2688_state *st = iio_priv(indio_dev);
403 ret = kstrtobool(buf, &en);
407 ret = regmap_update_bits(st->regmap, private, BIT(chan->channel),
408 en << chan->channel);
415 static ssize_t ltc2688_dither_freq_avail(const struct ltc2688_state *st,
416 const struct ltc2688_chan *chan,
422 for (f = 0; f < ARRAY_SIZE(chan->dither_frequency); f++)
423 sz += sysfs_emit_at(buf, sz, "%ld ", chan->dither_frequency[f]);
430 static ssize_t ltc2688_dither_freq_get(struct iio_dev *indio_dev,
432 const struct iio_chan_spec *chan,
435 const struct ltc2688_state *st = iio_priv(indio_dev);
436 const struct ltc2688_chan *c = &st->channels[chan->channel];
440 if (private == LTC2688_DITHER_FREQ_AVAIL)
441 return ltc2688_dither_freq_avail(st, c, buf);
443 ret = regmap_read(st->regmap, LTC2688_CMD_CH_SETTING(chan->channel),
448 freq = FIELD_GET(LTC2688_CH_DIT_PER_MSK, reg);
449 if (freq >= ARRAY_SIZE(c->dither_frequency))
452 return sysfs_emit(buf, "%ld\n", c->dither_frequency[freq]);
455 static ssize_t ltc2688_dither_freq_set(struct iio_dev *indio_dev,
457 const struct iio_chan_spec *chan,
458 const char *buf, size_t len)
460 const struct ltc2688_state *st = iio_priv(indio_dev);
461 const struct ltc2688_chan *c = &st->channels[chan->channel];
466 if (private == LTC2688_DITHER_FREQ_AVAIL)
469 ret = kstrtol(buf, 10, &val);
473 for (freq = 0; freq < ARRAY_SIZE(c->dither_frequency); freq++) {
474 if (val == c->dither_frequency[freq])
478 if (freq == ARRAY_SIZE(c->dither_frequency))
481 ret = regmap_update_bits(st->regmap,
482 LTC2688_CMD_CH_SETTING(chan->channel),
483 LTC2688_CH_DIT_PER_MSK,
484 FIELD_PREP(LTC2688_CH_DIT_PER_MSK, freq));
491 static ssize_t ltc2688_dac_input_read(struct iio_dev *indio_dev,
493 const struct iio_chan_spec *chan,
496 struct ltc2688_state *st = iio_priv(indio_dev);
500 if (private == LTC2688_INPUT_B_AVAIL)
501 return sysfs_emit(buf, "[%u %u %u]\n", ltc2688_raw_range[0],
502 ltc2688_raw_range[1],
503 ltc2688_raw_range[2] / 4);
505 if (private == LTC2688_DITHER_OFF)
506 return sysfs_emit(buf, "0\n");
508 ret = ltc2688_dac_code_read(st, chan->channel, private, &val);
512 return sysfs_emit(buf, "%u\n", val);
515 static ssize_t ltc2688_dac_input_write(struct iio_dev *indio_dev,
517 const struct iio_chan_spec *chan,
518 const char *buf, size_t len)
520 struct ltc2688_state *st = iio_priv(indio_dev);
524 if (private == LTC2688_INPUT_B_AVAIL || private == LTC2688_DITHER_OFF)
527 ret = kstrtou16(buf, 10, &val);
531 ret = ltc2688_dac_code_write(st, chan->channel, private, val);
538 static int ltc2688_get_dither_phase(struct iio_dev *dev,
539 const struct iio_chan_spec *chan)
541 struct ltc2688_state *st = iio_priv(dev);
544 ret = regmap_read(st->regmap, LTC2688_CMD_CH_SETTING(chan->channel),
549 return FIELD_GET(LTC2688_CH_DIT_PH_MSK, regval);
552 static int ltc2688_set_dither_phase(struct iio_dev *dev,
553 const struct iio_chan_spec *chan,
556 struct ltc2688_state *st = iio_priv(dev);
558 return regmap_update_bits(st->regmap,
559 LTC2688_CMD_CH_SETTING(chan->channel),
560 LTC2688_CH_DIT_PH_MSK,
561 FIELD_PREP(LTC2688_CH_DIT_PH_MSK, phase));
564 static int ltc2688_reg_access(struct iio_dev *indio_dev,
566 unsigned int writeval,
567 unsigned int *readval)
569 struct ltc2688_state *st = iio_priv(indio_dev);
572 return regmap_read(st->regmap, reg, readval);
574 return regmap_write(st->regmap, reg, writeval);
577 static const char * const ltc2688_dither_phase[] = {
578 "0", "1.5708", "3.14159", "4.71239",
581 static const struct iio_enum ltc2688_dither_phase_enum = {
582 .items = ltc2688_dither_phase,
583 .num_items = ARRAY_SIZE(ltc2688_dither_phase),
584 .set = ltc2688_set_dither_phase,
585 .get = ltc2688_get_dither_phase,
588 #define LTC2688_CHAN_EXT_INFO(_name, _what, _shared, _read, _write) { \
592 .private = (_what), \
593 .shared = (_shared), \
597 * For toggle mode we only expose the symbol attr (sw_toggle) in case a TGPx is
598 * not provided in dts.
600 static const struct iio_chan_spec_ext_info ltc2688_toggle_sym_ext_info[] = {
601 LTC2688_CHAN_EXT_INFO("raw0", LTC2688_INPUT_A, IIO_SEPARATE,
602 ltc2688_dac_input_read, ltc2688_dac_input_write),
603 LTC2688_CHAN_EXT_INFO("raw1", LTC2688_INPUT_B, IIO_SEPARATE,
604 ltc2688_dac_input_read, ltc2688_dac_input_write),
605 LTC2688_CHAN_EXT_INFO("toggle_en", LTC2688_CMD_TOGGLE_DITHER_EN,
606 IIO_SEPARATE, ltc2688_reg_bool_get,
607 ltc2688_dither_toggle_set),
608 LTC2688_CHAN_EXT_INFO("powerdown", LTC2688_CMD_POWERDOWN, IIO_SEPARATE,
609 ltc2688_reg_bool_get, ltc2688_reg_bool_set),
610 LTC2688_CHAN_EXT_INFO("symbol", LTC2688_CMD_SW_TOGGLE, IIO_SEPARATE,
611 ltc2688_reg_bool_get, ltc2688_reg_bool_set),
615 static const struct iio_chan_spec_ext_info ltc2688_toggle_ext_info[] = {
616 LTC2688_CHAN_EXT_INFO("raw0", LTC2688_INPUT_A, IIO_SEPARATE,
617 ltc2688_dac_input_read, ltc2688_dac_input_write),
618 LTC2688_CHAN_EXT_INFO("raw1", LTC2688_INPUT_B, IIO_SEPARATE,
619 ltc2688_dac_input_read, ltc2688_dac_input_write),
620 LTC2688_CHAN_EXT_INFO("toggle_en", LTC2688_CMD_TOGGLE_DITHER_EN,
621 IIO_SEPARATE, ltc2688_reg_bool_get,
622 ltc2688_dither_toggle_set),
623 LTC2688_CHAN_EXT_INFO("powerdown", LTC2688_CMD_POWERDOWN, IIO_SEPARATE,
624 ltc2688_reg_bool_get, ltc2688_reg_bool_set),
628 static struct iio_chan_spec_ext_info ltc2688_dither_ext_info[] = {
629 LTC2688_CHAN_EXT_INFO("dither_raw", LTC2688_INPUT_B, IIO_SEPARATE,
630 ltc2688_dac_input_read, ltc2688_dac_input_write),
631 LTC2688_CHAN_EXT_INFO("dither_raw_available", LTC2688_INPUT_B_AVAIL,
632 IIO_SEPARATE, ltc2688_dac_input_read,
633 ltc2688_dac_input_write),
634 LTC2688_CHAN_EXT_INFO("dither_offset", LTC2688_DITHER_OFF, IIO_SEPARATE,
635 ltc2688_dac_input_read, ltc2688_dac_input_write),
637 * Not IIO_ENUM because the available freq needs to be computed at
638 * probe. We could still use it, but it didn't felt much right.
640 LTC2688_CHAN_EXT_INFO("dither_frequency", 0, IIO_SEPARATE,
641 ltc2688_dither_freq_get, ltc2688_dither_freq_set),
642 LTC2688_CHAN_EXT_INFO("dither_frequency_available",
643 LTC2688_DITHER_FREQ_AVAIL, IIO_SEPARATE,
644 ltc2688_dither_freq_get, ltc2688_dither_freq_set),
645 IIO_ENUM("dither_phase", IIO_SEPARATE, <c2688_dither_phase_enum),
646 IIO_ENUM_AVAILABLE("dither_phase", IIO_SEPARATE,
647 <c2688_dither_phase_enum),
648 LTC2688_CHAN_EXT_INFO("dither_en", LTC2688_CMD_TOGGLE_DITHER_EN,
649 IIO_SEPARATE, ltc2688_reg_bool_get,
650 ltc2688_dither_toggle_set),
651 LTC2688_CHAN_EXT_INFO("powerdown", LTC2688_CMD_POWERDOWN, IIO_SEPARATE,
652 ltc2688_reg_bool_get, ltc2688_reg_bool_set),
656 static const struct iio_chan_spec_ext_info ltc2688_ext_info[] = {
657 LTC2688_CHAN_EXT_INFO("powerdown", LTC2688_CMD_POWERDOWN, IIO_SEPARATE,
658 ltc2688_reg_bool_get, ltc2688_reg_bool_set),
662 #define LTC2688_CHANNEL(_chan) { \
663 .type = IIO_VOLTAGE, \
666 .channel = (_chan), \
667 .info_mask_separate = BIT(IIO_CHAN_INFO_CALIBSCALE) | \
668 BIT(IIO_CHAN_INFO_SCALE) | BIT(IIO_CHAN_INFO_OFFSET) | \
669 BIT(IIO_CHAN_INFO_CALIBBIAS) | BIT(IIO_CHAN_INFO_RAW), \
670 .info_mask_separate_available = BIT(IIO_CHAN_INFO_RAW), \
671 .ext_info = ltc2688_ext_info, \
674 static const struct iio_chan_spec ltc2688_channels[] = {
693 static void ltc2688_clk_disable(void *clk)
695 clk_disable_unprepare(clk);
698 static const int ltc2688_period[LTC2688_DITHER_FREQ_AVAIL_N] = {
702 static int ltc2688_tgp_clk_setup(struct ltc2688_state *st,
703 struct ltc2688_chan *chan,
704 struct fwnode_handle *node, int tgp)
706 struct device *dev = &st->spi->dev;
711 clk = devm_get_clk_from_child(dev, to_of_node(node), NULL);
713 return dev_err_probe(dev, PTR_ERR(clk), "failed to get tgp clk.\n");
715 ret = clk_prepare_enable(clk);
717 return dev_err_probe(dev, ret, "failed to enable tgp clk.\n");
719 ret = devm_add_action_or_reset(dev, ltc2688_clk_disable, clk);
723 if (chan->toggle_chan)
726 /* calculate available dither frequencies */
727 rate = clk_get_rate(clk);
728 for (f = 0; f < ARRAY_SIZE(chan->dither_frequency); f++)
729 chan->dither_frequency[f] = DIV_ROUND_CLOSEST(rate, ltc2688_period[f]);
734 static int ltc2688_span_lookup(const struct ltc2688_state *st, int min, int max)
738 for (span = 0; span < ARRAY_SIZE(ltc2688_span_helper); span++) {
739 if (min == ltc2688_span_helper[span][0] &&
740 max == ltc2688_span_helper[span][1])
747 static int ltc2688_channel_config(struct ltc2688_state *st)
749 struct device *dev = &st->spi->dev;
750 struct fwnode_handle *child;
751 u32 reg, clk_input, val, tmp[2];
754 device_for_each_child_node(dev, child) {
755 struct ltc2688_chan *chan;
757 ret = fwnode_property_read_u32(child, "reg", ®);
759 fwnode_handle_put(child);
760 return dev_err_probe(dev, ret,
761 "Failed to get reg property\n");
764 if (reg >= LTC2688_DAC_CHANNELS) {
765 fwnode_handle_put(child);
766 return dev_err_probe(dev, -EINVAL,
767 "reg bigger than: %d\n",
768 LTC2688_DAC_CHANNELS);
772 chan = &st->channels[reg];
773 if (fwnode_property_read_bool(child, "adi,toggle-mode")) {
774 chan->toggle_chan = true;
775 /* assume sw toggle ABI */
776 st->iio_chan[reg].ext_info = ltc2688_toggle_sym_ext_info;
778 * Clear IIO_CHAN_INFO_RAW bit as toggle channels expose
779 * out_voltage_raw{0|1} files.
781 __clear_bit(IIO_CHAN_INFO_RAW,
782 &st->iio_chan[reg].info_mask_separate);
785 ret = fwnode_property_read_u32_array(child, "adi,output-range-microvolt",
786 tmp, ARRAY_SIZE(tmp));
788 span = ltc2688_span_lookup(st, (int)tmp[0] / 1000,
791 fwnode_handle_put(child);
792 return dev_err_probe(dev, -EINVAL,
793 "output range not valid:[%d %d]\n",
797 val |= FIELD_PREP(LTC2688_CH_SPAN_MSK, span);
800 ret = fwnode_property_read_u32(child, "adi,toggle-dither-input",
803 if (clk_input >= LTC2688_CH_TGP_MAX) {
804 fwnode_handle_put(child);
805 return dev_err_probe(dev, -EINVAL,
806 "toggle-dither-input inv value(%d)\n",
810 ret = ltc2688_tgp_clk_setup(st, chan, child, clk_input);
812 fwnode_handle_put(child);
817 * 0 means software toggle which is the default mode.
820 val |= FIELD_PREP(LTC2688_CH_TD_SEL_MSK, clk_input + 1);
823 * If a TGPx is given, we automatically assume a dither
824 * capable channel (unless toggle is already enabled).
825 * On top of this we just set here the dither bit in the
826 * channel settings. It won't have any effect until the
827 * global toggle/dither bit is enabled.
829 if (!chan->toggle_chan) {
830 val |= FIELD_PREP(LTC2688_CH_MODE_MSK, 1);
831 st->iio_chan[reg].ext_info = ltc2688_dither_ext_info;
833 /* wait, no sw toggle after all */
834 st->iio_chan[reg].ext_info = ltc2688_toggle_ext_info;
838 if (fwnode_property_read_bool(child, "adi,overrange")) {
839 chan->overrange = true;
840 val |= LTC2688_CH_OVERRANGE_MSK;
846 ret = regmap_write(st->regmap, LTC2688_CMD_CH_SETTING(reg),
849 fwnode_handle_put(child);
850 return dev_err_probe(dev, -EINVAL,
851 "failed to set chan settings\n");
858 static int ltc2688_setup(struct ltc2688_state *st, struct regulator *vref)
860 struct device *dev = &st->spi->dev;
861 struct gpio_desc *gpio;
865 * If we have a reset pin, use that to reset the board, If not, use
868 gpio = devm_gpiod_get_optional(dev, "clr", GPIOD_OUT_HIGH);
870 return dev_err_probe(dev, PTR_ERR(gpio), "Failed to get reset gpio");
872 usleep_range(1000, 1200);
873 /* bring device out of reset */
874 gpiod_set_value_cansleep(gpio, 0);
876 ret = regmap_update_bits(st->regmap, LTC2688_CMD_CONFIG,
883 usleep_range(10000, 12000);
886 * Duplicate the default channel configuration as it can change during
887 * @ltc2688_channel_config()
889 st->iio_chan = devm_kmemdup(dev, ltc2688_channels,
890 sizeof(ltc2688_channels), GFP_KERNEL);
894 ret = ltc2688_channel_config(st);
901 return regmap_set_bits(st->regmap, LTC2688_CMD_CONFIG,
902 LTC2688_CONFIG_EXT_REF);
905 static void ltc2688_disable_regulators(void *data)
907 struct ltc2688_state *st = data;
909 regulator_bulk_disable(ARRAY_SIZE(st->regulators), st->regulators);
912 static void ltc2688_disable_regulator(void *regulator)
914 regulator_disable(regulator);
917 static bool ltc2688_reg_readable(struct device *dev, unsigned int reg)
920 case LTC2688_CMD_CH_CODE(0) ... LTC2688_CMD_CH_GAIN(15):
922 case LTC2688_CMD_CONFIG ... LTC2688_CMD_THERMAL_STAT:
929 static bool ltc2688_reg_writable(struct device *dev, unsigned int reg)
932 * There's a jump from 0x76 to 0x78 in the write codes and the thermal
933 * status code is 0x77 (which is read only) so that we need to check
934 * that special condition.
936 if (reg <= LTC2688_CMD_UPDATE_ALL && reg != LTC2688_CMD_THERMAL_STAT)
942 static struct regmap_bus ltc2688_regmap_bus = {
943 .read = ltc2688_spi_read,
944 .write = ltc2688_spi_write,
945 .read_flag_mask = LTC2688_READ_OPERATION,
946 .reg_format_endian_default = REGMAP_ENDIAN_BIG,
947 .val_format_endian_default = REGMAP_ENDIAN_BIG,
950 static const struct regmap_config ltc2688_regmap_config = {
953 .readable_reg = ltc2688_reg_readable,
954 .writeable_reg = ltc2688_reg_writable,
955 /* ignoring the no op command */
956 .max_register = LTC2688_CMD_UPDATE_ALL,
959 static const struct iio_info ltc2688_info = {
960 .write_raw = ltc2688_write_raw,
961 .read_raw = ltc2688_read_raw,
962 .read_avail = ltc2688_read_avail,
963 .debugfs_reg_access = ltc2688_reg_access,
966 static int ltc2688_probe(struct spi_device *spi)
968 struct ltc2688_state *st;
969 struct iio_dev *indio_dev;
970 struct regulator *vref_reg;
971 struct device *dev = &spi->dev;
974 indio_dev = devm_iio_device_alloc(dev, sizeof(*st));
978 st = iio_priv(indio_dev);
981 /* Just write this once. No need to do it in every regmap read. */
982 st->tx_data[3] = LTC2688_CMD_NOOP;
983 mutex_init(&st->lock);
985 st->regmap = devm_regmap_init(dev, <c2688_regmap_bus, st,
986 <c2688_regmap_config);
987 if (IS_ERR(st->regmap))
988 return dev_err_probe(dev, PTR_ERR(st->regmap),
989 "Failed to init regmap");
991 st->regulators[0].supply = "vcc";
992 st->regulators[1].supply = "iovcc";
993 ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(st->regulators),
996 return dev_err_probe(dev, ret, "Failed to get regulators\n");
998 ret = regulator_bulk_enable(ARRAY_SIZE(st->regulators), st->regulators);
1000 return dev_err_probe(dev, ret, "Failed to enable regulators\n");
1002 ret = devm_add_action_or_reset(dev, ltc2688_disable_regulators, st);
1006 vref_reg = devm_regulator_get_optional(dev, "vref");
1007 if (IS_ERR(vref_reg)) {
1008 if (PTR_ERR(vref_reg) != -ENODEV)
1009 return dev_err_probe(dev, PTR_ERR(vref_reg),
1010 "Failed to get vref regulator");
1013 /* internal reference */
1016 ret = regulator_enable(vref_reg);
1018 return dev_err_probe(dev, ret,
1019 "Failed to enable vref regulators\n");
1021 ret = devm_add_action_or_reset(dev, ltc2688_disable_regulator,
1026 ret = regulator_get_voltage(vref_reg);
1028 return dev_err_probe(dev, ret, "Failed to get vref\n");
1030 st->vref = ret / 1000;
1033 ret = ltc2688_setup(st, vref_reg);
1037 indio_dev->name = "ltc2688";
1038 indio_dev->info = <c2688_info;
1039 indio_dev->modes = INDIO_DIRECT_MODE;
1040 indio_dev->channels = st->iio_chan;
1041 indio_dev->num_channels = ARRAY_SIZE(ltc2688_channels);
1043 return devm_iio_device_register(dev, indio_dev);
1046 static const struct of_device_id ltc2688_of_id[] = {
1047 { .compatible = "adi,ltc2688" },
1050 MODULE_DEVICE_TABLE(of, ltc2688_of_id);
1052 static const struct spi_device_id ltc2688_id[] = {
1056 MODULE_DEVICE_TABLE(spi, ltc2688_id);
1058 static struct spi_driver ltc2688_driver = {
1061 .of_match_table = ltc2688_of_id,
1063 .probe = ltc2688_probe,
1064 .id_table = ltc2688_id,
1066 module_spi_driver(ltc2688_driver);
1068 MODULE_AUTHOR("Nuno Sá <nuno.sa@analog.com>");
1069 MODULE_DESCRIPTION("Analog Devices LTC2688 DAC");
1070 MODULE_LICENSE("GPL");