Re: [PATCH 12/14] staging: iio: adc: new driver for ADT7408 temperature sensors

[Jonathan Cameron <jic23@cam.ac.uk>]

On 10/23/10 21:29, Mike Frysinger wrote:
> From: Sonic Zhang <sonic.zhang@analog.com>
Here we enter new territory. This device is already
supported in hwmon.  Do we have a usecase that is not
covered by that driver? 

If this is only for hardware monitoring by Guenter (cc'd) can
perhaps advise on how to support everything you have here...

I'm personally not against having drivers in IIO for devices
supported elsewhere, but the requirements for justification
are rather higher. Also care is needed to ensure no issues with
platform data etc.

Guenter, for your information we have a set of temp drivers coming,
as a small element of a larger set, from Analog's tree. Those
I've reviewed so far have wanted to use IIO's event infrastructure
(which is much more general than hwmon's handling of alarms)
or have been suitably high performance devices with general
adc's to satisfy me that they clearly have uses beyond
hardware monitoring.


> 
> Signed-off-by: Sonic Zhang <sonic.zhang@analog.com>
> Signed-off-by: Mike Frysinger <vapier@gentoo.org>
> ---
>  drivers/staging/iio/adc/Kconfig   |    7 +
>  drivers/staging/iio/adc/Makefile  |    1 +
>  drivers/staging/iio/adc/adt7408.c | 1006 +++++++++++++++++++++++++++++++++++++
>  3 files changed, 1014 insertions(+), 0 deletions(-)
>  create mode 100644 drivers/staging/iio/adc/adt7408.c
> 
> diff --git a/drivers/staging/iio/adc/Kconfig b/drivers/staging/iio/adc/Kconfig
> index 5d13918..ea75700 100644
> --- a/drivers/staging/iio/adc/Kconfig
> +++ b/drivers/staging/iio/adc/Kconfig
> @@ -114,3 +114,10 @@ config ADT7408
>  	help
>  	  Say yes here to build support for Analog Devices ADT7408
>  	  temperature sensors.
> +
> +config ADT7410
> +	tristate "Analog Devices ADT7410 temperature sensor driver"
> +	depends on I2C
> +	help
> +	  Say yes here to build support for Analog Devices ADT7410
> +	  temperature sensors.
> diff --git a/drivers/staging/iio/adc/Makefile b/drivers/staging/iio/adc/Makefile
> index 6c11363..dc2bdbe 100644
> --- a/drivers/staging/iio/adc/Makefile
> +++ b/drivers/staging/iio/adc/Makefile
> @@ -21,3 +21,4 @@ obj-$(CONFIG_AD774X) += ad774x.o
>  obj-$(CONFIG_AD7816) += ad7816.o
>  obj-$(CONFIG_ADT75) += adt75.o
>  obj-$(CONFIG_ADT7310) += adt7310.o
> +obj-$(CONFIG_ADT7408) += adt7408.o
> diff --git a/drivers/staging/iio/adc/adt7408.c b/drivers/staging/iio/adc/adt7408.c
> new file mode 100644
> index 0000000..25bd594
> --- /dev/null
> +++ b/drivers/staging/iio/adc/adt7408.c
> @@ -0,0 +1,1006 @@
> +/*
> + * ADT7408 digital temperature sensor driver supporting ADT7408
> + *
> + * Copyright 2010 Analog Devices Inc.
> + *
> + * Licensed under the GPL-2 or later.
> + */
> +
> +#include <linux/interrupt.h>
> +#include <linux/gpio.h>
> +#include <linux/workqueue.h>
> +#include <linux/device.h>
> +#include <linux/kernel.h>
> +#include <linux/slab.h>
> +#include <linux/sysfs.h>
> +#include <linux/list.h>
> +#include <linux/i2c.h>
> +#include <linux/rtc.h>
> +
> +#include "../iio.h"
> +#include "../sysfs.h"
> +
> +/*
> + * ADT7408 registers definition
> + */
> +
> +#define ADT7408_CAPABILITY		0
> +#define ADT7408_CONFIG			1
> +#define ADT7408_T_ALARM_HIGH		2
> +#define ADT7408_T_ALARM_LOW		3
> +#define ADT7408_T_CRIT			4
> +#define ADT7408_TEMPERATURE		5
> +#define ADT7408_MANUFACTURER_ID		6
> +#define ADT7408_DEVICE_ID		7
> +
> +/*
> + * ADT7408 capability
> + */
> +#define ADT7408_CAP_ALARM_CRIT_TRIPS	0x1
> +#define ADT7408_CAP_HIGH_PRECISION	0x2
> +#define ADT7408_CAP_WIDER_RANGE		0x4
> +#define ADT7408_CAP_T_RESOLUTION_MASK	0x18
> +#define ADT7408_CAP_T_RESOLUTION_HIGH	0x18
> +#define ADT7408_CAP_T_RESOLUTION_LOW	0x8
> +
> +/*
> + * ADT7408 config
> + */
> +#define ADT7408_EVENT_MODE		0x1
> +#define ADT7408_EVENT_POLARITY		0x2
> +#define ADT7408_EVENT_CRIT_ONLY		0x4
> +#define ADT7408_EVENT_ENABLE		0x8
> +#define ADT7408_EVENT_STATUS		0x10
> +#define ADT7408_EVENT_CLEAR		0x20
> +#define ADT7408_EVENT_ALARM_LOCK	0x40
> +#define ADT7408_EVENT_CRIT_LOCK		0x80
> +#define ADT7408_PD			0x100
> +#define ADT7408_HISTERESIS_MASK		0x600
> +#define ADT7408_HISTERESIS_1_5		0x200
> +#define ADT7408_HISTERESIS_3		0x400
> +#define ADT7408_HISTERESIS_6		0x600
> +
> +/*
> + * ADT7408 masks
> + */
> +#define ADT7408_BOUND_VALUE_SIGN		0x400
> +#define ADT7408_BOUND_VALUE_OFFSET		2
> +#define ADT7408_BOUND_VALUE_FLOAT_OFFSET	2
> +#define ADT7408_BOUND_VALUE_FLOAT_MASK		0x3
> +#define ADT7408_T_VALUE_SIGN			0x1000
> +#define ADT7408_T_VALUE_FLOAT_OFFSET		4
> +#define ADT7408_T_VALUE_FLOAT_MASK		0xF
> +
> +/*
> + * ADT7408 event source
> + */
> +#define ADT7408_T_BELLOW_ALARM			0x2000
> +#define ADT7408_T_ABOVE_ALARM			0x4000
> +#define ADT7408_T_ABOVE_CRIT			0x8000
> +
> +
> +/*
> + * struct adt7408_chip_info - chip specifc information
> + */
> +
> +struct adt7408_chip_info {
> +	const char *name;
> +	struct i2c_client *client;
> +	struct iio_dev *indio_dev;
> +	struct work_struct thresh_work;
> +	s64 last_timestamp;
> +	u16 config;
> +};
> +
> +/*
> + * adt7408 register access by I2C
> + */
> +
> +static int adt7408_i2c_read(struct adt7408_chip_info *chip, u8 reg, u16 *data)
> +{
> +	struct i2c_client *client = chip->client;
> +	int ret = 0;
> +
> +	ret = i2c_smbus_read_word_data(client, reg);
> +	if (ret < 0) {
> +		dev_err(&client->dev, "I2C read error\n");
> +		return ret;
> +	}
> +
> +	*data = swab16((u16)ret);
> +
> +	return 0;
> +}
> +
> +static int adt7408_i2c_write(struct adt7408_chip_info *chip, u8 reg, u16 data)
> +{
> +	struct i2c_client *client = chip->client;
> +	int ret = 0;
> +
> +	ret = i2c_smbus_write_word_data(client, reg, swab16(data));
> +	if (ret < 0)
> +		dev_err(&client->dev, "I2C write error\n");
> +
> +	return ret;
> +}
> +
> +static int adt7408_is_event_locked(struct adt7408_chip_info *chip)
> +{
> +	return chip->config & (ADT7408_EVENT_ALARM_LOCK | ADT7408_EVENT_ALARM_LOCK);
> +}
> +
> +static ssize_t adt7408_show_mode(struct device *dev,
> +		struct device_attribute *attr,
> +		char *buf)
> +{
> +	struct iio_dev *dev_info = dev_get_drvdata(dev);
> +	struct adt7408_chip_info *chip = dev_info->dev_data;
> +
> +	if (chip->config & ADT7408_PD)
> +		return sprintf(buf, "power-save\n");
> +	else
> +		return sprintf(buf, "full\n");
> +}
> +
> +static ssize_t adt7408_store_mode(struct device *dev,
> +		struct device_attribute *attr,
> +		const char *buf,
> +		size_t len)
> +{
> +	struct iio_dev *dev_info = dev_get_drvdata(dev);
> +	struct adt7408_chip_info *chip = dev_info->dev_data;
> +	u16 config;
> +	int ret;
> +
> +	if (adt7408_is_event_locked(chip)) {
> +		dev_err(dev, "Warning: Events are locked.\n");
> +		return -EIO;
> +	}
> +
> +	ret = adt7408_i2c_read(chip, ADT7408_CONFIG, &chip->config);
> +	if (ret)
> +		return -EIO;
> +
> +	config = chip->config & (~ADT7408_PD);
> +	if (!strcmp(buf, "full"))
> +		config |= ADT7408_PD;
> +
> +	ret = adt7408_i2c_write(chip, ADT7408_CONFIG, config);
> +	if (ret)
> +		return -EIO;
> +
> +	chip->config = config;
> +
> +	return ret;
> +}
> +
> +static IIO_DEVICE_ATTR(mode, S_IRUGO | S_IWUSR,
> +		adt7408_show_mode,
> +		adt7408_store_mode,
> +		0);
> +
> +static ssize_t adt7408_show_available_modes(struct device *dev,
> +		struct device_attribute *attr,
> +		char *buf)
> +{
> +	return sprintf(buf, "full\npower-down\n");
> +}
> +
> +static IIO_DEVICE_ATTR(available_modes, S_IRUGO, adt7408_show_available_modes, NULL, 0);
> +
> +static ssize_t adt7408_show_capability(struct device *dev,
> +		struct device_attribute *attr,
> +		char *buf)
> +{
> +	struct iio_dev *dev_info = dev_get_drvdata(dev);
> +	struct adt7408_chip_info *chip = dev_info->dev_data;
> +	u16 capability;
> +	int ret;
> +
> +	ret = adt7408_i2c_read(chip, ADT7408_CAPABILITY, &capability);
> +	if (ret)
> +		return -EIO;
> +
> +	return sprintf(buf, "0x%x\n", capability);
> +}
> +
> +static IIO_DEVICE_ATTR(capability, S_IRUGO | S_IWUSR,
> +		adt7408_show_capability,
> +		NULL,
> +		0);
> +
> +static ssize_t adt7408_show_manufactory_id(struct device *dev,
> +		struct device_attribute *attr,
> +		char *buf)
> +{
> +	struct iio_dev *dev_info = dev_get_drvdata(dev);
> +	struct adt7408_chip_info *chip = dev_info->dev_data;
> +	u16 id;
> +	int ret;
> +
> +	ret = adt7408_i2c_read(chip, ADT7408_MANUFACTURER_ID, &id);
> +	if (ret)
> +		return -EIO;
> +
> +	return sprintf(buf, "0x%x\n", id);
> +}
> +
> +static IIO_DEVICE_ATTR(manufactory_id, S_IRUGO | S_IWUSR,
> +		adt7408_show_manufactory_id,
> +		NULL,
> +		0);
> +
> +static ssize_t adt7408_show_device_id(struct device *dev,
> +		struct device_attribute *attr,
> +		char *buf)
> +{
> +	struct iio_dev *dev_info = dev_get_drvdata(dev);
> +	struct adt7408_chip_info *chip = dev_info->dev_data;
> +	u16 id;
> +	int ret;
> +
> +	ret = adt7408_i2c_read(chip, ADT7408_MANUFACTURER_ID, &id);
> +	if (ret)
> +		return -EIO;
> +
> +	return sprintf(buf, "0x%x\n", id);
> +}
> +
> +static IIO_DEVICE_ATTR(device_id, S_IRUGO | S_IWUSR,
> +		adt7408_show_device_id,
> +		NULL,
> +		0);
> +
> +static ssize_t adt7408_show_value(struct device *dev,
> +		struct device_attribute *attr,
> +		char *buf)
> +{
> +	struct iio_dev *dev_info = dev_get_drvdata(dev);
> +	struct adt7408_chip_info *chip = dev_info->dev_data;
> +	u16 data;
> +	char sign = ' ';
> +	int ret;
> +
> +	if (chip->config & ADT7408_PD) {
> +		dev_err(dev, "Can't read value in power-down mode.\n");
> +		return -EIO;
> +	}
> +
> +	ret = adt7408_i2c_read(chip, ADT7408_TEMPERATURE, &data);
> +	if (ret)
> +		return -EIO;
> +
> +	if (data & ADT7408_T_VALUE_SIGN) {
> +		/* convert supplement to positive value */
> +		data = (ADT7408_T_VALUE_SIGN << 1) - data;
> +		sign = '-';
> +	}
> +
> +	return sprintf(buf, "%c%d.%.4d\n", sign,
> +		(data >> ADT7408_T_VALUE_FLOAT_OFFSET),
> +		(data & ADT7408_T_VALUE_FLOAT_MASK) * 625);
> +}
> +
> +static IIO_DEVICE_ATTR(value, S_IRUGO, adt7408_show_value, NULL, 0);
> +
> +static ssize_t adt7408_show_name(struct device *dev,
> +		struct device_attribute *attr,
> +		char *buf)
> +{
> +	struct iio_dev *dev_info = dev_get_drvdata(dev);
> +	struct adt7408_chip_info *chip = dev_info->dev_data;
> +	return sprintf(buf, "%s\n", chip->name);
> +}
> +
> +static IIO_DEVICE_ATTR(name, S_IRUGO, adt7408_show_name, NULL, 0);
> +
> +static struct attribute *adt7408_attributes[] = {
> +	&iio_dev_attr_available_modes.dev_attr.attr,
> +	&iio_dev_attr_mode.dev_attr.attr,
> +	&iio_dev_attr_capability.dev_attr.attr,
> +	&iio_dev_attr_device_id.dev_attr.attr,
> +	&iio_dev_attr_manufactory_id.dev_attr.attr,
> +	&iio_dev_attr_value.dev_attr.attr,
> +	&iio_dev_attr_name.dev_attr.attr,
> +	NULL,
> +};
> +
> +static const struct attribute_group adt7408_attribute_group = {
> +	.attrs = adt7408_attributes,
> +};
> +
> +/*
> + * temperature bound events
> + */
> +
> +#define IIO_EVENT_CODE_ADT7408_ABOVE_ALARM    (IIO_EVENT_CODE_DEVICE_SPECIFIC + 1)
> +#define IIO_EVENT_CODE_ADT7408_BELLOW_ALARM    (IIO_EVENT_CODE_DEVICE_SPECIFIC + 2)
> +#define IIO_EVENT_CODE_ADT7408_ABOVE_CRIT    (IIO_EVENT_CODE_DEVICE_SPECIFIC + 3)
> +
> +static void adt7408_interrupt_bh(struct work_struct *work_s)
> +{
> +	struct adt7408_chip_info *chip =
> +		container_of(work_s, struct adt7408_chip_info, thresh_work);
> +	u16 config;
> +	u16 data;
> +
> +	if (adt7408_i2c_read(chip, ADT7408_CONFIG, &chip->config))
> +		return;
> +
> +	if (!(chip->config & ADT7408_EVENT_STATUS))
> +		return;
> +
> +	config = chip->config & ~ADT7408_EVENT_CLEAR;
> +	if (data)
> +		config |= ADT7408_EVENT_CLEAR;
> +
> +	adt7408_i2c_write(chip, ADT7408_CONFIG, config);
> +
> +	if (adt7408_i2c_read(chip, ADT7408_TEMPERATURE, &data))
> +		goto exit;
> +
> +	if (data & ADT7408_T_ABOVE_ALARM)
> +		iio_push_event(chip->indio_dev, 0,
> +			IIO_EVENT_CODE_ADT7408_ABOVE_ALARM,
> +			chip->last_timestamp);
> +	if (data & ADT7408_T_BELLOW_ALARM)
> +		iio_push_event(chip->indio_dev, 0,
> +			IIO_EVENT_CODE_ADT7408_BELLOW_ALARM,
> +			chip->last_timestamp);
> +	if (data & ADT7408_T_ABOVE_CRIT)
> +		iio_push_event(chip->indio_dev, 0,
> +			IIO_EVENT_CODE_ADT7408_ABOVE_CRIT,
> +			chip->last_timestamp);
> +exit:
> +	enable_irq(chip->client->irq);
> +}
> +
> +static int adt7408_interrupt(struct iio_dev *dev_info,
> +		int index,
> +		s64 timestamp,
> +		int no_test)
> +{
> +	struct adt7408_chip_info *chip = dev_info->dev_data;
> +
> +	chip->last_timestamp = timestamp;
> +	schedule_work(&chip->thresh_work);
> +
> +	return 0;
> +}
> +
> +IIO_EVENT_SH(adt7408, &adt7408_interrupt);
> +
> +static ssize_t adt7408_show_event_mode(struct device *dev,
> +		struct device_attribute *attr,
> +		char *buf)
> +{
> +	struct iio_dev *dev_info = dev_get_drvdata(dev);
> +	struct adt7408_chip_info *chip = dev_info->dev_data;
> +	int ret;
> +
> +	ret = adt7408_i2c_read(chip, ADT7408_CONFIG, &chip->config);
> +	if (ret)
> +		return -EIO;
> +
> +	if (chip->config & ADT7408_EVENT_MODE)
> +		return sprintf(buf, "interrupt\n");
> +	else
> +		return sprintf(buf, "comparator\n");
> +}
> +
> +static ssize_t adt7408_set_event_mode(struct device *dev,
> +		struct device_attribute *attr,
> +		const char *buf,
> +		size_t len)
> +{
> +	struct iio_dev *dev_info = dev_get_drvdata(dev);
> +	struct adt7408_chip_info *chip = dev_info->dev_data;
> +	u16 config;
> +	int ret;
> +
> +	if (adt7408_is_event_locked(chip)) {
> +		dev_err(dev, "Warning: Events are locked.\n");
> +		return -EIO;
> +	}
> +
> +	ret = adt7408_i2c_read(chip, ADT7408_CONFIG, &chip->config);
> +	if (ret)
> +		return -EIO;
> +
> +	config = chip->config &= ~ADT7408_EVENT_MODE;
> +	if (strcmp(buf, "comparator") != 0)
> +		config |= ADT7408_EVENT_MODE;
> +
> +	ret = adt7408_i2c_write(chip, ADT7408_CONFIG, config);
> +	if (ret)
> +		return -EIO;
> +
> +	chip->config = config;
> +
> +	return ret;
> +}
> +
> +static ssize_t adt7408_show_available_event_modes(struct device *dev,
> +		struct device_attribute *attr,
> +		char *buf)
> +{
> +	return sprintf(buf, "comparator\ninterrupt\n");
> +}
> +
> +static ssize_t adt7408_show_event_crit_only(struct device *dev,
> +		struct device_attribute *attr,
> +		char *buf)
> +{
> +	struct iio_dev *dev_info = dev_get_drvdata(dev);
> +	struct adt7408_chip_info *chip = dev_info->dev_data;
> +	int ret;
> +
> +	ret = adt7408_i2c_read(chip, ADT7408_CONFIG, &chip->config);
> +	if (ret)
> +		return -EIO;
> +
> +	return sprintf(buf, "%d\n", !!(chip->config & ADT7408_EVENT_CRIT_ONLY));
> +}
> +
> +static ssize_t adt7408_set_event_crit_only(struct device *dev,
> +		struct device_attribute *attr,
> +		const char *buf,
> +		size_t len)
> +{
> +	struct iio_dev *dev_info = dev_get_drvdata(dev);
> +	struct adt7408_chip_info *chip = dev_info->dev_data;
> +	unsigned long data = 0;
> +	u16 config;
> +	int ret;
> +
> +	if (adt7408_is_event_locked(chip)) {
> +		dev_err(dev, "Warning: Events are locked.\n");
> +		return -EIO;
> +	}
> +
> +	ret = strict_strtoul(buf, 10, &data);
> +	if (ret)
> +		return -EINVAL;
> +
> +	ret = adt7408_i2c_read(chip, ADT7408_CONFIG, &chip->config);
> +	if (ret)
> +		return -EIO;
> +
> +	config = chip->config &= ~ADT7408_EVENT_CRIT_ONLY;
> +	if (data)
> +		config |= ADT7408_EVENT_CRIT_ONLY;
> +
> +	ret = adt7408_i2c_write(chip, ADT7408_CONFIG, config);
> +	if (ret)
> +		return -EIO;
> +
> +	chip->config = config;
> +
> +	return ret;
> +}
> +
> +static ssize_t adt7408_show_event_enable(struct device *dev,
> +		struct device_attribute *attr,
> +		char *buf)
> +{
> +	struct iio_dev *dev_info = dev_get_drvdata(dev);
> +	struct adt7408_chip_info *chip = dev_info->dev_data;
> +	int ret;
> +
> +	ret = adt7408_i2c_read(chip, ADT7408_CONFIG, &chip->config);
> +	if (ret)
> +		return -EIO;
> +
> +	return sprintf(buf, "%d\n", !!(chip->config & ADT7408_EVENT_ENABLE));
> +}
> +
> +static ssize_t adt7408_set_event_enable(struct device *dev,
> +		struct device_attribute *attr,
> +		const char *buf,
> +		size_t len)
> +{
> +	struct iio_dev *dev_info = dev_get_drvdata(dev);
> +	struct adt7408_chip_info *chip = dev_info->dev_data;
> +	unsigned long data;
> +	u16 config;
> +	int ret;
> +
> +	if (adt7408_is_event_locked(chip)) {
> +		dev_err(dev, "Warning: Events are locked.\n");
> +		return -EIO;
> +	}
> +
> +	ret = strict_strtoul(buf, 10, &data);
> +	if (ret)
> +		return -EINVAL;
> +
> +	ret = adt7408_i2c_read(chip, ADT7408_CONFIG, &chip->config);
> +	if (ret)
> +		return -EIO;
> +
> +	config = chip->config & ~ADT7408_EVENT_ENABLE;
> +	if (data)
> +		config |= ADT7408_EVENT_ENABLE;
> +
> +	ret = adt7408_i2c_write(chip, ADT7408_CONFIG, config);
> +	if (ret)
> +		return -EIO;
> +
> +	chip->config = config;
> +
> +	return ret;
> +}
> +
> +static ssize_t adt7408_show_alarm_lock(struct device *dev,
> +		struct device_attribute *attr,
> +		char *buf)
> +{
> +	struct iio_dev *dev_info = dev_get_drvdata(dev);
> +	struct adt7408_chip_info *chip = dev_info->dev_data;
> +	int ret;
> +
> +	ret = adt7408_i2c_read(chip, ADT7408_CONFIG, &chip->config);
> +	if (ret)
> +		return -EIO;
> +
> +	return sprintf(buf, "%d\n", !!(chip->config & ADT7408_EVENT_ALARM_LOCK));
> +}
> +
> +static ssize_t adt7408_set_alarm_lock(struct device *dev,
> +		struct device_attribute *attr,
> +		const char *buf,
> +		size_t len)
> +{
> +	struct iio_dev *dev_info = dev_get_drvdata(dev);
> +	struct adt7408_chip_info *chip = dev_info->dev_data;
> +	unsigned long data;
> +	u16 config;
> +	int ret;
> +
> +	ret = strict_strtoul(buf, 10, &data);
> +	if (ret)
> +		return -EINVAL;
> +
> +	ret = adt7408_i2c_read(chip, ADT7408_CONFIG, &chip->config);
> +	if (ret)
> +		return -EIO;
> +
> +	config = chip->config & ~ADT7408_EVENT_ALARM_LOCK;
> +	if (data)
> +		config |= ADT7408_EVENT_ALARM_LOCK;
> +
> +	ret = adt7408_i2c_write(chip, ADT7408_CONFIG, config);
> +	if (ret)
> +		return -EIO;
> +
> +	chip->config = config;
> +
> +	return ret;
> +}
> +
> +static ssize_t adt7408_show_crit_lock(struct device *dev,
> +		struct device_attribute *attr,
> +		char *buf)
> +{
> +	struct iio_dev *dev_info = dev_get_drvdata(dev);
> +	struct adt7408_chip_info *chip = dev_info->dev_data;
> +	int ret;
> +
> +	ret = adt7408_i2c_read(chip, ADT7408_CONFIG, &chip->config);
> +	if (ret)
> +		return -EIO;
> +
> +	return sprintf(buf, "%d\n", !!(chip->config & ADT7408_EVENT_CRIT_LOCK));
> +}
> +
> +static ssize_t adt7408_set_crit_lock(struct device *dev,
> +		struct device_attribute *attr,
> +		const char *buf,
> +		size_t len)
> +{
> +	struct iio_dev *dev_info = dev_get_drvdata(dev);
> +	struct adt7408_chip_info *chip = dev_info->dev_data;
> +	unsigned long data;
> +	u16 config;
> +	int ret;
> +
> +	ret = strict_strtoul(buf, 10, &data);
> +	if (ret)
> +		return -EINVAL;
> +
> +	ret = adt7408_i2c_read(chip, ADT7408_CONFIG, &chip->config);
> +	if (ret)
> +		return -EIO;
> +
> +	config = chip->config & ~ADT7408_EVENT_CRIT_LOCK;
> +	if (data)
> +		config |= ADT7408_EVENT_CRIT_LOCK;
> +
> +	ret = adt7408_i2c_write(chip, ADT7408_CONFIG, config);
> +	if (ret)
> +		return -EIO;
> +
> +	chip->config = config;
> +
> +	return ret;
> +}
> +
> +
> +static inline ssize_t adt7408_show_t_bound(struct device *dev,
> +		struct device_attribute *attr,
> +		u8 bound_reg,
> +		char *buf)
> +{
> +	struct iio_dev *dev_info = dev_get_drvdata(dev);
> +	struct adt7408_chip_info *chip = dev_info->dev_data;
> +	u16 data;
> +	char sign = ' ';
> +	int ret;
> +
> +	ret = adt7408_i2c_read(chip, bound_reg, &data);
> +	if (ret)
> +		return -EIO;
> +
> +	data >>= ADT7408_BOUND_VALUE_OFFSET;
> +	if (data & ADT7408_BOUND_VALUE_SIGN) {
> +		/* convert supplement to positive value */
> +		data = (ADT7408_BOUND_VALUE_SIGN << 1) - data;
> +		sign = '-';
> +	}
> +
> +	return sprintf(buf, "%c%d.%.2d\n", sign,
> +			data >> ADT7408_BOUND_VALUE_FLOAT_OFFSET,
> +			(data & ADT7408_BOUND_VALUE_FLOAT_MASK) * 25);
> +}
> +
> +static inline ssize_t adt7408_set_t_bound(struct device *dev,
> +		struct device_attribute *attr,
> +		u8 bound_reg,
> +		const char *buf,
> +		size_t len)
> +{
> +	struct iio_dev *dev_info = dev_get_drvdata(dev);
> +	struct adt7408_chip_info *chip = dev_info->dev_data;
> +	long tmp1, tmp2;
> +	u16 data;
> +	char *pos;
> +	int ret;
> +
> +	pos = strchr(buf, '.');
> +
> +	ret = strict_strtol(buf, 10, &tmp1);
> +
> +	if (ret || tmp1 > 127 || tmp1 < -128)
> +		return -EINVAL;
> +
> +	if (pos) {
> +		len = strlen(pos);
> +		if (len > ADT7408_BOUND_VALUE_FLOAT_OFFSET)
> +			len = ADT7408_BOUND_VALUE_FLOAT_OFFSET;
> +		pos[len] = 0;
> +		ret = strict_strtol(pos, 10, &tmp2);
> +
> +		if (!ret)
> +			tmp2 = (tmp2 / 25) * 25;
> +	}
> +
> +	if (tmp1 < 0)
> +		data = (u16)(-tmp1);
> +	else
> +		data = (u16)tmp1;
> +	data = (data << ADT7408_BOUND_VALUE_FLOAT_OFFSET) |
> +		(tmp2 & ADT7408_BOUND_VALUE_FLOAT_MASK);
> +	if (tmp1 < 0)
> +		/* convert positive value to supplyment */
> +		data = (ADT7408_BOUND_VALUE_SIGN << 1) - data;
> +	data <<= ADT7408_BOUND_VALUE_OFFSET;
> +
> +	ret = adt7408_i2c_write(chip, bound_reg, data);
> +	if (ret)
> +		return -EIO;
> +
> +	return ret;
> +}
> +
> +static ssize_t adt7408_show_t_alarm_high(struct device *dev,
> +		struct device_attribute *attr,
> +		char *buf)
> +{
> +	return adt7408_show_t_bound(dev, attr,
> +			ADT7408_T_ALARM_HIGH, buf);
> +}
> +
> +static inline ssize_t adt7408_set_t_alarm_high(struct device *dev,
> +		struct device_attribute *attr,
> +		const char *buf,
> +		size_t len)
> +{
> +	return adt7408_set_t_bound(dev, attr,
> +			ADT7408_T_ALARM_HIGH, buf, len);
> +}
> +
> +static ssize_t adt7408_show_t_alarm_low(struct device *dev,
> +		struct device_attribute *attr,
> +		char *buf)
> +{
> +	return adt7408_show_t_bound(dev, attr,
> +			ADT7408_T_ALARM_LOW, buf);
> +}
> +
> +static inline ssize_t adt7408_set_t_alarm_low(struct device *dev,
> +		struct device_attribute *attr,
> +		const char *buf,
> +		size_t len)
> +{
> +	return adt7408_set_t_bound(dev, attr,
> +			ADT7408_T_ALARM_LOW, buf, len);
> +}
> +
> +static ssize_t adt7408_show_t_crit(struct device *dev,
> +		struct device_attribute *attr,
> +		char *buf)
> +{
> +	return adt7408_show_t_bound(dev, attr,
> +			ADT7408_T_CRIT, buf);
> +}
> +
> +static inline ssize_t adt7408_set_t_crit(struct device *dev,
> +		struct device_attribute *attr,
> +		const char *buf,
> +		size_t len)
> +{
> +	return adt7408_set_t_bound(dev, attr,
> +			ADT7408_T_CRIT, buf, len);
> +}
> +
> +static ssize_t adt7408_show_t_hyst(struct device *dev,
> +		struct device_attribute *attr,
> +		char *buf)
> +{
> +	struct iio_dev *dev_info = dev_get_drvdata(dev);
> +	struct adt7408_chip_info *chip = dev_info->dev_data;
> +	int ret;
> +
> +	/* retrive ALART status */
> +	ret = adt7408_i2c_read(chip, ADT7408_CONFIG, &chip->config);
> +	if (ret)
> +		return -EIO;
> +
> +	switch (chip->config & ADT7408_HISTERESIS_MASK) {
> +	case ADT7408_HISTERESIS_1_5:
> +		return sprintf(buf, "1.5\n");
> +	case ADT7408_HISTERESIS_3:
> +		return sprintf(buf, "3\n");
> +	case ADT7408_HISTERESIS_6:
> +		return sprintf(buf, "6\n");
> +	default:
> +		return sprintf(buf, "Disabled\n");
> +	}
> +}
> +
> +static inline ssize_t adt7408_set_t_hyst(struct device *dev,
> +		struct device_attribute *attr,
> +		const char *buf,
> +		size_t len)
> +{
> +	struct iio_dev *dev_info = dev_get_drvdata(dev);
> +	struct adt7408_chip_info *chip = dev_info->dev_data;
> +	int ret;
> +	u16 config = 0;
> +
> +	if (strcmp(buf, "disble"))
> +		config = ADT7408_HISTERESIS_MASK;
> +	else if (strcmp(buf, "1.5"))
> +		config = ADT7408_HISTERESIS_1_5;
> +	else if (len > 1 && buf[0] == '3')
> +		config = ADT7408_HISTERESIS_6;
> +	else if (len > 1 && buf[0] == '6')
> +		config = ADT7408_HISTERESIS_6;
> +
> +	if (!config)
> +		return -EINVAL;
> +
> +	/* retrive ALART status */
> +	ret = adt7408_i2c_read(chip, ADT7408_CONFIG, &chip->config);
> +	if (ret)
> +		return -EIO;
> +
> +	config |= chip->config & ~ADT7408_HISTERESIS_MASK;
> +
> +	ret = adt7408_i2c_write(chip, ADT7408_CONFIG, config);
> +	if (ret)
> +		return -EIO;
> +
> +	chip->config = config;
> +	return ret;
> +}
> +
> +static ssize_t adt7408_show_available_t_hyst(struct device *dev,
> +		struct device_attribute *attr,
> +		char *buf)
> +{
> +	return sprintf(buf, "1.5\n3\n6\ndisable\n");
> +}
> +
> +IIO_EVENT_ATTR_SH(event_mode, iio_event_adt7408,
> +		adt7408_show_event_mode, adt7408_set_event_mode, 0);
> +IIO_EVENT_ATTR_SH(available_event_modes, iio_event_adt7408,
> +		adt7408_show_available_event_modes, NULL, 0);
> +IIO_EVENT_ATTR_SH(event_crit_only, iio_event_adt7408,
> +		adt7408_show_event_crit_only, adt7408_set_event_crit_only, 0);
> +IIO_EVENT_ATTR_SH(event_enable, iio_event_adt7408,
> +		adt7408_show_event_enable, adt7408_set_event_enable, 0);
> +IIO_EVENT_ATTR_SH(alarm_lock, iio_event_adt7408,
> +		adt7408_show_alarm_lock, adt7408_set_alarm_lock, 0);
> +IIO_EVENT_ATTR_SH(crit_lock, iio_event_adt7408,
> +		adt7408_show_crit_lock, adt7408_set_crit_lock, 0);
> +IIO_EVENT_ATTR_SH(t_alarm_high, iio_event_adt7408,
> +		adt7408_show_t_alarm_high, adt7408_set_t_alarm_high, 0);
> +IIO_EVENT_ATTR_SH(t_alarm_low, iio_event_adt7408,
> +		adt7408_show_t_alarm_low, adt7408_set_t_alarm_low, 0);
> +IIO_EVENT_ATTR_SH(t_crit, iio_event_adt7408,
> +		adt7408_show_t_crit, adt7408_set_t_crit, 0);
> +IIO_EVENT_ATTR_SH(t_hyst, iio_event_adt7408,
> +		adt7408_show_t_hyst, adt7408_set_t_hyst, 0);
> +IIO_EVENT_ATTR_SH(available_t_hyst, iio_event_adt7408,
> +		adt7408_show_available_t_hyst, NULL, 0);
> +
> +static struct attribute *adt7408_event_attributes[] = {
> +	&iio_event_attr_event_mode.dev_attr.attr,
> +	&iio_event_attr_available_event_modes.dev_attr.attr,
> +	&iio_event_attr_event_crit_only.dev_attr.attr,
> +	&iio_event_attr_event_enable.dev_attr.attr,
> +	&iio_event_attr_alarm_lock.dev_attr.attr,
> +	&iio_event_attr_crit_lock.dev_attr.attr,
> +	&iio_event_attr_t_alarm_high.dev_attr.attr,
> +	&iio_event_attr_t_alarm_low.dev_attr.attr,
> +	&iio_event_attr_t_crit.dev_attr.attr,
> +	&iio_event_attr_t_hyst.dev_attr.attr,
> +	&iio_event_attr_available_t_hyst.dev_attr.attr,
> +	NULL,
> +};
> +
> +static struct attribute_group adt7408_event_attribute_group = {
> +	.attrs = adt7408_event_attributes,
> +};
> +
> +/*
> + * device probe and remove
> + */
> +
> +static int __devinit adt7408_probe(struct i2c_client *client,
> +		const struct i2c_device_id *id)
> +{
> +	struct adt7408_chip_info *chip;
> +	int ret = 0;
> +
> +	chip = kzalloc(sizeof(struct adt7408_chip_info), GFP_KERNEL);
> +
> +	if (chip == NULL)
> +		return -ENOMEM;
> +
> +	/* this is only used for device removal purposes */
> +	i2c_set_clientdata(client, chip);
> +
> +	chip->client = client;
> +	chip->name = id->name;
> +
> +	chip->indio_dev = iio_allocate_device();
> +	if (chip->indio_dev == NULL) {
> +		ret = -ENOMEM;
> +		goto error_free_chip;
> +	}
> +
> +	chip->indio_dev->dev.parent = &client->dev;
> +	chip->indio_dev->attrs = &adt7408_attribute_group;
> +	chip->indio_dev->event_attrs = &adt7408_event_attribute_group;
> +	chip->indio_dev->dev_data = (void *)chip;
> +	chip->indio_dev->driver_module = THIS_MODULE;
> +	chip->indio_dev->num_interrupt_lines = 1;
> +	chip->indio_dev->modes = INDIO_DIRECT_MODE;
> +
> +	ret = iio_device_register(chip->indio_dev);
> +	if (ret)
> +		goto error_free_dev;
> +
> +	if (client->irq) {
> +		ret = iio_register_interrupt_line(client->irq,
> +				chip->indio_dev,
> +				0,
> +				client->irq_flags,
> +				chip->name);
> +		if (ret)
> +			goto error_unreg_dev;
> +
> +		/*
> +		 * The event handler list element refer to iio_event_adt7408.
> +		 * All event attributes bind to the same event handler.
> +		 * So, only register event handler once.
> +		 */
> +		iio_add_event_to_list(&iio_event_adt7408,
> +				&chip->indio_dev->interrupts[0]->ev_list);
> +
> +		INIT_WORK(&chip->thresh_work, adt7408_interrupt_bh);
> +
> +		ret = adt7408_i2c_read(chip, ADT7408_CONFIG, &chip->config);
> +		if (ret) {
> +			ret = -EIO;
> +			goto error_unreg_irq;
> +		}
> +
> +		if (client->irq_flags & IRQF_TRIGGER_HIGH)
> +			chip->config |= ADT7408_EVENT_POLARITY;
> +		else
> +			chip->config &= ~ADT7408_EVENT_POLARITY;
> +
> +		ret = adt7408_i2c_write(chip, ADT7408_CONFIG, chip->config);
> +		if (ret) {
> +			ret = -EIO;
> +			goto error_unreg_irq;
> +		}
> +	}
> +
> +	dev_info(&client->dev, "%s temperature sensor registered.\n",
> +			 id->name);
> +
> +	return 0;
> +
> +error_unreg_irq:
> +	iio_unregister_interrupt_line(chip->indio_dev, 0);
> +error_unreg_dev:
> +	iio_device_unregister(chip->indio_dev);
> +error_free_dev:
> +	iio_free_device(chip->indio_dev);
> +error_free_chip:
> +	kfree(chip);
> +
> +	return ret;
> +}
> +
> +static int __devexit adt7408_remove(struct i2c_client *client)
> +{
> +	struct adt7408_chip_info *chip = i2c_get_clientdata(client);
> +	struct iio_dev *indio_dev = chip->indio_dev;
> +
> +	if (client->irq)
> +		iio_unregister_interrupt_line(indio_dev, 0);
> +	iio_device_unregister(indio_dev);
> +	iio_free_device(chip->indio_dev);
> +	kfree(chip);
> +
> +	return 0;
> +}
> +
> +static const struct i2c_device_id adt7408_id[] = {
> +	{ "adt7408", 0 },
> +	{}
> +};
> +
> +MODULE_DEVICE_TABLE(i2c, adt7408_id);
> +
> +static struct i2c_driver adt7408_driver = {
> +	.driver = {
> +		.name = "adt7408",
> +	},
> +	.probe = adt7408_probe,
> +	.remove = __devexit_p(adt7408_remove),
> +	.id_table = adt7408_id,
> +};
> +
> +static __init int adt7408_init(void)
> +{
> +	return i2c_add_driver(&adt7408_driver);
> +}
> +
> +static __exit void adt7408_exit(void)
> +{
> +	i2c_del_driver(&adt7408_driver);
> +}
> +
> +MODULE_AUTHOR("Sonic Zhang <sonic.zhang@analog.com>");
> +MODULE_DESCRIPTION("Analog Devices ADT7408 digital"
> +			" temperature sensor driver");
> +MODULE_LICENSE("GPL v2");
> +
> +module_init(adt7408_init);
> +module_exit(adt7408_exit);