[PATCH v4 0/2] add support to STM HTS221 humidity + temperature sensor

All of lore.kernel.org
 help / color / mirror / Atom feed

* [PATCH v4 0/2] add support to STM HTS221 humidity + temperature sensor
@ 2016-10-13 20:06 ` Lorenzo Bianconi
  0 siblings, 0 replies; 13+ messages in thread
From: Lorenzo Bianconi @ 2016-10-13 20:06 UTC (permalink / raw)
  To: jic23-DgEjT+Ai2ygdnm+yROfE0A
  Cc: linux-iio-u79uwXL29TY76Z2rM5mHXA,
	devicetree-u79uwXL29TY76Z2rM5mHXA, lorenzo.bianconi-qxv4g6HH51o

Changes since v3:
- fix trigger management according to how humidity and temperature samples
  are computed by the device
- define two separate calibration routines to improve code readability
- fix device tree binding
- move driver in humidity folder
- rename hts221_dev in hts221_hw
- code style fixes

Changes since v2:
- fix endianness issue in hts221_parse_caldata()
- make dev->buffer large enough to avoid the memcpy() in
  hts221_buffer_handler_thread()
- remove trigger top half routine and move timestamp sampling in
  hts221_buffer_handler_thread()
- use devm_iio_* routines to register iio_device/trigger and setup
  iio_triggered_buffer
- reduce spi max read/write size
- cosmetics

Changes since v1:
- use single iio_device for both humidity and temperature sensors
- use iio_claim_direct_mode() routine instead of grabbing the mutex directly
- use more unique prefix for all defines
- remove useless dev_info()
- use of_match_ptr instead of access directly to of_match_table
- use devm_iio_* routines
- use info_mask_shared_by_all element for sampling_frequency
- use oversampling ABI for humidityrelative_avg_sample and temp_avg_sample

Lorenzo Bianconi (2):
  iio: humidity: add support to hts221 rh/temp combo device
  Documentation: dt: iio: humidity: add hts221 sensor device binding

 .../devicetree/bindings/iio/humidity/hts221.txt    |  22 +
 drivers/iio/humidity/Kconfig                       |  22 +
 drivers/iio/humidity/Makefile                      |   7 +
 drivers/iio/humidity/hts221.h                      |  73 +++
 drivers/iio/humidity/hts221_buffer.c               | 168 +++++
 drivers/iio/humidity/hts221_core.c                 | 687 +++++++++++++++++++++
 drivers/iio/humidity/hts221_i2c.c                  | 110 ++++
 drivers/iio/humidity/hts221_spi.c                  | 125 ++++
 8 files changed, 1214 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/iio/humidity/hts221.txt
 create mode 100644 drivers/iio/humidity/hts221.h
 create mode 100644 drivers/iio/humidity/hts221_buffer.c
 create mode 100644 drivers/iio/humidity/hts221_core.c
 create mode 100644 drivers/iio/humidity/hts221_i2c.c
 create mode 100644 drivers/iio/humidity/hts221_spi.c

-- 
2.7.4

--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

^ permalink raw reply	[flat|nested] 13+ messages in thread

* [PATCH v4 0/2] add support to STM HTS221 humidity + temperature sensor
@ 2016-10-13 20:06 ` Lorenzo Bianconi
  0 siblings, 0 replies; 13+ messages in thread
From: Lorenzo Bianconi @ 2016-10-13 20:06 UTC (permalink / raw)
  To: jic23; +Cc: linux-iio, devicetree, lorenzo.bianconi

Changes since v3:
- fix trigger management according to how humidity and temperature samples
  are computed by the device
- define two separate calibration routines to improve code readability
- fix device tree binding
- move driver in humidity folder
- rename hts221_dev in hts221_hw
- code style fixes

Changes since v2:
- fix endianness issue in hts221_parse_caldata()
- make dev->buffer large enough to avoid the memcpy() in
  hts221_buffer_handler_thread()
- remove trigger top half routine and move timestamp sampling in
  hts221_buffer_handler_thread()
- use devm_iio_* routines to register iio_device/trigger and setup
  iio_triggered_buffer
- reduce spi max read/write size
- cosmetics

Changes since v1:
- use single iio_device for both humidity and temperature sensors
- use iio_claim_direct_mode() routine instead of grabbing the mutex directly
- use more unique prefix for all defines
- remove useless dev_info()
- use of_match_ptr instead of access directly to of_match_table
- use devm_iio_* routines
- use info_mask_shared_by_all element for sampling_frequency
- use oversampling ABI for humidityrelative_avg_sample and temp_avg_sample

Lorenzo Bianconi (2):
  iio: humidity: add support to hts221 rh/temp combo device
  Documentation: dt: iio: humidity: add hts221 sensor device binding

 .../devicetree/bindings/iio/humidity/hts221.txt    |  22 +
 drivers/iio/humidity/Kconfig                       |  22 +
 drivers/iio/humidity/Makefile                      |   7 +
 drivers/iio/humidity/hts221.h                      |  73 +++
 drivers/iio/humidity/hts221_buffer.c               | 168 +++++
 drivers/iio/humidity/hts221_core.c                 | 687 +++++++++++++++++++++
 drivers/iio/humidity/hts221_i2c.c                  | 110 ++++
 drivers/iio/humidity/hts221_spi.c                  | 125 ++++
 8 files changed, 1214 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/iio/humidity/hts221.txt
 create mode 100644 drivers/iio/humidity/hts221.h
 create mode 100644 drivers/iio/humidity/hts221_buffer.c
 create mode 100644 drivers/iio/humidity/hts221_core.c
 create mode 100644 drivers/iio/humidity/hts221_i2c.c
 create mode 100644 drivers/iio/humidity/hts221_spi.c

-- 
2.7.4


^ permalink raw reply	[flat|nested] 13+ messages in thread

* [PATCH v4 1/2] iio: humidity: add support to hts221 rh/temp combo device
  2016-10-13 20:06 ` Lorenzo Bianconi
@ 2016-10-13 20:06     ` Lorenzo Bianconi
  -1 siblings, 0 replies; 13+ messages in thread
From: Lorenzo Bianconi @ 2016-10-13 20:06 UTC (permalink / raw)
  To: jic23-DgEjT+Ai2ygdnm+yROfE0A
  Cc: linux-iio-u79uwXL29TY76Z2rM5mHXA,
	devicetree-u79uwXL29TY76Z2rM5mHXA, lorenzo.bianconi-qxv4g6HH51o

Add support to STM HTS221 humidity + temperature sensor

http://www.st.com/resource/en/datasheet/hts221.pdf

- continuous mode support
- i2c support
- spi support
- trigger mode support

Signed-off-by: Lorenzo Bianconi <lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>
---
 drivers/iio/humidity/Kconfig         |  22 ++
 drivers/iio/humidity/Makefile        |   7 +
 drivers/iio/humidity/hts221.h        |  73 ++++
 drivers/iio/humidity/hts221_buffer.c | 168 +++++++++
 drivers/iio/humidity/hts221_core.c   | 687 +++++++++++++++++++++++++++++++++++
 drivers/iio/humidity/hts221_i2c.c    | 110 ++++++
 drivers/iio/humidity/hts221_spi.c    | 125 +++++++
 7 files changed, 1192 insertions(+)
 create mode 100644 drivers/iio/humidity/hts221.h
 create mode 100644 drivers/iio/humidity/hts221_buffer.c
 create mode 100644 drivers/iio/humidity/hts221_core.c
 create mode 100644 drivers/iio/humidity/hts221_i2c.c
 create mode 100644 drivers/iio/humidity/hts221_spi.c

diff --git a/drivers/iio/humidity/Kconfig b/drivers/iio/humidity/Kconfig
index b17e2e2..6fd11d0 100644
--- a/drivers/iio/humidity/Kconfig
+++ b/drivers/iio/humidity/Kconfig
@@ -34,6 +34,28 @@ config HDC100X
 	  To compile this driver as a module, choose M here: the module
 	  will be called hdc100x.
 
+config HTS221
+	tristate "STMicroelectronics HTS221 sensor Driver"
+	depends on (I2C || SPI)
+	select IIO_BUFFER
+	select IIO_TRIGGERED_BUFFER
+	select HTS221_I2C if (I2C)
+	select HTS221_SPI if (SPI_MASTER)
+	help
+	  Say yes here to build support for STMicroelectronics HTS221
+	  temperature-humidity sensor
+
+	  To compile this driver as a module, choose M here: the module
+	  will be called hts221.
+
+config HTS221_I2C
+	tristate
+	depends on HTS221
+
+config HTS221_SPI
+	tristate
+	depends on HTS221
+
 config HTU21
 	tristate "Measurement Specialties HTU21 humidity & temperature sensor"
 	depends on I2C
diff --git a/drivers/iio/humidity/Makefile b/drivers/iio/humidity/Makefile
index 4a73442..a6850e4 100644
--- a/drivers/iio/humidity/Makefile
+++ b/drivers/iio/humidity/Makefile
@@ -5,6 +5,13 @@
 obj-$(CONFIG_AM2315) += am2315.o
 obj-$(CONFIG_DHT11) += dht11.o
 obj-$(CONFIG_HDC100X) += hdc100x.o
+
+hts221-y := hts221_core.o \
+	    hts221_buffer.o
+obj-$(CONFIG_HTS221) += hts221.o
+obj-$(CONFIG_HTS221_I2C) += hts221_i2c.o
+obj-$(CONFIG_HTS221_SPI) += hts221_spi.o
+
 obj-$(CONFIG_HTU21) += htu21.o
 obj-$(CONFIG_SI7005) += si7005.o
 obj-$(CONFIG_SI7020) += si7020.o
