1 // SPDX-License-Identifier: GPL-2.0
2 /* max31856.c
3  *
4  * Maxim MAX31856 thermocouple sensor driver
5  *
6  * Copyright (C) 2018-2019 Rockwell Collins
7  */
8 
9 #include <linux/ctype.h>
10 #include <linux/mod_devicetable.h>
11 #include <linux/module.h>
12 #include <linux/init.h>
13 #include <linux/err.h>
14 #include <linux/property.h>
15 #include <linux/spi/spi.h>
16 #include <linux/iio/iio.h>
17 #include <linux/iio/sysfs.h>
18 #include <linux/util_macros.h>
19 #include <asm/unaligned.h>
20 #include <dt-bindings/iio/temperature/thermocouple.h>
21 /*
22  * The MSB of the register value determines whether the following byte will
23  * be written or read. If it is 0, one or more byte reads will follow.
24  */
25 #define MAX31856_RD_WR_BIT         BIT(7)
26 
27 #define MAX31856_CR0_AUTOCONVERT   BIT(7)
28 #define MAX31856_CR0_1SHOT         BIT(6)
29 #define MAX31856_CR0_OCFAULT       BIT(4)
30 #define MAX31856_CR0_OCFAULT_MASK  GENMASK(5, 4)
31 #define MAX31856_CR0_FILTER_50HZ   BIT(0)
32 #define MAX31856_AVERAGING_MASK    GENMASK(6, 4)
33 #define MAX31856_AVERAGING_SHIFT   4
34 #define MAX31856_TC_TYPE_MASK      GENMASK(3, 0)
35 #define MAX31856_FAULT_OVUV        BIT(1)
36 #define MAX31856_FAULT_OPEN        BIT(0)
37 
38 /* The MAX31856 registers */
39 #define MAX31856_CR0_REG           0x00
40 #define MAX31856_CR1_REG           0x01
41 #define MAX31856_MASK_REG          0x02
42 #define MAX31856_CJHF_REG          0x03
43 #define MAX31856_CJLF_REG          0x04
44 #define MAX31856_LTHFTH_REG        0x05
45 #define MAX31856_LTHFTL_REG        0x06
46 #define MAX31856_LTLFTH_REG        0x07
47 #define MAX31856_LTLFTL_REG        0x08
48 #define MAX31856_CJTO_REG          0x09
49 #define MAX31856_CJTH_REG          0x0A
50 #define MAX31856_CJTL_REG          0x0B
51 #define MAX31856_LTCBH_REG         0x0C
52 #define MAX31856_LTCBM_REG         0x0D
53 #define MAX31856_LTCBL_REG         0x0E
54 #define MAX31856_SR_REG            0x0F
55 
56 static const struct iio_chan_spec max31856_channels[] = {
57 	{	/* Thermocouple Temperature */
58 		.type = IIO_TEMP,
59 		.info_mask_separate =
60 			BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE) |
61 			BIT(IIO_CHAN_INFO_THERMOCOUPLE_TYPE),
62 		.info_mask_shared_by_type =
63 			BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO)
64 	},
65 	{	/* Cold Junction Temperature */
66 		.type = IIO_TEMP,
67 		.channel2 = IIO_MOD_TEMP_AMBIENT,
68 		.modified = 1,
69 		.info_mask_separate =
70 			BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
71 		.info_mask_shared_by_type =
72 			BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO)
73 	},
74 };
75 
76 struct max31856_data {
77 	struct spi_device *spi;
78 	u32 thermocouple_type;
79 	bool filter_50hz;
80 	int averaging;
81 };
82 
83 static const char max31856_tc_types[] = {
84 	'B', 'E', 'J', 'K', 'N', 'R', 'S', 'T'
85 };
86 
87 static int max31856_read(struct max31856_data *data, u8 reg,
88 			 u8 val[], unsigned int read_size)
89 {
90 	return spi_write_then_read(data->spi, &reg, 1, val, read_size);
91 }
92 
93 static int max31856_write(struct max31856_data *data, u8 reg,
94 			  unsigned int val)
95 {
96 	u8 buf[2];
97 
98 	buf[0] = reg | (MAX31856_RD_WR_BIT);
99 	buf[1] = val;
100 
101 	return spi_write(data->spi, buf, 2);
102 }
103 
104 static int max31856_init(struct max31856_data *data)
105 {
106 	int ret;
107 	u8 reg_cr0_val, reg_cr1_val;
108 
109 	/* Start by changing to Off mode before making changes as
110 	 * some settings are recommended to be set only when the device
111 	 * is off
112 	 */
113 	ret = max31856_read(data, MAX31856_CR0_REG, &reg_cr0_val, 1);
114 	if (ret)
115 		return ret;
116 
117 	reg_cr0_val &= ~MAX31856_CR0_AUTOCONVERT;
118 	ret = max31856_write(data, MAX31856_CR0_REG, reg_cr0_val);
119 	if (ret)
120 		return ret;
121 
122 	/* Set thermocouple type based on dts property */
123 	ret = max31856_read(data, MAX31856_CR1_REG, &reg_cr1_val, 1);
124 	if (ret)
125 		return ret;
126 
127 	reg_cr1_val &= ~MAX31856_TC_TYPE_MASK;
128 	reg_cr1_val |= data->thermocouple_type;
129 
130 	reg_cr1_val &= ~MAX31856_AVERAGING_MASK;
131 	reg_cr1_val |= data->averaging << MAX31856_AVERAGING_SHIFT;
132 
133 	ret = max31856_write(data, MAX31856_CR1_REG, reg_cr1_val);
134 	if (ret)
135 		return ret;
136 
137 	/*
138 	 * Enable Open circuit fault detection
139 	 * Read datasheet for more information: Table 4.
140 	 * Value 01 means : Enabled (Once every 16 conversions)
141 	 */
142 	reg_cr0_val &= ~MAX31856_CR0_OCFAULT_MASK;
143 	reg_cr0_val |= MAX31856_CR0_OCFAULT;
144 
145 	/* Set Auto Conversion Mode */
146 	reg_cr0_val &= ~MAX31856_CR0_1SHOT;
147 	reg_cr0_val |= MAX31856_CR0_AUTOCONVERT;
148 
149 	if (data->filter_50hz)
150 		reg_cr0_val |= MAX31856_CR0_FILTER_50HZ;
151 	else
152 		reg_cr0_val &= ~MAX31856_CR0_FILTER_50HZ;
153 
154 	return max31856_write(data, MAX31856_CR0_REG, reg_cr0_val);
155 }
156 
157 static int max31856_thermocouple_read(struct max31856_data *data,
158 				      struct iio_chan_spec const *chan,
159 				      int *val)
160 {
161 	int ret, offset_cjto;
162 	u8 reg_val[3];
163 
164 	switch (chan->channel2) {
165 	case IIO_NO_MOD:
166 		/*
167 		 * Multibyte Read
168 		 * MAX31856_LTCBH_REG, MAX31856_LTCBM_REG, MAX31856_LTCBL_REG
169 		 */
170 		ret = max31856_read(data, MAX31856_LTCBH_REG, reg_val, 3);
171 		if (ret)
172 			return ret;
173 		/* Skip last 5 dead bits of LTCBL */
174 		*val = get_unaligned_be24(&reg_val[0]) >> 5;
175 		/* Check 7th bit of LTCBH reg. value for sign*/
176 		if (reg_val[0] & 0x80)
177 			*val -= 0x80000;
178 		break;
179 
180 	case IIO_MOD_TEMP_AMBIENT:
181 		/*
182 		 * Multibyte Read
183 		 * MAX31856_CJTO_REG, MAX31856_CJTH_REG, MAX31856_CJTL_REG
184 		 */
185 		ret = max31856_read(data, MAX31856_CJTO_REG, reg_val, 3);
186 		if (ret)
187 			return ret;
188 		/* Get Cold Junction Temp. offset register value */
189 		offset_cjto = reg_val[0];
190 		/* Get CJTH and CJTL value and skip last 2 dead bits of CJTL */
191 		*val = get_unaligned_be16(&reg_val[1]) >> 2;
192 		/* As per datasheet add offset into CJTH and CJTL */
193 		*val += offset_cjto;
194 		/* Check 7th bit of CJTH reg. value for sign */
195 		if (reg_val[1] & 0x80)
196 			*val -= 0x4000;
197 		break;
198 
199 	default:
200 		return -EINVAL;
201 	}
202 
203 	ret = max31856_read(data, MAX31856_SR_REG, reg_val, 1);
204 	if (ret)
205 		return ret;
206 	/* Check for over/under voltage or open circuit fault */
207 	if (reg_val[0] & (MAX31856_FAULT_OVUV | MAX31856_FAULT_OPEN))
208 		return -EIO;
209 
210 	return ret;
211 }
212 
213 static int max31856_read_raw(struct iio_dev *indio_dev,
214 			     struct iio_chan_spec const *chan,
215 			     int *val, int *val2, long mask)
216 {
217 	struct max31856_data *data = iio_priv(indio_dev);
218 	int ret;
219 
220 	switch (mask) {
221 	case IIO_CHAN_INFO_RAW:
222 		ret = max31856_thermocouple_read(data, chan, val);
223 		if (ret)
224 			return ret;
225 		return IIO_VAL_INT;
226 	case IIO_CHAN_INFO_SCALE:
227 		switch (chan->channel2) {
228 		case IIO_MOD_TEMP_AMBIENT:
229 			/* Cold junction Temp. Data resolution is 0.015625 */
230 			*val = 15;
231 			*val2 = 625000; /* 1000 * 0.015625 */
232 			ret = IIO_VAL_INT_PLUS_MICRO;
233 			break;
234 		default:
235 			/* Thermocouple Temp. Data resolution is 0.0078125 */
236 			*val = 7;
237 			*val2 = 812500; /* 1000 * 0.0078125) */
238 			return IIO_VAL_INT_PLUS_MICRO;
239 		}
240 		break;
241 	case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
242 		*val = 1 << data->averaging;
243 		return IIO_VAL_INT;
244 	case IIO_CHAN_INFO_THERMOCOUPLE_TYPE:
245 		*val = max31856_tc_types[data->thermocouple_type];
246 		return IIO_VAL_CHAR;
247 	default:
248 		ret = -EINVAL;
249 		break;
250 	}
251 
252 	return ret;
253 }
254 
255 static int max31856_write_raw_get_fmt(struct iio_dev *indio_dev,
256 				      struct iio_chan_spec const *chan,
257 				      long mask)
258 {
259 	switch (mask) {
260 	case IIO_CHAN_INFO_THERMOCOUPLE_TYPE:
261 		return IIO_VAL_CHAR;
262 	default:
263 		return IIO_VAL_INT;
264 	}
265 }
266 
267 static int max31856_write_raw(struct iio_dev *indio_dev,
268 			      struct iio_chan_spec const *chan,
269 			      int val, int val2, long mask)
270 {
271 	struct max31856_data *data = iio_priv(indio_dev);
272 	int msb;
273 
274 	switch (mask) {
275 	case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
276 		if (val > 16 || val < 1)
277 			return -EINVAL;
278 		msb = fls(val) - 1;
279 		/* Round up to next 2pow if needed */
280 		if (BIT(msb) < val)
281 			msb++;
282 
283 		data->averaging = msb;
284 		max31856_init(data);
285 		break;
286 	case IIO_CHAN_INFO_THERMOCOUPLE_TYPE:
287 	{
288 		int tc_type = -1;
289 		int i;
290 
291 		for (i = 0; i < ARRAY_SIZE(max31856_tc_types); i++) {
292 			if (max31856_tc_types[i] == toupper(val)) {
293 				tc_type = i;
294 				break;
295 			}
296 		}
297 		if (tc_type < 0)
298 			return -EINVAL;
299 
300 		data->thermocouple_type = tc_type;
301 		max31856_init(data);
302 		break;
303 	}
304 	default:
305 		return -EINVAL;
306 	}
307 
308 	return 0;
309 }
310 
311 static ssize_t show_fault(struct device *dev, u8 faultbit, char *buf)
312 {
313 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
314 	struct max31856_data *data = iio_priv(indio_dev);
315 	u8 reg_val;
316 	int ret;
317 	bool fault;
318 
319 	ret = max31856_read(data, MAX31856_SR_REG, &reg_val, 1);
320 	if (ret)
321 		return ret;
322 
323 	fault = reg_val & faultbit;
324 
325 	return sysfs_emit(buf, "%d\n", fault);
326 }
327 
328 static ssize_t show_fault_ovuv(struct device *dev,
329 			       struct device_attribute *attr,
330 			       char *buf)
331 {
332 	return show_fault(dev, MAX31856_FAULT_OVUV, buf);
333 }
334 
335 static ssize_t show_fault_oc(struct device *dev,
336 			     struct device_attribute *attr,
337 			     char *buf)
338 {
339 	return show_fault(dev, MAX31856_FAULT_OPEN, buf);
340 }
341 
342 static ssize_t show_filter(struct device *dev,
343 			   struct device_attribute *attr,
344 			   char *buf)
345 {
346 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
347 	struct max31856_data *data = iio_priv(indio_dev);
348 
349 	return sysfs_emit(buf, "%d\n", data->filter_50hz ? 50 : 60);
350 }
351 
352 static ssize_t set_filter(struct device *dev,
353 			  struct device_attribute *attr,
354 			  const char *buf,
355 			  size_t len)
356 {
357 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
358 	struct max31856_data *data = iio_priv(indio_dev);
359 	unsigned int freq;
360 	int ret;
361 
362 	ret = kstrtouint(buf, 10, &freq);
363 	if (ret)
364 		return ret;
365 
366 	switch (freq) {
367 	case 50:
368 		data->filter_50hz = true;
369 		break;
370 	case 60:
371 		data->filter_50hz = false;
372 		break;
373 	default:
374 		return -EINVAL;
375 	}
376 
377 	max31856_init(data);
378 	return len;
379 }
380 
381 static IIO_DEVICE_ATTR(fault_ovuv, 0444, show_fault_ovuv, NULL, 0);
382 static IIO_DEVICE_ATTR(fault_oc, 0444, show_fault_oc, NULL, 0);
383 static IIO_DEVICE_ATTR(in_temp_filter_notch_center_frequency, 0644,
384 		       show_filter, set_filter, 0);
385 
386 static struct attribute *max31856_attributes[] = {
387 	&iio_dev_attr_fault_ovuv.dev_attr.attr,
388 	&iio_dev_attr_fault_oc.dev_attr.attr,
389 	&iio_dev_attr_in_temp_filter_notch_center_frequency.dev_attr.attr,
390 	NULL,
391 };
392 
393 static const struct attribute_group max31856_group = {
394 	.attrs = max31856_attributes,
395 };
396 
397 static const struct iio_info max31856_info = {
398 	.read_raw = max31856_read_raw,
399 	.write_raw = max31856_write_raw,
400 	.write_raw_get_fmt = max31856_write_raw_get_fmt,
401 	.attrs = &max31856_group,
402 };
403 
404 static int max31856_probe(struct spi_device *spi)
405 {
406 	const struct spi_device_id *id = spi_get_device_id(spi);
407 	struct iio_dev *indio_dev;
408 	struct max31856_data *data;
409 	int ret;
410 
411 	indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*data));
412 	if (!indio_dev)
413 		return -ENOMEM;
414 
415 	data = iio_priv(indio_dev);
416 	data->spi = spi;
417 	data->filter_50hz = false;
418 
419 	spi_set_drvdata(spi, indio_dev);
420 
421 	indio_dev->info = &max31856_info;
422 	indio_dev->name = id->name;
423 	indio_dev->modes = INDIO_DIRECT_MODE;
424 	indio_dev->channels = max31856_channels;
425 	indio_dev->num_channels = ARRAY_SIZE(max31856_channels);
426 
427 	ret = device_property_read_u32(&spi->dev, "thermocouple-type", &data->thermocouple_type);
428 	if (ret) {
429 		dev_info(&spi->dev,
430 			 "Could not read thermocouple type DT property, configuring as a K-Type\n");
431 		data->thermocouple_type = THERMOCOUPLE_TYPE_K;
432 	}
433 
434 	/*
435 	 * no need to translate values as the supported types
436 	 * have the same value as the #defines
437 	 */
438 	switch (data->thermocouple_type) {
439 	case THERMOCOUPLE_TYPE_B:
440 	case THERMOCOUPLE_TYPE_E:
441 	case THERMOCOUPLE_TYPE_J:
442 	case THERMOCOUPLE_TYPE_K:
443 	case THERMOCOUPLE_TYPE_N:
444 	case THERMOCOUPLE_TYPE_R:
445 	case THERMOCOUPLE_TYPE_S:
446 	case THERMOCOUPLE_TYPE_T:
447 		break;
448 	default:
449 		dev_err(&spi->dev,
450 			"error: thermocouple-type %u not supported by max31856\n"
451 			, data->thermocouple_type);
452 		return -EINVAL;
453 	}
454 
455 	ret = max31856_init(data);
456 	if (ret) {
457 		dev_err(&spi->dev, "error: Failed to configure max31856\n");
458 		return ret;
459 	}
460 
461 	return devm_iio_device_register(&spi->dev, indio_dev);
462 }
463 
464 static const struct spi_device_id max31856_id[] = {
465 	{ "max31856", 0 },
466 	{ }
467 };
468 MODULE_DEVICE_TABLE(spi, max31856_id);
469 
470 static const struct of_device_id max31856_of_match[] = {
471 	{ .compatible = "maxim,max31856" },
472 	{ }
473 };
474 MODULE_DEVICE_TABLE(of, max31856_of_match);
475 
476 static struct spi_driver max31856_driver = {
477 	.driver = {
478 		.name = "max31856",
479 		.of_match_table = max31856_of_match,
480 	},
481 	.probe = max31856_probe,
482 	.id_table = max31856_id,
483 };
484 module_spi_driver(max31856_driver);
485 
486 MODULE_AUTHOR("Paresh Chaudhary <paresh.chaudhary@rockwellcollins.com>");
487 MODULE_AUTHOR("Patrick Havelange <patrick.havelange@essensium.com>");
488 MODULE_DESCRIPTION("Maxim MAX31856 thermocouple sensor driver");
489 MODULE_LICENSE("GPL");
490