On 10/26/10 04:27, Zhang, Sonic wrote: > > >> -----Original Message----- >> From: Jonathan Cameron [mailto:jic23@xxxxxxxxx] >> Sent: Monday, October 25, 2010 6:54 AM >> To: Mike Frysinger >> Cc: linux-iio@xxxxxxxxxxxxxxx; >> device-drivers-devel@xxxxxxxxxxxxxxxxxxxx; Zhang, Sonic; Guenter Roeck >> Subject: Re: [PATCH 12/14] staging: iio: adc: new driver for >> ADT7408 temperature sensors >> >> On 10/23/10 21:29, Mike Frysinger wrote: >>> From: Sonic Zhang <sonic.zhang@xxxxxxxxxx> >> Here we enter new territory. This device is already supported >> in hwmon. Do we have a usecase that is not covered by that driver? >> > > I don't find a way to get event notification other than poll in hwmon > framework. So, I move all temperature devic with interrupt available > to IIO framework. Whilst it isn't often done (and is a little clunky). It is possible to select on sysfs attributes much like any other file. I'm sure Guenter can tell us if any current hwmon devices are doing this? > Sonic > >> 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@xxxxxxxxxx> >>> Signed-off-by: Mike Frysinger <vapier@xxxxxxxxxx> >>> --- >>> 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@xxxxxxxxxx>"); >>> +MODULE_DESCRIPTION("Analog Devices ADT7408 digital" >>> + " temperature sensor driver"); >>> +MODULE_LICENSE("GPL v2"); >>> + >>> +module_init(adt7408_init); >>> +module_exit(adt7408_exit); >> >> > -- To unsubscribe from this list: send the line "unsubscribe linux-iio" in the body of a message to majordomo@xxxxxxxxxxxxxxx More majordomo info at http://vger.kernel.org/majordomo-info.html
