[linux-2.6-block.git] / drivers / iio / temperature / max31856.c

// SPDX-License-Identifier: GPL-2.0
/* max31856.c
 *
 * Maxim MAX31856 thermocouple sensor driver
 *
 * Copyright (C) 2018-2019 Rockwell Collins
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/spi/spi.h>
#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>
#include <dt-bindings/iio/temperature/thermocouple.h>
/*
 * The MSB of the register value determines whether the following byte will
 * be written or read. If it is 0, one or more byte reads will follow.
 */
#define MAX31856_RD_WR_BIT         BIT(7)

#define MAX31856_CR0_AUTOCONVERT   BIT(7)
#define MAX31856_CR0_1SHOT         BIT(6)
#define MAX31856_CR0_OCFAULT       BIT(4)
#define MAX31856_CR0_OCFAULT_MASK  GENMASK(5, 4)
#define MAX31856_TC_TYPE_MASK      GENMASK(3, 0)
#define MAX31856_FAULT_OVUV        BIT(1)
#define MAX31856_FAULT_OPEN        BIT(0)

/* The MAX31856 registers */
#define MAX31856_CR0_REG           0x00
#define MAX31856_CR1_REG           0x01
#define MAX31856_MASK_REG          0x02
#define MAX31856_CJHF_REG          0x03
#define MAX31856_CJLF_REG          0x04
#define MAX31856_LTHFTH_REG        0x05
#define MAX31856_LTHFTL_REG        0x06
#define MAX31856_LTLFTH_REG        0x07
#define MAX31856_LTLFTL_REG        0x08
#define MAX31856_CJTO_REG          0x09
#define MAX31856_CJTH_REG          0x0A
#define MAX31856_CJTL_REG          0x0B
#define MAX31856_LTCBH_REG         0x0C
#define MAX31856_LTCBM_REG         0x0D
#define MAX31856_LTCBL_REG         0x0E
#define MAX31856_SR_REG            0x0F

static const struct iio_chan_spec max31856_channels[] = {
	{	/* Thermocouple Temperature */
		.type = IIO_TEMP,
		.info_mask_separate =
			BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
	},
	{	/* Cold Junction Temperature */
		.type = IIO_TEMP,
		.channel2 = IIO_MOD_TEMP_AMBIENT,
		.modified = 1,
		.info_mask_separate =
			BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
	},
};

struct max31856_data {
	struct spi_device *spi;
	u32 thermocouple_type;
};

static int max31856_read(struct max31856_data *data, u8 reg,
			 u8 val[], unsigned int read_size)
{
	return spi_write_then_read(data->spi, &reg, 1, val, read_size);
}

static int max31856_write(struct max31856_data *data, u8 reg,
			  unsigned int val)
{
	u8 buf[2];

	buf[0] = reg | (MAX31856_RD_WR_BIT);
	buf[1] = val;

	return spi_write(data->spi, buf, 2);
}

static int max31856_init(struct max31856_data *data)
{
	int ret;
	u8 reg_cr0_val, reg_cr1_val;

	/* Start by changing to Off mode before making changes as
	 * some settings are recommended to be set only when the device
	 * is off
	 */
	ret = max31856_read(data, MAX31856_CR0_REG, &reg_cr0_val, 1);
	if (ret)
		return ret;

	reg_cr0_val &= ~MAX31856_CR0_AUTOCONVERT;
	ret = max31856_write(data, MAX31856_CR0_REG, reg_cr0_val);
	if (ret)
		return ret;

	/* Set thermocouple type based on dts property */
	ret = max31856_read(data, MAX31856_CR1_REG, &reg_cr1_val, 1);
	if (ret)
		return ret;

	reg_cr1_val &= ~MAX31856_TC_TYPE_MASK;
	reg_cr1_val |= data->thermocouple_type;
	ret = max31856_write(data, MAX31856_CR1_REG, reg_cr1_val);
	if (ret)
		return ret;

	/*
	 * Enable Open circuit fault detection
	 * Read datasheet for more information: Table 4.
	 * Value 01 means : Enabled (Once every 16 conversions)
	 */
	reg_cr0_val &= ~MAX31856_CR0_OCFAULT_MASK;
	reg_cr0_val |= MAX31856_CR0_OCFAULT;

	/* Set Auto Conversion Mode */
	reg_cr0_val &= ~MAX31856_CR0_1SHOT;
	reg_cr0_val |= MAX31856_CR0_AUTOCONVERT;

	return max31856_write(data, MAX31856_CR0_REG, reg_cr0_val);
}

