?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
interconnect: qcom: Fix Kconfig indentation
[linux/fpc-iii.git] / drivers / iio / temperature / ltc2983.c
blobddf47023364b0c840e6579b2e1f29d19de236645
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Analog Devices LTC2983 Multi-Sensor Digital Temperature Measurement System
4 * driver
5 *
6 * Copyright 2019 Analog Devices Inc.
7 */
8 #include <linux/bitfield.h>
9 #include <linux/completion.h>
10 #include <linux/device.h>
11 #include <linux/kernel.h>
12 #include <linux/iio/iio.h>
13 #include <linux/interrupt.h>
14 #include <linux/list.h>
15 #include <linux/module.h>
16 #include <linux/of_gpio.h>
17 #include <linux/regmap.h>
18 #include <linux/spi/spi.h>
19
20 /* register map */
21 #define LTC2983_STATUS_REG 0x0000
22 #define LTC2983_TEMP_RES_START_REG 0x0010
23 #define LTC2983_TEMP_RES_END_REG 0x005F
24 #define LTC2983_GLOBAL_CONFIG_REG 0x00F0
25 #define LTC2983_MULT_CHANNEL_START_REG 0x00F4
26 #define LTC2983_MULT_CHANNEL_END_REG 0x00F7
27 #define LTC2983_MUX_CONFIG_REG 0x00FF
28 #define LTC2983_CHAN_ASSIGN_START_REG 0x0200
29 #define LTC2983_CHAN_ASSIGN_END_REG 0x024F
30 #define LTC2983_CUST_SENS_TBL_START_REG 0x0250
31 #define LTC2983_CUST_SENS_TBL_END_REG 0x03CF
32
33 #define LTC2983_DIFFERENTIAL_CHAN_MIN 2
34 #define LTC2983_MAX_CHANNELS_NR 20
35 #define LTC2983_MIN_CHANNELS_NR 1
36 #define LTC2983_SLEEP 0x97
37 #define LTC2983_CUSTOM_STEINHART_SIZE 24
38 #define LTC2983_CUSTOM_SENSOR_ENTRY_SZ 6
39 #define LTC2983_CUSTOM_STEINHART_ENTRY_SZ 4
40
41 #define LTC2983_CHAN_START_ADDR(chan) \
42 (((chan - 1) * 4) + LTC2983_CHAN_ASSIGN_START_REG)
43 #define LTC2983_CHAN_RES_ADDR(chan) \
44 (((chan - 1) * 4) + LTC2983_TEMP_RES_START_REG)
45 #define LTC2983_THERMOCOUPLE_DIFF_MASK BIT(3)
46 #define LTC2983_THERMOCOUPLE_SGL(x) \
47 FIELD_PREP(LTC2983_THERMOCOUPLE_DIFF_MASK, x)
48 #define LTC2983_THERMOCOUPLE_OC_CURR_MASK GENMASK(1, 0)
49 #define LTC2983_THERMOCOUPLE_OC_CURR(x) \
50 FIELD_PREP(LTC2983_THERMOCOUPLE_OC_CURR_MASK, x)
51 #define LTC2983_THERMOCOUPLE_OC_CHECK_MASK BIT(2)
52 #define LTC2983_THERMOCOUPLE_OC_CHECK(x) \
53 FIELD_PREP(LTC2983_THERMOCOUPLE_OC_CHECK_MASK, x)
54
55 #define LTC2983_THERMISTOR_DIFF_MASK BIT(2)
56 #define LTC2983_THERMISTOR_SGL(x) \
57 FIELD_PREP(LTC2983_THERMISTOR_DIFF_MASK, x)
58 #define LTC2983_THERMISTOR_R_SHARE_MASK BIT(1)
59 #define LTC2983_THERMISTOR_R_SHARE(x) \
60 FIELD_PREP(LTC2983_THERMISTOR_R_SHARE_MASK, x)
61 #define LTC2983_THERMISTOR_C_ROTATE_MASK BIT(0)
62 #define LTC2983_THERMISTOR_C_ROTATE(x) \
63 FIELD_PREP(LTC2983_THERMISTOR_C_ROTATE_MASK, x)
64
65 #define LTC2983_DIODE_DIFF_MASK BIT(2)
66 #define LTC2983_DIODE_SGL(x) \
67 FIELD_PREP(LTC2983_DIODE_DIFF_MASK, x)
68 #define LTC2983_DIODE_3_CONV_CYCLE_MASK BIT(1)
69 #define LTC2983_DIODE_3_CONV_CYCLE(x) \
70 FIELD_PREP(LTC2983_DIODE_3_CONV_CYCLE_MASK, x)
71 #define LTC2983_DIODE_AVERAGE_ON_MASK BIT(0)
72 #define LTC2983_DIODE_AVERAGE_ON(x) \
73 FIELD_PREP(LTC2983_DIODE_AVERAGE_ON_MASK, x)
74
75 #define LTC2983_RTD_4_WIRE_MASK BIT(3)
76 #define LTC2983_RTD_ROTATION_MASK BIT(1)
77 #define LTC2983_RTD_C_ROTATE(x) \
78 FIELD_PREP(LTC2983_RTD_ROTATION_MASK, x)
79 #define LTC2983_RTD_KELVIN_R_SENSE_MASK GENMASK(3, 2)
80 #define LTC2983_RTD_N_WIRES_MASK GENMASK(3, 2)
81 #define LTC2983_RTD_N_WIRES(x) \
82 FIELD_PREP(LTC2983_RTD_N_WIRES_MASK, x)
83 #define LTC2983_RTD_R_SHARE_MASK BIT(0)
84 #define LTC2983_RTD_R_SHARE(x) \
85 FIELD_PREP(LTC2983_RTD_R_SHARE_MASK, 1)
86
87 #define LTC2983_COMMON_HARD_FAULT_MASK GENMASK(31, 30)
88 #define LTC2983_COMMON_SOFT_FAULT_MASK GENMASK(27, 25)
89
90 #define LTC2983_STATUS_START_MASK BIT(7)
91 #define LTC2983_STATUS_START(x) FIELD_PREP(LTC2983_STATUS_START_MASK, x)
92
93 #define LTC2983_STATUS_CHAN_SEL_MASK GENMASK(4, 0)
94 #define LTC2983_STATUS_CHAN_SEL(x) \
95 FIELD_PREP(LTC2983_STATUS_CHAN_SEL_MASK, x)
96
97 #define LTC2983_TEMP_UNITS_MASK BIT(2)
98 #define LTC2983_TEMP_UNITS(x) FIELD_PREP(LTC2983_TEMP_UNITS_MASK, x)
99
100 #define LTC2983_NOTCH_FREQ_MASK GENMASK(1, 0)
101 #define LTC2983_NOTCH_FREQ(x) FIELD_PREP(LTC2983_NOTCH_FREQ_MASK, x)
102
103 #define LTC2983_RES_VALID_MASK BIT(24)
104 #define LTC2983_DATA_MASK GENMASK(23, 0)
105 #define LTC2983_DATA_SIGN_BIT 23
106
107 #define LTC2983_CHAN_TYPE_MASK GENMASK(31, 27)
108 #define LTC2983_CHAN_TYPE(x) FIELD_PREP(LTC2983_CHAN_TYPE_MASK, x)
109
110 /* cold junction for thermocouples and rsense for rtd's and thermistor's */
111 #define LTC2983_CHAN_ASSIGN_MASK GENMASK(26, 22)
112 #define LTC2983_CHAN_ASSIGN(x) FIELD_PREP(LTC2983_CHAN_ASSIGN_MASK, x)
113
114 #define LTC2983_CUSTOM_LEN_MASK GENMASK(5, 0)
115 #define LTC2983_CUSTOM_LEN(x) FIELD_PREP(LTC2983_CUSTOM_LEN_MASK, x)
116
117 #define LTC2983_CUSTOM_ADDR_MASK GENMASK(11, 6)
118 #define LTC2983_CUSTOM_ADDR(x) FIELD_PREP(LTC2983_CUSTOM_ADDR_MASK, x)
119
120 #define LTC2983_THERMOCOUPLE_CFG_MASK GENMASK(21, 18)
121 #define LTC2983_THERMOCOUPLE_CFG(x) \
122 FIELD_PREP(LTC2983_THERMOCOUPLE_CFG_MASK, x)
123 #define LTC2983_THERMOCOUPLE_HARD_FAULT_MASK GENMASK(31, 29)
124 #define LTC2983_THERMOCOUPLE_SOFT_FAULT_MASK GENMASK(28, 25)
125
126 #define LTC2983_RTD_CFG_MASK GENMASK(21, 18)
127 #define LTC2983_RTD_CFG(x) FIELD_PREP(LTC2983_RTD_CFG_MASK, x)
128 #define LTC2983_RTD_EXC_CURRENT_MASK GENMASK(17, 14)
129 #define LTC2983_RTD_EXC_CURRENT(x) \
130 FIELD_PREP(LTC2983_RTD_EXC_CURRENT_MASK, x)
131 #define LTC2983_RTD_CURVE_MASK GENMASK(13, 12)
132 #define LTC2983_RTD_CURVE(x) FIELD_PREP(LTC2983_RTD_CURVE_MASK, x)
133
134 #define LTC2983_THERMISTOR_CFG_MASK GENMASK(21, 19)
135 #define LTC2983_THERMISTOR_CFG(x) \
136 FIELD_PREP(LTC2983_THERMISTOR_CFG_MASK, x)
137 #define LTC2983_THERMISTOR_EXC_CURRENT_MASK GENMASK(18, 15)
138 #define LTC2983_THERMISTOR_EXC_CURRENT(x) \
139 FIELD_PREP(LTC2983_THERMISTOR_EXC_CURRENT_MASK, x)
140
141 #define LTC2983_DIODE_CFG_MASK GENMASK(26, 24)
142 #define LTC2983_DIODE_CFG(x) FIELD_PREP(LTC2983_DIODE_CFG_MASK, x)
143 #define LTC2983_DIODE_EXC_CURRENT_MASK GENMASK(23, 22)
144 #define LTC2983_DIODE_EXC_CURRENT(x) \
145 FIELD_PREP(LTC2983_DIODE_EXC_CURRENT_MASK, x)
146 #define LTC2983_DIODE_IDEAL_FACTOR_MASK GENMASK(21, 0)
147 #define LTC2983_DIODE_IDEAL_FACTOR(x) \
148 FIELD_PREP(LTC2983_DIODE_IDEAL_FACTOR_MASK, x)
149
150 #define LTC2983_R_SENSE_VAL_MASK GENMASK(26, 0)
151 #define LTC2983_R_SENSE_VAL(x) FIELD_PREP(LTC2983_R_SENSE_VAL_MASK, x)
152
153 #define LTC2983_ADC_SINGLE_ENDED_MASK BIT(26)
154 #define LTC2983_ADC_SINGLE_ENDED(x) \
155 FIELD_PREP(LTC2983_ADC_SINGLE_ENDED_MASK, x)
156
157 enum {
158 LTC2983_SENSOR_THERMOCOUPLE = 1,
159 LTC2983_SENSOR_THERMOCOUPLE_CUSTOM = 9,
160 LTC2983_SENSOR_RTD = 10,
161 LTC2983_SENSOR_RTD_CUSTOM = 18,
162 LTC2983_SENSOR_THERMISTOR = 19,
163 LTC2983_SENSOR_THERMISTOR_STEINHART = 26,
164 LTC2983_SENSOR_THERMISTOR_CUSTOM = 27,
165 LTC2983_SENSOR_DIODE = 28,
166 LTC2983_SENSOR_SENSE_RESISTOR = 29,
167 LTC2983_SENSOR_DIRECT_ADC = 30,
168 };
169
170 #define to_thermocouple(_sensor) \
171 container_of(_sensor, struct ltc2983_thermocouple, sensor)
172
173 #define to_rtd(_sensor) \
174 container_of(_sensor, struct ltc2983_rtd, sensor)
175
176 #define to_thermistor(_sensor) \
177 container_of(_sensor, struct ltc2983_thermistor, sensor)
178
179 #define to_diode(_sensor) \
180 container_of(_sensor, struct ltc2983_diode, sensor)
181
182 #define to_rsense(_sensor) \
183 container_of(_sensor, struct ltc2983_rsense, sensor)
184
185 #define to_adc(_sensor) \
186 container_of(_sensor, struct ltc2983_adc, sensor)
187
188 struct ltc2983_data {
189 struct regmap *regmap;
190 struct spi_device *spi;
191 struct mutex lock;
192 struct completion completion;
193 struct iio_chan_spec *iio_chan;
194 struct ltc2983_sensor **sensors;
195 u32 mux_delay_config;
196 u32 filter_notch_freq;
197 u16 custom_table_size;
198 u8 num_channels;
199 u8 iio_channels;
200 /*
201 * DMA (thus cache coherency maintenance) requires the
202 * transfer buffers to live in their own cache lines.
203 * Holds the converted temperature
204 */
205 __be32 temp ____cacheline_aligned;
206 };
207
208 struct ltc2983_sensor {
209 int (*fault_handler)(const struct ltc2983_data *st, const u32 result);
210 int (*assign_chan)(struct ltc2983_data *st,
211 const struct ltc2983_sensor *sensor);
212 /* specifies the sensor channel */
213 u32 chan;
214 /* sensor type */
215 u32 type;
216 };
217
218 struct ltc2983_custom_sensor {
219 /* raw table sensor data */
220 u8 *table;
221 size_t size;
222 /* address offset */
223 s8 offset;
224 bool is_steinhart;
225 };
226
227 struct ltc2983_thermocouple {
228 struct ltc2983_sensor sensor;
229 struct ltc2983_custom_sensor *custom;
230 u32 sensor_config;
231 u32 cold_junction_chan;
232 };
233
234 struct ltc2983_rtd {
235 struct ltc2983_sensor sensor;
236 struct ltc2983_custom_sensor *custom;
237 u32 sensor_config;
238 u32 r_sense_chan;
239 u32 excitation_current;
240 u32 rtd_curve;
241 };
242
243 struct ltc2983_thermistor {
244 struct ltc2983_sensor sensor;
245 struct ltc2983_custom_sensor *custom;
246 u32 sensor_config;
247 u32 r_sense_chan;
248 u32 excitation_current;
249 };
250
251 struct ltc2983_diode {
252 struct ltc2983_sensor sensor;
253 u32 sensor_config;
254 u32 excitation_current;
255 u32 ideal_factor_value;
256 };
257
258 struct ltc2983_rsense {
259 struct ltc2983_sensor sensor;
260 u32 r_sense_val;
261 };
262
263 struct ltc2983_adc {
264 struct ltc2983_sensor sensor;
265 bool single_ended;
266 };
267
268 /*
269 * Convert to Q format numbers. These number's are integers where
270 * the number of integer and fractional bits are specified. The resolution
271 * is given by 1/@resolution and tell us the number of fractional bits. For
272 * instance a resolution of 2^-10 means we have 10 fractional bits.
273 */
274 static u32 __convert_to_raw(const u64 val, const u32 resolution)
275 {
276 u64 __res = val * resolution;
277
278 /* all values are multiplied by 1000000 to remove the fraction */
279 do_div(__res, 1000000);
280
281 return __res;
282 }
283
284 static u32 __convert_to_raw_sign(const u64 val, const u32 resolution)
285 {
286 s64 __res = -(s32)val;
287
288 __res = __convert_to_raw(__res, resolution);
289
290 return (u32)-__res;
291 }
292
293 static int __ltc2983_fault_handler(const struct ltc2983_data *st,
294 const u32 result, const u32 hard_mask,
295 const u32 soft_mask)
296 {
297 const struct device *dev = &st->spi->dev;
298
299 if (result & hard_mask) {
300 dev_err(dev, "Invalid conversion: Sensor HARD fault\n");
301 return -EIO;
302 } else if (result & soft_mask) {
303 /* just print a warning */
304 dev_warn(dev, "Suspicious conversion: Sensor SOFT fault\n");
305 }
306
307 return 0;
308 }
309
310 static int __ltc2983_chan_assign_common(const struct ltc2983_data *st,
311 const struct ltc2983_sensor *sensor,
312 u32 chan_val)
313 {
314 u32 reg = LTC2983_CHAN_START_ADDR(sensor->chan);
315 __be32 __chan_val;
316
317 chan_val |= LTC2983_CHAN_TYPE(sensor->type);
318 dev_dbg(&st->spi->dev, "Assign reg:0x%04X, val:0x%08X\n", reg,
319 chan_val);
320 __chan_val = cpu_to_be32(chan_val);
321 return regmap_bulk_write(st->regmap, reg, &__chan_val,
322 sizeof(__chan_val));
323 }
324
325 static int __ltc2983_chan_custom_sensor_assign(struct ltc2983_data *st,
326 struct ltc2983_custom_sensor *custom,
327 u32 *chan_val)
328 {
329 u32 reg;
330 u8 mult = custom->is_steinhart ? LTC2983_CUSTOM_STEINHART_ENTRY_SZ :
331 LTC2983_CUSTOM_SENSOR_ENTRY_SZ;
332 const struct device *dev = &st->spi->dev;
333 /*
334 * custom->size holds the raw size of the table. However, when
335 * configuring the sensor channel, we must write the number of
336 * entries of the table minus 1. For steinhart sensors 0 is written
337 * since the size is constant!
338 */
339 const u8 len = custom->is_steinhart ? 0 :
340 (custom->size / LTC2983_CUSTOM_SENSOR_ENTRY_SZ) - 1;
341 /*
342 * Check if the offset was assigned already. It should be for steinhart
343 * sensors. When coming from sleep, it should be assigned for all.
344 */
345 if (custom->offset < 0) {
346 /*
347 * This needs to be done again here because, from the moment
348 * when this test was done (successfully) for this custom
349 * sensor, a steinhart sensor might have been added changing
350 * custom_table_size...
351 */
352 if (st->custom_table_size + custom->size >
353 (LTC2983_CUST_SENS_TBL_END_REG -
354 LTC2983_CUST_SENS_TBL_START_REG) + 1) {
355 dev_err(dev,
356 "Not space left(%d) for new custom sensor(%zu)",
357 st->custom_table_size,
358 custom->size);
359 return -EINVAL;
360 }
361
362 custom->offset = st->custom_table_size /
363 LTC2983_CUSTOM_SENSOR_ENTRY_SZ;
364 st->custom_table_size += custom->size;
365 }
366
367 reg = (custom->offset * mult) + LTC2983_CUST_SENS_TBL_START_REG;
368
369 *chan_val |= LTC2983_CUSTOM_LEN(len);
370 *chan_val |= LTC2983_CUSTOM_ADDR(custom->offset);
371 dev_dbg(dev, "Assign custom sensor, reg:0x%04X, off:%d, sz:%zu",
372 reg, custom->offset,
373 custom->size);
374 /* write custom sensor table */
375 return regmap_bulk_write(st->regmap, reg, custom->table, custom->size);
376 }
377
378 static struct ltc2983_custom_sensor *__ltc2983_custom_sensor_new(
379 struct ltc2983_data *st,
380 const struct device_node *np,
381 const char *propname,
382 const bool is_steinhart,
383 const u32 resolution,
384 const bool has_signed)
385 {
386 struct ltc2983_custom_sensor *new_custom;
387 u8 index, n_entries, tbl = 0;
388 struct device *dev = &st->spi->dev;
389 /*
390 * For custom steinhart, the full u32 is taken. For all the others
391 * the MSB is discarded.
392 */
393 const u8 n_size = (is_steinhart == true) ? 4 : 3;
394 const u8 e_size = (is_steinhart == true) ? sizeof(u32) : sizeof(u64);
395
396 n_entries = of_property_count_elems_of_size(np, propname, e_size);
397 /* n_entries must be an even number */
398 if (!n_entries || (n_entries % 2) != 0) {
399 dev_err(dev, "Number of entries either 0 or not even\n");
400 return ERR_PTR(-EINVAL);
401 }
402
403 new_custom = devm_kzalloc(dev, sizeof(*new_custom), GFP_KERNEL);
404 if (!new_custom)
405 return ERR_PTR(-ENOMEM);
406
407 new_custom->size = n_entries * n_size;
408 /* check Steinhart size */
409 if (is_steinhart && new_custom->size != LTC2983_CUSTOM_STEINHART_SIZE) {
410 dev_err(dev, "Steinhart sensors size(%zu) must be 24",
411 new_custom->size);
412 return ERR_PTR(-EINVAL);
413 }
414 /* Check space on the table. */
415 if (st->custom_table_size + new_custom->size >
416 (LTC2983_CUST_SENS_TBL_END_REG -
417 LTC2983_CUST_SENS_TBL_START_REG) + 1) {
418 dev_err(dev, "No space left(%d) for new custom sensor(%zu)",
419 st->custom_table_size, new_custom->size);
420 return ERR_PTR(-EINVAL);
421 }
422
423 /* allocate the table */
424 new_custom->table = devm_kzalloc(dev, new_custom->size, GFP_KERNEL);
425 if (!new_custom->table)
426 return ERR_PTR(-ENOMEM);
427
428 for (index = 0; index < n_entries; index++) {
429 u64 temp = 0, j;
430 /*
431 * Steinhart sensors are configured with raw values in the
432 * devicetree. For the other sensors we must convert the
433 * value to raw. The odd index's correspond to temperarures
434 * and always have 1/1024 of resolution. Temperatures also
435 * come in kelvin, so signed values is not possible
436 */
437 if (!is_steinhart) {
438 of_property_read_u64_index(np, propname, index, &temp);
439
440 if ((index % 2) != 0)
441 temp = __convert_to_raw(temp, 1024);
442 else if (has_signed && (s64)temp < 0)
443 temp = __convert_to_raw_sign(temp, resolution);
444 else
445 temp = __convert_to_raw(temp, resolution);
446 } else {
447 of_property_read_u32_index(np, propname, index,
448 (u32 *)&temp);
449 }
450
451 for (j = 0; j < n_size; j++)
452 new_custom->table[tbl++] =
453 temp >> (8 * (n_size - j - 1));
454 }
455
456 new_custom->is_steinhart = is_steinhart;
457 /*
458 * This is done to first add all the steinhart sensors to the table,
459 * in order to maximize the table usage. If we mix adding steinhart
460 * with the other sensors, we might have to do some roundup to make
461 * sure that sensor_addr - 0x250(start address) is a multiple of 4
462 * (for steinhart), and a multiple of 6 for all the other sensors.
463 * Since we have const 24 bytes for steinhart sensors and 24 is
464 * also a multiple of 6, we guarantee that the first non-steinhart
465 * sensor will sit in a correct address without the need of filling
466 * addresses.
467 */
468 if (is_steinhart) {
469 new_custom->offset = st->custom_table_size /
470 LTC2983_CUSTOM_STEINHART_ENTRY_SZ;
471 st->custom_table_size += new_custom->size;
472 } else {
473 /* mark as unset. This is checked later on the assign phase */
474 new_custom->offset = -1;
475 }
476
477 return new_custom;
478 }
479
480 static int ltc2983_thermocouple_fault_handler(const struct ltc2983_data *st,
481 const u32 result)
482 {
483 return __ltc2983_fault_handler(st, result,
484 LTC2983_THERMOCOUPLE_HARD_FAULT_MASK,
485 LTC2983_THERMOCOUPLE_SOFT_FAULT_MASK);
486 }
487
488 static int ltc2983_common_fault_handler(const struct ltc2983_data *st,
489 const u32 result)
490 {
491 return __ltc2983_fault_handler(st, result,
492 LTC2983_COMMON_HARD_FAULT_MASK,
493 LTC2983_COMMON_SOFT_FAULT_MASK);
494 }
495
496 static int ltc2983_thermocouple_assign_chan(struct ltc2983_data *st,
497 const struct ltc2983_sensor *sensor)
498 {
499 struct ltc2983_thermocouple *thermo = to_thermocouple(sensor);
500 u32 chan_val;
501
502 chan_val = LTC2983_CHAN_ASSIGN(thermo->cold_junction_chan);
503 chan_val |= LTC2983_THERMOCOUPLE_CFG(thermo->sensor_config);
504
505 if (thermo->custom) {
506 int ret;
507
508 ret = __ltc2983_chan_custom_sensor_assign(st, thermo->custom,
509 &chan_val);
510 if (ret)
511 return ret;
512 }
513 return __ltc2983_chan_assign_common(st, sensor, chan_val);
514 }
515
516 static int ltc2983_rtd_assign_chan(struct ltc2983_data *st,
517 const struct ltc2983_sensor *sensor)
518 {
519 struct ltc2983_rtd *rtd = to_rtd(sensor);
520 u32 chan_val;
521
522 chan_val = LTC2983_CHAN_ASSIGN(rtd->r_sense_chan);
523 chan_val |= LTC2983_RTD_CFG(rtd->sensor_config);
524 chan_val |= LTC2983_RTD_EXC_CURRENT(rtd->excitation_current);
525 chan_val |= LTC2983_RTD_CURVE(rtd->rtd_curve);
526
527 if (rtd->custom) {
528 int ret;
529
530 ret = __ltc2983_chan_custom_sensor_assign(st, rtd->custom,
531 &chan_val);
532 if (ret)
533 return ret;
534 }
535 return __ltc2983_chan_assign_common(st, sensor, chan_val);
536 }
537
538 static int ltc2983_thermistor_assign_chan(struct ltc2983_data *st,
539 const struct ltc2983_sensor *sensor)
540 {
541 struct ltc2983_thermistor *thermistor = to_thermistor(sensor);
542 u32 chan_val;
543
544 chan_val = LTC2983_CHAN_ASSIGN(thermistor->r_sense_chan);
545 chan_val |= LTC2983_THERMISTOR_CFG(thermistor->sensor_config);
546 chan_val |=
547 LTC2983_THERMISTOR_EXC_CURRENT(thermistor->excitation_current);
548
549 if (thermistor->custom) {
550 int ret;
551
552 ret = __ltc2983_chan_custom_sensor_assign(st,
553 thermistor->custom,
554 &chan_val);
555 if (ret)
556 return ret;
557 }
558 return __ltc2983_chan_assign_common(st, sensor, chan_val);
559 }
560
561 static int ltc2983_diode_assign_chan(struct ltc2983_data *st,
562 const struct ltc2983_sensor *sensor)
563 {
564 struct ltc2983_diode *diode = to_diode(sensor);
565 u32 chan_val;
566
567 chan_val = LTC2983_DIODE_CFG(diode->sensor_config);
568 chan_val |= LTC2983_DIODE_EXC_CURRENT(diode->excitation_current);
569 chan_val |= LTC2983_DIODE_IDEAL_FACTOR(diode->ideal_factor_value);
570
571 return __ltc2983_chan_assign_common(st, sensor, chan_val);
572 }
573
574 static int ltc2983_r_sense_assign_chan(struct ltc2983_data *st,
575 const struct ltc2983_sensor *sensor)
576 {
577 struct ltc2983_rsense *rsense = to_rsense(sensor);
578 u32 chan_val;
579
580 chan_val = LTC2983_R_SENSE_VAL(rsense->r_sense_val);
581
582 return __ltc2983_chan_assign_common(st, sensor, chan_val);
583 }
584
585 static int ltc2983_adc_assign_chan(struct ltc2983_data *st,
586 const struct ltc2983_sensor *sensor)
587 {
588 struct ltc2983_adc *adc = to_adc(sensor);
589 u32 chan_val;
590
591 chan_val = LTC2983_ADC_SINGLE_ENDED(adc->single_ended);
592
593 return __ltc2983_chan_assign_common(st, sensor, chan_val);
594 }
595
596 static struct ltc2983_sensor *ltc2983_thermocouple_new(
597 const struct device_node *child,
598 struct ltc2983_data *st,
599 const struct ltc2983_sensor *sensor)
600 {
601 struct ltc2983_thermocouple *thermo;
602 struct device_node *phandle;
603 u32 oc_current;
604 int ret;
605
606 thermo = devm_kzalloc(&st->spi->dev, sizeof(*thermo), GFP_KERNEL);
607 if (!thermo)
608 return ERR_PTR(-ENOMEM);
609
610 if (of_property_read_bool(child, "adi,single-ended"))
611 thermo->sensor_config = LTC2983_THERMOCOUPLE_SGL(1);
612
613 ret = of_property_read_u32(child, "adi,sensor-oc-current-microamp",
614 &oc_current);
615 if (!ret) {
616 switch (oc_current) {
617 case 10:
618 thermo->sensor_config |=
619 LTC2983_THERMOCOUPLE_OC_CURR(0);
620 break;
621 case 100:
622 thermo->sensor_config |=
623 LTC2983_THERMOCOUPLE_OC_CURR(1);
624 break;
625 case 500:
626 thermo->sensor_config |=
627 LTC2983_THERMOCOUPLE_OC_CURR(2);
628 break;
629 case 1000:
630 thermo->sensor_config |=
631 LTC2983_THERMOCOUPLE_OC_CURR(3);
632 break;
633 default:
634 dev_err(&st->spi->dev,
635 "Invalid open circuit current:%u", oc_current);
636 return ERR_PTR(-EINVAL);
637 }
638
639 thermo->sensor_config |= LTC2983_THERMOCOUPLE_OC_CHECK(1);
640 }
641 /* validate channel index */
642 if (!(thermo->sensor_config & LTC2983_THERMOCOUPLE_DIFF_MASK) &&
643 sensor->chan < LTC2983_DIFFERENTIAL_CHAN_MIN) {
644 dev_err(&st->spi->dev,
645 "Invalid chann:%d for differential thermocouple",
646 sensor->chan);
647 return ERR_PTR(-EINVAL);
648 }
649
650 phandle = of_parse_phandle(child, "adi,cold-junction-handle", 0);
651 if (phandle) {
652 int ret;
653
654 ret = of_property_read_u32(phandle, "reg",
655 &thermo->cold_junction_chan);
656 if (ret) {
657 /*
658 * This would be catched later but we can just return
659 * the error right away.
660 */
661 dev_err(&st->spi->dev, "Property reg must be given\n");
662 of_node_put(phandle);
663 return ERR_PTR(-EINVAL);
664 }
665 }
666
667 /* check custom sensor */
668 if (sensor->type == LTC2983_SENSOR_THERMOCOUPLE_CUSTOM) {
669 const char *propname = "adi,custom-thermocouple";
670
671 thermo->custom = __ltc2983_custom_sensor_new(st, child,
672 propname, false,
673 16384, true);
674 if (IS_ERR(thermo->custom)) {
675 of_node_put(phandle);
676 return ERR_CAST(thermo->custom);
677 }
678 }
679
680 /* set common parameters */
681 thermo->sensor.fault_handler = ltc2983_thermocouple_fault_handler;
682 thermo->sensor.assign_chan = ltc2983_thermocouple_assign_chan;
683
684 of_node_put(phandle);
685 return &thermo->sensor;
686 }
687
688 static struct ltc2983_sensor *ltc2983_rtd_new(const struct device_node *child,
689 struct ltc2983_data *st,
690 const struct ltc2983_sensor *sensor)
691 {
692 struct ltc2983_rtd *rtd;
693 int ret = 0;
694 struct device *dev = &st->spi->dev;
695 struct device_node *phandle;
696 u32 excitation_current = 0, n_wires = 0;
697
698 rtd = devm_kzalloc(dev, sizeof(*rtd), GFP_KERNEL);
699 if (!rtd)
700 return ERR_PTR(-ENOMEM);
701
702 phandle = of_parse_phandle(child, "adi,rsense-handle", 0);
703 if (!phandle) {
704 dev_err(dev, "Property adi,rsense-handle missing or invalid");
705 return ERR_PTR(-EINVAL);
706 }
707
708 ret = of_property_read_u32(phandle, "reg", &rtd->r_sense_chan);
709 if (ret) {
710 dev_err(dev, "Property reg must be given\n");
711 goto fail;
712 }
713
714 ret = of_property_read_u32(child, "adi,number-of-wires", &n_wires);
715 if (!ret) {
716 switch (n_wires) {
717 case 2:
718 rtd->sensor_config = LTC2983_RTD_N_WIRES(0);
719 break;
720 case 3:
721 rtd->sensor_config = LTC2983_RTD_N_WIRES(1);
722 break;
723 case 4:
724 rtd->sensor_config = LTC2983_RTD_N_WIRES(2);
725 break;
726 case 5:
727 /* 4 wires, Kelvin Rsense */
728 rtd->sensor_config = LTC2983_RTD_N_WIRES(3);
729 break;
730 default:
731 dev_err(dev, "Invalid number of wires:%u\n", n_wires);
732 ret = -EINVAL;
733 goto fail;
734 }
735 }
736
737 if (of_property_read_bool(child, "adi,rsense-share")) {
738 /* Current rotation is only available with rsense sharing */
739 if (of_property_read_bool(child, "adi,current-rotate")) {
740 if (n_wires == 2 || n_wires == 3) {
741 dev_err(dev,
742 "Rotation not allowed for 2/3 Wire RTDs");
743 ret = -EINVAL;
744 goto fail;
745 }
746 rtd->sensor_config |= LTC2983_RTD_C_ROTATE(1);
747 } else {
748 rtd->sensor_config |= LTC2983_RTD_R_SHARE(1);
749 }
750 }
751 /*
752 * rtd channel indexes are a bit more complicated to validate.
753 * For 4wire RTD with rotation, the channel selection cannot be
754 * >=19 since the chann + 1 is used in this configuration.
755 * For 4wire RTDs with kelvin rsense, the rsense channel cannot be
756 * <=1 since chanel - 1 and channel - 2 are used.
757 */
758 if (rtd->sensor_config & LTC2983_RTD_4_WIRE_MASK) {
759 /* 4-wire */
760 u8 min = LTC2983_DIFFERENTIAL_CHAN_MIN,
761 max = LTC2983_MAX_CHANNELS_NR;
762
763 if (rtd->sensor_config & LTC2983_RTD_ROTATION_MASK)
764 max = LTC2983_MAX_CHANNELS_NR - 1;
765
766 if (((rtd->sensor_config & LTC2983_RTD_KELVIN_R_SENSE_MASK)
767 == LTC2983_RTD_KELVIN_R_SENSE_MASK) &&
768 (rtd->r_sense_chan <= min)) {
769 /* kelvin rsense*/
770 dev_err(dev,
771 "Invalid rsense chann:%d to use in kelvin rsense",
772 rtd->r_sense_chan);
773
774 ret = -EINVAL;
775 goto fail;
776 }
777
778 if (sensor->chan < min || sensor->chan > max) {
779 dev_err(dev, "Invalid chann:%d for the rtd config",
780 sensor->chan);
781
782 ret = -EINVAL;
783 goto fail;
784 }
785 } else {
786 /* same as differential case */
787 if (sensor->chan < LTC2983_DIFFERENTIAL_CHAN_MIN) {
788 dev_err(&st->spi->dev,
789 "Invalid chann:%d for RTD", sensor->chan);
790
791 ret = -EINVAL;
792 goto fail;
793 }
794 }
795
796 /* check custom sensor */
797 if (sensor->type == LTC2983_SENSOR_RTD_CUSTOM) {
798 rtd->custom = __ltc2983_custom_sensor_new(st, child,
799 "adi,custom-rtd",
800 false, 2048, false);
801 if (IS_ERR(rtd->custom)) {
802 of_node_put(phandle);
803 return ERR_CAST(rtd->custom);
804 }
805 }
806
807 /* set common parameters */
808 rtd->sensor.fault_handler = ltc2983_common_fault_handler;
809 rtd->sensor.assign_chan = ltc2983_rtd_assign_chan;
810
811 ret = of_property_read_u32(child, "adi,excitation-current-microamp",
812 &excitation_current);
813 if (ret) {
814 /* default to 5uA */
815 rtd->excitation_current = 1;
816 } else {
817 switch (excitation_current) {
818 case 5:
819 rtd->excitation_current = 0x01;
820 break;
821 case 10:
822 rtd->excitation_current = 0x02;
823 break;
824 case 25:
825 rtd->excitation_current = 0x03;
826 break;
827 case 50:
828 rtd->excitation_current = 0x04;
829 break;
830 case 100:
831 rtd->excitation_current = 0x05;
832 break;
833 case 250:
834 rtd->excitation_current = 0x06;
835 break;
836 case 500:
837 rtd->excitation_current = 0x07;
838 break;
839 case 1000:
840 rtd->excitation_current = 0x08;
841 break;
842 default:
843 dev_err(&st->spi->dev,
844 "Invalid value for excitation current(%u)",
845 excitation_current);
846 ret = -EINVAL;
847 goto fail;
848 }
849 }
850
851 of_property_read_u32(child, "adi,rtd-curve", &rtd->rtd_curve);
852
853 of_node_put(phandle);
854 return &rtd->sensor;
855 fail:
856 of_node_put(phandle);
857 return ERR_PTR(ret);
858 }
859
860 static struct ltc2983_sensor *ltc2983_thermistor_new(
861 const struct device_node *child,
862 struct ltc2983_data *st,
863 const struct ltc2983_sensor *sensor)
864 {
865 struct ltc2983_thermistor *thermistor;
866 struct device *dev = &st->spi->dev;
867 struct device_node *phandle;
868 u32 excitation_current = 0;
869 int ret = 0;
870
871 thermistor = devm_kzalloc(dev, sizeof(*thermistor), GFP_KERNEL);
872 if (!thermistor)
873 return ERR_PTR(-ENOMEM);
874
875 phandle = of_parse_phandle(child, "adi,rsense-handle", 0);
876 if (!phandle) {
877 dev_err(dev, "Property adi,rsense-handle missing or invalid");
878 return ERR_PTR(-EINVAL);
879 }
880
881 ret = of_property_read_u32(phandle, "reg", &thermistor->r_sense_chan);
882 if (ret) {
883 dev_err(dev, "rsense channel must be configured...\n");
884 goto fail;
885 }
886
887 if (of_property_read_bool(child, "adi,single-ended")) {
888 thermistor->sensor_config = LTC2983_THERMISTOR_SGL(1);
889 } else if (of_property_read_bool(child, "adi,rsense-share")) {
890 /* rotation is only possible if sharing rsense */
891 if (of_property_read_bool(child, "adi,current-rotate"))
892 thermistor->sensor_config =
893 LTC2983_THERMISTOR_C_ROTATE(1);
894 else
895 thermistor->sensor_config =
896 LTC2983_THERMISTOR_R_SHARE(1);
897 }
898 /* validate channel index */
899 if (!(thermistor->sensor_config & LTC2983_THERMISTOR_DIFF_MASK) &&
900 sensor->chan < LTC2983_DIFFERENTIAL_CHAN_MIN) {
901 dev_err(&st->spi->dev,
902 "Invalid chann:%d for differential thermistor",
903 sensor->chan);
904 ret = -EINVAL;
905 goto fail;
906 }
907
908 /* check custom sensor */
909 if (sensor->type >= LTC2983_SENSOR_THERMISTOR_STEINHART) {
910 bool steinhart = false;
911 const char *propname;
912
913 if (sensor->type == LTC2983_SENSOR_THERMISTOR_STEINHART) {
914 steinhart = true;
915 propname = "adi,custom-steinhart";
916 } else {
917 propname = "adi,custom-thermistor";
918 }
919
920 thermistor->custom = __ltc2983_custom_sensor_new(st, child,
921 propname,
922 steinhart,
923 64, false);
924 if (IS_ERR(thermistor->custom)) {
925 of_node_put(phandle);
926 return ERR_CAST(thermistor->custom);
927 }
928 }
929 /* set common parameters */
930 thermistor->sensor.fault_handler = ltc2983_common_fault_handler;
931 thermistor->sensor.assign_chan = ltc2983_thermistor_assign_chan;
932
933 ret = of_property_read_u32(child, "adi,excitation-current-nanoamp",
934 &excitation_current);
935 if (ret) {
936 /* Auto range is not allowed for custom sensors */
937 if (sensor->type >= LTC2983_SENSOR_THERMISTOR_STEINHART)
938 /* default to 1uA */
939 thermistor->excitation_current = 0x03;
940 else
941 /* default to auto-range */
942 thermistor->excitation_current = 0x0c;
943 } else {
944 switch (excitation_current) {
945 case 0:
946 /* auto range */
947 if (sensor->type >=
948 LTC2983_SENSOR_THERMISTOR_STEINHART) {
949 dev_err(&st->spi->dev,
950 "Auto Range not allowed for custom sensors\n");
951 ret = -EINVAL;
952 goto fail;
953 }
954 thermistor->excitation_current = 0x0c;
955 break;
956 case 250:
957 thermistor->excitation_current = 0x01;
958 break;
959 case 500:
960 thermistor->excitation_current = 0x02;
961 break;
962 case 1000:
963 thermistor->excitation_current = 0x03;
964 break;
965 case 5000:
966 thermistor->excitation_current = 0x04;
967 break;
968 case 10000:
969 thermistor->excitation_current = 0x05;
970 break;
971 case 25000:
972 thermistor->excitation_current = 0x06;
973 break;
974 case 50000:
975 thermistor->excitation_current = 0x07;
976 break;
977 case 100000:
978 thermistor->excitation_current = 0x08;
979 break;
980 case 250000:
981 thermistor->excitation_current = 0x09;
982 break;
983 case 500000:
984 thermistor->excitation_current = 0x0a;
985 break;
986 case 1000000:
987 thermistor->excitation_current = 0x0b;
988 break;
989 default:
990 dev_err(&st->spi->dev,
991 "Invalid value for excitation current(%u)",
992 excitation_current);
993 ret = -EINVAL;
994 goto fail;
995 }
996 }
997
998 of_node_put(phandle);
999 return &thermistor->sensor;
1000 fail:
1001 of_node_put(phandle);
1002 return ERR_PTR(ret);
1003 }
1004
1005 static struct ltc2983_sensor *ltc2983_diode_new(
1006 const struct device_node *child,
1007 const struct ltc2983_data *st,
1008 const struct ltc2983_sensor *sensor)
1009 {
1010 struct ltc2983_diode *diode;
1011 u32 temp = 0, excitation_current = 0;
1012 int ret;
1013
1014 diode = devm_kzalloc(&st->spi->dev, sizeof(*diode), GFP_KERNEL);
1015 if (!diode)
1016 return ERR_PTR(-ENOMEM);
1017
1018 if (of_property_read_bool(child, "adi,single-ended"))
1019 diode->sensor_config = LTC2983_DIODE_SGL(1);
1020
1021 if (of_property_read_bool(child, "adi,three-conversion-cycles"))
1022 diode->sensor_config |= LTC2983_DIODE_3_CONV_CYCLE(1);
1023
1024 if (of_property_read_bool(child, "adi,average-on"))
1025 diode->sensor_config |= LTC2983_DIODE_AVERAGE_ON(1);
1026
1027 /* validate channel index */
1028 if (!(diode->sensor_config & LTC2983_DIODE_DIFF_MASK) &&
1029 sensor->chan < LTC2983_DIFFERENTIAL_CHAN_MIN) {
1030 dev_err(&st->spi->dev,
1031 "Invalid chann:%d for differential thermistor",
1032 sensor->chan);
1033 return ERR_PTR(-EINVAL);
1034 }
1035 /* set common parameters */
1036 diode->sensor.fault_handler = ltc2983_common_fault_handler;
1037 diode->sensor.assign_chan = ltc2983_diode_assign_chan;
1038
1039 ret = of_property_read_u32(child, "adi,excitation-current-microamp",
1040 &excitation_current);
1041 if (!ret) {
1042 switch (excitation_current) {
1043 case 10:
1044 diode->excitation_current = 0x00;
1045 break;
1046 case 20:
1047 diode->excitation_current = 0x01;
1048 break;
1049 case 40:
1050 diode->excitation_current = 0x02;
1051 break;
1052 case 80:
1053 diode->excitation_current = 0x03;
1054 break;
1055 default:
1056 dev_err(&st->spi->dev,
1057 "Invalid value for excitation current(%u)",
1058 excitation_current);
1059 return ERR_PTR(-EINVAL);
1060 }
1061 }
1062
1063 of_property_read_u32(child, "adi,ideal-factor-value", &temp);
1064
1065 /* 2^20 resolution */
1066 diode->ideal_factor_value = __convert_to_raw(temp, 1048576);
1067
1068 return &diode->sensor;
1069 }
1070
1071 static struct ltc2983_sensor *ltc2983_r_sense_new(struct device_node *child,
1072 struct ltc2983_data *st,
1073 const struct ltc2983_sensor *sensor)
1074 {
1075 struct ltc2983_rsense *rsense;
1076 int ret;
1077 u32 temp;
1078
1079 rsense = devm_kzalloc(&st->spi->dev, sizeof(*rsense), GFP_KERNEL);
1080 if (!rsense)
1081 return ERR_PTR(-ENOMEM);
1082
1083 /* validate channel index */
1084 if (sensor->chan < LTC2983_DIFFERENTIAL_CHAN_MIN) {
1085 dev_err(&st->spi->dev, "Invalid chann:%d for r_sense",
1086 sensor->chan);
1087 return ERR_PTR(-EINVAL);
1088 }
1089
1090 ret = of_property_read_u32(child, "adi,rsense-val-milli-ohms", &temp);
1091 if (ret) {
1092 dev_err(&st->spi->dev, "Property adi,rsense-val-milli-ohms missing\n");
1093 return ERR_PTR(-EINVAL);
1094 }
1095 /*
1096 * Times 1000 because we have milli-ohms and __convert_to_raw
1097 * expects scales of 1000000 which are used for all other
1098 * properties.
1099 * 2^10 resolution
1100 */
1101 rsense->r_sense_val = __convert_to_raw((u64)temp * 1000, 1024);
1102
1103 /* set common parameters */
1104 rsense->sensor.assign_chan = ltc2983_r_sense_assign_chan;
1105
1106 return &rsense->sensor;
1107 }
1108
1109 static struct ltc2983_sensor *ltc2983_adc_new(struct device_node *child,
1110 struct ltc2983_data *st,
1111 const struct ltc2983_sensor *sensor)
1112 {
1113 struct ltc2983_adc *adc;
1114
1115 adc = devm_kzalloc(&st->spi->dev, sizeof(*adc), GFP_KERNEL);
1116 if (!adc)
1117 return ERR_PTR(-ENOMEM);
1118
1119 if (of_property_read_bool(child, "adi,single-ended"))
1120 adc->single_ended = true;
1121
1122 if (!adc->single_ended &&
1123 sensor->chan < LTC2983_DIFFERENTIAL_CHAN_MIN) {
1124 dev_err(&st->spi->dev, "Invalid chan:%d for differential adc\n",
1125 sensor->chan);
1126 return ERR_PTR(-EINVAL);
1127 }
1128 /* set common parameters */
1129 adc->sensor.assign_chan = ltc2983_adc_assign_chan;
1130 adc->sensor.fault_handler = ltc2983_common_fault_handler;
1131
1132 return &adc->sensor;
1133 }
1134
1135 static int ltc2983_chan_read(struct ltc2983_data *st,
1136 const struct ltc2983_sensor *sensor, int *val)
1137 {
1138 u32 start_conversion = 0;
1139 int ret;
1140 unsigned long time;
1141
1142 start_conversion = LTC2983_STATUS_START(true);
1143 start_conversion |= LTC2983_STATUS_CHAN_SEL(sensor->chan);
1144 dev_dbg(&st->spi->dev, "Start conversion on chan:%d, status:%02X\n",
1145 sensor->chan, start_conversion);
1146 /* start conversion */
1147 ret = regmap_write(st->regmap, LTC2983_STATUS_REG, start_conversion);
1148 if (ret)
1149 return ret;
1150
1151 reinit_completion(&st->completion);
1152 /*
1153 * wait for conversion to complete.
1154 * 300 ms should be more than enough to complete the conversion.
1155 * Depending on the sensor configuration, there are 2/3 conversions
1156 * cycles of 82ms.
1157 */
1158 time = wait_for_completion_timeout(&st->completion,
1159 msecs_to_jiffies(300));
1160 if (!time) {
1161 dev_warn(&st->spi->dev, "Conversion timed out\n");
1162 return -ETIMEDOUT;
1163 }
1164
1165 /* read the converted data */
1166 ret = regmap_bulk_read(st->regmap, LTC2983_CHAN_RES_ADDR(sensor->chan),
1167 &st->temp, sizeof(st->temp));
1168 if (ret)
1169 return ret;
1170
1171 *val = __be32_to_cpu(st->temp);
1172
1173 if (!(LTC2983_RES_VALID_MASK & *val)) {
1174 dev_err(&st->spi->dev, "Invalid conversion detected\n");
1175 return -EIO;
1176 }
1177
1178 ret = sensor->fault_handler(st, *val);
1179 if (ret)
1180 return ret;
1181
1182 *val = sign_extend32((*val) & LTC2983_DATA_MASK, LTC2983_DATA_SIGN_BIT);
1183 return 0;
1184 }
1185
1186 static int ltc2983_read_raw(struct iio_dev *indio_dev,
1187 struct iio_chan_spec const *chan,
1188 int *val, int *val2, long mask)
1189 {
1190 struct ltc2983_data *st = iio_priv(indio_dev);
1191 int ret;
1192
1193 /* sanity check */
1194 if (chan->address >= st->num_channels) {
1195 dev_err(&st->spi->dev, "Invalid chan address:%ld",
1196 chan->address);
1197 return -EINVAL;
1198 }
1199
1200 switch (mask) {
1201 case IIO_CHAN_INFO_RAW:
1202 mutex_lock(&st->lock);
1203 ret = ltc2983_chan_read(st, st->sensors[chan->address], val);
1204 mutex_unlock(&st->lock);
1205 return ret ?: IIO_VAL_INT;
1206 case IIO_CHAN_INFO_SCALE:
1207 switch (chan->type) {
1208 case IIO_TEMP:
1209 /* value in milli degrees */
1210 *val = 1000;
1211 /* 2^10 */
1212 *val2 = 1024;
1213 return IIO_VAL_FRACTIONAL;
1214 case IIO_VOLTAGE:
1215 /* value in millivolt */
1216 *val = 1000;
1217 /* 2^21 */
1218 *val2 = 2097152;
1219 return IIO_VAL_FRACTIONAL;
1220 default:
1221 return -EINVAL;
1222 }
1223 }
1224
1225 return -EINVAL;
1226 }
1227
1228 static int ltc2983_reg_access(struct iio_dev *indio_dev,
1229 unsigned int reg,
1230 unsigned int writeval,
1231 unsigned int *readval)
1232 {
1233 struct ltc2983_data *st = iio_priv(indio_dev);
1234
1235 if (readval)
1236 return regmap_read(st->regmap, reg, readval);
1237 else
1238 return regmap_write(st->regmap, reg, writeval);
1239 }
1240
1241 static irqreturn_t ltc2983_irq_handler(int irq, void *data)
1242 {
1243 struct ltc2983_data *st = data;
1244
1245 complete(&st->completion);
1246 return IRQ_HANDLED;
1247 }
1248
1249 #define LTC2983_CHAN(__type, index, __address) ({ \
1250 struct iio_chan_spec __chan = { \
1251 .type = __type, \
1252 .indexed = 1, \
1253 .channel = index, \
1254 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
1255 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
1256 .address = __address, \
1257 }; \
1258 __chan; \
1259 })
1260
1261 static int ltc2983_parse_dt(struct ltc2983_data *st)
1262 {
1263 struct device_node *child;
1264 struct device *dev = &st->spi->dev;
1265 int ret = 0, chan = 0, channel_avail_mask = 0;
1266
1267 of_property_read_u32(dev->of_node, "adi,mux-delay-config-us",
1268 &st->mux_delay_config);
1269
1270 of_property_read_u32(dev->of_node, "adi,filter-notch-freq",
1271 &st->filter_notch_freq);
1272
1273 st->num_channels = of_get_available_child_count(dev->of_node);
1274 st->sensors = devm_kcalloc(dev, st->num_channels, sizeof(*st->sensors),
1275 GFP_KERNEL);
1276 if (!st->sensors)
1277 return -ENOMEM;
1278
1279 st->iio_channels = st->num_channels;
1280 for_each_available_child_of_node(dev->of_node, child) {
1281 struct ltc2983_sensor sensor;
1282
1283 ret = of_property_read_u32(child, "reg", &sensor.chan);
1284 if (ret) {
1285 dev_err(dev, "reg property must given for child nodes\n");
1286 return ret;
1287 }
1288
1289 /* check if we have a valid channel */
1290 if (sensor.chan < LTC2983_MIN_CHANNELS_NR ||
1291 sensor.chan > LTC2983_MAX_CHANNELS_NR) {
1292 dev_err(dev,
1293 "chan:%d must be from 1 to 20\n", sensor.chan);
1294 return -EINVAL;
1295 } else if (channel_avail_mask & BIT(sensor.chan)) {
1296 dev_err(dev, "chan:%d already in use\n", sensor.chan);
1297 return -EINVAL;
1298 }
1299
1300 ret = of_property_read_u32(child, "adi,sensor-type",
1301 &sensor.type);
1302 if (ret) {
1303 dev_err(dev,
1304 "adi,sensor-type property must given for child nodes\n");
1305 return ret;
1306 }
1307
1308 dev_dbg(dev, "Create new sensor, type %u, chann %u",
1309 sensor.type,
1310 sensor.chan);
1311
1312 if (sensor.type >= LTC2983_SENSOR_THERMOCOUPLE &&
1313 sensor.type <= LTC2983_SENSOR_THERMOCOUPLE_CUSTOM) {
1314 st->sensors[chan] = ltc2983_thermocouple_new(child, st,
1315 &sensor);
1316 } else if (sensor.type >= LTC2983_SENSOR_RTD &&
1317 sensor.type <= LTC2983_SENSOR_RTD_CUSTOM) {
1318 st->sensors[chan] = ltc2983_rtd_new(child, st, &sensor);
1319 } else if (sensor.type >= LTC2983_SENSOR_THERMISTOR &&
1320 sensor.type <= LTC2983_SENSOR_THERMISTOR_CUSTOM) {
1321 st->sensors[chan] = ltc2983_thermistor_new(child, st,
1322 &sensor);
1323 } else if (sensor.type == LTC2983_SENSOR_DIODE) {
1324 st->sensors[chan] = ltc2983_diode_new(child, st,
1325 &sensor);
1326 } else if (sensor.type == LTC2983_SENSOR_SENSE_RESISTOR) {
1327 st->sensors[chan] = ltc2983_r_sense_new(child, st,
1328 &sensor);
1329 /* don't add rsense to iio */
1330 st->iio_channels--;
1331 } else if (sensor.type == LTC2983_SENSOR_DIRECT_ADC) {
1332 st->sensors[chan] = ltc2983_adc_new(child, st, &sensor);
1333 } else {
1334 dev_err(dev, "Unknown sensor type %d\n", sensor.type);
1335 return -EINVAL;
1336 }
1337
1338 if (IS_ERR(st->sensors[chan])) {
1339 dev_err(dev, "Failed to create sensor %ld",
1340 PTR_ERR(st->sensors[chan]));
1341 return PTR_ERR(st->sensors[chan]);
1342 }
1343 /* set generic sensor parameters */
1344 st->sensors[chan]->chan = sensor.chan;
1345 st->sensors[chan]->type = sensor.type;
1346
1347 channel_avail_mask |= BIT(sensor.chan);
1348 chan++;
1349 }
1350
1351 return 0;
1352 }
1353
1354 static int ltc2983_setup(struct ltc2983_data *st, bool assign_iio)
1355 {
1356 u32 iio_chan_t = 0, iio_chan_v = 0, chan, iio_idx = 0;
1357 int ret;
1358 unsigned long time;
1359
1360 /* make sure the device is up */
1361 time = wait_for_completion_timeout(&st->completion,
1362 msecs_to_jiffies(250));
1363
1364 if (!time) {
1365 dev_err(&st->spi->dev, "Device startup timed out\n");
1366 return -ETIMEDOUT;
1367 }
1368
1369 st->iio_chan = devm_kzalloc(&st->spi->dev,
1370 st->iio_channels * sizeof(*st->iio_chan),
1371 GFP_KERNEL);
1372
1373 if (!st->iio_chan)
1374 return -ENOMEM;
1375
1376 ret = regmap_update_bits(st->regmap, LTC2983_GLOBAL_CONFIG_REG,
1377 LTC2983_NOTCH_FREQ_MASK,
1378 LTC2983_NOTCH_FREQ(st->filter_notch_freq));
1379 if (ret)
1380 return ret;
1381
1382 ret = regmap_write(st->regmap, LTC2983_MUX_CONFIG_REG,
1383 st->mux_delay_config);
1384 if (ret)
1385 return ret;
1386
1387 for (chan = 0; chan < st->num_channels; chan++) {
1388 u32 chan_type = 0, *iio_chan;
1389
1390 ret = st->sensors[chan]->assign_chan(st, st->sensors[chan]);
1391 if (ret)
1392 return ret;
1393 /*
1394 * The assign_iio flag is necessary for when the device is
1395 * coming out of sleep. In that case, we just need to
1396 * re-configure the device channels.
1397 * We also don't assign iio channels for rsense.
1398 */
1399 if (st->sensors[chan]->type == LTC2983_SENSOR_SENSE_RESISTOR ||
1400 !assign_iio)
1401 continue;
1402
1403 /* assign iio channel */
1404 if (st->sensors[chan]->type != LTC2983_SENSOR_DIRECT_ADC) {
1405 chan_type = IIO_TEMP;
1406 iio_chan = &iio_chan_t;
1407 } else {
1408 chan_type = IIO_VOLTAGE;
1409 iio_chan = &iio_chan_v;
1410 }
1411
1412 /*
1413 * add chan as the iio .address so that, we can directly
1414 * reference the sensor given the iio_chan_spec
1415 */
1416 st->iio_chan[iio_idx++] = LTC2983_CHAN(chan_type, (*iio_chan)++,
1417 chan);
1418 }
1419
1420 return 0;
1421 }
1422
1423 static const struct regmap_range ltc2983_reg_ranges[] = {
1424 regmap_reg_range(LTC2983_STATUS_REG, LTC2983_STATUS_REG),
1425 regmap_reg_range(LTC2983_TEMP_RES_START_REG, LTC2983_TEMP_RES_END_REG),
1426 regmap_reg_range(LTC2983_GLOBAL_CONFIG_REG, LTC2983_GLOBAL_CONFIG_REG),
1427 regmap_reg_range(LTC2983_MULT_CHANNEL_START_REG,
1428 LTC2983_MULT_CHANNEL_END_REG),
1429 regmap_reg_range(LTC2983_MUX_CONFIG_REG, LTC2983_MUX_CONFIG_REG),
1430 regmap_reg_range(LTC2983_CHAN_ASSIGN_START_REG,
1431 LTC2983_CHAN_ASSIGN_END_REG),
1432 regmap_reg_range(LTC2983_CUST_SENS_TBL_START_REG,
1433 LTC2983_CUST_SENS_TBL_END_REG),
1434 };
1435
1436 static const struct regmap_access_table ltc2983_reg_table = {
1437 .yes_ranges = ltc2983_reg_ranges,
1438 .n_yes_ranges = ARRAY_SIZE(ltc2983_reg_ranges),
1439 };
1440
1441 /*
1442 * The reg_bits are actually 12 but the device needs the first *complete*
1443 * byte for the command (R/W).
1444 */
1445 static const struct regmap_config ltc2983_regmap_config = {
1446 .reg_bits = 24,
1447 .val_bits = 8,
1448 .wr_table = &ltc2983_reg_table,
1449 .rd_table = &ltc2983_reg_table,
1450 .read_flag_mask = GENMASK(1, 0),
1451 .write_flag_mask = BIT(1),
1452 };
1453
1454 static const struct iio_info ltc2983_iio_info = {
1455 .read_raw = ltc2983_read_raw,
1456 .debugfs_reg_access = ltc2983_reg_access,
1457 };
1458
1459 static int ltc2983_probe(struct spi_device *spi)
1460 {
1461 struct ltc2983_data *st;
1462 struct iio_dev *indio_dev;
1463 const char *name = spi_get_device_id(spi)->name;
1464 int ret;
1465
1466 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
1467 if (!indio_dev)
1468 return -ENOMEM;
1469
1470 st = iio_priv(indio_dev);
1471
1472 st->regmap = devm_regmap_init_spi(spi, &ltc2983_regmap_config);
1473 if (IS_ERR(st->regmap)) {
1474 dev_err(&spi->dev, "Failed to initialize regmap\n");
1475 return PTR_ERR(st->regmap);
1476 }
1477
1478 mutex_init(&st->lock);
1479 init_completion(&st->completion);
1480 st->spi = spi;
1481 spi_set_drvdata(spi, st);
1482
1483 ret = ltc2983_parse_dt(st);
1484 if (ret)
1485 return ret;
1486 /*
1487 * let's request the irq now so it is used to sync the device
1488 * startup in ltc2983_setup()
1489 */
1490 ret = devm_request_irq(&spi->dev, spi->irq, ltc2983_irq_handler,
1491 IRQF_TRIGGER_RISING, name, st);
1492 if (ret) {
1493 dev_err(&spi->dev, "failed to request an irq, %d", ret);
1494 return ret;
1495 }
1496
1497 ret = ltc2983_setup(st, true);
1498 if (ret)
1499 return ret;
1500
1501 indio_dev->dev.parent = &spi->dev;
1502 indio_dev->name = name;
1503 indio_dev->num_channels = st->iio_channels;
1504 indio_dev->channels = st->iio_chan;
1505 indio_dev->modes = INDIO_DIRECT_MODE;
1506 indio_dev->info = &ltc2983_iio_info;
1507
1508 return devm_iio_device_register(&spi->dev, indio_dev);
1509 }
1510
1511 static int __maybe_unused ltc2983_resume(struct device *dev)
1512 {
1513 struct ltc2983_data *st = spi_get_drvdata(to_spi_device(dev));
1514 int dummy;
1515
1516 /* dummy read to bring the device out of sleep */
1517 regmap_read(st->regmap, LTC2983_STATUS_REG, &dummy);
1518 /* we need to re-assign the channels */
1519 return ltc2983_setup(st, false);
1520 }
1521
1522 static int __maybe_unused ltc2983_suspend(struct device *dev)
1523 {
1524 struct ltc2983_data *st = spi_get_drvdata(to_spi_device(dev));
1525
1526 return regmap_write(st->regmap, LTC2983_STATUS_REG, LTC2983_SLEEP);
1527 }
1528
1529 static SIMPLE_DEV_PM_OPS(ltc2983_pm_ops, ltc2983_suspend, ltc2983_resume);
1530
1531 static const struct spi_device_id ltc2983_id_table[] = {
1532 { "ltc2983" },
1533 {},
1534 };
1535 MODULE_DEVICE_TABLE(spi, ltc2983_id_table);
1536
1537 static const struct of_device_id ltc2983_of_match[] = {
1538 { .compatible = "adi,ltc2983" },
1539 {},
1540 };
1541 MODULE_DEVICE_TABLE(of, ltc2983_of_match);
1542
1543 static struct spi_driver ltc2983_driver = {
1544 .driver = {
1545 .name = "ltc2983",
1546 .of_match_table = ltc2983_of_match,
1547 .pm = &ltc2983_pm_ops,
1548 },
1549 .probe = ltc2983_probe,
1550 .id_table = ltc2983_id_table,
1551 };
1552
1553 module_spi_driver(ltc2983_driver);
1554
1555 MODULE_AUTHOR("Nuno Sa <nuno.sa@analog.com>");
1556 MODULE_DESCRIPTION("Analog Devices LTC2983 SPI Temperature sensors");
1557 MODULE_LICENSE("GPL");
Linux with added FPC-III support