diff --git a/drivers/iio/humidity/hts221.h b/drivers/iio/humidity/hts221.h
new file mode 100644
index 0000000..0d2993c
--- /dev/null
+++ b/drivers/iio/humidity/hts221.h
@@ -0,0 +1,73 @@
+/*
+ * STMicroelectronics hts221 sensor driver
+ *
+ * Copyright 2016 STMicroelectronics Inc.
+ *
+ * Lorenzo Bianconi <lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>
+ *
+ * Licensed under the GPL-2.
+ */
+
+#ifndef HTS221_H
+#define HTS221_H
+
+#define HTS221_DEV_NAME		"hts221"
+
+#include <linux/iio/iio.h>
+
+#define HTS221_RX_MAX_LENGTH	8
+#define HTS221_TX_MAX_LENGTH	8
+
+#define HTS221_DATA_SIZE	2
+
+struct hts221_transfer_buffer {
+	u8 rx_buf[HTS221_RX_MAX_LENGTH];
+	u8 tx_buf[HTS221_TX_MAX_LENGTH] ____cacheline_aligned;
+};
+
+struct hts221_transfer_function {
+	int (*read)(struct device *dev, u8 addr, int len, u8 *data);
+	int (*write)(struct device *dev, u8 addr, int len, u8 *data);
+};
+
+#define HTS221_AVG_DEPTH	8
+struct hts221_avg_avl {
+	u16 avg;
+	u8 val;
+};
+
+enum hts221_sensor_type {
+	HTS221_SENSOR_H,
+	HTS221_SENSOR_T,
+	HTS221_SENSOR_MAX,
+};
+
+struct hts221_sensor {
+	u8 cur_avg_idx;
+	int slope, b_gen;
+};
+
+struct hts221_hw {
+	const char *name;
+	struct device *dev;
+
+	struct mutex lock;
+	struct iio_trigger *trig;
+	int irq;
+
+	struct hts221_sensor sensors[HTS221_SENSOR_MAX];
+
+	u8 odr;
+
+	const struct hts221_transfer_function *tf;
+	struct hts221_transfer_buffer tb;
+};
+
+int hts221_config_drdy(struct hts221_hw *hw, bool enable);
+int hts221_probe(struct iio_dev *iio_dev);
+int hts221_power_on(struct hts221_hw *hw);
+int hts221_power_off(struct hts221_hw *hw);
+int hts221_allocate_buffers(struct hts221_hw *hw);
+int hts221_allocate_triggers(struct hts221_hw *hw);
+
+#endif /* HTS221_H */
diff --git a/drivers/iio/humidity/hts221_buffer.c b/drivers/iio/humidity/hts221_buffer.c
new file mode 100644
index 0000000..6b174fd
--- /dev/null
+++ b/drivers/iio/humidity/hts221_buffer.c
@@ -0,0 +1,168 @@
+/*
+ * STMicroelectronics hts221 sensor driver
+ *
+ * Copyright 2016 STMicroelectronics Inc.
+ *
+ * Lorenzo Bianconi <lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>
+ *
+ * Licensed under the GPL-2.
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/interrupt.h>
+#include <linux/irqreturn.h>
+
+#include <linux/iio/iio.h>
+#include <linux/iio/trigger.h>
+#include <linux/interrupt.h>
+#include <linux/iio/events.h>
+#include <linux/iio/trigger_consumer.h>
+#include <linux/iio/triggered_buffer.h>
+#include <linux/iio/buffer.h>
+
+#include "hts221.h"
+
+#define HTS221_REG_STATUS_ADDR		0x27
+#define HTS221_RH_DRDY_MASK		BIT(1)
+#define HTS221_TEMP_DRDY_MASK		BIT(0)
+
+static int hts221_trig_set_state(struct iio_trigger *trig, bool state)
+{
+	struct iio_dev *iio_dev = iio_trigger_get_drvdata(trig);
+	struct hts221_hw *hw = iio_priv(iio_dev);
+
+	return hts221_config_drdy(hw, state);
+}
+
+static const struct iio_trigger_ops hts221_trigger_ops = {
+	.owner = THIS_MODULE,
+	.set_trigger_state = hts221_trig_set_state,
+};
+
+static irqreturn_t hts221_trigger_handler_thread(int irq, void *private)
+{
+	struct hts221_hw *hw = (struct hts221_hw *)private;
+	u8 status;
+	int err;
+
+	err = hw->tf->read(hw->dev, HTS221_REG_STATUS_ADDR, sizeof(status),
+			   &status);
+	if (err < 0)
+		return IRQ_HANDLED;
+
+	/* H_DA bit (humidity data available) is routed to DRDY line.
+	 * Humidity sample is computed after temperature one.
+	 * Here we can assume data channels are both available if H_DA bit
+	 * is set in status register
+	 */
+	if (!(status & HTS221_RH_DRDY_MASK))
+		return IRQ_NONE;
+
+	iio_trigger_poll_chained(hw->trig);
+
+	return IRQ_HANDLED;
+}
+
+int hts221_allocate_triggers(struct hts221_hw *hw)
+{
+	struct iio_dev *iio_dev = iio_priv_to_dev(hw);
+	unsigned long irq_type;
+	int err;
+
+	irq_type = irqd_get_trigger_type(irq_get_irq_data(hw->irq));
+
+	switch (irq_type) {
+	case IRQF_TRIGGER_HIGH:
+	case IRQF_TRIGGER_RISING:
+		break;
+	default:
+		dev_info(hw->dev,
+			 "mode %lx unsupported, using IRQF_TRIGGER_RISING\n",
+			 irq_type);
+		irq_type = IRQF_TRIGGER_RISING;
+		break;
+	}
+
+	err = devm_request_threaded_irq(hw->dev, hw->irq, NULL,
+					hts221_trigger_handler_thread,
+					irq_type | IRQF_ONESHOT,
+					hw->name, hw);
+	if (err) {
+		dev_err(hw->dev, "failed to request trigger irq %d\n",
+			hw->irq);
+		return err;
+	}
+
+	hw->trig = devm_iio_trigger_alloc(hw->dev, "%s-trigger",
+					  iio_dev->name);
+	if (!hw->trig)
+		return -ENOMEM;
+
+	iio_trigger_set_drvdata(hw->trig, iio_dev);
+	hw->trig->ops = &hts221_trigger_ops;
+	hw->trig->dev.parent = hw->dev;
+	iio_dev->trig = iio_trigger_get(hw->trig);
+
+	return devm_iio_trigger_register(hw->dev, hw->trig);
+}
+
+static int hts221_buffer_preenable(struct iio_dev *iio_dev)
+{
+	return hts221_power_on(iio_priv(iio_dev));
+}
+
+static int hts221_buffer_postdisable(struct iio_dev *iio_dev)
+{
+	return hts221_power_off(iio_priv(iio_dev));
+}
+
+static const struct iio_buffer_setup_ops hts221_buffer_ops = {
+	.preenable = hts221_buffer_preenable,
+	.postenable = iio_triggered_buffer_postenable,
+	.predisable = iio_triggered_buffer_predisable,
+	.postdisable = hts221_buffer_postdisable,
+};
+
+static irqreturn_t hts221_buffer_handler_thread(int irq, void *p)
+{
+	u8 buffer[ALIGN(2 * HTS221_DATA_SIZE, sizeof(s64)) + sizeof(s64)];
+	struct iio_poll_func *pf = p;
+	struct iio_dev *iio_dev = pf->indio_dev;
+	struct hts221_hw *hw = iio_priv(iio_dev);
+	struct iio_chan_spec const *ch;
+	int err;
+
+	/* humidity data */
+	ch = &iio_dev->channels[HTS221_SENSOR_H];
+	err = hw->tf->read(hw->dev, ch->address, HTS221_DATA_SIZE,
+			   buffer);
+	if (err < 0)
+		goto out;
+
+	/* temperature data */
+	ch = &iio_dev->channels[HTS221_SENSOR_T];
+	err = hw->tf->read(hw->dev, ch->address, HTS221_DATA_SIZE,
+			   buffer + HTS221_DATA_SIZE);
+	if (err < 0)
+		goto out;
+
+	iio_push_to_buffers_with_timestamp(iio_dev, buffer,
+					   iio_get_time_ns(iio_dev));
+
+out:
+	iio_trigger_notify_done(hw->trig);
+
+	return IRQ_HANDLED;
+}
+
+int hts221_allocate_buffers(struct hts221_hw *hw)
+{
+	return devm_iio_triggered_buffer_setup(hw->dev, iio_priv_to_dev(hw),
+					NULL, hts221_buffer_handler_thread,
+					&hts221_buffer_ops);
+}
+
+MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>");
+MODULE_DESCRIPTION("STMicroelectronics hts221 buffer driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/humidity/hts221_core.c b/drivers/iio/humidity/hts221_core.c
new file mode 100644
index 0000000..5a099dd
--- /dev/null
+++ b/drivers/iio/humidity/hts221_core.c
@@ -0,0 +1,687 @@
+/*
+ * STMicroelectronics hts221 sensor driver
+ *
+ * Copyright 2016 STMicroelectronics Inc.
+ *
+ * Lorenzo Bianconi <lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>
+ *
+ * Licensed under the GPL-2.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/iio/sysfs.h>
+#include <linux/delay.h>
+#include <asm/unaligned.h>
+
+#include "hts221.h"
+
+#define HTS221_REG_WHOAMI_ADDR		0x0f
+#define HTS221_REG_WHOAMI_VAL		0xbc
+
+#define HTS221_REG_CNTRL1_ADDR		0x20
+#define HTS221_REG_CNTRL2_ADDR		0x21
+#define HTS221_REG_CNTRL3_ADDR		0x22
+
+#define HTS221_REG_AVG_ADDR		0x10
+#define HTS221_REG_H_OUT_L		0x28
+#define HTS221_REG_T_OUT_L		0x2a
+
+#define HTS221_HUMIDITY_AVG_MASK	0x07
+#define HTS221_TEMP_AVG_MASK		0x38
+
+#define HTS221_ODR_MASK			0x87
+#define HTS221_BDU_MASK			BIT(2)
+
+#define HTS221_DRDY_MASK		BIT(2)
+
+#define HTS221_ENABLE_SENSOR		BIT(7)
+
+#define HTS221_HUMIDITY_AVG_4		0x00 /* 0.4 %RH */
+#define HTS221_HUMIDITY_AVG_8		0x01 /* 0.3 %RH */
+#define HTS221_HUMIDITY_AVG_16		0x02 /* 0.2 %RH */
+#define HTS221_HUMIDITY_AVG_32		0x03 /* 0.15 %RH */
+#define HTS221_HUMIDITY_AVG_64		0x04 /* 0.1 %RH */
+#define HTS221_HUMIDITY_AVG_128		0x05 /* 0.07 %RH */
+#define HTS221_HUMIDITY_AVG_256		0x06 /* 0.05 %RH */
+#define HTS221_HUMIDITY_AVG_512		0x07 /* 0.03 %RH */
+
+#define HTS221_TEMP_AVG_2		0x00 /* 0.08 degC */
+#define HTS221_TEMP_AVG_4		0x08 /* 0.05 degC */
+#define HTS221_TEMP_AVG_8		0x10 /* 0.04 degC */
+#define HTS221_TEMP_AVG_16		0x18 /* 0.03 degC */
+#define HTS221_TEMP_AVG_32		0x20 /* 0.02 degC */
+#define HTS221_TEMP_AVG_64		0x28 /* 0.015 degC */
+#define HTS221_TEMP_AVG_128		0x30 /* 0.01 degC */
+#define HTS221_TEMP_AVG_256		0x38 /* 0.007 degC */
+
+/* calibration registers */
+#define HTS221_REG_0RH_CAL_X_H		0x36
+#define HTS221_REG_1RH_CAL_X_H		0x3a
+#define HTS221_REG_0RH_CAL_Y_H		0x30
+#define HTS221_REG_1RH_CAL_Y_H		0x31
+#define HTS221_REG_0T_CAL_X_L		0x3c
+#define HTS221_REG_1T_CAL_X_L		0x3e
+#define HTS221_REG_0T_CAL_Y_H		0x32
+#define HTS221_REG_1T_CAL_Y_H		0x33
+#define HTS221_REG_T1_T0_CAL_Y_H	0x35
+
+struct hts221_odr {
+	u8 hz;
+	u8 val;
+};
+
+struct hts221_avg {
+	u8 addr;
+	u8 mask;
+	struct hts221_avg_avl avg_avl[HTS221_AVG_DEPTH];
+};
+
+static const struct hts221_odr hts221_odr_table[] = {
+	{  1, 0x01 },	/* 1Hz */
+	{  7, 0x02 },	/* 7Hz */
+	{ 13, 0x03 },	/* 12.5Hz */
+};
+
+static const struct hts221_avg hts221_avg_list[] = {
+	{
+		.addr = HTS221_REG_AVG_ADDR,
+		.mask = HTS221_HUMIDITY_AVG_MASK,
+		.avg_avl = {
+			{ 4, HTS221_HUMIDITY_AVG_4 },
+			{ 8, HTS221_HUMIDITY_AVG_8 },
+			{ 16, HTS221_HUMIDITY_AVG_16 },
+			{ 32, HTS221_HUMIDITY_AVG_32 },
+			{ 64, HTS221_HUMIDITY_AVG_64 },
+			{ 128, HTS221_HUMIDITY_AVG_128 },
+			{ 256, HTS221_HUMIDITY_AVG_256 },
+			{ 512, HTS221_HUMIDITY_AVG_512 },
+		},
+	},
+	{
+		.addr = HTS221_REG_AVG_ADDR,
+		.mask = HTS221_TEMP_AVG_MASK,
+		.avg_avl = {
+			{ 2, HTS221_TEMP_AVG_2 },
+			{ 4, HTS221_TEMP_AVG_4 },
+			{ 8, HTS221_TEMP_AVG_8 },
+			{ 16, HTS221_TEMP_AVG_16 },
+			{ 32, HTS221_TEMP_AVG_32 },
+			{ 64, HTS221_TEMP_AVG_64 },
+			{ 128, HTS221_TEMP_AVG_128 },
+			{ 256, HTS221_TEMP_AVG_256 },
+		},
+	},
+};
+
+static const struct iio_chan_spec hts221_channels[] = {
+	{
+		.type = IIO_HUMIDITYRELATIVE,
+		.address = HTS221_REG_H_OUT_L,
+		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
+				      BIT(IIO_CHAN_INFO_OFFSET) |
+				      BIT(IIO_CHAN_INFO_SCALE) |
+				      BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
+		.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
+		.scan_index = 0,
+		.scan_type = {
+			.sign = 's',
+			.realbits = 16,
+			.storagebits = 16,
+			.endianness = IIO_LE,
+		},
+	},
+	{
+		.type = IIO_TEMP,
+		.address = HTS221_REG_T_OUT_L,
+		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
+				      BIT(IIO_CHAN_INFO_OFFSET) |
+				      BIT(IIO_CHAN_INFO_SCALE) |
+				      BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
+		.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
+		.scan_index = 1,
+		.scan_type = {
+			.sign = 's',
+			.realbits = 16,
+			.storagebits = 16,
+			.endianness = IIO_LE,
+		},
+	},
+	IIO_CHAN_SOFT_TIMESTAMP(2),
+};
+
+static int hts221_write_with_mask(struct hts221_hw *hw, u8 addr, u8 mask,
+				  u8 val)
+{
+	u8 data;
+	int err;
+
+	mutex_lock(&hw->lock);
+
+	err = hw->tf->read(hw->dev, addr, sizeof(data), &data);
+	if (err < 0) {
+		dev_err(hw->dev, "failed to read %02x register\n", addr);
+		goto unlock;
+	}
+
+	data = (data & ~mask) | (val & mask);
+
+	err = hw->tf->write(hw->dev, addr, sizeof(data), &data);
+	if (err < 0)
+		dev_err(hw->dev, "failed to write %02x register\n", addr);
+
+unlock:
+	mutex_unlock(&hw->lock);
+
+	return err;
+}
+
+static int hts221_check_whoami(struct hts221_hw *hw)
+{
+	u8 data;
+	int err;
+
+	err = hw->tf->read(hw->dev, HTS221_REG_WHOAMI_ADDR, sizeof(data),
+			   &data);
+	if (err < 0) {
+		dev_err(hw->dev, "failed to read whoami register\n");
+		return err;
+	}
+
+	if (data != HTS221_REG_WHOAMI_VAL) {
+		dev_err(hw->dev, "wrong whoami {%02x vs %02x}\n",
+			data, HTS221_REG_WHOAMI_VAL);
+		return -ENODEV;
+	}
+
+	return 0;
+}
+
+int hts221_config_drdy(struct hts221_hw *hw, bool enable)
+{
+	u8 val = enable ? BIT(2) : 0;
+	int err;
+
+	err = hts221_write_with_mask(hw, HTS221_REG_CNTRL3_ADDR,
+				     HTS221_DRDY_MASK, val);
+
+	return err < 0 ? err : 0;
+}
+
+static int hts221_update_odr(struct hts221_hw *hw, u8 odr)
+{
+	int i, err;
+	u8 val;
+
+	for (i = 0; i < ARRAY_SIZE(hts221_odr_table); i++)
+		if (hts221_odr_table[i].hz == odr)
+			break;
+
+	if (i == ARRAY_SIZE(hts221_odr_table))
+		return -EINVAL;
+
+	val = HTS221_ENABLE_SENSOR | HTS221_BDU_MASK | hts221_odr_table[i].val;
+	err = hts221_write_with_mask(hw, HTS221_REG_CNTRL1_ADDR,
+				     HTS221_ODR_MASK, val);
+	if (err < 0)
+		return err;
+
+	hw->odr = odr;
+
+	return 0;
+}
+
+static int hts221_update_avg(struct hts221_hw *hw,
+			     enum hts221_sensor_type type,
+			     u16 val)
+{
+	int i, err;
+	const struct hts221_avg *avg = &hts221_avg_list[type];
+
+	for (i = 0; i < HTS221_AVG_DEPTH; i++)
+		if (avg->avg_avl[i].avg == val)
+			break;
+
+	if (i == HTS221_AVG_DEPTH)
+		return -EINVAL;
+
+	err = hts221_write_with_mask(hw, avg->addr, avg->mask,
+				     avg->avg_avl[i].val);
+	if (err < 0)
+		return err;
+
+	hw->sensors[type].cur_avg_idx = i;
+
+	return 0;
+}
+
+static ssize_t hts221_sysfs_sampling_freq(struct device *dev,
+					  struct device_attribute *attr,
+					  char *buf)
+{
+	int i;
+	ssize_t len = 0;
+
+	for (i = 0; i < ARRAY_SIZE(hts221_odr_table); i++)
+		len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
+				 hts221_odr_table[i].hz);
+	buf[len - 1] = '\n';
+
+	return len;
+}
+
+static ssize_t
+hts221_sysfs_rh_oversampling_avail(struct device *dev,
+				   struct device_attribute *attr,
+				   char *buf)
+{
+	const struct hts221_avg *avg = &hts221_avg_list[HTS221_SENSOR_H];
+	ssize_t len = 0;
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(avg->avg_avl); i++)
+		len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
+				 avg->avg_avl[i].avg);
+	buf[len - 1] = '\n';
+
+	return len;
+}
+
+static ssize_t
+hts221_sysfs_temp_oversampling_avail(struct device *dev,
+				     struct device_attribute *attr,
+				     char *buf)
+{
+	const struct hts221_avg *avg = &hts221_avg_list[HTS221_SENSOR_T];
+	ssize_t len = 0;
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(avg->avg_avl); i++)
+		len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
+				 avg->avg_avl[i].avg);
+	buf[len - 1] = '\n';
+
+	return len;
+}
+
+int hts221_power_on(struct hts221_hw *hw)
+{
+	return hts221_update_odr(hw, hw->odr);
+}
+
+int hts221_power_off(struct hts221_hw *hw)
+{
+	u8 data[] = {0x00, 0x00};
+
+	return hw->tf->write(hw->dev, HTS221_REG_CNTRL1_ADDR, sizeof(data),
+			     data);
+}
+
+static int hts221_parse_temp_caldata(struct hts221_hw *hw)
+{
+	int err, *slope, *b_gen;
+	s16 cal_x0, cal_x1, cal_y0, cal_y1;
+	u8 cal0, cal1;
+
+	err = hw->tf->read(hw->dev, HTS221_REG_0T_CAL_Y_H,
+			   sizeof(cal0), &cal0);
+	if (err < 0)
+		return err;
+
+	err = hw->tf->read(hw->dev, HTS221_REG_T1_T0_CAL_Y_H,
+			   sizeof(cal1), &cal1);
+	if (err < 0)
+		return err;
+	cal_y0 = (le16_to_cpu(cal1 & 0x3) << 8) | cal0;
+
+	err = hw->tf->read(hw->dev, HTS221_REG_1T_CAL_Y_H,
+			   sizeof(cal0), &cal0);
+	if (err < 0)
+		return err;
+	cal_y1 = (((cal1 & 0xc) >> 2) << 8) | cal0;
+
+	err = hw->tf->read(hw->dev, HTS221_REG_0T_CAL_X_L, sizeof(cal_x0),
+			   (u8 *)&cal_x0);
+	if (err < 0)
+		return err;
+	cal_x0 = le16_to_cpu(cal_x0);
+
+	err = hw->tf->read(hw->dev, HTS221_REG_1T_CAL_X_L, sizeof(cal_x1),
+			   (u8 *)&cal_x1);
+	if (err < 0)
+		return err;
+	cal_x1 = le16_to_cpu(cal_x1);
+
+	slope = &hw->sensors[HTS221_SENSOR_T].slope;
+	b_gen = &hw->sensors[HTS221_SENSOR_T].b_gen;
+
+	*slope = ((cal_y1 - cal_y0) * 8000) / (cal_x1 - cal_x0);
+	*b_gen = (((s32)cal_x1 * cal_y0 - (s32)cal_x0 * cal_y1) * 1000) /
+		 (cal_x1 - cal_x0);
+	*b_gen *= 8;
+
+	return 0;
+}
+
+static int hts221_parse_rh_caldata(struct hts221_hw *hw)
+{
+	int err, *slope, *b_gen;
+	s16 cal_x0, cal_x1, cal_y0, cal_y1;
+	u8 data;
+
+	err = hw->tf->read(hw->dev, HTS221_REG_0RH_CAL_Y_H, sizeof(data),
+			   &data);
+	if (err < 0)
+		return err;
+	cal_y0 = data;
+
+	err = hw->tf->read(hw->dev, HTS221_REG_1RH_CAL_Y_H, sizeof(data),
+			   &data);
+	if (err < 0)
+		return err;
+	cal_y1 = data;
+
+	err = hw->tf->read(hw->dev, HTS221_REG_0RH_CAL_X_H, sizeof(cal_x0),
+			   (u8 *)&cal_x0);
+	if (err < 0)
+		return err;
+	cal_x0 = le16_to_cpu(cal_x0);
+
+	err = hw->tf->read(hw->dev, HTS221_REG_1RH_CAL_X_H, sizeof(cal_x1),
+			   (u8 *)&cal_x1);
+	if (err < 0)
+		return err;
+	cal_x1 = le16_to_cpu(cal_x1);
+
+	slope = &hw->sensors[HTS221_SENSOR_H].slope;
+	b_gen = &hw->sensors[HTS221_SENSOR_H].b_gen;
+
+	*slope = ((cal_y1 - cal_y0) * 8000) / (cal_x1 - cal_x0);
+	*b_gen = (((s32)cal_x1 * cal_y0 - (s32)cal_x0 * cal_y1) * 1000) /
+		 (cal_x1 - cal_x0);
+	*b_gen *= 8;
+
+	return 0;
+}
+
+static int hts221_get_sensor_scale(struct hts221_hw *hw,
+				   enum iio_chan_type ch_type,
+				   int *val, int *val2)
+{
+	s64 tmp;
+	s32 rem, div, data;
+
+	switch (ch_type) {
+	case IIO_HUMIDITYRELATIVE:
+		data = hw->sensors[HTS221_SENSOR_H].slope;
+		div = (1 << 4) * 1000;
+		break;
+	case IIO_TEMP:
+		data = hw->sensors[HTS221_SENSOR_T].slope;
+		div = (1 << 6) * 1000;
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	tmp = div_s64(data * 1000000000LL, div);
+	tmp = div_s64_rem(tmp, 1000000000LL, &rem);
+
+	*val = tmp;
+	*val2 = rem;
+
+	return IIO_VAL_INT_PLUS_NANO;
+}
+
+static int hts221_get_sensor_offset(struct hts221_hw *hw,
+				    enum iio_chan_type ch_type,
+				    int *val, int *val2)
+{
+	s64 tmp;
+	s32 rem, div, data;
+
+	switch (ch_type) {
+	case IIO_HUMIDITYRELATIVE:
+		data = hw->sensors[HTS221_SENSOR_H].b_gen;
+		div = hw->sensors[HTS221_SENSOR_H].slope;
+		break;
+	case IIO_TEMP:
+		data = hw->sensors[HTS221_SENSOR_T].b_gen;
+		div = hw->sensors[HTS221_SENSOR_T].slope;
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	tmp = div_s64(data * 1000000000LL, div);
+	tmp = div_s64_rem(tmp, 1000000000LL, &rem);
+
+	*val = tmp;
+	*val2 = rem;
+
+	return IIO_VAL_INT_PLUS_NANO;
+}
+
+static int hts221_read_oneshot(struct hts221_hw *hw, u8 addr, int *val)
+{
+	u8 data[HTS221_DATA_SIZE];
+	int err;
+
+	err = hts221_power_on(hw);
+	if (err < 0)
+		return err;
+
+	msleep(50);
+
+	err = hw->tf->read(hw->dev, addr, sizeof(data), data);
+	if (err < 0)
+		return err;
+
+	hts221_power_off(hw);
+
+	*val = (s16)get_unaligned_le16(data);
+
+	return IIO_VAL_INT;
+}
+
+static int hts221_read_raw(struct iio_dev *iio_dev,
+			   struct iio_chan_spec const *ch,
+			   int *val, int *val2, long mask)
+{
+	struct hts221_hw *hw = iio_priv(iio_dev);
+	int ret;
+
+	ret = iio_device_claim_direct_mode(iio_dev);
+	if (ret)
+		return ret;
+
+	switch (mask) {
+	case IIO_CHAN_INFO_RAW:
+		ret = hts221_read_oneshot(hw, ch->address, val);
+		break;
+	case IIO_CHAN_INFO_SCALE:
+		ret = hts221_get_sensor_scale(hw, ch->type, val, val2);
+		break;
+	case IIO_CHAN_INFO_OFFSET:
+		ret = hts221_get_sensor_offset(hw, ch->type, val, val2);
+		break;
+	case IIO_CHAN_INFO_SAMP_FREQ:
+		*val = hw->odr;
+		ret = IIO_VAL_INT;
+		break;
+	case IIO_CHAN_INFO_OVERSAMPLING_RATIO: {
+		u8 idx;
+		const struct hts221_avg *avg;
+
+		switch (ch->type) {
+		case IIO_HUMIDITYRELATIVE:
+			avg = &hts221_avg_list[HTS221_SENSOR_H];
+			idx = hw->sensors[HTS221_SENSOR_H].cur_avg_idx;
+			*val = avg->avg_avl[idx].avg;
+			ret = IIO_VAL_INT;
+			break;
+		case IIO_TEMP:
+			avg = &hts221_avg_list[HTS221_SENSOR_T];
+			idx = hw->sensors[HTS221_SENSOR_T].cur_avg_idx;
+			*val = avg->avg_avl[idx].avg;
+			ret = IIO_VAL_INT;
+			break;
+		default:
+			ret = -EINVAL;
+			break;
+		}
+		break;
+	}
+	default:
+		ret = -EINVAL;
+		break;
+	}
+
+	iio_device_release_direct_mode(iio_dev);
+
+	return ret;
+}
+
+static int hts221_write_raw(struct iio_dev *iio_dev,
+			    struct iio_chan_spec const *chan,
+			    int val, int val2, long mask)
+{
+	struct hts221_hw *hw = iio_priv(iio_dev);
+	int ret;
+
+	ret = iio_device_claim_direct_mode(iio_dev);
+	if (ret)
+		return ret;
+
+	switch (mask) {
+	case IIO_CHAN_INFO_SAMP_FREQ:
+		ret = hts221_update_odr(hw, val);
+		break;
+	case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
+		switch (chan->type) {
+		case IIO_HUMIDITYRELATIVE:
+			ret = hts221_update_avg(hw, HTS221_SENSOR_H, val);
+			break;
+		case IIO_TEMP:
+			ret = hts221_update_avg(hw, HTS221_SENSOR_T, val);
+			break;
+		default:
+			ret = -EINVAL;
+			break;
+		}
+		break;
+	default:
+		ret = -EINVAL;
+		break;
+	}
+
+	iio_device_release_direct_mode(iio_dev);
+
+	return ret;
+}
+
+static int hts221_validate_trigger(struct iio_dev *iio_dev,
+				   struct iio_trigger *trig)
+{
+	struct hts221_hw *hw = iio_priv(iio_dev);
+
+	return hw->trig == trig ? 0 : -EINVAL;
+}
+
+static IIO_DEVICE_ATTR(in_humidity_oversampling_ratio_available, S_IRUGO,
+		       hts221_sysfs_rh_oversampling_avail, NULL, 0);
+static IIO_DEVICE_ATTR(in_temp_oversampling_ratio_available, S_IRUGO,
+		       hts221_sysfs_temp_oversampling_avail, NULL, 0);
+static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(hts221_sysfs_sampling_freq);
+
+static struct attribute *hts221_attributes[] = {
+	&iio_dev_attr_sampling_frequency_available.dev_attr.attr,
+	&iio_dev_attr_in_humidity_oversampling_ratio_available.dev_attr.attr,
+	&iio_dev_attr_in_temp_oversampling_ratio_available.dev_attr.attr,
+	NULL,
+};
+
+static const struct attribute_group hts221_attribute_group = {
+	.attrs = hts221_attributes,
+};
+
+static const struct iio_info hts221_info = {
+	.driver_module = THIS_MODULE,
+	.attrs = &hts221_attribute_group,
+	.read_raw = hts221_read_raw,
+	.write_raw = hts221_write_raw,
+	.validate_trigger = hts221_validate_trigger,
+};
+
+static const unsigned long hts221_scan_masks[] = {0x3, 0x0};
+
+int hts221_probe(struct iio_dev *iio_dev)
+{
+	struct hts221_hw *hw = iio_priv(iio_dev);
+	int err;
+	u8 data;
+
+	mutex_init(&hw->lock);
+
+	err = hts221_check_whoami(hw);
+	if (err < 0)
+		return err;
+
+	hw->odr = hts221_odr_table[0].hz;
+
+	iio_dev->modes = INDIO_DIRECT_MODE;
+	iio_dev->dev.parent = hw->dev;
+	iio_dev->available_scan_masks = hts221_scan_masks;
+	iio_dev->channels = hts221_channels;
+	iio_dev->num_channels = ARRAY_SIZE(hts221_channels);
+	iio_dev->name = HTS221_DEV_NAME;
+	iio_dev->info = &hts221_info;
+
+	/* configure humidity sensor */
+	err = hts221_parse_rh_caldata(hw);
+	if (err < 0) {
+		dev_err(hw->dev, "failed to get rh calibration data\n");
+		return err;
+	}
+
+	data = hts221_avg_list[HTS221_SENSOR_H].avg_avl[3].avg;
+	err = hts221_update_avg(hw, HTS221_SENSOR_H, data);
+	if (err < 0) {
+		dev_err(hw->dev, "failed to set rh oversampling ratio\n");
+		return err;
+	}
+
+	/* configure temperature sensor */
+	err = hts221_parse_temp_caldata(hw);
+	if (err < 0) {
+		dev_err(hw->dev,
+			"failed to get temperature calibration data\n");
+		return err;
+	}
+
+	data = hts221_avg_list[HTS221_SENSOR_T].avg_avl[3].avg;
+	err = hts221_update_avg(hw, HTS221_SENSOR_T, data);
+	if (err < 0) {
+		dev_err(hw->dev,
+			"failed to set temperature oversampling ratio\n");
+		return err;
+	}
+
+	if (hw->irq > 0) {
+		err = hts221_allocate_buffers(hw);
+		if (err < 0)
+			return err;
+
+		err = hts221_allocate_triggers(hw);
+		if (err)
+			return err;
+	}
+
+	return devm_iio_device_register(hw->dev, iio_dev);
+}
+EXPORT_SYMBOL(hts221_probe);
+
+MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>");
+MODULE_DESCRIPTION("STMicroelectronics hts221 sensor driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/humidity/hts221_i2c.c b/drivers/iio/humidity/hts221_i2c.c
new file mode 100644
index 0000000..367ecd5
--- /dev/null
+++ b/drivers/iio/humidity/hts221_i2c.c
@@ -0,0 +1,110 @@
+/*
+ * STMicroelectronics hts221 i2c driver
+ *
+ * Copyright 2016 STMicroelectronics Inc.
+ *
+ * Lorenzo Bianconi <lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>
+ *
+ * Licensed under the GPL-2.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/slab.h>
+#include "hts221.h"
+
+#define I2C_AUTO_INCREMENT	0x80
+
+static int hts221_i2c_read(struct device *dev, u8 addr, int len, u8 *data)
+{
+	struct i2c_msg msg[2];
+	struct i2c_client *client = to_i2c_client(dev);
+
+	if (len > 1)
+		addr |= I2C_AUTO_INCREMENT;
+
+	msg[0].addr = client->addr;
+	msg[0].flags = client->flags;
+	msg[0].len = 1;
+	msg[0].buf = &addr;
+
+	msg[1].addr = client->addr;
+	msg[1].flags = client->flags | I2C_M_RD;
+	msg[1].len = len;
+	msg[1].buf = data;
+
+	return i2c_transfer(client->adapter, msg, 2);
+}
+
+static int hts221_i2c_write(struct device *dev, u8 addr, int len, u8 *data)
+{
+	u8 send[len + 1];
+	struct i2c_msg msg;
+	struct i2c_client *client = to_i2c_client(dev);
+
+	if (len > 1)
+		addr |= I2C_AUTO_INCREMENT;
+
+	send[0] = addr;
+	memcpy(&send[1], data, len * sizeof(u8));
+
+	msg.addr = client->addr;
+	msg.flags = client->flags;
+	msg.len = len + 1;
+	msg.buf = send;
+
+	return i2c_transfer(client->adapter, &msg, 1);
+}
+
+static const struct hts221_transfer_function hts221_transfer_fn = {
+	.read = hts221_i2c_read,
+	.write = hts221_i2c_write,
+};
+
+static int hts221_i2c_probe(struct i2c_client *client,
+			    const struct i2c_device_id *id)
+{
+	struct hts221_hw *hw;
+	struct iio_dev *iio_dev;
+
+	iio_dev = devm_iio_device_alloc(&client->dev, sizeof(*hw));
+	if (!iio_dev)
+		return -ENOMEM;
+
+	i2c_set_clientdata(client, iio_dev);
+
+	hw = iio_priv(iio_dev);
+	hw->name = client->name;
+	hw->dev = &client->dev;
+	hw->irq = client->irq;
+	hw->tf = &hts221_transfer_fn;
+
+	return hts221_probe(iio_dev);
+}
+
+static const struct of_device_id hts221_i2c_of_match[] = {
+	{ .compatible = "st,hts221", },
+	{},
+};
+MODULE_DEVICE_TABLE(of, hts221_i2c_of_match);
+
+static const struct i2c_device_id hts221_i2c_id_table[] = {
+	{ HTS221_DEV_NAME },
+	{},
+};
+MODULE_DEVICE_TABLE(i2c, hts221_i2c_id_table);
+
+static struct i2c_driver hts221_driver = {
+	.driver = {
+		.name = "hts221_i2c",
+		.of_match_table = of_match_ptr(hts221_i2c_of_match),
+	},
+	.probe = hts221_i2c_probe,
+	.id_table = hts221_i2c_id_table,
+};
+module_i2c_driver(hts221_driver);
+
+MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>");
+MODULE_DESCRIPTION("STMicroelectronics hts221 i2c driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/humidity/hts221_spi.c b/drivers/iio/humidity/hts221_spi.c
new file mode 100644
index 0000000..70df5e7
--- /dev/null
+++ b/drivers/iio/humidity/hts221_spi.c
@@ -0,0 +1,125 @@
+/*
+ * STMicroelectronics hts221 spi driver
+ *
+ * Copyright 2016 STMicroelectronics Inc.
+ *
+ * Lorenzo Bianconi <lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>
+ *
+ * Licensed under the GPL-2.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/spi/spi.h>
+#include <linux/slab.h>
+#include "hts221.h"
+
+#define SENSORS_SPI_READ	0x80
+#define SPI_AUTO_INCREMENT	0x40
+
+static int hts221_spi_read(struct device *dev, u8 addr, int len, u8 *data)
+{
+	int err;
+	struct spi_device *spi = to_spi_device(dev);
+	struct iio_dev *iio_dev = spi_get_drvdata(spi);
+	struct hts221_hw *hw = iio_priv(iio_dev);
+
+	struct spi_transfer xfers[] = {
+		{
+			.tx_buf = hw->tb.tx_buf,
+			.bits_per_word = 8,
+			.len = 1,
+		},
+		{
+			.rx_buf = hw->tb.rx_buf,
+			.bits_per_word = 8,
+			.len = len,
+		}
+	};
+
+	if (len > 1)
+		addr |= SPI_AUTO_INCREMENT;
+	hw->tb.tx_buf[0] = addr | SENSORS_SPI_READ;
+
+	err = spi_sync_transfer(spi, xfers,  ARRAY_SIZE(xfers));
+	if (err < 0)
+		return err;
+
+	memcpy(data, hw->tb.rx_buf, len * sizeof(u8));
+
+	return len;
+}
+
+static int hts221_spi_write(struct device *dev, u8 addr, int len, u8 *data)
+{
+	struct spi_device *spi = to_spi_device(dev);
+	struct iio_dev *iio_dev = spi_get_drvdata(spi);
+	struct hts221_hw *hw = iio_priv(iio_dev);
+
+	struct spi_transfer xfers = {
+		.tx_buf = hw->tb.tx_buf,
+		.bits_per_word = 8,
+		.len = len + 1,
+	};
+
+	if (len >= HTS221_TX_MAX_LENGTH)
+		return -ENOMEM;
+
+	if (len > 1)
+		addr |= SPI_AUTO_INCREMENT;
+	hw->tb.tx_buf[0] = addr;
+	memcpy(&hw->tb.tx_buf[1], data, len);
+
+	return spi_sync_transfer(spi, &xfers, 1);
+}
+
+static const struct hts221_transfer_function hts221_transfer_fn = {
+	.read = hts221_spi_read,
+	.write = hts221_spi_write,
+};
+
+static int hts221_spi_probe(struct spi_device *spi)
+{
+	struct hts221_hw *hw;
+	struct iio_dev *iio_dev;
+
+	iio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*hw));
+	if (!iio_dev)
+		return -ENOMEM;
+
+	spi_set_drvdata(spi, iio_dev);
+
+	hw = iio_priv(iio_dev);
+	hw->name = spi->modalias;
+	hw->dev = &spi->dev;
+	hw->irq = spi->irq;
+	hw->tf = &hts221_transfer_fn;
+
+	return hts221_probe(iio_dev);
+}
+
+static const struct of_device_id hts221_spi_of_match[] = {
+	{ .compatible = "st,hts221", },
+	{},
+};
+MODULE_DEVICE_TABLE(of, hts221_spi_of_match);
+
+static const struct spi_device_id hts221_spi_id_table[] = {
+	{ HTS221_DEV_NAME },
+	{},
+};
+MODULE_DEVICE_TABLE(spi, hts221_spi_id_table);
+
+static struct spi_driver hts221_driver = {
+	.driver = {
+		.name = "hts221_spi",
+		.of_match_table = of_match_ptr(hts221_spi_of_match),
+	},
+	.probe = hts221_spi_probe,
+	.id_table = hts221_spi_id_table,
+};
+module_spi_driver(hts221_driver);
+
+MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>");
+MODULE_DESCRIPTION("STMicroelectronics hts221 spi driver");
+MODULE_LICENSE("GPL v2");
-- 
2.7.4

--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

^ permalink raw reply related	[flat|nested] 13+ messages in thread

* [PATCH v4 1/2] iio: humidity: add support to hts221 rh/temp combo device
@ 2016-10-13 20:06     ` Lorenzo Bianconi
  0 siblings, 0 replies; 13+ messages in thread
From: Lorenzo Bianconi @ 2016-10-13 20:06 UTC (permalink / raw)
  To: jic23; +Cc: linux-iio, devicetree, lorenzo.bianconi

Add support to STM HTS221 humidity + temperature sensor

http://www.st.com/resource/en/datasheet/hts221.pdf

- continuous mode support
- i2c support
- spi support
- trigger mode support

Signed-off-by: Lorenzo Bianconi <lorenzo.bianconi@st.com>
---
 drivers/iio/humidity/Kconfig         |  22 ++
 drivers/iio/humidity/Makefile        |   7 +
 drivers/iio/humidity/hts221.h        |  73 ++++
 drivers/iio/humidity/hts221_buffer.c | 168 +++++++++
 drivers/iio/humidity/hts221_core.c   | 687 +++++++++++++++++++++++++++++++++++
 drivers/iio/humidity/hts221_i2c.c    | 110 ++++++
 drivers/iio/humidity/hts221_spi.c    | 125 +++++++
 7 files changed, 1192 insertions(+)
 create mode 100644 drivers/iio/humidity/hts221.h
 create mode 100644 drivers/iio/humidity/hts221_buffer.c
 create mode 100644 drivers/iio/humidity/hts221_core.c
 create mode 100644 drivers/iio/humidity/hts221_i2c.c
 create mode 100644 drivers/iio/humidity/hts221_spi.c

diff --git a/drivers/iio/humidity/Kconfig b/drivers/iio/humidity/Kconfig
index b17e2e2..6fd11d0 100644
--- a/drivers/iio/humidity/Kconfig
+++ b/drivers/iio/humidity/Kconfig
@@ -34,6 +34,28 @@ config HDC100X
 	  To compile this driver as a module, choose M here: the module
 	  will be called hdc100x.
 
+config HTS221
+	tristate "STMicroelectronics HTS221 sensor Driver"
+	depends on (I2C || SPI)
+	select IIO_BUFFER
+	select IIO_TRIGGERED_BUFFER
+	select HTS221_I2C if (I2C)
+	select HTS221_SPI if (SPI_MASTER)
+	help
+	  Say yes here to build support for STMicroelectronics HTS221
+	  temperature-humidity sensor
+
+	  To compile this driver as a module, choose M here: the module
+	  will be called hts221.
+
+config HTS221_I2C
+	tristate
+	depends on HTS221
+
+config HTS221_SPI
+	tristate
+	depends on HTS221
+
 config HTU21
 	tristate "Measurement Specialties HTU21 humidity & temperature sensor"
 	depends on I2C
diff --git a/drivers/iio/humidity/Makefile b/drivers/iio/humidity/Makefile
index 4a73442..a6850e4 100644
--- a/drivers/iio/humidity/Makefile
+++ b/drivers/iio/humidity/Makefile
@@ -5,6 +5,13 @@
 obj-$(CONFIG_AM2315) += am2315.o
 obj-$(CONFIG_DHT11) += dht11.o
 obj-$(CONFIG_HDC100X) += hdc100x.o
+
+hts221-y := hts221_core.o \
+	    hts221_buffer.o
+obj-$(CONFIG_HTS221) += hts221.o
+obj-$(CONFIG_HTS221_I2C) += hts221_i2c.o
+obj-$(CONFIG_HTS221_SPI) += hts221_spi.o
+
 obj-$(CONFIG_HTU21) += htu21.o
 obj-$(CONFIG_SI7005) += si7005.o
 obj-$(CONFIG_SI7020) += si7020.o
diff --git a/drivers/iio/humidity/hts221.h b/drivers/iio/humidity/hts221.h
new file mode 100644
index 0000000..0d2993c
--- /dev/null
+++ b/drivers/iio/humidity/hts221.h
@@ -0,0 +1,73 @@
+/*
+ * STMicroelectronics hts221 sensor driver
+ *
+ * Copyright 2016 STMicroelectronics Inc.
+ *
+ * Lorenzo Bianconi <lorenzo.bianconi@st.com>
+ *
+ * Licensed under the GPL-2.
+ */
+
+#ifndef HTS221_H
+#define HTS221_H
+
+#define HTS221_DEV_NAME		"hts221"
+
+#include <linux/iio/iio.h>
+
+#define HTS221_RX_MAX_LENGTH	8
+#define HTS221_TX_MAX_LENGTH	8
+
+#define HTS221_DATA_SIZE	2
+
+struct hts221_transfer_buffer {
+	u8 rx_buf[HTS221_RX_MAX_LENGTH];
+	u8 tx_buf[HTS221_TX_MAX_LENGTH] ____cacheline_aligned;
+};
+
+struct hts221_transfer_function {
+	int (*read)(struct device *dev, u8 addr, int len, u8 *data);
+	int (*write)(struct device *dev, u8 addr, int len, u8 *data);
+};
+
+#define HTS221_AVG_DEPTH	8
+struct hts221_avg_avl {
+	u16 avg;
+	u8 val;
+};
+
+enum hts221_sensor_type {
+	HTS221_SENSOR_H,
+	HTS221_SENSOR_T,
+	HTS221_SENSOR_MAX,
+};
+
+struct hts221_sensor {
+	u8 cur_avg_idx;
+	int slope, b_gen;
+};
+
+struct hts221_hw {
+	const char *name;
+	struct device *dev;
+
+	struct mutex lock;
+	struct iio_trigger *trig;
+	int irq;
+
+	struct hts221_sensor sensors[HTS221_SENSOR_MAX];
+
+	u8 odr;
+
+	const struct hts221_transfer_function *tf;
+	struct hts221_transfer_buffer tb;
+};
+
+int hts221_config_drdy(struct hts221_hw *hw, bool enable);
+int hts221_probe(struct iio_dev *iio_dev);
+int hts221_power_on(struct hts221_hw *hw);
+int hts221_power_off(struct hts221_hw *hw);
+int hts221_allocate_buffers(struct hts221_hw *hw);
+int hts221_allocate_triggers(struct hts221_hw *hw);
+
+#endif /* HTS221_H */
diff --git a/drivers/iio/humidity/hts221_buffer.c b/drivers/iio/humidity/hts221_buffer.c
new file mode 100644
index 0000000..6b174fd
--- /dev/null
+++ b/drivers/iio/humidity/hts221_buffer.c
@@ -0,0 +1,168 @@
+/*
+ * STMicroelectronics hts221 sensor driver
+ *
+ * Copyright 2016 STMicroelectronics Inc.
+ *
+ * Lorenzo Bianconi <lorenzo.bianconi@st.com>
+ *
+ * Licensed under the GPL-2.
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/interrupt.h>
+#include <linux/irqreturn.h>
+
+#include <linux/iio/iio.h>
+#include <linux/iio/trigger.h>
+#include <linux/interrupt.h>
+#include <linux/iio/events.h>
+#include <linux/iio/trigger_consumer.h>
+#include <linux/iio/triggered_buffer.h>
+#include <linux/iio/buffer.h>
+
+#include "hts221.h"
+
+#define HTS221_REG_STATUS_ADDR		0x27
+#define HTS221_RH_DRDY_MASK		BIT(1)
+#define HTS221_TEMP_DRDY_MASK		BIT(0)
+
+static int hts221_trig_set_state(struct iio_trigger *trig, bool state)
+{
+	struct iio_dev *iio_dev = iio_trigger_get_drvdata(trig);
+	struct hts221_hw *hw = iio_priv(iio_dev);
+
+	return hts221_config_drdy(hw, state);
+}
+
+static const struct iio_trigger_ops hts221_trigger_ops = {
+	.owner = THIS_MODULE,
+	.set_trigger_state = hts221_trig_set_state,
+};
+
+static irqreturn_t hts221_trigger_handler_thread(int irq, void *private)
+{
+	struct hts221_hw *hw = (struct hts221_hw *)private;
+	u8 status;
+	int err;
+
+	err = hw->tf->read(hw->dev, HTS221_REG_STATUS_ADDR, sizeof(status),
+			   &status);
+	if (err < 0)
+		return IRQ_HANDLED;
+
+	/* H_DA bit (humidity data available) is routed to DRDY line.
+	 * Humidity sample is computed after temperature one.
+	 * Here we can assume data channels are both available if H_DA bit
+	 * is set in status register
+	 */
+	if (!(status & HTS221_RH_DRDY_MASK))
+		return IRQ_NONE;
+
+	iio_trigger_poll_chained(hw->trig);
+
+	return IRQ_HANDLED;
+}
+
+int hts221_allocate_triggers(struct hts221_hw *hw)
+{
+	struct iio_dev *iio_dev = iio_priv_to_dev(hw);
+	unsigned long irq_type;
+	int err;
+
+	irq_type = irqd_get_trigger_type(irq_get_irq_data(hw->irq));
+
+	switch (irq_type) {
+	case IRQF_TRIGGER_HIGH:
+	case IRQF_TRIGGER_RISING:
+		break;
+	default:
+		dev_info(hw->dev,
+			 "mode %lx unsupported, using IRQF_TRIGGER_RISING\n",
+			 irq_type);
+		irq_type = IRQF_TRIGGER_RISING;
+		break;
+	}
+
+	err = devm_request_threaded_irq(hw->dev, hw->irq, NULL,
+					hts221_trigger_handler_thread,
+					irq_type | IRQF_ONESHOT,
+					hw->name, hw);
+	if (err) {
+		dev_err(hw->dev, "failed to request trigger irq %d\n",
+			hw->irq);
+		return err;
+	}
+
+	hw->trig = devm_iio_trigger_alloc(hw->dev, "%s-trigger",
+					  iio_dev->name);
+	if (!hw->trig)
+		return -ENOMEM;
+
+	iio_trigger_set_drvdata(hw->trig, iio_dev);
+	hw->trig->ops = &hts221_trigger_ops;
+	hw->trig->dev.parent = hw->dev;
+	iio_dev->trig = iio_trigger_get(hw->trig);
+
+	return devm_iio_trigger_register(hw->dev, hw->trig);
+}
+
+static int hts221_buffer_preenable(struct iio_dev *iio_dev)
+{
+	return hts221_power_on(iio_priv(iio_dev));
+}
+
+static int hts221_buffer_postdisable(struct iio_dev *iio_dev)
+{
+	return hts221_power_off(iio_priv(iio_dev));
+}
+
+static const struct iio_buffer_setup_ops hts221_buffer_ops = {
+	.preenable = hts221_buffer_preenable,
+	.postenable = iio_triggered_buffer_postenable,
+	.predisable = iio_triggered_buffer_predisable,
+	.postdisable = hts221_buffer_postdisable,
+};
+
+static irqreturn_t hts221_buffer_handler_thread(int irq, void *p)
+{
+	u8 buffer[ALIGN(2 * HTS221_DATA_SIZE, sizeof(s64)) + sizeof(s64)];
+	struct iio_poll_func *pf = p;
+	struct iio_dev *iio_dev = pf->indio_dev;
+	struct hts221_hw *hw = iio_priv(iio_dev);
+	struct iio_chan_spec const *ch;
+	int err;
+
+	/* humidity data */
+	ch = &iio_dev->channels[HTS221_SENSOR_H];
+	err = hw->tf->read(hw->dev, ch->address, HTS221_DATA_SIZE,
+			   buffer);
+	if (err < 0)
+		goto out;
+
+	/* temperature data */
+	ch = &iio_dev->channels[HTS221_SENSOR_T];
+	err = hw->tf->read(hw->dev, ch->address, HTS221_DATA_SIZE,
+			   buffer + HTS221_DATA_SIZE);
+	if (err < 0)
+		goto out;
+
+	iio_push_to_buffers_with_timestamp(iio_dev, buffer,
+					   iio_get_time_ns(iio_dev));
+
+out:
+	iio_trigger_notify_done(hw->trig);
+
+	return IRQ_HANDLED;
+}
+
+int hts221_allocate_buffers(struct hts221_hw *hw)
+{
+	return devm_iio_triggered_buffer_setup(hw->dev, iio_priv_to_dev(hw),
+					NULL, hts221_buffer_handler_thread,
+					&hts221_buffer_ops);
+}
+
+MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi@st.com>");
+MODULE_DESCRIPTION("STMicroelectronics hts221 buffer driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/humidity/hts221_core.c b/drivers/iio/humidity/hts221_core.c
new file mode 100644
index 0000000..5a099dd
--- /dev/null
+++ b/drivers/iio/humidity/hts221_core.c
@@ -0,0 +1,687 @@
+/*
+ * STMicroelectronics hts221 sensor driver
+ *
+ * Copyright 2016 STMicroelectronics Inc.
+ *
+ * Lorenzo Bianconi <lorenzo.bianconi@st.com>
+ *
+ * Licensed under the GPL-2.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/iio/sysfs.h>
+#include <linux/delay.h>
+#include <asm/unaligned.h>
+
+#include "hts221.h"
+
+#define HTS221_REG_WHOAMI_ADDR		0x0f
+#define HTS221_REG_WHOAMI_VAL		0xbc
+
+#define HTS221_REG_CNTRL1_ADDR		0x20
+#define HTS221_REG_CNTRL2_ADDR		0x21
+#define HTS221_REG_CNTRL3_ADDR		0x22
+
+#define HTS221_REG_AVG_ADDR		0x10
+#define HTS221_REG_H_OUT_L		0x28
+#define HTS221_REG_T_OUT_L		0x2a
+
+#define HTS221_HUMIDITY_AVG_MASK	0x07
+#define HTS221_TEMP_AVG_MASK		0x38
+
+#define HTS221_ODR_MASK			0x87
+#define HTS221_BDU_MASK			BIT(2)
+
+#define HTS221_DRDY_MASK		BIT(2)
+
+#define HTS221_ENABLE_SENSOR		BIT(7)
+
+#define HTS221_HUMIDITY_AVG_4		0x00 /* 0.4 %RH */
+#define HTS221_HUMIDITY_AVG_8		0x01 /* 0.3 %RH */
+#define HTS221_HUMIDITY_AVG_16		0x02 /* 0.2 %RH */
+#define HTS221_HUMIDITY_AVG_32		0x03 /* 0.15 %RH */
+#define HTS221_HUMIDITY_AVG_64		0x04 /* 0.1 %RH */
+#define HTS221_HUMIDITY_AVG_128		0x05 /* 0.07 %RH */
+#define HTS221_HUMIDITY_AVG_256		0x06 /* 0.05 %RH */
+#define HTS221_HUMIDITY_AVG_512		0x07 /* 0.03 %RH */
+
+#define HTS221_TEMP_AVG_2		0x00 /* 0.08 degC */
+#define HTS221_TEMP_AVG_4		0x08 /* 0.05 degC */
+#define HTS221_TEMP_AVG_8		0x10 /* 0.04 degC */
+#define HTS221_TEMP_AVG_16		0x18 /* 0.03 degC */
+#define HTS221_TEMP_AVG_32		0x20 /* 0.02 degC */
+#define HTS221_TEMP_AVG_64		0x28 /* 0.015 degC */
+#define HTS221_TEMP_AVG_128		0x30 /* 0.01 degC */
+#define HTS221_TEMP_AVG_256		0x38 /* 0.007 degC */
+
+/* calibration registers */
+#define HTS221_REG_0RH_CAL_X_H		0x36
+#define HTS221_REG_1RH_CAL_X_H		0x3a
+#define HTS221_REG_0RH_CAL_Y_H		0x30
+#define HTS221_REG_1RH_CAL_Y_H		0x31
+#define HTS221_REG_0T_CAL_X_L		0x3c
+#define HTS221_REG_1T_CAL_X_L		0x3e
+#define HTS221_REG_0T_CAL_Y_H		0x32
+#define HTS221_REG_1T_CAL_Y_H		0x33
+#define HTS221_REG_T1_T0_CAL_Y_H	0x35
+
+struct hts221_odr {
+	u8 hz;
+	u8 val;
+};
+
+struct hts221_avg {
+	u8 addr;
+	u8 mask;
+	struct hts221_avg_avl avg_avl[HTS221_AVG_DEPTH];
+};
+
+static const struct hts221_odr hts221_odr_table[] = {
+	{  1, 0x01 },	/* 1Hz */
+	{  7, 0x02 },	/* 7Hz */
+	{ 13, 0x03 },	/* 12.5Hz */
+};
+
+static const struct hts221_avg hts221_avg_list[] = {
+	{
+		.addr = HTS221_REG_AVG_ADDR,
+		.mask = HTS221_HUMIDITY_AVG_MASK,
+		.avg_avl = {
+			{ 4, HTS221_HUMIDITY_AVG_4 },
+			{ 8, HTS221_HUMIDITY_AVG_8 },
+			{ 16, HTS221_HUMIDITY_AVG_16 },
+			{ 32, HTS221_HUMIDITY_AVG_32 },
+			{ 64, HTS221_HUMIDITY_AVG_64 },
+			{ 128, HTS221_HUMIDITY_AVG_128 },
+			{ 256, HTS221_HUMIDITY_AVG_256 },
+			{ 512, HTS221_HUMIDITY_AVG_512 },
+		},
+	},
+	{
+		.addr = HTS221_REG_AVG_ADDR,
+		.mask = HTS221_TEMP_AVG_MASK,
+		.avg_avl = {
+			{ 2, HTS221_TEMP_AVG_2 },
+			{ 4, HTS221_TEMP_AVG_4 },
+			{ 8, HTS221_TEMP_AVG_8 },
+			{ 16, HTS221_TEMP_AVG_16 },
+			{ 32, HTS221_TEMP_AVG_32 },
+			{ 64, HTS221_TEMP_AVG_64 },
+			{ 128, HTS221_TEMP_AVG_128 },
+			{ 256, HTS221_TEMP_AVG_256 },
+		},
+	},
+};
+
+static const struct iio_chan_spec hts221_channels[] = {
+	{
+		.type = IIO_HUMIDITYRELATIVE,
+		.address = HTS221_REG_H_OUT_L,
+		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
+				      BIT(IIO_CHAN_INFO_OFFSET) |
+				      BIT(IIO_CHAN_INFO_SCALE) |
+				      BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
+		.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
+		.scan_index = 0,
+		.scan_type = {
+			.sign = 's',
+			.realbits = 16,
+			.storagebits = 16,
+			.endianness = IIO_LE,
+		},
+	},
+	{
+		.type = IIO_TEMP,
+		.address = HTS221_REG_T_OUT_L,
+		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
+				      BIT(IIO_CHAN_INFO_OFFSET) |
+				      BIT(IIO_CHAN_INFO_SCALE) |
+				      BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
+		.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
+		.scan_index = 1,
+		.scan_type = {
+			.sign = 's',
+			.realbits = 16,
+			.storagebits = 16,
+			.endianness = IIO_LE,
+		},
+	},
+	IIO_CHAN_SOFT_TIMESTAMP(2),
+};
+
+static int hts221_write_with_mask(struct hts221_hw *hw, u8 addr, u8 mask,
+				  u8 val)
+{
+	u8 data;
+	int err;
+
+	mutex_lock(&hw->lock);
+
+	err = hw->tf->read(hw->dev, addr, sizeof(data), &data);
+	if (err < 0) {
+		dev_err(hw->dev, "failed to read %02x register\n", addr);
+		goto unlock;
+	}
+
+	data = (data & ~mask) | (val & mask);
+
+	err = hw->tf->write(hw->dev, addr, sizeof(data), &data);
+	if (err < 0)
+		dev_err(hw->dev, "failed to write %02x register\n", addr);
+
+unlock:
+	mutex_unlock(&hw->lock);
+
+	return err;
+}
+
+static int hts221_check_whoami(struct hts221_hw *hw)
+{
+	u8 data;
+	int err;
+
+	err = hw->tf->read(hw->dev, HTS221_REG_WHOAMI_ADDR, sizeof(data),
+			   &data);
+	if (err < 0) {
+		dev_err(hw->dev, "failed to read whoami register\n");
+		return err;
+	}
+
+	if (data != HTS221_REG_WHOAMI_VAL) {
+		dev_err(hw->dev, "wrong whoami {%02x vs %02x}\n",
+			data, HTS221_REG_WHOAMI_VAL);
+		return -ENODEV;
+	}
+
+	return 0;
+}
+
+int hts221_config_drdy(struct hts221_hw *hw, bool enable)
+{
+	u8 val = enable ? BIT(2) : 0;
+	int err;
+
+	err = hts221_write_with_mask(hw, HTS221_REG_CNTRL3_ADDR,
+				     HTS221_DRDY_MASK, val);
+
+	return err < 0 ? err : 0;
+}
+
+static int hts221_update_odr(struct hts221_hw *hw, u8 odr)
+{
+	int i, err;
+	u8 val;
+
+	for (i = 0; i < ARRAY_SIZE(hts221_odr_table); i++)
+		if (hts221_odr_table[i].hz == odr)
+			break;
+
+	if (i == ARRAY_SIZE(hts221_odr_table))
+		return -EINVAL;
+
+	val = HTS221_ENABLE_SENSOR | HTS221_BDU_MASK | hts221_odr_table[i].val;
+	err = hts221_write_with_mask(hw, HTS221_REG_CNTRL1_ADDR,
+				     HTS221_ODR_MASK, val);
+	if (err < 0)
+		return err;
+
+	hw->odr = odr;
+
+	return 0;
+}
+
+static int hts221_update_avg(struct hts221_hw *hw,
+			     enum hts221_sensor_type type,
+			     u16 val)
+{
+	int i, err;
+	const struct hts221_avg *avg = &hts221_avg_list[type];
+
+	for (i = 0; i < HTS221_AVG_DEPTH; i++)
+		if (avg->avg_avl[i].avg == val)
+			break;
+
+	if (i == HTS221_AVG_DEPTH)
+		return -EINVAL;
+
+	err = hts221_write_with_mask(hw, avg->addr, avg->mask,
+				     avg->avg_avl[i].val);
+	if (err < 0)
+		return err;
+
+	hw->sensors[type].cur_avg_idx = i;
+
+	return 0;
+}
+
+static ssize_t hts221_sysfs_sampling_freq(struct device *dev,
+					  struct device_attribute *attr,
+					  char *buf)
+{
+	int i;
+	ssize_t len = 0;
+
+	for (i = 0; i < ARRAY_SIZE(hts221_odr_table); i++)
+		len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
+				 hts221_odr_table[i].hz);
+	buf[len - 1] = '\n';
+
+	return len;
+}
+
+static ssize_t
+hts221_sysfs_rh_oversampling_avail(struct device *dev,
+				   struct device_attribute *attr,
+				   char *buf)
+{
+	const struct hts221_avg *avg = &hts221_avg_list[HTS221_SENSOR_H];
+	ssize_t len = 0;
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(avg->avg_avl); i++)
+		len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
+				 avg->avg_avl[i].avg);
+	buf[len - 1] = '\n';
+
+	return len;
+}
+
+static ssize_t
+hts221_sysfs_temp_oversampling_avail(struct device *dev,
+				     struct device_attribute *attr,
+				     char *buf)
+{
+	const struct hts221_avg *avg = &hts221_avg_list[HTS221_SENSOR_T];
+	ssize_t len = 0;
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(avg->avg_avl); i++)
+		len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
+				 avg->avg_avl[i].avg);
+	buf[len - 1] = '\n';
+
+	return len;
+}
+
+int hts221_power_on(struct hts221_hw *hw)
+{
+	return hts221_update_odr(hw, hw->odr);
+}
+
+int hts221_power_off(struct hts221_hw *hw)
+{
+	u8 data[] = {0x00, 0x00};
+
+	return hw->tf->write(hw->dev, HTS221_REG_CNTRL1_ADDR, sizeof(data),
+			     data);
+}
+
+static int hts221_parse_temp_caldata(struct hts221_hw *hw)
+{
+	int err, *slope, *b_gen;
+	s16 cal_x0, cal_x1, cal_y0, cal_y1;
+	u8 cal0, cal1;
+
+	err = hw->tf->read(hw->dev, HTS221_REG_0T_CAL_Y_H,
+			   sizeof(cal0), &cal0);
+	if (err < 0)
+		return err;
+
+	err = hw->tf->read(hw->dev, HTS221_REG_T1_T0_CAL_Y_H,
+			   sizeof(cal1), &cal1);
+	if (err < 0)
+		return err;
+	cal_y0 = (le16_to_cpu(cal1 & 0x3) << 8) | cal0;
+
+	err = hw->tf->read(hw->dev, HTS221_REG_1T_CAL_Y_H,
+			   sizeof(cal0), &cal0);
+	if (err < 0)
+		return err;
+	cal_y1 = (((cal1 & 0xc) >> 2) << 8) | cal0;
+
+	err = hw->tf->read(hw->dev, HTS221_REG_0T_CAL_X_L, sizeof(cal_x0),
+			   (u8 *)&cal_x0);
+	if (err < 0)
+		return err;
+	cal_x0 = le16_to_cpu(cal_x0);
+
+	err = hw->tf->read(hw->dev, HTS221_REG_1T_CAL_X_L, sizeof(cal_x1),
+			   (u8 *)&cal_x1);
+	if (err < 0)
+		return err;
+	cal_x1 = le16_to_cpu(cal_x1);
+
+	slope = &hw->sensors[HTS221_SENSOR_T].slope;
+	b_gen = &hw->sensors[HTS221_SENSOR_T].b_gen;
+
+	*slope = ((cal_y1 - cal_y0) * 8000) / (cal_x1 - cal_x0);
+	*b_gen = (((s32)cal_x1 * cal_y0 - (s32)cal_x0 * cal_y1) * 1000) /
+		 (cal_x1 - cal_x0);
+	*b_gen *= 8;
+
+	return 0;
+}
+
+static int hts221_parse_rh_caldata(struct hts221_hw *hw)
+{
+	int err, *slope, *b_gen;
+	s16 cal_x0, cal_x1, cal_y0, cal_y1;
+	u8 data;
+
+	err = hw->tf->read(hw->dev, HTS221_REG_0RH_CAL_Y_H, sizeof(data),
+			   &data);
+	if (err < 0)
+		return err;
+	cal_y0 = data;
+
+	err = hw->tf->read(hw->dev, HTS221_REG_1RH_CAL_Y_H, sizeof(data),
+			   &data);
+	if (err < 0)
+		return err;
+	cal_y1 = data;
+
+	err = hw->tf->read(hw->dev, HTS221_REG_0RH_CAL_X_H, sizeof(cal_x0),
+			   (u8 *)&cal_x0);
+	if (err < 0)
+		return err;
+	cal_x0 = le16_to_cpu(cal_x0);
+
+	err = hw->tf->read(hw->dev, HTS221_REG_1RH_CAL_X_H, sizeof(cal_x1),
+			   (u8 *)&cal_x1);
+	if (err < 0)
+		return err;
+	cal_x1 = le16_to_cpu(cal_x1);
+
+	slope = &hw->sensors[HTS221_SENSOR_H].slope;
+	b_gen = &hw->sensors[HTS221_SENSOR_H].b_gen;
+
+	*slope = ((cal_y1 - cal_y0) * 8000) / (cal_x1 - cal_x0);
+	*b_gen = (((s32)cal_x1 * cal_y0 - (s32)cal_x0 * cal_y1) * 1000) /
+		 (cal_x1 - cal_x0);
+	*b_gen *= 8;
+
+	return 0;
+}
+
+static int hts221_get_sensor_scale(struct hts221_hw *hw,
+				   enum iio_chan_type ch_type,
+				   int *val, int *val2)
+{
+	s64 tmp;
+	s32 rem, div, data;
+
+	switch (ch_type) {
+	case IIO_HUMIDITYRELATIVE:
+		data = hw->sensors[HTS221_SENSOR_H].slope;
+		div = (1 << 4) * 1000;
+		break;
+	case IIO_TEMP:
+		data = hw->sensors[HTS221_SENSOR_T].slope;
+		div = (1 << 6) * 1000;
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	tmp = div_s64(data * 1000000000LL, div);
+	tmp = div_s64_rem(tmp, 1000000000LL, &rem);
+
+	*val = tmp;
+	*val2 = rem;
+
+	return IIO_VAL_INT_PLUS_NANO;
+}
+
+static int hts221_get_sensor_offset(struct hts221_hw *hw,
+				    enum iio_chan_type ch_type,
+				    int *val, int *val2)
+{
+	s64 tmp;
+	s32 rem, div, data;
+
+	switch (ch_type) {
+	case IIO_HUMIDITYRELATIVE:
+		data = hw->sensors[HTS221_SENSOR_H].b_gen;
+		div = hw->sensors[HTS221_SENSOR_H].slope;
+		break;
+	case IIO_TEMP:
+		data = hw->sensors[HTS221_SENSOR_T].b_gen;
+		div = hw->sensors[HTS221_SENSOR_T].slope;
+		break;
+	default:
+		return -EINVAL;
+	}
+
+	tmp = div_s64(data * 1000000000LL, div);
+	tmp = div_s64_rem(tmp, 1000000000LL, &rem);
+
+	*val = tmp;
+	*val2 = rem;
+
+	return IIO_VAL_INT_PLUS_NANO;
+}
+
+static int hts221_read_oneshot(struct hts221_hw *hw, u8 addr, int *val)
+{
+	u8 data[HTS221_DATA_SIZE];
+	int err;
+
+	err = hts221_power_on(hw);
+	if (err < 0)
+		return err;
+
+	msleep(50);
+
+	err = hw->tf->read(hw->dev, addr, sizeof(data), data);
+	if (err < 0)
+		return err;
+
+	hts221_power_off(hw);
+
+	*val = (s16)get_unaligned_le16(data);
+
+	return IIO_VAL_INT;
+}
+
+static int hts221_read_raw(struct iio_dev *iio_dev,
+			   struct iio_chan_spec const *ch,
+			   int *val, int *val2, long mask)
+{
+	struct hts221_hw *hw = iio_priv(iio_dev);
+	int ret;
+
+	ret = iio_device_claim_direct_mode(iio_dev);
+	if (ret)
+		return ret;
+
+	switch (mask) {
+	case IIO_CHAN_INFO_RAW:
+		ret = hts221_read_oneshot(hw, ch->address, val);
+		break;
+	case IIO_CHAN_INFO_SCALE:
+		ret = hts221_get_sensor_scale(hw, ch->type, val, val2);
+		break;
+	case IIO_CHAN_INFO_OFFSET:
+		ret = hts221_get_sensor_offset(hw, ch->type, val, val2);
+		break;
+	case IIO_CHAN_INFO_SAMP_FREQ:
+		*val = hw->odr;
+		ret = IIO_VAL_INT;
+		break;
+	case IIO_CHAN_INFO_OVERSAMPLING_RATIO: {
+		u8 idx;
+		const struct hts221_avg *avg;
+
+		switch (ch->type) {
+		case IIO_HUMIDITYRELATIVE:
+			avg = &hts221_avg_list[HTS221_SENSOR_H];
+			idx = hw->sensors[HTS221_SENSOR_H].cur_avg_idx;
+			*val = avg->avg_avl[idx].avg;
+			ret = IIO_VAL_INT;
+			break;
+		case IIO_TEMP:
+			avg = &hts221_avg_list[HTS221_SENSOR_T];
+			idx = hw->sensors[HTS221_SENSOR_T].cur_avg_idx;
+			*val = avg->avg_avl[idx].avg;
+			ret = IIO_VAL_INT;
+			break;
+		default:
+			ret = -EINVAL;
+			break;
+		}
+		break;
+	}
+	default:
+		ret = -EINVAL;
+		break;
+	}
+
+	iio_device_release_direct_mode(iio_dev);
+
+	return ret;
+}
+
+static int hts221_write_raw(struct iio_dev *iio_dev,
+			    struct iio_chan_spec const *chan,
+			    int val, int val2, long mask)
+{
+	struct hts221_hw *hw = iio_priv(iio_dev);
+	int ret;
+
+	ret = iio_device_claim_direct_mode(iio_dev);
+	if (ret)
+		return ret;
+
+	switch (mask) {
+	case IIO_CHAN_INFO_SAMP_FREQ:
+		ret = hts221_update_odr(hw, val);
+		break;
+	case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
+		switch (chan->type) {
+		case IIO_HUMIDITYRELATIVE:
+			ret = hts221_update_avg(hw, HTS221_SENSOR_H, val);
+			break;
+		case IIO_TEMP:
+			ret = hts221_update_avg(hw, HTS221_SENSOR_T, val);
+			break;
+		default:
+			ret = -EINVAL;
+			break;
+		}
+		break;
+	default:
+		ret = -EINVAL;
+		break;
+	}
+
+	iio_device_release_direct_mode(iio_dev);
+
+	return ret;
+}
+
+static int hts221_validate_trigger(struct iio_dev *iio_dev,
+				   struct iio_trigger *trig)
+{
+	struct hts221_hw *hw = iio_priv(iio_dev);
+
+	return hw->trig == trig ? 0 : -EINVAL;
+}
+
+static IIO_DEVICE_ATTR(in_humidity_oversampling_ratio_available, S_IRUGO,
+		       hts221_sysfs_rh_oversampling_avail, NULL, 0);
+static IIO_DEVICE_ATTR(in_temp_oversampling_ratio_available, S_IRUGO,
+		       hts221_sysfs_temp_oversampling_avail, NULL, 0);
+static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(hts221_sysfs_sampling_freq);
+
+static struct attribute *hts221_attributes[] = {
+	&iio_dev_attr_sampling_frequency_available.dev_attr.attr,
+	&iio_dev_attr_in_humidity_oversampling_ratio_available.dev_attr.attr,
+	&iio_dev_attr_in_temp_oversampling_ratio_available.dev_attr.attr,
+	NULL,
+};
+
+static const struct attribute_group hts221_attribute_group = {
+	.attrs = hts221_attributes,
+};
+
+static const struct iio_info hts221_info = {
+	.driver_module = THIS_MODULE,
+	.attrs = &hts221_attribute_group,
+	.read_raw = hts221_read_raw,
+	.write_raw = hts221_write_raw,
+	.validate_trigger = hts221_validate_trigger,
+};
+
+static const unsigned long hts221_scan_masks[] = {0x3, 0x0};
+
+int hts221_probe(struct iio_dev *iio_dev)
+{
+	struct hts221_hw *hw = iio_priv(iio_dev);
+	int err;
+	u8 data;
+
+	mutex_init(&hw->lock);
+
+	err = hts221_check_whoami(hw);
+	if (err < 0)
+		return err;
+
+	hw->odr = hts221_odr_table[0].hz;
+
+	iio_dev->modes = INDIO_DIRECT_MODE;
+	iio_dev->dev.parent = hw->dev;
+	iio_dev->available_scan_masks = hts221_scan_masks;
+	iio_dev->channels = hts221_channels;
+	iio_dev->num_channels = ARRAY_SIZE(hts221_channels);
+	iio_dev->name = HTS221_DEV_NAME;
+	iio_dev->info = &hts221_info;
+
+	/* configure humidity sensor */
+	err = hts221_parse_rh_caldata(hw);
+	if (err < 0) {
+		dev_err(hw->dev, "failed to get rh calibration data\n");
+		return err;
+	}
+
+	data = hts221_avg_list[HTS221_SENSOR_H].avg_avl[3].avg;
+	err = hts221_update_avg(hw, HTS221_SENSOR_H, data);
+	if (err < 0) {
+		dev_err(hw->dev, "failed to set rh oversampling ratio\n");
+		return err;
+	}
+
+	/* configure temperature sensor */
+	err = hts221_parse_temp_caldata(hw);
+	if (err < 0) {
+		dev_err(hw->dev,
+			"failed to get temperature calibration data\n");
+		return err;
+	}
+
+	data = hts221_avg_list[HTS221_SENSOR_T].avg_avl[3].avg;
+	err = hts221_update_avg(hw, HTS221_SENSOR_T, data);
+	if (err < 0) {
+		dev_err(hw->dev,
+			"failed to set temperature oversampling ratio\n");
+		return err;
+	}
+
+	if (hw->irq > 0) {
+		err = hts221_allocate_buffers(hw);
+		if (err < 0)
+			return err;
+
+		err = hts221_allocate_triggers(hw);
+		if (err)
+			return err;
+	}
+
+	return devm_iio_device_register(hw->dev, iio_dev);
+}
+EXPORT_SYMBOL(hts221_probe);
+
+MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi@st.com>");
+MODULE_DESCRIPTION("STMicroelectronics hts221 sensor driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/humidity/hts221_i2c.c b/drivers/iio/humidity/hts221_i2c.c
new file mode 100644
index 0000000..367ecd5
--- /dev/null
+++ b/drivers/iio/humidity/hts221_i2c.c
@@ -0,0 +1,110 @@
+/*
+ * STMicroelectronics hts221 i2c driver
+ *
+ * Copyright 2016 STMicroelectronics Inc.
+ *
+ * Lorenzo Bianconi <lorenzo.bianconi@st.com>
+ *
+ * Licensed under the GPL-2.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/slab.h>
+#include "hts221.h"
+
+#define I2C_AUTO_INCREMENT	0x80
+
+static int hts221_i2c_read(struct device *dev, u8 addr, int len, u8 *data)
+{
+	struct i2c_msg msg[2];
+	struct i2c_client *client = to_i2c_client(dev);
+
+	if (len > 1)
+		addr |= I2C_AUTO_INCREMENT;
+
+	msg[0].addr = client->addr;
+	msg[0].flags = client->flags;
+	msg[0].len = 1;
+	msg[0].buf = &addr;
+
+	msg[1].addr = client->addr;
+	msg[1].flags = client->flags | I2C_M_RD;
+	msg[1].len = len;
+	msg[1].buf = data;
+
+	return i2c_transfer(client->adapter, msg, 2);
+}
+
+static int hts221_i2c_write(struct device *dev, u8 addr, int len, u8 *data)
+{
+	u8 send[len + 1];
+	struct i2c_msg msg;
+	struct i2c_client *client = to_i2c_client(dev);
+
+	if (len > 1)
+		addr |= I2C_AUTO_INCREMENT;
+
+	send[0] = addr;
+	memcpy(&send[1], data, len * sizeof(u8));
+
+	msg.addr = client->addr;
+	msg.flags = client->flags;
+	msg.len = len + 1;
+	msg.buf = send;
+
+	return i2c_transfer(client->adapter, &msg, 1);
+}
+
+static const struct hts221_transfer_function hts221_transfer_fn = {
+	.read = hts221_i2c_read,
+	.write = hts221_i2c_write,
+};
+
+static int hts221_i2c_probe(struct i2c_client *client,
+			    const struct i2c_device_id *id)
+{
+	struct hts221_hw *hw;
+	struct iio_dev *iio_dev;
+
+	iio_dev = devm_iio_device_alloc(&client->dev, sizeof(*hw));
+	if (!iio_dev)
+		return -ENOMEM;
+
+	i2c_set_clientdata(client, iio_dev);
+
+	hw = iio_priv(iio_dev);
+	hw->name = client->name;
+	hw->dev = &client->dev;
+	hw->irq = client->irq;
+	hw->tf = &hts221_transfer_fn;
+
+	return hts221_probe(iio_dev);
+}
+
+static const struct of_device_id hts221_i2c_of_match[] = {
+	{ .compatible = "st,hts221", },
+	{},
+};
+MODULE_DEVICE_TABLE(of, hts221_i2c_of_match);
+
+static const struct i2c_device_id hts221_i2c_id_table[] = {
+	{ HTS221_DEV_NAME },
+	{},
+};
+MODULE_DEVICE_TABLE(i2c, hts221_i2c_id_table);
+
+static struct i2c_driver hts221_driver = {
+	.driver = {
+		.name = "hts221_i2c",
+		.of_match_table = of_match_ptr(hts221_i2c_of_match),
+	},
+	.probe = hts221_i2c_probe,
+	.id_table = hts221_i2c_id_table,
+};
+module_i2c_driver(hts221_driver);
+
+MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi@st.com>");
+MODULE_DESCRIPTION("STMicroelectronics hts221 i2c driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/humidity/hts221_spi.c b/drivers/iio/humidity/hts221_spi.c
new file mode 100644
index 0000000..70df5e7
--- /dev/null
+++ b/drivers/iio/humidity/hts221_spi.c
@@ -0,0 +1,125 @@
+/*
+ * STMicroelectronics hts221 spi driver
+ *
+ * Copyright 2016 STMicroelectronics Inc.
+ *
+ * Lorenzo Bianconi <lorenzo.bianconi@st.com>
+ *
+ * Licensed under the GPL-2.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/spi/spi.h>
+#include <linux/slab.h>
+#include "hts221.h"
+
+#define SENSORS_SPI_READ	0x80
+#define SPI_AUTO_INCREMENT	0x40
+
+static int hts221_spi_read(struct device *dev, u8 addr, int len, u8 *data)
+{
+	int err;
+	struct spi_device *spi = to_spi_device(dev);
+	struct iio_dev *iio_dev = spi_get_drvdata(spi);
+	struct hts221_hw *hw = iio_priv(iio_dev);
+
+	struct spi_transfer xfers[] = {
+		{
+			.tx_buf = hw->tb.tx_buf,
+			.bits_per_word = 8,
+			.len = 1,
+		},
+		{
+			.rx_buf = hw->tb.rx_buf,
+			.bits_per_word = 8,
+			.len = len,
+		}
+	};
+
+	if (len > 1)
+		addr |= SPI_AUTO_INCREMENT;
+	hw->tb.tx_buf[0] = addr | SENSORS_SPI_READ;
+
+	err = spi_sync_transfer(spi, xfers,  ARRAY_SIZE(xfers));
+	if (err < 0)
+		return err;
+
+	memcpy(data, hw->tb.rx_buf, len * sizeof(u8));
+
+	return len;
+}
+
+static int hts221_spi_write(struct device *dev, u8 addr, int len, u8 *data)
+{
+	struct spi_device *spi = to_spi_device(dev);
+	struct iio_dev *iio_dev = spi_get_drvdata(spi);
+	struct hts221_hw *hw = iio_priv(iio_dev);
+
+	struct spi_transfer xfers = {
+		.tx_buf = hw->tb.tx_buf,
+		.bits_per_word = 8,
+		.len = len + 1,
+	};
+
+	if (len >= HTS221_TX_MAX_LENGTH)
+		return -ENOMEM;
+
+	if (len > 1)
+		addr |= SPI_AUTO_INCREMENT;
+	hw->tb.tx_buf[0] = addr;
+	memcpy(&hw->tb.tx_buf[1], data, len);
+
+	return spi_sync_transfer(spi, &xfers, 1);
+}
+
+static const struct hts221_transfer_function hts221_transfer_fn = {
+	.read = hts221_spi_read,
+	.write = hts221_spi_write,
+};
+
+static int hts221_spi_probe(struct spi_device *spi)
+{
+	struct hts221_hw *hw;
+	struct iio_dev *iio_dev;
+
+	iio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*hw));
+	if (!iio_dev)
+		return -ENOMEM;
+
+	spi_set_drvdata(spi, iio_dev);
+
+	hw = iio_priv(iio_dev);
+	hw->name = spi->modalias;
+	hw->dev = &spi->dev;
+	hw->irq = spi->irq;
+	hw->tf = &hts221_transfer_fn;
+
+	return hts221_probe(iio_dev);
+}
+
+static const struct of_device_id hts221_spi_of_match[] = {
+	{ .compatible = "st,hts221", },
+	{},
+};
+MODULE_DEVICE_TABLE(of, hts221_spi_of_match);
+
+static const struct spi_device_id hts221_spi_id_table[] = {
+	{ HTS221_DEV_NAME },
+	{},
+};
+MODULE_DEVICE_TABLE(spi, hts221_spi_id_table);
+
+static struct spi_driver hts221_driver = {
+	.driver = {
+		.name = "hts221_spi",
+		.of_match_table = of_match_ptr(hts221_spi_of_match),
+	},
+	.probe = hts221_spi_probe,
+	.id_table = hts221_spi_id_table,
+};
+module_spi_driver(hts221_driver);
+
+MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi@st.com>");
+MODULE_DESCRIPTION("STMicroelectronics hts221 spi driver");
+MODULE_LICENSE("GPL v2");
-- 
2.7.4


^ permalink raw reply related	[flat|nested] 13+ messages in thread

* [PATCH v4 2/2] Documentation: dt: iio: humidity: add hts221 sensor device binding
  2016-10-13 20:06 ` Lorenzo Bianconi
@ 2016-10-13 20:06     ` Lorenzo Bianconi
  -1 siblings, 0 replies; 13+ messages in thread
From: Lorenzo Bianconi @ 2016-10-13 20:06 UTC (permalink / raw)
  To: jic23-DgEjT+Ai2ygdnm+yROfE0A
  Cc: linux-iio-u79uwXL29TY76Z2rM5mHXA,
	devicetree-u79uwXL29TY76Z2rM5mHXA, lorenzo.bianconi-qxv4g6HH51o

Signed-off-by: Lorenzo Bianconi <lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>
---
 .../devicetree/bindings/iio/humidity/hts221.txt    | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/iio/humidity/hts221.txt

diff --git a/Documentation/devicetree/bindings/iio/humidity/hts221.txt b/Documentation/devicetree/bindings/iio/humidity/hts221.txt
new file mode 100644
index 0000000..b20ab9c1
--- /dev/null
+++ b/Documentation/devicetree/bindings/iio/humidity/hts221.txt
@@ -0,0 +1,22 @@
+* HTS221 STM humidity + temperature sensor
+
+Required properties:
+- compatible: should be "st,hts221"
+- reg: i2c address of the sensor / spi cs line
+
+Optional properties:
+- interrupt-parent: should be the phandle for the interrupt controller
+- interrupts: interrupt mapping for IRQ. It should be configured with
+  flags IRQ_TYPE_LEVEL_HIGH or IRQ_TYPE_EDGE_RISING.
+
+  Refer to interrupt-controller/interrupts.txt for generic interrupt
+  client node bindings.
+
+Example:
+
+hts221@5f {
+	compatible = "st,hts221";
+	reg = <0x5f>;
+	interrupt-parent = <&gpio0>;
+	interrupts = <0 IRQ_TYPE_EDGE_RISING>;
+};
-- 
2.7.4

--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

^ permalink raw reply related	[flat|nested] 13+ messages in thread

* [PATCH v4 2/2] Documentation: dt: iio: humidity: add hts221 sensor device binding
@ 2016-10-13 20:06     ` Lorenzo Bianconi
  0 siblings, 0 replies; 13+ messages in thread
From: Lorenzo Bianconi @ 2016-10-13 20:06 UTC (permalink / raw)
  To: jic23; +Cc: linux-iio, devicetree, lorenzo.bianconi

Signed-off-by: Lorenzo Bianconi <lorenzo.bianconi@st.com>
---
 .../devicetree/bindings/iio/humidity/hts221.txt    | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/iio/humidity/hts221.txt

diff --git a/Documentation/devicetree/bindings/iio/humidity/hts221.txt b/Documentation/devicetree/bindings/iio/humidity/hts221.txt
new file mode 100644
index 0000000..b20ab9c1
--- /dev/null
+++ b/Documentation/devicetree/bindings/iio/humidity/hts221.txt
@@ -0,0 +1,22 @@
+* HTS221 STM humidity + temperature sensor
+
+Required properties:
+- compatible: should be "st,hts221"
+- reg: i2c address of the sensor / spi cs line
+
+Optional properties:
+- interrupt-parent: should be the phandle for the interrupt controller
+- interrupts: interrupt mapping for IRQ. It should be configured with
+  flags IRQ_TYPE_LEVEL_HIGH or IRQ_TYPE_EDGE_RISING.
+
+  Refer to interrupt-controller/interrupts.txt for generic interrupt
+  client node bindings.
+
+Example:
+
+hts221@5f {
+	compatible = "st,hts221";
+	reg = <0x5f>;
+	interrupt-parent = <&gpio0>;
+	interrupts = <0 IRQ_TYPE_EDGE_RISING>;
+};
-- 
2.7.4


^ permalink raw reply related	[flat|nested] 13+ messages in thread

* Re: [PATCH v4 2/2] Documentation: dt: iio: humidity: add hts221 sensor device binding
  2016-10-13 20:06     ` Lorenzo Bianconi
@ 2016-10-18 14:00         ` Rob Herring
  -1 siblings, 0 replies; 13+ messages in thread
From: Rob Herring @ 2016-10-18 14:00 UTC (permalink / raw)
  To: Lorenzo Bianconi
  Cc: jic23-DgEjT+Ai2ygdnm+yROfE0A, linux-iio-u79uwXL29TY76Z2rM5mHXA,
	devicetree-u79uwXL29TY76Z2rM5mHXA, lorenzo.bianconi-qxv4g6HH51o

On Thu, Oct 13, 2016 at 10:06:05PM +0200, Lorenzo Bianconi wrote:
> Signed-off-by: Lorenzo Bianconi <lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>
> ---
>  .../devicetree/bindings/iio/humidity/hts221.txt    | 22 ++++++++++++++++++++++
>  1 file changed, 22 insertions(+)
>  create mode 100644 Documentation/devicetree/bindings/iio/humidity/hts221.txt

Acked-by: Rob Herring <robh-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org>

^ permalink raw reply	[flat|nested] 13+ messages in thread

* Re: [PATCH v4 2/2] Documentation: dt: iio: humidity: add hts221 sensor device binding
@ 2016-10-18 14:00         ` Rob Herring
  0 siblings, 0 replies; 13+ messages in thread
From: Rob Herring @ 2016-10-18 14:00 UTC (permalink / raw)
  To: Lorenzo Bianconi; +Cc: jic23, linux-iio, devicetree, lorenzo.bianconi

On Thu, Oct 13, 2016 at 10:06:05PM +0200, Lorenzo Bianconi wrote:
> Signed-off-by: Lorenzo Bianconi <lorenzo.bianconi@st.com>
> ---
>  .../devicetree/bindings/iio/humidity/hts221.txt    | 22 ++++++++++++++++++++++
>  1 file changed, 22 insertions(+)
>  create mode 100644 Documentation/devicetree/bindings/iio/humidity/hts221.txt

Acked-by: Rob Herring <robh@kernel.org>

^ permalink raw reply	[flat|nested] 13+ messages in thread

* Re: [PATCH v4 1/2] iio: humidity: add support to hts221 rh/temp combo device
  2016-10-13 20:06     ` Lorenzo Bianconi
@ 2016-10-22 14:35         ` Jonathan Cameron
  -1 siblings, 0 replies; 13+ messages in thread
From: Jonathan Cameron @ 2016-10-22 14:35 UTC (permalink / raw)
  To: Lorenzo Bianconi
  Cc: linux-iio-u79uwXL29TY76Z2rM5mHXA,
	devicetree-u79uwXL29TY76Z2rM5mHXA, lorenzo.bianconi-qxv4g6HH51o

On 13/10/16 21:06, Lorenzo Bianconi wrote:
> Add support to STM HTS221 humidity + temperature sensor
> 
> http://www.st.com/resource/en/datasheet/hts221.pdf
> 
> - continuous mode support
> - i2c support
> - spi support
> - trigger mode support
> 
> Signed-off-by: Lorenzo Bianconi <lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>
Couple of really really trivial things inline. I've fixed up.

Applied to the togreg branch of iio.git and pushed out as testing
for the autobuilders to play with it.  This certainly ended up
much simpler than it started after you chased down how the hardware
was actually working!

Thanks,

Jonathan

p.s. Just discovered I didn't send this last weekend when I actually applied the patch!
Sorry about that.
> ---
>  drivers/iio/humidity/Kconfig         |  22 ++
>  drivers/iio/humidity/Makefile        |   7 +
>  drivers/iio/humidity/hts221.h        |  73 ++++
>  drivers/iio/humidity/hts221_buffer.c | 168 +++++++++
>  drivers/iio/humidity/hts221_core.c   | 687 +++++++++++++++++++++++++++++++++++
>  drivers/iio/humidity/hts221_i2c.c    | 110 ++++++
>  drivers/iio/humidity/hts221_spi.c    | 125 +++++++
>  7 files changed, 1192 insertions(+)
>  create mode 100644 drivers/iio/humidity/hts221.h
>  create mode 100644 drivers/iio/humidity/hts221_buffer.c
>  create mode 100644 drivers/iio/humidity/hts221_core.c
>  create mode 100644 drivers/iio/humidity/hts221_i2c.c
>  create mode 100644 drivers/iio/humidity/hts221_spi.c
> 
> diff --git a/drivers/iio/humidity/Kconfig b/drivers/iio/humidity/Kconfig
> index b17e2e2..6fd11d0 100644
> --- a/drivers/iio/humidity/Kconfig
> +++ b/drivers/iio/humidity/Kconfig
> @@ -34,6 +34,28 @@ config HDC100X
>  	  To compile this driver as a module, choose M here: the module
>  	  will be called hdc100x.
>  
> +config HTS221
> +	tristate "STMicroelectronics HTS221 sensor Driver"
> +	depends on (I2C || SPI)
> +	select IIO_BUFFER
> +	select IIO_TRIGGERED_BUFFER
> +	select HTS221_I2C if (I2C)
> +	select HTS221_SPI if (SPI_MASTER)
> +	help
> +	  Say yes here to build support for STMicroelectronics HTS221
> +	  temperature-humidity sensor
> +
> +	  To compile this driver as a module, choose M here: the module
> +	  will be called hts221.
> +
> +config HTS221_I2C
> +	tristate
> +	depends on HTS221
> +
> +config HTS221_SPI
> +	tristate
> +	depends on HTS221
> +
>  config HTU21
>  	tristate "Measurement Specialties HTU21 humidity & temperature sensor"
>  	depends on I2C
> diff --git a/drivers/iio/humidity/Makefile b/drivers/iio/humidity/Makefile
> index 4a73442..a6850e4 100644
> --- a/drivers/iio/humidity/Makefile
> +++ b/drivers/iio/humidity/Makefile
> @@ -5,6 +5,13 @@
>  obj-$(CONFIG_AM2315) += am2315.o
>  obj-$(CONFIG_DHT11) += dht11.o
>  obj-$(CONFIG_HDC100X) += hdc100x.o
> +
> +hts221-y := hts221_core.o \
> +	    hts221_buffer.o
> +obj-$(CONFIG_HTS221) += hts221.o
> +obj-$(CONFIG_HTS221_I2C) += hts221_i2c.o
> +obj-$(CONFIG_HTS221_SPI) += hts221_spi.o
> +
>  obj-$(CONFIG_HTU21) += htu21.o
>  obj-$(CONFIG_SI7005) += si7005.o
>  obj-$(CONFIG_SI7020) += si7020.o
> diff --git a/drivers/iio/humidity/hts221.h b/drivers/iio/humidity/hts221.h
> new file mode 100644
> index 0000000..0d2993c
> --- /dev/null
> +++ b/drivers/iio/humidity/hts221.h
> @@ -0,0 +1,73 @@
> +/*
> + * STMicroelectronics hts221 sensor driver
> + *
> + * Copyright 2016 STMicroelectronics Inc.
> + *
> + * Lorenzo Bianconi <lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>
> + *
> + * Licensed under the GPL-2.
> + */
> +
> +#ifndef HTS221_H
> +#define HTS221_H
> +
> +#define HTS221_DEV_NAME		"hts221"
> +
> +#include <linux/iio/iio.h>
> +
> +#define HTS221_RX_MAX_LENGTH	8
> +#define HTS221_TX_MAX_LENGTH	8
> +
> +#define HTS221_DATA_SIZE	2
> +
> +struct hts221_transfer_buffer {
> +	u8 rx_buf[HTS221_RX_MAX_LENGTH];
> +	u8 tx_buf[HTS221_TX_MAX_LENGTH] ____cacheline_aligned;
> +};
> +
> +struct hts221_transfer_function {
> +	int (*read)(struct device *dev, u8 addr, int len, u8 *data);
> +	int (*write)(struct device *dev, u8 addr, int len, u8 *data);
> +};
> +
> +#define HTS221_AVG_DEPTH	8
> +struct hts221_avg_avl {
> +	u16 avg;
> +	u8 val;
> +};
> +
> +enum hts221_sensor_type {
> +	HTS221_SENSOR_H,
> +	HTS221_SENSOR_T,
> +	HTS221_SENSOR_MAX,
> +};
> +
> +struct hts221_sensor {
> +	u8 cur_avg_idx;
> +	int slope, b_gen;
> +};
> +
> +struct hts221_hw {
> +	const char *name;
> +	struct device *dev;
> +
> +	struct mutex lock;
> +	struct iio_trigger *trig;
> +	int irq;
> +
> +	struct hts221_sensor sensors[HTS221_SENSOR_MAX];
> +
> +	u8 odr;
> +
> +	const struct hts221_transfer_function *tf;
> +	struct hts221_transfer_buffer tb;
> +};
> +
> +int hts221_config_drdy(struct hts221_hw *hw, bool enable);
> +int hts221_probe(struct iio_dev *iio_dev);
> +int hts221_power_on(struct hts221_hw *hw);
> +int hts221_power_off(struct hts221_hw *hw);
> +int hts221_allocate_buffers(struct hts221_hw *hw);
> +int hts221_allocate_triggers(struct hts221_hw *hw);
> +
> +#endif /* HTS221_H */
> diff --git a/drivers/iio/humidity/hts221_buffer.c b/drivers/iio/humidity/hts221_buffer.c
> new file mode 100644
> index 0000000..6b174fd
> --- /dev/null
> +++ b/drivers/iio/humidity/hts221_buffer.c
> @@ -0,0 +1,168 @@
> +/*
> + * STMicroelectronics hts221 sensor driver
> + *
> + * Copyright 2016 STMicroelectronics Inc.
> + *
> + * Lorenzo Bianconi <lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>
> + *
> + * Licensed under the GPL-2.
> + */
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/device.h>
> +#include <linux/interrupt.h>
> +#include <linux/irqreturn.h>
> +
> +#include <linux/iio/iio.h>
> +#include <linux/iio/trigger.h>
> +#include <linux/interrupt.h>
> +#include <linux/iio/events.h>
> +#include <linux/iio/trigger_consumer.h>
> +#include <linux/iio/triggered_buffer.h>
> +#include <linux/iio/buffer.h>
> +
> +#include "hts221.h"
> +
> +#define HTS221_REG_STATUS_ADDR		0x27
> +#define HTS221_RH_DRDY_MASK		BIT(1)
> +#define HTS221_TEMP_DRDY_MASK		BIT(0)
> +
> +static int hts221_trig_set_state(struct iio_trigger *trig, bool state)
> +{
> +	struct iio_dev *iio_dev = iio_trigger_get_drvdata(trig);
> +	struct hts221_hw *hw = iio_priv(iio_dev);
> +
> +	return hts221_config_drdy(hw, state);
> +}
> +
> +static const struct iio_trigger_ops hts221_trigger_ops = {
> +	.owner = THIS_MODULE,
> +	.set_trigger_state = hts221_trig_set_state,
> +};
> +
> +static irqreturn_t hts221_trigger_handler_thread(int irq, void *private)
> +{
> +	struct hts221_hw *hw = (struct hts221_hw *)private;
> +	u8 status;
> +	int err;
> +
> +	err = hw->tf->read(hw->dev, HTS221_REG_STATUS_ADDR, sizeof(status),
> +			   &status);
> +	if (err < 0)
> +		return IRQ_HANDLED;
> +
Not kernel style multi line comment. I'll fix it up if I take this version.
> +	/* H_DA bit (humidity data available) is routed to DRDY line.
> +	 * Humidity sample is computed after temperature one.
> +	 * Here we can assume data channels are both available if H_DA bit
> +	 * is set in status register
> +	 */
> +	if (!(status & HTS221_RH_DRDY_MASK))
> +		return IRQ_NONE;
> +
> +	iio_trigger_poll_chained(hw->trig);
> +
> +	return IRQ_HANDLED;
> +}
> +
> +int hts221_allocate_triggers(struct hts221_hw *hw)
Nitpick of the day - there is now only one ;)
> +{
> +	struct iio_dev *iio_dev = iio_priv_to_dev(hw);
> +	unsigned long irq_type;
> +	int err;
> +
> +	irq_type = irqd_get_trigger_type(irq_get_irq_data(hw->irq));
> +
> +	switch (irq_type) {
> +	case IRQF_TRIGGER_HIGH:
> +	case IRQF_TRIGGER_RISING:
> +		break;
> +	default:
> +		dev_info(hw->dev,
> +			 "mode %lx unsupported, using IRQF_TRIGGER_RISING\n",
> +			 irq_type);
> +		irq_type = IRQF_TRIGGER_RISING;
> +		break;
> +	}
> +
> +	err = devm_request_threaded_irq(hw->dev, hw->irq, NULL,
> +					hts221_trigger_handler_thread,
> +					irq_type | IRQF_ONESHOT,
> +					hw->name, hw);
> +	if (err) {
> +		dev_err(hw->dev, "failed to request trigger irq %d\n",
> +			hw->irq);
> +		return err;
> +	}
> +
> +	hw->trig = devm_iio_trigger_alloc(hw->dev, "%s-trigger",
> +					  iio_dev->name);
> +	if (!hw->trig)
> +		return -ENOMEM;
> +
> +	iio_trigger_set_drvdata(hw->trig, iio_dev);
> +	hw->trig->ops = &hts221_trigger_ops;
> +	hw->trig->dev.parent = hw->dev;
> +	iio_dev->trig = iio_trigger_get(hw->trig);
> +
> +	return devm_iio_trigger_register(hw->dev, hw->trig);
> +}
> +
> +static int hts221_buffer_preenable(struct iio_dev *iio_dev)
> +{
> +	return hts221_power_on(iio_priv(iio_dev));
> +}
> +
> +static int hts221_buffer_postdisable(struct iio_dev *iio_dev)
> +{
> +	return hts221_power_off(iio_priv(iio_dev));
> +}
> +
> +static const struct iio_buffer_setup_ops hts221_buffer_ops = {
> +	.preenable = hts221_buffer_preenable,
> +	.postenable = iio_triggered_buffer_postenable,
> +	.predisable = iio_triggered_buffer_predisable,
> +	.postdisable = hts221_buffer_postdisable,
> +};
> +
> +static irqreturn_t hts221_buffer_handler_thread(int irq, void *p)
> +{
> +	u8 buffer[ALIGN(2 * HTS221_DATA_SIZE, sizeof(s64)) + sizeof(s64)];
> +	struct iio_poll_func *pf = p;
> +	struct iio_dev *iio_dev = pf->indio_dev;
> +	struct hts221_hw *hw = iio_priv(iio_dev);
> +	struct iio_chan_spec const *ch;
> +	int err;
> +
> +	/* humidity data */
> +	ch = &iio_dev->channels[HTS221_SENSOR_H];
> +	err = hw->tf->read(hw->dev, ch->address, HTS221_DATA_SIZE,
> +			   buffer);
> +	if (err < 0)
> +		goto out;
> +
> +	/* temperature data */
> +	ch = &iio_dev->channels[HTS221_SENSOR_T];
> +	err = hw->tf->read(hw->dev, ch->address, HTS221_DATA_SIZE,
> +			   buffer + HTS221_DATA_SIZE);
> +	if (err < 0)
> +		goto out;
> +
> +	iio_push_to_buffers_with_timestamp(iio_dev, buffer,
> +					   iio_get_time_ns(iio_dev));
> +
> +out:
> +	iio_trigger_notify_done(hw->trig);
> +
> +	return IRQ_HANDLED;
> +}
> +
> +int hts221_allocate_buffers(struct hts221_hw *hw)
> +{
> +	return devm_iio_triggered_buffer_setup(hw->dev, iio_priv_to_dev(hw),
> +					NULL, hts221_buffer_handler_thread,
> +					&hts221_buffer_ops);
> +}
> +
> +MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>");
> +MODULE_DESCRIPTION("STMicroelectronics hts221 buffer driver");
> +MODULE_LICENSE("GPL v2");
> diff --git a/drivers/iio/humidity/hts221_core.c b/drivers/iio/humidity/hts221_core.c
> new file mode 100644
> index 0000000..5a099dd
> --- /dev/null
> +++ b/drivers/iio/humidity/hts221_core.c
> @@ -0,0 +1,687 @@
> +/*
> + * STMicroelectronics hts221 sensor driver
> + *
> + * Copyright 2016 STMicroelectronics Inc.
> + *
> + * Lorenzo Bianconi <lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>
> + *
> + * Licensed under the GPL-2.
> + */
> +
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/device.h>
> +#include <linux/iio/sysfs.h>
> +#include <linux/delay.h>
> +#include <asm/unaligned.h>
> +
> +#include "hts221.h"
> +
> +#define HTS221_REG_WHOAMI_ADDR		0x0f
> +#define HTS221_REG_WHOAMI_VAL		0xbc
> +
> +#define HTS221_REG_CNTRL1_ADDR		0x20
> +#define HTS221_REG_CNTRL2_ADDR		0x21
> +#define HTS221_REG_CNTRL3_ADDR		0x22
> +
> +#define HTS221_REG_AVG_ADDR		0x10
> +#define HTS221_REG_H_OUT_L		0x28
> +#define HTS221_REG_T_OUT_L		0x2a
> +
> +#define HTS221_HUMIDITY_AVG_MASK	0x07
> +#define HTS221_TEMP_AVG_MASK		0x38
> +
> +#define HTS221_ODR_MASK			0x87
> +#define HTS221_BDU_MASK			BIT(2)
> +
> +#define HTS221_DRDY_MASK		BIT(2)
> +
> +#define HTS221_ENABLE_SENSOR		BIT(7)
> +
> +#define HTS221_HUMIDITY_AVG_4		0x00 /* 0.4 %RH */
> +#define HTS221_HUMIDITY_AVG_8		0x01 /* 0.3 %RH */
> +#define HTS221_HUMIDITY_AVG_16		0x02 /* 0.2 %RH */
> +#define HTS221_HUMIDITY_AVG_32		0x03 /* 0.15 %RH */
> +#define HTS221_HUMIDITY_AVG_64		0x04 /* 0.1 %RH */
> +#define HTS221_HUMIDITY_AVG_128		0x05 /* 0.07 %RH */
> +#define HTS221_HUMIDITY_AVG_256		0x06 /* 0.05 %RH */
> +#define HTS221_HUMIDITY_AVG_512		0x07 /* 0.03 %RH */
> +
> +#define HTS221_TEMP_AVG_2		0x00 /* 0.08 degC */
> +#define HTS221_TEMP_AVG_4		0x08 /* 0.05 degC */
> +#define HTS221_TEMP_AVG_8		0x10 /* 0.04 degC */
> +#define HTS221_TEMP_AVG_16		0x18 /* 0.03 degC */
> +#define HTS221_TEMP_AVG_32		0x20 /* 0.02 degC */
> +#define HTS221_TEMP_AVG_64		0x28 /* 0.015 degC */
> +#define HTS221_TEMP_AVG_128		0x30 /* 0.01 degC */
> +#define HTS221_TEMP_AVG_256		0x38 /* 0.007 degC */
> +
> +/* calibration registers */
> +#define HTS221_REG_0RH_CAL_X_H		0x36
> +#define HTS221_REG_1RH_CAL_X_H		0x3a
> +#define HTS221_REG_0RH_CAL_Y_H		0x30
> +#define HTS221_REG_1RH_CAL_Y_H		0x31
> +#define HTS221_REG_0T_CAL_X_L		0x3c
> +#define HTS221_REG_1T_CAL_X_L		0x3e
> +#define HTS221_REG_0T_CAL_Y_H		0x32
> +#define HTS221_REG_1T_CAL_Y_H		0x33
> +#define HTS221_REG_T1_T0_CAL_Y_H	0x35
> +
> +struct hts221_odr {
> +	u8 hz;
> +	u8 val;
> +};
> +
> +struct hts221_avg {
> +	u8 addr;
> +	u8 mask;
> +	struct hts221_avg_avl avg_avl[HTS221_AVG_DEPTH];
> +};
> +
> +static const struct hts221_odr hts221_odr_table[] = {
> +	{  1, 0x01 },	/* 1Hz */
> +	{  7, 0x02 },	/* 7Hz */
> +	{ 13, 0x03 },	/* 12.5Hz */
> +};
> +
> +static const struct hts221_avg hts221_avg_list[] = {
> +	{
> +		.addr = HTS221_REG_AVG_ADDR,
> +		.mask = HTS221_HUMIDITY_AVG_MASK,
> +		.avg_avl = {
> +			{ 4, HTS221_HUMIDITY_AVG_4 },
> +			{ 8, HTS221_HUMIDITY_AVG_8 },
> +			{ 16, HTS221_HUMIDITY_AVG_16 },
> +			{ 32, HTS221_HUMIDITY_AVG_32 },
> +			{ 64, HTS221_HUMIDITY_AVG_64 },
> +			{ 128, HTS221_HUMIDITY_AVG_128 },
> +			{ 256, HTS221_HUMIDITY_AVG_256 },
> +			{ 512, HTS221_HUMIDITY_AVG_512 },
> +		},
> +	},
> +	{
> +		.addr = HTS221_REG_AVG_ADDR,
> +		.mask = HTS221_TEMP_AVG_MASK,
> +		.avg_avl = {
> +			{ 2, HTS221_TEMP_AVG_2 },
> +			{ 4, HTS221_TEMP_AVG_4 },
> +			{ 8, HTS221_TEMP_AVG_8 },
> +			{ 16, HTS221_TEMP_AVG_16 },
> +			{ 32, HTS221_TEMP_AVG_32 },
> +			{ 64, HTS221_TEMP_AVG_64 },
> +			{ 128, HTS221_TEMP_AVG_128 },
> +			{ 256, HTS221_TEMP_AVG_256 },
> +		},
> +	},
> +};
> +
> +static const struct iio_chan_spec hts221_channels[] = {
> +	{
> +		.type = IIO_HUMIDITYRELATIVE,
> +		.address = HTS221_REG_H_OUT_L,
> +		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
> +				      BIT(IIO_CHAN_INFO_OFFSET) |
> +				      BIT(IIO_CHAN_INFO_SCALE) |
> +				      BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
> +		.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
> +		.scan_index = 0,
> +		.scan_type = {
> +			.sign = 's',
> +			.realbits = 16,
> +			.storagebits = 16,
> +			.endianness = IIO_LE,
> +		},
> +	},
> +	{
> +		.type = IIO_TEMP,
> +		.address = HTS221_REG_T_OUT_L,
> +		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
> +				      BIT(IIO_CHAN_INFO_OFFSET) |
> +				      BIT(IIO_CHAN_INFO_SCALE) |
> +				      BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
> +		.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
> +		.scan_index = 1,
> +		.scan_type = {
> +			.sign = 's',
> +			.realbits = 16,
> +			.storagebits = 16,
> +			.endianness = IIO_LE,
> +		},
> +	},
> +	IIO_CHAN_SOFT_TIMESTAMP(2),
> +};
> +
> +static int hts221_write_with_mask(struct hts221_hw *hw, u8 addr, u8 mask,
> +				  u8 val)
> +{
> +	u8 data;
> +	int err;
> +
> +	mutex_lock(&hw->lock);
> +
> +	err = hw->tf->read(hw->dev, addr, sizeof(data), &data);
> +	if (err < 0) {
> +		dev_err(hw->dev, "failed to read %02x register\n", addr);
> +		goto unlock;
> +	}
> +
> +	data = (data & ~mask) | (val & mask);
> +
> +	err = hw->tf->write(hw->dev, addr, sizeof(data), &data);
> +	if (err < 0)
> +		dev_err(hw->dev, "failed to write %02x register\n", addr);
> +
> +unlock:
> +	mutex_unlock(&hw->lock);
> +
> +	return err;
> +}
> +
> +static int hts221_check_whoami(struct hts221_hw *hw)
> +{
> +	u8 data;
> +	int err;
> +
> +	err = hw->tf->read(hw->dev, HTS221_REG_WHOAMI_ADDR, sizeof(data),
> +			   &data);
> +	if (err < 0) {
> +		dev_err(hw->dev, "failed to read whoami register\n");
> +		return err;
> +	}
> +
> +	if (data != HTS221_REG_WHOAMI_VAL) {
> +		dev_err(hw->dev, "wrong whoami {%02x vs %02x}\n",
> +			data, HTS221_REG_WHOAMI_VAL);
> +		return -ENODEV;
> +	}
> +
> +	return 0;
> +}
> +
> +int hts221_config_drdy(struct hts221_hw *hw, bool enable)
> +{
> +	u8 val = enable ? BIT(2) : 0;
> +	int err;
> +
> +	err = hts221_write_with_mask(hw, HTS221_REG_CNTRL3_ADDR,
> +				     HTS221_DRDY_MASK, val);
> +
> +	return err < 0 ? err : 0;
> +}
> +
> +static int hts221_update_odr(struct hts221_hw *hw, u8 odr)
> +{
> +	int i, err;
> +	u8 val;
> +
> +	for (i = 0; i < ARRAY_SIZE(hts221_odr_table); i++)
> +		if (hts221_odr_table[i].hz == odr)
> +			break;
> +
> +	if (i == ARRAY_SIZE(hts221_odr_table))
> +		return -EINVAL;
> +
> +	val = HTS221_ENABLE_SENSOR | HTS221_BDU_MASK | hts221_odr_table[i].val;
> +	err = hts221_write_with_mask(hw, HTS221_REG_CNTRL1_ADDR,
> +				     HTS221_ODR_MASK, val);
> +	if (err < 0)
> +		return err;
> +
> +	hw->odr = odr;
> +
> +	return 0;
> +}
> +
> +static int hts221_update_avg(struct hts221_hw *hw,
> +			     enum hts221_sensor_type type,
> +			     u16 val)
> +{
> +	int i, err;
> +	const struct hts221_avg *avg = &hts221_avg_list[type];
> +
> +	for (i = 0; i < HTS221_AVG_DEPTH; i++)
> +		if (avg->avg_avl[i].avg == val)
> +			break;
> +
> +	if (i == HTS221_AVG_DEPTH)
> +		return -EINVAL;
> +
> +	err = hts221_write_with_mask(hw, avg->addr, avg->mask,
> +				     avg->avg_avl[i].val);
> +	if (err < 0)
> +		return err;
> +
> +	hw->sensors[type].cur_avg_idx = i;
> +
> +	return 0;
> +}
> +
> +static ssize_t hts221_sysfs_sampling_freq(struct device *dev,
> +					  struct device_attribute *attr,
> +					  char *buf)
> +{
> +	int i;
> +	ssize_t len = 0;
> +
> +	for (i = 0; i < ARRAY_SIZE(hts221_odr_table); i++)
> +		len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
> +				 hts221_odr_table[i].hz);
> +	buf[len - 1] = '\n';
> +
> +	return len;
> +}
> +
> +static ssize_t
> +hts221_sysfs_rh_oversampling_avail(struct device *dev,
> +				   struct device_attribute *attr,
> +				   char *buf)
> +{
> +	const struct hts221_avg *avg = &hts221_avg_list[HTS221_SENSOR_H];
> +	ssize_t len = 0;
> +	int i;
> +
> +	for (i = 0; i < ARRAY_SIZE(avg->avg_avl); i++)
> +		len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
> +				 avg->avg_avl[i].avg);
> +	buf[len - 1] = '\n';
> +
> +	return len;
> +}
> +
> +static ssize_t
> +hts221_sysfs_temp_oversampling_avail(struct device *dev,
> +				     struct device_attribute *attr,
> +				     char *buf)
> +{
> +	const struct hts221_avg *avg = &hts221_avg_list[HTS221_SENSOR_T];
> +	ssize_t len = 0;
> +	int i;
> +
> +	for (i = 0; i < ARRAY_SIZE(avg->avg_avl); i++)
> +		len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
> +				 avg->avg_avl[i].avg);
> +	buf[len - 1] = '\n';
> +
> +	return len;
> +}
> +
> +int hts221_power_on(struct hts221_hw *hw)
> +{
> +	return hts221_update_odr(hw, hw->odr);
> +}
> +
> +int hts221_power_off(struct hts221_hw *hw)
> +{
> +	u8 data[] = {0x00, 0x00};
> +
> +	return hw->tf->write(hw->dev, HTS221_REG_CNTRL1_ADDR, sizeof(data),
> +			     data);
> +}
> +
> +static int hts221_parse_temp_caldata(struct hts221_hw *hw)
> +{
> +	int err, *slope, *b_gen;
> +	s16 cal_x0, cal_x1, cal_y0, cal_y1;
> +	u8 cal0, cal1;
> +
> +	err = hw->tf->read(hw->dev, HTS221_REG_0T_CAL_Y_H,
> +			   sizeof(cal0), &cal0);
> +	if (err < 0)
> +		return err;
> +
> +	err = hw->tf->read(hw->dev, HTS221_REG_T1_T0_CAL_Y_H,
> +			   sizeof(cal1), &cal1);
> +	if (err < 0)
> +		return err;
> +	cal_y0 = (le16_to_cpu(cal1 & 0x3) << 8) | cal0;
> +
> +	err = hw->tf->read(hw->dev, HTS221_REG_1T_CAL_Y_H,
> +			   sizeof(cal0), &cal0);
> +	if (err < 0)
> +		return err;
> +	cal_y1 = (((cal1 & 0xc) >> 2) << 8) | cal0;
> +
> +	err = hw->tf->read(hw->dev, HTS221_REG_0T_CAL_X_L, sizeof(cal_x0),
> +			   (u8 *)&cal_x0);
> +	if (err < 0)
> +		return err;
> +	cal_x0 = le16_to_cpu(cal_x0);
> +
> +	err = hw->tf->read(hw->dev, HTS221_REG_1T_CAL_X_L, sizeof(cal_x1),
> +			   (u8 *)&cal_x1);
> +	if (err < 0)
> +		return err;
> +	cal_x1 = le16_to_cpu(cal_x1);
> +
> +	slope = &hw->sensors[HTS221_SENSOR_T].slope;
> +	b_gen = &hw->sensors[HTS221_SENSOR_T].b_gen;
> +
> +	*slope = ((cal_y1 - cal_y0) * 8000) / (cal_x1 - cal_x0);
> +	*b_gen = (((s32)cal_x1 * cal_y0 - (s32)cal_x0 * cal_y1) * 1000) /
> +		 (cal_x1 - cal_x0);
> +	*b_gen *= 8;
> +
> +	return 0;
> +}
> +
> +static int hts221_parse_rh_caldata(struct hts221_hw *hw)
> +{
> +	int err, *slope, *b_gen;
> +	s16 cal_x0, cal_x1, cal_y0, cal_y1;
> +	u8 data;
> +
> +	err = hw->tf->read(hw->dev, HTS221_REG_0RH_CAL_Y_H, sizeof(data),
> +			   &data);
> +	if (err < 0)
> +		return err;
> +	cal_y0 = data;
> +
> +	err = hw->tf->read(hw->dev, HTS221_REG_1RH_CAL_Y_H, sizeof(data),
> +			   &data);
> +	if (err < 0)
> +		return err;
> +	cal_y1 = data;
> +
> +	err = hw->tf->read(hw->dev, HTS221_REG_0RH_CAL_X_H, sizeof(cal_x0),
> +			   (u8 *)&cal_x0);
> +	if (err < 0)
> +		return err;
> +	cal_x0 = le16_to_cpu(cal_x0);
> +
> +	err = hw->tf->read(hw->dev, HTS221_REG_1RH_CAL_X_H, sizeof(cal_x1),
> +			   (u8 *)&cal_x1);
> +	if (err < 0)
> +		return err;
> +	cal_x1 = le16_to_cpu(cal_x1);
> +
> +	slope = &hw->sensors[HTS221_SENSOR_H].slope;
> +	b_gen = &hw->sensors[HTS221_SENSOR_H].b_gen;
> +
> +	*slope = ((cal_y1 - cal_y0) * 8000) / (cal_x1 - cal_x0);
> +	*b_gen = (((s32)cal_x1 * cal_y0 - (s32)cal_x0 * cal_y1) * 1000) /
> +		 (cal_x1 - cal_x0);
> +	*b_gen *= 8;
> +
> +	return 0;
> +}
> +
> +static int hts221_get_sensor_scale(struct hts221_hw *hw,
> +				   enum iio_chan_type ch_type,
> +				   int *val, int *val2)
> +{
> +	s64 tmp;
> +	s32 rem, div, data;
> +
> +	switch (ch_type) {
> +	case IIO_HUMIDITYRELATIVE:
> +		data = hw->sensors[HTS221_SENSOR_H].slope;
> +		div = (1 << 4) * 1000;
> +		break;
> +	case IIO_TEMP:
> +		data = hw->sensors[HTS221_SENSOR_T].slope;
> +		div = (1 << 6) * 1000;
> +		break;
> +	default:
> +		return -EINVAL;
> +	}
> +
> +	tmp = div_s64(data * 1000000000LL, div);
> +	tmp = div_s64_rem(tmp, 1000000000LL, &rem);
> +
> +	*val = tmp;
> +	*val2 = rem;
> +
> +	return IIO_VAL_INT_PLUS_NANO;
> +}
> +
> +static int hts221_get_sensor_offset(struct hts221_hw *hw,
> +				    enum iio_chan_type ch_type,
> +				    int *val, int *val2)
> +{
> +	s64 tmp;
> +	s32 rem, div, data;
> +
> +	switch (ch_type) {
> +	case IIO_HUMIDITYRELATIVE:
> +		data = hw->sensors[HTS221_SENSOR_H].b_gen;
> +		div = hw->sensors[HTS221_SENSOR_H].slope;
> +		break;
> +	case IIO_TEMP:
> +		data = hw->sensors[HTS221_SENSOR_T].b_gen;
> +		div = hw->sensors[HTS221_SENSOR_T].slope;
> +		break;
> +	default:
> +		return -EINVAL;
> +	}
> +
> +	tmp = div_s64(data * 1000000000LL, div);
> +	tmp = div_s64_rem(tmp, 1000000000LL, &rem);
> +
> +	*val = tmp;
> +	*val2 = rem;
> +
> +	return IIO_VAL_INT_PLUS_NANO;
> +}
> +
> +static int hts221_read_oneshot(struct hts221_hw *hw, u8 addr, int *val)
> +{
> +	u8 data[HTS221_DATA_SIZE];
> +	int err;
> +
> +	err = hts221_power_on(hw);
> +	if (err < 0)
> +		return err;
> +
> +	msleep(50);
> +
> +	err = hw->tf->read(hw->dev, addr, sizeof(data), data);
> +	if (err < 0)
> +		return err;
> +
> +	hts221_power_off(hw);
> +
> +	*val = (s16)get_unaligned_le16(data);
> +
> +	return IIO_VAL_INT;
> +}
> +
> +static int hts221_read_raw(struct iio_dev *iio_dev,
> +			   struct iio_chan_spec const *ch,
> +			   int *val, int *val2, long mask)
> +{
> +	struct hts221_hw *hw = iio_priv(iio_dev);
> +	int ret;
> +
> +	ret = iio_device_claim_direct_mode(iio_dev);
> +	if (ret)
> +		return ret;
> +
> +	switch (mask) {
> +	case IIO_CHAN_INFO_RAW:
> +		ret = hts221_read_oneshot(hw, ch->address, val);
> +		break;
> +	case IIO_CHAN_INFO_SCALE:
> +		ret = hts221_get_sensor_scale(hw, ch->type, val, val2);
> +		break;
> +	case IIO_CHAN_INFO_OFFSET:
> +		ret = hts221_get_sensor_offset(hw, ch->type, val, val2);
> +		break;
> +	case IIO_CHAN_INFO_SAMP_FREQ:
> +		*val = hw->odr;
> +		ret = IIO_VAL_INT;
> +		break;
> +	case IIO_CHAN_INFO_OVERSAMPLING_RATIO: {
> +		u8 idx;
> +		const struct hts221_avg *avg;
> +
> +		switch (ch->type) {
> +		case IIO_HUMIDITYRELATIVE:
> +			avg = &hts221_avg_list[HTS221_SENSOR_H];
> +			idx = hw->sensors[HTS221_SENSOR_H].cur_avg_idx;
> +			*val = avg->avg_avl[idx].avg;
> +			ret = IIO_VAL_INT;
> +			break;
> +		case IIO_TEMP:
> +			avg = &hts221_avg_list[HTS221_SENSOR_T];
> +			idx = hw->sensors[HTS221_SENSOR_T].cur_avg_idx;
> +			*val = avg->avg_avl[idx].avg;
> +			ret = IIO_VAL_INT;
> +			break;
> +		default:
> +			ret = -EINVAL;
> +			break;
> +		}
> +		break;
> +	}
> +	default:
> +		ret = -EINVAL;
> +		break;
> +	}
> +
> +	iio_device_release_direct_mode(iio_dev);
> +
> +	return ret;
> +}
> +
> +static int hts221_write_raw(struct iio_dev *iio_dev,
> +			    struct iio_chan_spec const *chan,
> +			    int val, int val2, long mask)
> +{
> +	struct hts221_hw *hw = iio_priv(iio_dev);
> +	int ret;
> +
> +	ret = iio_device_claim_direct_mode(iio_dev);
> +	if (ret)
> +		return ret;
> +
> +	switch (mask) {
> +	case IIO_CHAN_INFO_SAMP_FREQ:
> +		ret = hts221_update_odr(hw, val);
> +		break;
> +	case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
> +		switch (chan->type) {
> +		case IIO_HUMIDITYRELATIVE:
> +			ret = hts221_update_avg(hw, HTS221_SENSOR_H, val);
> +			break;
> +		case IIO_TEMP:
> +			ret = hts221_update_avg(hw, HTS221_SENSOR_T, val);
> +			break;
> +		default:
> +			ret = -EINVAL;
> +			break;
> +		}
> +		break;
> +	default:
> +		ret = -EINVAL;
> +		break;
> +	}
> +
> +	iio_device_release_direct_mode(iio_dev);
> +
> +	return ret;
> +}
> +
> +static int hts221_validate_trigger(struct iio_dev *iio_dev,
> +				   struct iio_trigger *trig)
> +{
> +	struct hts221_hw *hw = iio_priv(iio_dev);
> +
> +	return hw->trig == trig ? 0 : -EINVAL;
> +}
> +
> +static IIO_DEVICE_ATTR(in_humidity_oversampling_ratio_available, S_IRUGO,
> +		       hts221_sysfs_rh_oversampling_avail, NULL, 0);
> +static IIO_DEVICE_ATTR(in_temp_oversampling_ratio_available, S_IRUGO,
> +		       hts221_sysfs_temp_oversampling_avail, NULL, 0);
> +static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(hts221_sysfs_sampling_freq);
> +
> +static struct attribute *hts221_attributes[] = {
> +	&iio_dev_attr_sampling_frequency_available.dev_attr.attr,
> +	&iio_dev_attr_in_humidity_oversampling_ratio_available.dev_attr.attr,
> +	&iio_dev_attr_in_temp_oversampling_ratio_available.dev_attr.attr,
> +	NULL,
> +};
> +
> +static const struct attribute_group hts221_attribute_group = {
> +	.attrs = hts221_attributes,
> +};
> +
> +static const struct iio_info hts221_info = {
> +	.driver_module = THIS_MODULE,
> +	.attrs = &hts221_attribute_group,
> +	.read_raw = hts221_read_raw,
> +	.write_raw = hts221_write_raw,
> +	.validate_trigger = hts221_validate_trigger,
> +};
> +
> +static const unsigned long hts221_scan_masks[] = {0x3, 0x0};
> +
> +int hts221_probe(struct iio_dev *iio_dev)
> +{
> +	struct hts221_hw *hw = iio_priv(iio_dev);
> +	int err;
> +	u8 data;
> +
> +	mutex_init(&hw->lock);
> +
> +	err = hts221_check_whoami(hw);
> +	if (err < 0)
> +		return err;
> +
> +	hw->odr = hts221_odr_table[0].hz;
> +
> +	iio_dev->modes = INDIO_DIRECT_MODE;
> +	iio_dev->dev.parent = hw->dev;
> +	iio_dev->available_scan_masks = hts221_scan_masks;
> +	iio_dev->channels = hts221_channels;
> +	iio_dev->num_channels = ARRAY_SIZE(hts221_channels);
> +	iio_dev->name = HTS221_DEV_NAME;
> +	iio_dev->info = &hts221_info;
> +
> +	/* configure humidity sensor */
> +	err = hts221_parse_rh_caldata(hw);
> +	if (err < 0) {
> +		dev_err(hw->dev, "failed to get rh calibration data\n");
> +		return err;
> +	}
> +
> +	data = hts221_avg_list[HTS221_SENSOR_H].avg_avl[3].avg;
> +	err = hts221_update_avg(hw, HTS221_SENSOR_H, data);
> +	if (err < 0) {
> +		dev_err(hw->dev, "failed to set rh oversampling ratio\n");
> +		return err;
> +	}
> +
> +	/* configure temperature sensor */
> +	err = hts221_parse_temp_caldata(hw);
> +	if (err < 0) {
> +		dev_err(hw->dev,
> +			"failed to get temperature calibration data\n");
> +		return err;
> +	}
> +
> +	data = hts221_avg_list[HTS221_SENSOR_T].avg_avl[3].avg;
> +	err = hts221_update_avg(hw, HTS221_SENSOR_T, data);
> +	if (err < 0) {
> +		dev_err(hw->dev,
> +			"failed to set temperature oversampling ratio\n");
> +		return err;
> +	}
> +
> +	if (hw->irq > 0) {
> +		err = hts221_allocate_buffers(hw);
> +		if (err < 0)
> +			return err;
> +
> +		err = hts221_allocate_triggers(hw);
> +		if (err)
> +			return err;
> +	}
> +
> +	return devm_iio_device_register(hw->dev, iio_dev);
> +}
> +EXPORT_SYMBOL(hts221_probe);
> +
> +MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>");
> +MODULE_DESCRIPTION("STMicroelectronics hts221 sensor driver");
> +MODULE_LICENSE("GPL v2");
> diff --git a/drivers/iio/humidity/hts221_i2c.c b/drivers/iio/humidity/hts221_i2c.c
> new file mode 100644
> index 0000000..367ecd5
> --- /dev/null
> +++ b/drivers/iio/humidity/hts221_i2c.c
> @@ -0,0 +1,110 @@
> +/*
> + * STMicroelectronics hts221 i2c driver
> + *
> + * Copyright 2016 STMicroelectronics Inc.
> + *
> + * Lorenzo Bianconi <lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>
> + *
> + * Licensed under the GPL-2.
> + */
> +
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/i2c.h>
> +#include <linux/slab.h>
> +#include "hts221.h"
> +
> +#define I2C_AUTO_INCREMENT	0x80
> +
> +static int hts221_i2c_read(struct device *dev, u8 addr, int len, u8 *data)
> +{
> +	struct i2c_msg msg[2];
> +	struct i2c_client *client = to_i2c_client(dev);
> +
> +	if (len > 1)
> +		addr |= I2C_AUTO_INCREMENT;
> +
> +	msg[0].addr = client->addr;
> +	msg[0].flags = client->flags;
> +	msg[0].len = 1;
> +	msg[0].buf = &addr;
> +
> +	msg[1].addr = client->addr;
> +	msg[1].flags = client->flags | I2C_M_RD;
> +	msg[1].len = len;
> +	msg[1].buf = data;
> +
> +	return i2c_transfer(client->adapter, msg, 2);
> +}
> +
> +static int hts221_i2c_write(struct device *dev, u8 addr, int len, u8 *data)
> +{
> +	u8 send[len + 1];
> +	struct i2c_msg msg;
> +	struct i2c_client *client = to_i2c_client(dev);
> +
> +	if (len > 1)
> +		addr |= I2C_AUTO_INCREMENT;
> +
> +	send[0] = addr;
> +	memcpy(&send[1], data, len * sizeof(u8));
> +
> +	msg.addr = client->addr;
> +	msg.flags = client->flags;
> +	msg.len = len + 1;
> +	msg.buf = send;
> +
> +	return i2c_transfer(client->adapter, &msg, 1);
> +}
> +
> +static const struct hts221_transfer_function hts221_transfer_fn = {
> +	.read = hts221_i2c_read,
> +	.write = hts221_i2c_write,
> +};
> +
> +static int hts221_i2c_probe(struct i2c_client *client,
> +			    const struct i2c_device_id *id)
> +{
> +	struct hts221_hw *hw;
> +	struct iio_dev *iio_dev;
> +
> +	iio_dev = devm_iio_device_alloc(&client->dev, sizeof(*hw));
> +	if (!iio_dev)
> +		return -ENOMEM;
> +
> +	i2c_set_clientdata(client, iio_dev);
> +
> +	hw = iio_priv(iio_dev);
> +	hw->name = client->name;
> +	hw->dev = &client->dev;
> +	hw->irq = client->irq;
> +	hw->tf = &hts221_transfer_fn;
> +
> +	return hts221_probe(iio_dev);
> +}
> +
> +static const struct of_device_id hts221_i2c_of_match[] = {
> +	{ .compatible = "st,hts221", },
> +	{},
> +};
> +MODULE_DEVICE_TABLE(of, hts221_i2c_of_match);
> +
> +static const struct i2c_device_id hts221_i2c_id_table[] = {
> +	{ HTS221_DEV_NAME },
> +	{},
> +};
> +MODULE_DEVICE_TABLE(i2c, hts221_i2c_id_table);
> +
> +static struct i2c_driver hts221_driver = {
> +	.driver = {
> +		.name = "hts221_i2c",
> +		.of_match_table = of_match_ptr(hts221_i2c_of_match),
> +	},
> +	.probe = hts221_i2c_probe,
> +	.id_table = hts221_i2c_id_table,
> +};
> +module_i2c_driver(hts221_driver);
> +
> +MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>");
> +MODULE_DESCRIPTION("STMicroelectronics hts221 i2c driver");
> +MODULE_LICENSE("GPL v2");
> diff --git a/drivers/iio/humidity/hts221_spi.c b/drivers/iio/humidity/hts221_spi.c
> new file mode 100644
> index 0000000..70df5e7
> --- /dev/null
> +++ b/drivers/iio/humidity/hts221_spi.c
> @@ -0,0 +1,125 @@
> +/*
> + * STMicroelectronics hts221 spi driver
> + *
> + * Copyright 2016 STMicroelectronics Inc.
> + *
> + * Lorenzo Bianconi <lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>
> + *
> + * Licensed under the GPL-2.
> + */
> +
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/spi/spi.h>
> +#include <linux/slab.h>
> +#include "hts221.h"
> +
> +#define SENSORS_SPI_READ	0x80
> +#define SPI_AUTO_INCREMENT	0x40
> +
> +static int hts221_spi_read(struct device *dev, u8 addr, int len, u8 *data)
> +{
> +	int err;
> +	struct spi_device *spi = to_spi_device(dev);
> +	struct iio_dev *iio_dev = spi_get_drvdata(spi);
> +	struct hts221_hw *hw = iio_priv(iio_dev);
> +
> +	struct spi_transfer xfers[] = {
> +		{
> +			.tx_buf = hw->tb.tx_buf,
> +			.bits_per_word = 8,
> +			.len = 1,
> +		},
> +		{
> +			.rx_buf = hw->tb.rx_buf,
> +			.bits_per_word = 8,
> +			.len = len,
> +		}
> +	};
> +
> +	if (len > 1)
> +		addr |= SPI_AUTO_INCREMENT;
> +	hw->tb.tx_buf[0] = addr | SENSORS_SPI_READ;
> +
> +	err = spi_sync_transfer(spi, xfers,  ARRAY_SIZE(xfers));
> +	if (err < 0)
> +		return err;
> +
> +	memcpy(data, hw->tb.rx_buf, len * sizeof(u8));
> +
> +	return len;
> +}
> +
> +static int hts221_spi_write(struct device *dev, u8 addr, int len, u8 *data)
> +{
> +	struct spi_device *spi = to_spi_device(dev);
> +	struct iio_dev *iio_dev = spi_get_drvdata(spi);
> +	struct hts221_hw *hw = iio_priv(iio_dev);
> +
> +	struct spi_transfer xfers = {
> +		.tx_buf = hw->tb.tx_buf,
> +		.bits_per_word = 8,
> +		.len = len + 1,
> +	};
> +
> +	if (len >= HTS221_TX_MAX_LENGTH)
> +		return -ENOMEM;
> +
> +	if (len > 1)
> +		addr |= SPI_AUTO_INCREMENT;
> +	hw->tb.tx_buf[0] = addr;
> +	memcpy(&hw->tb.tx_buf[1], data, len);
> +
> +	return spi_sync_transfer(spi, &xfers, 1);
> +}
> +
> +static const struct hts221_transfer_function hts221_transfer_fn = {
> +	.read = hts221_spi_read,
> +	.write = hts221_spi_write,
> +};
> +
> +static int hts221_spi_probe(struct spi_device *spi)
> +{
> +	struct hts221_hw *hw;
> +	struct iio_dev *iio_dev;
> +
> +	iio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*hw));
> +	if (!iio_dev)
> +		return -ENOMEM;
> +
> +	spi_set_drvdata(spi, iio_dev);
> +
> +	hw = iio_priv(iio_dev);
> +	hw->name = spi->modalias;
> +	hw->dev = &spi->dev;
> +	hw->irq = spi->irq;
> +	hw->tf = &hts221_transfer_fn;
> +
> +	return hts221_probe(iio_dev);
> +}
> +
> +static const struct of_device_id hts221_spi_of_match[] = {
> +	{ .compatible = "st,hts221", },
> +	{},
> +};
> +MODULE_DEVICE_TABLE(of, hts221_spi_of_match);
> +
> +static const struct spi_device_id hts221_spi_id_table[] = {
> +	{ HTS221_DEV_NAME },
> +	{},
> +};
> +MODULE_DEVICE_TABLE(spi, hts221_spi_id_table);
> +
> +static struct spi_driver hts221_driver = {
> +	.driver = {
> +		.name = "hts221_spi",
> +		.of_match_table = of_match_ptr(hts221_spi_of_match),
> +	},
> +	.probe = hts221_spi_probe,
> +	.id_table = hts221_spi_id_table,
> +};
> +module_spi_driver(hts221_driver);
> +
> +MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>");
> +MODULE_DESCRIPTION("STMicroelectronics hts221 spi driver");
> +MODULE_LICENSE("GPL v2");
> 

