iio: devm helpers and Murata zpa2326 barometer support

Introduce driver for Murata ZPA2326 pressure and temperature sensor:
http://www.murata.com/en-us/products/productdetail?partno=ZPA2326-0311A-R

Signed-off-by Gregor Boirie <[email protected]>

---
 .../devicetree/bindings/iio/pressure/zpa2326.txt   |   23 +
 drivers/iio/pressure/Kconfig                       |   33 +
 drivers/iio/pressure/Makefile                      |    3 +
 drivers/iio/pressure/zpa2326.c                     | 1766 ++++++++++++++++++++
 drivers/iio/pressure/zpa2326.h                     |   76 +
 drivers/iio/pressure/zpa2326_i2c.c                 |  188 +++
 drivers/iio/pressure/zpa2326_spi.c                 |  184 ++
 7 files changed, 2273 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/iio/pressure/zpa2326.txt
 create mode 100644 drivers/iio/pressure/zpa2326.c
 create mode 100644 drivers/iio/pressure/zpa2326.h
 create mode 100644 drivers/iio/pressure/zpa2326_i2c.c
 create mode 100644 drivers/iio/pressure/zpa2326_spi.c

Documentation/devicetree/bindings/iio/pressure/zpa2326.txt new file +23 -0

new file mode 100644
index 0000000..4b92906
@@ -0,0 +1,23 @@
+Murata ZPA2326 pressure sensor
+
+Pressure sensor from Murata with SPI and I2C bus interfaces.
+
+Required properties:
+- compatible: "murata,zpa2326"
+- reg: the I2C address or SPI chip select the device will respond to
+
+Optional properties:
+- interrupt-parent: should be the phandle for the interrupt controller
+- interrupts: interrupt mapping for IRQ
+- vdd-supply: an optional regulator that needs to be on to provide VDD
+  power to the sensor
+
+Example:
+
+zpa2326@5c {
+	compatible = "murata,zpa2326";
+	reg = <0x5c>;
+	interrupt-parent = <&gpio>;
+	interrupts = <12>;
+	vdd-supply = <&ldo_1v8_gnss>;
+};

drivers/iio/pressure/Kconfig +22 -0

index d130cdc..a3db56f 100644
@@ -187,4 +187,37 @@ config HP206C
 	  This driver can also be built as a module. If so, the module will
 	  be called hp206c.
 
+config ZPA2326
+	tristate "Murata ZPA2326 pressure sensor driver"
+	depends on I2C || SPI
+	select IIO_BUFFER
+	select IIO_TRIGGERED_BUFFER
+	help
+	  Say Y here to build support for the Murata ZPA2326 pressure and
+	  temperature sensor.
+
+	  To compile this driver as a module, choose M here: the module will
+	  be called zpa2326.
+
+config ZPA2326_I2C
+	tristate "support I2C bus connection"
+	depends on I2C && ZPA2326
+	help
+	  Say Y here to build I2C bus support for the Murata ZPA2326 pressure
+	  and temperature sensor.
+
+	  To compile this driver as a module, choose M here: the module will
+	  be called zpa2326_i2c.
+

drivers/iio/pressure/Kconfig +1 -0

+
 endmenu

drivers/iio/pressure/Makefile +3 -0

index 7f395be..fff7718 100644
@@ -22,6 +22,9 @@ st_pressure-y := st_pressure_core.o
 st_pressure-$(CONFIG_IIO_BUFFER) += st_pressure_buffer.o
 obj-$(CONFIG_T5403) += t5403.o
 obj-$(CONFIG_HP206C) += hp206c.o
+obj-$(CONFIG_ZPA2326) += zpa2326.o
+obj-$(CONFIG_ZPA2326_I2C) += zpa2326_i2c.o
+obj-$(CONFIG_ZPA2326_SPI) += zpa2326_spi.o
 
 obj-$(CONFIG_IIO_ST_PRESS_I2C) += st_pressure_i2c.o
 obj-$(CONFIG_IIO_ST_PRESS_SPI) += st_pressure_spi.o

drivers/iio/pressure/zpa2326.c new file +19 -0

new file mode 100644
index 0000000..7b76c34
@@ -0,0 +1,1766 @@
+/*
+ * Murata ZPA2326 pressure and temperature sensor IIO driver
+ *
+ * Copyright (c) 2016 Parrot S.A.
+ *
+ * Author: Gregor Boirie <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ *
+ * README:
+ * ------

drivers/iio/pressure/zpa2326.c new file +10 -0

+ * back to low power mode. It is meant for on demand sampling with optimal power
+ * saving at the cost of lower sampling rate and higher software overhead.
+ * This is a natural candidate for IIO read_raw hook implementation
+ * (INDIO_DIRECT_MODE). It is also used for triggered buffering support to
+ * ensure explicit synchronization with external trigger events
+ * (INDIO_BUFFER_TRIGGERED).
+ *
+ * The continuous mode works according to a periodic hardware measurement
+ * process continuously pushing samples into an internal hardware fifo (for
+ * pressure samples only). Measurement cycle completion may be signaled by a

drivers/iio/pressure/zpa2326.c new file +21 -0

+ * acquisition.
+ *
+ * Note that hardware sampling frequency is taken into account for
+ * INDIO_BUFFER_SOFTWARE mode only as the highest sampling rate seems to be the
+ * most energy efficient.
+ *
+ * TODO:
+ *   - preset pressure threshold crossing / IIO events
+ *   - differential pressure sampling
+ *   - hardware samples averaging
+ */
+
+/* Comment out to enable really verbose logging. */
+/*#define DEBUG*/
+
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/sched.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/regulator/consumer.h>

drivers/iio/pressure/zpa2326.c new file +158 -0