static int max31856_thermocouple_read(struct max31856_data *data,
				      struct iio_chan_spec const *chan,
				      int *val)
{
	int ret, offset_cjto;
	u8 reg_val[3];

	switch (chan->channel2) {
	case IIO_NO_MOD:
		/*
		 * Multibyte Read
		 * MAX31856_LTCBH_REG, MAX31856_LTCBM_REG, MAX31856_LTCBL_REG
		 */
		ret = max31856_read(data, MAX31856_LTCBH_REG, reg_val, 3);
		if (ret)
			return ret;
		/* Skip last 5 dead bits of LTCBL */
		*val = (reg_val[0] << 16 | reg_val[1] << 8 | reg_val[2]) >> 5;
		/* Check 7th bit of LTCBH reg. value for sign*/
		if (reg_val[0] & 0x80)
			*val -= 0x80000;
		break;

	case IIO_MOD_TEMP_AMBIENT:
		/*
		 * Multibyte Read
		 * MAX31856_CJTO_REG, MAX31856_CJTH_REG, MAX31856_CJTL_REG
		 */
		ret = max31856_read(data, MAX31856_CJTO_REG, reg_val, 3);
		if (ret)
			return ret;
		/* Get Cold Junction Temp. offset register value */
		offset_cjto = reg_val[0];
		/* Get CJTH and CJTL value and skip last 2 dead bits of CJTL */
		*val = (reg_val[1] << 8 | reg_val[2]) >> 2;
		/* As per datasheet add offset into CJTH and CJTL */
		*val += offset_cjto;
		/* Check 7th bit of CJTH reg. value for sign */
		if (reg_val[1] & 0x80)
			*val -= 0x4000;
		break;

	default:
		return -EINVAL;
	}

	ret = max31856_read(data, MAX31856_SR_REG, reg_val, 1);
	if (ret)
		return ret;
	/* Check for over/under voltage or open circuit fault */
	if (reg_val[0] & (MAX31856_FAULT_OVUV | MAX31856_FAULT_OPEN))
		return -EIO;

	return ret;
}

static int max31856_read_raw(struct iio_dev *indio_dev,
			     struct iio_chan_spec const *chan,
			     int *val, int *val2, long mask)
{
	struct max31856_data *data = iio_priv(indio_dev);
	int ret;

	switch (mask) {
	case IIO_CHAN_INFO_RAW:
		ret = max31856_thermocouple_read(data, chan, val);
		if (ret)
			return ret;
		return IIO_VAL_INT;
	case IIO_CHAN_INFO_SCALE:
		switch (chan->channel2) {
		case IIO_MOD_TEMP_AMBIENT:
			/* Cold junction Temp. Data resolution is 0.015625 */
			*val = 15;
			*val2 = 625000; /* 1000 * 0.015625 */
			ret = IIO_VAL_INT_PLUS_MICRO;
			break;
		default:
			/* Thermocouple Temp. Data resolution is 0.0078125 */
			*val = 7;
			*val2 = 812500; /* 1000 * 0.0078125) */
			return IIO_VAL_INT_PLUS_MICRO;
		}
		break;
	}

	return ret;
}

static ssize_t show_fault(struct device *dev, u8 faultbit, char *buf)
{
	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
	struct max31856_data *data = iio_priv(indio_dev);
	u8 reg_val;
	int ret;
	bool fault;

	ret = max31856_read(data, MAX31856_SR_REG, &reg_val, 1);
	if (ret)
		return ret;

	fault = reg_val & faultbit;

	return sprintf(buf, "%d\n", fault);
}

static ssize_t show_fault_ovuv(struct device *dev,
			       struct device_attribute *attr,
			       char *buf)
{
	return show_fault(dev, MAX31856_FAULT_OVUV, buf);
}

static ssize_t show_fault_oc(struct device *dev,
			     struct device_attribute *attr,
			     char *buf)
{
	return show_fault(dev, MAX31856_FAULT_OPEN, buf);
}