--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

^ permalink raw reply	[flat|nested] 13+ messages in thread

* Re: [PATCH v4 1/2] iio: humidity: add support to hts221 rh/temp combo device
@ 2016-10-22 14:35         ` Jonathan Cameron
  0 siblings, 0 replies; 13+ messages in thread
From: Jonathan Cameron @ 2016-10-22 14:35 UTC (permalink / raw)
  To: Lorenzo Bianconi; +Cc: linux-iio, devicetree, lorenzo.bianconi

On 13/10/16 21:06, Lorenzo Bianconi wrote:
> Add support to STM HTS221 humidity + temperature sensor
> 
> http://www.st.com/resource/en/datasheet/hts221.pdf
> 
> - continuous mode support
> - i2c support
> - spi support
> - trigger mode support
> 
> Signed-off-by: Lorenzo Bianconi <lorenzo.bianconi@st.com>
Couple of really really trivial things inline. I've fixed up.

Applied to the togreg branch of iio.git and pushed out as testing
for the autobuilders to play with it.  This certainly ended up
much simpler than it started after you chased down how the hardware
was actually working!

Thanks,

Jonathan

p.s. Just discovered I didn't send this last weekend when I actually applied the patch!
Sorry about that.
> ---
>  drivers/iio/humidity/Kconfig         |  22 ++
>  drivers/iio/humidity/Makefile        |   7 +
>  drivers/iio/humidity/hts221.h        |  73 ++++
>  drivers/iio/humidity/hts221_buffer.c | 168 +++++++++
>  drivers/iio/humidity/hts221_core.c   | 687 +++++++++++++++++++++++++++++++++++
>  drivers/iio/humidity/hts221_i2c.c    | 110 ++++++
>  drivers/iio/humidity/hts221_spi.c    | 125 +++++++
>  7 files changed, 1192 insertions(+)
>  create mode 100644 drivers/iio/humidity/hts221.h
>  create mode 100644 drivers/iio/humidity/hts221_buffer.c
>  create mode 100644 drivers/iio/humidity/hts221_core.c
>  create mode 100644 drivers/iio/humidity/hts221_i2c.c
>  create mode 100644 drivers/iio/humidity/hts221_spi.c
> 
> diff --git a/drivers/iio/humidity/Kconfig b/drivers/iio/humidity/Kconfig
> index b17e2e2..6fd11d0 100644
> --- a/drivers/iio/humidity/Kconfig
> +++ b/drivers/iio/humidity/Kconfig
> @@ -34,6 +34,28 @@ config HDC100X
>  	  To compile this driver as a module, choose M here: the module
>  	  will be called hdc100x.
>  
> +config HTS221
> +	tristate "STMicroelectronics HTS221 sensor Driver"
> +	depends on (I2C || SPI)
> +	select IIO_BUFFER
> +	select IIO_TRIGGERED_BUFFER
> +	select HTS221_I2C if (I2C)
> +	select HTS221_SPI if (SPI_MASTER)
> +	help
> +	  Say yes here to build support for STMicroelectronics HTS221
> +	  temperature-humidity sensor
> +
> +	  To compile this driver as a module, choose M here: the module
> +	  will be called hts221.
> +
> +config HTS221_I2C
> +	tristate
> +	depends on HTS221
> +
> +config HTS221_SPI
> +	tristate
> +	depends on HTS221
> +
>  config HTU21
>  	tristate "Measurement Specialties HTU21 humidity & temperature sensor"
>  	depends on I2C
> diff --git a/drivers/iio/humidity/Makefile b/drivers/iio/humidity/Makefile
> index 4a73442..a6850e4 100644
> --- a/drivers/iio/humidity/Makefile
> +++ b/drivers/iio/humidity/Makefile
> @@ -5,6 +5,13 @@
>  obj-$(CONFIG_AM2315) += am2315.o
>  obj-$(CONFIG_DHT11) += dht11.o
>  obj-$(CONFIG_HDC100X) += hdc100x.o
> +
> +hts221-y := hts221_core.o \
> +	    hts221_buffer.o
> +obj-$(CONFIG_HTS221) += hts221.o
> +obj-$(CONFIG_HTS221_I2C) += hts221_i2c.o
> +obj-$(CONFIG_HTS221_SPI) += hts221_spi.o
> +
>  obj-$(CONFIG_HTU21) += htu21.o
>  obj-$(CONFIG_SI7005) += si7005.o
>  obj-$(CONFIG_SI7020) += si7020.o
> diff --git a/drivers/iio/humidity/hts221.h b/drivers/iio/humidity/hts221.h
> new file mode 100644
> index 0000000..0d2993c
> --- /dev/null
> +++ b/drivers/iio/humidity/hts221.h
> @@ -0,0 +1,73 @@
> +/*
> + * STMicroelectronics hts221 sensor driver
> + *
> + * Copyright 2016 STMicroelectronics Inc.
> + *
> + * Lorenzo Bianconi <lorenzo.bianconi@st.com>
> + *
> + * Licensed under the GPL-2.
> + */
> +
> +#ifndef HTS221_H
> +#define HTS221_H
> +
> +#define HTS221_DEV_NAME		"hts221"
> +
> +#include <linux/iio/iio.h>
> +
> +#define HTS221_RX_MAX_LENGTH	8
> +#define HTS221_TX_MAX_LENGTH	8
> +
> +#define HTS221_DATA_SIZE	2
> +
> +struct hts221_transfer_buffer {
> +	u8 rx_buf[HTS221_RX_MAX_LENGTH];
> +	u8 tx_buf[HTS221_TX_MAX_LENGTH] ____cacheline_aligned;
> +};
> +
> +struct hts221_transfer_function {
> +	int (*read)(struct device *dev, u8 addr, int len, u8 *data);
> +	int (*write)(struct device *dev, u8 addr, int len, u8 *data);
> +};
> +
> +#define HTS221_AVG_DEPTH	8
> +struct hts221_avg_avl {
> +	u16 avg;
> +	u8 val;
> +};
> +
> +enum hts221_sensor_type {
> +	HTS221_SENSOR_H,
> +	HTS221_SENSOR_T,
> +	HTS221_SENSOR_MAX,
> +};
> +
> +struct hts221_sensor {
> +	u8 cur_avg_idx;
> +	int slope, b_gen;
> +};
> +
> +struct hts221_hw {
> +	const char *name;
> +	struct device *dev;
> +
> +	struct mutex lock;
> +	struct iio_trigger *trig;
> +	int irq;
> +
> +	struct hts221_sensor sensors[HTS221_SENSOR_MAX];
> +
> +	u8 odr;
> +
> +	const struct hts221_transfer_function *tf;
> +	struct hts221_transfer_buffer tb;
> +};
> +
> +int hts221_config_drdy(struct hts221_hw *hw, bool enable);
> +int hts221_probe(struct iio_dev *iio_dev);
> +int hts221_power_on(struct hts221_hw *hw);
> +int hts221_power_off(struct hts221_hw *hw);
> +int hts221_allocate_buffers(struct hts221_hw *hw);
> +int hts221_allocate_triggers(struct hts221_hw *hw);
> +
> +#endif /* HTS221_H */
> diff --git a/drivers/iio/humidity/hts221_buffer.c b/drivers/iio/humidity/hts221_buffer.c
> new file mode 100644
> index 0000000..6b174fd
> --- /dev/null
> +++ b/drivers/iio/humidity/hts221_buffer.c
> @@ -0,0 +1,168 @@
> +/*
> + * STMicroelectronics hts221 sensor driver
> + *
> + * Copyright 2016 STMicroelectronics Inc.
> + *
> + * Lorenzo Bianconi <lorenzo.bianconi@st.com>
> + *
> + * Licensed under the GPL-2.
> + */
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/device.h>
> +#include <linux/interrupt.h>
> +#include <linux/irqreturn.h>
> +
> +#include <linux/iio/iio.h>
> +#include <linux/iio/trigger.h>
> +#include <linux/interrupt.h>
> +#include <linux/iio/events.h>
> +#include <linux/iio/trigger_consumer.h>
> +#include <linux/iio/triggered_buffer.h>
> +#include <linux/iio/buffer.h>
> +
> +#include "hts221.h"
> +
> +#define HTS221_REG_STATUS_ADDR		0x27
> +#define HTS221_RH_DRDY_MASK		BIT(1)
> +#define HTS221_TEMP_DRDY_MASK		BIT(0)
> +
> +static int hts221_trig_set_state(struct iio_trigger *trig, bool state)
> +{
> +	struct iio_dev *iio_dev = iio_trigger_get_drvdata(trig);
> +	struct hts221_hw *hw = iio_priv(iio_dev);
> +
> +	return hts221_config_drdy(hw, state);
> +}
> +
> +static const struct iio_trigger_ops hts221_trigger_ops = {
> +	.owner = THIS_MODULE,
> +	.set_trigger_state = hts221_trig_set_state,
> +};
> +
> +static irqreturn_t hts221_trigger_handler_thread(int irq, void *private)
> +{
> +	struct hts221_hw *hw = (struct hts221_hw *)private;
> +	u8 status;
> +	int err;
> +
> +	err = hw->tf->read(hw->dev, HTS221_REG_STATUS_ADDR, sizeof(status),
> +			   &status);
> +	if (err < 0)
> +		return IRQ_HANDLED;
> +
Not kernel style multi line comment. I'll fix it up if I take this version.
> +	/* H_DA bit (humidity data available) is routed to DRDY line.
> +	 * Humidity sample is computed after temperature one.
> +	 * Here we can assume data channels are both available if H_DA bit
> +	 * is set in status register
> +	 */
> +	if (!(status & HTS221_RH_DRDY_MASK))
> +		return IRQ_NONE;
> +
> +	iio_trigger_poll_chained(hw->trig);
> +
> +	return IRQ_HANDLED;
> +}
> +
> +int hts221_allocate_triggers(struct hts221_hw *hw)
Nitpick of the day - there is now only one ;)
> +{
> +	struct iio_dev *iio_dev = iio_priv_to_dev(hw);
> +	unsigned long irq_type;
> +	int err;
> +
> +	irq_type = irqd_get_trigger_type(irq_get_irq_data(hw->irq));
> +
> +	switch (irq_type) {
> +	case IRQF_TRIGGER_HIGH:
> +	case IRQF_TRIGGER_RISING:
> +		break;
> +	default:
> +		dev_info(hw->dev,
> +			 "mode %lx unsupported, using IRQF_TRIGGER_RISING\n",
> +			 irq_type);
> +		irq_type = IRQF_TRIGGER_RISING;
> +		break;
> +	}
> +
> +	err = devm_request_threaded_irq(hw->dev, hw->irq, NULL,
> +					hts221_trigger_handler_thread,
> +					irq_type | IRQF_ONESHOT,
> +					hw->name, hw);
> +	if (err) {
> +		dev_err(hw->dev, "failed to request trigger irq %d\n",
> +			hw->irq);
> +		return err;
> +	}
> +
> +	hw->trig = devm_iio_trigger_alloc(hw->dev, "%s-trigger",
> +					  iio_dev->name);
> +	if (!hw->trig)
> +		return -ENOMEM;
> +
> +	iio_trigger_set_drvdata(hw->trig, iio_dev);
> +	hw->trig->ops = &hts221_trigger_ops;
> +	hw->trig->dev.parent = hw->dev;
> +	iio_dev->trig = iio_trigger_get(hw->trig);
> +
> +	return devm_iio_trigger_register(hw->dev, hw->trig);
> +}
> +
> +static int hts221_buffer_preenable(struct iio_dev *iio_dev)
> +{
> +	return hts221_power_on(iio_priv(iio_dev));
> +}
> +
> +static int hts221_buffer_postdisable(struct iio_dev *iio_dev)
> +{
> +	return hts221_power_off(iio_priv(iio_dev));
> +}
> +
> +static const struct iio_buffer_setup_ops hts221_buffer_ops = {
> +	.preenable = hts221_buffer_preenable,
> +	.postenable = iio_triggered_buffer_postenable,
> +	.predisable = iio_triggered_buffer_predisable,
> +	.postdisable = hts221_buffer_postdisable,
> +};
> +
> +static irqreturn_t hts221_buffer_handler_thread(int irq, void *p)
> +{
> +	u8 buffer[ALIGN(2 * HTS221_DATA_SIZE, sizeof(s64)) + sizeof(s64)];
> +	struct iio_poll_func *pf = p;
> +	struct iio_dev *iio_dev = pf->indio_dev;
> +	struct hts221_hw *hw = iio_priv(iio_dev);
> +	struct iio_chan_spec const *ch;
> +	int err;
> +
> +	/* humidity data */
> +	ch = &iio_dev->channels[HTS221_SENSOR_H];
> +	err = hw->tf->read(hw->dev, ch->address, HTS221_DATA_SIZE,
> +			   buffer);
> +	if (err < 0)
> +		goto out;
> +
> +	/* temperature data */
> +	ch = &iio_dev->channels[HTS221_SENSOR_T];
> +	err = hw->tf->read(hw->dev, ch->address, HTS221_DATA_SIZE,
> +			   buffer + HTS221_DATA_SIZE);
> +	if (err < 0)
> +		goto out;
> +
> +	iio_push_to_buffers_with_timestamp(iio_dev, buffer,
> +					   iio_get_time_ns(iio_dev));
> +
> +out:
> +	iio_trigger_notify_done(hw->trig);
> +
> +	return IRQ_HANDLED;
> +}
> +
> +int hts221_allocate_buffers(struct hts221_hw *hw)
> +{
> +	return devm_iio_triggered_buffer_setup(hw->dev, iio_priv_to_dev(hw),
> +					NULL, hts221_buffer_handler_thread,
> +					&hts221_buffer_ops);
> +}
> +
> +MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi@st.com>");
> +MODULE_DESCRIPTION("STMicroelectronics hts221 buffer driver");
> +MODULE_LICENSE("GPL v2");
> diff --git a/drivers/iio/humidity/hts221_core.c b/drivers/iio/humidity/hts221_core.c
> new file mode 100644
> index 0000000..5a099dd
> --- /dev/null
> +++ b/drivers/iio/humidity/hts221_core.c
> @@ -0,0 +1,687 @@
> +/*
> + * STMicroelectronics hts221 sensor driver
> + *
> + * Copyright 2016 STMicroelectronics Inc.
> + *
> + * Lorenzo Bianconi <lorenzo.bianconi@st.com>
> + *
> + * Licensed under the GPL-2.
> + */
> +
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/device.h>
> +#include <linux/iio/sysfs.h>
> +#include <linux/delay.h>
> +#include <asm/unaligned.h>
> +
> +#include "hts221.h"
> +
> +#define HTS221_REG_WHOAMI_ADDR		0x0f
> +#define HTS221_REG_WHOAMI_VAL		0xbc
> +
> +#define HTS221_REG_CNTRL1_ADDR		0x20
> +#define HTS221_REG_CNTRL2_ADDR		0x21
> +#define HTS221_REG_CNTRL3_ADDR		0x22
> +
> +#define HTS221_REG_AVG_ADDR		0x10
> +#define HTS221_REG_H_OUT_L		0x28
> +#define HTS221_REG_T_OUT_L		0x2a
> +
> +#define HTS221_HUMIDITY_AVG_MASK	0x07
> +#define HTS221_TEMP_AVG_MASK		0x38
> +
> +#define HTS221_ODR_MASK			0x87
> +#define HTS221_BDU_MASK			BIT(2)
> +
> +#define HTS221_DRDY_MASK		BIT(2)
> +
> +#define HTS221_ENABLE_SENSOR		BIT(7)
> +
> +#define HTS221_HUMIDITY_AVG_4		0x00 /* 0.4 %RH */
> +#define HTS221_HUMIDITY_AVG_8		0x01 /* 0.3 %RH */
> +#define HTS221_HUMIDITY_AVG_16		0x02 /* 0.2 %RH */
> +#define HTS221_HUMIDITY_AVG_32		0x03 /* 0.15 %RH */
> +#define HTS221_HUMIDITY_AVG_64		0x04 /* 0.1 %RH */
> +#define HTS221_HUMIDITY_AVG_128		0x05 /* 0.07 %RH */
> +#define HTS221_HUMIDITY_AVG_256		0x06 /* 0.05 %RH */
> +#define HTS221_HUMIDITY_AVG_512		0x07 /* 0.03 %RH */
> +
> +#define HTS221_TEMP_AVG_2		0x00 /* 0.08 degC */
> +#define HTS221_TEMP_AVG_4		0x08 /* 0.05 degC */
> +#define HTS221_TEMP_AVG_8		0x10 /* 0.04 degC */
> +#define HTS221_TEMP_AVG_16		0x18 /* 0.03 degC */
> +#define HTS221_TEMP_AVG_32		0x20 /* 0.02 degC */
> +#define HTS221_TEMP_AVG_64		0x28 /* 0.015 degC */
> +#define HTS221_TEMP_AVG_128		0x30 /* 0.01 degC */
> +#define HTS221_TEMP_AVG_256		0x38 /* 0.007 degC */
> +
> +/* calibration registers */
> +#define HTS221_REG_0RH_CAL_X_H		0x36
> +#define HTS221_REG_1RH_CAL_X_H		0x3a
> +#define HTS221_REG_0RH_CAL_Y_H		0x30
> +#define HTS221_REG_1RH_CAL_Y_H		0x31
> +#define HTS221_REG_0T_CAL_X_L		0x3c
> +#define HTS221_REG_1T_CAL_X_L		0x3e
> +#define HTS221_REG_0T_CAL_Y_H		0x32
> +#define HTS221_REG_1T_CAL_Y_H		0x33
> +#define HTS221_REG_T1_T0_CAL_Y_H	0x35
> +
> +struct hts221_odr {
> +	u8 hz;
> +	u8 val;
> +};
> +
> +struct hts221_avg {
> +	u8 addr;
> +	u8 mask;
> +	struct hts221_avg_avl avg_avl[HTS221_AVG_DEPTH];
> +};
> +
> +static const struct hts221_odr hts221_odr_table[] = {
> +	{  1, 0x01 },	/* 1Hz */
> +	{  7, 0x02 },	/* 7Hz */
> +	{ 13, 0x03 },	/* 12.5Hz */
> +};
> +
> +static const struct hts221_avg hts221_avg_list[] = {
> +	{
> +		.addr = HTS221_REG_AVG_ADDR,
> +		.mask = HTS221_HUMIDITY_AVG_MASK,
> +		.avg_avl = {
> +			{ 4, HTS221_HUMIDITY_AVG_4 },
> +			{ 8, HTS221_HUMIDITY_AVG_8 },
> +			{ 16, HTS221_HUMIDITY_AVG_16 },
> +			{ 32, HTS221_HUMIDITY_AVG_32 },
> +			{ 64, HTS221_HUMIDITY_AVG_64 },
> +			{ 128, HTS221_HUMIDITY_AVG_128 },
> +			{ 256, HTS221_HUMIDITY_AVG_256 },
> +			{ 512, HTS221_HUMIDITY_AVG_512 },
> +		},
> +	},
> +	{
> +		.addr = HTS221_REG_AVG_ADDR,
> +		.mask = HTS221_TEMP_AVG_MASK,
> +		.avg_avl = {
> +			{ 2, HTS221_TEMP_AVG_2 },
> +			{ 4, HTS221_TEMP_AVG_4 },
> +			{ 8, HTS221_TEMP_AVG_8 },
> +			{ 16, HTS221_TEMP_AVG_16 },
> +			{ 32, HTS221_TEMP_AVG_32 },
> +			{ 64, HTS221_TEMP_AVG_64 },
> +			{ 128, HTS221_TEMP_AVG_128 },
> +			{ 256, HTS221_TEMP_AVG_256 },
> +		},
> +	},
> +};
> +
> +static const struct iio_chan_spec hts221_channels[] = {
> +	{
> +		.type = IIO_HUMIDITYRELATIVE,
> +		.address = HTS221_REG_H_OUT_L,
> +		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
> +				      BIT(IIO_CHAN_INFO_OFFSET) |
> +				      BIT(IIO_CHAN_INFO_SCALE) |
> +				      BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
> +		.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
> +		.scan_index = 0,
> +		.scan_type = {
> +			.sign = 's',
> +			.realbits = 16,
> +			.storagebits = 16,
> +			.endianness = IIO_LE,
> +		},
> +	},
> +	{
> +		.type = IIO_TEMP,
> +		.address = HTS221_REG_T_OUT_L,
> +		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
> +				      BIT(IIO_CHAN_INFO_OFFSET) |
> +				      BIT(IIO_CHAN_INFO_SCALE) |
> +				      BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
> +		.info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
> +		.scan_index = 1,
> +		.scan_type = {
> +			.sign = 's',
> +			.realbits = 16,
> +			.storagebits = 16,
> +			.endianness = IIO_LE,
> +		},
> +	},
> +	IIO_CHAN_SOFT_TIMESTAMP(2),
> +};
> +
> +static int hts221_write_with_mask(struct hts221_hw *hw, u8 addr, u8 mask,
> +				  u8 val)
> +{
> +	u8 data;
> +	int err;
> +
> +	mutex_lock(&hw->lock);
> +
> +	err = hw->tf->read(hw->dev, addr, sizeof(data), &data);
> +	if (err < 0) {
> +		dev_err(hw->dev, "failed to read %02x register\n", addr);
> +		goto unlock;
> +	}
> +
> +	data = (data & ~mask) | (val & mask);
> +
> +	err = hw->tf->write(hw->dev, addr, sizeof(data), &data);
> +	if (err < 0)
> +		dev_err(hw->dev, "failed to write %02x register\n", addr);
> +
> +unlock:
> +	mutex_unlock(&hw->lock);
> +
> +	return err;
> +}
> +
> +static int hts221_check_whoami(struct hts221_hw *hw)
> +{
> +	u8 data;
> +	int err;
> +
> +	err = hw->tf->read(hw->dev, HTS221_REG_WHOAMI_ADDR, sizeof(data),
> +			   &data);
> +	if (err < 0) {
> +		dev_err(hw->dev, "failed to read whoami register\n");
> +		return err;
> +	}
> +
> +	if (data != HTS221_REG_WHOAMI_VAL) {
> +		dev_err(hw->dev, "wrong whoami {%02x vs %02x}\n",
> +			data, HTS221_REG_WHOAMI_VAL);
> +		return -ENODEV;
> +	}
> +
> +	return 0;
> +}
> +
> +int hts221_config_drdy(struct hts221_hw *hw, bool enable)
> +{
> +	u8 val = enable ? BIT(2) : 0;
> +	int err;
> +
> +	err = hts221_write_with_mask(hw, HTS221_REG_CNTRL3_ADDR,
> +				     HTS221_DRDY_MASK, val);
> +
> +	return err < 0 ? err : 0;
> +}
> +
> +static int hts221_update_odr(struct hts221_hw *hw, u8 odr)
> +{
> +	int i, err;
> +	u8 val;
> +
> +	for (i = 0; i < ARRAY_SIZE(hts221_odr_table); i++)
> +		if (hts221_odr_table[i].hz == odr)
> +			break;
> +
> +	if (i == ARRAY_SIZE(hts221_odr_table))
> +		return -EINVAL;
> +
> +	val = HTS221_ENABLE_SENSOR | HTS221_BDU_MASK | hts221_odr_table[i].val;
> +	err = hts221_write_with_mask(hw, HTS221_REG_CNTRL1_ADDR,
> +				     HTS221_ODR_MASK, val);
> +	if (err < 0)
> +		return err;
> +
> +	hw->odr = odr;
> +
> +	return 0;
> +}
> +
> +static int hts221_update_avg(struct hts221_hw *hw,
> +			     enum hts221_sensor_type type,
> +			     u16 val)
> +{
> +	int i, err;
> +	const struct hts221_avg *avg = &hts221_avg_list[type];
> +
> +	for (i = 0; i < HTS221_AVG_DEPTH; i++)
> +		if (avg->avg_avl[i].avg == val)
> +			break;
> +
> +	if (i == HTS221_AVG_DEPTH)
> +		return -EINVAL;
> +
> +	err = hts221_write_with_mask(hw, avg->addr, avg->mask,
> +				     avg->avg_avl[i].val);
> +	if (err < 0)
> +		return err;
> +
> +	hw->sensors[type].cur_avg_idx = i;
> +
> +	return 0;
> +}
> +
> +static ssize_t hts221_sysfs_sampling_freq(struct device *dev,
> +					  struct device_attribute *attr,
> +					  char *buf)
> +{
> +	int i;
> +	ssize_t len = 0;
> +
> +	for (i = 0; i < ARRAY_SIZE(hts221_odr_table); i++)
> +		len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
> +				 hts221_odr_table[i].hz);
> +	buf[len - 1] = '\n';
> +
> +	return len;
> +}
> +
> +static ssize_t
> +hts221_sysfs_rh_oversampling_avail(struct device *dev,
> +				   struct device_attribute *attr,
> +				   char *buf)
> +{
> +	const struct hts221_avg *avg = &hts221_avg_list[HTS221_SENSOR_H];
> +	ssize_t len = 0;
> +	int i;
> +
> +	for (i = 0; i < ARRAY_SIZE(avg->avg_avl); i++)
> +		len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
> +				 avg->avg_avl[i].avg);
> +	buf[len - 1] = '\n';
> +
> +	return len;
> +}
> +
> +static ssize_t
> +hts221_sysfs_temp_oversampling_avail(struct device *dev,
> +				     struct device_attribute *attr,
> +				     char *buf)
> +{
> +	const struct hts221_avg *avg = &hts221_avg_list[HTS221_SENSOR_T];
> +	ssize_t len = 0;
> +	int i;
> +
> +	for (i = 0; i < ARRAY_SIZE(avg->avg_avl); i++)
> +		len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
> +				 avg->avg_avl[i].avg);
> +	buf[len - 1] = '\n';
> +
> +	return len;
> +}
> +
> +int hts221_power_on(struct hts221_hw *hw)
> +{
> +	return hts221_update_odr(hw, hw->odr);
> +}
> +
> +int hts221_power_off(struct hts221_hw *hw)
> +{
> +	u8 data[] = {0x00, 0x00};
> +
> +	return hw->tf->write(hw->dev, HTS221_REG_CNTRL1_ADDR, sizeof(data),
> +			     data);
> +}
> +
> +static int hts221_parse_temp_caldata(struct hts221_hw *hw)
> +{
> +	int err, *slope, *b_gen;
> +	s16 cal_x0, cal_x1, cal_y0, cal_y1;
> +	u8 cal0, cal1;
> +
> +	err = hw->tf->read(hw->dev, HTS221_REG_0T_CAL_Y_H,
> +			   sizeof(cal0), &cal0);
> +	if (err < 0)
> +		return err;
> +
> +	err = hw->tf->read(hw->dev, HTS221_REG_T1_T0_CAL_Y_H,
> +			   sizeof(cal1), &cal1);
> +	if (err < 0)
> +		return err;
> +	cal_y0 = (le16_to_cpu(cal1 & 0x3) << 8) | cal0;
> +
> +	err = hw->tf->read(hw->dev, HTS221_REG_1T_CAL_Y_H,
> +			   sizeof(cal0), &cal0);
> +	if (err < 0)
> +		return err;
> +	cal_y1 = (((cal1 & 0xc) >> 2) << 8) | cal0;
> +
> +	err = hw->tf->read(hw->dev, HTS221_REG_0T_CAL_X_L, sizeof(cal_x0),
> +			   (u8 *)&cal_x0);
> +	if (err < 0)
> +		return err;
> +	cal_x0 = le16_to_cpu(cal_x0);
> +
> +	err = hw->tf->read(hw->dev, HTS221_REG_1T_CAL_X_L, sizeof(cal_x1),
> +			   (u8 *)&cal_x1);
> +	if (err < 0)
> +		return err;
> +	cal_x1 = le16_to_cpu(cal_x1);
> +
> +	slope = &hw->sensors[HTS221_SENSOR_T].slope;
> +	b_gen = &hw->sensors[HTS221_SENSOR_T].b_gen;
> +
> +	*slope = ((cal_y1 - cal_y0) * 8000) / (cal_x1 - cal_x0);
> +	*b_gen = (((s32)cal_x1 * cal_y0 - (s32)cal_x0 * cal_y1) * 1000) /
> +		 (cal_x1 - cal_x0);
> +	*b_gen *= 8;
> +
> +	return 0;
> +}
> +
> +static int hts221_parse_rh_caldata(struct hts221_hw *hw)
> +{
> +	int err, *slope, *b_gen;
> +	s16 cal_x0, cal_x1, cal_y0, cal_y1;
> +	u8 data;
> +
> +	err = hw->tf->read(hw->dev, HTS221_REG_0RH_CAL_Y_H, sizeof(data),
> +			   &data);
> +	if (err < 0)
> +		return err;
> +	cal_y0 = data;
> +
> +	err = hw->tf->read(hw->dev, HTS221_REG_1RH_CAL_Y_H, sizeof(data),
> +			   &data);
> +	if (err < 0)
> +		return err;
> +	cal_y1 = data;
> +
> +	err = hw->tf->read(hw->dev, HTS221_REG_0RH_CAL_X_H, sizeof(cal_x0),
> +			   (u8 *)&cal_x0);
> +	if (err < 0)
> +		return err;
> +	cal_x0 = le16_to_cpu(cal_x0);
> +
> +	err = hw->tf->read(hw->dev, HTS221_REG_1RH_CAL_X_H, sizeof(cal_x1),
> +			   (u8 *)&cal_x1);
> +	if (err < 0)
> +		return err;
> +	cal_x1 = le16_to_cpu(cal_x1);
> +
> +	slope = &hw->sensors[HTS221_SENSOR_H].slope;
> +	b_gen = &hw->sensors[HTS221_SENSOR_H].b_gen;
> +
> +	*slope = ((cal_y1 - cal_y0) * 8000) / (cal_x1 - cal_x0);
> +	*b_gen = (((s32)cal_x1 * cal_y0 - (s32)cal_x0 * cal_y1) * 1000) /
> +		 (cal_x1 - cal_x0);
> +	*b_gen *= 8;
> +
> +	return 0;
> +}
> +
> +static int hts221_get_sensor_scale(struct hts221_hw *hw,
> +				   enum iio_chan_type ch_type,
> +				   int *val, int *val2)
> +{
> +	s64 tmp;
> +	s32 rem, div, data;
> +
> +	switch (ch_type) {
> +	case IIO_HUMIDITYRELATIVE:
> +		data = hw->sensors[HTS221_SENSOR_H].slope;
> +		div = (1 << 4) * 1000;
> +		break;
> +	case IIO_TEMP:
> +		data = hw->sensors[HTS221_SENSOR_T].slope;
> +		div = (1 << 6) * 1000;
> +		break;
> +	default:
> +		return -EINVAL;
> +	}
> +
> +	tmp = div_s64(data * 1000000000LL, div);
> +	tmp = div_s64_rem(tmp, 1000000000LL, &rem);
> +
> +	*val = tmp;
> +	*val2 = rem;
> +
> +	return IIO_VAL_INT_PLUS_NANO;
> +}
> +
> +static int hts221_get_sensor_offset(struct hts221_hw *hw,
> +				    enum iio_chan_type ch_type,
> +				    int *val, int *val2)
> +{
> +	s64 tmp;
> +	s32 rem, div, data;
> +
> +	switch (ch_type) {
> +	case IIO_HUMIDITYRELATIVE:
> +		data = hw->sensors[HTS221_SENSOR_H].b_gen;
> +		div = hw->sensors[HTS221_SENSOR_H].slope;
> +		break;
> +	case IIO_TEMP:
> +		data = hw->sensors[HTS221_SENSOR_T].b_gen;
> +		div = hw->sensors[HTS221_SENSOR_T].slope;
> +		break;
> +	default:
> +		return -EINVAL;
> +	}
> +
> +	tmp = div_s64(data * 1000000000LL, div);
> +	tmp = div_s64_rem(tmp, 1000000000LL, &rem);
> +
> +	*val = tmp;
> +	*val2 = rem;
> +
> +	return IIO_VAL_INT_PLUS_NANO;
> +}
> +
> +static int hts221_read_oneshot(struct hts221_hw *hw, u8 addr, int *val)
> +{
> +	u8 data[HTS221_DATA_SIZE];
> +	int err;
> +
> +	err = hts221_power_on(hw);
> +	if (err < 0)
> +		return err;
> +
> +	msleep(50);
> +
> +	err = hw->tf->read(hw->dev, addr, sizeof(data), data);
> +	if (err < 0)
> +		return err;
> +
> +	hts221_power_off(hw);
> +
> +	*val = (s16)get_unaligned_le16(data);
> +
> +	return IIO_VAL_INT;
> +}
> +
> +static int hts221_read_raw(struct iio_dev *iio_dev,
> +			   struct iio_chan_spec const *ch,
> +			   int *val, int *val2, long mask)
> +{
> +	struct hts221_hw *hw = iio_priv(iio_dev);
> +	int ret;
> +
> +	ret = iio_device_claim_direct_mode(iio_dev);
> +	if (ret)
> +		return ret;
> +
> +	switch (mask) {
> +	case IIO_CHAN_INFO_RAW:
> +		ret = hts221_read_oneshot(hw, ch->address, val);
> +		break;
> +	case IIO_CHAN_INFO_SCALE:
> +		ret = hts221_get_sensor_scale(hw, ch->type, val, val2);
> +		break;
> +	case IIO_CHAN_INFO_OFFSET:
> +		ret = hts221_get_sensor_offset(hw, ch->type, val, val2);
> +		break;
> +	case IIO_CHAN_INFO_SAMP_FREQ:
> +		*val = hw->odr;
> +		ret = IIO_VAL_INT;
> +		break;
> +	case IIO_CHAN_INFO_OVERSAMPLING_RATIO: {
> +		u8 idx;
> +		const struct hts221_avg *avg;
> +
> +		switch (ch->type) {
> +		case IIO_HUMIDITYRELATIVE:
> +			avg = &hts221_avg_list[HTS221_SENSOR_H];
> +			idx = hw->sensors[HTS221_SENSOR_H].cur_avg_idx;
> +			*val = avg->avg_avl[idx].avg;
> +			ret = IIO_VAL_INT;
> +			break;
> +		case IIO_TEMP:
> +			avg = &hts221_avg_list[HTS221_SENSOR_T];
> +			idx = hw->sensors[HTS221_SENSOR_T].cur_avg_idx;
> +			*val = avg->avg_avl[idx].avg;
> +			ret = IIO_VAL_INT;
> +			break;
> +		default:
> +			ret = -EINVAL;
> +			break;
> +		}
> +		break;
> +	}
> +	default:
> +		ret = -EINVAL;
> +		break;
> +	}
> +
> +	iio_device_release_direct_mode(iio_dev);
> +
> +	return ret;
> +}
> +
> +static int hts221_write_raw(struct iio_dev *iio_dev,
> +			    struct iio_chan_spec const *chan,
> +			    int val, int val2, long mask)
> +{
> +	struct hts221_hw *hw = iio_priv(iio_dev);
> +	int ret;
> +
> +	ret = iio_device_claim_direct_mode(iio_dev);
> +	if (ret)
> +		return ret;
> +
> +	switch (mask) {
> +	case IIO_CHAN_INFO_SAMP_FREQ:
> +		ret = hts221_update_odr(hw, val);
> +		break;
> +	case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
> +		switch (chan->type) {
> +		case IIO_HUMIDITYRELATIVE:
> +			ret = hts221_update_avg(hw, HTS221_SENSOR_H, val);
> +			break;
> +		case IIO_TEMP:
> +			ret = hts221_update_avg(hw, HTS221_SENSOR_T, val);
> +			break;
> +		default:
> +			ret = -EINVAL;
> +			break;
> +		}
> +		break;
> +	default:
> +		ret = -EINVAL;
> +		break;
> +	}
> +
> +	iio_device_release_direct_mode(iio_dev);
> +
> +	return ret;
> +}
> +
> +static int hts221_validate_trigger(struct iio_dev *iio_dev,
> +				   struct iio_trigger *trig)
> +{
> +	struct hts221_hw *hw = iio_priv(iio_dev);
> +
> +	return hw->trig == trig ? 0 : -EINVAL;
> +}
> +
> +static IIO_DEVICE_ATTR(in_humidity_oversampling_ratio_available, S_IRUGO,
> +		       hts221_sysfs_rh_oversampling_avail, NULL, 0);
> +static IIO_DEVICE_ATTR(in_temp_oversampling_ratio_available, S_IRUGO,
> +		       hts221_sysfs_temp_oversampling_avail, NULL, 0);
> +static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(hts221_sysfs_sampling_freq);
> +
> +static struct attribute *hts221_attributes[] = {
> +	&iio_dev_attr_sampling_frequency_available.dev_attr.attr,
> +	&iio_dev_attr_in_humidity_oversampling_ratio_available.dev_attr.attr,
> +	&iio_dev_attr_in_temp_oversampling_ratio_available.dev_attr.attr,
> +	NULL,
> +};
> +
> +static const struct attribute_group hts221_attribute_group = {
> +	.attrs = hts221_attributes,
> +};
> +
> +static const struct iio_info hts221_info = {
> +	.driver_module = THIS_MODULE,
> +	.attrs = &hts221_attribute_group,
> +	.read_raw = hts221_read_raw,
> +	.write_raw = hts221_write_raw,
> +	.validate_trigger = hts221_validate_trigger,
> +};
> +
> +static const unsigned long hts221_scan_masks[] = {0x3, 0x0};
> +
> +int hts221_probe(struct iio_dev *iio_dev)
> +{
> +	struct hts221_hw *hw = iio_priv(iio_dev);
> +	int err;
> +	u8 data;
> +
> +	mutex_init(&hw->lock);
> +
> +	err = hts221_check_whoami(hw);
> +	if (err < 0)
> +		return err;
> +
> +	hw->odr = hts221_odr_table[0].hz;
> +
> +	iio_dev->modes = INDIO_DIRECT_MODE;
> +	iio_dev->dev.parent = hw->dev;
> +	iio_dev->available_scan_masks = hts221_scan_masks;
> +	iio_dev->channels = hts221_channels;
> +	iio_dev->num_channels = ARRAY_SIZE(hts221_channels);
> +	iio_dev->name = HTS221_DEV_NAME;
> +	iio_dev->info = &hts221_info;
> +
> +	/* configure humidity sensor */
> +	err = hts221_parse_rh_caldata(hw);
> +	if (err < 0) {
> +		dev_err(hw->dev, "failed to get rh calibration data\n");
> +		return err;
> +	}
> +
> +	data = hts221_avg_list[HTS221_SENSOR_H].avg_avl[3].avg;
> +	err = hts221_update_avg(hw, HTS221_SENSOR_H, data);
> +	if (err < 0) {
> +		dev_err(hw->dev, "failed to set rh oversampling ratio\n");
> +		return err;
> +	}
> +
> +	/* configure temperature sensor */
> +	err = hts221_parse_temp_caldata(hw);
> +	if (err < 0) {
> +		dev_err(hw->dev,
> +			"failed to get temperature calibration data\n");
> +		return err;
> +	}
> +
> +	data = hts221_avg_list[HTS221_SENSOR_T].avg_avl[3].avg;
> +	err = hts221_update_avg(hw, HTS221_SENSOR_T, data);
> +	if (err < 0) {
> +		dev_err(hw->dev,
> +			"failed to set temperature oversampling ratio\n");
> +		return err;
> +	}
> +
> +	if (hw->irq > 0) {
> +		err = hts221_allocate_buffers(hw);
> +		if (err < 0)
> +			return err;
> +
> +		err = hts221_allocate_triggers(hw);
> +		if (err)
> +			return err;
> +	}
> +
> +	return devm_iio_device_register(hw->dev, iio_dev);
> +}
> +EXPORT_SYMBOL(hts221_probe);
> +
> +MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi@st.com>");
> +MODULE_DESCRIPTION("STMicroelectronics hts221 sensor driver");
> +MODULE_LICENSE("GPL v2");
> diff --git a/drivers/iio/humidity/hts221_i2c.c b/drivers/iio/humidity/hts221_i2c.c
> new file mode 100644
> index 0000000..367ecd5
> --- /dev/null
> +++ b/drivers/iio/humidity/hts221_i2c.c
> @@ -0,0 +1,110 @@
> +/*
> + * STMicroelectronics hts221 i2c driver
> + *
> + * Copyright 2016 STMicroelectronics Inc.
> + *
> + * Lorenzo Bianconi <lorenzo.bianconi@st.com>
> + *
> + * Licensed under the GPL-2.
> + */
> +
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/i2c.h>
> +#include <linux/slab.h>
> +#include "hts221.h"
> +
> +#define I2C_AUTO_INCREMENT	0x80
> +
> +static int hts221_i2c_read(struct device *dev, u8 addr, int len, u8 *data)
> +{
> +	struct i2c_msg msg[2];
> +	struct i2c_client *client = to_i2c_client(dev);
> +
> +	if (len > 1)
> +		addr |= I2C_AUTO_INCREMENT;
> +
> +	msg[0].addr = client->addr;
> +	msg[0].flags = client->flags;
> +	msg[0].len = 1;
> +	msg[0].buf = &addr;
> +
> +	msg[1].addr = client->addr;
> +	msg[1].flags = client->flags | I2C_M_RD;
> +	msg[1].len = len;
> +	msg[1].buf = data;
> +
> +	return i2c_transfer(client->adapter, msg, 2);
> +}
> +
> +static int hts221_i2c_write(struct device *dev, u8 addr, int len, u8 *data)
> +{
> +	u8 send[len + 1];
> +	struct i2c_msg msg;
> +	struct i2c_client *client = to_i2c_client(dev);
> +
> +	if (len > 1)
> +		addr |= I2C_AUTO_INCREMENT;
> +
> +	send[0] = addr;
> +	memcpy(&send[1], data, len * sizeof(u8));
> +
> +	msg.addr = client->addr;
> +	msg.flags = client->flags;
> +	msg.len = len + 1;
> +	msg.buf = send;
> +
> +	return i2c_transfer(client->adapter, &msg, 1);
> +}
> +
> +static const struct hts221_transfer_function hts221_transfer_fn = {
> +	.read = hts221_i2c_read,
> +	.write = hts221_i2c_write,
> +};
> +
> +static int hts221_i2c_probe(struct i2c_client *client,
> +			    const struct i2c_device_id *id)
> +{
> +	struct hts221_hw *hw;
> +	struct iio_dev *iio_dev;
> +
> +	iio_dev = devm_iio_device_alloc(&client->dev, sizeof(*hw));
> +	if (!iio_dev)
> +		return -ENOMEM;
> +
> +	i2c_set_clientdata(client, iio_dev);
> +
> +	hw = iio_priv(iio_dev);
> +	hw->name = client->name;
> +	hw->dev = &client->dev;
> +	hw->irq = client->irq;
> +	hw->tf = &hts221_transfer_fn;
> +
> +	return hts221_probe(iio_dev);
> +}
> +
> +static const struct of_device_id hts221_i2c_of_match[] = {
> +	{ .compatible = "st,hts221", },
> +	{},
> +};
> +MODULE_DEVICE_TABLE(of, hts221_i2c_of_match);
> +
> +static const struct i2c_device_id hts221_i2c_id_table[] = {
> +	{ HTS221_DEV_NAME },
> +	{},
> +};
> +MODULE_DEVICE_TABLE(i2c, hts221_i2c_id_table);
> +
> +static struct i2c_driver hts221_driver = {
> +	.driver = {
> +		.name = "hts221_i2c",
> +		.of_match_table = of_match_ptr(hts221_i2c_of_match),
> +	},
> +	.probe = hts221_i2c_probe,
> +	.id_table = hts221_i2c_id_table,
> +};
> +module_i2c_driver(hts221_driver);
> +
> +MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi@st.com>");
> +MODULE_DESCRIPTION("STMicroelectronics hts221 i2c driver");
> +MODULE_LICENSE("GPL v2");
> diff --git a/drivers/iio/humidity/hts221_spi.c b/drivers/iio/humidity/hts221_spi.c
> new file mode 100644
> index 0000000..70df5e7
> --- /dev/null
> +++ b/drivers/iio/humidity/hts221_spi.c
> @@ -0,0 +1,125 @@
> +/*
> + * STMicroelectronics hts221 spi driver
> + *
> + * Copyright 2016 STMicroelectronics Inc.
> + *
> + * Lorenzo Bianconi <lorenzo.bianconi@st.com>
> + *
> + * Licensed under the GPL-2.
> + */
> +
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/spi/spi.h>
> +#include <linux/slab.h>
> +#include "hts221.h"
> +
> +#define SENSORS_SPI_READ	0x80
> +#define SPI_AUTO_INCREMENT	0x40
> +
> +static int hts221_spi_read(struct device *dev, u8 addr, int len, u8 *data)
> +{
> +	int err;
> +	struct spi_device *spi = to_spi_device(dev);
> +	struct iio_dev *iio_dev = spi_get_drvdata(spi);
> +	struct hts221_hw *hw = iio_priv(iio_dev);
> +
> +	struct spi_transfer xfers[] = {
> +		{
> +			.tx_buf = hw->tb.tx_buf,
> +			.bits_per_word = 8,
> +			.len = 1,
> +		},
> +		{
> +			.rx_buf = hw->tb.rx_buf,
> +			.bits_per_word = 8,
> +			.len = len,
> +		}
> +	};
> +
> +	if (len > 1)
> +		addr |= SPI_AUTO_INCREMENT;
> +	hw->tb.tx_buf[0] = addr | SENSORS_SPI_READ;
> +
> +	err = spi_sync_transfer(spi, xfers,  ARRAY_SIZE(xfers));
> +	if (err < 0)
> +		return err;
> +
> +	memcpy(data, hw->tb.rx_buf, len * sizeof(u8));
> +
> +	return len;
> +}
> +
> +static int hts221_spi_write(struct device *dev, u8 addr, int len, u8 *data)
> +{
> +	struct spi_device *spi = to_spi_device(dev);
> +	struct iio_dev *iio_dev = spi_get_drvdata(spi);
> +	struct hts221_hw *hw = iio_priv(iio_dev);
> +
> +	struct spi_transfer xfers = {
> +		.tx_buf = hw->tb.tx_buf,
> +		.bits_per_word = 8,
> +		.len = len + 1,
> +	};
> +
> +	if (len >= HTS221_TX_MAX_LENGTH)
> +		return -ENOMEM;
> +
> +	if (len > 1)
> +		addr |= SPI_AUTO_INCREMENT;
> +	hw->tb.tx_buf[0] = addr;
> +	memcpy(&hw->tb.tx_buf[1], data, len);
> +
> +	return spi_sync_transfer(spi, &xfers, 1);
> +}
> +
> +static const struct hts221_transfer_function hts221_transfer_fn = {
> +	.read = hts221_spi_read,
> +	.write = hts221_spi_write,
> +};
> +
> +static int hts221_spi_probe(struct spi_device *spi)
> +{
> +	struct hts221_hw *hw;
> +	struct iio_dev *iio_dev;
> +
> +	iio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*hw));
> +	if (!iio_dev)
> +		return -ENOMEM;
> +
> +	spi_set_drvdata(spi, iio_dev);
> +
> +	hw = iio_priv(iio_dev);
> +	hw->name = spi->modalias;
> +	hw->dev = &spi->dev;
> +	hw->irq = spi->irq;
> +	hw->tf = &hts221_transfer_fn;
> +
> +	return hts221_probe(iio_dev);
> +}
> +
> +static const struct of_device_id hts221_spi_of_match[] = {
> +	{ .compatible = "st,hts221", },
> +	{},
> +};
> +MODULE_DEVICE_TABLE(of, hts221_spi_of_match);
> +
> +static const struct spi_device_id hts221_spi_id_table[] = {
> +	{ HTS221_DEV_NAME },
> +	{},
> +};
> +MODULE_DEVICE_TABLE(spi, hts221_spi_id_table);
> +
> +static struct spi_driver hts221_driver = {
> +	.driver = {
> +		.name = "hts221_spi",
> +		.of_match_table = of_match_ptr(hts221_spi_of_match),
> +	},
> +	.probe = hts221_spi_probe,
> +	.id_table = hts221_spi_id_table,
> +};
> +module_spi_driver(hts221_driver);
> +
> +MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi@st.com>");
> +MODULE_DESCRIPTION("STMicroelectronics hts221 spi driver");
> +MODULE_LICENSE("GPL v2");
> 


^ permalink raw reply	[flat|nested] 13+ messages in thread

* Re: [PATCH v4 2/2] Documentation: dt: iio: humidity: add hts221 sensor device binding
  2016-10-18 14:00         ` Rob Herring
