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