?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
module: Convert symbol namespace to string literal
[linux.git] / drivers / iio / adc / ad7192.c
blob1c87db0e04605042e9a824a3d9d88c3291974691
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * AD7192 and similar SPI ADC driver
4 *
5 * Copyright 2011-2015 Analog Devices Inc.
6 */
7
8 #include <linux/interrupt.h>
9 #include <linux/bitfield.h>
10 #include <linux/clk.h>
11 #include <linux/clk-provider.h>
12 #include <linux/device.h>
13 #include <linux/kernel.h>
14 #include <linux/slab.h>
15 #include <linux/sysfs.h>
16 #include <linux/spi/spi.h>
17 #include <linux/regulator/consumer.h>
18 #include <linux/err.h>
19 #include <linux/sched.h>
20 #include <linux/delay.h>
21 #include <linux/module.h>
22 #include <linux/mod_devicetable.h>
23 #include <linux/property.h>
24 #include <linux/units.h>
25
26 #include <linux/iio/iio.h>
27 #include <linux/iio/sysfs.h>
28 #include <linux/iio/buffer.h>
29 #include <linux/iio/trigger.h>
30 #include <linux/iio/trigger_consumer.h>
31 #include <linux/iio/triggered_buffer.h>
32 #include <linux/iio/adc/ad_sigma_delta.h>
33
34 /* Registers */
35 #define AD7192_REG_COMM 0 /* Communications Register (WO, 8-bit) */
36 #define AD7192_REG_STAT 0 /* Status Register (RO, 8-bit) */
37 #define AD7192_REG_MODE 1 /* Mode Register (RW, 24-bit */
38 #define AD7192_REG_CONF 2 /* Configuration Register (RW, 24-bit) */
39 #define AD7192_REG_DATA 3 /* Data Register (RO, 24/32-bit) */
40 #define AD7192_REG_ID 4 /* ID Register (RO, 8-bit) */
41 #define AD7192_REG_GPOCON 5 /* GPOCON Register (RO, 8-bit) */
42 #define AD7192_REG_OFFSET 6 /* Offset Register (RW, 16-bit */
43 /* (AD7792)/24-bit (AD7192)) */
44 #define AD7192_REG_FULLSALE 7 /* Full-Scale Register */
45 /* (RW, 16-bit (AD7792)/24-bit (AD7192)) */
46
47 /* Communications Register Bit Designations (AD7192_REG_COMM) */
48 #define AD7192_COMM_WEN BIT(7) /* Write Enable */
49 #define AD7192_COMM_WRITE 0 /* Write Operation */
50 #define AD7192_COMM_READ BIT(6) /* Read Operation */
51 #define AD7192_COMM_ADDR_MASK GENMASK(5, 3) /* Register Address Mask */
52 #define AD7192_COMM_CREAD BIT(2) /* Continuous Read of Data Register */
53
54 /* Status Register Bit Designations (AD7192_REG_STAT) */
55 #define AD7192_STAT_RDY BIT(7) /* Ready */
56 #define AD7192_STAT_ERR BIT(6) /* Error (Overrange, Underrange) */
57 #define AD7192_STAT_NOREF BIT(5) /* Error no external reference */
58 #define AD7192_STAT_PARITY BIT(4) /* Parity */
59 #define AD7192_STAT_CH3 BIT(2) /* Channel 3 */
60 #define AD7192_STAT_CH2 BIT(1) /* Channel 2 */
61 #define AD7192_STAT_CH1 BIT(0) /* Channel 1 */
62
63 /* Mode Register Bit Designations (AD7192_REG_MODE) */
64 #define AD7192_MODE_SEL_MASK GENMASK(23, 21) /* Operation Mode Select Mask */
65 #define AD7192_MODE_STA_MASK BIT(20) /* Status Register transmission Mask */
66 #define AD7192_MODE_CLKSRC_MASK GENMASK(19, 18) /* Clock Source Select Mask */
67 #define AD7192_MODE_AVG_MASK GENMASK(17, 16)
68 /* Fast Settling Filter Average Select Mask (AD7193 only) */
69 #define AD7192_MODE_SINC3 BIT(15) /* SINC3 Filter Select */
70 #define AD7192_MODE_ENPAR BIT(13) /* Parity Enable */
71 #define AD7192_MODE_CLKDIV BIT(12) /* Clock divide by 2 (AD7190/2 only)*/
72 #define AD7192_MODE_SCYCLE BIT(11) /* Single cycle conversion */
73 #define AD7192_MODE_REJ60 BIT(10) /* 50/60Hz notch filter */
74 /* Filter Update Rate Select Mask */
75 #define AD7192_MODE_RATE_MASK GENMASK(9, 0)
76
77 /* Mode Register: AD7192_MODE_SEL options */
78 #define AD7192_MODE_CONT 0 /* Continuous Conversion Mode */
79 #define AD7192_MODE_SINGLE 1 /* Single Conversion Mode */
80 #define AD7192_MODE_IDLE 2 /* Idle Mode */
81 #define AD7192_MODE_PWRDN 3 /* Power-Down Mode */
82 #define AD7192_MODE_CAL_INT_ZERO 4 /* Internal Zero-Scale Calibration */
83 #define AD7192_MODE_CAL_INT_FULL 5 /* Internal Full-Scale Calibration */
84 #define AD7192_MODE_CAL_SYS_ZERO 6 /* System Zero-Scale Calibration */
85 #define AD7192_MODE_CAL_SYS_FULL 7 /* System Full-Scale Calibration */
86
87 /* Mode Register: AD7192_MODE_CLKSRC options */
88 #define AD7192_CLK_EXT_MCLK1_2 0 /* External 4.92 MHz Clock connected*/
89 /* from MCLK1 to MCLK2 */
90 #define AD7192_CLK_EXT_MCLK2 1 /* External Clock applied to MCLK2 */
91 #define AD7192_CLK_INT 2 /* Internal 4.92 MHz Clock not */
92 /* available at the MCLK2 pin */
93 #define AD7192_CLK_INT_CO 3 /* Internal 4.92 MHz Clock available*/
94 /* at the MCLK2 pin */
95
96 /* Configuration Register Bit Designations (AD7192_REG_CONF) */
97
98 #define AD7192_CONF_CHOP BIT(23) /* CHOP enable */
99 #define AD7192_CONF_ACX BIT(22) /* AC excitation enable(AD7195 only) */
100 #define AD7192_CONF_REFSEL BIT(20) /* REFIN1/REFIN2 Reference Select */
101 #define AD7192_CONF_CHAN_MASK GENMASK(18, 8) /* Channel select mask */
102 #define AD7192_CONF_BURN BIT(7) /* Burnout current enable */
103 #define AD7192_CONF_REFDET BIT(6) /* Reference detect enable */
104 #define AD7192_CONF_BUF BIT(4) /* Buffered Mode Enable */
105 #define AD7192_CONF_UNIPOLAR BIT(3) /* Unipolar/Bipolar Enable */
106 #define AD7192_CONF_GAIN_MASK GENMASK(2, 0) /* Gain Select */
107
108 #define AD7192_CH_AIN1P_AIN2M BIT(0) /* AIN1(+) - AIN2(-) */
109 #define AD7192_CH_AIN3P_AIN4M BIT(1) /* AIN3(+) - AIN4(-) */
110 #define AD7192_CH_TEMP BIT(2) /* Temp Sensor */
111 #define AD7192_CH_AIN2P_AIN2M BIT(3) /* AIN2(+) - AIN2(-) */
112 #define AD7192_CH_AIN1 BIT(4) /* AIN1 - AINCOM */
113 #define AD7192_CH_AIN2 BIT(5) /* AIN2 - AINCOM */
114 #define AD7192_CH_AIN3 BIT(6) /* AIN3 - AINCOM */
115 #define AD7192_CH_AIN4 BIT(7) /* AIN4 - AINCOM */
116
117 #define AD7193_CH_AIN1P_AIN2M 0x001 /* AIN1(+) - AIN2(-) */
118 #define AD7193_CH_AIN3P_AIN4M 0x002 /* AIN3(+) - AIN4(-) */
119 #define AD7193_CH_AIN5P_AIN6M 0x004 /* AIN5(+) - AIN6(-) */
120 #define AD7193_CH_AIN7P_AIN8M 0x008 /* AIN7(+) - AIN8(-) */
121 #define AD7193_CH_TEMP 0x100 /* Temp senseor */
122 #define AD7193_CH_AIN2P_AIN2M 0x200 /* AIN2(+) - AIN2(-) */
123 #define AD7193_CH_AIN1 0x401 /* AIN1 - AINCOM */
124 #define AD7193_CH_AIN2 0x402 /* AIN2 - AINCOM */
125 #define AD7193_CH_AIN3 0x404 /* AIN3 - AINCOM */
126 #define AD7193_CH_AIN4 0x408 /* AIN4 - AINCOM */
127 #define AD7193_CH_AIN5 0x410 /* AIN5 - AINCOM */
128 #define AD7193_CH_AIN6 0x420 /* AIN6 - AINCOM */
129 #define AD7193_CH_AIN7 0x440 /* AIN7 - AINCOM */
130 #define AD7193_CH_AIN8 0x480 /* AIN7 - AINCOM */
131 #define AD7193_CH_AINCOM 0x600 /* AINCOM - AINCOM */
132
133 #define AD7194_CH_POS(x) (((x) - 1) << 4)
134 #define AD7194_CH_NEG(x) ((x) - 1)
135
136 /* 10th bit corresponds to CON18(Pseudo) */
137 #define AD7194_CH(p) (BIT(10) | AD7194_CH_POS(p))
138
139 #define AD7194_DIFF_CH(p, n) (AD7194_CH_POS(p) | AD7194_CH_NEG(n))
140 #define AD7194_CH_TEMP 0x100
141 #define AD7194_CH_BASE_NR 2
142 #define AD7194_CH_AIN_START 1
143 #define AD7194_CH_AIN_NR 16
144 #define AD7194_CH_MAX_NR 272
145
146 /* ID Register Bit Designations (AD7192_REG_ID) */
147 #define CHIPID_AD7190 0x4
148 #define CHIPID_AD7192 0x0
149 #define CHIPID_AD7193 0x2
150 #define CHIPID_AD7194 0x3
151 #define CHIPID_AD7195 0x6
152 #define AD7192_ID_MASK GENMASK(3, 0)
153
154 /* GPOCON Register Bit Designations (AD7192_REG_GPOCON) */
155 #define AD7192_GPOCON_BPDSW BIT(6) /* Bridge power-down switch enable */
156 #define AD7192_GPOCON_GP32EN BIT(5) /* Digital Output P3 and P2 enable */
157 #define AD7192_GPOCON_GP10EN BIT(4) /* Digital Output P1 and P0 enable */
158 #define AD7192_GPOCON_P3DAT BIT(3) /* P3 state */
159 #define AD7192_GPOCON_P2DAT BIT(2) /* P2 state */
160 #define AD7192_GPOCON_P1DAT BIT(1) /* P1 state */
161 #define AD7192_GPOCON_P0DAT BIT(0) /* P0 state */
162
163 #define AD7192_EXT_FREQ_MHZ_MIN 2457600
164 #define AD7192_EXT_FREQ_MHZ_MAX 5120000
165 #define AD7192_INT_FREQ_MHZ 4915200
166
167 #define AD7192_NO_SYNC_FILTER 1
168 #define AD7192_SYNC3_FILTER 3
169 #define AD7192_SYNC4_FILTER 4
170
171 /* NOTE:
172 * The AD7190/2/5 features a dual use data out ready DOUT/RDY output.
173 * In order to avoid contentions on the SPI bus, it's therefore necessary
174 * to use spi bus locking.
175 *
176 * The DOUT/RDY output must also be wired to an interrupt capable GPIO.
177 */
178
179 enum {
180 AD7192_SYSCALIB_ZERO_SCALE,
181 AD7192_SYSCALIB_FULL_SCALE,
182 };
183
184 enum {
185 ID_AD7190,
186 ID_AD7192,
187 ID_AD7193,
188 ID_AD7194,
189 ID_AD7195,
190 };
191
192 struct ad7192_chip_info {
193 unsigned int chip_id;
194 const char *name;
195 const struct iio_chan_spec *channels;
196 u8 num_channels;
197 const struct ad_sigma_delta_info *sigma_delta_info;
198 const struct iio_info *info;
199 int (*parse_channels)(struct iio_dev *indio_dev);
200 };
201
202 struct ad7192_state {
203 const struct ad7192_chip_info *chip_info;
204 struct clk *mclk;
205 struct clk_hw int_clk_hw;
206 u16 int_vref_mv;
207 u32 aincom_mv;
208 u32 fclk;
209 u32 mode;
210 u32 conf;
211 u32 scale_avail[8][2];
212 u32 filter_freq_avail[4][2];
213 u32 oversampling_ratio_avail[4];
214 u8 gpocon;
215 u8 clock_sel;
216 struct mutex lock; /* protect sensor state */
217 u8 syscalib_mode[8];
218
219 struct ad_sigma_delta sd;
220 };
221
222 static const char * const ad7192_syscalib_modes[] = {
223 [AD7192_SYSCALIB_ZERO_SCALE] = "zero_scale",
224 [AD7192_SYSCALIB_FULL_SCALE] = "full_scale",
225 };
226
227 static int ad7192_set_syscalib_mode(struct iio_dev *indio_dev,
228 const struct iio_chan_spec *chan,
229 unsigned int mode)
230 {
231 struct ad7192_state *st = iio_priv(indio_dev);
232
233 st->syscalib_mode[chan->channel] = mode;
234
235 return 0;
236 }
237
238 static int ad7192_get_syscalib_mode(struct iio_dev *indio_dev,
239 const struct iio_chan_spec *chan)
240 {
241 struct ad7192_state *st = iio_priv(indio_dev);
242
243 return st->syscalib_mode[chan->channel];
244 }
245
246 static ssize_t ad7192_write_syscalib(struct iio_dev *indio_dev,
247 uintptr_t private,
248 const struct iio_chan_spec *chan,
249 const char *buf, size_t len)
250 {
251 struct ad7192_state *st = iio_priv(indio_dev);
252 bool sys_calib;
253 int ret, temp;
254
255 ret = kstrtobool(buf, &sys_calib);
256 if (ret)
257 return ret;
258
259 temp = st->syscalib_mode[chan->channel];
260 if (sys_calib) {
261 if (temp == AD7192_SYSCALIB_ZERO_SCALE)
262 ret = ad_sd_calibrate(&st->sd, AD7192_MODE_CAL_SYS_ZERO,
263 chan->address);
264 else
265 ret = ad_sd_calibrate(&st->sd, AD7192_MODE_CAL_SYS_FULL,
266 chan->address);
267 }
268
269 return ret ? ret : len;
270 }
271
272 static const struct iio_enum ad7192_syscalib_mode_enum = {
273 .items = ad7192_syscalib_modes,
274 .num_items = ARRAY_SIZE(ad7192_syscalib_modes),
275 .set = ad7192_set_syscalib_mode,
276 .get = ad7192_get_syscalib_mode
277 };
278
279 static const struct iio_chan_spec_ext_info ad7192_calibsys_ext_info[] = {
280 {
281 .name = "sys_calibration",
282 .write = ad7192_write_syscalib,
283 .shared = IIO_SEPARATE,
284 },
285 IIO_ENUM("sys_calibration_mode", IIO_SEPARATE,
286 &ad7192_syscalib_mode_enum),
287 IIO_ENUM_AVAILABLE("sys_calibration_mode", IIO_SHARED_BY_TYPE,
288 &ad7192_syscalib_mode_enum),
289 { }
290 };
291
292 static struct ad7192_state *ad_sigma_delta_to_ad7192(struct ad_sigma_delta *sd)
293 {
294 return container_of(sd, struct ad7192_state, sd);
295 }
296
297 static int ad7192_set_channel(struct ad_sigma_delta *sd, unsigned int channel)
298 {
299 struct ad7192_state *st = ad_sigma_delta_to_ad7192(sd);
300
301 st->conf &= ~AD7192_CONF_CHAN_MASK;
302 st->conf |= FIELD_PREP(AD7192_CONF_CHAN_MASK, channel);
303
304 return ad_sd_write_reg(&st->sd, AD7192_REG_CONF, 3, st->conf);
305 }
306
307 static int ad7192_set_mode(struct ad_sigma_delta *sd,
308 enum ad_sigma_delta_mode mode)
309 {
310 struct ad7192_state *st = ad_sigma_delta_to_ad7192(sd);
311
312 st->mode &= ~AD7192_MODE_SEL_MASK;
313 st->mode |= FIELD_PREP(AD7192_MODE_SEL_MASK, mode);
314
315 return ad_sd_write_reg(&st->sd, AD7192_REG_MODE, 3, st->mode);
316 }
317
318 static int ad7192_append_status(struct ad_sigma_delta *sd, bool append)
319 {
320 struct ad7192_state *st = ad_sigma_delta_to_ad7192(sd);
321 unsigned int mode = st->mode;
322 int ret;
323
324 mode &= ~AD7192_MODE_STA_MASK;
325 mode |= FIELD_PREP(AD7192_MODE_STA_MASK, append);
326
327 ret = ad_sd_write_reg(&st->sd, AD7192_REG_MODE, 3, mode);
328 if (ret < 0)
329 return ret;
330
331 st->mode = mode;
332
333 return 0;
334 }
335
336 static int ad7192_disable_all(struct ad_sigma_delta *sd)
337 {
338 struct ad7192_state *st = ad_sigma_delta_to_ad7192(sd);
339 u32 conf = st->conf;
340 int ret;
341
342 conf &= ~AD7192_CONF_CHAN_MASK;
343
344 ret = ad_sd_write_reg(&st->sd, AD7192_REG_CONF, 3, conf);
345 if (ret < 0)
346 return ret;
347
348 st->conf = conf;
349
350 return 0;
351 }
352
353 static const struct ad_sigma_delta_info ad7192_sigma_delta_info = {
354 .set_channel = ad7192_set_channel,
355 .append_status = ad7192_append_status,
356 .disable_all = ad7192_disable_all,
357 .set_mode = ad7192_set_mode,
358 .has_registers = true,
359 .addr_shift = 3,
360 .read_mask = BIT(6),
361 .status_ch_mask = GENMASK(3, 0),
362 .num_slots = 4,
363 .irq_flags = IRQF_TRIGGER_FALLING,
364 };
365
366 static const struct ad_sigma_delta_info ad7194_sigma_delta_info = {
367 .set_channel = ad7192_set_channel,
368 .append_status = ad7192_append_status,
369 .disable_all = ad7192_disable_all,
370 .set_mode = ad7192_set_mode,
371 .has_registers = true,
372 .addr_shift = 3,
373 .read_mask = BIT(6),
374 .status_ch_mask = GENMASK(3, 0),
375 .irq_flags = IRQF_TRIGGER_FALLING,
376 };
377
378 static const struct ad_sd_calib_data ad7192_calib_arr[8] = {
379 {AD7192_MODE_CAL_INT_ZERO, AD7192_CH_AIN1},
380 {AD7192_MODE_CAL_INT_FULL, AD7192_CH_AIN1},
381 {AD7192_MODE_CAL_INT_ZERO, AD7192_CH_AIN2},
382 {AD7192_MODE_CAL_INT_FULL, AD7192_CH_AIN2},
383 {AD7192_MODE_CAL_INT_ZERO, AD7192_CH_AIN3},
384 {AD7192_MODE_CAL_INT_FULL, AD7192_CH_AIN3},
385 {AD7192_MODE_CAL_INT_ZERO, AD7192_CH_AIN4},
386 {AD7192_MODE_CAL_INT_FULL, AD7192_CH_AIN4}
387 };
388
389 static int ad7192_calibrate_all(struct ad7192_state *st)
390 {
391 return ad_sd_calibrate_all(&st->sd, ad7192_calib_arr,
392 ARRAY_SIZE(ad7192_calib_arr));
393 }
394
395 static inline bool ad7192_valid_external_frequency(u32 freq)
396 {
397 return (freq >= AD7192_EXT_FREQ_MHZ_MIN &&
398 freq <= AD7192_EXT_FREQ_MHZ_MAX);
399 }
400
401 /*
402 * Position 0 of ad7192_clock_names, xtal, corresponds to clock source
403 * configuration AD7192_CLK_EXT_MCLK1_2 and position 1, mclk, corresponds to
404 * AD7192_CLK_EXT_MCLK2
405 */
406 static const char *const ad7192_clock_names[] = {
407 "xtal",
408 "mclk"
409 };
410
411 static struct ad7192_state *clk_hw_to_ad7192(struct clk_hw *hw)
412 {
413 return container_of(hw, struct ad7192_state, int_clk_hw);
414 }
415
416 static unsigned long ad7192_clk_recalc_rate(struct clk_hw *hw,
417 unsigned long parent_rate)
418 {
419 return AD7192_INT_FREQ_MHZ;
420 }
421
422 static int ad7192_clk_output_is_enabled(struct clk_hw *hw)
423 {
424 struct ad7192_state *st = clk_hw_to_ad7192(hw);
425
426 return st->clock_sel == AD7192_CLK_INT_CO;
427 }
428
429 static int ad7192_clk_prepare(struct clk_hw *hw)
430 {
431 struct ad7192_state *st = clk_hw_to_ad7192(hw);
432 int ret;
433
434 st->mode &= ~AD7192_MODE_CLKSRC_MASK;
435 st->mode |= AD7192_CLK_INT_CO;
436
437 ret = ad_sd_write_reg(&st->sd, AD7192_REG_MODE, 3, st->mode);
438 if (ret)
439 return ret;
440
441 st->clock_sel = AD7192_CLK_INT_CO;
442
443 return 0;
444 }
445
446 static void ad7192_clk_unprepare(struct clk_hw *hw)
447 {
448 struct ad7192_state *st = clk_hw_to_ad7192(hw);
449 int ret;
450
451 st->mode &= ~AD7192_MODE_CLKSRC_MASK;
452 st->mode |= AD7192_CLK_INT;
453
454 ret = ad_sd_write_reg(&st->sd, AD7192_REG_MODE, 3, st->mode);
455 if (ret)
456 return;
457
458 st->clock_sel = AD7192_CLK_INT;
459 }
460
461 static const struct clk_ops ad7192_int_clk_ops = {
462 .recalc_rate = ad7192_clk_recalc_rate,
463 .is_enabled = ad7192_clk_output_is_enabled,
464 .prepare = ad7192_clk_prepare,
465 .unprepare = ad7192_clk_unprepare,
466 };
467
468 static int ad7192_register_clk_provider(struct ad7192_state *st)
469 {
470 struct device *dev = &st->sd.spi->dev;
471 struct clk_init_data init = {};
472 int ret;
473
474 if (!IS_ENABLED(CONFIG_COMMON_CLK))
475 return 0;
476
477 if (!device_property_present(dev, "#clock-cells"))
478 return 0;
479
480 init.name = devm_kasprintf(dev, GFP_KERNEL, "%s-clk",
481 fwnode_get_name(dev_fwnode(dev)));
482 if (!init.name)
483 return -ENOMEM;
484
485 init.ops = &ad7192_int_clk_ops;
486
487 st->int_clk_hw.init = &init;
488 ret = devm_clk_hw_register(dev, &st->int_clk_hw);
489 if (ret)
490 return ret;
491
492 return devm_of_clk_add_hw_provider(dev, of_clk_hw_simple_get,
493 &st->int_clk_hw);
494 }
495
496 static int ad7192_clock_setup(struct ad7192_state *st)
497 {
498 struct device *dev = &st->sd.spi->dev;
499 int ret;
500
501 /*
502 * The following two if branches are kept for backward compatibility but
503 * the use of the two devicetree properties is highly discouraged. Clock
504 * configuration should be done according to the bindings.
505 */
506
507 if (device_property_read_bool(dev, "adi,int-clock-output-enable")) {
508 st->clock_sel = AD7192_CLK_INT_CO;
509 st->fclk = AD7192_INT_FREQ_MHZ;
510 dev_warn(dev, "Property adi,int-clock-output-enable is deprecated! Check bindings!\n");
511 return 0;
512 }
513
514 if (device_property_read_bool(dev, "adi,clock-xtal")) {
515 st->clock_sel = AD7192_CLK_EXT_MCLK1_2;
516 st->mclk = devm_clk_get_enabled(dev, "mclk");
517 if (IS_ERR(st->mclk))
518 return dev_err_probe(dev, PTR_ERR(st->mclk),
519 "Failed to get mclk\n");
520
521 st->fclk = clk_get_rate(st->mclk);
522 if (!ad7192_valid_external_frequency(st->fclk))
523 return dev_err_probe(dev, -EINVAL,
524 "External clock frequency out of bounds\n");
525
526 dev_warn(dev, "Property adi,clock-xtal is deprecated! Check bindings!\n");
527 return 0;
528 }
529
530 ret = device_property_match_property_string(dev, "clock-names",
531 ad7192_clock_names,
532 ARRAY_SIZE(ad7192_clock_names));
533 if (ret < 0) {
534 st->clock_sel = AD7192_CLK_INT;
535 st->fclk = AD7192_INT_FREQ_MHZ;
536
537 ret = ad7192_register_clk_provider(st);
538 if (ret)
539 return dev_err_probe(dev, ret,
540 "Failed to register clock provider\n");
541 return 0;
542 }
543
544 st->clock_sel = AD7192_CLK_EXT_MCLK1_2 + ret;
545
546 st->mclk = devm_clk_get_enabled(dev, ad7192_clock_names[ret]);
547 if (IS_ERR(st->mclk))
548 return dev_err_probe(dev, PTR_ERR(st->mclk),
549 "Failed to get clock source\n");
550
551 st->fclk = clk_get_rate(st->mclk);
552 if (!ad7192_valid_external_frequency(st->fclk))
553 return dev_err_probe(dev, -EINVAL,
554 "External clock frequency out of bounds\n");
555
556 return 0;
557 }
558
559 static int ad7192_setup(struct iio_dev *indio_dev, struct device *dev)
560 {
561 struct ad7192_state *st = iio_priv(indio_dev);
562 bool rej60_en, refin2_en;
563 bool buf_en, bipolar, burnout_curr_en;
564 unsigned long long scale_uv;
565 int i, ret, id;
566
567 /* reset the serial interface */
568 ret = ad_sd_reset(&st->sd, 48);
569 if (ret < 0)
570 return ret;
571 usleep_range(500, 1000); /* Wait for at least 500us */
572
573 /* write/read test for device presence */
574 ret = ad_sd_read_reg(&st->sd, AD7192_REG_ID, 1, &id);
575 if (ret)
576 return ret;
577
578 id = FIELD_GET(AD7192_ID_MASK, id);
579
580 if (id != st->chip_info->chip_id)
581 dev_warn(dev, "device ID query failed (0x%X != 0x%X)\n",
582 id, st->chip_info->chip_id);
583
584 st->mode = FIELD_PREP(AD7192_MODE_SEL_MASK, AD7192_MODE_IDLE) |
585 FIELD_PREP(AD7192_MODE_CLKSRC_MASK, st->clock_sel) |
586 FIELD_PREP(AD7192_MODE_RATE_MASK, 480);
587
588 st->conf = FIELD_PREP(AD7192_CONF_GAIN_MASK, 0);
589
590 rej60_en = device_property_read_bool(dev, "adi,rejection-60-Hz-enable");
591 if (rej60_en)
592 st->mode |= AD7192_MODE_REJ60;
593
594 refin2_en = device_property_read_bool(dev, "adi,refin2-pins-enable");
595 if (refin2_en && st->chip_info->chip_id != CHIPID_AD7195)
596 st->conf |= AD7192_CONF_REFSEL;
597
598 st->conf &= ~AD7192_CONF_CHOP;
599
600 buf_en = device_property_read_bool(dev, "adi,buffer-enable");
601 if (buf_en)
602 st->conf |= AD7192_CONF_BUF;
603
604 bipolar = device_property_read_bool(dev, "bipolar");
605 if (!bipolar)
606 st->conf |= AD7192_CONF_UNIPOLAR;
607
608 burnout_curr_en = device_property_read_bool(dev,
609 "adi,burnout-currents-enable");
610 if (burnout_curr_en && buf_en) {
611 st->conf |= AD7192_CONF_BURN;
612 } else if (burnout_curr_en) {
613 dev_warn(dev,
614 "Can't enable burnout currents: see CHOP or buffer\n");
615 }
616
617 ret = ad_sd_write_reg(&st->sd, AD7192_REG_MODE, 3, st->mode);
618 if (ret)
619 return ret;
620
621 ret = ad_sd_write_reg(&st->sd, AD7192_REG_CONF, 3, st->conf);
622 if (ret)
623 return ret;
624
625 ret = ad7192_calibrate_all(st);
626 if (ret)
627 return ret;
628
629 /* Populate available ADC input ranges */
630 for (i = 0; i < ARRAY_SIZE(st->scale_avail); i++) {
631 scale_uv = ((u64)st->int_vref_mv * 100000000)
632 >> (indio_dev->channels[0].scan_type.realbits -
633 !FIELD_GET(AD7192_CONF_UNIPOLAR, st->conf));
634 scale_uv >>= i;
635
636 st->scale_avail[i][1] = do_div(scale_uv, 100000000) * 10;
637 st->scale_avail[i][0] = scale_uv;
638 }
639
640 st->oversampling_ratio_avail[0] = 1;
641 st->oversampling_ratio_avail[1] = 2;
642 st->oversampling_ratio_avail[2] = 8;
643 st->oversampling_ratio_avail[3] = 16;
644
645 st->filter_freq_avail[0][0] = 600;
646 st->filter_freq_avail[1][0] = 800;
647 st->filter_freq_avail[2][0] = 2300;
648 st->filter_freq_avail[3][0] = 2720;
649
650 st->filter_freq_avail[0][1] = 1000;
651 st->filter_freq_avail[1][1] = 1000;
652 st->filter_freq_avail[2][1] = 1000;
653 st->filter_freq_avail[3][1] = 1000;
654
655 return 0;
656 }
657
658 static ssize_t ad7192_show_ac_excitation(struct device *dev,
659 struct device_attribute *attr,
660 char *buf)
661 {
662 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
663 struct ad7192_state *st = iio_priv(indio_dev);
664
665 return sysfs_emit(buf, "%ld\n", FIELD_GET(AD7192_CONF_ACX, st->conf));
666 }
667
668 static ssize_t ad7192_show_bridge_switch(struct device *dev,
669 struct device_attribute *attr,
670 char *buf)
671 {
672 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
673 struct ad7192_state *st = iio_priv(indio_dev);
674
675 return sysfs_emit(buf, "%ld\n",
676 FIELD_GET(AD7192_GPOCON_BPDSW, st->gpocon));
677 }
678
679 static ssize_t ad7192_set(struct device *dev,
680 struct device_attribute *attr,
681 const char *buf,
682 size_t len)
683 {
684 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
685 struct ad7192_state *st = iio_priv(indio_dev);
686 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
687 int ret;
688 bool val;
689
690 ret = kstrtobool(buf, &val);
691 if (ret < 0)
692 return ret;
693
694 ret = iio_device_claim_direct_mode(indio_dev);
695 if (ret)
696 return ret;
697
698 switch ((u32)this_attr->address) {
699 case AD7192_REG_GPOCON:
700 if (val)
701 st->gpocon |= AD7192_GPOCON_BPDSW;
702 else
703 st->gpocon &= ~AD7192_GPOCON_BPDSW;
704
705 ad_sd_write_reg(&st->sd, AD7192_REG_GPOCON, 1, st->gpocon);
706 break;
707 case AD7192_REG_CONF:
708 if (val)
709 st->conf |= AD7192_CONF_ACX;
710 else
711 st->conf &= ~AD7192_CONF_ACX;
712
713 ad_sd_write_reg(&st->sd, AD7192_REG_CONF, 3, st->conf);
714 break;
715 default:
716 ret = -EINVAL;
717 }
718
719 iio_device_release_direct_mode(indio_dev);
720
721 return ret ? ret : len;
722 }
723
724 static int ad7192_compute_f_order(struct ad7192_state *st, bool sinc3_en, bool chop_en)
725 {
726 u8 avg_factor_selected, oversampling_ratio;
727
728 avg_factor_selected = FIELD_GET(AD7192_MODE_AVG_MASK, st->mode);
729
730 if (!avg_factor_selected && !chop_en)
731 return 1;
732
733 oversampling_ratio = st->oversampling_ratio_avail[avg_factor_selected];
734
735 if (sinc3_en)
736 return AD7192_SYNC3_FILTER + oversampling_ratio - 1;
737
738 return AD7192_SYNC4_FILTER + oversampling_ratio - 1;
739 }
740
741 static int ad7192_get_f_order(struct ad7192_state *st)
742 {
743 bool sinc3_en, chop_en;
744
745 sinc3_en = FIELD_GET(AD7192_MODE_SINC3, st->mode);
746 chop_en = FIELD_GET(AD7192_CONF_CHOP, st->conf);
747
748 return ad7192_compute_f_order(st, sinc3_en, chop_en);
749 }
750
751 static int ad7192_compute_f_adc(struct ad7192_state *st, bool sinc3_en,
752 bool chop_en)
753 {
754 unsigned int f_order = ad7192_compute_f_order(st, sinc3_en, chop_en);
755
756 return DIV_ROUND_CLOSEST(st->fclk,
757 f_order * FIELD_GET(AD7192_MODE_RATE_MASK, st->mode));
758 }
759
760 static int ad7192_get_f_adc(struct ad7192_state *st)
761 {
762 unsigned int f_order = ad7192_get_f_order(st);
763
764 return DIV_ROUND_CLOSEST(st->fclk,
765 f_order * FIELD_GET(AD7192_MODE_RATE_MASK, st->mode));
766 }
767
768 static void ad7192_update_filter_freq_avail(struct ad7192_state *st)
769 {
770 unsigned int fadc;
771
772 /* Formulas for filter at page 25 of the datasheet */
773 fadc = ad7192_compute_f_adc(st, false, true);
774 st->filter_freq_avail[0][0] = DIV_ROUND_CLOSEST(fadc * 240, 1024);
775
776 fadc = ad7192_compute_f_adc(st, true, true);
777 st->filter_freq_avail[1][0] = DIV_ROUND_CLOSEST(fadc * 240, 1024);
778
779 fadc = ad7192_compute_f_adc(st, false, false);
780 st->filter_freq_avail[2][0] = DIV_ROUND_CLOSEST(fadc * 230, 1024);
781
782 fadc = ad7192_compute_f_adc(st, true, false);
783 st->filter_freq_avail[3][0] = DIV_ROUND_CLOSEST(fadc * 272, 1024);
784 }
785
786 static IIO_DEVICE_ATTR(bridge_switch_en, 0644,
787 ad7192_show_bridge_switch, ad7192_set,
788 AD7192_REG_GPOCON);
789
790 static IIO_DEVICE_ATTR(ac_excitation_en, 0644,
791 ad7192_show_ac_excitation, ad7192_set,
792 AD7192_REG_CONF);
793
794 static struct attribute *ad7192_attributes[] = {
795 &iio_dev_attr_bridge_switch_en.dev_attr.attr,
796 NULL
797 };
798
799 static const struct attribute_group ad7192_attribute_group = {
800 .attrs = ad7192_attributes,
801 };
802
803 static struct attribute *ad7195_attributes[] = {
804 &iio_dev_attr_bridge_switch_en.dev_attr.attr,
805 &iio_dev_attr_ac_excitation_en.dev_attr.attr,
806 NULL
807 };
808
809 static const struct attribute_group ad7195_attribute_group = {
810 .attrs = ad7195_attributes,
811 };
812
813 static unsigned int ad7192_get_temp_scale(bool unipolar)
814 {
815 return unipolar ? 2815 * 2 : 2815;
816 }
817
818 static int ad7192_set_3db_filter_freq(struct ad7192_state *st,
819 int val, int val2)
820 {
821 int i, ret, freq;
822 unsigned int diff_new, diff_old;
823 int idx = 0;
824
825 diff_old = U32_MAX;
826 freq = val * 1000 + val2;
827
828 for (i = 0; i < ARRAY_SIZE(st->filter_freq_avail); i++) {
829 diff_new = abs(freq - st->filter_freq_avail[i][0]);
830 if (diff_new < diff_old) {
831 diff_old = diff_new;
832 idx = i;
833 }
834 }
835
836 switch (idx) {
837 case 0:
838 st->mode &= ~AD7192_MODE_SINC3;
839
840 st->conf |= AD7192_CONF_CHOP;
841 break;
842 case 1:
843 st->mode |= AD7192_MODE_SINC3;
844
845 st->conf |= AD7192_CONF_CHOP;
846 break;
847 case 2:
848 st->mode &= ~AD7192_MODE_SINC3;
849
850 st->conf &= ~AD7192_CONF_CHOP;
851 break;
852 case 3:
853 st->mode |= AD7192_MODE_SINC3;
854
855 st->conf &= ~AD7192_CONF_CHOP;
856 break;
857 }
858
859 ret = ad_sd_write_reg(&st->sd, AD7192_REG_MODE, 3, st->mode);
860 if (ret < 0)
861 return ret;
862
863 return ad_sd_write_reg(&st->sd, AD7192_REG_CONF, 3, st->conf);
864 }
865
866 static int ad7192_get_3db_filter_freq(struct ad7192_state *st)
867 {
868 unsigned int fadc;
869
870 fadc = ad7192_get_f_adc(st);
871
872 if (FIELD_GET(AD7192_CONF_CHOP, st->conf))
873 return DIV_ROUND_CLOSEST(fadc * 240, 1024);
874 if (FIELD_GET(AD7192_MODE_SINC3, st->mode))
875 return DIV_ROUND_CLOSEST(fadc * 272, 1024);
876 else
877 return DIV_ROUND_CLOSEST(fadc * 230, 1024);
878 }
879
880 static int ad7192_read_raw(struct iio_dev *indio_dev,
881 struct iio_chan_spec const *chan,
882 int *val,
883 int *val2,
884 long m)
885 {
886 struct ad7192_state *st = iio_priv(indio_dev);
887 bool unipolar = FIELD_GET(AD7192_CONF_UNIPOLAR, st->conf);
888 u8 gain = FIELD_GET(AD7192_CONF_GAIN_MASK, st->conf);
889
890 switch (m) {
891 case IIO_CHAN_INFO_RAW:
892 return ad_sigma_delta_single_conversion(indio_dev, chan, val);
893 case IIO_CHAN_INFO_SCALE:
894 switch (chan->type) {
895 case IIO_VOLTAGE:
896 mutex_lock(&st->lock);
897 *val = st->scale_avail[gain][0];
898 *val2 = st->scale_avail[gain][1];
899 mutex_unlock(&st->lock);
900 return IIO_VAL_INT_PLUS_NANO;
901 case IIO_TEMP:
902 *val = 0;
903 *val2 = 1000000000 / ad7192_get_temp_scale(unipolar);
904 return IIO_VAL_INT_PLUS_NANO;
905 default:
906 return -EINVAL;
907 }
908 case IIO_CHAN_INFO_OFFSET:
909 if (!unipolar)
910 *val = -(1 << (chan->scan_type.realbits - 1));
911 else
912 *val = 0;
913
914 switch (chan->type) {
915 case IIO_VOLTAGE:
916 /*
917 * Only applies to pseudo-differential inputs.
918 * AINCOM voltage has to be converted to "raw" units.
919 */
920 if (st->aincom_mv && !chan->differential)
921 *val += DIV_ROUND_CLOSEST_ULL((u64)st->aincom_mv * NANO,
922 st->scale_avail[gain][1]);
923 return IIO_VAL_INT;
924 /* Kelvin to Celsius */
925 case IIO_TEMP:
926 *val -= 273 * ad7192_get_temp_scale(unipolar);
927 return IIO_VAL_INT;
928 default:
929 return -EINVAL;
930 }
931 case IIO_CHAN_INFO_SAMP_FREQ:
932 *val = DIV_ROUND_CLOSEST(ad7192_get_f_adc(st), 1024);
933 return IIO_VAL_INT;
934 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
935 *val = ad7192_get_3db_filter_freq(st);
936 *val2 = 1000;
937 return IIO_VAL_FRACTIONAL;
938 case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
939 *val = st->oversampling_ratio_avail[FIELD_GET(AD7192_MODE_AVG_MASK, st->mode)];
940 return IIO_VAL_INT;
941 }
942
943 return -EINVAL;
944 }
945
946 static int ad7192_write_raw(struct iio_dev *indio_dev,
947 struct iio_chan_spec const *chan,
948 int val,
949 int val2,
950 long mask)
951 {
952 struct ad7192_state *st = iio_priv(indio_dev);
953 int ret, i, div;
954 unsigned int tmp;
955
956 ret = iio_device_claim_direct_mode(indio_dev);
957 if (ret)
958 return ret;
959
960 mutex_lock(&st->lock);
961
962 switch (mask) {
963 case IIO_CHAN_INFO_SCALE:
964 ret = -EINVAL;
965 for (i = 0; i < ARRAY_SIZE(st->scale_avail); i++)
966 if (val2 == st->scale_avail[i][1]) {
967 ret = 0;
968 tmp = st->conf;
969 st->conf &= ~AD7192_CONF_GAIN_MASK;
970 st->conf |= FIELD_PREP(AD7192_CONF_GAIN_MASK, i);
971 if (tmp == st->conf)
972 break;
973 ad_sd_write_reg(&st->sd, AD7192_REG_CONF,
974 3, st->conf);
975 ad7192_calibrate_all(st);
976 break;
977 }
978 break;
979 case IIO_CHAN_INFO_SAMP_FREQ:
980 if (!val) {
981 ret = -EINVAL;
982 break;
983 }
984
985 div = st->fclk / (val * ad7192_get_f_order(st) * 1024);
986 if (div < 1 || div > 1023) {
987 ret = -EINVAL;
988 break;
989 }
990
991 st->mode &= ~AD7192_MODE_RATE_MASK;
992 st->mode |= FIELD_PREP(AD7192_MODE_RATE_MASK, div);
993 ad_sd_write_reg(&st->sd, AD7192_REG_MODE, 3, st->mode);
994 ad7192_update_filter_freq_avail(st);
995 break;
996 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
997 ret = ad7192_set_3db_filter_freq(st, val, val2 / 1000);
998 break;
999 case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
1000 ret = -EINVAL;
1001 for (i = 0; i < ARRAY_SIZE(st->oversampling_ratio_avail); i++)
1002 if (val == st->oversampling_ratio_avail[i]) {
1003 ret = 0;
1004 tmp = st->mode;
1005 st->mode &= ~AD7192_MODE_AVG_MASK;
1006 st->mode |= FIELD_PREP(AD7192_MODE_AVG_MASK, i);
1007 if (tmp == st->mode)
1008 break;
1009 ad_sd_write_reg(&st->sd, AD7192_REG_MODE,
1010 3, st->mode);
1011 break;
1012 }
1013 ad7192_update_filter_freq_avail(st);
1014 break;
1015 default:
1016 ret = -EINVAL;
1017 }
1018
1019 mutex_unlock(&st->lock);
1020
1021 iio_device_release_direct_mode(indio_dev);
1022
1023 return ret;
1024 }
1025
1026 static int ad7192_write_raw_get_fmt(struct iio_dev *indio_dev,
1027 struct iio_chan_spec const *chan,
1028 long mask)
1029 {
1030 switch (mask) {
1031 case IIO_CHAN_INFO_SCALE:
1032 return IIO_VAL_INT_PLUS_NANO;
1033 case IIO_CHAN_INFO_SAMP_FREQ:
1034 return IIO_VAL_INT;
1035 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
1036 return IIO_VAL_INT_PLUS_MICRO;
1037 case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
1038 return IIO_VAL_INT;
1039 default:
1040 return -EINVAL;
1041 }
1042 }
1043
1044 static int ad7192_read_avail(struct iio_dev *indio_dev,
1045 struct iio_chan_spec const *chan,
1046 const int **vals, int *type, int *length,
1047 long mask)
1048 {
1049 struct ad7192_state *st = iio_priv(indio_dev);
1050
1051 switch (mask) {
1052 case IIO_CHAN_INFO_SCALE:
1053 *vals = (int *)st->scale_avail;
1054 *type = IIO_VAL_INT_PLUS_NANO;
1055 /* Values are stored in a 2D matrix */
1056 *length = ARRAY_SIZE(st->scale_avail) * 2;
1057
1058 return IIO_AVAIL_LIST;
1059 case IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY:
1060 *vals = (int *)st->filter_freq_avail;
1061 *type = IIO_VAL_FRACTIONAL;
1062 *length = ARRAY_SIZE(st->filter_freq_avail) * 2;
1063
1064 return IIO_AVAIL_LIST;
1065 case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
1066 *vals = (int *)st->oversampling_ratio_avail;
1067 *type = IIO_VAL_INT;
1068 *length = ARRAY_SIZE(st->oversampling_ratio_avail);
1069
1070 return IIO_AVAIL_LIST;
1071 }
1072
1073 return -EINVAL;
1074 }
1075
1076 static int ad7192_update_scan_mode(struct iio_dev *indio_dev, const unsigned long *scan_mask)
1077 {
1078 struct ad7192_state *st = iio_priv(indio_dev);
1079 u32 conf = st->conf;
1080 int ret;
1081 int i;
1082
1083 conf &= ~AD7192_CONF_CHAN_MASK;
1084 for_each_set_bit(i, scan_mask, 8)
1085 conf |= FIELD_PREP(AD7192_CONF_CHAN_MASK, i);
1086
1087 ret = ad_sd_write_reg(&st->sd, AD7192_REG_CONF, 3, conf);
1088 if (ret < 0)
1089 return ret;
1090
1091 st->conf = conf;
1092
1093 return 0;
1094 }
1095
1096 static const struct iio_info ad7192_info = {
1097 .read_raw = ad7192_read_raw,
1098 .write_raw = ad7192_write_raw,
1099 .write_raw_get_fmt = ad7192_write_raw_get_fmt,
1100 .read_avail = ad7192_read_avail,
1101 .attrs = &ad7192_attribute_group,
1102 .validate_trigger = ad_sd_validate_trigger,
1103 .update_scan_mode = ad7192_update_scan_mode,
1104 };
1105
1106 static const struct iio_info ad7194_info = {
1107 .read_raw = ad7192_read_raw,
1108 .write_raw = ad7192_write_raw,
1109 .write_raw_get_fmt = ad7192_write_raw_get_fmt,
1110 .read_avail = ad7192_read_avail,
1111 .validate_trigger = ad_sd_validate_trigger,
1112 };
1113
1114 static const struct iio_info ad7195_info = {
1115 .read_raw = ad7192_read_raw,
1116 .write_raw = ad7192_write_raw,
1117 .write_raw_get_fmt = ad7192_write_raw_get_fmt,
1118 .read_avail = ad7192_read_avail,
1119 .attrs = &ad7195_attribute_group,
1120 .validate_trigger = ad_sd_validate_trigger,
1121 .update_scan_mode = ad7192_update_scan_mode,
1122 };
1123
1124 #define __AD719x_CHANNEL(_si, _channel1, _channel2, _address, _type, \
1125 _mask_all, _mask_type_av, _mask_all_av, _ext_info) \
1126 { \
1127 .type = (_type), \
1128 .differential = ((_channel2) == -1 ? 0 : 1), \
1129 .indexed = 1, \
1130 .channel = (_channel1), \
1131 .channel2 = (_channel2), \
1132 .address = (_address), \
1133 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
1134 BIT(IIO_CHAN_INFO_OFFSET), \
1135 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
1136 .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ) | \
1137 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY) | \
1138 (_mask_all), \
1139 .info_mask_shared_by_type_available = (_mask_type_av), \
1140 .info_mask_shared_by_all_available = \
1141 BIT(IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY) | \
1142 (_mask_all_av), \
1143 .ext_info = (_ext_info), \
1144 .scan_index = (_si), \
1145 .scan_type = { \
1146 .sign = 'u', \
1147 .realbits = 24, \
1148 .storagebits = 32, \
1149 .endianness = IIO_BE, \
1150 }, \
1151 }
1152
1153 #define AD719x_DIFF_CHANNEL(_si, _channel1, _channel2, _address) \
1154 __AD719x_CHANNEL(_si, _channel1, _channel2, _address, IIO_VOLTAGE, 0, \
1155 BIT(IIO_CHAN_INFO_SCALE), 0, ad7192_calibsys_ext_info)
1156
1157 #define AD719x_CHANNEL(_si, _channel1, _address) \
1158 __AD719x_CHANNEL(_si, _channel1, -1, _address, IIO_VOLTAGE, 0, \
1159 BIT(IIO_CHAN_INFO_SCALE), 0, ad7192_calibsys_ext_info)
1160
1161 #define AD719x_TEMP_CHANNEL(_si, _address) \
1162 __AD719x_CHANNEL(_si, 0, -1, _address, IIO_TEMP, 0, 0, 0, NULL)
1163
1164 #define AD7193_DIFF_CHANNEL(_si, _channel1, _channel2, _address) \
1165 __AD719x_CHANNEL(_si, _channel1, _channel2, _address, \
1166 IIO_VOLTAGE, \
1167 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), \
1168 BIT(IIO_CHAN_INFO_SCALE), \
1169 BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO), \
1170 ad7192_calibsys_ext_info)
1171
1172 #define AD7193_CHANNEL(_si, _channel1, _address) \
1173 AD7193_DIFF_CHANNEL(_si, _channel1, -1, _address)
1174
1175 static const struct iio_chan_spec ad7192_channels[] = {
1176 AD719x_DIFF_CHANNEL(0, 1, 2, AD7192_CH_AIN1P_AIN2M),
1177 AD719x_DIFF_CHANNEL(1, 3, 4, AD7192_CH_AIN3P_AIN4M),
1178 AD719x_TEMP_CHANNEL(2, AD7192_CH_TEMP),
1179 AD719x_DIFF_CHANNEL(3, 2, 2, AD7192_CH_AIN2P_AIN2M),
1180 AD719x_CHANNEL(4, 1, AD7192_CH_AIN1),
1181 AD719x_CHANNEL(5, 2, AD7192_CH_AIN2),
1182 AD719x_CHANNEL(6, 3, AD7192_CH_AIN3),
1183 AD719x_CHANNEL(7, 4, AD7192_CH_AIN4),
1184 IIO_CHAN_SOFT_TIMESTAMP(8),
1185 };
1186
1187 static const struct iio_chan_spec ad7193_channels[] = {
1188 AD7193_DIFF_CHANNEL(0, 1, 2, AD7193_CH_AIN1P_AIN2M),
1189 AD7193_DIFF_CHANNEL(1, 3, 4, AD7193_CH_AIN3P_AIN4M),
1190 AD7193_DIFF_CHANNEL(2, 5, 6, AD7193_CH_AIN5P_AIN6M),
1191 AD7193_DIFF_CHANNEL(3, 7, 8, AD7193_CH_AIN7P_AIN8M),
1192 AD719x_TEMP_CHANNEL(4, AD7193_CH_TEMP),
1193 AD7193_DIFF_CHANNEL(5, 2, 2, AD7193_CH_AIN2P_AIN2M),
1194 AD7193_CHANNEL(6, 1, AD7193_CH_AIN1),
1195 AD7193_CHANNEL(7, 2, AD7193_CH_AIN2),
1196 AD7193_CHANNEL(8, 3, AD7193_CH_AIN3),
1197 AD7193_CHANNEL(9, 4, AD7193_CH_AIN4),
1198 AD7193_CHANNEL(10, 5, AD7193_CH_AIN5),
1199 AD7193_CHANNEL(11, 6, AD7193_CH_AIN6),
1200 AD7193_CHANNEL(12, 7, AD7193_CH_AIN7),
1201 AD7193_CHANNEL(13, 8, AD7193_CH_AIN8),
1202 IIO_CHAN_SOFT_TIMESTAMP(14),
1203 };
1204
1205 static bool ad7194_validate_ain_channel(struct device *dev, u32 ain)
1206 {
1207 return in_range(ain, AD7194_CH_AIN_START, AD7194_CH_AIN_NR);
1208 }
1209
1210 static int ad7194_parse_channels(struct iio_dev *indio_dev)
1211 {
1212 struct device *dev = indio_dev->dev.parent;
1213 struct iio_chan_spec *ad7194_channels;
1214 const struct iio_chan_spec ad7194_chan = AD7193_CHANNEL(0, 0, 0);
1215 const struct iio_chan_spec ad7194_chan_diff = AD7193_DIFF_CHANNEL(0, 0, 0, 0);
1216 const struct iio_chan_spec ad7194_chan_temp = AD719x_TEMP_CHANNEL(0, 0);
1217 const struct iio_chan_spec ad7194_chan_timestamp = IIO_CHAN_SOFT_TIMESTAMP(0);
1218 unsigned int num_channels, index = 0;
1219 u32 ain[2];
1220 int ret;
1221
1222 num_channels = device_get_child_node_count(dev);
1223 if (num_channels > AD7194_CH_MAX_NR)
1224 return dev_err_probe(dev, -EINVAL, "Too many channels: %u\n",
1225 num_channels);
1226
1227 num_channels += AD7194_CH_BASE_NR;
1228
1229 ad7194_channels = devm_kcalloc(dev, num_channels,
1230 sizeof(*ad7194_channels), GFP_KERNEL);
1231 if (!ad7194_channels)
1232 return -ENOMEM;
1233
1234 indio_dev->channels = ad7194_channels;
1235 indio_dev->num_channels = num_channels;
1236
1237 device_for_each_child_node_scoped(dev, child) {
1238 ret = fwnode_property_read_u32_array(child, "diff-channels",
1239 ain, ARRAY_SIZE(ain));
1240 if (ret == 0) {
1241 if (!ad7194_validate_ain_channel(dev, ain[0]))
1242 return dev_err_probe(dev, -EINVAL,
1243 "Invalid AIN channel: %u\n",
1244 ain[0]);
1245
1246 if (!ad7194_validate_ain_channel(dev, ain[1]))
1247 return dev_err_probe(dev, -EINVAL,
1248 "Invalid AIN channel: %u\n",
1249 ain[1]);
1250
1251 *ad7194_channels = ad7194_chan_diff;
1252 ad7194_channels->scan_index = index++;
1253 ad7194_channels->channel = ain[0];
1254 ad7194_channels->channel2 = ain[1];
1255 ad7194_channels->address = AD7194_DIFF_CH(ain[0], ain[1]);
1256 } else {
1257 ret = fwnode_property_read_u32(child, "single-channel",
1258 &ain[0]);
1259 if (ret)
1260 return dev_err_probe(dev, ret,
1261 "Missing channel property\n");
1262
1263 if (!ad7194_validate_ain_channel(dev, ain[0]))
1264 return dev_err_probe(dev, -EINVAL,
1265 "Invalid AIN channel: %u\n",
1266 ain[0]);
1267
1268 *ad7194_channels = ad7194_chan;
1269 ad7194_channels->scan_index = index++;
1270 ad7194_channels->channel = ain[0];
1271 ad7194_channels->address = AD7194_CH(ain[0]);
1272 }
1273 ad7194_channels++;
1274 }
1275
1276 *ad7194_channels = ad7194_chan_temp;
1277 ad7194_channels->scan_index = index++;
1278 ad7194_channels->address = AD7194_CH_TEMP;
1279 ad7194_channels++;
1280
1281 *ad7194_channels = ad7194_chan_timestamp;
1282 ad7194_channels->scan_index = index;
1283
1284 return 0;
1285 }
1286
1287 static const struct ad7192_chip_info ad7192_chip_info_tbl[] = {
1288 [ID_AD7190] = {
1289 .chip_id = CHIPID_AD7190,
1290 .name = "ad7190",
1291 .channels = ad7192_channels,
1292 .num_channels = ARRAY_SIZE(ad7192_channels),
1293 .sigma_delta_info = &ad7192_sigma_delta_info,
1294 .info = &ad7192_info,
1295 },
1296 [ID_AD7192] = {
1297 .chip_id = CHIPID_AD7192,
1298 .name = "ad7192",
1299 .channels = ad7192_channels,
1300 .num_channels = ARRAY_SIZE(ad7192_channels),
1301 .sigma_delta_info = &ad7192_sigma_delta_info,
1302 .info = &ad7192_info,
1303 },
1304 [ID_AD7193] = {
1305 .chip_id = CHIPID_AD7193,
1306 .name = "ad7193",
1307 .channels = ad7193_channels,
1308 .num_channels = ARRAY_SIZE(ad7193_channels),
1309 .sigma_delta_info = &ad7192_sigma_delta_info,
1310 .info = &ad7192_info,
1311 },
1312 [ID_AD7194] = {
1313 .chip_id = CHIPID_AD7194,
1314 .name = "ad7194",
1315 .info = &ad7194_info,
1316 .sigma_delta_info = &ad7194_sigma_delta_info,
1317 .parse_channels = ad7194_parse_channels,
1318 },
1319 [ID_AD7195] = {
1320 .chip_id = CHIPID_AD7195,
1321 .name = "ad7195",
1322 .channels = ad7192_channels,
1323 .num_channels = ARRAY_SIZE(ad7192_channels),
1324 .sigma_delta_info = &ad7192_sigma_delta_info,
1325 .info = &ad7195_info,
1326 },
1327 };
1328
1329 static int ad7192_probe(struct spi_device *spi)
1330 {
1331 struct device *dev = &spi->dev;
1332 struct ad7192_state *st;
1333 struct iio_dev *indio_dev;
1334 int ret, avdd_mv;
1335
1336 if (!spi->irq)
1337 return dev_err_probe(dev, -ENODEV, "Failed to get IRQ\n");
1338
1339 indio_dev = devm_iio_device_alloc(dev, sizeof(*st));
1340 if (!indio_dev)
1341 return -ENOMEM;
1342
1343 st = iio_priv(indio_dev);
1344
1345 mutex_init(&st->lock);
1346
1347 /*
1348 * Regulator aincom is optional to maintain compatibility with older DT.
1349 * Newer firmware should provide a zero volt fixed supply if wired to
1350 * ground.
1351 */
1352 ret = devm_regulator_get_enable_read_voltage(dev, "aincom");
1353 if (ret < 0 && ret != -ENODEV)
1354 return dev_err_probe(dev, ret, "Failed to get AINCOM voltage\n");
1355
1356 st->aincom_mv = ret == -ENODEV ? 0 : ret / MILLI;
1357
1358 /* AVDD can optionally be used as reference voltage */
1359 ret = devm_regulator_get_enable_read_voltage(dev, "avdd");
1360 if (ret == -ENODEV || ret == -EINVAL) {
1361 int ret2;
1362
1363 /*
1364 * We get -EINVAL if avdd is a supply with unknown voltage. We
1365 * still need to enable it since it is also a power supply.
1366 */
1367 ret2 = devm_regulator_get_enable(dev, "avdd");
1368 if (ret2)
1369 return dev_err_probe(dev, ret2,
1370 "Failed to enable AVDD supply\n");
1371 } else if (ret < 0) {
1372 return dev_err_probe(dev, ret, "Failed to get AVDD voltage\n");
1373 }
1374
1375 avdd_mv = ret == -ENODEV || ret == -EINVAL ? 0 : ret / MILLI;
1376
1377 ret = devm_regulator_get_enable(dev, "dvdd");
1378 if (ret)
1379 return dev_err_probe(dev, ret, "Failed to enable specified DVdd supply\n");
1380
1381 /*
1382 * This is either REFIN1 or REFIN2 depending on adi,refin2-pins-enable.
1383 * If this supply is not present, fall back to AVDD as reference.
1384 */
1385 ret = devm_regulator_get_enable_read_voltage(dev, "vref");
1386 if (ret == -ENODEV) {
1387 if (avdd_mv == 0)
1388 return dev_err_probe(dev, -ENODEV,
1389 "No reference voltage available\n");
1390 } else if (ret < 0) {
1391 return ret;
1392 }
1393
1394 st->int_vref_mv = ret == -ENODEV ? avdd_mv : ret / MILLI;
1395
1396 st->chip_info = spi_get_device_match_data(spi);
1397 if (!st->chip_info)
1398 return -ENODEV;
1399
1400 indio_dev->name = st->chip_info->name;
1401 indio_dev->modes = INDIO_DIRECT_MODE;
1402 indio_dev->info = st->chip_info->info;
1403 if (st->chip_info->parse_channels) {
1404 ret = st->chip_info->parse_channels(indio_dev);
1405 if (ret)
1406 return ret;
1407 } else {
1408 indio_dev->channels = st->chip_info->channels;
1409 indio_dev->num_channels = st->chip_info->num_channels;
1410 }
1411
1412 ret = ad_sd_init(&st->sd, indio_dev, spi, st->chip_info->sigma_delta_info);
1413 if (ret)
1414 return ret;
1415
1416 ret = devm_ad_sd_setup_buffer_and_trigger(dev, indio_dev);
1417 if (ret)
1418 return ret;
1419
1420 ret = ad7192_clock_setup(st);
1421 if (ret)
1422 return ret;
1423
1424 ret = ad7192_setup(indio_dev, dev);
1425 if (ret)
1426 return ret;
1427
1428 return devm_iio_device_register(dev, indio_dev);
1429 }
1430
1431 static const struct of_device_id ad7192_of_match[] = {
1432 { .compatible = "adi,ad7190", .data = &ad7192_chip_info_tbl[ID_AD7190] },
1433 { .compatible = "adi,ad7192", .data = &ad7192_chip_info_tbl[ID_AD7192] },
1434 { .compatible = "adi,ad7193", .data = &ad7192_chip_info_tbl[ID_AD7193] },
1435 { .compatible = "adi,ad7194", .data = &ad7192_chip_info_tbl[ID_AD7194] },
1436 { .compatible = "adi,ad7195", .data = &ad7192_chip_info_tbl[ID_AD7195] },
1437 { }
1438 };
1439 MODULE_DEVICE_TABLE(of, ad7192_of_match);
1440
1441 static const struct spi_device_id ad7192_ids[] = {
1442 { "ad7190", (kernel_ulong_t)&ad7192_chip_info_tbl[ID_AD7190] },
1443 { "ad7192", (kernel_ulong_t)&ad7192_chip_info_tbl[ID_AD7192] },
1444 { "ad7193", (kernel_ulong_t)&ad7192_chip_info_tbl[ID_AD7193] },
1445 { "ad7194", (kernel_ulong_t)&ad7192_chip_info_tbl[ID_AD7194] },
1446 { "ad7195", (kernel_ulong_t)&ad7192_chip_info_tbl[ID_AD7195] },
1447 { }
1448 };
1449 MODULE_DEVICE_TABLE(spi, ad7192_ids);
1450
1451 static struct spi_driver ad7192_driver = {
1452 .driver = {
1453 .name = "ad7192",
1454 .of_match_table = ad7192_of_match,
1455 },
1456 .probe = ad7192_probe,
1457 .id_table = ad7192_ids,
1458 };
1459 module_spi_driver(ad7192_driver);
1460
1461 MODULE_AUTHOR("Michael Hennerich <michael.hennerich@analog.com>");
1462 MODULE_DESCRIPTION("Analog Devices AD7192 and similar ADC");
1463 MODULE_LICENSE("GPL v2");
1464 MODULE_IMPORT_NS("IIO_AD_SIGMA_DELTA");
Linux Kernel