@ 2016-10-22 14:37           ` Jonathan Cameron
  -1 siblings, 0 replies; 13+ messages in thread
From: Jonathan Cameron @ 2016-10-22 14:37 UTC (permalink / raw)
  To: Rob Herring, Lorenzo Bianconi
  Cc: linux-iio-u79uwXL29TY76Z2rM5mHXA,
	devicetree-u79uwXL29TY76Z2rM5mHXA, lorenzo.bianconi-qxv4g6HH51o

On 18/10/16 15:00, Rob Herring wrote:
> On Thu, Oct 13, 2016 at 10:06:05PM +0200, Lorenzo Bianconi wrote:
>> Signed-off-by: Lorenzo Bianconi <lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>
>> ---
>>  .../devicetree/bindings/iio/humidity/hts221.txt    | 22 ++++++++++++++++++++++
>>  1 file changed, 22 insertions(+)
>>  create mode 100644 Documentation/devicetree/bindings/iio/humidity/hts221.txt
> 
> Acked-by: Rob Herring <robh-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org>
> 
Applied. Thanks.
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

^ permalink raw reply	[flat|nested] 13+ messages in thread

* Re: [PATCH v4 2/2] Documentation: dt: iio: humidity: add hts221 sensor device binding
@ 2016-10-22 14:37           ` Jonathan Cameron
  0 siblings, 0 replies; 13+ messages in thread
