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