static IIO_DEVICE_ATTR(fault_ovuv, 0444, show_fault_ovuv, NULL, 0);
static IIO_DEVICE_ATTR(fault_oc, 0444, show_fault_oc, NULL, 0);

static struct attribute *max31856_attributes[] = {
	&iio_dev_attr_fault_ovuv.dev_attr.attr,
	&iio_dev_attr_fault_oc.dev_attr.attr,
	NULL,
};

static const struct attribute_group max31856_group = {
	.attrs = max31856_attributes,
};

static const struct iio_info max31856_info = {
	.read_raw = max31856_read_raw,
	.attrs = &max31856_group,
};

static int max31856_probe(struct spi_device *spi)
{
	const struct spi_device_id *id = spi_get_device_id(spi);
	struct iio_dev *indio_dev;
	struct max31856_data *data;
	int ret;

	indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*data));
	if (!indio_dev)
		return -ENOMEM;

	data = iio_priv(indio_dev);
	data->spi = spi;

	spi_set_drvdata(spi, indio_dev);

	indio_dev->info = &max31856_info;
	indio_dev->name = id->name;
	indio_dev->modes = INDIO_DIRECT_MODE;
	indio_dev->channels = max31856_channels;
	indio_dev->num_channels = ARRAY_SIZE(max31856_channels);

	ret = of_property_read_u32(spi->dev.of_node, "thermocouple-type",
				   &data->thermocouple_type);

	if (ret) {
		dev_info(&spi->dev,
			 "Could not read thermocouple type DT property, configuring as a K-Type\n");
		data->thermocouple_type = THERMOCOUPLE_TYPE_K;
	}

	/*
	 * no need to translate values as the supported types
	 * have the same value as the #defines
	 */
	switch (data->thermocouple_type) {
	case THERMOCOUPLE_TYPE_B:
	case THERMOCOUPLE_TYPE_E:
	case THERMOCOUPLE_TYPE_J:
	case THERMOCOUPLE_TYPE_K:
	case THERMOCOUPLE_TYPE_N:
	case THERMOCOUPLE_TYPE_R:
	case THERMOCOUPLE_TYPE_S:
	case THERMOCOUPLE_TYPE_T:
		break;
	default:
		dev_err(&spi->dev,
			"error: thermocouple-type %u not supported by max31856\n"
			, data->thermocouple_type);
		return -EINVAL;
	}

	ret = max31856_init(data);
	if (ret) {
		dev_err(&spi->dev, "error: Failed to configure max31856\n");
		return ret;
	}

	return devm_iio_device_register(&spi->dev, indio_dev);
}

static const struct spi_device_id max31856_id[] = {
	{ "max31856", 0 },
	{ }
};
MODULE_DEVICE_TABLE(spi, max31856_id);

static const struct of_device_id max31856_of_match[] = {
	{ .compatible = "maxim,max31856" },
	{ }
};
MODULE_DEVICE_TABLE(of, max31856_of_match);

static struct spi_driver max31856_driver = {
	.driver = {
		.name = "max31856",
		.of_match_table = max31856_of_match,
	},
	.probe = max31856_probe,
	.id_table = max31856_id,
};
module_spi_driver(max31856_driver);