From: Jonathan Cameron @ 2016-10-22 14:37 UTC (permalink / raw)
  To: Rob Herring, Lorenzo Bianconi; +Cc: linux-iio, devicetree, lorenzo.bianconi

On 18/10/16 15:00, Rob Herring wrote:
> On Thu, Oct 13, 2016 at 10:06:05PM +0200, Lorenzo Bianconi wrote:
>> Signed-off-by: Lorenzo Bianconi <lorenzo.bianconi@st.com>
>> ---
>>  .../devicetree/bindings/iio/humidity/hts221.txt    | 22 ++++++++++++++++++++++
>>  1 file changed, 22 insertions(+)
>>  create mode 100644 Documentation/devicetree/bindings/iio/humidity/hts221.txt
> 
> Acked-by: Rob Herring <robh@kernel.org>
> 
Applied. Thanks.

^ permalink raw reply	[flat|nested] 13+ messages in thread

* Re: [PATCH v4 1/2] iio: humidity: add support to hts221 rh/temp combo device
  2016-10-22 14:35         ` Jonathan Cameron
  (?)
@ 2016-10-22 16:03         ` Lorenzo Bianconi
  -1 siblings, 0 replies; 13+ messages in thread
From: Lorenzo Bianconi @ 2016-10-22 16:03 UTC (permalink / raw)
  To: Jonathan Cameron; +Cc: linux-iio, Lorenzo BIANCONI

