drivers/iio/temperature/max31856.c - linux - Git at Google

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

 #include <linux/ctype.h>
 #include <linux/mod_devicetable.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/err.h>
 #include <linux/property.h>
 #include <linux/spi/spi.h>
 #include <linux/iio/iio.h>
 #include <linux/iio/sysfs.h>
 #include <linux/util_macros.h>
 #include <asm/unaligned.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_CR0_FILTER_50HZ   BIT(0)
 #define MAX31856_AVERAGING_MASK    GENMASK(6, 4)
 #define MAX31856_AVERAGING_SHIFT   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) |
 			BIT(IIO_CHAN_INFO_THERMOCOUPLE_TYPE),
 		.info_mask_shared_by_type =
 			BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO)
 	},
 	{	/* 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),
 		.info_mask_shared_by_type =
 			BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO)
 	},
 };

 struct max31856_data {
 	struct spi_device *spi;
 	u32 thermocouple_type;
 	bool filter_50hz;
 	int averaging;
 };

 static const char max31856_tc_types[] = {
 	'B', 'E', 'J', 'K', 'N', 'R', 'S', 'T'
 };

 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;

 	reg_cr1_val &= ~MAX31856_AVERAGING_MASK;
 	reg_cr1_val |= data->averaging << MAX31856_AVERAGING_SHIFT;

 	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;

 	if (data->filter_50hz)
 		reg_cr0_val |= MAX31856_CR0_FILTER_50HZ;
 	else
 		reg_cr0_val &= ~MAX31856_CR0_FILTER_50HZ;

 	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 = get_unaligned_be24(&reg_val[0]) >> 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 = get_unaligned_be16(&reg_val[1]) >> 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;
 	case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
 		*val = 1 << data->averaging;
 		return IIO_VAL_INT;
 	case IIO_CHAN_INFO_THERMOCOUPLE_TYPE:
 		*val = max31856_tc_types[data->thermocouple_type];
 		return IIO_VAL_CHAR;
 	default:
 		ret = -EINVAL;
 		break;
 	}

 	return ret;
 }

 static int max31856_write_raw_get_fmt(struct iio_dev *indio_dev,
 				      struct iio_chan_spec const *chan,
 				      long mask)
 {
 	switch (mask) {
 	case IIO_CHAN_INFO_THERMOCOUPLE_TYPE:
 		return IIO_VAL_CHAR;
 	default:
 		return IIO_VAL_INT;
 	}
 }

 static int max31856_write_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 msb;

 	switch (mask) {
 	case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
 		if (val > 16 || val < 1)
 			return -EINVAL;
 		msb = fls(val) - 1;
 		/* Round up to next 2pow if needed */
 		if (BIT(msb) < val)
 			msb++;

 		data->averaging = msb;
 		max31856_init(data);
 		break;
 	case IIO_CHAN_INFO_THERMOCOUPLE_TYPE:
 	{
 		int tc_type = -1;
 		int i;

 		for (i = 0; i < ARRAY_SIZE(max31856_tc_types); i++) {
 			if (max31856_tc_types[i] == toupper(val)) {
 				tc_type = i;
 				break;
 			}
 		}
 		if (tc_type < 0)
 			return -EINVAL;

 		data->thermocouple_type = tc_type;
 		max31856_init(data);
 		break;
 	}
 	default:
 		return -EINVAL;
 	}

 	return 0;
 }

 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 sysfs_emit(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 ssize_t show_filter(struct device *dev,
 			   struct device_attribute *attr,
 			   char *buf)
 {
 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 	struct max31856_data *data = iio_priv(indio_dev);

 	return sysfs_emit(buf, "%d\n", data->filter_50hz ? 50 : 60);
 }

 static ssize_t set_filter(struct device *dev,
 			  struct device_attribute *attr,
 			  const char *buf,
 			  size_t len)
 {
 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 	struct max31856_data *data = iio_priv(indio_dev);
 	unsigned int freq;
 	int ret;

 	ret = kstrtouint(buf, 10, &freq);
 	if (ret)
 		return ret;

 	switch (freq) {
 	case 50:
 		data->filter_50hz = true;
 		break;
 	case 60:
 		data->filter_50hz = false;
 		break;
 	default:
 		return -EINVAL;
 	}

 	max31856_init(data);
 	return len;
 }

 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 IIO_DEVICE_ATTR(in_temp_filter_notch_center_frequency, 0644,
 		       show_filter, set_filter, 0);

 static struct attribute *max31856_attributes[] = {
 	&iio_dev_attr_fault_ovuv.dev_attr.attr,
 	&iio_dev_attr_fault_oc.dev_attr.attr,
 	&iio_dev_attr_in_temp_filter_notch_center_frequency.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,
 	.write_raw = max31856_write_raw,
 	.write_raw_get_fmt = max31856_write_raw_get_fmt,
 	.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;
 	data->filter_50hz = false;

 	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 = device_property_read_u32(&spi->dev, "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");
	// SPDX-License-Identifier: GPL-2.0
	/* max31856.c
	*
	* Maxim MAX31856 thermocouple sensor driver
	*
	* Copyright (C) 2018-2019 Rockwell Collins
	*/

	#include <linux/ctype.h>
	#include <linux/mod_devicetable.h>
	#include <linux/module.h>
	#include <linux/init.h>
	#include <linux/err.h>
	#include <linux/property.h>
	#include <linux/spi/spi.h>
	#include <linux/iio/iio.h>
	#include <linux/iio/sysfs.h>
	#include <linux/util_macros.h>
	#include <asm/unaligned.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_CR0_FILTER_50HZ BIT(0)
	#define MAX31856_AVERAGING_MASK GENMASK(6, 4)
	#define MAX31856_AVERAGING_SHIFT 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) \|
	BIT(IIO_CHAN_INFO_THERMOCOUPLE_TYPE),
	.info_mask_shared_by_type =
	BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO)
	},
	{ /* 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),
	.info_mask_shared_by_type =
	BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO)
	},
	};

	struct max31856_data {
	struct spi_device *spi;
	u32 thermocouple_type;
	bool filter_50hz;
	int averaging;
	};

	static const char max31856_tc_types[] = {
	'B', 'E', 'J', 'K', 'N', 'R', 'S', 'T'
	};

	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;

	reg_cr1_val &= ~MAX31856_AVERAGING_MASK;
	reg_cr1_val \|= data->averaging << MAX31856_AVERAGING_SHIFT;

	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;

	if (data->filter_50hz)
	reg_cr0_val \|= MAX31856_CR0_FILTER_50HZ;
	else
	reg_cr0_val &= ~MAX31856_CR0_FILTER_50HZ;

	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 = get_unaligned_be24(&reg_val[0]) >> 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 = get_unaligned_be16(&reg_val[1]) >> 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;
	case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
	*val = 1 << data->averaging;
	return IIO_VAL_INT;
	case IIO_CHAN_INFO_THERMOCOUPLE_TYPE:
	*val = max31856_tc_types[data->thermocouple_type];
	return IIO_VAL_CHAR;
	default:
	ret = -EINVAL;
	break;
	}

	return ret;
	}

	static int max31856_write_raw_get_fmt(struct iio_dev *indio_dev,
	struct iio_chan_spec const *chan,
	long mask)
	{
	switch (mask) {
	case IIO_CHAN_INFO_THERMOCOUPLE_TYPE:
	return IIO_VAL_CHAR;
	default:
	return IIO_VAL_INT;
	}
	}

	static int max31856_write_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 msb;

	switch (mask) {
	case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
	if (val > 16 \|\| val < 1)
	return -EINVAL;
	msb = fls(val) - 1;
	/* Round up to next 2pow if needed */
	if (BIT(msb) < val)
	msb++;

	data->averaging = msb;
	max31856_init(data);
	break;
	case IIO_CHAN_INFO_THERMOCOUPLE_TYPE:
	{
	int tc_type = -1;
	int i;

	for (i = 0; i < ARRAY_SIZE(max31856_tc_types); i++) {
	if (max31856_tc_types[i] == toupper(val)) {
	tc_type = i;
	break;
	}
	}
	if (tc_type < 0)
	return -EINVAL;

	data->thermocouple_type = tc_type;
	max31856_init(data);
	break;
	}
	default:
	return -EINVAL;
	}

	return 0;
	}

	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 sysfs_emit(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 ssize_t show_filter(struct device *dev,
	struct device_attribute *attr,
	char *buf)
	{
	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
	struct max31856_data *data = iio_priv(indio_dev);

	return sysfs_emit(buf, "%d\n", data->filter_50hz ? 50 : 60);
	}

	static ssize_t set_filter(struct device *dev,
	struct device_attribute *attr,
	const char *buf,
	size_t len)
	{
	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
	struct max31856_data *data = iio_priv(indio_dev);
	unsigned int freq;
	int ret;

	ret = kstrtouint(buf, 10, &freq);
	if (ret)
	return ret;

	switch (freq) {
	case 50:
	data->filter_50hz = true;
	break;
	case 60:
	data->filter_50hz = false;
	break;
	default:
	return -EINVAL;
	}

	max31856_init(data);
	return len;
	}

	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 IIO_DEVICE_ATTR(in_temp_filter_notch_center_frequency, 0644,
	show_filter, set_filter, 0);

	static struct attribute *max31856_attributes[] = {
	&iio_dev_attr_fault_ovuv.dev_attr.attr,
	&iio_dev_attr_fault_oc.dev_attr.attr,
	&iio_dev_attr_in_temp_filter_notch_center_frequency.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,
	.write_raw = max31856_write_raw,
	.write_raw_get_fmt = max31856_write_raw_get_fmt,
	.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;
	data->filter_50hz = false;

	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 = device_property_read_u32(&spi->dev, "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");