Add mcp98xx driver to allow temperature reading, and setting of
upper and lower alert thresholds.
Signed-off-by: Matt Ranostay <mranos...@gmail.com>
---
drivers/iio/temperature/Kconfig | 10 +
drivers/iio/temperature/Makefile | 1 +
drivers/iio/temperature/mcp98xx.c | 588 ++++++++++++++++++++++++++++++++++++++
3 files changed, 599 insertions(+)
create mode 100644 drivers/iio/temperature/mcp98xx.c
diff --git a/drivers/iio/temperature/Kconfig b/drivers/iio/temperature/Kconfig
index 21feaa4..1bab442 100644
--- a/drivers/iio/temperature/Kconfig
+++ b/drivers/iio/temperature/Kconfig
@@ -3,6 +3,16 @@
#
menu "Temperature sensors"
+config MCP98XX
+ tristate "MPC98xx temperature sensor"
+ depends on I2C
+ help
+ If you say yes here you get support for the Microchip 98xx series
+ of temperature sensors.
+
+ This driver can also be built as a module. If so, the module will
+ be called mcp98xx.
+
config MLX90614
tristate "MLX90614 contact-less infrared sensor"
depends on I2C
diff --git a/drivers/iio/temperature/Makefile b/drivers/iio/temperature/Makefile
index 40710a8..d67263d 100644
--- a/drivers/iio/temperature/Makefile
+++ b/drivers/iio/temperature/Makefile
@@ -2,5 +2,6 @@
# Makefile for industrial I/O temperature drivers
#
+obj-$(CONFIG_MCP98XX) += mcp98xx.o
obj-$(CONFIG_MLX90614) += mlx90614.o
obj-$(CONFIG_TMP006) += tmp006.o
diff --git a/drivers/iio/temperature/mcp98xx.c
b/drivers/iio/temperature/mcp98xx.c
new file mode 100644
index 0000000..2a98a26
--- /dev/null
+++ b/drivers/iio/temperature/mcp98xx.c
@@ -0,0 +1,588 @@
+/*
+ * mcp98xx.c - Support for Microchip MCP98xx series of temperature sensors
+ *
+ * Copyright (C) 2015 Matt Ranostay <mranos...@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/mutex.h>
+#include <linux/err.h>
+#include <linux/irq.h>
+#include <linux/gpio.h>
+#include <linux/spi/spi.h>
+#include <linux/iio/iio.h>
+#include <linux/i2c.h>
+#include <linux/pm_runtime.h>
+#include <linux/regmap.h>
+#include <linux/iio/iio.h>
+#include <linux/iio/events.h>
+#include <linux/iio/sysfs.h>
+
+#define MCP98XX_REG_CONFIG 0x01
+#define MCP98XX_REG_CONFIG_INT_EN BIT(0)
+#define MCP98XX_REG_CONFIG_ALERT_EN BIT(3)
+#define MCP98XX_REG_CONFIG_CLR_INT BIT(5)
+#define MCP98XX_REG_CONFIG_SHDN BIT(8)
+
+#define MCP98XX_REG_CONFIG_HYSTER_MASK 0x600
+#define MCP98XX_REG_CONFIG_HYSTER_MASK_SHIFT 9
+
+#define MCP98XX_REG_TUPPER 0x02
+#define MCP98XX_REG_TLOWER 0x03
+#define MCP98XX_REG_TCRIT 0x04
+
+#define MCP98XX_REG_TEMP 0x05
+#define MCP98XX_REG_TEMP_TSIGN BIT(12)
+#define MCP98XX_REG_TEMP_TLOWER BIT(13)
+#define MCP98XX_REG_TEMP_TUPPER BIT(14)
+#define MCP98XX_REG_TEMP_MASK 0x1fff
+
+#define MCP98XX_REG_MANF_ID 0x06
+#define MCP98XX_REG_DEV_ID 0x07
+
+#define MCP98XX_REG_RESOLUTION 0x08
+#define MCP98XX_REG_RESOLUTION_MASK 0x03
+
+#define MCP98XX_MAX_INT_TIME_IN_US 300000
+
+#define MCP98XX_DRV_NAME "mcp98xx"
+
+struct mcp98xx_data {
+ struct mutex lock;
+ struct regmap *regmap;
+ struct i2c_client *client;
+
+ /* config */
+ int low_thres_en;
+ int high_thres_en;
+
+ int it_time_in_us;
+ int hysteresis_idx;
+};
+
+static bool mcp98xx_is_volatile_reg(struct device *dev, unsigned int reg)
+{
+ switch (reg) {
+ case MCP98XX_REG_CONFIG:
+ case MCP98XX_REG_TEMP:
+ return true;
+ default:
+ return false;
+ }
+}
+
+static const struct regmap_config mcp98xx_regmap_config = {
+ .reg_bits = 8,
+ .val_bits = 16,
+ .use_single_rw = 1,
+ .max_register = MCP98XX_REG_RESOLUTION,
+ .cache_type = REGCACHE_FLAT,
+ .volatile_reg = mcp98xx_is_volatile_reg,
+};
+
+static const int mcp98xx_it_time_map[] = { 30000, 65000, 130000, 250000 };
+
+static IIO_CONST_ATTR_INT_TIME_AVAIL("0.03 0.065 0.13 0.25");
+
+static const int mcp98xx_hysteresis_map[][2] = {
+ {0, 0}, {1, 500000}, {3, 0}, {6, 0}
+};
+
+static IIO_CONST_ATTR(hysteresis_scale_available, "0 1.5 3 6");
+
+static struct attribute *mcp98xx_attributes[] = {
+ &iio_const_attr_integration_time_available.dev_attr.attr,
+ &iio_const_attr_hysteresis_scale_available.dev_attr.attr,
+ NULL,
+};
+
+static struct attribute_group mcp98xx_attribute_group = {
+ .attrs = mcp98xx_attributes,
+};
+
+static const struct iio_event_spec mcp98xx_event_spec[] = {
+ {
+ .type = IIO_EV_TYPE_THRESH,
+ .dir = IIO_EV_DIR_RISING,
+ .mask_separate = BIT(IIO_EV_INFO_VALUE) |
+ BIT(IIO_EV_INFO_ENABLE),
+ },
+ {
+ .type = IIO_EV_TYPE_THRESH,
+ .dir = IIO_EV_DIR_FALLING,
+ .mask_separate = BIT(IIO_EV_INFO_VALUE) |
+ BIT(IIO_EV_INFO_ENABLE),
+ },
+};
+
+static const struct iio_chan_spec mcp98xx_channels[] = {
+ {
+ .type = IIO_TEMP,
+ .channel = 0,
+ .channel2 = IIO_MOD_TEMP_AMBIENT,
+ .address = MCP98XX_REG_TEMP,
+ .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
+ BIT(IIO_CHAN_INFO_INT_TIME) |
+ BIT(IIO_CHAN_INFO_HYSTERESIS),
+ .modified = 1,
+ .scan_index = -1,
+
+ .event_spec = mcp98xx_event_spec,
+ .num_event_specs = ARRAY_SIZE(mcp98xx_event_spec),
+ }
+};
+
+static int mcp98xx_set_alert_state(struct mcp98xx_data *data, bool state)
+{
+ if (state) {
+ pm_runtime_get(&data->client->dev);
+ } else {
+ pm_runtime_put_autosuspend(&data->client->dev);
+
+ if (data->low_thres_en)
+ state = true;
+ if (data->high_thres_en)
+ state = true;
+ }
+
+ return regmap_update_bits(data->regmap, MCP98XX_REG_CONFIG,
+ MCP98XX_REG_CONFIG_ALERT_EN,
+ state ? MCP98XX_REG_CONFIG_ALERT_EN : 0);
+}
+
+static int mcp98xx_set_sleep(struct mcp98xx_data *data, bool state);
+
+static int mcp98xx_set_it_time(struct mcp98xx_data *data, int val2)
+{
+ int ret = -EINVAL;
+ int idx;
+
+ for (idx = 0; idx < ARRAY_SIZE(mcp98xx_it_time_map); idx++) {
+ if (val2 == mcp98xx_it_time_map[idx]) {
+ mutex_lock(&data->lock);
+ ret = i2c_smbus_write_byte_data(data->client,
+ MCP98XX_REG_RESOLUTION,
+ idx);
+ if (!ret)
+ data->it_time_in_us = val2;
+ mutex_unlock(&data->lock);
+ break;
+ }
+ }
+
+ return ret;
+}
+
+static int mcp98xx_set_hysteresis(struct mcp98xx_data *data, int val, int val2)
+{
+ int ret = -EINVAL;
+ int idx;
+
+ for (idx = 0; idx < ARRAY_SIZE(mcp98xx_hysteresis_map); idx++) {
+ if (mcp98xx_hysteresis_map[idx][0] == val &&
+ mcp98xx_hysteresis_map[idx][1] == val2) {
+
+ mutex_lock(&data->lock);
+ ret = regmap_update_bits(data->regmap,
+ MCP98XX_REG_CONFIG,
+ MCP98XX_REG_CONFIG_HYSTER_MASK,
+ idx << MCP98XX_REG_CONFIG_HYSTER_MASK_SHIFT);
+
+ if (!ret)
+ data->hysteresis_idx = idx;
+ mutex_unlock(&data->lock);
+ break;
+ }
+ }
+ return ret;
+}
+
+#ifdef CONFIG_PM
+static int mcp98xx_power_get(struct mcp98xx_data *data)
+{
+ struct device *dev = &data->client->dev;
+ int suspended;
+ int ret;
+
+ mutex_lock(&data->lock);
+
+ suspended = pm_runtime_suspended(dev);
+ ret = pm_runtime_get_sync(dev);
+
+ /* Wait for a new sample to be ready */
+ if (suspended)
+ usleep_range(data->it_time_in_us, MCP98XX_MAX_INT_TIME_IN_US);
+
+ mutex_unlock(&data->lock);
+
+ return ret;
+}
+
+static int mcp98xx_set_sleep(struct mcp98xx_data *data, bool state)
+{
+ return regmap_update_bits(data->regmap, MCP98XX_REG_CONFIG,
+ MCP98XX_REG_CONFIG_SHDN,
+ state ? MCP98XX_REG_CONFIG_SHDN : 0);
+}
+#else
+static int mcp98xx_power_get(struct mcp98xx_data *data)
+{
+ return 0;
+}
+
+static int mcp98xx_set_sleep(struct mcp98xx_data *data, bool state)
+{
+ return 0;
+}
+#endif
+
+static int mcp98xx_read_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *channel, int *val,
+ int *val2, long mask)
+{
+ struct mcp98xx_data *data = iio_priv(indio_dev);
+
+ switch (mask) {
+ case IIO_CHAN_INFO_PROCESSED:
+ case IIO_CHAN_INFO_RAW: {
+ unsigned int reg;
+ int ret;
+
+ mcp98xx_power_get(data);
+ ret = regmap_read(data->regmap, MCP98XX_REG_TEMP, ®);
+ pm_runtime_put_autosuspend(&data->client->dev);
+ if (ret)
+ return -EINVAL;
+ *val = sign_extend32(reg, 12) >> 4;
+ *val2 = (reg & 0xf) * 62500;
+ return IIO_VAL_INT_PLUS_MICRO;
+ }
+ case IIO_CHAN_INFO_INT_TIME:
+ *val = 0;
+ *val2 = data->it_time_in_us;
+ return IIO_VAL_INT_PLUS_MICRO;
+ case IIO_CHAN_INFO_HYSTERESIS:
+ mutex_lock(&data->lock);
+ *val = mcp98xx_hysteresis_map[data->hysteresis_idx][0];
+ *val2 = mcp98xx_hysteresis_map[data->hysteresis_idx][1];
+ mutex_unlock(&data->lock);
+ return IIO_VAL_INT_PLUS_MICRO;
+ default:
+ return -EINVAL;
+ }
+}
+
+static int mcp98xx_write_raw(struct iio_dev *indio_dev,
+ struct iio_chan_spec const *chan,
+ int val, int val2, long mask)
+{
+ struct mcp98xx_data *data = iio_priv(indio_dev);
+
+ switch (mask) {
+ case IIO_CHAN_INFO_INT_TIME:
+ if (val != 0)
+ return -EINVAL;
+ return mcp98xx_set_it_time(data, val2);
+ case IIO_CHAN_INFO_HYSTERESIS:
+ return mcp98xx_set_hysteresis(data, val, val2);
+ default:
+ return -EINVAL;
+ }
+}
+
+static int mcp98xx_read_event(struct iio_dev *indio_dev,
+ const struct iio_chan_spec *chan,
+ enum iio_event_type type,
+ enum iio_event_direction dir,
+ enum iio_event_info info,
+ int *val, int *val2)
+{
+ struct mcp98xx_data *data = iio_priv(indio_dev);
+ unsigned int reg;
+ int ret;
+
+ switch (dir) {
+ case IIO_EV_DIR_FALLING:
+ ret = regmap_read(data->regmap, MCP98XX_REG_TLOWER, ®);
+ break;
+ case IIO_EV_DIR_RISING:
+ ret = regmap_read(data->regmap, MCP98XX_REG_TUPPER, ®);
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ if (ret)
+ return -EINVAL;
+
+ *val = sign_extend32(reg & MCP98XX_REG_TEMP_MASK, 12) >> 4;
+ *val2 = ((reg & 0xf) >> 2) * 250000;
+
+ return IIO_VAL_INT_PLUS_MICRO;
+};
+
+static int mcp98xx_write_event(struct iio_dev *indio_dev,
+ const struct iio_chan_spec *chan,
+ enum iio_event_type type,
+ enum iio_event_direction dir,
+ enum iio_event_info info,
+ int val, int val2)
+{
+ struct mcp98xx_data *data = iio_priv(indio_dev);
+ u16 buf;
+
+ if (val < -40 || val > 125)
+ return -EINVAL;
+
+ if (val2 < 0 || val2 % 250000)
+ return -EINVAL;
+
+ buf = (val << 4 | (val2 / 250000) << 2) & 0x1ffc;
+
+ switch (dir) {
+ case IIO_EV_DIR_FALLING:
+ return regmap_write(data->regmap, MCP98XX_REG_TLOWER, buf);
+ case IIO_EV_DIR_RISING:
+ return regmap_write(data->regmap, MCP98XX_REG_TUPPER, buf);
+ default:
+ return -EINVAL;
+ }
+}
+
+
+static int mcp98xx_read_event_config(struct iio_dev *indio_dev,
+ const struct iio_chan_spec *chan,
+ enum iio_event_type type,
+ enum iio_event_direction dir)
+{
+ struct mcp98xx_data *data = iio_priv(indio_dev);
+
+ switch (dir) {
+ case IIO_EV_DIR_FALLING:
+ return data->low_thres_en;
+ case IIO_EV_DIR_RISING:
+ return data->high_thres_en;
+ default:
+ return -EINVAL;
+ }
+}
+
+static int mcp98xx_write_event_config(struct iio_dev *indio_dev,
+ const struct iio_chan_spec *chan,
+ enum iio_event_type type,
+ enum iio_event_direction dir,
+ int state)
+{
+ struct mcp98xx_data *data = iio_priv(indio_dev);
+ int ret = 0;
+
+ state = !!state;
+
+ switch (dir) {
+ case IIO_EV_DIR_FALLING:
+ if (data->low_thres_en == state)
+ return -EINVAL;
+ mutex_lock(&data->lock);
+ data->low_thres_en = state;
+
+ ret = mcp98xx_set_alert_state(data, state);
+ mutex_unlock(&data->lock);
+ break;
+ case IIO_EV_DIR_RISING:
+ if (data->high_thres_en == state)
+ return -EINVAL;
+ mutex_lock(&data->lock);
+ data->high_thres_en = state;
+
+ ret = mcp98xx_set_alert_state(data, state);
+ mutex_unlock(&data->lock);
+ break;
+ default:
+ ret = -EINVAL;
+ }
+
+ return ret;
+}
+
+static const struct iio_info mcp98xx_info = {
+ .driver_module = THIS_MODULE,
+ .attrs = &mcp98xx_attribute_group,
+ .read_raw = &mcp98xx_read_raw,
+ .write_raw = &mcp98xx_write_raw,
+ .read_event_value = &mcp98xx_read_event,
+ .write_event_value = &mcp98xx_write_event,
+ .read_event_config = &mcp98xx_read_event_config,
+ .write_event_config = &mcp98xx_write_event_config,
+};
+
+static irqreturn_t mcp98xx_interrupt_handler(int irq, void *private)
+{
+ struct iio_dev *indio_dev = private;
+ struct mcp98xx_data *data = iio_priv(indio_dev);
+ int ret, status;
+
+ ret = regmap_read(data->regmap, MCP98XX_REG_TEMP, &status);
+ if (ret < 0) {
+ dev_err(&data->client->dev, "irq temp reg read failed\n");
+ return IRQ_HANDLED;
+ }
+
+ if ((status & MCP98XX_REG_TEMP_TLOWER) && data->low_thres_en) {
+ iio_push_event(indio_dev,
+ IIO_UNMOD_EVENT_CODE(IIO_TEMP, 0,
+ IIO_EV_TYPE_THRESH,
+ IIO_EV_DIR_FALLING),
+ iio_get_time_ns());
+ }
+
+ if ((status & MCP98XX_REG_TEMP_TUPPER) && data->high_thres_en) {
+ iio_push_event(indio_dev,
+ IIO_UNMOD_EVENT_CODE(IIO_TEMP, 0,
+ IIO_EV_TYPE_THRESH,
+ IIO_EV_DIR_RISING),
+ iio_get_time_ns());
+ }
+
+ regmap_update_bits(data->regmap, MCP98XX_REG_CONFIG,
+ MCP98XX_REG_CONFIG_CLR_INT, 0);
+
+ return IRQ_HANDLED;
+}
+
+static int mcp98xx_probe(struct i2c_client *client,
+ const struct i2c_device_id *id)
+{
+ struct mcp98xx_data *data;
+ struct iio_dev *indio_dev;
+ struct regmap *regmap;
+ int ret;
+
+ indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
+ if (!indio_dev)
+ return -ENOMEM;
+
+ indio_dev->info = &mcp98xx_info,
+ indio_dev->name = MCP98XX_DRV_NAME;
+ indio_dev->channels = mcp98xx_channels;
+ indio_dev->num_channels = 1;
+ indio_dev->modes = INDIO_DIRECT_MODE;
+
+ regmap = devm_regmap_init_i2c(client, &mcp98xx_regmap_config);
+ if (IS_ERR(regmap)) {
+ dev_err(&client->dev, "regmap init failed\n");
+ return PTR_ERR(regmap);
+ }
+
+ data = iio_priv(indio_dev);
+ i2c_set_clientdata(client, indio_dev);
+ data->client = client;
+ data->regmap = regmap;
+ mutex_init(&data->lock);
+
+ ret = devm_request_threaded_irq(&client->dev, client->irq, NULL,
+ &mcp98xx_interrupt_handler,
+ IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+ MCP98XX_DRV_NAME,
+ indio_dev);
+
+ if (ret) {
+ dev_err(&client->dev, "unable to request irq\n");
+ return ret;
+ }
+
+ /* Mask critical threshold interrupt by setting to MAX temp */
+ ret = regmap_write(regmap, MCP98XX_REG_TCRIT, 0xffc);
+ if (ret)
+ return ret;
+
+ ret = pm_runtime_set_active(&client->dev);
+ if (ret)
+ return ret;
+
+ pm_runtime_enable(&client->dev);
+ pm_runtime_set_autosuspend_delay(&client->dev, 1000);
+ pm_runtime_use_autosuspend(&client->dev);
+
+ ret = iio_device_register(indio_dev);
+ if (ret < 0) {
+ dev_err(&client->dev, "unable to register device\n");
+ return ret;
+ }
+
+ /* default to 250ms */
+ mcp98xx_set_it_time(data, 250000);
+
+ /* sleep till a data read or threshold event monitor is requested */
+ mcp98xx_set_sleep(data, true);
+
+ return 0;
+}
+
+static int mcp98xx_remove(struct i2c_client *client)
+{
+ struct iio_dev *indio_dev = i2c_get_clientdata(client);
+
+ iio_device_unregister(indio_dev);
+ mcp98xx_set_sleep(iio_priv(indio_dev), true);
+
+ return 0;
+}
+
+#ifdef CONFIG_PM
+static int mcp98xx_runtime_suspend(struct device *dev)
+{
+ struct mcp98xx_data *data = iio_priv(i2c_get_clientdata(
+ to_i2c_client(dev)));
+
+ return mcp98xx_set_sleep(data, true);
+}
+
+static int mcp98xx_runtime_resume(struct device *dev)
+{
+ struct mcp98xx_data *data = iio_priv(i2c_get_clientdata(
+ to_i2c_client(dev)));
+
+ return mcp98xx_set_sleep(data, false);
+}
+#endif
+
+static const struct dev_pm_ops mcp98xx_pm_ops = {
+ SET_RUNTIME_PM_OPS(mcp98xx_runtime_suspend,
+ mcp98xx_runtime_resume, NULL)
+};
+
+static const struct i2c_device_id mcp98xx_id[] = {
+ {"mcp98xx", 0},
+ {}
+};
+MODULE_DEVICE_TABLE(i2c, mcp98xx_id);
+
+static struct i2c_driver mcp98xx_driver = {
+ .driver = {
+ .name = "mcp98xx",
+ .pm = &mcp98xx_pm_ops,
+ .owner = THIS_MODULE,
+ },
+ .probe = mcp98xx_probe,
+ .remove = mcp98xx_remove,
+ .id_table = mcp98xx_id,
+};
+module_i2c_driver(mcp98xx_driver);
+
+MODULE_AUTHOR("Matt Ranostay <mranos...@gmail.com>");
+MODULE_DESCRIPTION("Microchip MCP98xx temperature sensor");
+MODULE_LICENSE("GPL");
--
1.9.1
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
