On 13/09/16 13:23, Gregor Boirie wrote: > 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 <gregor.boirie@xxxxxxxxxx> A nicely written driver for a bit of hardware with some crazy corners. Applied to the togreg branch of iio.git - initially pushed out as testing for the autobuilders to play with it. Thanks Jonathan > --- > .../devicetree/bindings/iio/pressure/zpa2326.txt | 31 + > drivers/iio/pressure/Kconfig | 22 + > drivers/iio/pressure/Makefile | 3 + > drivers/iio/pressure/zpa2326.c | 1735 ++++++++++++++++++++ > drivers/iio/pressure/zpa2326.h | 89 + > drivers/iio/pressure/zpa2326_i2c.c | 99 ++ > drivers/iio/pressure/zpa2326_spi.c | 103 ++ > 7 files changed, 2082 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 > > diff --git a/Documentation/devicetree/bindings/iio/pressure/zpa2326.txt b/Documentation/devicetree/bindings/iio/pressure/zpa2326.txt > new file mode 100644 > index 0000000..fb85de6 > --- /dev/null > +++ b/Documentation/devicetree/bindings/iio/pressure/zpa2326.txt > @@ -0,0 +1,31 @@ > +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 > + > +Recommended properties for SPI bus usage: > +- spi-max-frequency: maximum SPI bus frequency as documented in > + Documentation/devicetree/bindings/spi/spi-bus.txt > + > +Optional properties: > +- vref-supply: an optional regulator that needs to be on to provide VREF > + power to the sensor > +- vdd-supply: an optional regulator that needs to be on to provide VDD > + power to the sensor > +- interrupt-parent: phandle to the parent interrupt controller as documented in > + Documentation/devicetree/bindings/interrupt-controller/interrupts.txt > +- interrupts: interrupt mapping for IRQ as documented in > + Documentation/devicetree/bindings/interrupt-controller/interrupts.txt > + > +Example: > + > +zpa2326@5c { > + compatible = "murata,zpa2326"; > + reg = <0x5c>; > + interrupt-parent = <&gpio>; > + interrupts = <12>; > + vdd-supply = <&ldo_1v8_gnss>; > +}; > diff --git a/drivers/iio/pressure/Kconfig b/drivers/iio/pressure/Kconfig > index d130cdc..cc090d8 100644 > --- a/drivers/iio/pressure/Kconfig > +++ b/drivers/iio/pressure/Kconfig > @@ -187,4 +187,26 @@ 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" > + select IIO_BUFFER > + select IIO_TRIGGERED_BUFFER > + select REGMAP > + select ZPA2326_I2C if I2C > + select ZPA2326_SPI if SPI_MASTER > + 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 > + select REGMAP_I2C > + > +config ZPA2326_SPI > + tristate > + select REGMAP_SPI > + > endmenu > diff --git a/drivers/iio/pressure/Makefile b/drivers/iio/pressure/Makefile > index 7f395be..fff7718 100644 > --- a/drivers/iio/pressure/Makefile > +++ b/drivers/iio/pressure/Makefile > @@ -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 > diff --git a/drivers/iio/pressure/zpa2326.c b/drivers/iio/pressure/zpa2326.c > new file mode 100644 > index 0000000..19d2eb4 > --- /dev/null > +++ b/drivers/iio/pressure/zpa2326.c > @@ -0,0 +1,1735 @@ > +/* > + * Murata ZPA2326 pressure and temperature sensor IIO driver > + * > + * Copyright (c) 2016 Parrot S.A. > + * > + * Author: Gregor Boirie <gregor.boirie@xxxxxxxxxx> > + * > + * 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. > + */ > + > +/** > + * DOC: ZPA2326 theory of operations > + * > + * This driver supports %INDIO_DIRECT_MODE and %INDIO_BUFFER_TRIGGERED IIO > + * modes. > + * A internal hardware trigger is also implemented to dispatch registered IIO > + * trigger consumers upon "sample ready" interrupts. > + * > + * ZPA2326 hardware supports 2 sampling mode: one shot and continuous. > + * > + * A complete one shot sampling cycle gets device out of low power mode, > + * performs pressure and temperature measurements, then automatically switches > + * 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 > + * "sample ready" interrupt. > + * Typical software sequence of operations : > + * - get device out of low power mode, > + * - setup hardware sampling period, > + * - at end of period, upon data ready interrupt: pop pressure samples out of > + * hardware FIFO and fetch temperature sample > + * - when no longer needed, stop sampling process by putting device into > + * low power mode. > + * This mode is used to implement %INDIO_BUFFER_TRIGGERED mode if device tree > + * declares a valid interrupt line. In this case, the internal hardware trigger > + * drives acquisition. > + * > + * Note that hardware sampling frequency is taken into account only when > + * internal hardware trigger is attached 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. > + */ > + > +#include <linux/module.h> > +#include <linux/kernel.h> > +#include <linux/delay.h> > +#include <linux/interrupt.h> > +#include <linux/regulator/consumer.h> > +#include <linux/pm_runtime.h> > +#include <linux/regmap.h> > +#include <linux/iio/iio.h> > +#include <linux/iio/sysfs.h> > +#include <linux/iio/buffer.h> > +#include <linux/iio/trigger.h> > +#include <linux/iio/trigger_consumer.h> > +#include <linux/iio/triggered_buffer.h> > +#include "zpa2326.h" > + > +/* 200 ms should be enough for the longest conversion time in one-shot mode. */ > +#define ZPA2326_CONVERSION_JIFFIES (HZ / 5) > + > +/* There should be a 1 ms delay (Tpup) after getting out of reset. */ > +#define ZPA2326_TPUP_USEC_MIN (1000) > +#define ZPA2326_TPUP_USEC_MAX (2000) > + > +/** > + * struct zpa2326_frequency - Hardware sampling frequency descriptor > + * @hz : Frequency in Hertz. > + * @odr: Output Data Rate word as expected by %ZPA2326_CTRL_REG3_REG. > + */ > +struct zpa2326_frequency { > + int hz; > + u16 odr; > +}; > + > +/* > + * Keep these in strict ascending order: last array entry is expected to > + * correspond to the highest sampling frequency. > + */ > +static const struct zpa2326_frequency zpa2326_sampling_frequencies[] = { > + { .hz = 1, .odr = 1 << ZPA2326_CTRL_REG3_ODR_SHIFT }, > + { .hz = 5, .odr = 5 << ZPA2326_CTRL_REG3_ODR_SHIFT }, > + { .hz = 11, .odr = 6 << ZPA2326_CTRL_REG3_ODR_SHIFT }, > + { .hz = 23, .odr = 7 << ZPA2326_CTRL_REG3_ODR_SHIFT }, > +}; > + > +/* Return the highest hardware sampling frequency available. */ > +static const struct zpa2326_frequency *zpa2326_highest_frequency(void) > +{ > + return &zpa2326_sampling_frequencies[ > + ARRAY_SIZE(zpa2326_sampling_frequencies) - 1]; > +} > + > +/** > + * struct zpa_private - Per-device internal private state > + * @timestamp: Buffered samples ready datum. > + * @regmap: Underlying I2C / SPI bus adapter used to abstract slave register > + * accesses. > + * @result: Allows sampling logic to get completion status of operations > + * that interrupt handlers perform asynchronously. > + * @data_ready: Interrupt handler uses this to wake user context up at sampling > + * operation completion. > + * @trigger: Optional hardware / interrupt driven trigger used to notify > + * external devices a new sample is ready. > + * @waken: Flag indicating whether or not device has just been powered on. > + * @irq: Optional interrupt line: negative or zero if not declared into > + * DT, in which case sampling logic keeps polling status register > + * to detect completion. > + * @frequency: Current hardware sampling frequency. > + * @vref: Power / voltage reference. > + * @vdd: Power supply. > + */ > +struct zpa2326_private { > + s64 timestamp; > + struct regmap *regmap; > + int result; > + struct completion data_ready; > + struct iio_trigger *trigger; > + bool waken; > + int irq; > + const struct zpa2326_frequency *frequency; > + struct regulator *vref; > + struct regulator *vdd; > +}; > + > +#define zpa2326_err(_idev, _format, _arg...) \ > + dev_err(_idev->dev.parent, _format, ##_arg) > + > +#define zpa2326_warn(_idev, _format, _arg...) \ > + dev_warn(_idev->dev.parent, _format, ##_arg) > + > +#ifdef DEBUG > +#define zpa2326_dbg(_idev, _format, _arg...) \ > + dev_dbg(_idev->dev.parent, _format, ##_arg) > +#else > +#define zpa2326_dbg(_idev, _format, _arg...) > +#endif > + > +bool zpa2326_isreg_writeable(struct device *dev, unsigned int reg) > +{ > + switch (reg) { > + case ZPA2326_REF_P_XL_REG: > + case ZPA2326_REF_P_L_REG: > + case ZPA2326_REF_P_H_REG: > + case ZPA2326_RES_CONF_REG: > + case ZPA2326_CTRL_REG0_REG: > + case ZPA2326_CTRL_REG1_REG: > + case ZPA2326_CTRL_REG2_REG: > + case ZPA2326_CTRL_REG3_REG: > + case ZPA2326_THS_P_LOW_REG: > + case ZPA2326_THS_P_HIGH_REG: > + return true; > + > + default: > + return false; > + } > +} > +EXPORT_SYMBOL_GPL(zpa2326_isreg_writeable); > + > +bool zpa2326_isreg_readable(struct device *dev, unsigned int reg) > +{ > + switch (reg) { > + case ZPA2326_REF_P_XL_REG: > + case ZPA2326_REF_P_L_REG: > + case ZPA2326_REF_P_H_REG: > + case ZPA2326_DEVICE_ID_REG: > + case ZPA2326_RES_CONF_REG: > + case ZPA2326_CTRL_REG0_REG: > + case ZPA2326_CTRL_REG1_REG: > + case ZPA2326_CTRL_REG2_REG: > + case ZPA2326_CTRL_REG3_REG: > + case ZPA2326_INT_SOURCE_REG: > + case ZPA2326_THS_P_LOW_REG: > + case ZPA2326_THS_P_HIGH_REG: > + case ZPA2326_STATUS_REG: > + case ZPA2326_PRESS_OUT_XL_REG: > + case ZPA2326_PRESS_OUT_L_REG: > + case ZPA2326_PRESS_OUT_H_REG: > + case ZPA2326_TEMP_OUT_L_REG: > + case ZPA2326_TEMP_OUT_H_REG: > + return true; > + > + default: > + return false; > + } > +} > +EXPORT_SYMBOL_GPL(zpa2326_isreg_readable); > + > +bool zpa2326_isreg_precious(struct device *dev, unsigned int reg) > +{ > + switch (reg) { > + case ZPA2326_INT_SOURCE_REG: > + case ZPA2326_PRESS_OUT_H_REG: > + return true; > + > + default: > + return false; > + } > +} > +EXPORT_SYMBOL_GPL(zpa2326_isreg_precious); > + > +/** > + * zpa2326_enable_device() - Enable device, i.e. get out of low power mode. > + * @indio_dev: The IIO device associated with the hardware to enable. > + * > + * Required to access complete register space and to perform any sampling > + * or control operations. > + * > + * Return: Zero when successful, a negative error code otherwise. > + */ > +static int zpa2326_enable_device(const struct iio_dev *indio_dev) > +{ > + int err; > + > + err = regmap_write(((struct zpa2326_private *) > + iio_priv(indio_dev))->regmap, > + ZPA2326_CTRL_REG0_REG, ZPA2326_CTRL_REG0_ENABLE); > + if (err) { > + zpa2326_err(indio_dev, "failed to enable device (%d)", err); > + return err; > + } > + > + zpa2326_dbg(indio_dev, "enabled"); > + > + return 0; > +} > + > +/** > + * zpa2326_sleep() - Disable device, i.e. switch to low power mode. > + * @indio_dev: The IIO device associated with the hardware to disable. > + * > + * Only %ZPA2326_DEVICE_ID_REG and %ZPA2326_CTRL_REG0_REG registers may be > + * accessed once device is in the disabled state. > + * > + * Return: Zero when successful, a negative error code otherwise. > + */ > +static int zpa2326_sleep(const struct iio_dev *indio_dev) > +{ > + int err; > + > + err = regmap_write(((struct zpa2326_private *) > + iio_priv(indio_dev))->regmap, > + ZPA2326_CTRL_REG0_REG, 0); > + if (err) { > + zpa2326_err(indio_dev, "failed to sleep (%d)", err); > + return err; > + } > + > + zpa2326_dbg(indio_dev, "sleeping"); > + > + return 0; > +} > + > +/** > + * zpa2326_reset_device() - Reset device to default hardware state. > + * @indio_dev: The IIO device associated with the hardware to reset. > + * > + * Disable sampling and empty hardware FIFO. > + * Device must be enabled before reset, i.e. not in low power mode. > + * > + * Return: Zero when successful, a negative error code otherwise. > + */ > +static int zpa2326_reset_device(const struct iio_dev *indio_dev) > +{ > + int err; > + > + err = regmap_write(((struct zpa2326_private *) > + iio_priv(indio_dev))->regmap, > + ZPA2326_CTRL_REG2_REG, ZPA2326_CTRL_REG2_SWRESET); > + if (err) { > + zpa2326_err(indio_dev, "failed to reset device (%d)", err); > + return err; > + } > + > + usleep_range(ZPA2326_TPUP_USEC_MIN, ZPA2326_TPUP_USEC_MAX); > + > + zpa2326_dbg(indio_dev, "reset"); > + > + return 0; > +} > + > +/** > + * zpa2326_start_oneshot() - Start a single sampling cycle, i.e. in one shot > + * mode. > + * @indio_dev: The IIO device associated with the sampling hardware. > + * > + * Device must have been previously enabled and configured for one shot mode. > + * Device will be switched back to low power mode at end of cycle. > + * > + * Return: Zero when successful, a negative error code otherwise. > + */ > +static int zpa2326_start_oneshot(const struct iio_dev *indio_dev) > +{ > + int err; > + > + err = regmap_write(((struct zpa2326_private *) > + iio_priv(indio_dev))->regmap, > + ZPA2326_CTRL_REG0_REG, > + ZPA2326_CTRL_REG0_ENABLE | > + ZPA2326_CTRL_REG0_ONE_SHOT); > + if (err) { > + zpa2326_err(indio_dev, "failed to start one shot cycle (%d)", > + err); > + return err; > + } > + > + zpa2326_dbg(indio_dev, "one shot cycle started"); > + > + return 0; > +} > + > +/** > + * zpa2326_power_on() - Power on device to allow subsequent configuration. > + * @indio_dev: The IIO device associated with the sampling hardware. > + * @private: Internal private state related to @indio_dev. > + * > + * 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. > + * > + * Return: Zero when successful, a negative error code otherwise. > + */ > +static int zpa2326_power_on(const struct iio_dev *indio_dev, > + const struct zpa2326_private *private) > +{ > + int err; > + > + err = regulator_enable(private->vref); > + if (err) > + return err; > + > + err = regulator_enable(private->vdd); > + if (err) > + goto vref; > + > + zpa2326_dbg(indio_dev, "powered on"); > + > + err = zpa2326_enable_device(indio_dev); > + if (err) > + goto vdd; > + > + err = zpa2326_reset_device(indio_dev); > + if (err) > + goto sleep; > + > + return 0; > + > +sleep: > + zpa2326_sleep(indio_dev); > +vdd: > + regulator_disable(private->vdd); > +vref: > + regulator_disable(private->vref); > + > + zpa2326_dbg(indio_dev, "powered off"); > + > + return err; > +} > + > +/** > + * zpa2326_power_off() - Power off device, i.e. disable attached power > + * regulators. > + * @indio_dev: The IIO device associated with the sampling hardware. > + * @private: Internal private state related to @indio_dev. > + * > + * Return: Zero when successful, a negative error code otherwise. > + */ > +static void zpa2326_power_off(const struct iio_dev *indio_dev, > + const struct zpa2326_private *private) > +{ > + regulator_disable(private->vdd); > + regulator_disable(private->vref); > + > + zpa2326_dbg(indio_dev, "powered off"); > +} > + > +/** > + * zpa2326_config_oneshot() - Setup device for one shot / on demand mode. > + * @indio_dev: The IIO device associated with the sampling hardware. > + * @irq: Optional interrupt line the hardware uses to notify new data > + * samples are ready. Negative or zero values indicate no interrupts > + * are available, meaning polling is required. > + * > + * 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 > + * zpa2326_config_oneshot(). > + * > + * Return: Zero when successful, a negative error code otherwise. > + */ > +static int zpa2326_config_oneshot(const struct iio_dev *indio_dev, > + int irq) > +{ > + struct regmap *regs = ((struct zpa2326_private *) > + iio_priv(indio_dev))->regmap; > + const struct zpa2326_frequency *freq = zpa2326_highest_frequency(); > + int err; > + > + /* Setup highest available Output Data Rate for one shot mode. */ > + err = regmap_write(regs, ZPA2326_CTRL_REG3_REG, freq->odr); > + if (err) > + return err; > + > + if (irq > 0) { > + /* Request interrupt when new sample is available. */ > + err = regmap_write(regs, ZPA2326_CTRL_REG1_REG, > + (u8)~ZPA2326_CTRL_REG1_MASK_DATA_READY); > + > + if (err) { > + dev_err(indio_dev->dev.parent, > + "failed to setup one shot mode (%d)", err); > + return err; > + } > + } > + > + zpa2326_dbg(indio_dev, "one shot mode setup @%dHz", freq->hz); > + > + return 0; > +} > + > +/** > + * zpa2326_clear_fifo() - Clear remaining entries in hardware FIFO. > + * @indio_dev: The IIO device associated with the sampling hardware. > + * @min_count: Number of samples present within 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. > + * > + * Return: Zero when successful, a negative error code otherwise. > + */ > +static int zpa2326_clear_fifo(const struct iio_dev *indio_dev, > + unsigned int min_count) > +{ > + struct regmap *regs = ((struct zpa2326_private *) > + iio_priv(indio_dev))->regmap; > + int err; > + unsigned int val; > + > + if (!min_count) { > + /* > + * No hint: read status register to determine whether FIFO is > + * empty or not. > + */ > + err = regmap_read(regs, ZPA2326_STATUS_REG, &val); > + > + if (err < 0) > + goto err; > + > + if (val & ZPA2326_STATUS_FIFO_E) > + /* Fifo is empty: nothing to trash. */ > + return 0; > + } > + > + /* Clear FIFO. */ > + do { > + /* > + * A single fetch from pressure MSB register is enough to pop > + * values out of FIFO. > + */ > + err = regmap_read(regs, ZPA2326_PRESS_OUT_H_REG, &val); > + 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 = regmap_read(regs, ZPA2326_STATUS_REG, &val); > + if (err < 0) > + goto err; > + > + } while (!(val & ZPA2326_STATUS_FIFO_E)); > + > + zpa2326_dbg(indio_dev, "FIFO cleared"); > + > + return 0; > + > +err: > + zpa2326_err(indio_dev, "failed to clear FIFO (%d)", err); > + > + return err; > +} > + > +/** > + * zpa2326_dequeue_pressure() - Retrieve the most recent pressure sample from > + * hardware FIFO. > + * @indio_dev: The IIO device associated with the sampling hardware. > + * @pressure: Sampled pressure output. > + * > + * Note that ZPA2326 hardware FIFO stores pressure samples only. > + * > + * Return: Zero when successful, a negative error code otherwise. > + */ > +static int zpa2326_dequeue_pressure(const struct iio_dev *indio_dev, > + u32 *pressure) > +{ > + struct regmap *regs = ((struct zpa2326_private *) > + iio_priv(indio_dev))->regmap; > + unsigned int val; > + int err; > + int cleared = -1; > + > + err = regmap_read(regs, ZPA2326_STATUS_REG, &val); > + if (err < 0) > + return err; > + > + *pressure = 0; > + > + if (val & ZPA2326_STATUS_P_OR) { > + /* > + * Fifo overrun : first sample dequeued from FIFO is the > + * newest. > + */ > + zpa2326_warn(indio_dev, "FIFO overflow"); > + > + err = regmap_bulk_read(regs, ZPA2326_PRESS_OUT_XL_REG, pressure, > + 3); > + if (err) > + return err; > + > +#define ZPA2326_FIFO_DEPTH (16U) > + /* Hardware FIFO may hold no more than 16 pressure samples. */ > + return zpa2326_clear_fifo(indio_dev, ZPA2326_FIFO_DEPTH - 1); > + } > + > + /* > + * 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. > + */ > + do { > + err = regmap_bulk_read(regs, ZPA2326_PRESS_OUT_XL_REG, pressure, > + 3); > + if (err) > + return err; > + > + err = regmap_read(regs, ZPA2326_STATUS_REG, &val); > + if (err < 0) > + return err; > + > + cleared++; > + } while (!(val & ZPA2326_STATUS_FIFO_E)); > + > + if (cleared) > + /* > + * Samples were pushed by hardware during previous rounds but we > + * didn't consume them fast enough: inform user. > + */ > + zpa2326_dbg(indio_dev, "cleared %d FIFO entries", cleared); > + > + return 0; > +} > + > +/** > + * zpa2326_fill_sample_buffer() - Enqueue new channel samples to IIO buffer. > + * @indio_dev: The IIO device associated with the sampling hardware. > + * @private: Internal private state related to @indio_dev. > + * > + * Return: Zero when successful, a negative error code otherwise. > + */ > +static int zpa2326_fill_sample_buffer(struct iio_dev *indio_dev, > + const struct zpa2326_private *private) > +{ > + struct { > + u32 pressure; > + u16 temperature; > + u64 timestamp; > + } sample; > + int err; > + > + if (test_bit(0, indio_dev->active_scan_mask)) { > + /* Get current pressure from hardware FIFO. */ > + err = zpa2326_dequeue_pressure(indio_dev, &sample.pressure); > + if (err) { > + zpa2326_warn(indio_dev, "failed to fetch pressure (%d)", > + err); > + return err; > + } > + } > + > + if (test_bit(1, indio_dev->active_scan_mask)) { > + /* Get current temperature. */ > + err = regmap_bulk_read(private->regmap, ZPA2326_TEMP_OUT_L_REG, > + &sample.temperature, 2); > + if (err) { > + zpa2326_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 > + * zpa2326_handle_irq(), > + * - or oneshot completion polling machinery : see > + * zpa2326_trigger_handler(). > + */ > + zpa2326_dbg(indio_dev, "filling raw samples buffer"); > + > + iio_push_to_buffers_with_timestamp(indio_dev, &sample, > + private->timestamp); > + > + return 0; > +} > + > +#ifdef CONFIG_PM > +static int zpa2326_runtime_suspend(struct device *parent) > +{ > + const struct iio_dev *indio_dev = dev_get_drvdata(parent); > + > + if (pm_runtime_autosuspend_expiration(parent)) > + /* Userspace changed autosuspend delay. */ > + return -EAGAIN; > + > + zpa2326_power_off(indio_dev, iio_priv(indio_dev)); > + > + return 0; > +} > + > +static int zpa2326_runtime_resume(struct device *parent) > +{ > + const struct iio_dev *indio_dev = dev_get_drvdata(parent); > + > + return zpa2326_power_on(indio_dev, iio_priv(indio_dev)); > +} > + > +const struct dev_pm_ops zpa2326_pm_ops = { > + SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, > + pm_runtime_force_resume) > + SET_RUNTIME_PM_OPS(zpa2326_runtime_suspend, zpa2326_runtime_resume, > + NULL) > +}; > +EXPORT_SYMBOL_GPL(zpa2326_pm_ops); > + > +/** > + * zpa2326_resume() - Request the PM layer to power supply the device. > + * @indio_dev: The IIO device associated with the sampling hardware. > + * > + * Return: > + * < 0 - a negative error code meaning failure ; > + * 0 - success, device has just been powered up ; > + * 1 - success, device was already powered. > + */ > +static int zpa2326_resume(const struct iio_dev *indio_dev) > +{ > + int err; > + > + err = pm_runtime_get_sync(indio_dev->dev.parent); > + if (err < 0) > + return err; > + > + if (err > 0) { > + /* > + * Device was already power supplied: get it out of low power > + * mode and inform caller. > + */ > + zpa2326_enable_device(indio_dev); > + return 1; > + } > + > + /* Inform caller device has just been brought back to life. */ > + return 0; > +} > + > +/** > + * zpa2326_suspend() - Schedule a power down using autosuspend feature of PM > + * layer. > + * @indio_dev: The IIO device associated with the sampling hardware. > + * > + * Device is switched to low power mode at first to save power even when > + * attached regulator is a "dummy" one. > + */ > +static void zpa2326_suspend(struct iio_dev *indio_dev) > +{ > + struct device *parent = indio_dev->dev.parent; > + > + zpa2326_sleep(indio_dev); > + > + pm_runtime_mark_last_busy(parent); > + pm_runtime_put_autosuspend(parent); > +} > + > +static void zpa2326_init_runtime(struct device *parent) > +{ > + pm_runtime_get_noresume(parent); > + pm_runtime_set_active(parent); > + pm_runtime_enable(parent); > + pm_runtime_set_autosuspend_delay(parent, 1000); > + pm_runtime_use_autosuspend(parent); > + pm_runtime_mark_last_busy(parent); > + pm_runtime_put_autosuspend(parent); > +} > + > +static void zpa2326_fini_runtime(struct device *parent) > +{ > + pm_runtime_disable(parent); > + pm_runtime_set_suspended(parent); > +} > +#else /* !CONFIG_PM */ > +static int zpa2326_resume(const struct iio_dev *indio_dev) > +{ > + zpa2326_enable_device(indio_dev); > + > + return 0; > +} > + > +static void zpa2326_suspend(struct iio_dev *indio_dev) > +{ > + zpa2326_sleep(indio_dev); > +} > + > +#define zpa2326_init_runtime(_parent) > +#define zpa2326_fini_runtime(_parent) > +#endif /* !CONFIG_PM */ > + > +/** > + * zpa2326_handle_irq() - Process hardware interrupts. > + * @irq: Interrupt line the hardware uses to notify new data has arrived. > + * @data: The IIO device associated with the sampling hardware. > + * > + * Timestamp buffered samples as soon as possible then schedule threaded bottom > + * half. > + * > + * Return: Always successful. > + */ > +static irqreturn_t zpa2326_handle_irq(int irq, void *data) > +{ > + struct iio_dev *indio_dev = (struct iio_dev *)data; > + > + if (iio_buffer_enabled(indio_dev)) { > + /* Timestamping needed for buffered sampling only. */ > + ((struct zpa2326_private *) > + iio_priv(indio_dev))->timestamp = iio_get_time_ns(indio_dev); > + } > + > + return IRQ_WAKE_THREAD; > +} > + > +/** > + * zpa2326_handle_threaded_irq() - Interrupt bottom-half handler. > + * @irq: Interrupt line the hardware uses to notify new data has arrived. > + * @data: The IIO device associated with the sampling hardware. > + * > + * 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 zpa2326_handle_threaded_irq() is > + * called from within a thread, i.e. not called from hard interrupt context. > + * > + * When device is using its own internal hardware trigger in continuous sampling > + * mode, data are available into hardware FIFO once interrupt has occurred. All > + * we have to do is to dispatch the trigger, which in turn will fetch data and > + * fill IIO buffer. > + * > + * When not using its own internal hardware trigger, the device has been > + * configured in one-shot mode either by an external trigger or the IIO read_raw > + * hook. This means one of the latter is currently waiting for sampling > + * completion, in which case we must simply wake it up. > + * > + * See zpa2326_trigger_handler(). > + * > + * Return: > + * %IRQ_NONE - no consistent interrupt happened ; > + * %IRQ_HANDLED - there was new samples available. > + */ > +static irqreturn_t zpa2326_handle_threaded_irq(int irq, void *data) > +{ > + struct iio_dev *indio_dev = (struct iio_dev *)data; > + struct zpa2326_private *priv = iio_priv(indio_dev); > + unsigned int val; > + bool cont; > + irqreturn_t ret = IRQ_NONE; > + > + /* > + * Are we using our own internal trigger in triggered buffer mode, i.e., > + * currently working in continuous sampling mode ? > + */ > + cont = (iio_buffer_enabled(indio_dev) && > + iio_trigger_using_own(indio_dev)); > + > + /* > + * Device works according to a level interrupt scheme: reading interrupt > + * status de-asserts interrupt line. > + */ > + priv->result = regmap_read(priv->regmap, ZPA2326_INT_SOURCE_REG, &val); > + if (priv->result < 0) { > + if (cont) > + return IRQ_NONE; > + > + goto complete; > + } > + > + /* Data ready is the only interrupt source we requested. */ > + if (!(val & ZPA2326_INT_SOURCE_DATA_READY)) { > + /* > + * 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. > + */ > + zpa2326_warn(indio_dev, "unexpected interrupt status %02x", > + val); > + > + if (cont) > + return IRQ_NONE; > + > + priv->result = -ENODATA; > + goto complete; > + } > + > + /* New sample available: dispatch internal trigger consumers. */ > + iio_trigger_poll_chained(priv->trigger); > + > + if (cont) > + /* > + * Internal hardware trigger has been scheduled above : it will > + * fetch data on its own. > + */ > + return IRQ_HANDLED; > + > + ret = IRQ_HANDLED; > + > +complete: > + /* > + * Wake up direct or externaly triggered buffer mode waiters: see > + * zpa2326_sample_oneshot() and zpa2326_trigger_handler(). > + */ > + complete(&priv->data_ready); > + > + return ret; > +} > + > +/** > + * zpa2326_wait_oneshot_completion() - Wait for oneshot data ready interrupt. > + * @indio_dev: The IIO device associated with the sampling hardware. > + * @private: Internal private state related to @indio_dev. > + * > + * Return: Zero when successful, a negative error code otherwise. > + */ > +static int zpa2326_wait_oneshot_completion(const struct iio_dev *indio_dev, > + struct zpa2326_private *private) > +{ > + int ret; > + unsigned int val; > + > + zpa2326_dbg(indio_dev, "waiting for one shot completion interrupt"); > + > + ret = wait_for_completion_interruptible_timeout( > + &private->data_ready, ZPA2326_CONVERSION_JIFFIES); > + if (ret > 0) > + /* > + * Interrupt handler completed before timeout: return operation > + * status. > + */ > + return private->result; > + > + /* Clear all interrupts just to be sure. */ > + regmap_read(private->regmap, ZPA2326_INT_SOURCE_REG, &val); > + > + if (!ret) > + /* Timed out. */ > + ret = -ETIME; > + > + if (ret != -ERESTARTSYS) > + zpa2326_warn(indio_dev, "no one shot interrupt occurred (%d)", > + ret); > + > + return ret; > +} > + > +static int zpa2326_init_managed_irq(struct device *parent, > + struct iio_dev *indio_dev, > + struct zpa2326_private *private, > + int irq) > +{ > + int err; > + > + private->irq = irq; > + > + if (irq <= 0) { > + /* > + * Platform declared no interrupt line: device will be polled > + * for data availability. > + */ > + dev_info(parent, "no interrupt found, running in polling mode"); > + return 0; > + } > + > + init_completion(&private->data_ready); > + > + /* Request handler to be scheduled into threaded interrupt context. */ > + err = devm_request_threaded_irq(parent, irq, zpa2326_handle_irq, > + zpa2326_handle_threaded_irq, > + IRQF_TRIGGER_RISING | IRQF_ONESHOT, > + dev_name(parent), indio_dev); > + if (err) { > + dev_err(parent, "failed to request interrupt %d (%d)", irq, > + err); > + return err; > + } > + > + dev_info(parent, "using interrupt %d", irq); > + > + return 0; > +} > + > +/** > + * zpa2326_poll_oneshot_completion() - Actively poll for one shot data ready. > + * @indio_dev: The IIO device associated with the sampling hardware. > + * > + * Loop over registers content to detect end of sampling cycle. Used when DT > + * declared no valid interrupt lines. > + * > + * Return: Zero when successful, a negative error code otherwise. > + */ > +static int zpa2326_poll_oneshot_completion(const struct iio_dev *indio_dev) > +{ > + unsigned long tmout = jiffies + ZPA2326_CONVERSION_JIFFIES; > + struct regmap *regs = ((struct zpa2326_private *) > + iio_priv(indio_dev))->regmap; > + unsigned int val; > + int err; > + > + zpa2326_dbg(indio_dev, "polling for one shot completion"); > + > + /* > + * 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 = regmap_read(regs, ZPA2326_CTRL_REG0_REG, &val); > + if (err < 0) > + goto err; > + > + if (!(val & ZPA2326_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 = regmap_read(regs, ZPA2326_STATUS_REG, &val); > + if (err < 0) > + goto err; > + > + if (!(val & ZPA2326_STATUS_P_DA)) { > + /* No sample available. */ > + err = -ENODATA; > + goto err; > + } > + > + return 0; > + > +err: > + zpa2326_warn(indio_dev, "failed to poll one shot completion (%d)", err); > + > + return err; > +} > + > +/** > + * zpa2326_fetch_raw_sample() - Retrieve a raw sample and convert it to CPU > + * endianness. > + * @indio_dev: The IIO device associated with the sampling hardware. > + * @type: Type of measurement / channel to fetch from. > + * @value: Sample output. > + * > + * Return: Zero when successful, a negative error code otherwise. > + */ > +static int zpa2326_fetch_raw_sample(const struct iio_dev *indio_dev, > + enum iio_chan_type type, > + int *value) > +{ > + struct regmap *regs = ((struct zpa2326_private *) > + iio_priv(indio_dev))->regmap; > + int err; > + > + switch (type) { > + case IIO_PRESSURE: > + zpa2326_dbg(indio_dev, "fetching raw pressure sample"); > + > + err = regmap_bulk_read(regs, ZPA2326_PRESS_OUT_XL_REG, value, > + 3); > + if (err) { > + zpa2326_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: > + zpa2326_dbg(indio_dev, "fetching raw temperature sample"); > + > + err = regmap_bulk_read(regs, ZPA2326_TEMP_OUT_L_REG, value, 2); > + if (err) { > + zpa2326_warn(indio_dev, > + "failed to fetch temperature (%d)", err); > + return err; > + } > + > + /* Temperature is a 16 bits wide little-endian signed int. */ > + *value = (int)le16_to_cpup((__le16 *)value); > + > + return IIO_VAL_INT; > + > + default: > + return -EINVAL; > + } > +} > + > +/** > + * zpa2326_sample_oneshot() - Perform a complete one shot sampling cycle. > + * @indio_dev: The IIO device associated with the sampling hardware. > + * @type: Type of measurement / channel to fetch from. > + * @value: Sample output. > + * > + * Return: Zero when successful, a negative error code otherwise. > + */ > +static int zpa2326_sample_oneshot(struct iio_dev *indio_dev, > + enum iio_chan_type type, > + int *value) > +{ > + int ret; > + struct zpa2326_private *priv; > + > + ret = iio_device_claim_direct_mode(indio_dev); > + if (ret) > + return ret; > + > + ret = zpa2326_resume(indio_dev); > + if (ret < 0) > + goto release; > + > + priv = iio_priv(indio_dev); > + > + if (ret > 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) { > + ret = zpa2326_clear_fifo(indio_dev, 0); > + if (ret) > + goto suspend; > + } > + } else { > + /* > + * We have just been power supplied, i.e. device is in default > + * "out of reset" state, meaning we need to reconfigure it > + * entirely. > + */ > + ret = zpa2326_config_oneshot(indio_dev, priv->irq); > + if (ret) > + goto suspend; > + } > + > + /* Start a sampling cycle in oneshot mode. */ > + ret = zpa2326_start_oneshot(indio_dev); > + if (ret) > + goto suspend; > + > + /* Wait for sampling cycle to complete. */ > + if (priv->irq > 0) > + ret = zpa2326_wait_oneshot_completion(indio_dev, priv); > + else > + ret = zpa2326_poll_oneshot_completion(indio_dev); > + > + if (ret) > + goto suspend; > + > + /* Retrieve raw sample value and convert it to CPU endianness. */ > + ret = zpa2326_fetch_raw_sample(indio_dev, type, value); > + > +suspend: > + zpa2326_suspend(indio_dev); > +release: > + iio_device_release_direct_mode(indio_dev); > + > + return ret; > +} > + > +/** > + * zpa2326_trigger_handler() - Perform an IIO buffered sampling round in one > + * shot mode. > + * @irq: The software interrupt assigned to @data > + * @data: The IIO poll function dispatched by external trigger our device is > + * attached to. > + * > + * Bottom-half handler called by the IIO trigger to which our device is > + * currently attached. Allows us to synchronize this device buffered sampling > + * either with external events (such as timer expiration, external device sample > + * ready, etc...) or with its own interrupt (internal hardware trigger). > + * > + * When using an external trigger, basically run the same sequence of operations > + * as for zpa2326_sample_oneshot() with the following hereafter. Hardware FIFO > + * is not cleared since already done at buffering enable time and samples > + * dequeueing always retrieves the most recent value. > + * > + * Otherwise, when internal hardware trigger has dispatched us, just fetch data > + * from hardware FIFO. > + * > + * Fetched data will pushed unprocessed to IIO buffer since samples conversion > + * is delegated to userspace in buffered mode (endianness, etc...). > + * > + * Return: > + * %IRQ_NONE - no consistent interrupt happened ; > + * %IRQ_HANDLED - there was new samples available. > + */ > +static irqreturn_t zpa2326_trigger_handler(int irq, void *data) > +{ > + struct iio_dev *indio_dev = ((struct iio_poll_func *) > + data)->indio_dev; > + struct zpa2326_private *priv = iio_priv(indio_dev); > + bool cont; > + > + /* > + * We have been dispatched, meaning we are in triggered buffer mode. > + * Using our own internal trigger implies we are currently in continuous > + * hardware sampling mode. > + */ > + cont = iio_trigger_using_own(indio_dev); > + > + if (!cont) { > + /* On demand sampling : start a one shot cycle. */ > + if (zpa2326_start_oneshot(indio_dev)) > + goto out; > + > + /* Wait for sampling cycle to complete. */ > + if (priv->irq <= 0) { > + /* No interrupt available: poll for completion. */ > + if (zpa2326_poll_oneshot_completion(indio_dev)) > + goto out; > + > + /* Only timestamp sample once it is ready. */ > + priv->timestamp = iio_get_time_ns(indio_dev); > + } else { > + /* Interrupt handlers will timestamp for us. */ > + if (zpa2326_wait_oneshot_completion(indio_dev, priv)) > + goto out; > + } > + } > + > + /* Enqueue to IIO buffer / userspace. */ > + zpa2326_fill_sample_buffer(indio_dev, priv); > + > +out: > + if (!cont) > + /* Don't switch to low power if sampling continuously. */ > + zpa2326_sleep(indio_dev); > + > + /* Inform attached trigger we are done. */ > + iio_trigger_notify_done(indio_dev->trig); > + > + return IRQ_HANDLED; > +} > + > +/** > + * zpa2326_preenable_buffer() - Prepare device for configuring triggered > + * sampling > + * modes. > + * @indio_dev: The IIO device associated with the sampling hardware. > + * > + * Basically power up device. > + * Called with IIO device's lock held. > + * > + * Return: Zero when successful, a negative error code otherwise. > + */ > +static int zpa2326_preenable_buffer(struct iio_dev *indio_dev) > +{ > + int ret = zpa2326_resume(indio_dev); > + > + if (ret < 0) > + return ret; > + > + /* Tell zpa2326_postenable_buffer() if we have just been powered on. */ > + ((struct zpa2326_private *) > + iio_priv(indio_dev))->waken = iio_priv(indio_dev); > + > + return 0; > +} > + > +/** > + * zpa2326_postenable_buffer() - Configure device for triggered sampling. > + * @indio_dev: The IIO device associated with the sampling hardware. > + * > + * Basically setup one-shot mode if plugging external trigger. > + * Otherwise, let internal trigger configure continuous sampling : > + * see zpa2326_set_trigger_state(). > + * > + * If an error is returned, IIO layer will call our postdisable hook for us, > + * i.e. no need to explicitly power device off here. > + * Called with IIO device's lock held. > + * > + * Called with IIO device's lock held. > + * > + * Return: Zero when successful, a negative error code otherwise. > + */ > +static int zpa2326_postenable_buffer(struct iio_dev *indio_dev) > +{ > + const struct zpa2326_private *priv = iio_priv(indio_dev); > + int err; > + > + if (!priv->waken) { > + /* > + * We were already power supplied. Just clear hardware FIFO to > + * get rid of samples acquired during previous rounds (if any). > + */ > + err = zpa2326_clear_fifo(indio_dev, 0); > + if (err) > + goto err; > + } > + > + if (!iio_trigger_using_own(indio_dev) && priv->waken) { > + /* > + * We are using an external trigger and we have just been > + * powered up: reconfigure one-shot mode. > + */ > + err = zpa2326_config_oneshot(indio_dev, priv->irq); > + if (err) > + goto err; > + } > + > + /* Plug our own trigger event handler. */ > + err = iio_triggered_buffer_postenable(indio_dev); > + if (err) > + goto err; > + > + return 0; > + > +err: > + zpa2326_err(indio_dev, "failed to enable buffering (%d)", err); > + > + return err; > +} > + > +static int zpa2326_postdisable_buffer(struct iio_dev *indio_dev) > +{ > + zpa2326_suspend(indio_dev); > + > + return 0; > +} > + > +static const struct iio_buffer_setup_ops zpa2326_buffer_setup_ops = { > + .preenable = zpa2326_preenable_buffer, > + .postenable = zpa2326_postenable_buffer, > + .predisable = iio_triggered_buffer_predisable, > + .postdisable = zpa2326_postdisable_buffer > +}; > + > +/** > + * zpa2326_set_trigger_state() - Start / stop continuous sampling. > + * @trig: The trigger being attached to IIO device associated with the sampling > + * hardware. > + * @state: Tell whether to start (true) or stop (false) > + * > + * Basically enable / disable hardware continuous sampling mode. > + * > + * Called with IIO device's lock held at postenable() or predisable() time. > + * > + * Return: Zero when successful, a negative error code otherwise. > + */ > +static int zpa2326_set_trigger_state(struct iio_trigger *trig, bool state) > +{ > + const struct iio_dev *indio_dev = dev_get_drvdata( > + trig->dev.parent); > + const struct zpa2326_private *priv = iio_priv(indio_dev); > + int err; > + > + if (!state) { > + /* > + * Switch trigger off : in case of failure, interrupt is left > + * disabled in order to prevent handler from accessing released > + * resources. > + */ > + unsigned int val; > + > + /* > + * 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(priv->irq); > + > + /* > + * Disable continuous sampling mode to restore settings for > + * one shot / direct sampling operations. > + */ > + err = regmap_write(priv->regmap, ZPA2326_CTRL_REG3_REG, > + zpa2326_highest_frequency()->odr); > + if (err) > + return 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 = regmap_read(priv->regmap, ZPA2326_INT_SOURCE_REG, &val); > + if (err < 0) > + return 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(priv->irq); > + > + zpa2326_dbg(indio_dev, "continuous mode stopped"); > + } else { > + /* > + * Switch trigger on : start continuous sampling at required > + * frequency. > + */ > + > + if (priv->waken) { > + /* Enable interrupt if getting out of reset. */ > + err = regmap_write(priv->regmap, ZPA2326_CTRL_REG1_REG, > + (u8) > + ~ZPA2326_CTRL_REG1_MASK_DATA_READY); > + if (err) > + return err; > + } > + > + /* Enable continuous sampling at specified frequency. */ > + err = regmap_write(priv->regmap, ZPA2326_CTRL_REG3_REG, > + ZPA2326_CTRL_REG3_ENABLE_MEAS | > + priv->frequency->odr); > + if (err) > + return err; > + > + zpa2326_dbg(indio_dev, "continuous mode setup @%dHz", > + priv->frequency->hz); > + } > + > + return 0; > +} > + > +static const struct iio_trigger_ops zpa2326_trigger_ops = { > + .owner = THIS_MODULE, > + .set_trigger_state = zpa2326_set_trigger_state, > +}; > + > +/** > + * zpa2326_init_trigger() - Create an interrupt driven / hardware trigger > + * allowing to notify external devices a new sample is > + * ready. > + * @parent: Hardware sampling device @indio_dev is a child of. > + * @indio_dev: The IIO device associated with the sampling hardware. > + * @private: Internal private state related to @indio_dev. > + * @irq: Optional interrupt line the hardware uses to notify new data > + * samples are ready. Negative or zero values indicate no interrupts > + * are available, meaning polling is required. > + * > + * Only relevant when DT declares a valid interrupt line. > + * > + * Return: Zero when successful, a negative error code otherwise. > + */ > +static int zpa2326_init_managed_trigger(struct device *parent, > + struct iio_dev *indio_dev, > + struct zpa2326_private *private, > + int irq) > +{ > + struct iio_trigger *trigger; > + int ret; > + > + if (irq <= 0) > + return 0; > + > + trigger = devm_iio_trigger_alloc(parent, "%s-dev%d", > + indio_dev->name, indio_dev->id); > + if (!trigger) > + return -ENOMEM; > + > + /* Basic setup. */ > + trigger->dev.parent = parent; > + trigger->ops = &zpa2326_trigger_ops; > + > + private->trigger = trigger; > + > + /* Register to triggers space. */ > + ret = devm_iio_trigger_register(parent, trigger); > + if (ret) > + dev_err(parent, "failed to register hardware trigger (%d)", > + ret); > + > + return ret; > +} > + > +static int zpa2326_get_frequency(const struct iio_dev *indio_dev) > +{ > + return ((struct zpa2326_private *)iio_priv(indio_dev))->frequency->hz; > +} > + > +static int zpa2326_set_frequency(struct iio_dev *indio_dev, int hz) > +{ > + struct zpa2326_private *priv = iio_priv(indio_dev); > + int freq; > + int err; > + > + /* Check if requested frequency is supported. */ > + for (freq = 0; freq < ARRAY_SIZE(zpa2326_sampling_frequencies); freq++) > + if (zpa2326_sampling_frequencies[freq].hz == hz) > + break; > + if (freq == ARRAY_SIZE(zpa2326_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 = &zpa2326_sampling_frequencies[freq]; > + > + iio_device_release_direct_mode(indio_dev); > + > + return 0; > +} > + > +/* Expose supported hardware sampling frequencies (Hz) through sysfs. */ > +static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("1 5 11 23"); > + > +static struct attribute *zpa2326_attributes[] = { > + &iio_const_attr_sampling_frequency_available.dev_attr.attr, > + NULL > +}; > + > +static const struct attribute_group zpa2326_attribute_group = { > + .attrs = zpa2326_attributes, > +}; > + > +static int zpa2326_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 zpa2326_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 = 1; > + *val2 = 64000; > + return IIO_VAL_FRACTIONAL; > + > + 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: > + return -EINVAL; > + } > + > + case IIO_CHAN_INFO_OFFSET: > + switch (chan->type) { > + case IIO_TEMP: > + *val = -17683000; > + *val2 = 649; > + return IIO_VAL_FRACTIONAL; > + > + default: > + return -EINVAL; > + } > + > + case IIO_CHAN_INFO_SAMP_FREQ: > + *val = zpa2326_get_frequency(indio_dev); > + return IIO_VAL_INT; > + > + default: > + return -EINVAL; > + } > +} > + > +static int zpa2326_write_raw(struct iio_dev *indio_dev, > + const struct iio_chan_spec *chan, > + int val, > + int val2, > + long mask) > +{ > + if ((mask != IIO_CHAN_INFO_SAMP_FREQ) || val2) > + return -EINVAL; > + > + return zpa2326_set_frequency(indio_dev, val); > +} > + > +static const struct iio_chan_spec zpa2326_channels[] = { > + [0] = { > + .type = IIO_PRESSURE, > + .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), > + .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), > + }, > + [1] = { > + .type = IIO_TEMP, > + .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), > + .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), > + }, > + [2] = IIO_CHAN_SOFT_TIMESTAMP(2), > +}; > + > +static const struct iio_info zpa2326_info = { > + .driver_module = THIS_MODULE, > + .attrs = &zpa2326_attribute_group, > + .read_raw = zpa2326_read_raw, > + .write_raw = zpa2326_write_raw, > +}; > + > +static struct iio_dev *zpa2326_create_managed_iiodev(struct device *device, > + const char *name, > + struct regmap *regmap) > +{ > + struct iio_dev *indio_dev; > + > + /* Allocate space to hold IIO device internal state. */ > + indio_dev = devm_iio_device_alloc(device, > + sizeof(struct zpa2326_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 = zpa2326_channels; > + indio_dev->num_channels = ARRAY_SIZE(zpa2326_channels); > + indio_dev->name = name; > + indio_dev->info = &zpa2326_info; > + > + return indio_dev; > +} > + > +int zpa2326_probe(struct device *parent, > + const char *name, > + int irq, > + unsigned int hwid, > + struct regmap *regmap) > +{ > + struct iio_dev *indio_dev; > + struct zpa2326_private *priv; > + int err; > + unsigned int id; > + > + indio_dev = zpa2326_create_managed_iiodev(parent, name, regmap); > + if (!indio_dev) > + return -ENOMEM; > + > + priv = iio_priv(indio_dev); > + > + priv->vref = devm_regulator_get(parent, "vref"); > + if (IS_ERR(priv->vref)) > + return PTR_ERR(priv->vref); > + > + priv->vdd = devm_regulator_get(parent, "vdd"); > + if (IS_ERR(priv->vdd)) > + return PTR_ERR(priv->vdd); > + > + /* Set default hardware sampling frequency to highest rate supported. */ > + priv->frequency = zpa2326_highest_frequency(); > + > + /* > + * Plug device's underlying bus abstraction : this MUST be set before > + * registering interrupt handlers since an interrupt might happen if > + * power up sequence is not properly applied. > + */ > + priv->regmap = regmap; > + > + err = devm_iio_triggered_buffer_setup(parent, indio_dev, NULL, > + zpa2326_trigger_handler, > + &zpa2326_buffer_setup_ops); > + if (err) > + return err; > + > + err = zpa2326_init_managed_trigger(parent, indio_dev, priv, irq); > + if (err) > + return err; > + > + err = zpa2326_init_managed_irq(parent, indio_dev, priv, irq); > + if (err) > + return err; > + > + /* Power up to check device ID and perform initial hardware setup. */ > + err = zpa2326_power_on(indio_dev, priv); > + if (err) > + return err; > + > + /* Read id register to check we are talking to the right slave. */ > + err = regmap_read(regmap, ZPA2326_DEVICE_ID_REG, &id); > + if (err) > + goto sleep; > + > + if (id != hwid) { > + dev_err(parent, "found device with unexpected id %02x", id); > + err = -ENODEV; > + goto sleep; > + } > + > + err = zpa2326_config_oneshot(indio_dev, irq); > + if (err) > + goto sleep; > + > + /* Setup done : go sleeping. Device will be awaken upon user request. */ > + err = zpa2326_sleep(indio_dev); > + if (err) > + goto poweroff; > + > + dev_set_drvdata(parent, indio_dev); > + > + zpa2326_init_runtime(parent); > + > + err = iio_device_register(indio_dev); > + if (err) { > + zpa2326_fini_runtime(parent); > + goto poweroff; > + } > + > + return 0; > + > +sleep: > + /* Put to sleep just in case power regulators are "dummy" ones. */ > + zpa2326_sleep(indio_dev); > +poweroff: > + zpa2326_power_off(indio_dev, priv); > + > + return err; > +} > +EXPORT_SYMBOL_GPL(zpa2326_probe); > + > +void zpa2326_remove(const struct device *parent) > +{ > + struct iio_dev *indio_dev = dev_get_drvdata(parent); > + > + iio_device_unregister(indio_dev); > + zpa2326_fini_runtime(indio_dev->dev.parent); > + zpa2326_sleep(indio_dev); > + zpa2326_power_off(indio_dev, iio_priv(indio_dev)); > +} > +EXPORT_SYMBOL_GPL(zpa2326_remove); > + > +MODULE_AUTHOR("Gregor Boirie <gregor.boirie@xxxxxxxxxx>"); > +MODULE_DESCRIPTION("Core driver for Murata ZPA2326 pressure sensor"); > +MODULE_LICENSE("GPL v2"); > diff --git a/drivers/iio/pressure/zpa2326.h b/drivers/iio/pressure/zpa2326.h > new file mode 100644 > index 0000000..05d3e1e > --- /dev/null > +++ b/drivers/iio/pressure/zpa2326.h > @@ -0,0 +1,89 @@ > +/* > + * Murata ZPA2326 pressure and temperature sensor IIO driver > + * > + * Copyright (c) 2016 Parrot S.A. > + * > + * Author: Gregor Boirie <gregor.boirie@xxxxxxxxxx> > + * > + * 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 > + > +/* Register map. */ > +#define ZPA2326_REF_P_XL_REG (0x8) > +#define ZPA2326_REF_P_L_REG (0x9) > +#define ZPA2326_REF_P_H_REG (0xa) > +#define ZPA2326_DEVICE_ID_REG (0xf) > +#define ZPA2326_DEVICE_ID (0xb9) > +#define ZPA2326_RES_CONF_REG (0x10) > +#define ZPA2326_CTRL_REG0_REG (0x20) > +#define ZPA2326_CTRL_REG0_ONE_SHOT BIT(0) > +#define ZPA2326_CTRL_REG0_ENABLE BIT(1) > +#define ZPA2326_CTRL_REG1_REG (0x21) > +#define ZPA2326_CTRL_REG1_MASK_DATA_READY BIT(2) > +#define ZPA2326_CTRL_REG2_REG (0x22) > +#define ZPA2326_CTRL_REG2_SWRESET BIT(2) > +#define ZPA2326_CTRL_REG3_REG (0x23) > +#define ZPA2326_CTRL_REG3_ODR_SHIFT (4) > +#define ZPA2326_CTRL_REG3_ENABLE_MEAS BIT(7) > +#define ZPA2326_INT_SOURCE_REG (0x24) > +#define ZPA2326_INT_SOURCE_DATA_READY BIT(2) > +#define ZPA2326_THS_P_LOW_REG (0x25) > +#define ZPA2326_THS_P_HIGH_REG (0x26) > +#define ZPA2326_STATUS_REG (0x27) > +#define ZPA2326_STATUS_P_DA BIT(1) > +#define ZPA2326_STATUS_FIFO_E BIT(2) > +#define ZPA2326_STATUS_P_OR BIT(5) > +#define ZPA2326_PRESS_OUT_XL_REG (0x28) > +#define ZPA2326_PRESS_OUT_L_REG (0x29) > +#define ZPA2326_PRESS_OUT_H_REG (0x2a) > +#define ZPA2326_TEMP_OUT_L_REG (0x2b) > +#define ZPA2326_TEMP_OUT_H_REG (0x2c) > + > +struct device; > +struct regmap; > + > +bool zpa2326_isreg_writeable(struct device *dev, unsigned int reg); > +bool zpa2326_isreg_readable(struct device *dev, unsigned int reg); > +bool zpa2326_isreg_precious(struct device *dev, unsigned int reg); > + > +/** > + * zpa2326_probe() - Instantiate and register core ZPA2326 IIO device > + * @parent: Hardware sampling device the created IIO device will be a child of. > + * @name: Arbitrary name to identify the device. > + * @irq: Interrupt line, negative if none. > + * @hwid: Expected device hardware id. > + * @regmap: Registers map used to abstract underlying bus accesses. > + * > + * Return: Zero when successful, a negative error code otherwise. > + */ > +int zpa2326_probe(struct device *parent, > + const char *name, > + int irq, > + unsigned int hwid, > + struct regmap *regmap); > + > +/** > + * zpa2326_remove() - Unregister and destroy core ZPA2326 IIO device. > + * @parent: Hardware sampling device the IIO device to remove is a child of. > + */ > +void zpa2326_remove(const struct device *parent); > + > +#ifdef CONFIG_PM > +#include <linux/pm.h> > +extern const struct dev_pm_ops zpa2326_pm_ops; > +#define ZPA2326_PM_OPS (&zpa2326_pm_ops) > +#else > +#define ZPA2326_PM_OPS (NULL) > +#endif > + > +#endif > diff --git a/drivers/iio/pressure/zpa2326_i2c.c b/drivers/iio/pressure/zpa2326_i2c.c > new file mode 100644 > index 0000000..e4d27dd > --- /dev/null > +++ b/drivers/iio/pressure/zpa2326_i2c.c > @@ -0,0 +1,99 @@ > +/* > + * Murata ZPA2326 I2C pressure and temperature sensor driver > + * > + * Copyright (c) 2016 Parrot S.A. > + * > + * Author: Gregor Boirie <gregor.boirie@xxxxxxxxxx> > + * > + * 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/regmap.h> > +#include <linux/i2c.h> > +#include <linux/of_device.h> > +#include "zpa2326.h" > + > +/* > + * read_flag_mask: > + * - address bit 7 must be set to request a register read operation > + */ > +static const struct regmap_config zpa2326_regmap_i2c_config = { > + .reg_bits = 8, > + .val_bits = 8, > + .writeable_reg = zpa2326_isreg_writeable, > + .readable_reg = zpa2326_isreg_readable, > + .precious_reg = zpa2326_isreg_precious, > + .max_register = ZPA2326_TEMP_OUT_H_REG, > + .read_flag_mask = BIT(7), > + .cache_type = REGCACHE_NONE, > +}; > + > +static unsigned int zpa2326_i2c_hwid(const struct i2c_client *client) > +{ > +#define ZPA2326_SA0(_addr) (_addr & BIT(0)) > +#define ZPA2326_DEVICE_ID_SA0_SHIFT (1) > + > + /* Identification register bit 1 mirrors device address bit 0. */ > + return (ZPA2326_DEVICE_ID | > + (ZPA2326_SA0(client->addr) << ZPA2326_DEVICE_ID_SA0_SHIFT)); > +} > + > +static int zpa2326_probe_i2c(struct i2c_client *client, > + const struct i2c_device_id *i2c_id) > +{ > + struct regmap *regmap; > + > + regmap = devm_regmap_init_i2c(client, &zpa2326_regmap_i2c_config); > + if (IS_ERR(regmap)) { > + dev_err(&client->dev, "failed to init registers map"); > + return PTR_ERR(regmap); > + } > + > + return zpa2326_probe(&client->dev, i2c_id->name, client->irq, > + zpa2326_i2c_hwid(client), regmap); > +} > + > +static int zpa2326_remove_i2c(struct i2c_client *client) > +{ > + zpa2326_remove(&client->dev); > + > + return 0; > +} > + > +static const struct i2c_device_id zpa2326_i2c_ids[] = { > + { "zpa2326", 0 }, > + { }, > +}; > +MODULE_DEVICE_TABLE(i2c, zpa2326_i2c_ids); > + > +#if defined(CONFIG_OF) > +static const struct of_device_id zpa2326_i2c_matches[] = { > + { .compatible = "murata,zpa2326" }, > + { } > +}; > +MODULE_DEVICE_TABLE(of, zpa2326_i2c_matches); > +#endif > + > +static struct i2c_driver zpa2326_i2c_driver = { > + .driver = { > + .name = "zpa2326-i2c", > + .of_match_table = of_match_ptr(zpa2326_i2c_matches), > + .pm = ZPA2326_PM_OPS, > + }, > + .probe = zpa2326_probe_i2c, > + .remove = zpa2326_remove_i2c, > + .id_table = zpa2326_i2c_ids, > +}; > +module_i2c_driver(zpa2326_i2c_driver); > + > +MODULE_AUTHOR("Gregor Boirie <gregor.boirie@xxxxxxxxxx>"); > +MODULE_DESCRIPTION("I2C driver for Murata ZPA2326 pressure sensor"); > +MODULE_LICENSE("GPL v2"); > diff --git a/drivers/iio/pressure/zpa2326_spi.c b/drivers/iio/pressure/zpa2326_spi.c > new file mode 100644 > index 0000000..bd2c1c3 > --- /dev/null > +++ b/drivers/iio/pressure/zpa2326_spi.c > @@ -0,0 +1,103 @@ > +/* > + * Murata ZPA2326 SPI pressure and temperature sensor driver > + * > + * Copyright (c) 2016 Parrot S.A. > + * > + * Author: Gregor Boirie <gregor.boirie@xxxxxxxxxx> > + * > + * 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/regmap.h> > +#include <linux/spi/spi.h> > +#include <linux/of_device.h> > +#include "zpa2326.h" > + > +/* > + * read_flag_mask: > + * - address bit 7 must be set to request a register read operation > + * - address bit 6 must be set to request register address auto increment > + */ > +static const struct regmap_config zpa2326_regmap_spi_config = { > + .reg_bits = 8, > + .val_bits = 8, > + .writeable_reg = zpa2326_isreg_writeable, > + .readable_reg = zpa2326_isreg_readable, > + .precious_reg = zpa2326_isreg_precious, > + .max_register = ZPA2326_TEMP_OUT_H_REG, > + .read_flag_mask = BIT(7) | BIT(6), > + .cache_type = REGCACHE_NONE, > +}; > + > +static int zpa2326_probe_spi(struct spi_device *spi) > +{ > + struct regmap *regmap; > + int err; > + > + regmap = devm_regmap_init_spi(spi, &zpa2326_regmap_spi_config); > + if (IS_ERR(regmap)) { > + dev_err(&spi->dev, "failed to init registers map"); > + return PTR_ERR(regmap); > + } > + > + /* > + * 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. > + */ > + spi->mode = SPI_MODE_3; > + spi->max_speed_hz = min(spi->max_speed_hz, 1000000U); > + spi->bits_per_word = 8; > + err = spi_setup(spi); > + if (err < 0) > + return err; > + > + return zpa2326_probe(&spi->dev, spi_get_device_id(spi)->name, > + spi->irq, ZPA2326_DEVICE_ID, regmap); > +} > + > +static int zpa2326_remove_spi(struct spi_device *spi) > +{ > + zpa2326_remove(&spi->dev); > + > + return 0; > +} > + > +static const struct spi_device_id zpa2326_spi_ids[] = { > + { "zpa2326", 0 }, > + { }, > +}; > +MODULE_DEVICE_TABLE(spi, zpa2326_spi_ids); > + > +#if defined(CONFIG_OF) > +static const struct of_device_id zpa2326_spi_matches[] = { > + { .compatible = "murata,zpa2326" }, > + { } > +}; > +MODULE_DEVICE_TABLE(of, zpa2326_spi_matches); > +#endif > + > +static struct spi_driver zpa2326_spi_driver = { > + .driver = { > + .name = "zpa2326-spi", > + .of_match_table = of_match_ptr(zpa2326_spi_matches), > + .pm = ZPA2326_PM_OPS, > + }, > + .probe = zpa2326_probe_spi, > + .remove = zpa2326_remove_spi, > + .id_table = zpa2326_spi_ids, > +}; > +module_spi_driver(zpa2326_spi_driver); > + > +MODULE_AUTHOR("Gregor Boirie <gregor.boirie@xxxxxxxxxx>"); > +MODULE_DESCRIPTION("SPI driver for Murata ZPA2326 pressure sensor"); > +MODULE_LICENSE("GPL v2"); > -- To unsubscribe from this list: send the line "unsubscribe devicetree" in the body of a message to majordomo@xxxxxxxxxxxxxxx More majordomo info at http://vger.kernel.org/majordomo-info.html