+#define ZPA_REF_P_L_REG                      ((u8)0x9)
+#define ZPA_REF_P_H_REG                      ((u8)0xa)
+#define ZPA_RES_CONF_REG                     ((u8)0x10)
+#define ZPA_CTRL_REG0_REG                    ((u8)0x20)
+#	define ZPA_CTRL_REG0_ONE_SHOT        BIT(0)
+#	define ZPA_CTRL_REG0_ENABLE          BIT(1)
+#define ZPA_CTRL_REG1_REG                    ((u8)0x21)
+#	define ZPA_CTRL_REG1_MASK_DATA_READY ((u8)BIT(2))
+#define ZPA_CTRL_REG2_REG                    ((u8)0x22)
+#	define ZPA_CTRL_REG2_SWRESET         BIT(2)
+#define ZPA_CTRL_REG3_REG                    ((u8)0x23)
+#	define ZPA_CTRL_REG3_ODR_SHIFT       (4)
+#	define ZPA_CTRL_REG3_ENABLE_MEAS     BIT(7)
+#define ZPA_INT_SOURCE_REG                   ((u8)0x24)
+#	define ZPA_INT_SOURCE_DATA_READY     BIT(2)
+#define ZPA_THS_P_LOW_REG                    ((u8)0x25)
+#define ZPA_THS_P_HIGH_REG                   ((u8)0x26)
+#define ZPA_STATUS_REG                       ((u8)0x27)
+#	define ZPA_STATUS_P_DA               BIT(1)
+#	define ZPA_STATUS_FIFO_E             BIT(2)
+#	define ZPA_STATUS_P_OR               BIT(5)
+#define ZPA_PRESS_OUT_XL_REG                 ((u8)0x28)
+#define ZPA_PRESS_OUT_L_REG                  ((u8)0x29)
+#define ZPA_PRESS_OUT_H_REG                  ((u8)0x2a)
+#define ZPA_TEMP_OUT_L_REG                   ((u8)0x2b)
+#define ZPA_TEMP_OUT_H_REG                   ((u8)0x2c)
+
+/* Hardware sampling frequency descriptor. */
+struct zpa_frequency {
+	/* Stringified frequency in Hertz. */
+	const char *hz;
+	/* Output Data Rate word as expected by ZPA_CTRL_REG3_REG. */
+	u16         odr;
+};
+
+/*
+ * Keep these in strict ascending order: last array entry is expected to
+ * correspond to the highest sampling frequency.
+ */
+static const struct zpa_frequency zpa_sampling_frequencies[] = {
+	{ .hz = "1",  .odr = 1 << ZPA_CTRL_REG3_ODR_SHIFT },
+	{ .hz = "5",  .odr = 5 << ZPA_CTRL_REG3_ODR_SHIFT },
+	{ .hz = "11", .odr = 6 << ZPA_CTRL_REG3_ODR_SHIFT },
+	{ .hz = "23", .odr = 7 << ZPA_CTRL_REG3_ODR_SHIFT },
+};
+
+/* Return the highest hardware sampling frequency available. */
+static const struct zpa_frequency *zpa_highest_frequency(void)
+{
+	return &zpa_sampling_frequencies[ARRAY_SIZE(zpa_sampling_frequencies) -
+					 1];
+}
+
+/* Per-device internal private state. */
+struct zpa_private {
+	/* Buffered samples ready datum. */
+	s64                         timestamp;
+	/*
+	 * Underlying I2C / SPI bus adapter used to abstract slave register
+	 * accesses.
+	 */
+	const struct zpa_bus       *bus;
+	/*
+	 * Interrupt handler stores sampling operation status here for user
+	 * context usage.
+	 */
+	int                         result;
+	/*
+	 * Interrupt handler uses this to wake user context up at sampling
+	 * operation completion.
+	 */
+	struct completion           data_ready;
+	/*
+	 * Optional hardware / interrupt driven trigger used to notify external
+	 * devices a new sample is ready.
+	 */
+	struct iio_trigger         *trigger;
+	/* Flag indicating whether or not device has just been powered on. */
+	bool                        waken;
+	/*
+	 * Optional interrupt line: negative if not declared into DT, in
+	 * which case user context keeps polling status register to detect
+	 * sampling completion.
+	 */
+	int                         irq;
+	/* Current hardware sampling frequency. */
+	const struct zpa_frequency *frequency;
+	/* Optional power supply. */
+	struct regulator           *vdd;
+};
+
+/******************************************************************************
+ * Various helpers
+ ******************************************************************************/
+
+#define zpa_err(_idev, _format, _arg...) \
+	dev_err(zpa_iio2slave(_idev), _format, ##_arg)
+
+#define zpa_warn(_idev, _format, _arg...) \
+	dev_warn(zpa_iio2slave(_idev), _format, ##_arg)
+
+#define zpa_dbg(_idev, _format, _arg...) \
+	dev_dbg(zpa_iio2slave(_idev), _format, ##_arg)
+
+static struct zpa_private *zpa_iio2priv(const struct iio_dev *indio_dev)
+{
+	return (struct zpa_private *)iio_priv(indio_dev);
+}
+
+/*
+ * Fetch single byte from slave register.
+ * indio_dev: IIO device the slave is attached to.
+ * address:   address of register to read from.
+ *
+ * Returns the fetched byte when successful, a negative error code otherwise.
+ */
+static int zpa_read_byte(const struct iio_dev *indio_dev, u8 address)
+{
+	return zpa_iio2priv(indio_dev)->bus->zpa_read_byte(indio_dev, address);
+}
+
+/*
+ * Store single byte to slave register.
+ * indio_dev: IIO device the slave is attached to
+ * address:   address of register to write to
+ *
+ * Returns: zero when successful, a negative error code otherwise.
+ */
+static int zpa_write_byte(const struct iio_dev *indio_dev, u8 address, u8 value)
+{
+	return zpa_iio2priv(indio_dev)->bus->zpa_write_byte(indio_dev, address,
+							    value);
+}
+
+/*
+ * Fetch multiple bytes from a block of contiguous slave registers.
+ * indio_dev: IIO device the slave is attached to.
+ * address:   start address of contiguous registers block to read from.
+ * length:    number of bytes to fetch.
+ * value:     location to store fetched data into.
+ *
+ * Returns: zero when successful, a negative error code otherwise.
+ */
+static int zpa_read_block(const struct iio_dev *indio_dev,
+			  u8                    address,
+			  u8                    length,
+			  u8                   *value)
+{
+	return zpa_iio2priv(indio_dev)->bus->zpa_read_block(indio_dev, address,
+							    length, value);
+}
+
+/******************************************************************************
+ * Device operations handling
+ ******************************************************************************/
+
+/*
+ * Enable device, i.e. get out of low power mode.

drivers/iio/pressure/zpa2326.c new file +32 -0

+		return err;
+	}
+
+	zpa_dbg(indio_dev, "enabled");
+	return 0;
+}
+
+/*
+ * Disable device, i.e. switch to low power mode.
+ *
+ * Only ZPA_DEVICE_ID_REG and ZPA_CTRL_REG0_REG registers may be accessed once
+ * device is in the disabled state.
+ */
+static int zpa_disable_device(const struct iio_dev *indio_dev)
+{
+	int err = zpa_write_byte(indio_dev, ZPA_CTRL_REG0_REG, 0);
+
+	if (err) {
+		zpa_err(indio_dev, "failed to disable device (%d)", err);
+		return err;
+	}
+
+	zpa_dbg(indio_dev, "disabled");
+	return 0;
+}
+
+/*
+ * Reset device to default hardware state.
+ *
+ * Disable sampling and empty hardware fifo.
+ * Device must be enabled before reset, i.e. not in low power mode.
+ */

drivers/iio/pressure/zpa2326.c new file +60 -0

+	usleep_range(1000, 2000);
+
+	zpa_dbg(indio_dev, "reset");
+	return 0;
+}
+
+/*
+ * Start a single sampling cycle, i.e. in one shot mode.
+ *
+ * Device must have been previously enabled and configured for one shot mode.
+ * Device will automatically switch back to low power mode at end of cycle.
+ */
+static int zpa_start_oneshot(const struct iio_dev *indio_dev)
+{
+	int err = zpa_write_byte(indio_dev, ZPA_CTRL_REG0_REG,
+				 ZPA_CTRL_REG0_ENABLE | ZPA_CTRL_REG0_ONE_SHOT);
+	if (err) {
+		zpa_err(indio_dev, "failed to start one shot cycle (%d)", err);
+		return err;
+	}
+
+	zpa_dbg(indio_dev, "one shot cycle started");
+	return 0;
+}
+
+/*
+ * Power on device to allow subsequent configuration.
+ *
+ * Sampling will be disabled, preventing strange things from happening in our
+ * back. Hardware fifo content will be cleared.
+ * When successful, device will be left in the enabled state to allow further
+ * configuration.
+ */
+static int zpa_power_on(const struct iio_dev     *indio_dev,
+			const struct zpa_private *private)
+{
+	int err = regulator_enable(private->vdd);
+
+	if (err)
+		return err;
+
+	zpa_dbg(indio_dev, "powered on");
+
+	err = zpa_enable_device(indio_dev);
+	if (err)
+		goto off;
+
+	err = zpa_reset_device(indio_dev);
+	if (err)
+		goto disable;
+
+	return 0;
+
+disable:
+	zpa_disable_device(indio_dev);
+off:
+	regulator_disable(private->vdd);
+
+	zpa_dbg(indio_dev, "powered off");
+	return err;

drivers/iio/pressure/zpa2326.c new file +128 -0

+	return err;
+}
+
+/*
+ * Setup device for one shot / on demand mode.
+ *
+ * Output Data Rate is configured for the highest possible rate so that
+ * conversion time and power consumption are reduced to a minimum.
+ * Note that hardware internal averaging machinery (not implemented in this
+ * driver) is not applicable in this mode.
+ *
+ * Device must have been previously enabled before calling zpa_config_oneshot().
+ */
+static int zpa_config_oneshot(const struct iio_dev *indio_dev,
+			      int                   irq)
+{
+	const struct zpa_frequency *freq = zpa_highest_frequency();
+	int                         err;
+
+	/* Setup highest available Output Data Rate for one shot mode. */
+	err = zpa_write_byte(indio_dev, ZPA_CTRL_REG3_REG, freq->odr);
+	if (err)
+		return err;
+
+	if (irq > 0)
+		/* Request interrupt when new sample is available. */
+		err = zpa_write_byte(indio_dev, ZPA_CTRL_REG1_REG,
+				     ~ZPA_CTRL_REG1_MASK_DATA_READY);
+	if (err) {
+		dev_err(zpa_iio2slave(indio_dev),
+			"failed to setup one shot mode (%d)", err);
+		return err;
+	}
+
+	dev_dbg(zpa_iio2slave(indio_dev), "one shot mode setup @%sHz",
+		freq->hz);
+
+	return 0;
+}
+
+/*
+ * Clear remaining entries in hardware fifo.
+ *
+ * min_count argument is a hint corresponding to the known minimum number of
+ * samples currently living in the fifo. This allows to reduce the number of bus
+ * accesses by skipping status register read operation as long as we know for
+ * sure there are still entries left.
+ */
+static int zpa_clear_fifo(const struct iio_dev *indio_dev,
+			  unsigned int          min_count)
+{
+	int err;
+
+	if (!min_count) {
+		/*
+		 * No hint: read status register to determine whether fifo is
+		 * empty or not.
+		 */
+		err = zpa_read_byte(indio_dev, ZPA_STATUS_REG);
+		if (err < 0)
+			goto err;
+
+		if (err & ZPA_STATUS_FIFO_E)
+			/* Fifo is empty: nothing to trash. */
+			return 0;
+	}
+
+	/* Clear fifo. */
+	do {
+		/*
+		 * A single fetch from pressure MSB register is enought to pop
+		 * values out of fifo.
+		 */
+		err = zpa_read_byte(indio_dev, ZPA_PRESS_OUT_H_REG);
+		if (err < 0)
+			goto err;
+
+		if (min_count) {
+			/*
+			 * We know for sure there are at least min_count entries
+			 * left in fifo. Skip status register read.
+			 */
+			min_count--;
+			continue;
+		}
+
+		err = zpa_read_byte(indio_dev, ZPA_STATUS_REG);
+		if (err < 0)
+			goto err;
+
+	} while (!(err & ZPA_STATUS_FIFO_E));
+
+	zpa_dbg(indio_dev, "fifo cleared");
+	return 0;
+
+err:
+	zpa_err(indio_dev, "failed to clear fifo (%d)", err);
+	return err;
+}
+
+/*
+ * Retrieve the most recent pressure sample from hardware fifo.
+ *
+ * Note that ZPA2326 hardware fifo stores pressure samples only.
+ */
+static int zpa_dequeue_pressure(const struct iio_dev *indio_dev, u32 *pressure)
+{
+	int err = zpa_read_byte(indio_dev, ZPA_STATUS_REG);
+
+	if (err < 0)
+		return err;
+
+	if (!(err & ZPA_STATUS_P_OR)) {
+		/*
+		 * Fifo has not overflown : retrieve newest sample. We need to
+		 * pop values out until fifo is empty : last fetched pressure is
+		 * the newest.
+		 * In nominal cases, we should find a single queued sample only.
+		 */
+		int cleared = -1;
+
+		do {
+			err = zpa_read_block(indio_dev, ZPA_PRESS_OUT_XL_REG, 3,
+					     (u8 *)pressure);
+			if (err)
+				return err;
+
+			err = zpa_read_byte(indio_dev, ZPA_STATUS_REG);

drivers/iio/pressure/zpa2326.c new file +17 -0

+			 * inform user.
+			 */
+			zpa_warn(indio_dev, "cleared %d fifo entries", cleared);
+
+		return 0;
+	}
+
+	/* Fifo overrun : first sample dequeued from fifo is the newest. */
+	zpa_warn(indio_dev, "fifo overflow");
+
+	err = zpa_read_block(indio_dev, ZPA_PRESS_OUT_XL_REG, 3,
+			     (u8 *)pressure);
+	if (err)
+		return err;
+
+#define ZPA_FIFO_DEPTH (16U)
+	/* Hardware fifo may hold no more than 16 pressure samples. */

drivers/iio/pressure/zpa2326.c new file +147 -0

+				 err);
+			return err;
+		}
+	}
+
+	if (test_bit(1, indio_dev->active_scan_mask)) {
+		/* Get current temperature. */
+		err = zpa_read_block(indio_dev, ZPA_TEMP_OUT_L_REG, 2,
+				     (u8 *)&sample.temperature);
+		if (err) {
+			zpa_warn(indio_dev, "failed to fetch temperature (%d)",
+				 err);
+			return err;
+		}
+	}
+
+	/*
+	 * Now push samples using timestamp stored either :
+	 *   - by hardware interrupt handler if interrupt is available: see
+	 *     zpa_handle_irq(),
+	 *   - or oneshot completion polling machinery : see
+	 *     zpa_trigger_oneshot().
+	 */
+	iio_push_to_buffers_with_timestamp(indio_dev, &sample,
+					   private->timestamp);
+	return 0;
+}
+
+/******************************************************************************
+ * Power management
+ ******************************************************************************/
+
+#ifdef CONFIG_PM
+static int zpa_runtime_suspend(struct device *slave)
+{
+	const struct iio_dev *indio_dev = dev_get_drvdata(slave);
+
+	if (pm_runtime_autosuspend_expiration(slave))
+		/* Userspace changed autosuspend delay. */
+		return -EAGAIN;
+
+	return zpa_power_off(indio_dev, zpa_iio2priv(indio_dev));
+}
+
+static int zpa_runtime_resume(struct device *slave)
+{
+	const struct iio_dev *indio_dev = dev_get_drvdata(slave);
+
+	return zpa_power_on(indio_dev, zpa_iio2priv(indio_dev));
+}
+
+const struct dev_pm_ops zpa_pm_ops = {
+	SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
+				pm_runtime_force_resume)
+	SET_RUNTIME_PM_OPS(zpa_runtime_suspend, zpa_runtime_resume, NULL)
+};
+EXPORT_SYMBOL_GPL(zpa_pm_ops);
+
+/* Request the PM layer to power supply the device. */
+static int zpa_resume(const struct iio_dev *indio_dev)
+{
+	struct device *slave = zpa_iio2slave(indio_dev);
+	int            err = pm_runtime_get_sync(slave);
+
+	if (err < 0)
+		goto put;
+
+	if (err > 0) {
+		/*
+		 * Device was already power supplied: get it out of low power
+		 * mode.
+		 */
+		err = zpa_enable_device(indio_dev);
+		if (err)
+			goto put;
+
+		/* Inform caller device was already power supplied. */
+		return 1;
+	}
+
+	/* Inform caller device has just been brought back to life. */
+	return 0;
+
+put:
+	pm_runtime_put_noidle(slave);
+	return err;
+}
+
+/*
+ * Schedule a power down using autosuspend feature of PM layer.
+ *
+ * Device is switched to low power mode at first to save power even when
+ * attached regulator is a "dummy" one.
+ */
+static int zpa_suspend(const struct iio_dev *indio_dev)
+{
+	struct device *slave = zpa_iio2slave(indio_dev);
+	int            err = zpa_disable_device(indio_dev);
+
+	pm_runtime_mark_last_busy(slave);
+
+	if (err)
+		goto err;
+
+	err = pm_runtime_put_autosuspend(slave);
+	if (err) {
+		dev_warn(slave, "failed to autosuspend (%d)", err);
+		goto err;
+	}
+
+	return 0;
+
+err:
+	pm_runtime_put_noidle(slave);
+	return err;
+}
+
+/* Setup runtime power management with autosuspend support. */
+static void zpa_init_runtime(struct device *slave)
+{
+	pm_runtime_get_noresume(slave);
+	pm_runtime_set_active(slave);
+	pm_runtime_enable(slave);
+	pm_runtime_set_autosuspend_delay(slave, 1000);
+	pm_runtime_use_autosuspend(slave);
+	pm_runtime_mark_last_busy(slave);
+	pm_runtime_put_autosuspend(slave);
+}
+
+static void zpa_fini_runtime(struct device *slave)
+{
+	pm_runtime_disable(slave);
+	pm_runtime_set_suspended(slave);
+}
+#else /* !CONFIG_PM */
+static int zpa_resume(const struct iio_dev *indio_dev)
+{
+	return zpa_enable_device(indio_dev);
+}
+
+static int zpa_suspend(const struct iio_dev *indio_dev)
+{
+	return zpa_disable_device(indio_dev);
+}
+
+#define zpa_init_runtime(_slave)
+#define zpa_fini_runtime(_slave)