> On 13/10/16 21:06, Lorenzo Bianconi wrote:
>> Add support to STM HTS221 humidity + temperature sensor
>>
>> http://www.st.com/resource/en/datasheet/hts221.pdf
>>
>> - continuous mode support
>> - i2c support
>> - spi support
>> - trigger mode support
>>
>> Signed-off-by: Lorenzo Bianconi <lorenzo.bianconi@st.com>
> Couple of really really trivial things inline. I've fixed up.
>
> Applied to the togreg branch of iio.git and pushed out as testing
> for the autobuilders to play with it.  This certainly ended up
> much simpler than it started after you chased down how the hardware
> was actually working!
>
> Thanks,
>
> Jonathan
>
> p.s. Just discovered I didn't send this last weekend when I actually applied the patch!
> Sorry about that.

No worries ;)

>> ---
>>  drivers/iio/humidity/Kconfig         |  22 ++
>>  drivers/iio/humidity/Makefile        |   7 +
>>  drivers/iio/humidity/hts221.h        |  73 ++++
>>  drivers/iio/humidity/hts221_buffer.c | 168 +++++++++
>>  drivers/iio/humidity/hts221_core.c   | 687 +++++++++++++++++++++++++++++++++++
>>  drivers/iio/humidity/hts221_i2c.c    | 110 ++++++
>>  drivers/iio/humidity/hts221_spi.c    | 125 +++++++
>>  7 files changed, 1192 insertions(+)
>>  create mode 100644 drivers/iio/humidity/hts221.h
>>  create mode 100644 drivers/iio/humidity/hts221_buffer.c
>>  create mode 100644 drivers/iio/humidity/hts221_core.c
>>  create mode 100644 drivers/iio/humidity/hts221_i2c.c
>>  create mode 100644 drivers/iio/humidity/hts221_spi.c
>>
>> diff --git a/drivers/iio/humidity/Kconfig b/drivers/iio/humidity/Kconfig
>> index b17e2e2..6fd11d0 100644
>> --- a/drivers/iio/humidity/Kconfig
>> +++ b/drivers/iio/humidity/Kconfig
>> @@ -34,6 +34,28 @@ config HDC100X
>>         To compile this driver as a module, choose M here: the module
>>         will be called hdc100x.
>>
>> +config HTS221
>> +     tristate "STMicroelectronics HTS221 sensor Driver"
>> +     depends on (I2C || SPI)
>> +     select IIO_BUFFER
>> +     select IIO_TRIGGERED_BUFFER
>> +     select HTS221_I2C if (I2C)
>> +     select HTS221_SPI if (SPI_MASTER)
>> +     help
>> +       Say yes here to build support for STMicroelectronics HTS221
>> +       temperature-humidity sensor
>> +
>> +       To compile this driver as a module, choose M here: the module
>> +       will be called hts221.
>> +
>> +config HTS221_I2C
>> +     tristate
>> +     depends on HTS221
>> +
>> +config HTS221_SPI
>> +     tristate
>> +     depends on HTS221
>> +
>>  config HTU21
>>       tristate "Measurement Specialties HTU21 humidity & temperature sensor"
>>       depends on I2C
>> diff --git a/drivers/iio/humidity/Makefile b/drivers/iio/humidity/Makefile
>> index 4a73442..a6850e4 100644
>> --- a/drivers/iio/humidity/Makefile
>> +++ b/drivers/iio/humidity/Makefile
>> @@ -5,6 +5,13 @@
>>  obj-$(CONFIG_AM2315) += am2315.o
>>  obj-$(CONFIG_DHT11) += dht11.o
>>  obj-$(CONFIG_HDC100X) += hdc100x.o
>> +
>> +hts221-y := hts221_core.o \
>> +         hts221_buffer.o
>> +obj-$(CONFIG_HTS221) += hts221.o
>> +obj-$(CONFIG_HTS221_I2C) += hts221_i2c.o
>> +obj-$(CONFIG_HTS221_SPI) += hts221_spi.o
>> +
>>  obj-$(CONFIG_HTU21) += htu21.o
>>  obj-$(CONFIG_SI7005) += si7005.o
>>  obj-$(CONFIG_SI7020) += si7020.o
>> diff --git a/drivers/iio/humidity/hts221.h b/drivers/iio/humidity/hts221.h
>> new file mode 100644
>> index 0000000..0d2993c
>> --- /dev/null
>> +++ b/drivers/iio/humidity/hts221.h
>> @@ -0,0 +1,73 @@
>> +/*
>> + * STMicroelectronics hts221 sensor driver
>> + *
>> + * Copyright 2016 STMicroelectronics Inc.
>> + *
>> + * Lorenzo Bianconi <lorenzo.bianconi@st.com>
>> + *
>> + * Licensed under the GPL-2.
>> + */
>> +
>> +#ifndef HTS221_H
>> +#define HTS221_H
>> +
>> +#define HTS221_DEV_NAME              "hts221"
>> +
>> +#include <linux/iio/iio.h>
>> +
>> +#define HTS221_RX_MAX_LENGTH 8
>> +#define HTS221_TX_MAX_LENGTH 8
>> +
>> +#define HTS221_DATA_SIZE     2
>> +
>> +struct hts221_transfer_buffer {
>> +     u8 rx_buf[HTS221_RX_MAX_LENGTH];
>> +     u8 tx_buf[HTS221_TX_MAX_LENGTH] ____cacheline_aligned;
>> +};
>> +
>> +struct hts221_transfer_function {
>> +     int (*read)(struct device *dev, u8 addr, int len, u8 *data);
>> +     int (*write)(struct device *dev, u8 addr, int len, u8 *data);
>> +};
>> +
>> +#define HTS221_AVG_DEPTH     8
>> +struct hts221_avg_avl {
>> +     u16 avg;
>> +     u8 val;
>> +};
>> +
>> +enum hts221_sensor_type {
>> +     HTS221_SENSOR_H,
>> +     HTS221_SENSOR_T,
>> +     HTS221_SENSOR_MAX,
>> +};
>> +
>> +struct hts221_sensor {
>> +     u8 cur_avg_idx;
>> +     int slope, b_gen;
>> +};
>> +
>> +struct hts221_hw {
>> +     const char *name;
>> +     struct device *dev;
>> +
>> +     struct mutex lock;
>> +     struct iio_trigger *trig;
>> +     int irq;
>> +
>> +     struct hts221_sensor sensors[HTS221_SENSOR_MAX];
>> +
>> +     u8 odr;
>> +
>> +     const struct hts221_transfer_function *tf;
>> +     struct hts221_transfer_buffer tb;
>> +};
>> +
>> +int hts221_config_drdy(struct hts221_hw *hw, bool enable);
>> +int hts221_probe(struct iio_dev *iio_dev);
>> +int hts221_power_on(struct hts221_hw *hw);
>> +int hts221_power_off(struct hts221_hw *hw);
>> +int hts221_allocate_buffers(struct hts221_hw *hw);
>> +int hts221_allocate_triggers(struct hts221_hw *hw);
>> +
>> +#endif /* HTS221_H */
>> diff --git a/drivers/iio/humidity/hts221_buffer.c b/drivers/iio/humidity/hts221_buffer.c
>> new file mode 100644
>> index 0000000..6b174fd
>> --- /dev/null
>> +++ b/drivers/iio/humidity/hts221_buffer.c
>> @@ -0,0 +1,168 @@
>> +/*
>> + * STMicroelectronics hts221 sensor driver
>> + *
>> + * Copyright 2016 STMicroelectronics Inc.
>> + *
>> + * Lorenzo Bianconi <lorenzo.bianconi@st.com>
>> + *
>> + * Licensed under the GPL-2.
>> + */
>> +#include <linux/kernel.h>
>> +#include <linux/module.h>
>> +#include <linux/device.h>
>> +#include <linux/interrupt.h>
>> +#include <linux/irqreturn.h>
>> +
>> +#include <linux/iio/iio.h>
>> +#include <linux/iio/trigger.h>
>> +#include <linux/interrupt.h>
>> +#include <linux/iio/events.h>
>> +#include <linux/iio/trigger_consumer.h>
>> +#include <linux/iio/triggered_buffer.h>
>> +#include <linux/iio/buffer.h>
>> +
>> +#include "hts221.h"
>> +
>> +#define HTS221_REG_STATUS_ADDR               0x27
>> +#define HTS221_RH_DRDY_MASK          BIT(1)
>> +#define HTS221_TEMP_DRDY_MASK                BIT(0)
>> +
>> +static int hts221_trig_set_state(struct iio_trigger *trig, bool state)
>> +{
>> +     struct iio_dev *iio_dev = iio_trigger_get_drvdata(trig);
>> +     struct hts221_hw *hw = iio_priv(iio_dev);
>> +
>> +     return hts221_config_drdy(hw, state);
>> +}
>> +
>> +static const struct iio_trigger_ops hts221_trigger_ops = {
>> +     .owner = THIS_MODULE,
>> +     .set_trigger_state = hts221_trig_set_state,
>> +};
>> +
>> +static irqreturn_t hts221_trigger_handler_thread(int irq, void *private)
>> +{
>> +     struct hts221_hw *hw = (struct hts221_hw *)private;
>> +     u8 status;
>> +     int err;
>> +
>> +     err = hw->tf->read(hw->dev, HTS221_REG_STATUS_ADDR, sizeof(status),
>> +                        &status);
>> +     if (err < 0)
>> +             return IRQ_HANDLED;
>> +
> Not kernel style multi line comment. I'll fix it up if I take this version.

Yes, sorry. I am used to net style.

>> +     /* H_DA bit (humidity data available) is routed to DRDY line.
>> +      * Humidity sample is computed after temperature one.
>> +      * Here we can assume data channels are both available if H_DA bit
>> +      * is set in status register
>> +      */
>> +     if (!(status & HTS221_RH_DRDY_MASK))
>> +             return IRQ_NONE;
>> +
>> +     iio_trigger_poll_chained(hw->trig);
>> +
>> +     return IRQ_HANDLED;
>> +}
>> +
>> +int hts221_allocate_triggers(struct hts221_hw *hw)
> Nitpick of the day - there is now only one ;)