MODULE_AUTHOR("Paresh Chaudhary <paresh.chaudhary@rockwellcollins.com>");
MODULE_AUTHOR("Patrick Havelange <patrick.havelange@essensium.com>");
MODULE_DESCRIPTION("Maxim MAX31856 thermocouple sensor driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
fb55a513 PC	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/module.h>
	10	#include <linux/init.h>
	11	#include <linux/err.h>
	12	#include <linux/spi/spi.h>
	13	#include <linux/iio/iio.h>
	14	#include <linux/iio/sysfs.h>
	15	#include <dt-bindings/iio/temperature/thermocouple.h>
	16	/*
	17	* The MSB of the register value determines whether the following byte will
	18	* be written or read. If it is 0, one or more byte reads will follow.
	19	*/
	20	#define MAX31856_RD_WR_BIT BIT(7)
	21
	22	#define MAX31856_CR0_AUTOCONVERT BIT(7)
	23	#define MAX31856_CR0_1SHOT BIT(6)
	24	#define MAX31856_CR0_OCFAULT BIT(4)
	25	#define MAX31856_CR0_OCFAULT_MASK GENMASK(5, 4)
	26	#define MAX31856_TC_TYPE_MASK GENMASK(3, 0)
	27	#define MAX31856_FAULT_OVUV BIT(1)
	28	#define MAX31856_FAULT_OPEN BIT(0)
	29
	30	/* The MAX31856 registers */
	31	#define MAX31856_CR0_REG 0x00
	32	#define MAX31856_CR1_REG 0x01
	33	#define MAX31856_MASK_REG 0x02
	34	#define MAX31856_CJHF_REG 0x03
	35	#define MAX31856_CJLF_REG 0x04
	36	#define MAX31856_LTHFTH_REG 0x05
	37	#define MAX31856_LTHFTL_REG 0x06
	38	#define MAX31856_LTLFTH_REG 0x07
	39	#define MAX31856_LTLFTL_REG 0x08
	40	#define MAX31856_CJTO_REG 0x09
	41	#define MAX31856_CJTH_REG 0x0A
	42	#define MAX31856_CJTL_REG 0x0B
	43	#define MAX31856_LTCBH_REG 0x0C
	44	#define MAX31856_LTCBM_REG 0x0D
	45	#define MAX31856_LTCBL_REG 0x0E
	46	#define MAX31856_SR_REG 0x0F
	47
	48	static const struct iio_chan_spec max31856_channels[] = {
	49	{ /* Thermocouple Temperature */
	50	.type = IIO_TEMP,
	51	.info_mask_separate =
	52	BIT(IIO_CHAN_INFO_RAW) \| BIT(IIO_CHAN_INFO_SCALE),
	53	},
	54	{ /* Cold Junction Temperature */
	55	.type = IIO_TEMP,
	56	.channel2 = IIO_MOD_TEMP_AMBIENT,
	57	.modified = 1,
	58	.info_mask_separate =
	59	BIT(IIO_CHAN_INFO_RAW) \| BIT(IIO_CHAN_INFO_SCALE),
	60	},
	61	};
	62
	63	struct max31856_data {
	64	struct spi_device *spi;
65	u32 thermocouple_type;
66	};
67
68	static int max31856_read(struct max31856_data *data, u8 reg,
69	u8 val[], unsigned int read_size)
70	{
71	return spi_write_then_read(data->spi, &reg, 1, val, read_size);
72	}
73
74	static int max31856_write(struct max31856_data *data, u8 reg,
75	unsigned int val)
76	{
77	u8 buf[2];
78
79	buf[0] = reg \| (MAX31856_RD_WR_BIT);
80	buf[1] = val;
81
82	return spi_write(data->spi, buf, 2);
83	}
84
85	static int max31856_init(struct max31856_data *data)
86	{
87	int ret;
88	u8 reg_cr0_val, reg_cr1_val;
89
90	/* Start by changing to Off mode before making changes as
91	* some settings are recommended to be set only when the device
92	* is off
93	*/
94	ret = max31856_read(data, MAX31856_CR0_REG, &reg_cr0_val, 1);
95	if (ret)
96	return ret;
97
98	reg_cr0_val &= ~MAX31856_CR0_AUTOCONVERT;
99	ret = max31856_write(data, MAX31856_CR0_REG, reg_cr0_val);
100	if (ret)
101	return ret;
102
103	/* Set thermocouple type based on dts property */
104	ret = max31856_read(data, MAX31856_CR1_REG, &reg_cr1_val, 1);
105	if (ret)
106	return ret;
107
108	reg_cr1_val &= ~MAX31856_TC_TYPE_MASK;
109	reg_cr1_val \|= data->thermocouple_type;
110	ret = max31856_write(data, MAX31856_CR1_REG, reg_cr1_val);
111	if (ret)
112	return ret;
113
114	/*
115	* Enable Open circuit fault detection
116	* Read datasheet for more information: Table 4.
117	* Value 01 means : Enabled (Once every 16 conversions)
118	*/
119	reg_cr0_val &= ~MAX31856_CR0_OCFAULT_MASK;
120	reg_cr0_val \|= MAX31856_CR0_OCFAULT;
121
122	/* Set Auto Conversion Mode */
123	reg_cr0_val &= ~MAX31856_CR0_1SHOT;
124	reg_cr0_val \|= MAX31856_CR0_AUTOCONVERT;
125
126	return max31856_write(data, MAX31856_CR0_REG, reg_cr0_val);
127	}
128
129	static int max31856_thermocouple_read(struct max31856_data *data,
130	struct iio_chan_spec const *chan,
131	int *val)
132	{
133	int ret, offset_cjto;
134	u8 reg_val[3];
135
136	switch (chan->channel2) {
137	case IIO_NO_MOD:
138	/*
139	* Multibyte Read
140	* MAX31856_LTCBH_REG, MAX31856_LTCBM_REG, MAX31856_LTCBL_REG
141	*/
142	ret = max31856_read(data, MAX31856_LTCBH_REG, reg_val, 3);
143	if (ret)
144	return ret;
145	/* Skip last 5 dead bits of LTCBL */
146	*val = (reg_val[0] << 16 \| reg_val[1] << 8 \| reg_val[2]) >> 5;
147	/* Check 7th bit of LTCBH reg. value for sign*/
148	if (reg_val[0] & 0x80)
149	*val -= 0x80000;
150	break;
151
152	case IIO_MOD_TEMP_AMBIENT:
153	/*
154	* Multibyte Read
155	* MAX31856_CJTO_REG, MAX31856_CJTH_REG, MAX31856_CJTL_REG
156	*/
157	ret = max31856_read(data, MAX31856_CJTO_REG, reg_val, 3);
158	if (ret)
159	return ret;
160	/* Get Cold Junction Temp. offset register value */
161	offset_cjto = reg_val[0];
162	/* Get CJTH and CJTL value and skip last 2 dead bits of CJTL */
163	*val = (reg_val[1] << 8 \| reg_val[2]) >> 2;
164	/* As per datasheet add offset into CJTH and CJTL */
165	*val += offset_cjto;
166	/* Check 7th bit of CJTH reg. value for sign */
167	if (reg_val[1] & 0x80)
168	*val -= 0x4000;
169	break;
170
171	default:
172	return -EINVAL;
173	}
174
175	ret = max31856_read(data, MAX31856_SR_REG, reg_val, 1);
176	if (ret)
177	return ret;
178	/* Check for over/under voltage or open circuit fault */
179	if (reg_val[0] & (MAX31856_FAULT_OVUV \| MAX31856_FAULT_OPEN))
180	return -EIO;
181
182	return ret;
183	}
184
185	static int max31856_read_raw(struct iio_dev *indio_dev,
186	struct iio_chan_spec const *chan,
187	int val, int val2, long mask)
188	{
189	struct max31856_data *data = iio_priv(indio_dev);
190	int ret;
191
192	switch (mask) {
193	case IIO_CHAN_INFO_RAW:
194	ret = max31856_thermocouple_read(data, chan, val);
195	if (ret)
196	return ret;
197	return IIO_VAL_INT;
198	case IIO_CHAN_INFO_SCALE:
199	switch (chan->channel2) {
200	case IIO_MOD_TEMP_AMBIENT:
201	/* Cold junction Temp. Data resolution is 0.015625 */
202	*val = 15;
203	val2 = 625000; / 1000 * 0.015625 */
204	ret = IIO_VAL_INT_PLUS_MICRO;
205	break;
206	default:
207	/* Thermocouple Temp. Data resolution is 0.0078125 */
208	*val = 7;
209	val2 = 812500; / 1000 * 0.0078125) */
210	return IIO_VAL_INT_PLUS_MICRO;
211	}
212	break;
213	}
214
215	return ret;
216	}
217
218	static ssize_t show_fault(struct device dev, u8 faultbit, char buf)
219	{
220	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
221	struct max31856_data *data = iio_priv(indio_dev);
222	u8 reg_val;
223	int ret;
224	bool fault;
225
226	ret = max31856_read(data, MAX31856_SR_REG, &reg_val, 1);
227	if (ret)
228	return ret;
229
230	fault = reg_val & faultbit;
231
232	return sprintf(buf, "%d\n", fault);
233	}
234
235	static ssize_t show_fault_ovuv(struct device *dev,
236	struct device_attribute *attr,
237	char *buf)
238	{
239	return show_fault(dev, MAX31856_FAULT_OVUV, buf);
240	}
241
242	static ssize_t show_fault_oc(struct device *dev,
243	struct device_attribute *attr,
244	char *buf)
245	{
246	return show_fault(dev, MAX31856_FAULT_OPEN, buf);
247	}
248
249	static IIO_DEVICE_ATTR(fault_ovuv, 0444, show_fault_ovuv, NULL, 0);
250	static IIO_DEVICE_ATTR(fault_oc, 0444, show_fault_oc, NULL, 0);
251
252	static struct attribute *max31856_attributes[] = {
253	&iio_dev_attr_fault_ovuv.dev_attr.attr,
254	&iio_dev_attr_fault_oc.dev_attr.attr,
255	NULL,
256	};
257
258	static const struct attribute_group max31856_group = {
259	.attrs = max31856_attributes,
260	};
261
262	static const struct iio_info max31856_info = {
263	.read_raw = max31856_read_raw,
264	.attrs = &max31856_group,
265	};
266
267	static int max31856_probe(struct spi_device *spi)
268	{
269	const struct spi_device_id *id = spi_get_device_id(spi);
270	struct iio_dev *indio_dev;
271	struct max31856_data *data;
272	int ret;
273
274	indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*data));
275	if (!indio_dev)
276	return -ENOMEM;
277
278	data = iio_priv(indio_dev);
279	data->spi = spi;
280
281	spi_set_drvdata(spi, indio_dev);
282
283	indio_dev->info = &max31856_info;
284	indio_dev->name = id->name;
285	indio_dev->modes = INDIO_DIRECT_MODE;
286	indio_dev->channels = max31856_channels;
287	indio_dev->num_channels = ARRAY_SIZE(max31856_channels);
288
289	ret = of_property_read_u32(spi->dev.of_node, "thermocouple-type",
290	&data->thermocouple_type);
291
292	if (ret) {
293	dev_info(&spi->dev,
294	"Could not read thermocouple type DT property, configuring as a K-Type\n");
295	data->thermocouple_type = THERMOCOUPLE_TYPE_K;
296	}
297
298	/*
299	* no need to translate values as the supported types
300	* have the same value as the #defines
301	*/
302	switch (data->thermocouple_type) {
303	case THERMOCOUPLE_TYPE_B:
304	case THERMOCOUPLE_TYPE_E:
305	case THERMOCOUPLE_TYPE_J:
306	case THERMOCOUPLE_TYPE_K:
307	case THERMOCOUPLE_TYPE_N:
308	case THERMOCOUPLE_TYPE_R:
309	case THERMOCOUPLE_TYPE_S:
310	case THERMOCOUPLE_TYPE_T:
311	break;
312	default:
313	dev_err(&spi->dev,
314	"error: thermocouple-type %u not supported by max31856\n"
315	, data->thermocouple_type);
316	return -EINVAL;
317	}
318
319	ret = max31856_init(data);
320	if (ret) {
321	dev_err(&spi->dev, "error: Failed to configure max31856\n");
322	return ret;
323	}
324
325	return devm_iio_device_register(&spi->dev, indio_dev);
326	}
327
328	static const struct spi_device_id max31856_id[] = {
329	{ "max31856", 0 },
330	{ }
331	};
332	MODULE_DEVICE_TABLE(spi, max31856_id);
333
334	static const struct of_device_id max31856_of_match[] = {
335	{ .compatible = "maxim,max31856" },
336	{ }
337	};
338	MODULE_DEVICE_TABLE(of, max31856_of_match);
339
340	static struct spi_driver max31856_driver = {
341	.driver = {
342	.name = "max31856",
343	.of_match_table = max31856_of_match,
344	},
345	.probe = max31856_probe,
346	.id_table = max31856_id,
347	};
348	module_spi_driver(max31856_driver);
349
350	MODULE_AUTHOR("Paresh Chaudhary <paresh.chaudhary@rockwellcollins.com>");
351	MODULE_AUTHOR("Patrick Havelange <patrick.havelange@essensium.com>");
352	MODULE_DESCRIPTION("Maxim MAX31856 thermocouple sensor driver");
353	MODULE_LICENSE("GPL");