drivers/iio/pressure/zpa2326.c new file +285 -0

+ * half.
+ */
+static irqreturn_t zpa_handle_irq(int irq, void *data)
+{
+	struct iio_dev *indio_dev = (struct iio_dev *)data;
+
+	if (iio_buffer_enabled(indio_dev)) {
+		struct zpa_private *priv = zpa_iio2priv(indio_dev);
+
+		/* Timestamping needed for buffered sampling only. */
+		priv->timestamp = iio_get_time_ns(indio_dev);
+	}
+
+	return IRQ_WAKE_THREAD;
+}
+
+/*
+ * Fetch interrupt status and acknowledge all interrupts.
+ *
+ * Called from threaded interrupt context.
+ */
+static int zpa_acknowledge_irq(const struct iio_dev     *indio_dev,
+			       const struct zpa_private *private)
+{
+	/*
+	 * Device works according to a level interrupt scheme: reading interrupt
+	 * status de-asserts interrupt line.
+	 */
+	int err = zpa_read_byte(indio_dev, ZPA_INT_SOURCE_REG);
+
+	if (err < 0)
+		return err;
+
+	/* Data ready is the only interrupt source we requested. */
+	if (!(err & ZPA_INT_SOURCE_DATA_READY)) {
+		zpa_warn(indio_dev, "unexpected interrupt status %02x", err);
+		return -ENODATA;
+	}
+
+	/* New sample available: notify our internal trigger consumers. */
+	iio_trigger_poll_chained(private->trigger);
+
+	return 0;
+}
+
+/*
+ * Interrupt bottom-half handler.
+ *
+ * Mainly ensures interrupt is caused by a real "new sample available"
+ * condition. This relies upon the ability to perform blocking / sleeping bus
+ * accesses to slave's registers. This is why zpa_handle_threaded_irq() is
+ * called from within a thread, i.e. not called from hard interrupt context.
+ */
+static irqreturn_t zpa_handle_threaded_irq(int irq, void *data)
+{
+	struct iio_dev     *indio_dev = (struct iio_dev *)data;
+	struct zpa_private *priv = zpa_iio2priv(indio_dev);
+	irqreturn_t         ret = IRQ_NONE;
+
+	priv->result = zpa_acknowledge_irq(indio_dev, priv);
+
+	if (indio_dev->currentmode == INDIO_BUFFER_SOFTWARE) {
+		/* Continuous sampling enabled. */
+
+		if (!priv->result)
+			/* Populate IIO buffer */
+			zpa_fill_sample_buffer(indio_dev, priv);
+		/*
+		 * Tell power management layer we've just used the device to
+		 * prevent from autosuspending to early.
+		 */
+		pm_runtime_mark_last_busy(zpa_iio2slave(indio_dev));
+
+		return (!priv->result) ? IRQ_HANDLED : IRQ_NONE;
+	}
+
+	if (priv->result)
+		/*
+		 * Interrupt happened but no new sample available: likely caused
+		 * by spurious interrupts, in which case, returning IRQ_NONE
+		 * allows to benefit from the generic spurious interrupts
+		 * handling.
+		 */
+		goto complete;
+
+	if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED)
+		priv->result = zpa_fill_sample_buffer(indio_dev, priv);
+
+	ret = IRQ_HANDLED;
+
+complete:
+	/*
+	 * Wake up direct or triggered buffer mode waiters: see
+	 * zpa_sample_oneshot() and zpa_trigger_oneshot().
+	 */
+	complete(&priv->data_ready);
+	return ret;
+}
+
+/* Wait for oneshot data ready interrupt. */
+static int zpa_wait_oneshot_completion(const struct iio_dev *indio_dev,
+				       struct zpa_private   *private)
+{
+	int err = wait_for_completion_interruptible_timeout(
+			&private->data_ready, ZPA_CONVERSION_TIMEOUT);
+
+	if (err > 0)
+		/*
+		 * Interrupt handler completed before timeout: return operation
+		 * status.
+		 */
+		return private->result;
+
+	/* Clear all interrupts just to be sure. */
+	zpa_read_byte(indio_dev, ZPA_INT_SOURCE_REG);
+
+	if (!err)
+		/* Timed out. */
+		err = -ETIME;
+
+	if (err != -ERESTARTSYS)
+		zpa_warn(indio_dev, "no one shot interrupt occurred (%d)", err);
+
+	return err;
+}
+
+/* Setup interrupt handling. */
+static int zpa_init_irq(struct device      *slave,
+			struct iio_dev     *indio_dev,
+			struct zpa_private *private,
+			int                 irq)
+{
+	int err;
+
+	if (irq <= 0) {
+		/*
+		 * Platform declared no interrupt line: device will be polled
+		 * for data availability.
+		 */
+		private->irq = -1;
+		dev_info(slave, "no interrupt found, running in polling mode");
+		return 0;
+	}
+
+	private->irq = irq;
+	init_completion(&private->data_ready);
+
+	/* Request handler to be scheduled into threaded interrupt context. */
+	err = devm_request_threaded_irq(slave, irq, zpa_handle_irq,
+					zpa_handle_threaded_irq,
+					IRQF_TRIGGER_RISING | IRQF_ONESHOT,
+					dev_name(slave), indio_dev);
+	if (err) {
+		dev_err(slave, "failed to request interrupt %d (%d)", irq, err);
+		return err;
+	}
+
+	dev_info(slave, "using interrupt %d", irq);
+	return 0;
+}
+
+/******************************************************************************
+ * Direct sampling
+ ******************************************************************************/
+
+/*
+ * Ensure exclusive access to prevent from modifying device setup in the back of
+ * ongoing operations.
+ * In the mean time, power on device to get access to the complete register map.
+ */
+static int zpa_claim_direct_mode(struct iio_dev *indio_dev)
+{
+	/* Gain exclusive access for userspace usage. */
+	int err = iio_device_claim_direct_mode(indio_dev);
+
+	if (err)
+		return err;
+
+	/* Bring device back to life. */
+	err = zpa_resume(indio_dev);
+	if (err < 0)
+		goto release;
+
+	return err;
+
+release:
+	/* Relinquish exclusive access. */
+	iio_device_release_direct_mode(indio_dev);
+	return err;
+}
+
+/* Release exclusive acces to device. Device is also powered down. */
+static void zpa_release_direct_mode(struct iio_dev *indio_dev)
+{
+	zpa_suspend(indio_dev);
+	iio_device_release_direct_mode(indio_dev);
+}
+
+/* Actively poll for one shot data ready. */
+static int zpa_poll_oneshot_completion(const struct iio_dev *indio_dev)
+{
+	unsigned long tmout = jiffies + ZPA_CONVERSION_TIMEOUT;
+	int           err;
+
+	/*
+	 * At least, 100 ms is needed for the device to complete its one-shot
+	 * cycle.
+	 */
+	if (msleep_interruptible(100))
+		return -ERESTARTSYS;
+
+	/* Poll for conversion completion in hardware. */
+	while (true) {
+		err = zpa_read_byte(indio_dev, ZPA_CTRL_REG0_REG);
+		if (err < 0)
+			goto err;
+
+		if (!(err & ZPA_CTRL_REG0_ONE_SHOT))
+			/* One-shot bit self clears at conversion end. */
+			break;
+
+		if (time_after(jiffies, tmout)) {
+			/* Prevent from waiting forever : let's time out. */
+			err = -ETIME;
+			goto err;
+		}
+
+		usleep_range(10000, 20000);
+	}
+
+	/*
+	 * In oneshot mode, pressure sample availability guarantees that
+	 * temperature conversion has also completed : just check pressure
+	 * status bit to keep things simple.
+	 */
+	err = zpa_read_byte(indio_dev, ZPA_STATUS_REG);
+	if (err < 0)
+		goto err;
+
+	if (!(err & ZPA_STATUS_P_DA)) {
+		/* No sample available. */
+		err = -ENODATA;
+		goto err;
+	}
+
+	return 0;
+
+err:
+	zpa_warn(indio_dev, "failed to poll one shot completion (%d)", err);
+	return err;
+}
+
+/* Retrieve a raw sample and convert it to CPU endianness. */
+static int zpa_fetch_raw_sample(const struct iio_dev *indio_dev,
+				enum iio_chan_type    type,
+				int                  *value)
+{
+	int err;
+
+	switch (type) {
+	case IIO_PRESSURE:
+		zpa_dbg(indio_dev, "fetching raw pressure sample");
+
+		err = zpa_read_block(indio_dev, ZPA_PRESS_OUT_XL_REG, 3,
+				     (u8 *)value);
+		if (err) {
+			zpa_warn(indio_dev, "failed to fetch pressure (%d)",
+				 err);
+			return err;
+		}
+
+		/* Pressure is a 24 bits wide little-endian unsigned int. */
+		*value = (((u8 *)value)[2] << 16) | (((u8 *)value)[1] << 8) |
+			 ((u8 *)value)[0];
+
+		return IIO_VAL_INT;
+
+	case IIO_TEMP:
+		zpa_dbg(indio_dev, "fetching raw temperature sample");
+
+		err = zpa_read_block(indio_dev, ZPA_TEMP_OUT_L_REG, 2,
+				     (u8 *)value);
+		if (err) {
+			zpa_warn(indio_dev, "failed to fetch temperature (%d)",
+				 err);

drivers/iio/pressure/zpa2326.c new file +561 -0

+	}
+}
+
+/* Perform a complete one shot sampling cycle. */
+static int zpa_sample_oneshot(struct iio_dev     *indio_dev,
+			      enum iio_chan_type  type,
+			      int                *value)
+{
+	/* Gain exclusive access to device. */
+	int                 err = zpa_claim_direct_mode(indio_dev);
+	struct zpa_private *priv = zpa_iio2priv(indio_dev);
+
+	if (err < 0)
+		return err;
+
+	if (err > 0) {
+		/*
+		 * We were already power supplied. Just clear hardware fifo to
+		 * get rid of samples acquired during previous rounds (if any).
+		 * Sampling operation always generates both temperature and
+		 * pressure samples. The latter are always enqueued into
+		 * hardware fifo. This may lead to situations were pressure
+		 * samples still sit into fifo when previous cycle(s) fetched
+		 * temperature data only.
+		 * Hence, we need to clear hardware fifo content to prevent from
+		 * getting outdated values at the end of current cycle.
+		 */
+		if (type == IIO_PRESSURE) {
+			err = zpa_clear_fifo(indio_dev, 0);
+			if (err)
+				goto release;
+		}
+	} else {
+		/*
+		 * We have just been power supplied, i.e. device is in default
+		 * "out of reset" state, meaning we need to reconfigure it
+		 * entirely.
+		 */
+		err = zpa_config_oneshot(indio_dev, priv->irq);
+		if (err)
+			goto release;
+	}
+
+	/* Start a sampling cycle in oneshot mode. */
+	err = zpa_start_oneshot(indio_dev);
+	if (err)
+		goto release;
+
+	/* Wait for sampling cycle to complete. */
+	zpa_dbg(indio_dev, "waiting for one shot completion");
+
+	if (priv->irq > 0)
+		err = zpa_wait_oneshot_completion(indio_dev, priv);
+	else
+		err = zpa_poll_oneshot_completion(indio_dev);
+
+	if (err)
+		goto release;
+
+	/* Retrieve raw sample value and convert it to CPU endianness. */
+	err = zpa_fetch_raw_sample(indio_dev, type, value);
+
+release:
+	zpa_release_direct_mode(indio_dev);
+	return err;
+}
+
+/******************************************************************************
+ * Buffering handling
+ ******************************************************************************/
+
+/*
+ * Reject external trigger attachment if setting up continuous hardware sampling
+ * mode.
+ */
+static int zpa_validate_trigger(struct iio_dev     *indio_dev,
+				struct iio_trigger *trigger)
+{
+	int ret = 0;
+
+	mutex_lock(&indio_dev->mlock);
+
+	if (indio_dev->currentmode == INDIO_BUFFER_SOFTWARE)
+		ret = -EBUSY;
+
+	mutex_unlock(&indio_dev->mlock);
+
+	return ret;
+}
+
+/* Finalize one shot cycle processing in triggered sampling mode. */
+static void zpa_complete_oneshot_trigger(const struct iio_dev *indio_dev)
+{
+	/*
+	 * Tell power management layer we've just used the device to prevent
+	 * from autosuspending to early.
+	 */
+	pm_runtime_mark_last_busy(zpa_iio2slave(indio_dev));
+
+	/* Inform attached trigger we are done. */
+	iio_trigger_notify_done(indio_dev->trig);
+}
+
+/*
+ * Perform an IIO buffered sampling round in one shot mode.
+ *
+ * Handler called by the IIO trigger currently attached to device. Allows to
+ * synchronize this device buffered sampling with external events (such as timer
+ * expiration, external device sample ready, etc...).
+ * Basically run the same sequence of operations as for zpa_sample_oneshot()
+ * with the following exceptions:
+ *   - hardware fifo is not cleared since already done at buffering enable time
+ *     and samples dequeueing always retrieves the most recent value,
+ *   - samples endianness is not processed since delegated to userspace in
+ *     buffered mode.
+ */
+static irqreturn_t zpa_trigger_oneshot(int irq, void *data)
+{
+	struct iio_poll_func *pf = data;
+	struct iio_dev       *indio_dev = pf->indio_dev;
+	struct zpa_private   *priv = zpa_iio2priv(indio_dev);
+
+	/* Start a one shot sampling cycle. */
+	if (zpa_start_oneshot(indio_dev))
+		goto err;
+
+	if (priv->irq <= 0) {
+		/* No interrupt available: poll for sampling completion. */
+		if (zpa_poll_oneshot_completion(indio_dev))
+			goto disable;
+
+		/* Only timestamp sample once it is ready. */
+		priv->timestamp = iio_get_time_ns(indio_dev);
+
+		/* Enqueue to IIO buffer / userspace. */
+		zpa_fill_sample_buffer(indio_dev, priv);
+	} else {
+		/* Interrupt handlers will timestamp and get samples for us. */
+		if (zpa_wait_oneshot_completion(indio_dev, priv))
+			goto disable;
+	}
+
+	zpa_complete_oneshot_trigger(indio_dev);
+	return IRQ_HANDLED;
+
+disable:
+	zpa_disable_device(indio_dev);
+err:
+	zpa_complete_oneshot_trigger(indio_dev);
+	return IRQ_NONE;
+}
+
+/*
+ * Get device ready for configuration of continuous / triggered sampling modes.
+ *
+ * Called with IIO device's lock held.
+ */
+static int zpa_preenable_ring(struct iio_dev *indio_dev)
+{
+	int err = zpa_resume(indio_dev);
+
+	if (err < 0)
+		return err;
+
+	if (err > 0) {
+		/*
+		 * We were already power supplied. Just clear hardware fifo to
+		 * get rid of samples acquired during previous rounds (if any).
+		 */
+		err = zpa_clear_fifo(indio_dev, 0);
+		if (err) {
+			zpa_suspend(indio_dev);
+			return err;
+		}
+
+		zpa_iio2priv(indio_dev)->waken = false;
+		return 0;
+	}
+
+	/* Tell zpa_postenable_ring() we have just been powered on. */
+	zpa_iio2priv(indio_dev)->waken = true;
+	return 0;
+}
+
+/*
+ * Configure and start continuous / triggered sampling.
+ *
+ * Called with IIO device's lock held.
+ * If an error is returned, IIO layer will call our postdisable hook for us,
+ * i.e. no need to explicitly power device off here.
+ */
+static int zpa_postenable_ring(struct iio_dev *indio_dev)
+{
+	const struct zpa_private *priv = zpa_iio2priv(indio_dev);
+	int                       err;
+
+	if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
+		/* Prepare device for triggered buffering usage. */
+
+		if (priv->waken) {
+			/*
+			 * We have just been power supplied, i.e. device is in
+			 * default "out of reset" state, meaning we need to
+			 * properly reconfigure it for on trigger demand usage.
+			 */
+			err = zpa_config_oneshot(indio_dev, priv->irq);
+			if (err)
+				return err;
+		}
+
+		/* Plug our own trigger event handler. */
+		err = iio_triggered_buffer_postenable(indio_dev);
+		if (err)
+			return err;
+
+		/*
+		 * Switch back to low power. A complete one shot sampling cycle
+		 * will be started upon trigger notification.
+		 */
+		return zpa_disable_device(indio_dev);
+	}
+
+	/* Prepare then start continuous sampling session. */
+
+	if (priv->waken) {
+		/*
+		 * We have just been power supplied, i.e. device is in default
+		 * "out of reset" state, meaning we need to unmask data ready
+		 * interrupt to process new samples.
+		 */
+		err = zpa_write_byte(indio_dev, ZPA_CTRL_REG1_REG,
+				     ~ZPA_CTRL_REG1_MASK_DATA_READY);
+		if (err)
+			goto err;
+	}
+
+	/* Start continuous sampling at required frequency. */
+	err = zpa_write_byte(indio_dev, ZPA_CTRL_REG3_REG,
+			     ZPA_CTRL_REG3_ENABLE_MEAS | priv->frequency->odr);
+	if (err)
+		goto err;
+
+	zpa_dbg(indio_dev, "continuous mode setup @%sHz", priv->frequency->hz);
+	return 0;
+
+err:
+	zpa_err(indio_dev, "failed to setup continuous mode (%d)", err);
+	return err;
+}
+
+/*
+ * Stop continuous / triggered sampling.
+ *
+ * Called with IIO device's lock held.
+ */
+static int zpa_predisable_ring(struct iio_dev *indio_dev)
+{
+	if (indio_dev->currentmode == INDIO_BUFFER_SOFTWARE) {
+		int irq = zpa_iio2priv(indio_dev)->irq;
+		int err;
+
+		/*
+		 * As device is working in continuous mode, handlers may be
+		 * accessing resources we are currently freeing...
+		 * Prevent this by disabling interrupt handlers and ensure
+		 * the device will generate no more interrupts unless explicitly
+		 * required to, i.e. by restoring back to default one shot mode.
+		 */
+		disable_irq(irq);
+
+		/*
+		 * Disable continuous sampling mode to restore settings for
+		 * one shot / direct sampling operations.
+		 */
+		err = zpa_write_byte(indio_dev, ZPA_CTRL_REG3_REG,
+				     zpa_highest_frequency()->odr);
+		if (err)
+			goto err;
+
+		/*
+		 * Now that device won't generate interrupts on its own,
+		 * acknowledge any currently active interrupts (may happen on
+		 * rare occasions while stopping continuous mode).
+		 */
+		err = zpa_read_byte(indio_dev, ZPA_INT_SOURCE_REG);
+		if (err < 0)
+			goto err;
+
+		/*
+		 * Re-enable interrupts only if we can guarantee the device will
+		 * generate no more interrupts to prevent handlers from
+		 * accessing released resources.
+		 */
+		enable_irq(irq);
+		return 0;
+
+err:
+		zpa_err(indio_dev,
+			"failed to stop buffering, leaving interrupt disabled... (%d)",
+			err);
+		return err;
+	}
+
+	/* Triggered buffering: unplug our own trigger event handler. */
+	return iio_triggered_buffer_predisable(indio_dev);
+}
+
+/* Called with IIO device's lock held. */
+static int zpa_postdisable_ring(struct iio_dev *indio_dev)
+{
+	return zpa_suspend(indio_dev);
+}
+
+static const struct iio_buffer_setup_ops zpa_ring_setup_ops = {
+	.preenable   = zpa_preenable_ring,
+	.postenable  = zpa_postenable_ring,
+	.predisable  = zpa_predisable_ring,
+	.postdisable = zpa_postdisable_ring,
+};
+
+/* Setup buffered sampling. */
+static int zpa_init_ring(struct device  *slave,
+			 struct iio_dev *indio_dev,
+			 int             irq)
+{
+	int err = devm_iio_triggered_buffer_setup(slave, indio_dev, NULL,
+						  zpa_trigger_oneshot,
+						  &zpa_ring_setup_ops);
+	if (err)
+		return err;
+
+	if (irq > 0)
+		/* Allow continuous hardware sampling if interrupt available. */
+		indio_dev->modes |= INDIO_BUFFER_SOFTWARE;
+
+	return 0;
+}
+
+/******************************************************************************
+ * Hardware trigger handling
+ ******************************************************************************/
+
+/*
+ * Using our own interrupt driven trigger to start a triggered buffer sampling
+ * round is pure nonsense: use continuous hardware sampling mode instead, i.e.
+ * INDIO_BUFFER_SOFTWARE. Or synchronize against an external trigger / device.
+ */
+static int zpa_validate_device(struct iio_trigger *trigger,
+			       struct iio_dev     *indio_dev)
+{
+	if (indio_dev == (struct iio_dev *)iio_trigger_get_drvdata(trigger))
+		return -EINVAL;
+
+	return 0;
+}
+
+static const struct iio_trigger_ops zpa_trigger_ops = {
+	.owner             = THIS_MODULE,
+	.validate_device   = zpa_validate_device,
+};
+
+/*
+ * Create an interrupt driven / hardware trigger allowing to notify external
+ * devices a new sample is ready.
+ */
+static int zpa_init_trigger(struct device      *slave,
+			    struct iio_dev     *indio_dev,
+			    struct zpa_private *private,
+			    int                 irq)
+{
+	struct iio_trigger *trigger;
+	int                 err;
+
+	if (irq <= 0)
+		return 0;
+
+	trigger = devm_iio_trigger_alloc(slave, "%s-sample-ready-dev%d",
+					 indio_dev->name, indio_dev->id);
+	if (!trigger)
+		return -ENOMEM;
+
+	/* Basic setup. */
+	trigger->dev.parent = slave;
+	trigger->ops = &zpa_trigger_ops;
+	iio_trigger_set_drvdata(trigger, indio_dev);
+
+	private->trigger = trigger;
+
+	/* Register to triggers space. */
+	err = devm_iio_trigger_register(slave, trigger);
+	if (err)
+		dev_err(slave, "failed to register hardware trigger (%d)", err);
+
+	return err;
+}
+
+/******************************************************************************
+ * Debugfs stuff
+ *
+ * Note this is mostly unusable with power management enabled systems since
+ * registers content is lost during power off -> on transitions.
+ ******************************************************************************/
+
+#if defined(CONFIG_DEBUG_FS)
+#define zpa_debugfs_ptr(_ptr) _ptr
+
+static int zpa_debugfs_read(struct iio_dev *indio_dev,
+			    u8              reg,
+			    unsigned int   *value)
+{
+	int err;
+
+	switch (reg) {
+	case ZPA_REF_P_XL_REG:
+	case ZPA_REF_P_L_REG:
+	case ZPA_REF_P_H_REG:
+	case ZPA_DEVICE_ID_REG:
+	case ZPA_RES_CONF_REG:
+	case ZPA_CTRL_REG0_REG:
+	case ZPA_CTRL_REG1_REG:
+	case ZPA_CTRL_REG2_REG:
+	case ZPA_CTRL_REG3_REG:
+	case ZPA_INT_SOURCE_REG: /* Will acknowledge interrupts. */
+	case ZPA_THS_P_LOW_REG:
+	case ZPA_THS_P_HIGH_REG:
+	case ZPA_STATUS_REG:
+	case ZPA_PRESS_OUT_XL_REG:
+	case ZPA_PRESS_OUT_L_REG:
+	case ZPA_PRESS_OUT_H_REG:  /* Will pop samples out of hardware fifo. */
+	case ZPA_TEMP_OUT_L_REG:
+	case ZPA_TEMP_OUT_H_REG:
+		break;
+
+	default:
+		return -EINVAL;
+	}
+
+	err = zpa_claim_direct_mode(indio_dev);
+	if (err < 0)
+		return err;
+
+	err = zpa_read_byte(indio_dev, reg);
+	if (err < 0)
+		goto release;
+
+	*value = err;
+	err = 0;
+
+release:
+	zpa_release_direct_mode(indio_dev);
+	return err;
+}
+
+static int zpa_debugfs_write(struct iio_dev *indio_dev,
+			     u8              reg,
+			     unsigned int    value)
+{
+	int err;
+
+	switch (reg) {
+	/* Read only registers */
+	case ZPA_DEVICE_ID_REG:
+	case ZPA_INT_SOURCE_REG:
+	case ZPA_STATUS_REG:
+	case ZPA_PRESS_OUT_XL_REG:
+	case ZPA_PRESS_OUT_L_REG:
+	case ZPA_PRESS_OUT_H_REG:
+	case ZPA_TEMP_OUT_L_REG:
+	case ZPA_TEMP_OUT_H_REG:
+		return -EPERM;
+
+	/* Read/write registers */
+	case ZPA_REF_P_XL_REG:
+	case ZPA_REF_P_L_REG:
+	case ZPA_REF_P_H_REG:
+	case ZPA_RES_CONF_REG:
+	case ZPA_CTRL_REG0_REG:
+	case ZPA_CTRL_REG1_REG:
+	case ZPA_CTRL_REG2_REG:
+	case ZPA_CTRL_REG3_REG:
+	case ZPA_THS_P_LOW_REG:
+	case ZPA_THS_P_HIGH_REG:
+		break;
+
+	default:
+		return -EINVAL;
+	}
+
+	if (value > U8_MAX)
+		return -ERANGE;
+
+	err = zpa_claim_direct_mode(indio_dev);
+	if (err < 0)
+		return err;
+
+	err = zpa_write_byte(indio_dev, reg, value);
+
+	zpa_release_direct_mode(indio_dev);
+	return err;
+}
+
+static int zpa_debugfs_reg_access(struct iio_dev *indio_dev,
+				  unsigned int    reg,
+				  unsigned int    writeval,
+				  unsigned int   *readval)
+{
+	if (readval)
+		return zpa_debugfs_read(indio_dev, reg, readval);
+
+	return zpa_debugfs_write(indio_dev, reg, writeval);
+}
+#else
+#define zpa_debugfs_ptr(_ptr) NULL
+#endif
+
+/******************************************************************************
+ * IIO device handling
+ ******************************************************************************/
+
+static int zpa_read_raw(struct iio_dev             *indio_dev,
+			struct iio_chan_spec const *chan,
+			int                        *val,
+			int                        *val2,
+			long                        mask)
+{
+	switch (mask) {
+	case IIO_CHAN_INFO_RAW:
+		return zpa_sample_oneshot(indio_dev, chan->type, val);
+
+	case IIO_CHAN_INFO_SCALE:
+		switch (chan->type) {
+		case IIO_PRESSURE:
+			/*
+			 * Pressure resolution is 1/64 Pascal. Scale to kPascal
+			 * as required by IIO ABI.
+			 */
+			*val = 0;
+			*val2 = 1000000 / 64;
+			return IIO_VAL_INT_PLUS_NANO;
+
+		case IIO_TEMP:
+			/*
+			 * Temperature follows the equation:
+			 *     Temp[degC] = Tempcode * 0.00649 - 176.83
+			 * where:
+			 *     Tempcode is composed the raw sampled 16 bits.
+			 *
+			 * Hence, to produce a temperature in milli-degrees
+			 * Celsius according to IIO ABI, we need to apply the
+			 * following equation to raw samples:
+			 *     Temp[milli degC] = (Tempcode + Offset) * Scale
+			 * where:
+			 *     Offset = -176.83 / 0.00649
+			 *     Scale = 0.00649 * 1000
+			 */
+			*val = 6;
+			*val2 = 490000;
+			return IIO_VAL_INT_PLUS_MICRO;
+
+		default:
+			BUG();

drivers/iio/pressure/zpa2326.c new file +49 -0

+static ssize_t zpa_show_frequency(struct device           *dev,
+				  struct device_attribute *attr,
+				  char                    *buf)
+{
+	const struct iio_dev *indio_dev = dev_to_iio_dev(dev);
+
+	return sprintf(buf, "%s\n", zpa_iio2priv(indio_dev)->frequency->hz);
+}
+
+/* Current hardware sampling frequency sysfs setter. */
+static ssize_t zpa_store_frequency(struct device           *dev,
+				   struct device_attribute *attr,
+				   const char              *buf,
+				   size_t                   len)
+{
+	struct iio_dev     *indio_dev = dev_to_iio_dev(dev);
+	struct zpa_private *priv = zpa_iio2priv(indio_dev);
+	int                 f, err;
+
+	/* Check if requested frequency is supported. */
+	for (f = 0; f < ARRAY_SIZE(zpa_sampling_frequencies); f++)
+		if (sysfs_streq(zpa_sampling_frequencies[f].hz, buf))
+			break;
+	if (f == ARRAY_SIZE(zpa_sampling_frequencies))
+		return -EINVAL;
+
+	/* Don't allow changing frequency if buffered sampling is ongoing. */
+	err = iio_device_claim_direct_mode(indio_dev);
+	if (err)
+		return err;
+
+	priv->frequency = &zpa_sampling_frequencies[f];
+
+	iio_device_release_direct_mode(indio_dev);
+
+	return len;
+}
+
+static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO,
+			      zpa_show_frequency,
+			      zpa_store_frequency);
+
+/* Expose supported hardware sampling frequencies (Hz) through sysfs. */
+static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("1 5 11 23");
+
+static struct attribute *zpa_attributes[] = {
+	&iio_dev_attr_sampling_frequency.dev_attr.attr,
+	&iio_const_attr_sampling_frequency_available.dev_attr.attr,
+	NULL

drivers/iio/pressure/zpa2326.c new file +101 -0

+		.scan_index             = 0,
+		.scan_type              = {
+			.sign                   = 'u',
+			.realbits               = 24,
+			.storagebits            = 32,
+			.endianness             = IIO_LE,
+		},
+		.info_mask_separate     = BIT(IIO_CHAN_INFO_RAW) |
+					  BIT(IIO_CHAN_INFO_SCALE),
+	},
+	[1] = {
+		.type                   = IIO_TEMP,
+		.channel                = 1,
+		.scan_index             = 1,
+		.scan_type              = {
+			.sign                   = 's',
+			.realbits               = 16,
+			.storagebits            = 16,
+			.endianness             = IIO_LE,
+		},
+		.info_mask_separate     = BIT(IIO_CHAN_INFO_RAW) |
+					  BIT(IIO_CHAN_INFO_SCALE) |
+					  BIT(IIO_CHAN_INFO_OFFSET),
+	},
+	[2] = IIO_CHAN_SOFT_TIMESTAMP(2),
+};
+
+static const struct iio_info zpa_info = {
+	.driver_module      = THIS_MODULE,
+	.attrs              = &zpa_attribute_group,
+	.read_raw           = zpa_read_raw,
+	.debugfs_reg_access = zpa_debugfs_ptr(zpa_debugfs_reg_access),
+	.validate_trigger   = zpa_validate_trigger,
+};
+
+/* Allocate and initialize a basic ZPA IIO device. */
+static struct iio_dev *zpa_create_iio(struct device        *device,
+				      const char           *name,
+				      const struct zpa_bus *bus)
+{
+	struct iio_dev *indio_dev;
+
+	/* Allocate space to hold IIO device internal state. */
+	indio_dev = devm_iio_device_alloc(device, sizeof(struct zpa_private));
+	if (!indio_dev)
+		return NULL;
+
+	/* Setup for userspace synchronous on demand sampling. */
+	indio_dev->modes = INDIO_DIRECT_MODE;
+	indio_dev->dev.parent = device;
+	indio_dev->channels = zpa_channels;
+	indio_dev->num_channels = ARRAY_SIZE(zpa_channels);
+	indio_dev->name = name;
+	indio_dev->info = &zpa_info;
+
+	/* Plug device's underlying bus abstraction. */
+	zpa_iio2priv(indio_dev)->bus = bus;
+
+	/* Init hardware sampling frequency to highest rate supported. */
+	zpa_iio2priv(indio_dev)->frequency = zpa_highest_frequency();
+
+	return indio_dev;
+}
+
+int zpa_probe(struct device        *slave,
+	      const char           *name,
+	      int                   irq,
+	      const struct zpa_bus *bus)
+{
+	struct iio_dev     *indio_dev = zpa_create_iio(slave, name, bus);
+	struct zpa_private *priv;
+	int                 err;
+
+	if (!indio_dev)
+		return -ENOMEM;
+
+	priv = zpa_iio2priv(indio_dev);
+
+	priv->vdd = devm_regulator_get(slave, "vdd");
+	if (IS_ERR(priv->vdd))
+		return PTR_ERR(priv->vdd);
+
+	err = zpa_power_on(indio_dev, priv);
+	if (err)
+		return err;
+
+	err = zpa_init_ring(slave, indio_dev, irq);
+	if (err)
+		goto disable;
+
+	err = zpa_init_trigger(slave, indio_dev, priv, irq);
+	if (err)
+		goto disable;
+
+	err = zpa_init_irq(slave, indio_dev, priv, irq);
+	if (err)
+		goto disable;
+
+	err = zpa_config_oneshot(indio_dev, irq);
+	if (err)
+		goto disable;

drivers/iio/pressure/zpa2326.c new file +31 -0

+	if (err) {
+		zpa_fini_runtime(slave);
+		goto off;
+	}
+
+	dev_dbg(slave, "%s barometer ready", name);
+	return 0;
+
+disable:
+	zpa_disable_device(indio_dev);
+off:
+	zpa_power_off(indio_dev, priv);
+	return err;
+}
+EXPORT_SYMBOL_GPL(zpa_probe);
+
+int zpa_remove(const struct device *slave)
+{
+	const struct iio_dev *indio_dev = dev_get_drvdata(slave);
+
+	zpa_fini_runtime(zpa_iio2slave(indio_dev));
+	zpa_disable_device(indio_dev);
+	zpa_power_off(indio_dev, zpa_iio2priv(indio_dev));
+
+	return 0;
+}
+EXPORT_SYMBOL_GPL(zpa_remove);
+
+MODULE_AUTHOR("Gregor Boirie <[email protected]>");
+MODULE_DESCRIPTION("Core driver for Murata ZPA2326 pressure sensor");
+MODULE_LICENSE("GPL v2");

drivers/iio/pressure/zpa2326.h new file +76 -0

new file mode 100644
index 0000000..df105cb
@@ -0,0 +1,76 @@
+/*
+ * Murata ZPA2326 pressure and temperature sensor IIO driver
+ *
+ * Copyright (c) 2016 Parrot S.A.
+ *
+ * Author: Gregor Boirie <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ */
+
+#ifndef _ZPA2326_H
+#define _ZPA2326_H
+
+#include <linux/iio/iio.h>
+
+#define ZPA_DEVICE_ID_REG              ((u8)0xf)
+#define ZPA_DEVICE_ID                  (0xb9)
+
+/*
+ * struct zpa_bus - underlying I2C / SPI bus adapter for zpa2326 driver
+ * @zpa_read_byte:  fetch and return a single byte from slave register
+ * @zpa_write_byte: store a single byte to slave register
+ * @zpa_read_block: fetch data block from multiple contiguous slave registers
+ *
+ * Abtract slave register accesses.
+ */
+struct zpa_bus {
+	int (*zpa_read_byte)(const struct iio_dev *indio_dev, u8 address);
+	int (*zpa_write_byte)(const struct iio_dev *indio_dev,
+			      u8                    address,
+			      u8                    value);
+	int (*zpa_read_block)(const struct iio_dev *indio_dev,
+			      u8                    address,
+			      u8                    length,
+			      u8                   *value);
+};
+
+static inline struct device *zpa_iio2slave(const struct iio_dev *indio_dev)
+{
+	return indio_dev->dev.parent;
+}
+
+/*
+ * zpa_probe() - instantiate and register core zpa2326 IIO device
+ * @slave: device the IIO device will be a child of
+ * @name:  arbitrary name identify the device
+ * @irq:   interrupt line, negative if none
+ * @bus:   underlying bus adapter
+ */
+int zpa_probe(struct device        *slave,
+	      const char           *name,
+	      int                   irq,
+	      const struct zpa_bus *bus);
+
+/*
+ * zpa_remove() - unregister and destroy core zpa2326 IIO device
+ * @slave: device the IIO device to remove is a child of
+ */
+int zpa_remove(const struct device *slave);
+
+#ifdef CONFIG_PM
+#include <linux/pm.h>
+extern const struct dev_pm_ops zpa_pm_ops;
+#define ZPA_PM_OPS (&zpa_pm_ops)
+#else
+#define ZPA_PM_OPS (NULL)
+#endif
+
+#endif

drivers/iio/pressure/zpa2326_i2c.c new file +188 -0

new file mode 100644
index 0000000..f43c41a
@@ -0,0 +1,188 @@
+/*
+ * Murata ZPA2326 I2C pressure and temperature sensor driver
+ *
+ * Copyright (c) 2016 Parrot S.A.
+ *
+ * Author: Gregor Boirie <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ */
+
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/of_device.h>
+#include "zpa2326.h"
+
+static const struct i2c_client *zpa_iio2client(const struct iio_dev *indio_dev)
+{
+	return to_i2c_client(zpa_iio2slave(indio_dev));
+}
+
+static int zpa_write_i2c_byte(const struct iio_dev *indio_dev, u8 address,
+			      u8 value)
+{
+	int                      err;
+	const struct i2c_client *client = zpa_iio2client(indio_dev);
+	u8                       buf[] = { address, value };
+	struct i2c_msg           msg = {
+		.addr  = client->addr,
+		.flags = client->flags,
+		.len   = ARRAY_SIZE(buf),
+		.buf   = buf
+	};
+
+	err = i2c_transfer(client->adapter, &msg, 1);
+	if (err < 0)
+		return err;
+
+	if (err != 1)
+		return -ENOMSG;
+
+	return 0;
+}
+
+static int _zpa_read_i2c_byte(const struct i2c_client *client, u8 address)
+{
+	int            err;
+	u8             byte;
+	struct i2c_msg msg[] = {
+		[0] = {
+			.addr  = client->addr,
+			.flags = client->flags,
+			.len   = 1,
+			.buf   = &address
+		},
+		[1] = {
+			.addr  = client->addr,
+			.flags = client->flags | I2C_M_RD,
+			.len   = 1,
+			.buf   = &byte
+		}
+	};
+
+	err = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
+	if (err < 0)
+		return err;
+
+	if (err != ARRAY_SIZE(msg))
+		return -ENOMSG;
+
+	return (int)byte;
+}
+
+static int zpa_read_i2c_byte(const struct iio_dev *indio_dev, u8 address)
+{
+	return _zpa_read_i2c_byte(zpa_iio2client(indio_dev), address);
+}
+
+static int zpa_read_i2c_block(const struct iio_dev *indio_dev,
+			      u8                    address,
+			      u8                    length,
+			      u8                   *value)
+{
+	int                      err;
+	const struct i2c_client *client = zpa_iio2client(indio_dev);
+	struct i2c_msg           msg[] = {
+		[0] = {
+			.addr  = client->addr,
+			.flags = client->flags,
+			.len   = 1,
+			.buf   = &address,
+		},
+		[1] = {
+			.addr  = client->addr,
+			.flags = client->flags | I2C_M_RD,
+			.len   = length,
+			.buf   = value
+		}
+	};
+
+	/* Set MSB to request register address auto increment. */
+	address |= (1U << 7);
+
+	err = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
+	if (err < 0)
+		return err;
+
+	if (err != ARRAY_SIZE(msg))
+		return -ENOMSG;
+
+	return 0;
+}
+
+static const struct zpa_bus zpa_i2c_bus = {
+	.zpa_read_byte  = &zpa_read_i2c_byte,
+	.zpa_write_byte = &zpa_write_i2c_byte,
+	.zpa_read_block = &zpa_read_i2c_block,
+};
+
+static int zpa_probe_i2c(struct i2c_client          *client,
+			 const struct i2c_device_id *id)
+{
+	int err;
+
+	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
+		return -ENODEV;
+
+	/*
+	 * Read identification register to check we are talking to the right
+	 * slave.
+	 */
+	err = _zpa_read_i2c_byte(client, ZPA_DEVICE_ID_REG);
+	if (err < 0)
+		return err;
+
+	/* Identification register bit 1 mirrors device address bit 0. */
+#define ZPA_SA0(_addr)          (_addr & BIT(0))
+#define ZPA_DEVICE_ID_SA0_SHIFT (1)
+	if (err != (ZPA_DEVICE_ID |
+		    (ZPA_SA0(client->addr) << ZPA_DEVICE_ID_SA0_SHIFT))) {
+		dev_err(&client->dev,
+			"found unexpected device with id %02x", err);
+		return -ENODEV;
+	}
+
+	return zpa_probe(&client->dev, id->name, client->irq, &zpa_i2c_bus);
+}
+
+static int zpa_remove_i2c(struct i2c_client *client)
+{
+	return zpa_remove(&client->dev);
+}
+
+static const struct i2c_device_id zpa_i2c_ids[] = {
+	{ "zpa2326", 0 },
+	{ },
+};
+MODULE_DEVICE_TABLE(i2c, zpa_i2c_ids);
+
+#if defined(CONFIG_OF)
+static const struct of_device_id zpa_i2c_matches[] = {
+	{ .compatible = "murata,zpa2326" },
+	{ }
+};
+MODULE_DEVICE_TABLE(of, zpa_i2c_matches);
+#endif
+
+static struct i2c_driver zpa_i2c_driver = {
+	.driver = {
+		.name           = "zpa2326-i2c",
+		.of_match_table = of_match_ptr(zpa_i2c_matches),
+		.pm             = ZPA_PM_OPS,
+	},
+	.probe    = zpa_probe_i2c,
+	.remove   = zpa_remove_i2c,
+	.id_table = zpa_i2c_ids,
+};
+module_i2c_driver(zpa_i2c_driver);
+
+MODULE_AUTHOR("Gregor Boirie <[email protected]>");
+MODULE_DESCRIPTION("I2C driver for Murata ZPA2326 pressure sensor");
+MODULE_LICENSE("GPL v2");

drivers/iio/pressure/zpa2326_spi.c new file +184 -0

new file mode 100644
index 0000000..a86e3b9
@@ -0,0 +1,184 @@
+/*
+ * Murata ZPA2326 SPI pressure and temperature sensor driver
+ *
+ * Copyright (c) 2016 Parrot S.A.
+ *
+ * Author: Gregor Boirie <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ */
+
+#include <linux/module.h>
+#include <linux/spi/spi.h>
+#include <linux/of_device.h>
+#include "zpa2326.h"
+
+/* Address bit 7 must be set to request a register read operation. */
+#define ZPA_SPI_ADDR_RD       BIT(7)
+/* Address bit 6 must be set to request register address auto increment. */
+#define ZPA_SPI_ADDR_AUTO_INC BIT(6)
+
+static struct spi_device *zpa_iio2spidev(const struct iio_dev *indio_dev)
+{
+	return to_spi_device(zpa_iio2slave(indio_dev));
+}
+
+static int zpa_write_spi_byte(const struct iio_dev *indio_dev,
+			      u8                    address,
+			      u8                    value)
+{
+	struct spi_transfer xfer;
+	u8                  buf[] = { address, value };
+
+	/* Zero-initialize to ensure forward compatibility. */
+	memset(&xfer, 0, sizeof(xfer));
+
+	/*
+	 * Register address write cycle followed by register content write
+	 * cycle.
+	 */
+	xfer.tx_buf = buf;
+	xfer.len = sizeof(buf);
+
+	return spi_sync_transfer(zpa_iio2spidev(indio_dev), &xfer, 1);
+}
+
+static int _zpa_read_spi_byte(struct spi_device *slave, u8 address)
+{
+	struct spi_transfer xfer[2];
+	u8                  buf;
+	int                 err;
+
+	/* Request read cycle. */
+	address |= ZPA_SPI_ADDR_RD;
+
+	/* Zero-initialize to ensure forward compatibility. */
+	memset(xfer, 0, sizeof(xfer));
+
+	/* Register address write cycle. */
+	xfer[0].tx_buf = &address;
+	xfer[0].len = sizeof(address);
+
+	/* Register content read cycle. */
+	xfer[1].rx_buf = &buf;
+	xfer[1].len = sizeof(buf);
+
+	err = spi_sync_transfer(slave, xfer, ARRAY_SIZE(xfer));
+	if (err)
+		return err;
+
+	return buf;
+}
+
+static int zpa_read_spi_byte(const struct iio_dev *indio_dev, u8 address)
+{
+	return _zpa_read_spi_byte(zpa_iio2spidev(indio_dev), address);
+}
+
+static int zpa_read_spi_block(const struct iio_dev *indio_dev,
+			      u8                    address,
+			      u8                    length,
+			      u8                   *value)
+{
+	struct spi_transfer xfer[2];
+
+	/* Request read cycle with register address auto increment. */
+	address |= ZPA_SPI_ADDR_RD | ZPA_SPI_ADDR_AUTO_INC;
+
+	/* Zero-initialize to ensure forward compatibility. */
+	memset(xfer, 0, sizeof(xfer));
+
+	/* First register address write cycle. */
+	xfer[0].tx_buf = &address;
+	xfer[0].len = sizeof(address);
+
+	/* Registers content read cycle (auto-increment). */
+	xfer[1].rx_buf = value;
+	xfer[1].len = length;
+
+	return spi_sync_transfer(zpa_iio2spidev(indio_dev), xfer,
+				 ARRAY_SIZE(xfer));
+}
+
+static const struct zpa_bus zpa_spi_bus = {
+	.zpa_read_byte  = &zpa_read_spi_byte,
+	.zpa_write_byte = &zpa_write_spi_byte,
+	.zpa_read_block = &zpa_read_spi_block,
+};
+
+static int zpa_probe_spi(struct spi_device *slave)
+{
+	int err;
+
+	/*
+	 * Enforce SPI slave settings to prevent from DT misconfiguration.
+	 *
+	 * Clock is idle high. Sampling happens on trailing edge, i.e., rising
+	 * edge. Maximum bus frequency is 1 mHz. Registers are 8 bits wide.
+	 */
+	slave->mode = SPI_MODE_3;
+	slave->max_speed_hz = min(slave->max_speed_hz, 1000U * 1000U);
+	slave->bits_per_word = 8;
+	err = spi_setup(slave);
+	if (err < 0)
+		return err;
+
+	/*
+	 * Read identification register to check we are talking to the right
+	 * slave.
+	 */
+	err = _zpa_read_spi_byte(slave, ZPA_DEVICE_ID_REG);
+	if (err < 0)
+		return err;
+
+	if (err != ZPA_DEVICE_ID) {
+		dev_err(&slave->dev,
+			"found unexpected device with id %02x", err);
+		return -ENODEV;
+	}
+
+	return zpa_probe(&slave->dev, spi_get_device_id(slave)->name,
+			 slave->irq, &zpa_spi_bus);
+}
+
+static int zpa_remove_spi(struct spi_device *slave)
+{
+	return zpa_remove(&slave->dev);
+}
+
+static const struct spi_device_id zpa_spi_ids[] = {
+	{ "zpa2326", 0 },
+	{ },
+};
+MODULE_DEVICE_TABLE(spi, zpa_spi_ids);
+
+#if defined(CONFIG_OF)
+static const struct of_device_id zpa_spi_matches[] = {
+	{ .compatible = "murata,zpa2326" },
+	{ }
+};
+MODULE_DEVICE_TABLE(of, zpa_spi_matches);
+#endif
+
+static struct spi_driver zpa_spi_driver = {
+	.driver = {
+		.name           = "zpa2326-spi",
+		.of_match_table = of_match_ptr(zpa_spi_matches),
+		.pm             = ZPA_PM_OPS,
+	},
+	.probe    = zpa_probe_spi,
+	.remove   = zpa_remove_spi,
+	.id_table = zpa_spi_ids,
+};
+module_spi_driver(zpa_spi_driver);
+
+MODULE_AUTHOR("Gregor Boirie <[email protected]>");
+MODULE_DESCRIPTION("SPI driver for Murata ZPA2326 pressure sensor");
+MODULE_LICENSE("GPL v2");

Introduce driver for Murata ZPA2326 pressure and temperature sensor:
http://www.murata.com/en-us/products/productdetail?partno=ZPA2326-0311A-R

Signed-off-by Gregor Boirie <[email protected]>

+++ b/Documentation/devicetree/bindings/iio/pressure/zpa2326.txt

Documentation/devicetree/bindings/iio/pressure/zpa2326.txt new file +3 -0

@@ -0,0 +1,23 @@
+Murata ZPA2326 pressure sensor
+
+Pressure sensor from Murata with SPI and I2C bus interfaces.

drivers/iio/pressure/Kconfig +21 -0

+config ZPA2326
+       tristate "Murata ZPA2326 pressure sensor driver"
+       depends on I2C || SPI
+       select IIO_BUFFER
+       select IIO_TRIGGERED_BUFFER
+       help
+         Say Y here to build support for the Murata ZPA2326 pressure and
+         temperature sensor.
+
+         To compile this driver as a module, choose M here: the module will
+         be called zpa2326.
+
+config ZPA2326_I2C
+       tristate "support I2C bus connection"
+       depends on I2C && ZPA2326
+       help
+         Say Y here to build I2C bus support for the Murata ZPA2326 pressure
+         and temperature sensor.
+
+         To compile this driver as a module, choose M here: the module will
+         be called zpa2326_i2c.

+#include <linux/sched.h>

+#include <linux/pm_runtime.h>

drivers/iio/pressure/zpa2326.c new file +13 -0

+/* Registers map. */
+#define ZPA_REF_P_XL_REG                     ((u8)0x8)
+#define ZPA_REF_P_L_REG                      ((u8)0x9)
+#define ZPA_REF_P_H_REG                      ((u8)0xa)
+#define ZPA_RES_CONF_REG                     ((u8)0x10)
+#define ZPA_CTRL_REG0_REG                    ((u8)0x20)
+#      define ZPA_CTRL_REG0_ONE_SHOT        BIT(0)
+#      define ZPA_CTRL_REG0_ENABLE          BIT(1)
+#define ZPA_CTRL_REG1_REG                    ((u8)0x21)
+#      define ZPA_CTRL_REG1_MASK_DATA_READY ((u8)BIT(2))
+#define ZPA_CTRL_REG2_REG                    ((u8)0x22)
+#      define ZPA_CTRL_REG2_SWRESET         BIT(2)
+#define ZPA_CTRL_REG3_REG                    ((u8)0x23)

+/******************************************************************************
+ * Various helpers
+ ******************************************************************************/

drivers/iio/pressure/zpa2326.c new file +7 -0

+/*
+ * Fetch multiple bytes from a block of contiguous slave registers.
+ * indio_dev: IIO device the slave is attached to.
+ * address:   start address of contiguous registers block to read from.
+ * length:    number of bytes to fetch.
+ * value:     location to store fetched data into.
+ *

drivers/iio/pressure/zpa2326.c new file +34 -0

+/*
+ * Retrieve the most recent pressure sample from hardware fifo.
+ *
+ * Note that ZPA2326 hardware fifo stores pressure samples only.
+ */
+static int zpa_dequeue_pressure(const struct iio_dev *indio_dev, u32 *pressure)
+{
+       int err = zpa_read_byte(indio_dev, ZPA_STATUS_REG);
+
+       if (err < 0)
+               return err;
+
+       if (!(err & ZPA_STATUS_P_OR)) {
+               /*
+                * Fifo has not overflown : retrieve newest sample. We need to
+                * pop values out until fifo is empty : last fetched pressure is
+                * the newest.
+                * In nominal cases, we should find a single queued sample only.
+                */
+               int cleared = -1;
+
+               do {
+                       err = zpa_read_block(indio_dev, ZPA_PRESS_OUT_XL_REG, 3,
+                                            (u8 *)pressure);
+                       if (err)
+                               return err;
+
+                       err = zpa_read_byte(indio_dev, ZPA_STATUS_REG);
+                       if (err < 0)
+                               return err;
+
+                       cleared++;
+               } while (!(err & ZPA_STATUS_FIFO_E));
+

drivers/iio/pressure/zpa2326.c new file +9 -0

+/* Enqueue new channel samples to IIO buffer. */
+static int zpa_fill_sample_buffer(struct iio_dev           *indio_dev,
+                                 const struct zpa_private *private)
+{
+       struct {
+               u32 pressure;
+               u16 temperature;
+               u64 timestamp;
+       }   sample;

drivers/iio/pressure/zpa2326.c new file +19 -0

+/* Request the PM layer to power supply the device. */
+static int zpa_resume(const struct iio_dev *indio_dev)
+{
+       struct device *slave = zpa_iio2slave(indio_dev);
+       int            err = pm_runtime_get_sync(slave);
+
+       if (err < 0)
+               goto put;
+
+       if (err > 0) {
+               /*
+                * Device was already power supplied: get it out of low power
+                * mode.
+                */
+               err = zpa_enable_device(indio_dev);
+               if (err)
+                       goto put;
+
+               /* Inform caller device was already power supplied. */

drivers/iio/pressure/zpa2326.c new file +12 -0

+static int zpa_suspend(const struct iio_dev *indio_dev)
+{
+       struct device *slave = zpa_iio2slave(indio_dev);
+       int            err = zpa_disable_device(indio_dev);
+
+       pm_runtime_mark_last_busy(slave);
+
+       if (err)
+               goto err;
+
+       err = pm_runtime_put_autosuspend(slave);
+       if (err) {

drivers/iio/pressure/zpa2326.c new file +22 -0

+
+/* Setup runtime power management with autosuspend support. */
+static void zpa_init_runtime(struct device *slave)
+{
+       pm_runtime_get_noresume(slave);
+       pm_runtime_set_active(slave);
+       pm_runtime_enable(slave);
+       pm_runtime_set_autosuspend_delay(slave, 1000);
+       pm_runtime_use_autosuspend(slave);
+       pm_runtime_mark_last_busy(slave);
+       pm_runtime_put_autosuspend(slave);
+}
+
+static void zpa_fini_runtime(struct device *slave)
+{
+       pm_runtime_disable(slave);
+       pm_runtime_set_suspended(slave);
+}
+#else /* !CONFIG_PM */
+static int zpa_resume(const struct iio_dev *indio_dev)
+{
+       return zpa_enable_device(indio_dev);

drivers/iio/pressure/zpa2326.c new file +7 -0

+static int zpa_acknowledge_irq(const struct iio_dev     *indio_dev,
+                              const struct zpa_private *private)
+{
+       /*
+        * Device works according to a level interrupt scheme: reading interrupt
+        * status de-asserts interrupt line.
+        */

drivers/iio/pressure/zpa2326.c new file +9 -0

+static irqreturn_t zpa_handle_threaded_irq(int irq, void *data)
+{
+       struct iio_dev     *indio_dev = (struct iio_dev *)data;
+       struct zpa_private *priv = zpa_iio2priv(indio_dev);
+       irqreturn_t         ret = IRQ_NONE;
+
+       priv->result = zpa_acknowledge_irq(indio_dev, priv);
+
+       if (indio_dev->currentmode == INDIO_BUFFER_SOFTWARE) {

+ return (!priv->result) ? IRQ_HANDLED : IRQ_NONE;

drivers/iio/pressure/zpa2326.c new file +8 -0

+/*
+ * Reject external trigger attachment if setting up continuous hardware sampling
+ * mode.
+ */
+static int zpa_validate_trigger(struct iio_dev     *indio_dev,
+                               struct iio_trigger *trigger)
+{
+       int ret = 0;

drivers/iio/pressure/zpa2326.c new file +36 -0

+static int zpa_debugfs_read(struct iio_dev *indio_dev,
+                           u8              reg,
+                           unsigned int   *value)
+{
+       int err;
+
+       switch (reg) {
+       case ZPA_REF_P_XL_REG:
+       case ZPA_REF_P_L_REG:
+       case ZPA_REF_P_H_REG:
+       case ZPA_DEVICE_ID_REG:
+       case ZPA_RES_CONF_REG:
+       case ZPA_CTRL_REG0_REG:
+       case ZPA_CTRL_REG1_REG:
+       case ZPA_CTRL_REG2_REG:
+       case ZPA_CTRL_REG3_REG:
+       case ZPA_INT_SOURCE_REG: /* Will acknowledge interrupts. */
+       case ZPA_THS_P_LOW_REG:
+       case ZPA_THS_P_HIGH_REG:
+       case ZPA_STATUS_REG:
+       case ZPA_PRESS_OUT_XL_REG:
+       case ZPA_PRESS_OUT_L_REG:
+       case ZPA_PRESS_OUT_H_REG:  /* Will pop samples out of hardware fifo. */
+       case ZPA_TEMP_OUT_L_REG:
+       case ZPA_TEMP_OUT_H_REG:
+               break;
+
+       default:
+               return -EINVAL;
+       }
+
+       err = zpa_claim_direct_mode(indio_dev);
+       if (err < 0)
+               return err;
+
+       err = zpa_read_byte(indio_dev, reg);

drivers/iio/pressure/zpa2326.c new file +20 -0

+static const struct iio_chan_spec zpa_channels[] = {
+       [0] = {
+               .type                   = IIO_PRESSURE,
+               .channel                = 0,
+               .scan_index             = 0,
+               .scan_type              = {
+                       .sign                   = 'u',
+                       .realbits               = 24,
+                       .storagebits            = 32,
+                       .endianness             = IIO_LE,
+               },
+               .info_mask_separate     = BIT(IIO_CHAN_INFO_RAW) |
+                                         BIT(IIO_CHAN_INFO_SCALE),
+       },
+       [1] = {
+               .type                   = IIO_TEMP,
+               .channel                = 1,
+               .scan_index             = 1,
+               .scan_type              = {
+                       .sign                   = 's',

drivers/iio/pressure/zpa2326_i2c.c new file +18 -0

+static int _zpa_read_i2c_byte(const struct i2c_client *client, u8 address)
+{
+       int            err;
+       u8             byte;
+       struct i2c_msg msg[] = {
+               [0] = {
+                       .addr  = client->addr,
+                       .flags = client->flags,
+                       .len   = 1,
+                       .buf   = &address
+               },
+               [1] = {
+                       .addr  = client->addr,
+                       .flags = client->flags | I2C_M_RD,
+                       .len   = 1,
+                       .buf   = &byte
+               }
+       };

drivers/iio/pressure/zpa2326_spi.c new file +16 -0

+static int _zpa_read_spi_byte(struct spi_device *slave, u8 address)
+{
+       struct spi_transfer xfer[2];
+       u8                  buf;
+       int                 err;
+
+       /* Request read cycle. */
+       address |= ZPA_SPI_ADDR_RD;
+
+       /* Zero-initialize to ensure forward compatibility. */
+       memset(xfer, 0, sizeof(xfer));
+
+       /* Register address write cycle. */
+       xfer[0].tx_buf = &address;
+       xfer[0].len = sizeof(address);
+

+#define ZPA_CONVERSION_TIMEOUT (HZ / 5)
ZPA2326_ prefix would be expected by convention

Review

Quoted 3 lines

(quoted diff) +2 -0

+
+/* Registers map. */

Register map

Quoted 1 line

+#define ZPA_REF_P_XL_REG ((u8)0x8)

do we really need u8 here?

why?