Leftover of v1 :)

>> +{
>> +     struct iio_dev *iio_dev = iio_priv_to_dev(hw);
>> +     unsigned long irq_type;
>> +     int err;
>> +
>> +     irq_type = irqd_get_trigger_type(irq_get_irq_data(hw->irq));
>> +
>> +     switch (irq_type) {
>> +     case IRQF_TRIGGER_HIGH:
>> +     case IRQF_TRIGGER_RISING:
>> +             break;
>> +     default:
>> +             dev_info(hw->dev,
>> +                      "mode %lx unsupported, using IRQF_TRIGGER_RISING\n",
>> +                      irq_type);
>> +             irq_type = IRQF_TRIGGER_RISING;
>> +             break;
>> +     }
>> +
>> +     err = devm_request_threaded_irq(hw->dev, hw->irq, NULL,
>> +                                     hts221_trigger_handler_thread,
>> +                                     irq_type | IRQF_ONESHOT,
>> +                                     hw->name, hw);
>> +     if (err) {
>> +             dev_err(hw->dev, "failed to request trigger irq %d\n",
>> +                     hw->irq);
>> +             return err;
>> +     }
>> +
>> +     hw->trig = devm_iio_trigger_alloc(hw->dev, "%s-trigger",
>> +                                       iio_dev->name);
>> +     if (!hw->trig)
>> +             return -ENOMEM;
>> +
>> +     iio_trigger_set_drvdata(hw->trig, iio_dev);
>> +     hw->trig->ops = &hts221_trigger_ops;
>> +     hw->trig->dev.parent = hw->dev;
>> +     iio_dev->trig = iio_trigger_get(hw->trig);
>> +
>> +     return devm_iio_trigger_register(hw->dev, hw->trig);
>> +}
>> +
>> +static int hts221_buffer_preenable(struct iio_dev *iio_dev)
>> +{
>> +     return hts221_power_on(iio_priv(iio_dev));
>> +}
>> +
>> +static int hts221_buffer_postdisable(struct iio_dev *iio_dev)
>> +{
>> +     return hts221_power_off(iio_priv(iio_dev));
>> +}
>> +
>> +static const struct iio_buffer_setup_ops hts221_buffer_ops = {
>> +     .preenable = hts221_buffer_preenable,
>> +     .postenable = iio_triggered_buffer_postenable,
>> +     .predisable = iio_triggered_buffer_predisable,
>> +     .postdisable = hts221_buffer_postdisable,
>> +};
>> +
>> +static irqreturn_t hts221_buffer_handler_thread(int irq, void *p)
>> +{
>> +     u8 buffer[ALIGN(2 * HTS221_DATA_SIZE, sizeof(s64)) + sizeof(s64)];
>> +     struct iio_poll_func *pf = p;
>> +     struct iio_dev *iio_dev = pf->indio_dev;
>> +     struct hts221_hw *hw = iio_priv(iio_dev);
>> +     struct iio_chan_spec const *ch;
>> +     int err;
>> +
>> +     /* humidity data */
>> +     ch = &iio_dev->channels[HTS221_SENSOR_H];
>> +     err = hw->tf->read(hw->dev, ch->address, HTS221_DATA_SIZE,
>> +                        buffer);
>> +     if (err < 0)
>> +             goto out;
>> +
>> +     /* temperature data */
>> +     ch = &iio_dev->channels[HTS221_SENSOR_T];
>> +     err = hw->tf->read(hw->dev, ch->address, HTS221_DATA_SIZE,
>> +                        buffer + HTS221_DATA_SIZE);
>> +     if (err < 0)
>> +             goto out;
>> +
>> +     iio_push_to_buffers_with_timestamp(iio_dev, buffer,
>> +                                        iio_get_time_ns(iio_dev));
>> +
>> +out:
>> +     iio_trigger_notify_done(hw->trig);
>> +
>> +     return IRQ_HANDLED;
>> +}
>> +
>> +int hts221_allocate_buffers(struct hts221_hw *hw)
>> +{
>> +     return devm_iio_triggered_buffer_setup(hw->dev, iio_priv_to_dev(hw),
>> +                                     NULL, hts221_buffer_handler_thread,
>> +                                     &hts221_buffer_ops);
>> +}
>> +
>> +MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi@st.com>");
>> +MODULE_DESCRIPTION("STMicroelectronics hts221 buffer driver");
>> +MODULE_LICENSE("GPL v2");
>> diff --git a/drivers/iio/humidity/hts221_core.c b/drivers/iio/humidity/hts221_core.c
>> new file mode 100644
>> index 0000000..5a099dd
>> --- /dev/null
>> +++ b/drivers/iio/humidity/hts221_core.c
>> @@ -0,0 +1,687 @@
>> +/*
>> + * STMicroelectronics hts221 sensor driver
>> + *
>> + * Copyright 2016 STMicroelectronics Inc.
>> + *
>> + * Lorenzo Bianconi <lorenzo.bianconi@st.com>
>> + *
>> + * Licensed under the GPL-2.
>> + */
>> +
>> +#include <linux/kernel.h>
>> +#include <linux/module.h>
>> +#include <linux/device.h>
>> +#include <linux/iio/sysfs.h>
>> +#include <linux/delay.h>
>> +#include <asm/unaligned.h>
>> +
>> +#include "hts221.h"
>> +
>> +#define HTS221_REG_WHOAMI_ADDR               0x0f
>> +#define HTS221_REG_WHOAMI_VAL                0xbc
>> +
>> +#define HTS221_REG_CNTRL1_ADDR               0x20
>> +#define HTS221_REG_CNTRL2_ADDR               0x21
>> +#define HTS221_REG_CNTRL3_ADDR               0x22
>> +
>> +#define HTS221_REG_AVG_ADDR          0x10
>> +#define HTS221_REG_H_OUT_L           0x28
>> +#define HTS221_REG_T_OUT_L           0x2a
>> +
>> +#define HTS221_HUMIDITY_AVG_MASK     0x07
>> +#define HTS221_TEMP_AVG_MASK         0x38
>> +
>> +#define HTS221_ODR_MASK                      0x87
>> +#define HTS221_BDU_MASK                      BIT(2)
>> +
>> +#define HTS221_DRDY_MASK             BIT(2)
>> +
>> +#define HTS221_ENABLE_SENSOR         BIT(7)
>> +
>> +#define HTS221_HUMIDITY_AVG_4                0x00 /* 0.4 %RH */
>> +#define HTS221_HUMIDITY_AVG_8                0x01 /* 0.3 %RH */
>> +#define HTS221_HUMIDITY_AVG_16               0x02 /* 0.2 %RH */
>> +#define HTS221_HUMIDITY_AVG_32               0x03 /* 0.15 %RH */
>> +#define HTS221_HUMIDITY_AVG_64               0x04 /* 0.1 %RH */
>> +#define HTS221_HUMIDITY_AVG_128              0x05 /* 0.07 %RH */
>> +#define HTS221_HUMIDITY_AVG_256              0x06 /* 0.05 %RH */
>> +#define HTS221_HUMIDITY_AVG_512              0x07 /* 0.03 %RH */
>> +
>> +#define HTS221_TEMP_AVG_2            0x00 /* 0.08 degC */
>> +#define HTS221_TEMP_AVG_4            0x08 /* 0.05 degC */
>> +#define HTS221_TEMP_AVG_8            0x10 /* 0.04 degC */
>> +#define HTS221_TEMP_AVG_16           0x18 /* 0.03 degC */
>> +#define HTS221_TEMP_AVG_32           0x20 /* 0.02 degC */
>> +#define HTS221_TEMP_AVG_64           0x28 /* 0.015 degC */
>> +#define HTS221_TEMP_AVG_128          0x30 /* 0.01 degC */
>> +#define HTS221_TEMP_AVG_256          0x38 /* 0.007 degC */
>> +
>> +/* calibration registers */
>> +#define HTS221_REG_0RH_CAL_X_H               0x36
>> +#define HTS221_REG_1RH_CAL_X_H               0x3a
>> +#define HTS221_REG_0RH_CAL_Y_H               0x30
>> +#define HTS221_REG_1RH_CAL_Y_H               0x31
>> +#define HTS221_REG_0T_CAL_X_L                0x3c
>> +#define HTS221_REG_1T_CAL_X_L                0x3e
>> +#define HTS221_REG_0T_CAL_Y_H                0x32
>> +#define HTS221_REG_1T_CAL_Y_H                0x33
>> +#define HTS221_REG_T1_T0_CAL_Y_H     0x35
>> +
>> +struct hts221_odr {
>> +     u8 hz;
>> +     u8 val;
>> +};
>> +
>> +struct hts221_avg {
>> +     u8 addr;
>> +     u8 mask;
>> +     struct hts221_avg_avl avg_avl[HTS221_AVG_DEPTH];
>> +};
>> +
>> +static const struct hts221_odr hts221_odr_table[] = {
>> +     {  1, 0x01 },   /* 1Hz */
>> +     {  7, 0x02 },   /* 7Hz */
>> +     { 13, 0x03 },   /* 12.5Hz */
>> +};
>> +
>> +static const struct hts221_avg hts221_avg_list[] = {
>> +     {
>> +             .addr = HTS221_REG_AVG_ADDR,
>> +             .mask = HTS221_HUMIDITY_AVG_MASK,
>> +             .avg_avl = {
>> +                     { 4, HTS221_HUMIDITY_AVG_4 },
>> +                     { 8, HTS221_HUMIDITY_AVG_8 },
>> +                     { 16, HTS221_HUMIDITY_AVG_16 },
>> +                     { 32, HTS221_HUMIDITY_AVG_32 },
>> +                     { 64, HTS221_HUMIDITY_AVG_64 },
>> +                     { 128, HTS221_HUMIDITY_AVG_128 },
>> +                     { 256, HTS221_HUMIDITY_AVG_256 },
>> +                     { 512, HTS221_HUMIDITY_AVG_512 },
>> +             },
>> +     },
>> +     {
>> +             .addr = HTS221_REG_AVG_ADDR,
>> +             .mask = HTS221_TEMP_AVG_MASK,
>> +             .avg_avl = {
>> +                     { 2, HTS221_TEMP_AVG_2 },
>> +                     { 4, HTS221_TEMP_AVG_4 },
>> +                     { 8, HTS221_TEMP_AVG_8 },
>> +                     { 16, HTS221_TEMP_AVG_16 },
>> +                     { 32, HTS221_TEMP_AVG_32 },
>> +                     { 64, HTS221_TEMP_AVG_64 },
>> +                     { 128, HTS221_TEMP_AVG_128 },
>> +                     { 256, HTS221_TEMP_AVG_256 },
>> +             },
>> +     },
>> +};
>> +
>> +static const struct iio_chan_spec hts221_channels[] = {
>> +     {
>> +             .type = IIO_HUMIDITYRELATIVE,
>> +             .address = HTS221_REG_H_OUT_L,
>> +             .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
>> +                                   BIT(IIO_CHAN_INFO_OFFSET) |
>> +                                   BIT(IIO_CHAN_INFO_SCALE) |
>> +                                   BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
>> +             .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
>> +             .scan_index = 0,
>> +             .scan_type = {
>> +                     .sign = 's',
>> +                     .realbits = 16,
>> +                     .storagebits = 16,
>> +                     .endianness = IIO_LE,
>> +             },
>> +     },
>> +     {
>> +             .type = IIO_TEMP,
>> +             .address = HTS221_REG_T_OUT_L,
>> +             .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
>> +                                   BIT(IIO_CHAN_INFO_OFFSET) |
>> +                                   BIT(IIO_CHAN_INFO_SCALE) |
>> +                                   BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
>> +             .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),
>> +             .scan_index = 1,
>> +             .scan_type = {
>> +                     .sign = 's',
>> +                     .realbits = 16,
>> +                     .storagebits = 16,
>> +                     .endianness = IIO_LE,
>> +             },
>> +     },
>> +     IIO_CHAN_SOFT_TIMESTAMP(2),
>> +};
>> +
>> +static int hts221_write_with_mask(struct hts221_hw *hw, u8 addr, u8 mask,
>> +                               u8 val)
>> +{
>> +     u8 data;
>> +     int err;
>> +
>> +     mutex_lock(&hw->lock);
>> +
>> +     err = hw->tf->read(hw->dev, addr, sizeof(data), &data);
>> +     if (err < 0) {
>> +             dev_err(hw->dev, "failed to read %02x register\n", addr);
>> +             goto unlock;
>> +     }
>> +
>> +     data = (data & ~mask) | (val & mask);
>> +
>> +     err = hw->tf->write(hw->dev, addr, sizeof(data), &data);
>> +     if (err < 0)
>> +             dev_err(hw->dev, "failed to write %02x register\n", addr);
>> +
>> +unlock:
>> +     mutex_unlock(&hw->lock);
>> +
>> +     return err;
>> +}
>> +
>> +static int hts221_check_whoami(struct hts221_hw *hw)
>> +{
>> +     u8 data;
>> +     int err;
>> +
>> +     err = hw->tf->read(hw->dev, HTS221_REG_WHOAMI_ADDR, sizeof(data),
>> +                        &data);
>> +     if (err < 0) {
>> +             dev_err(hw->dev, "failed to read whoami register\n");
>> +             return err;
>> +     }
>> +
>> +     if (data != HTS221_REG_WHOAMI_VAL) {
>> +             dev_err(hw->dev, "wrong whoami {%02x vs %02x}\n",
>> +                     data, HTS221_REG_WHOAMI_VAL);
>> +             return -ENODEV;
>> +     }
>> +
>> +     return 0;
>> +}
>> +
>> +int hts221_config_drdy(struct hts221_hw *hw, bool enable)
>> +{
>> +     u8 val = enable ? BIT(2) : 0;
>> +     int err;
>> +
>> +     err = hts221_write_with_mask(hw, HTS221_REG_CNTRL3_ADDR,
>> +                                  HTS221_DRDY_MASK, val);
>> +
>> +     return err < 0 ? err : 0;
>> +}
>> +
>> +static int hts221_update_odr(struct hts221_hw *hw, u8 odr)
>> +{
>> +     int i, err;
>> +     u8 val;
>> +
>> +     for (i = 0; i < ARRAY_SIZE(hts221_odr_table); i++)
>> +             if (hts221_odr_table[i].hz == odr)
>> +                     break;
>> +
>> +     if (i == ARRAY_SIZE(hts221_odr_table))
>> +             return -EINVAL;
>> +
>> +     val = HTS221_ENABLE_SENSOR | HTS221_BDU_MASK | hts221_odr_table[i].val;
>> +     err = hts221_write_with_mask(hw, HTS221_REG_CNTRL1_ADDR,
>> +                                  HTS221_ODR_MASK, val);
>> +     if (err < 0)
>> +             return err;
>> +
>> +     hw->odr = odr;
>> +
>> +     return 0;
>> +}
>> +
>> +static int hts221_update_avg(struct hts221_hw *hw,
>> +                          enum hts221_sensor_type type,
>> +                          u16 val)
>> +{
>> +     int i, err;
>> +     const struct hts221_avg *avg = &hts221_avg_list[type];
>> +
>> +     for (i = 0; i < HTS221_AVG_DEPTH; i++)
>> +             if (avg->avg_avl[i].avg == val)
>> +                     break;
>> +
>> +     if (i == HTS221_AVG_DEPTH)
>> +             return -EINVAL;
>> +
>> +     err = hts221_write_with_mask(hw, avg->addr, avg->mask,
>> +                                  avg->avg_avl[i].val);
>> +     if (err < 0)
>> +             return err;
>> +
>> +     hw->sensors[type].cur_avg_idx = i;
>> +
>> +     return 0;
>> +}
>> +
>> +static ssize_t hts221_sysfs_sampling_freq(struct device *dev,
>> +                                       struct device_attribute *attr,
>> +                                       char *buf)
>> +{
>> +     int i;
>> +     ssize_t len = 0;
>> +
>> +     for (i = 0; i < ARRAY_SIZE(hts221_odr_table); i++)
>> +             len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
>> +                              hts221_odr_table[i].hz);
>> +     buf[len - 1] = '\n';
>> +
>> +     return len;
>> +}
>> +
>> +static ssize_t
>> +hts221_sysfs_rh_oversampling_avail(struct device *dev,
>> +                                struct device_attribute *attr,
>> +                                char *buf)
>> +{
>> +     const struct hts221_avg *avg = &hts221_avg_list[HTS221_SENSOR_H];
>> +     ssize_t len = 0;
>> +     int i;
>> +
>> +     for (i = 0; i < ARRAY_SIZE(avg->avg_avl); i++)
>> +             len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
>> +                              avg->avg_avl[i].avg);
>> +     buf[len - 1] = '\n';
>> +
>> +     return len;
>> +}
>> +
>> +static ssize_t
>> +hts221_sysfs_temp_oversampling_avail(struct device *dev,
>> +                                  struct device_attribute *attr,
>> +                                  char *buf)
>> +{
>> +     const struct hts221_avg *avg = &hts221_avg_list[HTS221_SENSOR_T];
>> +     ssize_t len = 0;
>> +     int i;
>> +
>> +     for (i = 0; i < ARRAY_SIZE(avg->avg_avl); i++)
>> +             len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
>> +                              avg->avg_avl[i].avg);
>> +     buf[len - 1] = '\n';
>> +
>> +     return len;
>> +}
>> +
>> +int hts221_power_on(struct hts221_hw *hw)
>> +{
>> +     return hts221_update_odr(hw, hw->odr);
>> +}
>> +
>> +int hts221_power_off(struct hts221_hw *hw)
>> +{
>> +     u8 data[] = {0x00, 0x00};
>> +
>> +     return hw->tf->write(hw->dev, HTS221_REG_CNTRL1_ADDR, sizeof(data),
>> +                          data);
>> +}
>> +
>> +static int hts221_parse_temp_caldata(struct hts221_hw *hw)
>> +{
>> +     int err, *slope, *b_gen;
>> +     s16 cal_x0, cal_x1, cal_y0, cal_y1;
>> +     u8 cal0, cal1;
>> +
>> +     err = hw->tf->read(hw->dev, HTS221_REG_0T_CAL_Y_H,
>> +                        sizeof(cal0), &cal0);
>> +     if (err < 0)
>> +             return err;
>> +
>> +     err = hw->tf->read(hw->dev, HTS221_REG_T1_T0_CAL_Y_H,
>> +                        sizeof(cal1), &cal1);
>> +     if (err < 0)
>> +             return err;
>> +     cal_y0 = (le16_to_cpu(cal1 & 0x3) << 8) | cal0;
>> +
>> +     err = hw->tf->read(hw->dev, HTS221_REG_1T_CAL_Y_H,
>> +                        sizeof(cal0), &cal0);
>> +     if (err < 0)
>> +             return err;
>> +     cal_y1 = (((cal1 & 0xc) >> 2) << 8) | cal0;
>> +
>> +     err = hw->tf->read(hw->dev, HTS221_REG_0T_CAL_X_L, sizeof(cal_x0),
>> +                        (u8 *)&cal_x0);
>> +     if (err < 0)
>> +             return err;
>> +     cal_x0 = le16_to_cpu(cal_x0);
>> +
>> +     err = hw->tf->read(hw->dev, HTS221_REG_1T_CAL_X_L, sizeof(cal_x1),
>> +                        (u8 *)&cal_x1);
>> +     if (err < 0)
>> +             return err;
>> +     cal_x1 = le16_to_cpu(cal_x1);
>> +
>> +     slope = &hw->sensors[HTS221_SENSOR_T].slope;
>> +     b_gen = &hw->sensors[HTS221_SENSOR_T].b_gen;
>> +
>> +     *slope = ((cal_y1 - cal_y0) * 8000) / (cal_x1 - cal_x0);
>> +     *b_gen = (((s32)cal_x1 * cal_y0 - (s32)cal_x0 * cal_y1) * 1000) /
>> +              (cal_x1 - cal_x0);
>> +     *b_gen *= 8;
>> +
>> +     return 0;
>> +}
>> +
>> +static int hts221_parse_rh_caldata(struct hts221_hw *hw)
>> +{
>> +     int err, *slope, *b_gen;
>> +     s16 cal_x0, cal_x1, cal_y0, cal_y1;
>> +     u8 data;
>> +
>> +     err = hw->tf->read(hw->dev, HTS221_REG_0RH_CAL_Y_H, sizeof(data),
>> +                        &data);
>> +     if (err < 0)
>> +             return err;
>> +     cal_y0 = data;
>> +
>> +     err = hw->tf->read(hw->dev, HTS221_REG_1RH_CAL_Y_H, sizeof(data),
>> +                        &data);
>> +     if (err < 0)
>> +             return err;
>> +     cal_y1 = data;
>> +
>> +     err = hw->tf->read(hw->dev, HTS221_REG_0RH_CAL_X_H, sizeof(cal_x0),
>> +                        (u8 *)&cal_x0);
>> +     if (err < 0)
>> +             return err;
>> +     cal_x0 = le16_to_cpu(cal_x0);
>> +
>> +     err = hw->tf->read(hw->dev, HTS221_REG_1RH_CAL_X_H, sizeof(cal_x1),
>> +                        (u8 *)&cal_x1);
>> +     if (err < 0)
>> +             return err;
>> +     cal_x1 = le16_to_cpu(cal_x1);
>> +
>> +     slope = &hw->sensors[HTS221_SENSOR_H].slope;
>> +     b_gen = &hw->sensors[HTS221_SENSOR_H].b_gen;
>> +
>> +     *slope = ((cal_y1 - cal_y0) * 8000) / (cal_x1 - cal_x0);
>> +     *b_gen = (((s32)cal_x1 * cal_y0 - (s32)cal_x0 * cal_y1) * 1000) /
>> +              (cal_x1 - cal_x0);
>> +     *b_gen *= 8;
>> +
>> +     return 0;
>> +}
>> +
>> +static int hts221_get_sensor_scale(struct hts221_hw *hw,
>> +                                enum iio_chan_type ch_type,
>> +                                int *val, int *val2)
>> +{
>> +     s64 tmp;
>> +     s32 rem, div, data;
>> +
>> +     switch (ch_type) {
>> +     case IIO_HUMIDITYRELATIVE:
>> +             data = hw->sensors[HTS221_SENSOR_H].slope;
>> +             div = (1 << 4) * 1000;
>> +             break;
>> +     case IIO_TEMP:
>> +             data = hw->sensors[HTS221_SENSOR_T].slope;
>> +             div = (1 << 6) * 1000;
>> +             break;
>> +     default:
>> +             return -EINVAL;
>> +     }
>> +
>> +     tmp = div_s64(data * 1000000000LL, div);
>> +     tmp = div_s64_rem(tmp, 1000000000LL, &rem);
>> +
>> +     *val = tmp;
>> +     *val2 = rem;
>> +
>> +     return IIO_VAL_INT_PLUS_NANO;
>> +}
>> +
>> +static int hts221_get_sensor_offset(struct hts221_hw *hw,
>> +                                 enum iio_chan_type ch_type,
>> +                                 int *val, int *val2)
>> +{
>> +     s64 tmp;
>> +     s32 rem, div, data;
>> +
>> +     switch (ch_type) {
>> +     case IIO_HUMIDITYRELATIVE:
>> +             data = hw->sensors[HTS221_SENSOR_H].b_gen;
>> +             div = hw->sensors[HTS221_SENSOR_H].slope;
>> +             break;
>> +     case IIO_TEMP:
>> +             data = hw->sensors[HTS221_SENSOR_T].b_gen;
>> +             div = hw->sensors[HTS221_SENSOR_T].slope;
>> +             break;
>> +     default:
>> +             return -EINVAL;
>> +     }
>> +
>> +     tmp = div_s64(data * 1000000000LL, div);
>> +     tmp = div_s64_rem(tmp, 1000000000LL, &rem);
>> +
>> +     *val = tmp;
>> +     *val2 = rem;
>> +
>> +     return IIO_VAL_INT_PLUS_NANO;
>> +}
>> +
>> +static int hts221_read_oneshot(struct hts221_hw *hw, u8 addr, int *val)
>> +{
>> +     u8 data[HTS221_DATA_SIZE];
>> +     int err;
>> +
>> +     err = hts221_power_on(hw);
>> +     if (err < 0)
>> +             return err;
>> +
>> +     msleep(50);
>> +
>> +     err = hw->tf->read(hw->dev, addr, sizeof(data), data);
>> +     if (err < 0)
>> +             return err;
>> +
>> +     hts221_power_off(hw);
>> +
>> +     *val = (s16)get_unaligned_le16(data);
>> +
>> +     return IIO_VAL_INT;
>> +}
>> +
>> +static int hts221_read_raw(struct iio_dev *iio_dev,
>> +                        struct iio_chan_spec const *ch,
>> +                        int *val, int *val2, long mask)
>> +{
>> +     struct hts221_hw *hw = iio_priv(iio_dev);
>> +     int ret;
>> +
>> +     ret = iio_device_claim_direct_mode(iio_dev);
>> +     if (ret)
>> +             return ret;
>> +
>> +     switch (mask) {
>> +     case IIO_CHAN_INFO_RAW:
>> +             ret = hts221_read_oneshot(hw, ch->address, val);
>> +             break;
>> +     case IIO_CHAN_INFO_SCALE:
>> +             ret = hts221_get_sensor_scale(hw, ch->type, val, val2);
>> +             break;
>> +     case IIO_CHAN_INFO_OFFSET:
>> +             ret = hts221_get_sensor_offset(hw, ch->type, val, val2);
>> +             break;
>> +     case IIO_CHAN_INFO_SAMP_FREQ:
>> +             *val = hw->odr;
>> +             ret = IIO_VAL_INT;
>> +             break;
>> +     case IIO_CHAN_INFO_OVERSAMPLING_RATIO: {
>> +             u8 idx;
>> +             const struct hts221_avg *avg;
>> +
>> +             switch (ch->type) {
>> +             case IIO_HUMIDITYRELATIVE:
>> +                     avg = &hts221_avg_list[HTS221_SENSOR_H];
>> +                     idx = hw->sensors[HTS221_SENSOR_H].cur_avg_idx;
>> +                     *val = avg->avg_avl[idx].avg;
>> +                     ret = IIO_VAL_INT;
>> +                     break;
>> +             case IIO_TEMP:
>> +                     avg = &hts221_avg_list[HTS221_SENSOR_T];
>> +                     idx = hw->sensors[HTS221_SENSOR_T].cur_avg_idx;
>> +                     *val = avg->avg_avl[idx].avg;
>> +                     ret = IIO_VAL_INT;
>> +                     break;
>> +             default:
>> +                     ret = -EINVAL;
>> +                     break;
>> +             }
>> +             break;
>> +     }
>> +     default:
>> +             ret = -EINVAL;
>> +             break;
>> +     }
>> +
>> +     iio_device_release_direct_mode(iio_dev);
>> +
>> +     return ret;
>> +}
>> +
>> +static int hts221_write_raw(struct iio_dev *iio_dev,
>> +                         struct iio_chan_spec const *chan,
>> +                         int val, int val2, long mask)
>> +{
>> +     struct hts221_hw *hw = iio_priv(iio_dev);
>> +     int ret;
>> +
>> +     ret = iio_device_claim_direct_mode(iio_dev);
>> +     if (ret)
>> +             return ret;
>> +
>> +     switch (mask) {
>> +     case IIO_CHAN_INFO_SAMP_FREQ:
>> +             ret = hts221_update_odr(hw, val);
>> +             break;
>> +     case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
>> +             switch (chan->type) {
>> +             case IIO_HUMIDITYRELATIVE:
>> +                     ret = hts221_update_avg(hw, HTS221_SENSOR_H, val);
>> +                     break;
>> +             case IIO_TEMP:
>> +                     ret = hts221_update_avg(hw, HTS221_SENSOR_T, val);
>> +                     break;
>> +             default:
>> +                     ret = -EINVAL;
>> +                     break;
>> +             }
>> +             break;
>> +     default:
>> +             ret = -EINVAL;
>> +             break;
>> +     }
>> +
>> +     iio_device_release_direct_mode(iio_dev);
>> +
>> +     return ret;
>> +}
>> +
>> +static int hts221_validate_trigger(struct iio_dev *iio_dev,
>> +                                struct iio_trigger *trig)
>> +{
>> +     struct hts221_hw *hw = iio_priv(iio_dev);
>> +
>> +     return hw->trig == trig ? 0 : -EINVAL;
>> +}
>> +
>> +static IIO_DEVICE_ATTR(in_humidity_oversampling_ratio_available, S_IRUGO,
>> +                    hts221_sysfs_rh_oversampling_avail, NULL, 0);
>> +static IIO_DEVICE_ATTR(in_temp_oversampling_ratio_available, S_IRUGO,
>> +                    hts221_sysfs_temp_oversampling_avail, NULL, 0);
>> +static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(hts221_sysfs_sampling_freq);
>> +
>> +static struct attribute *hts221_attributes[] = {
>> +     &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
>> +     &iio_dev_attr_in_humidity_oversampling_ratio_available.dev_attr.attr,
>> +     &iio_dev_attr_in_temp_oversampling_ratio_available.dev_attr.attr,
>> +     NULL,
>> +};
>> +
>> +static const struct attribute_group hts221_attribute_group = {
>> +     .attrs = hts221_attributes,
>> +};
>> +
>> +static const struct iio_info hts221_info = {
>> +     .driver_module = THIS_MODULE,
>> +     .attrs = &hts221_attribute_group,
>> +     .read_raw = hts221_read_raw,
>> +     .write_raw = hts221_write_raw,
>> +     .validate_trigger = hts221_validate_trigger,
>> +};
>> +
>> +static const unsigned long hts221_scan_masks[] = {0x3, 0x0};
>> +
>> +int hts221_probe(struct iio_dev *iio_dev)
>> +{
>> +     struct hts221_hw *hw = iio_priv(iio_dev);
>> +     int err;
>> +     u8 data;
>> +
>> +     mutex_init(&hw->lock);
>> +
>> +     err = hts221_check_whoami(hw);
>> +     if (err < 0)
>> +             return err;
>> +
>> +     hw->odr = hts221_odr_table[0].hz;
>> +
>> +     iio_dev->modes = INDIO_DIRECT_MODE;
>> +     iio_dev->dev.parent = hw->dev;
>> +     iio_dev->available_scan_masks = hts221_scan_masks;
>> +     iio_dev->channels = hts221_channels;
>> +     iio_dev->num_channels = ARRAY_SIZE(hts221_channels);
>> +     iio_dev->name = HTS221_DEV_NAME;
>> +     iio_dev->info = &hts221_info;
>> +
>> +     /* configure humidity sensor */
>> +     err = hts221_parse_rh_caldata(hw);
>> +     if (err < 0) {
>> +             dev_err(hw->dev, "failed to get rh calibration data\n");
>> +             return err;
>> +     }
>> +
>> +     data = hts221_avg_list[HTS221_SENSOR_H].avg_avl[3].avg;
>> +     err = hts221_update_avg(hw, HTS221_SENSOR_H, data);
>> +     if (err < 0) {
>> +             dev_err(hw->dev, "failed to set rh oversampling ratio\n");
>> +             return err;
>> +     }
>> +
>> +     /* configure temperature sensor */
>> +     err = hts221_parse_temp_caldata(hw);
>> +     if (err < 0) {
>> +             dev_err(hw->dev,
>> +                     "failed to get temperature calibration data\n");
>> +             return err;
>> +     }
>> +
>> +     data = hts221_avg_list[HTS221_SENSOR_T].avg_avl[3].avg;
>> +     err = hts221_update_avg(hw, HTS221_SENSOR_T, data);
>> +     if (err < 0) {
>> +             dev_err(hw->dev,
>> +                     "failed to set temperature oversampling ratio\n");
>> +             return err;
>> +     }
>> +
>> +     if (hw->irq > 0) {
>> +             err = hts221_allocate_buffers(hw);
>> +             if (err < 0)
>> +                     return err;
>> +
>> +             err = hts221_allocate_triggers(hw);
>> +             if (err)
>> +                     return err;
>> +     }
>> +
>> +     return devm_iio_device_register(hw->dev, iio_dev);
>> +}
>> +EXPORT_SYMBOL(hts221_probe);
>> +
>> +MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi@st.com>");
>> +MODULE_DESCRIPTION("STMicroelectronics hts221 sensor driver");
>> +MODULE_LICENSE("GPL v2");
>> diff --git a/drivers/iio/humidity/hts221_i2c.c b/drivers/iio/humidity/hts221_i2c.c
>> new file mode 100644
>> index 0000000..367ecd5
>> --- /dev/null
>> +++ b/drivers/iio/humidity/hts221_i2c.c
>> @@ -0,0 +1,110 @@
>> +/*
>> + * STMicroelectronics hts221 i2c driver
>> + *
>> + * Copyright 2016 STMicroelectronics Inc.
>> + *
>> + * Lorenzo Bianconi <lorenzo.bianconi@st.com>
>> + *
>> + * Licensed under the GPL-2.
>> + */
>> +
>> +#include <linux/kernel.h>
>> +#include <linux/module.h>
>> +#include <linux/i2c.h>
>> +#include <linux/slab.h>
>> +#include "hts221.h"
>> +
>> +#define I2C_AUTO_INCREMENT   0x80
>> +
>> +static int hts221_i2c_read(struct device *dev, u8 addr, int len, u8 *data)
>> +{
>> +     struct i2c_msg msg[2];
>> +     struct i2c_client *client = to_i2c_client(dev);
>> +
>> +     if (len > 1)
>> +             addr |= I2C_AUTO_INCREMENT;
>> +
>> +     msg[0].addr = client->addr;
>> +     msg[0].flags = client->flags;
>> +     msg[0].len = 1;
>> +     msg[0].buf = &addr;
>> +
>> +     msg[1].addr = client->addr;
>> +     msg[1].flags = client->flags | I2C_M_RD;
>> +     msg[1].len = len;
>> +     msg[1].buf = data;
>> +
>> +     return i2c_transfer(client->adapter, msg, 2);
>> +}
>> +
>> +static int hts221_i2c_write(struct device *dev, u8 addr, int len, u8 *data)
>> +{
>> +     u8 send[len + 1];
>> +     struct i2c_msg msg;
>> +     struct i2c_client *client = to_i2c_client(dev);
>> +
>> +     if (len > 1)
>> +             addr |= I2C_AUTO_INCREMENT;
>> +
>> +     send[0] = addr;
>> +     memcpy(&send[1], data, len * sizeof(u8));
>> +
>> +     msg.addr = client->addr;
>> +     msg.flags = client->flags;
>> +     msg.len = len + 1;
>> +     msg.buf = send;
>> +
>> +     return i2c_transfer(client->adapter, &msg, 1);
>> +}
>> +
>> +static const struct hts221_transfer_function hts221_transfer_fn = {
>> +     .read = hts221_i2c_read,
>> +     .write = hts221_i2c_write,
>> +};
>> +
>> +static int hts221_i2c_probe(struct i2c_client *client,
>> +                         const struct i2c_device_id *id)
>> +{
>> +     struct hts221_hw *hw;
>> +     struct iio_dev *iio_dev;
>> +
>> +     iio_dev = devm_iio_device_alloc(&client->dev, sizeof(*hw));
>> +     if (!iio_dev)
>> +             return -ENOMEM;
>> +
>> +     i2c_set_clientdata(client, iio_dev);
>> +
>> +     hw = iio_priv(iio_dev);
>> +     hw->name = client->name;
>> +     hw->dev = &client->dev;
>> +     hw->irq = client->irq;
>> +     hw->tf = &hts221_transfer_fn;
>> +
>> +     return hts221_probe(iio_dev);
>> +}
>> +
>> +static const struct of_device_id hts221_i2c_of_match[] = {
>> +     { .compatible = "st,hts221", },
>> +     {},
>> +};
>> +MODULE_DEVICE_TABLE(of, hts221_i2c_of_match);
>> +
>> +static const struct i2c_device_id hts221_i2c_id_table[] = {
>> +     { HTS221_DEV_NAME },
>> +     {},
>> +};
>> +MODULE_DEVICE_TABLE(i2c, hts221_i2c_id_table);
>> +
>> +static struct i2c_driver hts221_driver = {
>> +     .driver = {
>> +             .name = "hts221_i2c",
>> +             .of_match_table = of_match_ptr(hts221_i2c_of_match),
>> +     },
>> +     .probe = hts221_i2c_probe,
>> +     .id_table = hts221_i2c_id_table,
>> +};
>> +module_i2c_driver(hts221_driver);
>> +
>> +MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi@st.com>");
>> +MODULE_DESCRIPTION("STMicroelectronics hts221 i2c driver");
>> +MODULE_LICENSE("GPL v2");
>> diff --git a/drivers/iio/humidity/hts221_spi.c b/drivers/iio/humidity/hts221_spi.c
>> new file mode 100644
>> index 0000000..70df5e7
>> --- /dev/null
>> +++ b/drivers/iio/humidity/hts221_spi.c
>> @@ -0,0 +1,125 @@
>> +/*
>> + * STMicroelectronics hts221 spi driver
>> + *
>> + * Copyright 2016 STMicroelectronics Inc.
>> + *
>> + * Lorenzo Bianconi <lorenzo.bianconi@st.com>
>> + *
>> + * Licensed under the GPL-2.
>> + */
>> +
>> +#include <linux/kernel.h>
>> +#include <linux/module.h>
>> +#include <linux/spi/spi.h>
>> +#include <linux/slab.h>
>> +#include "hts221.h"
>> +
>> +#define SENSORS_SPI_READ     0x80
>> +#define SPI_AUTO_INCREMENT   0x40
>> +
>> +static int hts221_spi_read(struct device *dev, u8 addr, int len, u8 *data)
>> +{
>> +     int err;
>> +     struct spi_device *spi = to_spi_device(dev);
>> +     struct iio_dev *iio_dev = spi_get_drvdata(spi);
>> +     struct hts221_hw *hw = iio_priv(iio_dev);
>> +
>> +     struct spi_transfer xfers[] = {
>> +             {
>> +                     .tx_buf = hw->tb.tx_buf,
>> +                     .bits_per_word = 8,
>> +                     .len = 1,
>> +             },
>> +             {
>> +                     .rx_buf = hw->tb.rx_buf,
>> +                     .bits_per_word = 8,
>> +                     .len = len,
>> +             }
>> +     };
>> +
>> +     if (len > 1)
>> +             addr |= SPI_AUTO_INCREMENT;
>> +     hw->tb.tx_buf[0] = addr | SENSORS_SPI_READ;
>> +
>> +     err = spi_sync_transfer(spi, xfers,  ARRAY_SIZE(xfers));
>> +     if (err < 0)
>> +             return err;
>> +
>> +     memcpy(data, hw->tb.rx_buf, len * sizeof(u8));
>> +
>> +     return len;
>> +}
>> +
>> +static int hts221_spi_write(struct device *dev, u8 addr, int len, u8 *data)
>> +{
>> +     struct spi_device *spi = to_spi_device(dev);
>> +     struct iio_dev *iio_dev = spi_get_drvdata(spi);
>> +     struct hts221_hw *hw = iio_priv(iio_dev);
>> +
>> +     struct spi_transfer xfers = {
>> +             .tx_buf = hw->tb.tx_buf,
>> +             .bits_per_word = 8,
>> +             .len = len + 1,
>> +     };
>> +
>> +     if (len >= HTS221_TX_MAX_LENGTH)
>> +             return -ENOMEM;
>> +
>> +     if (len > 1)
>> +             addr |= SPI_AUTO_INCREMENT;
>> +     hw->tb.tx_buf[0] = addr;
>> +     memcpy(&hw->tb.tx_buf[1], data, len);
>> +
>> +     return spi_sync_transfer(spi, &xfers, 1);
>> +}
>> +
>> +static const struct hts221_transfer_function hts221_transfer_fn = {
>> +     .read = hts221_spi_read,
>> +     .write = hts221_spi_write,
>> +};
>> +
>> +static int hts221_spi_probe(struct spi_device *spi)
>> +{
>> +     struct hts221_hw *hw;
>> +     struct iio_dev *iio_dev;
>> +
>> +     iio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*hw));
>> +     if (!iio_dev)
>> +             return -ENOMEM;
>> +
>> +     spi_set_drvdata(spi, iio_dev);
>> +
>> +     hw = iio_priv(iio_dev);
>> +     hw->name = spi->modalias;
>> +     hw->dev = &spi->dev;
>> +     hw->irq = spi->irq;
>> +     hw->tf = &hts221_transfer_fn;
>> +
>> +     return hts221_probe(iio_dev);
>> +}
>> +
>> +static const struct of_device_id hts221_spi_of_match[] = {
>> +     { .compatible = "st,hts221", },
>> +     {},
>> +};
>> +MODULE_DEVICE_TABLE(of, hts221_spi_of_match);
>> +
>> +static const struct spi_device_id hts221_spi_id_table[] = {
>> +     { HTS221_DEV_NAME },
>> +     {},
>> +};
>> +MODULE_DEVICE_TABLE(spi, hts221_spi_id_table);
>> +
>> +static struct spi_driver hts221_driver = {
>> +     .driver = {
>> +             .name = "hts221_spi",
>> +             .of_match_table = of_match_ptr(hts221_spi_of_match),
>> +     },
>> +     .probe = hts221_spi_probe,
>> +     .id_table = hts221_spi_id_table,
>> +};
>> +module_spi_driver(hts221_driver);
>> +
>> +MODULE_AUTHOR("Lorenzo Bianconi <lorenzo.bianconi@st.com>");
>> +MODULE_DESCRIPTION("STMicroelectronics hts221 spi driver");
>> +MODULE_LICENSE("GPL v2");
>>
>

Regards,
Lorenzo

-- 
UNIX is Sexy: who | grep -i blonde | talk; cd ~; wine; talk; touch;
unzip; touch; strip; gasp; finger; gasp; mount; fsck; more; yes; gasp;
umount; make clean; sleep

^ permalink raw reply	[flat|nested] 13+ messages in thread

end of thread, other threads:[~2016-10-22 16:03 UTC | newest]

Thread overview: 13+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2016-10-13 20:06 [PATCH v4 0/2] add support to STM HTS221 humidity + temperature sensor Lorenzo Bianconi
2016-10-13 20:06 ` Lorenzo Bianconi
     [not found] ` <1476389165-13542-1-git-send-email-lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>
2016-10-13 20:06   ` [PATCH v4 1/2] iio: humidity: add support to hts221 rh/temp combo device Lorenzo Bianconi
2016-10-13 20:06     ` Lorenzo Bianconi
     [not found]     ` <1476389165-13542-2-git-send-email-lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>
2016-10-22 14:35       ` Jonathan Cameron
2016-10-22 14:35         ` Jonathan Cameron
2016-10-22 16:03         ` Lorenzo Bianconi
2016-10-13 20:06   ` [PATCH v4 2/2] Documentation: dt: iio: humidity: add hts221 sensor device binding Lorenzo Bianconi
2016-10-13 20:06     ` Lorenzo Bianconi
     [not found]     ` <1476389165-13542-3-git-send-email-lorenzo.bianconi-qxv4g6HH51o@public.gmane.org>
2016-10-18 14:00       ` Rob Herring
2016-10-18 14:00         ` Rob Herring
2016-10-22 14:37         ` Jonathan Cameron
2016-10-22 14:37           ` Jonathan Cameron

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.