96 files changed, 6016 insertions, 412 deletions
diff --git a/Documentation/ABI/testing/sysfs-bus-iio b/Documentation/ABI/testing/sysfs-bus-iio
index f155eff910f9..df44998e7506 100644
--- a/Documentation/ABI/testing/sysfs-bus-iio
+++ b/Documentation/ABI/testing/sysfs-bus-iio
@@ -1512,3 +1512,56 @@ Contact:	linux-iio@vger.kernel.org
 Description:
                Raw (unscaled no offset etc.) pH reading of a substance as a negative
                base-10 logarithm of hydrodium ions in a litre of water.
+What:           /sys/bus/iio/devices/iio:deviceX/mount_matrix
+What:           /sys/bus/iio/devices/iio:deviceX/in_mount_matrix
+What:           /sys/bus/iio/devices/iio:deviceX/out_mount_matrix
+What:           /sys/bus/iio/devices/iio:deviceX/in_anglvel_mount_matrix
+What:           /sys/bus/iio/devices/iio:deviceX/in_accel_mount_matrix
+KernelVersion:  4.6
+Contact:        linux-iio@vger.kernel.org
+Description:
+                Mounting matrix for IIO sensors. This is a rotation matrix which
+                informs userspace about sensor chip's placement relative to the
+                main hardware it is mounted on.
+                Main hardware placement is defined according to the local
+                reference frame related to the physical quantity the sensor
+                measures.
+                Given that the rotation matrix is defined in a board specific
+                way (platform data and / or device-tree), the main hardware
+                reference frame definition is left to the implementor's choice
+                (see below for a magnetometer example).
+                Applications should apply this rotation matrix to samples so
+                that when main hardware reference frame is aligned onto local
+                reference frame, then sensor chip reference frame is also
+                perfectly aligned with it.
+                Matrix is a 3x3 unitary matrix and typically looks like
+                [0, 1, 0; 1, 0, 0; 0, 0, -1]. Identity matrix
+                [1, 0, 0; 0, 1, 0; 0, 0, 1] means sensor chip and main hardware
+                are perfectly aligned with each other.
+                For example, a mounting matrix for a magnetometer sensor informs
+                userspace about sensor chip's ORIENTATION relative to the main
+                hardware.
+                More specifically, main hardware orientation is defined with
+                respect to the LOCAL EARTH GEOMAGNETIC REFERENCE FRAME where :
+                * Y is in the ground plane and positive towards magnetic North ;
+                * X is in the ground plane, perpendicular to the North axis and
+                  positive towards the East ;
+                * Z is perpendicular to the ground plane and positive upwards.
+                An implementor might consider that for a hand-held device, a
+                'natural' orientation would be 'front facing camera at the top'.
+                The main hardware reference frame could then be described as :
+                * Y is in the plane of the screen and is positive towards the
+                  top of the screen ;
+                * X is in the plane of the screen, perpendicular to Y axis, and
+                  positive towards the right hand side of the screen ;
+                * Z is perpendicular to the screen plane and positive out of the
+                  screen.
+                Another example for a quadrotor UAV might be :
+                * Y is in the plane of the propellers and positive towards the
+                  front-view camera;
+                * X is in the plane of the propellers, perpendicular to Y axis,
+                  and positive towards the starboard side of the UAV ;
+                * Z is perpendicular to propellers plane and positive upwards.
diff --git a/Documentation/devicetree/bindings/staging/iio/adc/mxs-lradc.txt b/Documentation/devicetree/bindings/iio/adc/mxs-lradc.txt
index 555fb117d4fa..555fb117d4fa 100644
--- a/Documentation/devicetree/bindings/staging/iio/adc/mxs-lradc.txt
+++ b/Documentation/devicetree/bindings/iio/adc/mxs-lradc.txt
diff --git a/Documentation/devicetree/bindings/iio/dac/ad5592r.txt b/Documentation/devicetree/bindings/iio/dac/ad5592r.txt
new file mode 100644
index 000000000000..989f96f31c66
--- /dev/null
+++ b/Documentation/devicetree/bindings/iio/dac/ad5592r.txt
@@ -0,0 +1,155 @@
+Analog Devices AD5592R/AD5593R DAC/ADC device driver
+Required properties for the AD5592R:
+        - compatible: Must be "adi,ad5592r"
+        - reg: SPI chip select number for the device
+        - spi-max-frequency: Max SPI frequency to use (< 30000000)
+        - spi-cpol: The AD5592R requires inverse clock polarity (CPOL) mode
+Required properties for the AD5593R:
+        - compatible: Must be "adi,ad5593r"
+        - reg: I2C address of the device
+Required properties for all supported chips:
+        - #address-cells: Should be 1.
+        - #size-cells: Should be 0.
+        - channel nodes:
+          Each child node represents one channel and has the following
+          Required properties:
+                * reg: Pin on which this channel is connected to.
+                * adi,mode: Mode or function of this channel.
+                            Macros specifying the valid values
+                            can be found in <dt-bindings/iio/adi,ad5592r.h>.
+                            The following values are currently supported:
+                                * CH_MODE_UNUSED (the pin is unused)
+                                * CH_MODE_ADC (the pin is ADC input)
+                                * CH_MODE_DAC (the pin is DAC output)
+                                * CH_MODE_DAC_AND_ADC (the pin is DAC output
+                                        but can be monitored by an ADC, since
+                                        there is no disadvantage this
+                                        this should be considered as the
+                                        preferred DAC mode)
+                                * CH_MODE_GPIO (the pin is registered
+                                        with GPIOLIB)
+         Optional properties:
+                * adi,off-state: State of this channel when unused or the
+                                 device gets removed. Macros specifying the
+                                 valid values can be found in
+                                 <dt-bindings/iio/adi,ad5592r.h>.
+                                * CH_OFFSTATE_PULLDOWN (the pin is pulled down)
+                                * CH_OFFSTATE_OUT_LOW  (the pin is output low)
+                                * CH_OFFSTATE_OUT_HIGH (the pin is output high)
+                                * CH_OFFSTATE_OUT_TRISTATE (the pin is
+                                        tristated output)
+Optional properties:
+        - vref-supply: Phandle to the external reference voltage supply. This should
+          only be set if there is an external reference voltage connected to the VREF
+          pin. If the property is not set the internal 2.5V reference is used.
+        - reset-gpios : GPIO spec for the RESET pin. If specified, it will be
+          asserted during driver probe.
+        - gpio-controller: Marks the device node as a GPIO controller.
+        - #gpio-cells: Should be 2. The first cell is the GPIO number and the second
+          cell specifies GPIO flags, as defined in <dt-bindings/gpio/gpio.h>.
+AD5592R Example:
+        #include <dt-bindings/iio/adi,ad5592r.h>
+        vref: regulator-vref {
+                compatible = "regulator-fixed";
+                regulator-name = "vref-ad559x";
+                regulator-min-microvolt = <3300000>;
+                regulator-max-microvolt = <3300000>;
+                regulator-always-on;
+        };
+        ad5592r@0 {
+                #size-cells = <0>;
+                #address-cells = <1>;
+                #gpio-cells = <2>;
+                compatible = "adi,ad5592r";
+                reg = <0>;
+                spi-max-frequency = <1000000>;
+                spi-cpol;
+                vref-supply = <&vref>; /* optional */
+                reset-gpios = <&gpio0 86 0>;  /* optional */
+                gpio-controller;
+                channel@0 {
+                        reg = <0>;
+                        adi,mode = <CH_MODE_DAC>;
+                };
+                channel@1 {
+                        reg = <1>;
+                        adi,mode = <CH_MODE_ADC>;
+                };
+                channel@2 {
+                        reg = <2>;
+                        adi,mode = <CH_MODE_DAC_AND_ADC>;
+                };
+                channel@3 {
+                        reg = <3>;
+                        adi,mode = <CH_MODE_DAC_AND_ADC>;
+                        adi,off-state = <CH_OFFSTATE_PULLDOWN>;
+                };
+                channel@4 {
+                        reg = <4>;
+                        adi,mode = <CH_MODE_UNUSED>;
+                        adi,off-state = <CH_OFFSTATE_PULLDOWN>;
+                };
+                channel@5 {
+                        reg = <5>;
+                        adi,mode = <CH_MODE_GPIO>;
+                        adi,off-state = <CH_OFFSTATE_PULLDOWN>;
+                };
+                channel@6 {
+                        reg = <6>;
+                        adi,mode = <CH_MODE_GPIO>;
+                        adi,off-state = <CH_OFFSTATE_PULLDOWN>;
+                };
+                channel@7 {
+                        reg = <7>;
+                        adi,mode = <CH_MODE_GPIO>;
+                        adi,off-state = <CH_OFFSTATE_PULLDOWN>;
+                };
+        };
+AD5593R Example:
+        #include <dt-bindings/iio/adi,ad5592r.h>
+        ad5593r@10 {
+                #size-cells = <0>;
+                #address-cells = <1>;
+                #gpio-cells = <2>;
+                compatible = "adi,ad5593r";
+                reg = <0x10>;
+                gpio-controller;
+                channel@0 {
+                        reg = <0>;
+                        adi,mode = <CH_MODE_DAC>;
+                        adi,off-state = <CH_OFFSTATE_PULLDOWN>;
+                };
+                channel@1 {
+                        reg = <1>;
+                        adi,mode = <CH_MODE_ADC>;
+                        adi,off-state = <CH_OFFSTATE_PULLDOWN>;
+                };
+                channel@2 {
+                        reg = <2>;
+                        adi,mode = <CH_MODE_DAC_AND_ADC>;
+                        adi,off-state = <CH_OFFSTATE_PULLDOWN>;
+                };
+                channel@6 {
+                        reg = <6>;
+                        adi,mode = <CH_MODE_GPIO>;
+                        adi,off-state = <CH_OFFSTATE_PULLDOWN>;
+                };
+        };
diff --git a/Documentation/devicetree/bindings/iio/imu/inv_mpu6050.txt b/Documentation/devicetree/bindings/iio/imu/inv_mpu6050.txt
index e4d8f1c52f4a..a9fc11e43b45 100644
--- a/Documentation/devicetree/bindings/iio/imu/inv_mpu6050.txt
+++ b/Documentation/devicetree/bindings/iio/imu/inv_mpu6050.txt
@@ -8,10 +8,23 @@ Required properties:
 - interrupt-parent : should be the phandle for the interrupt controller
 - interrupts : interrupt mapping for GPIO IRQ
+Optional properties:
+ - mount-matrix: an optional 3x3 mounting rotation matrix
 Example:
        mpu6050@68 {
                compatible = "invensense,mpu6050";
                reg = <0x68>;
                interrupt-parent = <&gpio1>;
                interrupts = <18 1>;
+                mount-matrix = "-0.984807753012208",  /* x0 */
+                               "0",                   /* y0 */
+                               "-0.173648177666930",  /* z0 */
+                               "0",                   /* x1 */
+                               "-1",                  /* y1 */
+                               "0",                   /* z1 */
+                               "-0.173648177666930",  /* x2 */
+                               "0",                   /* y2 */
+                               "0.984807753012208";   /* z2 */
        };
diff --git a/Documentation/devicetree/bindings/iio/magnetometer/ak8975.txt b/Documentation/devicetree/bindings/iio/magnetometer/ak8975.txt
index 34a3206eefdf..e1e7dd3259f6 100644
--- a/Documentation/devicetree/bindings/iio/magnetometer/ak8975.txt
+++ b/Documentation/devicetree/bindings/iio/magnetometer/ak8975.txt
@@ -9,6 +9,7 @@ Optional properties:
  - gpios : should be device tree identifier of the magnetometer DRDY pin
  - vdd-supply: an optional regulator that needs to be on to provide VDD
+  - mount-matrix: an optional 3x3 mounting rotation matrix
 Example:
@@ -17,4 +18,13 @@ ak8975@0c {
        reg = <0x0c>;
        gpios = <&gpj0 7 0>;
        vdd-supply = <&ldo_3v3_gnss>;
+        mount-matrix = "-0.984807753012208",  /* x0 */
+                       "0",                   /* y0 */
+                       "-0.173648177666930",  /* z0 */
+                       "0",                   /* x1 */
+                       "-1",                  /* y1 */
+                       "0",                   /* z1 */
+                       "-0.173648177666930",  /* x2 */
+                       "0",                   /* y2 */
+                       "0.984807753012208";   /* z2 */
 };
diff --git a/Documentation/devicetree/bindings/iio/potentiometer/ds1803.txt b/Documentation/devicetree/bindings/iio/potentiometer/ds1803.txt
new file mode 100644
index 000000000000..df77bf552656
--- /dev/null
+++ b/Documentation/devicetree/bindings/iio/potentiometer/ds1803.txt
@@ -0,0 +1,21 @@
+* Maxim Integrated DS1803 digital potentiometer driver
+The node for this driver must be a child node of a I2C controller, hence
+all mandatory properties for your controller must be specified. See directory:
+        Documentation/devicetree/bindings/i2c
+for more details.
+Required properties:
+        - compatible:   Must be one of the following, depending on the
+                        model:
+                        "maxim,ds1803-010",
+                        "maxim,ds1803-050",
+                        "maxim,ds1803-100"
+Example:
+ds1803: ds1803@1 {
+        reg = <0x28>;
+        compatible = "maxim,ds1803-010";
+};
diff --git a/Documentation/devicetree/bindings/iio/pressure/hp03.txt b/Documentation/devicetree/bindings/iio/pressure/hp03.txt
new file mode 100644
index 000000000000..54e7e70bcea5
--- /dev/null
+++ b/Documentation/devicetree/bindings/iio/pressure/hp03.txt
@@ -0,0 +1,17 @@
+HopeRF HP03 digital pressure/temperature sensors
+Required properties:
+- compatible: must be "hoperf,hp03"
+- xclr-gpio: must be device tree identifier of the XCLR pin.
+             The XCLR pin is a reset of the ADC in the chip,
+             it must be pulled HI before the conversion and
+             readout of the value from the ADC registers and
+             pulled LO afterward.
+Example:
+hp03@0x77 {
+        compatible = "hoperf,hp03";
+        reg = <0x77>;
+        xclr-gpio = <&portc 0 0x0>;
+};
diff --git a/Documentation/devicetree/bindings/iio/st-sensors.txt b/Documentation/devicetree/bindings/iio/st-sensors.txt
index 71b7bdff21cd..5844cf72862d 100644
--- a/Documentation/devicetree/bindings/iio/st-sensors.txt
+++ b/Documentation/devicetree/bindings/iio/st-sensors.txt
@@ -16,6 +16,10 @@ Optional properties:
 - st,drdy-int-pin: the pin on the package that will be used to signal
  "data ready" (valid values: 1 or 2). This property is not configurable
  on all sensors.
+- drive-open-drain: the interrupt/data ready line will be configured
+  as open drain, which is useful if several sensors share the same
+  interrupt line. (This binding is taken from pinctrl/pinctrl-bindings.txt)
+  This is a boolean property.
 Sensors may also have applicable pin control settings, those use the
 standard bindings from pinctrl/pinctrl-bindings.txt.
@@ -47,6 +51,7 @@ Gyroscopes:
 - st,l3gd20-gyro
 - st,l3g4is-gyro
 - st,lsm330-gyro
+- st,lsm9ds0-gyro
 Magnetometers:
 - st,lsm303agr-magn
diff --git a/Documentation/driver-model/devres.txt b/Documentation/driver-model/devres.txt
index 73b98dfbcea4..bdc2dfbe6795 100644
--- a/Documentation/driver-model/devres.txt
+++ b/Documentation/driver-model/devres.txt
@@ -267,6 +267,10 @@ IIO
  devm_iio_kfifo_free()
  devm_iio_trigger_alloc()
  devm_iio_trigger_free()
+  devm_iio_channel_get()
+  devm_iio_channel_release()
+  devm_iio_channel_get_all()
+  devm_iio_channel_release_all()
 IO region
  devm_release_mem_region()
diff --git a/drivers/iio/accel/bmc150-accel-core.c b/drivers/iio/accel/bmc150-accel-core.c
index 2a0735d6955d..197e693e7e7b 100644
--- a/drivers/iio/accel/bmc150-accel-core.c
+++ b/drivers/iio/accel/bmc150-accel-core.c
@@ -188,7 +188,6 @@ enum bmc150_accel_trigger_id {
 struct bmc150_accel_data {
        struct regmap *regmap;
-        struct device *dev;
        int irq;
        struct bmc150_accel_interrupt interrupts[BMC150_ACCEL_INTERRUPTS];
        atomic_t active_intr;
@@ -257,6 +256,7 @@ static int bmc150_accel_set_mode(struct bmc150_accel_data *data,
                                 enum bmc150_power_modes mode,
                                 int dur_us)
 {
+        struct device *dev = regmap_get_device(data->regmap);
        int i;
        int ret;
        u8 lpw_bits;
@@ -280,11 +280,11 @@ static int bmc150_accel_set_mode(struct bmc150_accel_data *data,
        lpw_bits = mode << BMC150_ACCEL_PMU_MODE_SHIFT;
        lpw_bits |= (dur_val << BMC150_ACCEL_PMU_BIT_SLEEP_DUR_SHIFT);
-        dev_dbg(data->dev, "Set Mode bits %x\n", lpw_bits);
+        dev_dbg(dev, "Set Mode bits %x\n", lpw_bits);
        ret = regmap_write(data->regmap, BMC150_ACCEL_REG_PMU_LPW, lpw_bits);
        if (ret < 0) {
-                dev_err(data->dev, "Error writing reg_pmu_lpw\n");
+                dev_err(dev, "Error writing reg_pmu_lpw\n");
                return ret;
        }
@@ -317,23 +317,24 @@ static int bmc150_accel_set_bw(struct bmc150_accel_data *data, int val,
 static int bmc150_accel_update_slope(struct bmc150_accel_data *data)
 {
+        struct device *dev = regmap_get_device(data->regmap);
        int ret;
        ret = regmap_write(data->regmap, BMC150_ACCEL_REG_INT_6,
                                        data->slope_thres);
        if (ret < 0) {
-                dev_err(data->dev, "Error writing reg_int_6\n");
+                dev_err(dev, "Error writing reg_int_6\n");
                return ret;
        }
        ret = regmap_update_bits(data->regmap, BMC150_ACCEL_REG_INT_5,
                                 BMC150_ACCEL_SLOPE_DUR_MASK, data->slope_dur);
        if (ret < 0) {
-                dev_err(data->dev, "Error updating reg_int_5\n");
+                dev_err(dev, "Error updating reg_int_5\n");
                return ret;
        }
-        dev_dbg(data->dev, "%s: %x %x\n", __func__, data->slope_thres,
+        dev_dbg(dev, "%s: %x %x\n", __func__, data->slope_thres,
                data->slope_dur);
        return ret;
@@ -379,20 +380,21 @@ static int bmc150_accel_get_startup_times(struct bmc150_accel_data *data)
 static int bmc150_accel_set_power_state(struct bmc150_accel_data *data, bool on)
 {
+        struct device *dev = regmap_get_device(data->regmap);
        int ret;
        if (on) {
-                ret = pm_runtime_get_sync(data->dev);
+                ret = pm_runtime_get_sync(dev);
        } else {
-                pm_runtime_mark_last_busy(data->dev);
+                pm_runtime_mark_last_busy(dev);
-                ret = pm_runtime_put_autosuspend(data->dev);
+                ret = pm_runtime_put_autosuspend(dev);
        }
        if (ret < 0) {
-                dev_err(data->dev,
+                dev_err(dev,
                        "Failed: bmc150_accel_set_power_state for %d\n", on);
                if (on)
-                        pm_runtime_put_noidle(data->dev);
+                        pm_runtime_put_noidle(dev);
                return ret;
        }
@@ -446,6 +448,7 @@ static void bmc150_accel_interrupts_setup(struct iio_dev *indio_dev,
 static int bmc150_accel_set_interrupt(struct bmc150_accel_data *data, int i,
                                      bool state)
 {
+        struct device *dev = regmap_get_device(data->regmap);
        struct bmc150_accel_interrupt *intr = &data->interrupts[i];
        const struct bmc150_accel_interrupt_info *info = intr->info;
        int ret;
@@ -475,7 +478,7 @@ static int bmc150_accel_set_interrupt(struct bmc150_accel_data *data, int i,
        ret = regmap_update_bits(data->regmap, info->map_reg, info->map_bitmask,
                                 (state ? info->map_bitmask : 0));
        if (ret < 0) {
-                dev_err(data->dev, "Error updating reg_int_map\n");
+                dev_err(dev, "Error updating reg_int_map\n");
                goto out_fix_power_state;
        }
@@ -483,7 +486,7 @@ static int bmc150_accel_set_interrupt(struct bmc150_accel_data *data, int i,
        ret = regmap_update_bits(data->regmap, info->en_reg, info->en_bitmask,
                                 (state ? info->en_bitmask : 0));
        if (ret < 0) {
-                dev_err(data->dev, "Error updating reg_int_en\n");
+                dev_err(dev, "Error updating reg_int_en\n");
                goto out_fix_power_state;
        }
@@ -501,6 +504,7 @@ out_fix_power_state:
 static int bmc150_accel_set_scale(struct bmc150_accel_data *data, int val)
 {
+        struct device *dev = regmap_get_device(data->regmap);
        int ret, i;
        for (i = 0; i < ARRAY_SIZE(data->chip_info->scale_table); ++i) {
@@ -509,8 +513,7 @@ static int bmc150_accel_set_scale(struct bmc150_accel_data *data, int val)
                                     BMC150_ACCEL_REG_PMU_RANGE,
                                     data->chip_info->scale_table[i].reg_range);
                        if (ret < 0) {
-                                dev_err(data->dev,
+                                dev_err(dev, "Error writing pmu_range\n");
-                                        "Error writing pmu_range\n");
                                return ret;
                        }
@@ -524,6 +527,7 @@ static int bmc150_accel_set_scale(struct bmc150_accel_data *data, int val)
 static int bmc150_accel_get_temp(struct bmc150_accel_data *data, int *val)
 {
+        struct device *dev = regmap_get_device(data->regmap);
        int ret;
        unsigned int value;
@@ -531,7 +535,7 @@ static int bmc150_accel_get_temp(struct bmc150_accel_data *data, int *val)
        ret = regmap_read(data->regmap, BMC150_ACCEL_REG_TEMP, &value);
        if (ret < 0) {
-                dev_err(data->dev, "Error reading reg_temp\n");
+                dev_err(dev, "Error reading reg_temp\n");
                mutex_unlock(&data->mutex);
                return ret;
        }
@@ -546,6 +550,7 @@ static int bmc150_accel_get_axis(struct bmc150_accel_data *data,
                                 struct iio_chan_spec const *chan,
                                 int *val)
 {
+        struct device *dev = regmap_get_device(data->regmap);
        int ret;
        int axis = chan->scan_index;
        __le16 raw_val;
@@ -560,7 +565,7 @@ static int bmc150_accel_get_axis(struct bmc150_accel_data *data,
        ret = regmap_bulk_read(data->regmap, BMC150_ACCEL_AXIS_TO_REG(axis),
                               &raw_val, sizeof(raw_val));
        if (ret < 0) {
-                dev_err(data->dev, "Error reading axis %d\n", axis);
+                dev_err(dev, "Error reading axis %d\n", axis);
                bmc150_accel_set_power_state(data, false);
                mutex_unlock(&data->mutex);
                return ret;
@@ -832,6 +837,7 @@ static int bmc150_accel_set_watermark(struct iio_dev *indio_dev, unsigned val)
 static int bmc150_accel_fifo_transfer(struct bmc150_accel_data *data,
                                      char *buffer, int samples)
 {
+        struct device *dev = regmap_get_device(data->regmap);
        int sample_length = 3 * 2;
        int ret;
        int total_length = samples * sample_length;
@@ -855,7 +861,8 @@ static int bmc150_accel_fifo_transfer(struct bmc150_accel_data *data,
        }
        if (ret)
-                dev_err(data->dev, "Error transferring data from fifo in single steps of %zu\n",
+                dev_err(dev,
+                        "Error transferring data from fifo in single steps of %zu\n",
                        step);
        return ret;
@@ -865,6 +872,7 @@ static int __bmc150_accel_fifo_flush(struct iio_dev *indio_dev,
                                     unsigned samples, bool irq)
 {
        struct bmc150_accel_data *data = iio_priv(indio_dev);
+        struct device *dev = regmap_get_device(data->regmap);
        int ret, i;
        u8 count;
        u16 buffer[BMC150_ACCEL_FIFO_LENGTH * 3];
@@ -874,7 +882,7 @@ static int __bmc150_accel_fifo_flush(struct iio_dev *indio_dev,
        ret = regmap_read(data->regmap, BMC150_ACCEL_REG_FIFO_STATUS, &val);
        if (ret < 0) {
-                dev_err(data->dev, "Error reading reg_fifo_status\n");
+                dev_err(dev, "Error reading reg_fifo_status\n");
                return ret;
        }
@@ -1136,6 +1144,7 @@ static int bmc150_accel_trig_try_reen(struct iio_trigger *trig)
 {
        struct bmc150_accel_trigger *t = iio_trigger_get_drvdata(trig);
        struct bmc150_accel_data *data = t->data;
+        struct device *dev = regmap_get_device(data->regmap);
        int ret;
        /* new data interrupts don't need ack */
@@ -1149,8 +1158,7 @@ static int bmc150_accel_trig_try_reen(struct iio_trigger *trig)
                           BMC150_ACCEL_INT_MODE_LATCH_RESET);
        mutex_unlock(&data->mutex);
        if (ret < 0) {
-                dev_err(data->dev,
+                dev_err(dev, "Error writing reg_int_rst_latch\n");
-                        "Error writing reg_int_rst_latch\n");
                return ret;
        }
@@ -1201,13 +1209,14 @@ static const struct iio_trigger_ops bmc150_accel_trigger_ops = {
 static int bmc150_accel_handle_roc_event(struct iio_dev *indio_dev)
 {
        struct bmc150_accel_data *data = iio_priv(indio_dev);
+        struct device *dev = regmap_get_device(data->regmap);
        int dir;
        int ret;
        unsigned int val;
        ret = regmap_read(data->regmap, BMC150_ACCEL_REG_INT_STATUS_2, &val);
        if (ret < 0) {
-                dev_err(data->dev, "Error reading reg_int_status_2\n");
+                dev_err(dev, "Error reading reg_int_status_2\n");
                return ret;
        }
@@ -1250,6 +1259,7 @@ static irqreturn_t bmc150_accel_irq_thread_handler(int irq, void *private)
 {
        struct iio_dev *indio_dev = private;
        struct bmc150_accel_data *data = iio_priv(indio_dev);
+        struct device *dev = regmap_get_device(data->regmap);
        bool ack = false;
        int ret;
@@ -1273,7 +1283,7 @@ static irqreturn_t bmc150_accel_irq_thread_handler(int irq, void *private)
                                   BMC150_ACCEL_INT_MODE_LATCH_INT |
                                   BMC150_ACCEL_INT_MODE_LATCH_RESET);
                if (ret)
-                        dev_err(data->dev, "Error writing reg_int_rst_latch\n");
+                        dev_err(dev, "Error writing reg_int_rst_latch\n");
                ret = IRQ_HANDLED;
        } else {
@@ -1344,13 +1354,14 @@ static void bmc150_accel_unregister_triggers(struct bmc150_accel_data *data,
 static int bmc150_accel_triggers_setup(struct iio_dev *indio_dev,
                                       struct bmc150_accel_data *data)
 {
+        struct device *dev = regmap_get_device(data->regmap);
        int i, ret;
        for (i = 0; i < BMC150_ACCEL_TRIGGERS; i++) {
                struct bmc150_accel_trigger *t = &data->triggers[i];
-                t->indio_trig = devm_iio_trigger_alloc(data->dev,
+                t->indio_trig = devm_iio_trigger_alloc(dev,
-                                               bmc150_accel_triggers[i].name,
+                                        bmc150_accel_triggers[i].name,
                                                       indio_dev->name,
                                                       indio_dev->id);
                if (!t->indio_trig) {
@@ -1358,7 +1369,7 @@ static int bmc150_accel_triggers_setup(struct iio_dev *indio_dev,
                        break;
                }
-                t->indio_trig->dev.parent = data->dev;
+                t->indio_trig->dev.parent = dev;
                t->indio_trig->ops = &bmc150_accel_trigger_ops;
                t->intr = bmc150_accel_triggers[i].intr;
                t->data = data;
@@ -1382,12 +1393,13 @@ static int bmc150_accel_triggers_setup(struct iio_dev *indio_dev,
 static int bmc150_accel_fifo_set_mode(struct bmc150_accel_data *data)
 {
+        struct device *dev = regmap_get_device(data->regmap);
        u8 reg = BMC150_ACCEL_REG_FIFO_CONFIG1;
        int ret;
        ret = regmap_write(data->regmap, reg, data->fifo_mode);
        if (ret < 0) {
-                dev_err(data->dev, "Error writing reg_fifo_config1\n");
+                dev_err(dev, "Error writing reg_fifo_config1\n");
                return ret;
        }
@@ -1397,7 +1409,7 @@ static int bmc150_accel_fifo_set_mode(struct bmc150_accel_data *data)
        ret = regmap_write(data->regmap, BMC150_ACCEL_REG_FIFO_CONFIG0,
                           data->watermark);
        if (ret < 0)
-                dev_err(data->dev, "Error writing reg_fifo_config0\n");
+                dev_err(dev, "Error writing reg_fifo_config0\n");
        return ret;
 }
@@ -1481,17 +1493,17 @@ static const struct iio_buffer_setup_ops bmc150_accel_buffer_ops = {
 static int bmc150_accel_chip_init(struct bmc150_accel_data *data)
 {
+        struct device *dev = regmap_get_device(data->regmap);
        int ret, i;
        unsigned int val;
        ret = regmap_read(data->regmap, BMC150_ACCEL_REG_CHIP_ID, &val);
        if (ret < 0) {
-                dev_err(data->dev,
+                dev_err(dev, "Error: Reading chip id\n");
-                        "Error: Reading chip id\n");
                return ret;
        }
-        dev_dbg(data->dev, "Chip Id %x\n", val);
+        dev_dbg(dev, "Chip Id %x\n", val);
        for (i = 0; i < ARRAY_SIZE(bmc150_accel_chip_info_tbl); i++) {
                if (bmc150_accel_chip_info_tbl[i].chip_id == val) {
                        data->chip_info = &bmc150_accel_chip_info_tbl[i];
@@ -1500,7 +1512,7 @@ static int bmc150_accel_chip_init(struct bmc150_accel_data *data)
        }
        if (!data->chip_info) {
-                dev_err(data->dev, "Invalid chip %x\n", val);
+                dev_err(dev, "Invalid chip %x\n", val);
                return -ENODEV;
        }
@@ -1517,8 +1529,7 @@ static int bmc150_accel_chip_init(struct bmc150_accel_data *data)
        ret = regmap_write(data->regmap, BMC150_ACCEL_REG_PMU_RANGE,
                           BMC150_ACCEL_DEF_RANGE_4G);
        if (ret < 0) {
-                dev_err(data->dev,
+                dev_err(dev, "Error writing reg_pmu_range\n");
-                                        "Error writing reg_pmu_range\n");
                return ret;
        }
@@ -1536,8 +1547,7 @@ static int bmc150_accel_chip_init(struct bmc150_accel_data *data)
                           BMC150_ACCEL_INT_MODE_LATCH_INT |
                           BMC150_ACCEL_INT_MODE_LATCH_RESET);
        if (ret < 0) {
-                dev_err(data->dev,
+                dev_err(dev, "Error writing reg_int_rst_latch\n");
-                        "Error writing reg_int_rst_latch\n");
                return ret;
        }
@@ -1557,7 +1567,6 @@ int bmc150_accel_core_probe(struct device *dev, struct regmap *regmap, int irq,
        data = iio_priv(indio_dev);
        dev_set_drvdata(dev, indio_dev);
-        data->dev = dev;
        data->irq = irq;
        data->regmap = regmap;
@@ -1581,13 +1590,13 @@ int bmc150_accel_core_probe(struct device *dev, struct regmap *regmap, int irq,
                                         bmc150_accel_trigger_handler,
                                         &bmc150_accel_buffer_ops);
        if (ret < 0) {
-                dev_err(data->dev, "Failed: iio triggered buffer setup\n");
+                dev_err(dev, "Failed: iio triggered buffer setup\n");
                return ret;
        }
        if (data->irq > 0) {
                ret = devm_request_threaded_irq(
-                                                data->dev, data->irq,
+                                                dev, data->irq,
                                                bmc150_accel_irq_handler,
                                                bmc150_accel_irq_thread_handler,
                                                IRQF_TRIGGER_RISING,
@@ -1605,7 +1614,7 @@ int bmc150_accel_core_probe(struct device *dev, struct regmap *regmap, int irq,
                ret = regmap_write(data->regmap, BMC150_ACCEL_REG_INT_RST_LATCH,
                                   BMC150_ACCEL_INT_MODE_LATCH_RESET);
                if (ret < 0) {
-                        dev_err(data->dev, "Error writing reg_int_rst_latch\n");
+                        dev_err(dev, "Error writing reg_int_rst_latch\n");
                        goto err_buffer_cleanup;
                }
@@ -1654,9 +1663,9 @@ int bmc150_accel_core_remove(struct device *dev)
        iio_device_unregister(indio_dev);
-        pm_runtime_disable(data->dev);
+        pm_runtime_disable(dev);
-        pm_runtime_set_suspended(data->dev);
+        pm_runtime_set_suspended(dev);
-        pm_runtime_put_noidle(data->dev);
+        pm_runtime_put_noidle(dev);
        bmc150_accel_unregister_triggers(data, BMC150_ACCEL_TRIGGERS - 1);
@@ -1705,7 +1714,7 @@ static int bmc150_accel_runtime_suspend(struct device *dev)
        struct bmc150_accel_data *data = iio_priv(indio_dev);
        int ret;
-        dev_dbg(data->dev,  __func__);
+        dev_dbg(dev,  __func__);
        ret = bmc150_accel_set_mode(data, BMC150_ACCEL_SLEEP_MODE_SUSPEND, 0);
        if (ret < 0)
                return -EAGAIN;
@@ -1720,7 +1729,7 @@ static int bmc150_accel_runtime_resume(struct device *dev)
        int ret;
        int sleep_val;
-        dev_dbg(data->dev,  __func__);
+        dev_dbg(dev,  __func__);
        ret = bmc150_accel_set_mode(data, BMC150_ACCEL_SLEEP_MODE_NORMAL, 0);
        if (ret < 0)
diff --git a/drivers/iio/accel/mma7455_core.c b/drivers/iio/accel/mma7455_core.c
index c633cc2c0789..c902f54c23f5 100644
--- a/drivers/iio/accel/mma7455_core.c
+++ b/drivers/iio/accel/mma7455_core.c
@@ -55,11 +55,11 @@
 struct mma7455_data {
        struct regmap *regmap;
-        struct device *dev;
 };
 static int mma7455_drdy(struct mma7455_data *mma7455)
 {
+        struct device *dev = regmap_get_device(mma7455->regmap);
        unsigned int reg;
        int tries = 3;
        int ret;
@@ -75,7 +75,7 @@ static int mma7455_drdy(struct mma7455_data *mma7455)
                msleep(20);
        }
-        dev_warn(mma7455->dev, "data not ready\n");
+        dev_warn(dev, "data not ready\n");
        return -EIO;
 }
@@ -260,7 +260,6 @@ int mma7455_core_probe(struct device *dev, struct regmap *regmap,
        dev_set_drvdata(dev, indio_dev);
        mma7455 = iio_priv(indio_dev);
        mma7455->regmap = regmap;
-        mma7455->dev = dev;
        indio_dev->info = &mma7455_info;
        indio_dev->name = name;
diff --git a/drivers/iio/accel/st_accel_core.c b/drivers/iio/accel/st_accel_core.c
index fee32e3d7a05..dc73f2d85e6d 100644
--- a/drivers/iio/accel/st_accel_core.c
+++ b/drivers/iio/accel/st_accel_core.c
@@ -99,6 +99,8 @@
 #define ST_ACCEL_2_DRDY_IRQ_INT2_MASK           0x10
 #define ST_ACCEL_2_IHL_IRQ_ADDR                 0x22
 #define ST_ACCEL_2_IHL_IRQ_MASK                 0x80
+#define ST_ACCEL_2_OD_IRQ_ADDR                  0x22
+#define ST_ACCEL_2_OD_IRQ_MASK                  0x40
 #define ST_ACCEL_2_MULTIREAD_BIT                true
 /* CUSTOM VALUES FOR SENSOR 3 */
@@ -180,6 +182,8 @@
 #define ST_ACCEL_5_DRDY_IRQ_INT2_MASK           0x20
 #define ST_ACCEL_5_IHL_IRQ_ADDR                 0x22
 #define ST_ACCEL_5_IHL_IRQ_MASK                 0x80
+#define ST_ACCEL_5_OD_IRQ_ADDR                  0x22
+#define ST_ACCEL_5_OD_IRQ_MASK                  0x40
 #define ST_ACCEL_5_IG1_EN_ADDR                  0x21
 #define ST_ACCEL_5_IG1_EN_MASK                  0x08
 #define ST_ACCEL_5_MULTIREAD_BIT                false
@@ -332,6 +336,7 @@ static const struct st_sensor_settings st_accel_sensors_settings[] = {
                        .mask_int2 = ST_ACCEL_1_DRDY_IRQ_INT2_MASK,
                        .addr_ihl = ST_ACCEL_1_IHL_IRQ_ADDR,
                        .mask_ihl = ST_ACCEL_1_IHL_IRQ_MASK,
+                        .addr_stat_drdy = ST_SENSORS_DEFAULT_STAT_ADDR,
                },
                .multi_read_bit = ST_ACCEL_1_MULTIREAD_BIT,
                .bootime = 2,
@@ -397,6 +402,9 @@ static const struct st_sensor_settings st_accel_sensors_settings[] = {
                        .mask_int2 = ST_ACCEL_2_DRDY_IRQ_INT2_MASK,
                        .addr_ihl = ST_ACCEL_2_IHL_IRQ_ADDR,
                        .mask_ihl = ST_ACCEL_2_IHL_IRQ_MASK,
+                        .addr_od = ST_ACCEL_2_OD_IRQ_ADDR,
+                        .mask_od = ST_ACCEL_2_OD_IRQ_MASK,
+                        .addr_stat_drdy = ST_SENSORS_DEFAULT_STAT_ADDR,
                },
                .multi_read_bit = ST_ACCEL_2_MULTIREAD_BIT,
                .bootime = 2,
@@ -474,6 +482,7 @@ static const struct st_sensor_settings st_accel_sensors_settings[] = {
                        .mask_int2 = ST_ACCEL_3_DRDY_IRQ_INT2_MASK,
                        .addr_ihl = ST_ACCEL_3_IHL_IRQ_ADDR,
                        .mask_ihl = ST_ACCEL_3_IHL_IRQ_MASK,
+                        .addr_stat_drdy = ST_SENSORS_DEFAULT_STAT_ADDR,
                        .ig1 = {
                                .en_addr = ST_ACCEL_3_IG1_EN_ADDR,
                                .en_mask = ST_ACCEL_3_IG1_EN_MASK,
@@ -532,6 +541,7 @@ static const struct st_sensor_settings st_accel_sensors_settings[] = {
                .drdy_irq = {
                        .addr = ST_ACCEL_4_DRDY_IRQ_ADDR,
                        .mask_int1 = ST_ACCEL_4_DRDY_IRQ_INT1_MASK,
+                        .addr_stat_drdy = ST_SENSORS_DEFAULT_STAT_ADDR,
                },
                .multi_read_bit = ST_ACCEL_4_MULTIREAD_BIT,
                .bootime = 2, /* guess */
@@ -583,6 +593,9 @@ static const struct st_sensor_settings st_accel_sensors_settings[] = {
                        .mask_int2 = ST_ACCEL_5_DRDY_IRQ_INT2_MASK,
                        .addr_ihl = ST_ACCEL_5_IHL_IRQ_ADDR,
                        .mask_ihl = ST_ACCEL_5_IHL_IRQ_MASK,
+                        .addr_od = ST_ACCEL_5_OD_IRQ_ADDR,
+                        .mask_od = ST_ACCEL_5_OD_IRQ_MASK,
+                        .addr_stat_drdy = ST_SENSORS_DEFAULT_STAT_ADDR,
                },
                .multi_read_bit = ST_ACCEL_5_MULTIREAD_BIT,
                .bootime = 2, /* guess */
diff --git a/drivers/iio/adc/Kconfig b/drivers/iio/adc/Kconfig
index 5937030f0444..25378c5882e2 100644
--- a/drivers/iio/adc/Kconfig
+++ b/drivers/iio/adc/Kconfig
@@ -385,11 +385,11 @@ config ROCKCHIP_SARADC
          module will be called rockchip_saradc.
 config TI_ADC081C
-        tristate "Texas Instruments ADC081C021/027"
+        tristate "Texas Instruments ADC081C/ADC101C/ADC121C family"
        depends on I2C
        help
-          If you say yes here you get support for Texas Instruments ADC081C021
+          If you say yes here you get support for Texas Instruments ADC081C,
-          and ADC081C027 ADC chips.
+          ADC101C and ADC121C ADC chips.
          This driver can also be built as a module. If so, the module will be
          called ti-adc081c.
diff --git a/drivers/iio/adc/ad799x.c b/drivers/iio/adc/ad799x.c
index 01d71588d752..a3f5254f4e51 100644
--- a/drivers/iio/adc/ad799x.c
+++ b/drivers/iio/adc/ad799x.c
@@ -477,7 +477,7 @@ static int ad799x_read_event_value(struct iio_dev *indio_dev,
        if (ret < 0)
                return ret;
        *val = (ret >> chan->scan_type.shift) &
-                GENMASK(chan->scan_type.realbits - 1 , 0);
+                GENMASK(chan->scan_type.realbits - 1, 0);
        return IIO_VAL_INT;
 }
diff --git a/drivers/iio/adc/at91_adc.c b/drivers/iio/adc/at91_adc.c
index f284cd6a93d6..52430ba171f3 100644
--- a/drivers/iio/adc/at91_adc.c
+++ b/drivers/iio/adc/at91_adc.c
@@ -797,8 +797,8 @@ static u32 calc_startup_ticks_9x5(u32 startup_time, u32 adc_clk_khz)
         * Startup Time = <lookup_table_value> / ADC Clock
         */
        const int startup_lookup[] = {
-                0  , 8  , 16 , 24 ,
+                0,   8,   16,  24,
-                64 , 80 , 96 , 112,
+                64,  80,  96,  112,
                512, 576, 640, 704,
                768, 832, 896, 960
                };
@@ -924,14 +924,14 @@ static int at91_adc_probe_dt(struct at91_adc_state *st,
                        ret = -EINVAL;
                        goto error_ret;
                }
-                trig->name = name;
+                trig->name = name;
                if (of_property_read_u32(trig_node, "trigger-value", &prop)) {
                        dev_err(&idev->dev, "Missing trigger-value property in the DT.\n");
                        ret = -EINVAL;
                        goto error_ret;
                }
-                trig->value = prop;
+                trig->value = prop;
                trig->is_external = of_property_read_bool(trig_node, "trigger-external");
                i++;
        }
diff --git a/drivers/iio/adc/mcp3422.c b/drivers/iio/adc/mcp3422.c
index d7b36efd2f3c..d1172dc1e8e2 100644
--- a/drivers/iio/adc/mcp3422.c
+++ b/drivers/iio/adc/mcp3422.c
@@ -61,9 +61,9 @@
 static const int mcp3422_scales[4][4] = {
        { 1000000, 500000, 250000, 125000 },
-        { 250000 , 125000, 62500 , 31250  },
+        { 250000,  125000, 62500,  31250  },
-        { 62500  , 31250 , 15625 , 7812   },
+        { 62500,   31250,  15625,  7812   },
-        { 15625  , 7812  , 3906  , 1953   } };
+        { 15625,   7812,   3906,   1953   } };
 /* Constant msleep times for data acquisitions */
 static const int mcp3422_read_times[4] = {
diff --git a/drivers/iio/adc/mxs-lradc.c b/drivers/iio/adc/mxs-lradc.c
index 33051b87aac2..ad26da1edbee 100644
--- a/drivers/iio/adc/mxs-lradc.c
+++ b/drivers/iio/adc/mxs-lradc.c
@@ -686,6 +686,17 @@ static void mxs_lradc_prepare_pressure(struct mxs_lradc *lradc)
 static void mxs_lradc_enable_touch_detection(struct mxs_lradc *lradc)
 {
+        /* Configure the touchscreen type */
+        if (lradc->soc == IMX28_LRADC) {
+                mxs_lradc_reg_clear(lradc, LRADC_CTRL0_MX28_TOUCH_SCREEN_TYPE,
+                                    LRADC_CTRL0);
+                if (lradc->use_touchscreen == MXS_LRADC_TOUCHSCREEN_5WIRE)
+                        mxs_lradc_reg_set(lradc,
+                                          LRADC_CTRL0_MX28_TOUCH_SCREEN_TYPE,
+                                          LRADC_CTRL0);
+        }
        mxs_lradc_setup_touch_detection(lradc);
        lradc->cur_plate = LRADC_TOUCH;
@@ -1127,6 +1138,7 @@ static int mxs_lradc_ts_register(struct mxs_lradc *lradc)
        __set_bit(EV_ABS, input->evbit);
        __set_bit(EV_KEY, input->evbit);
        __set_bit(BTN_TOUCH, input->keybit);
+        __set_bit(INPUT_PROP_DIRECT, input->propbit);
        input_set_abs_params(input, ABS_X, 0, LRADC_SINGLE_SAMPLE_MASK, 0, 0);
        input_set_abs_params(input, ABS_Y, 0, LRADC_SINGLE_SAMPLE_MASK, 0, 0);
        input_set_abs_params(input, ABS_PRESSURE, 0, LRADC_SINGLE_SAMPLE_MASK,
@@ -1475,18 +1487,13 @@ static const struct iio_chan_spec mx28_lradc_chan_spec[] = {
        MXS_ADC_CHAN(15, IIO_VOLTAGE, "VDD5V"),
 };
-static int mxs_lradc_hw_init(struct mxs_lradc *lradc)
+static void mxs_lradc_hw_init(struct mxs_lradc *lradc)
 {
        /* The ADC always uses DELAY CHANNEL 0. */
        const u32 adc_cfg =
                (1 << (LRADC_DELAY_TRIGGER_DELAYS_OFFSET + 0)) |
                (LRADC_DELAY_TIMER_PER << LRADC_DELAY_DELAY_OFFSET);
-        int ret = stmp_reset_block(lradc->base);
-        if (ret)
-                return ret;
        /* Configure DELAY CHANNEL 0 for generic ADC sampling. */
        mxs_lradc_reg_wrt(lradc, adc_cfg, LRADC_DELAY(0));
@@ -1495,20 +1502,8 @@ static int mxs_lradc_hw_init(struct mxs_lradc *lradc)
        mxs_lradc_reg_wrt(lradc, 0, LRADC_DELAY(2));
        mxs_lradc_reg_wrt(lradc, 0, LRADC_DELAY(3));
-        /* Configure the touchscreen type */
-        if (lradc->soc == IMX28_LRADC) {
-                mxs_lradc_reg_clear(lradc, LRADC_CTRL0_MX28_TOUCH_SCREEN_TYPE,
-                                    LRADC_CTRL0);
-        if (lradc->use_touchscreen == MXS_LRADC_TOUCHSCREEN_5WIRE)
-                mxs_lradc_reg_set(lradc, LRADC_CTRL0_MX28_TOUCH_SCREEN_TYPE,
-                                  LRADC_CTRL0);
-        }
        /* Start internal temperature sensing. */
        mxs_lradc_reg_wrt(lradc, 0, LRADC_CTRL2);
-        return 0;
 }
 static void mxs_lradc_hw_stop(struct mxs_lradc *lradc)
@@ -1708,11 +1703,13 @@ static int mxs_lradc_probe(struct platform_device *pdev)
                }
        }
-        /* Configure the hardware. */
+        ret = stmp_reset_block(lradc->base);
-        ret = mxs_lradc_hw_init(lradc);
        if (ret)
                goto err_dev;
+        /* Configure the hardware. */
+        mxs_lradc_hw_init(lradc);
        /* Register the touchscreen input device. */
        if (touch_ret == 0) {
                ret = mxs_lradc_ts_register(lradc);
diff --git a/drivers/iio/adc/ti-adc081c.c b/drivers/iio/adc/ti-adc081c.c
index ecbc12138d58..9fd032d9f402 100644
--- a/drivers/iio/adc/ti-adc081c.c
+++ b/drivers/iio/adc/ti-adc081c.c
@@ -1,9 +1,21 @@
 /*
+ * TI ADC081C/ADC101C/ADC121C 8/10/12-bit ADC driver
+ *
 * Copyright (C) 2012 Avionic Design GmbH
+ * Copyright (C) 2016 Intel
 *
 * 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.
+ *
+ * Datasheets:
+ *      http://www.ti.com/lit/ds/symlink/adc081c021.pdf
+ *      http://www.ti.com/lit/ds/symlink/adc101c021.pdf
+ *      http://www.ti.com/lit/ds/symlink/adc121c021.pdf
+ *
+ * The devices have a very similar interface and differ mostly in the number of
+ * bits handled. For the 8-bit and 10-bit models the least-significant 4 or 2
+ * bits of value registers are reserved.
 */
 #include <linux/err.h>
@@ -12,11 +24,17 @@
 #include <linux/of.h>
 #include <linux/iio/iio.h>
+#include <linux/iio/buffer.h>
+#include <linux/iio/trigger_consumer.h>
+#include <linux/iio/triggered_buffer.h>
 #include <linux/regulator/consumer.h>
 struct adc081c {
        struct i2c_client *i2c;
        struct regulator *ref;
+        /* 8, 10 or 12 */
+        int bits;
 };
 #define REG_CONV_RES 0x00
@@ -34,7 +52,7 @@ static int adc081c_read_raw(struct iio_dev *iio,
                if (err < 0)
                        return err;
-                *value = (err >> 4) & 0xff;
+                *value = (err & 0xFFF) >> (12 - adc->bits);
                return IIO_VAL_INT;
        case IIO_CHAN_INFO_SCALE:
@@ -43,7 +61,7 @@ static int adc081c_read_raw(struct iio_dev *iio,
                        return err;
                *value = err / 1000;
-                *shift = 8;
+                *shift = adc->bits;
                return IIO_VAL_FRACTIONAL_LOG2;
@@ -54,10 +72,53 @@ static int adc081c_read_raw(struct iio_dev *iio,
        return -EINVAL;
 }
-static const struct iio_chan_spec adc081c_channel = {
+#define ADCxx1C_CHAN(_bits) {                                   \
-        .type = IIO_VOLTAGE,
+        .type = IIO_VOLTAGE,                                    \
-        .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
+        .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),   \
-        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
+        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),           \
+        .scan_type = {                                          \
+                .sign = 'u',                                    \
+                .realbits = (_bits),                            \
+                .storagebits = 16,                              \
+                .shift = 12 - (_bits),                          \
+                .endianness = IIO_CPU,                          \
+        },                                                      \
+}
+#define DEFINE_ADCxx1C_CHANNELS(_name, _bits)                           \
+        static const struct iio_chan_spec _name ## _channels[] = {      \
+                ADCxx1C_CHAN((_bits)),                                  \
+                IIO_CHAN_SOFT_TIMESTAMP(1),                             \
+        };                                                              \
+#define ADC081C_NUM_CHANNELS 2
+struct adcxx1c_model {
+        const struct iio_chan_spec* channels;
+        int bits;
+};
+#define ADCxx1C_MODEL(_name, _bits)                                     \
+        {                                                               \
+                .channels = _name ## _channels,                         \
+                .bits = (_bits),                                        \
+        }
+DEFINE_ADCxx1C_CHANNELS(adc081c,  8);
+DEFINE_ADCxx1C_CHANNELS(adc101c, 10);
+DEFINE_ADCxx1C_CHANNELS(adc121c, 12);
+/* Model ids are indexes in _models array */
+enum adcxx1c_model_id {
+        ADC081C = 0,
+        ADC101C = 1,
+        ADC121C = 2,
+};
+static struct adcxx1c_model adcxx1c_models[] = {
+        ADCxx1C_MODEL(adc081c,  8),
+        ADCxx1C_MODEL(adc101c, 10),
+        ADCxx1C_MODEL(adc121c, 12),
 };
 static const struct iio_info adc081c_info = {
@@ -65,11 +126,30 @@ static const struct iio_info adc081c_info = {
        .driver_module = THIS_MODULE,
 };
+static irqreturn_t adc081c_trigger_handler(int irq, void *p)
+{
+        struct iio_poll_func *pf = p;
+        struct iio_dev *indio_dev = pf->indio_dev;
+        struct adc081c *data = iio_priv(indio_dev);
+        u16 buf[8]; /* 2 bytes data + 6 bytes padding + 8 bytes timestamp */
+        int ret;
+        ret = i2c_smbus_read_word_swapped(data->i2c, REG_CONV_RES);
+        if (ret < 0)
+                goto out;
+        buf[0] = ret;
+        iio_push_to_buffers_with_timestamp(indio_dev, buf, iio_get_time_ns());
+out:
+        iio_trigger_notify_done(indio_dev->trig);
+        return IRQ_HANDLED;
+}
 static int adc081c_probe(struct i2c_client *client,
                         const struct i2c_device_id *id)
 {
        struct iio_dev *iio;
        struct adc081c *adc;
+        struct adcxx1c_model *model = &adcxx1c_models[id->driver_data];
        int err;
        if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WORD_DATA))
@@ -81,6 +161,7 @@ static int adc081c_probe(struct i2c_client *client,
        adc = iio_priv(iio);
        adc->i2c = client;
+        adc->bits = model->bits;
        adc->ref = devm_regulator_get(&client->dev, "vref");
        if (IS_ERR(adc->ref))
@@ -95,18 +176,26 @@ static int adc081c_probe(struct i2c_client *client,
        iio->modes = INDIO_DIRECT_MODE;
        iio->info = &adc081c_info;
-        iio->channels = &adc081c_channel;
+        iio->channels = model->channels;
-        iio->num_channels = 1;
+        iio->num_channels = ADC081C_NUM_CHANNELS;
+        err = iio_triggered_buffer_setup(iio, NULL, adc081c_trigger_handler, NULL);
+        if (err < 0) {
+                dev_err(&client->dev, "iio triggered buffer setup failed\n");
+                goto err_regulator_disable;
+        }
        err = iio_device_register(iio);
        if (err < 0)
-                goto regulator_disable;
+                goto err_buffer_cleanup;
        i2c_set_clientdata(client, iio);
        return 0;
-regulator_disable:
+err_buffer_cleanup:
+        iio_triggered_buffer_cleanup(iio);
+err_regulator_disable:
        regulator_disable(adc->ref);
        return err;
@@ -118,13 +207,16 @@ static int adc081c_remove(struct i2c_client *client)
        struct adc081c *adc = iio_priv(iio);
        iio_device_unregister(iio);
+        iio_triggered_buffer_cleanup(iio);
        regulator_disable(adc->ref);
        return 0;
 }
 static const struct i2c_device_id adc081c_id[] = {
-        { "adc081c", 0 },
+        { "adc081c", ADC081C },
+        { "adc101c", ADC101C },
+        { "adc121c", ADC121C },
        { }
 };
 MODULE_DEVICE_TABLE(i2c, adc081c_id);
@@ -132,6 +224,8 @@ MODULE_DEVICE_TABLE(i2c, adc081c_id);
 #ifdef CONFIG_OF
 static const struct of_device_id adc081c_of_match[] = {
        { .compatible = "ti,adc081c" },
+        { .compatible = "ti,adc101c" },
+        { .compatible = "ti,adc121c" },
        { }
 };
 MODULE_DEVICE_TABLE(of, adc081c_of_match);
@@ -149,5 +243,5 @@ static struct i2c_driver adc081c_driver = {
 module_i2c_driver(adc081c_driver);
 MODULE_AUTHOR("Thierry Reding <thierry.reding@avionic-design.de>");
-MODULE_DESCRIPTION("Texas Instruments ADC081C021/027 driver");
+MODULE_DESCRIPTION("Texas Instruments ADC081C/ADC101C/ADC121C driver");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/adc/vf610_adc.c b/drivers/iio/adc/vf610_adc.c
index b10f629cc44b..653bf1379d2e 100644
--- a/drivers/iio/adc/vf610_adc.c
+++ b/drivers/iio/adc/vf610_adc.c
@@ -714,19 +714,19 @@ static int vf610_write_raw(struct iio_dev *indio_dev,
        int i;
        switch (mask) {
-                case IIO_CHAN_INFO_SAMP_FREQ:
+        case IIO_CHAN_INFO_SAMP_FREQ:
-                        for (i = 0;
+                for (i = 0;
-                                i < ARRAY_SIZE(info->sample_freq_avail);
+                        i < ARRAY_SIZE(info->sample_freq_avail);
-                                i++)
+                        i++)
-                                if (val == info->sample_freq_avail[i]) {
+                        if (val == info->sample_freq_avail[i]) {
-                                        info->adc_feature.sample_rate = i;
+                                info->adc_feature.sample_rate = i;
-                                        vf610_adc_sample_set(info);
+                                vf610_adc_sample_set(info);
-                                        return 0;
+                                return 0;
-                                }
+                        }
-                        break;
+                break;
-                default:
+        default:
-                        break;
+                break;
        }
        return -EINVAL;
diff --git a/drivers/iio/common/hid-sensors/hid-sensor-trigger.c b/drivers/iio/common/hid-sensors/hid-sensor-trigger.c
index 595511022795..5b41f9d0d4f3 100644
--- a/drivers/iio/common/hid-sensors/hid-sensor-trigger.c
+++ b/drivers/iio/common/hid-sensors/hid-sensor-trigger.c
@@ -115,7 +115,7 @@ int hid_sensor_power_state(struct hid_sensor_common *st, bool state)
                return ret;
        }
-        return 0;
+        return 0;
 #else
        atomic_set(&st->user_requested_state, state);
        return _hid_sensor_power_state(st, state);
diff --git a/drivers/iio/common/ms_sensors/ms_sensors_i2c.c b/drivers/iio/common/ms_sensors/ms_sensors_i2c.c
index 669dc7c270f5..ecf7721ecaf4 100644
--- a/drivers/iio/common/ms_sensors/ms_sensors_i2c.c
+++ b/drivers/iio/common/ms_sensors/ms_sensors_i2c.c
@@ -106,7 +106,7 @@ int ms_sensors_convert_and_read(void *cli, u8 conv, u8 rd,
                                unsigned int delay, u32 *adc)
 {
        int ret;
-        __be32 buf = 0;
+        __be32 buf = 0;
        struct i2c_client *client = (struct i2c_client *)cli;
        /* Trigger conversion */
diff --git a/drivers/iio/common/st_sensors/st_sensors_buffer.c b/drivers/iio/common/st_sensors/st_sensors_buffer.c
index 73764961feac..c55898543a47 100644
--- a/drivers/iio/common/st_sensors/st_sensors_buffer.c
+++ b/drivers/iio/common/st_sensors/st_sensors_buffer.c
@@ -24,67 +24,30 @@
 int st_sensors_get_buffer_element(struct iio_dev *indio_dev, u8 *buf)
 {
-        u8 addr[3]; /* no ST sensor has more than 3 channels */
+        int i, len;
-        int i, n = 0, len;
+        int total = 0;
        struct st_sensor_data *sdata = iio_priv(indio_dev);
        unsigned int num_data_channels = sdata->num_data_channels;
-        unsigned int byte_for_channel =
-                        indio_dev->channels[0].scan_type.storagebits >> 3;
        for (i = 0; i < num_data_channels; i++) {
+                unsigned int bytes_to_read;
                if (test_bit(i, indio_dev->active_scan_mask)) {
-                        addr[n] = indio_dev->channels[i].address;
+                        bytes_to_read = indio_dev->channels[i].scan_type.storagebits >> 3;
-                        n++;
-                }
-        }
-        switch (n) {
-        case 1:
-                len = sdata->tf->read_multiple_byte(&sdata->tb, sdata->dev,
-                        addr[0], byte_for_channel, buf, sdata->multiread_bit);
-                break;
-        case 2:
-                if ((addr[1] - addr[0]) == byte_for_channel) {
                        len = sdata->tf->read_multiple_byte(&sdata->tb,
-                                sdata->dev, addr[0], byte_for_channel * n,
+                                sdata->dev, indio_dev->channels[i].address,
-                                buf, sdata->multiread_bit);
+                                bytes_to_read,
-                } else {
+                                buf + total, sdata->multiread_bit);
-                        u8 *rx_array;
-                        rx_array = kmalloc(byte_for_channel * num_data_channels,
-                                           GFP_KERNEL);
-                        if (!rx_array)
-                                return -ENOMEM;
-                        len = sdata->tf->read_multiple_byte(&sdata->tb,
+                        if (len < bytes_to_read)
-                                sdata->dev, addr[0],
+                                return -EIO;
-                                byte_for_channel * num_data_channels,
-                                rx_array, sdata->multiread_bit);
+                        /* Advance the buffer pointer */
-                        if (len < 0) {
+                        total += len;
-                                kfree(rx_array);
-                                return len;
-                        }
-                        for (i = 0; i < n * byte_for_channel; i++) {
-                                if (i < n)
-                                        buf[i] = rx_array[i];
-                                else
-                                        buf[i] = rx_array[n + i];
-                        }
-                        kfree(rx_array);
-                        len = byte_for_channel * n;
                }
-                break;
-        case 3:
-                len = sdata->tf->read_multiple_byte(&sdata->tb, sdata->dev,
-                        addr[0], byte_for_channel * num_data_channels,
-                        buf, sdata->multiread_bit);
-                break;
-        default:
-                return -EINVAL;
        }
-        if (len != byte_for_channel * n)
-                return -EIO;
-        return len;
+        return total;
 }
 EXPORT_SYMBOL(st_sensors_get_buffer_element);
@@ -95,6 +58,24 @@ irqreturn_t st_sensors_trigger_handler(int irq, void *p)
        struct iio_dev *indio_dev = pf->indio_dev;
        struct st_sensor_data *sdata = iio_priv(indio_dev);
+        /* If we have a status register, check if this IRQ came from us */
+        if (sdata->sensor_settings->drdy_irq.addr_stat_drdy) {
+                u8 status;
+                len = sdata->tf->read_byte(&sdata->tb, sdata->dev,
+                           sdata->sensor_settings->drdy_irq.addr_stat_drdy,
+                           &status);
+                if (len < 0)
+                        dev_err(sdata->dev, "could not read channel status\n");
+                /*
+                 * If this was not caused by any channels on this sensor,
+                 * return IRQ_NONE
+                 */
+                if (!(status & (u8)indio_dev->active_scan_mask[0]))
+                        return IRQ_NONE;
+        }
        len = st_sensors_get_buffer_element(indio_dev, sdata->buffer_data);
        if (len < 0)
                goto st_sensors_get_buffer_element_error;
diff --git a/drivers/iio/common/st_sensors/st_sensors_core.c b/drivers/iio/common/st_sensors/st_sensors_core.c
index f5a2d445d0c0..dffe00692169 100644
--- a/drivers/iio/common/st_sensors/st_sensors_core.c
+++ b/drivers/iio/common/st_sensors/st_sensors_core.c
@@ -301,6 +301,14 @@ static int st_sensors_set_drdy_int_pin(struct iio_dev *indio_dev,
                return -EINVAL;
        }
+        if (pdata->open_drain) {
+                if (!sdata->sensor_settings->drdy_irq.addr_od)
+                        dev_err(&indio_dev->dev,
+                                "open drain requested but unsupported.\n");
+                else
+                        sdata->int_pin_open_drain = true;
+        }
        return 0;
 }
@@ -321,6 +329,8 @@ static struct st_sensors_platform_data *st_sensors_of_probe(struct device *dev,
        else
                pdata->drdy_int_pin = defdata ? defdata->drdy_int_pin : 0;
+        pdata->open_drain = of_property_read_bool(np, "drive-open-drain");
        return pdata;
 }
 #else
@@ -374,6 +384,16 @@ int st_sensors_init_sensor(struct iio_dev *indio_dev,
                        return err;
        }
+        if (sdata->int_pin_open_drain) {
+                dev_info(&indio_dev->dev,
+                         "set interrupt line to open drain mode\n");
+                err = st_sensors_write_data_with_mask(indio_dev,
+                                sdata->sensor_settings->drdy_irq.addr_od,
+                                sdata->sensor_settings->drdy_irq.mask_od, 1);
+                if (err < 0)
+                        return err;
+        }
        err = st_sensors_set_axis_enable(indio_dev, ST_SENSORS_ENABLE_ALL_AXIS);
        return err;
diff --git a/drivers/iio/common/st_sensors/st_sensors_trigger.c b/drivers/iio/common/st_sensors/st_sensors_trigger.c
index 6a8c98327945..da72279fcf99 100644
--- a/drivers/iio/common/st_sensors/st_sensors_trigger.c
+++ b/drivers/iio/common/st_sensors/st_sensors_trigger.c
@@ -64,6 +64,19 @@ int st_sensors_allocate_trigger(struct iio_dev *indio_dev,
                        "rising edge\n", irq_trig);
                irq_trig = IRQF_TRIGGER_RISING;
        }
+        /*
+         * If the interrupt pin is Open Drain, by definition this
+         * means that the interrupt line may be shared with other
+         * peripherals. But to do this we also need to have a status
+         * register and mask to figure out if this sensor was firing
+         * the IRQ or not, so we can tell the interrupt handle that
+         * it was "our" interrupt.
+         */
+        if (sdata->int_pin_open_drain &&
+            sdata->sensor_settings->drdy_irq.addr_stat_drdy)
+                irq_trig |= IRQF_SHARED;
        err = request_threaded_irq(irq,
                        iio_trigger_generic_data_rdy_poll,
                        NULL,
diff --git a/drivers/iio/dac/Kconfig b/drivers/iio/dac/Kconfig
index 210db81ca144..61d5008bff5c 100644
--- a/drivers/iio/dac/Kconfig
+++ b/drivers/iio/dac/Kconfig
@@ -74,6 +74,33 @@ config AD5449
          To compile this driver as a module, choose M here: the
          module will be called ad5449.
+config AD5592R_BASE
+        tristate
+config AD5592R
+        tristate "Analog Devices AD5592R ADC/DAC driver"
+        depends on SPI_MASTER
+        select GPIOLIB
+        select AD5592R_BASE
+        help
+          Say yes here to build support for Analog Devices AD5592R
+          Digital to Analog / Analog to Digital Converter.
+          To compile this driver as a module, choose M here: the
+          module will be called ad5592r.
+config AD5593R
+        tristate "Analog Devices AD5593R ADC/DAC driver"
+        depends on I2C
+        select GPIOLIB
+        select AD5592R_BASE
+        help
+          Say yes here to build support for Analog Devices AD5593R
+          Digital to Analog / Analog to Digital Converter.
+          To compile this driver as a module, choose M here: the
+          module will be called ad5593r.
 config AD5504
        tristate "Analog Devices AD5504/AD5501 DAC SPI driver"
        depends on SPI
diff --git a/drivers/iio/dac/Makefile b/drivers/iio/dac/Makefile
index 420a15cdaa53..8b78d5ca9b11 100644
--- a/drivers/iio/dac/Makefile
+++ b/drivers/iio/dac/Makefile
@@ -11,6 +11,9 @@ obj-$(CONFIG_AD5064) += ad5064.o
 obj-$(CONFIG_AD5504) += ad5504.o
 obj-$(CONFIG_AD5446) += ad5446.o
 obj-$(CONFIG_AD5449) += ad5449.o
+obj-$(CONFIG_AD5592R_BASE) += ad5592r-base.o
+obj-$(CONFIG_AD5592R) += ad5592r.o
+obj-$(CONFIG_AD5593R) += ad5593r.o
 obj-$(CONFIG_AD5755) += ad5755.o
 obj-$(CONFIG_AD5761) += ad5761.o
 obj-$(CONFIG_AD5764) += ad5764.o
diff --git a/drivers/iio/dac/ad5592r-base.c b/drivers/iio/dac/ad5592r-base.c
new file mode 100644
index 000000000000..948f600e7059
--- /dev/null
+++ b/drivers/iio/dac/ad5592r-base.c
@@ -0,0 +1,691 @@
+/*
+ * AD5592R Digital <-> Analog converters driver
+ *
+ * Copyright 2014-2016 Analog Devices Inc.
+ * Author: Paul Cercueil <paul.cercueil@analog.com>
+ *
+ * Licensed under the GPL-2.
+ */
+#include <linux/bitops.h>
+#include <linux/delay.h>
+#include <linux/iio/iio.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/of.h>
+#include <linux/regulator/consumer.h>
+#include <linux/gpio/consumer.h>
+#include <linux/gpio/driver.h>
+#include <linux/gpio.h>
+#include <linux/property.h>
+#include <dt-bindings/iio/adi,ad5592r.h>
+#include "ad5592r-base.h"
+static int ad5592r_gpio_get(struct gpio_chip *chip, unsigned offset)
+{
+        struct ad5592r_state *st = gpiochip_get_data(chip);
+        int ret = 0;
+        u8 val;
+        mutex_lock(&st->gpio_lock);
+        if (st->gpio_out & BIT(offset))
+                val = st->gpio_val;
+        else
+                ret = st->ops->gpio_read(st, &val);
+        mutex_unlock(&st->gpio_lock);
+        if (ret < 0)
+                return ret;
+        return !!(val & BIT(offset));
+}
+static void ad5592r_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
+{
+        struct ad5592r_state *st = gpiochip_get_data(chip);
+        mutex_lock(&st->gpio_lock);
+        if (value)
+                st->gpio_val |= BIT(offset);
+        else
+                st->gpio_val &= ~BIT(offset);
+        st->ops->reg_write(st, AD5592R_REG_GPIO_SET, st->gpio_val);
+        mutex_unlock(&st->gpio_lock);
+}
+static int ad5592r_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
+{
+        struct ad5592r_state *st = gpiochip_get_data(chip);
+        int ret;
+        mutex_lock(&st->gpio_lock);
+        st->gpio_out &= ~BIT(offset);
+        st->gpio_in |= BIT(offset);
+        ret = st->ops->reg_write(st, AD5592R_REG_GPIO_OUT_EN, st->gpio_out);
+        if (ret < 0)
+                goto err_unlock;
+        ret = st->ops->reg_write(st, AD5592R_REG_GPIO_IN_EN, st->gpio_in);
+err_unlock:
+        mutex_unlock(&st->gpio_lock);
+        return ret;
+}
+static int ad5592r_gpio_direction_output(struct gpio_chip *chip,
+                                         unsigned offset, int value)
+{
+        struct ad5592r_state *st = gpiochip_get_data(chip);
+        int ret;
+        mutex_lock(&st->gpio_lock);
+        if (value)
+                st->gpio_val |= BIT(offset);
+        else
+                st->gpio_val &= ~BIT(offset);
+        st->gpio_in &= ~BIT(offset);
+        st->gpio_out |= BIT(offset);
+        ret = st->ops->reg_write(st, AD5592R_REG_GPIO_SET, st->gpio_val);
+        if (ret < 0)
+                goto err_unlock;
+        ret = st->ops->reg_write(st, AD5592R_REG_GPIO_OUT_EN, st->gpio_out);
+        if (ret < 0)
+                goto err_unlock;
+        ret = st->ops->reg_write(st, AD5592R_REG_GPIO_IN_EN, st->gpio_in);
+err_unlock:
+        mutex_unlock(&st->gpio_lock);
+        return ret;
+}
+static int ad5592r_gpio_request(struct gpio_chip *chip, unsigned offset)
+{
+        struct ad5592r_state *st = gpiochip_get_data(chip);
+        if (!(st->gpio_map & BIT(offset))) {
+                dev_err(st->dev, "GPIO %d is reserved by alternate function\n",
+                        offset);
+                return -ENODEV;
+        }
+        return 0;
+}
+static int ad5592r_gpio_init(struct ad5592r_state *st)
+{
+        if (!st->gpio_map)
+                return 0;
+        st->gpiochip.label = dev_name(st->dev);
+        st->gpiochip.base = -1;
+        st->gpiochip.ngpio = 8;
+        st->gpiochip.parent = st->dev;
+        st->gpiochip.can_sleep = true;
+        st->gpiochip.direction_input = ad5592r_gpio_direction_input;
+        st->gpiochip.direction_output = ad5592r_gpio_direction_output;
+        st->gpiochip.get = ad5592r_gpio_get;
+        st->gpiochip.set = ad5592r_gpio_set;
+        st->gpiochip.request = ad5592r_gpio_request;
+        st->gpiochip.owner = THIS_MODULE;
+        mutex_init(&st->gpio_lock);
+        return gpiochip_add_data(&st->gpiochip, st);
+}
+static void ad5592r_gpio_cleanup(struct ad5592r_state *st)
+{
+        if (st->gpio_map)
+                gpiochip_remove(&st->gpiochip);
+}
+static int ad5592r_reset(struct ad5592r_state *st)
+{
+        struct gpio_desc *gpio;
+        struct iio_dev *iio_dev = iio_priv_to_dev(st);
+        gpio = devm_gpiod_get_optional(st->dev, "reset", GPIOD_OUT_LOW);
+        if (IS_ERR(gpio))
+                return PTR_ERR(gpio);
+        if (gpio) {
+                udelay(1);
+                gpiod_set_value(gpio, 1);
+        } else {
+                mutex_lock(&iio_dev->mlock);
+                /* Writing this magic value resets the device */
+                st->ops->reg_write(st, AD5592R_REG_RESET, 0xdac);
+                mutex_unlock(&iio_dev->mlock);
+        }
+        udelay(250);
+        return 0;
+}
+static int ad5592r_get_vref(struct ad5592r_state *st)
+{
+        int ret;
+        if (st->reg) {
+                ret = regulator_get_voltage(st->reg);
+                if (ret < 0)
+                        return ret;
+                return ret / 1000;
+        } else {
+                return 2500;
+        }
+}
+static int ad5592r_set_channel_modes(struct ad5592r_state *st)
+{
+        const struct ad5592r_rw_ops *ops = st->ops;
+        int ret;
+        unsigned i;
+        struct iio_dev *iio_dev = iio_priv_to_dev(st);
+        u8 pulldown = 0, tristate = 0, dac = 0, adc = 0;
+        u16 read_back;
+        for (i = 0; i < st->num_channels; i++) {
+                switch (st->channel_modes[i]) {
+                case CH_MODE_DAC:
+                        dac |= BIT(i);
+                        break;
+                case CH_MODE_ADC:
+                        adc |= BIT(i);
+                        break;
+                case CH_MODE_DAC_AND_ADC:
+                        dac |= BIT(i);
+                        adc |= BIT(i);
+                        break;
+                case CH_MODE_GPIO:
+                        st->gpio_map |= BIT(i);
+                        st->gpio_in |= BIT(i); /* Default to input */
+                        break;
+                case CH_MODE_UNUSED:
+                        /* fall-through */
+                default:
+                        switch (st->channel_offstate[i]) {
+                        case CH_OFFSTATE_OUT_TRISTATE:
+                                tristate |= BIT(i);
+                                break;
+                        case CH_OFFSTATE_OUT_LOW:
+                                st->gpio_out |= BIT(i);
+                                break;
+                        case CH_OFFSTATE_OUT_HIGH:
+                                st->gpio_out |= BIT(i);
+                                st->gpio_val |= BIT(i);
+                                break;
+                        case CH_OFFSTATE_PULLDOWN:
+                                /* fall-through */
+                        default:
+                                pulldown |= BIT(i);
+                                break;
+                        }
+                }
+        }
+        mutex_lock(&iio_dev->mlock);
+        /* Pull down unused pins to GND */
+        ret = ops->reg_write(st, AD5592R_REG_PULLDOWN, pulldown);
+        if (ret)
+                goto err_unlock;
+        ret = ops->reg_write(st, AD5592R_REG_TRISTATE, tristate);
+        if (ret)
+                goto err_unlock;
+        /* Configure pins that we use */
+        ret = ops->reg_write(st, AD5592R_REG_DAC_EN, dac);
+        if (ret)
+                goto err_unlock;
+        ret = ops->reg_write(st, AD5592R_REG_ADC_EN, adc);
+        if (ret)
+                goto err_unlock;
+        ret = ops->reg_write(st, AD5592R_REG_GPIO_SET, st->gpio_val);
+        if (ret)
+                goto err_unlock;
+        ret = ops->reg_write(st, AD5592R_REG_GPIO_OUT_EN, st->gpio_out);
+        if (ret)
+                goto err_unlock;
+        ret = ops->reg_write(st, AD5592R_REG_GPIO_IN_EN, st->gpio_in);
+        if (ret)
+                goto err_unlock;
+        /* Verify that we can read back at least one register */
+        ret = ops->reg_read(st, AD5592R_REG_ADC_EN, &read_back);
+        if (!ret && (read_back & 0xff) != adc)
+                ret = -EIO;
+err_unlock:
+        mutex_unlock(&iio_dev->mlock);
+        return ret;
+}
+static int ad5592r_reset_channel_modes(struct ad5592r_state *st)
+{
+        int i;
+        for (i = 0; i < ARRAY_SIZE(st->channel_modes); i++)
+                st->channel_modes[i] = CH_MODE_UNUSED;
+        return ad5592r_set_channel_modes(st);
+}
+static int ad5592r_write_raw(struct iio_dev *iio_dev,
+        struct iio_chan_spec const *chan, int val, int val2, long mask)
+{
+        struct ad5592r_state *st = iio_priv(iio_dev);
+        int ret;
+        switch (mask) {
+        case IIO_CHAN_INFO_RAW:
+                if (val >= (1 << chan->scan_type.realbits) || val < 0)
+                        return -EINVAL;
+                if (!chan->output)
+                        return -EINVAL;
+                mutex_lock(&iio_dev->mlock);
+                ret = st->ops->write_dac(st, chan->channel, val);
+                if (!ret)
+                        st->cached_dac[chan->channel] = val;
+                mutex_unlock(&iio_dev->mlock);
+                return ret;
+        case IIO_CHAN_INFO_SCALE:
+                if (chan->type == IIO_VOLTAGE) {
+                        bool gain;
+                        if (val == st->scale_avail[0][0] &&
+                                val2 == st->scale_avail[0][1])
+                                gain = false;
+                        else if (val == st->scale_avail[1][0] &&
+                                 val2 == st->scale_avail[1][1])
+                                gain = true;
+                        else
+                                return -EINVAL;
+                        mutex_lock(&iio_dev->mlock);
+                        ret = st->ops->reg_read(st, AD5592R_REG_CTRL,
+                                                &st->cached_gp_ctrl);
+                        if (ret < 0) {
+                                mutex_unlock(&iio_dev->mlock);
+                                return ret;
+                        }
+                        if (chan->output) {
+                                if (gain)
+                                        st->cached_gp_ctrl |=
+                                                AD5592R_REG_CTRL_DAC_RANGE;
+                                else
+                                        st->cached_gp_ctrl &=
+                                                ~AD5592R_REG_CTRL_DAC_RANGE;
+                        } else {
+                                if (gain)
+                                        st->cached_gp_ctrl |=
+                                                AD5592R_REG_CTRL_ADC_RANGE;
+                                else
+                                        st->cached_gp_ctrl &=
+                                                ~AD5592R_REG_CTRL_ADC_RANGE;
+                        }
+                        ret = st->ops->reg_write(st, AD5592R_REG_CTRL,
+                                                 st->cached_gp_ctrl);
+                        mutex_unlock(&iio_dev->mlock);
+                        return ret;
+                }
+                break;
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
+static int ad5592r_read_raw(struct iio_dev *iio_dev,
+                           struct iio_chan_spec const *chan,
+                           int *val, int *val2, long m)
+{
+        struct ad5592r_state *st = iio_priv(iio_dev);
+        u16 read_val;
+        int ret;
+        switch (m) {
+        case IIO_CHAN_INFO_RAW:
+                mutex_lock(&iio_dev->mlock);
+                if (!chan->output) {
+                        ret = st->ops->read_adc(st, chan->channel, &read_val);
+                        if (ret)
+                                goto unlock;
+                        if ((read_val >> 12 & 0x7) != (chan->channel & 0x7)) {
+                                dev_err(st->dev, "Error while reading channel %u\n",
+                                                chan->channel);
+                                ret = -EIO;
+                                goto unlock;
+                        }
+                        read_val &= GENMASK(11, 0);
+                } else {
+                        read_val = st->cached_dac[chan->channel];
+                }
+                dev_dbg(st->dev, "Channel %u read: 0x%04hX\n",
+                                chan->channel, read_val);
+                *val = (int) read_val;
+                ret = IIO_VAL_INT;
+                break;
+        case IIO_CHAN_INFO_SCALE:
+                *val = ad5592r_get_vref(st);
+                if (chan->type == IIO_TEMP) {
+                        s64 tmp = *val * (3767897513LL / 25LL);
+                        *val = div_s64_rem(tmp, 1000000000LL, val2);
+                        ret = IIO_VAL_INT_PLUS_MICRO;
+                } else {
+                        int mult;
+                        mutex_lock(&iio_dev->mlock);
+                        if (chan->output)
+                                mult = !!(st->cached_gp_ctrl &
+                                        AD5592R_REG_CTRL_DAC_RANGE);
+                        else
+                                mult = !!(st->cached_gp_ctrl &
+                                        AD5592R_REG_CTRL_ADC_RANGE);
+                        *val *= ++mult;
+                        *val2 = chan->scan_type.realbits;
+                        ret = IIO_VAL_FRACTIONAL_LOG2;
+                }
+                break;
+        case IIO_CHAN_INFO_OFFSET:
+                ret = ad5592r_get_vref(st);
+                mutex_lock(&iio_dev->mlock);
+                if (st->cached_gp_ctrl & AD5592R_REG_CTRL_ADC_RANGE)
+                        *val = (-34365 * 25) / ret;
+                else
+                        *val = (-75365 * 25) / ret;
+                ret =  IIO_VAL_INT;
+                break;
+        default:
+                ret = -EINVAL;
+        }
+unlock:
+        mutex_unlock(&iio_dev->mlock);
+        return ret;
+}
+static int ad5592r_write_raw_get_fmt(struct iio_dev *indio_dev,
+                                 struct iio_chan_spec const *chan, long mask)
+{
+        switch (mask) {
+        case IIO_CHAN_INFO_SCALE:
+                return IIO_VAL_INT_PLUS_NANO;
+        default:
+                return IIO_VAL_INT_PLUS_MICRO;
+        }
+        return -EINVAL;
+}
+static const struct iio_info ad5592r_info = {
+        .read_raw = ad5592r_read_raw,
+        .write_raw = ad5592r_write_raw,
+        .write_raw_get_fmt = ad5592r_write_raw_get_fmt,
+        .driver_module = THIS_MODULE,
+};
+static ssize_t ad5592r_show_scale_available(struct iio_dev *iio_dev,
+                                           uintptr_t private,
+                                           const struct iio_chan_spec *chan,
+                                           char *buf)
+{
+        struct ad5592r_state *st = iio_priv(iio_dev);
+        return sprintf(buf, "%d.%09u %d.%09u\n",
+                st->scale_avail[0][0], st->scale_avail[0][1],
+                st->scale_avail[1][0], st->scale_avail[1][1]);
+}
+static struct iio_chan_spec_ext_info ad5592r_ext_info[] = {
+        {
+         .name = "scale_available",
+         .read = ad5592r_show_scale_available,
+         .shared = true,
+         },
+        {},
+};
+static void ad5592r_setup_channel(struct iio_dev *iio_dev,
+                struct iio_chan_spec *chan, bool output, unsigned id)
+{
+        chan->type = IIO_VOLTAGE;
+        chan->indexed = 1;
+        chan->output = output;
+        chan->channel = id;
+        chan->info_mask_separate = BIT(IIO_CHAN_INFO_RAW);
+        chan->info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE);
+        chan->scan_type.sign = 'u';
+        chan->scan_type.realbits = 12;
+        chan->scan_type.storagebits = 16;
+        chan->ext_info = ad5592r_ext_info;
+}
+static int ad5592r_alloc_channels(struct ad5592r_state *st)
+{
+        unsigned i, curr_channel = 0,
+                 num_channels = st->num_channels;
+        struct iio_dev *iio_dev = iio_priv_to_dev(st);
+        struct iio_chan_spec *channels;
+        struct fwnode_handle *child;
+        u32 reg, tmp;
+        int ret;
+        device_for_each_child_node(st->dev, child) {
+                ret = fwnode_property_read_u32(child, "reg", &reg);
+                if (ret || reg > ARRAY_SIZE(st->channel_modes))
+                        continue;
+                ret = fwnode_property_read_u32(child, "adi,mode", &tmp);
+                if (!ret)
+                        st->channel_modes[reg] = tmp;
+                fwnode_property_read_u32(child, "adi,off-state", &tmp);
+                if (!ret)
+                        st->channel_offstate[reg] = tmp;
+        }
+        channels = devm_kzalloc(st->dev,
+                        (1 + 2 * num_channels) * sizeof(*channels), GFP_KERNEL);
+        if (!channels)
+                return -ENOMEM;
+        for (i = 0; i < num_channels; i++) {
+                switch (st->channel_modes[i]) {
+                case CH_MODE_DAC:
+                        ad5592r_setup_channel(iio_dev, &channels[curr_channel],
+                                        true, i);
+                        curr_channel++;
+                        break;
+                case CH_MODE_ADC:
+                        ad5592r_setup_channel(iio_dev, &channels[curr_channel],
+                                        false, i);
+                        curr_channel++;
+                        break;
+                case CH_MODE_DAC_AND_ADC:
+                        ad5592r_setup_channel(iio_dev, &channels[curr_channel],
+                                        true, i);
+                        curr_channel++;
+                        ad5592r_setup_channel(iio_dev, &channels[curr_channel],
+                                        false, i);
+                        curr_channel++;
+                        break;
+                default:
+                        continue;
+                }
+        }
+        channels[curr_channel].type = IIO_TEMP;
+        channels[curr_channel].channel = 8;
+        channels[curr_channel].info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
+                                   BIT(IIO_CHAN_INFO_SCALE) |
+                                   BIT(IIO_CHAN_INFO_OFFSET);
+        curr_channel++;
+        iio_dev->num_channels = curr_channel;
+        iio_dev->channels = channels;
+        return 0;
+}
+static void ad5592r_init_scales(struct ad5592r_state *st, int vref_mV)
+{
+        s64 tmp = (s64)vref_mV * 1000000000LL >> 12;
+        st->scale_avail[0][0] =
+                div_s64_rem(tmp, 1000000000LL, &st->scale_avail[0][1]);
+        st->scale_avail[1][0] =
+                div_s64_rem(tmp * 2, 1000000000LL, &st->scale_avail[1][1]);
+}
+int ad5592r_probe(struct device *dev, const char *name,
+                const struct ad5592r_rw_ops *ops)
+{
+        struct iio_dev *iio_dev;
+        struct ad5592r_state *st;
+        int ret;
+        iio_dev = devm_iio_device_alloc(dev, sizeof(*st));
+        if (!iio_dev)
+                return -ENOMEM;
+        st = iio_priv(iio_dev);
+        st->dev = dev;
+        st->ops = ops;
+        st->num_channels = 8;
+        dev_set_drvdata(dev, iio_dev);
+        st->reg = devm_regulator_get_optional(dev, "vref");
+        if (IS_ERR(st->reg)) {
+                if ((PTR_ERR(st->reg) != -ENODEV) && dev->of_node)
+                        return PTR_ERR(st->reg);
+                st->reg = NULL;
+        } else {
+                ret = regulator_enable(st->reg);
+                if (ret)
+                        return ret;
+        }
+        iio_dev->dev.parent = dev;
+        iio_dev->name = name;
+        iio_dev->info = &ad5592r_info;
+        iio_dev->modes = INDIO_DIRECT_MODE;
+        ad5592r_init_scales(st, ad5592r_get_vref(st));
+        ret = ad5592r_reset(st);
+        if (ret)
+                goto error_disable_reg;
+        ret = ops->reg_write(st, AD5592R_REG_PD,
+                     (st->reg == NULL) ? AD5592R_REG_PD_EN_REF : 0);
+        if (ret)
+                goto error_disable_reg;
+        ret = ad5592r_alloc_channels(st);
+        if (ret)
+                goto error_disable_reg;
+        ret = ad5592r_set_channel_modes(st);
+        if (ret)
+                goto error_reset_ch_modes;
+        ret = iio_device_register(iio_dev);
+        if (ret)
+                goto error_reset_ch_modes;
+        ret = ad5592r_gpio_init(st);
+        if (ret)
+                goto error_dev_unregister;
+        return 0;
+error_dev_unregister:
+        iio_device_unregister(iio_dev);
+error_reset_ch_modes:
+        ad5592r_reset_channel_modes(st);
+error_disable_reg:
+        if (st->reg)
+                regulator_disable(st->reg);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(ad5592r_probe);
+int ad5592r_remove(struct device *dev)
+{
+        struct iio_dev *iio_dev = dev_get_drvdata(dev);
+        struct ad5592r_state *st = iio_priv(iio_dev);
+        iio_device_unregister(iio_dev);
+        ad5592r_reset_channel_modes(st);
+        ad5592r_gpio_cleanup(st);
+        if (st->reg)
+                regulator_disable(st->reg);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(ad5592r_remove);
+MODULE_AUTHOR("Paul Cercueil <paul.cercueil@analog.com>");
+MODULE_DESCRIPTION("Analog Devices AD5592R multi-channel converters");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/dac/ad5592r-base.h b/drivers/iio/dac/ad5592r-base.h
new file mode 100644
index 000000000000..841457e93f85
--- /dev/null
+++ b/drivers/iio/dac/ad5592r-base.h
@@ -0,0 +1,76 @@
+/*
+ * AD5592R / AD5593R Digital <-> Analog converters driver
+ *
+ * Copyright 2015-2016 Analog Devices Inc.
+ * Author: Paul Cercueil <paul.cercueil@analog.com>
+ *
+ * Licensed under the GPL-2.
+ */
+#ifndef __DRIVERS_IIO_DAC_AD5592R_BASE_H__
+#define __DRIVERS_IIO_DAC_AD5592R_BASE_H__
+#include <linux/types.h>
+#include <linux/cache.h>
+#include <linux/mutex.h>
+#include <linux/gpio/driver.h>
+struct device;
+struct ad5592r_state;
+enum ad5592r_registers {
+        AD5592R_REG_NOOP                = 0x0,
+        AD5592R_REG_DAC_READBACK        = 0x1,
+        AD5592R_REG_ADC_SEQ             = 0x2,
+        AD5592R_REG_CTRL                = 0x3,
+        AD5592R_REG_ADC_EN              = 0x4,
+        AD5592R_REG_DAC_EN              = 0x5,
+        AD5592R_REG_PULLDOWN            = 0x6,
+        AD5592R_REG_LDAC                = 0x7,
+        AD5592R_REG_GPIO_OUT_EN         = 0x8,
+        AD5592R_REG_GPIO_SET            = 0x9,
+        AD5592R_REG_GPIO_IN_EN          = 0xA,
+        AD5592R_REG_PD                  = 0xB,
+        AD5592R_REG_OPEN_DRAIN          = 0xC,
+        AD5592R_REG_TRISTATE            = 0xD,
+        AD5592R_REG_RESET               = 0xF,
+};
+#define AD5592R_REG_PD_EN_REF           BIT(9)
+#define AD5592R_REG_CTRL_ADC_RANGE      BIT(5)
+#define AD5592R_REG_CTRL_DAC_RANGE      BIT(4)
+struct ad5592r_rw_ops {
+        int (*write_dac)(struct ad5592r_state *st, unsigned chan, u16 value);
+        int (*read_adc)(struct ad5592r_state *st, unsigned chan, u16 *value);
+        int (*reg_write)(struct ad5592r_state *st, u8 reg, u16 value);
+        int (*reg_read)(struct ad5592r_state *st, u8 reg, u16 *value);
+        int (*gpio_read)(struct ad5592r_state *st, u8 *value);
+};
+struct ad5592r_state {
+        struct device *dev;
+        struct regulator *reg;
+        struct gpio_chip gpiochip;
+        struct mutex gpio_lock; /* Protect cached gpio_out, gpio_val, etc. */
+        unsigned int num_channels;
+        const struct ad5592r_rw_ops *ops;
+        int scale_avail[2][2];
+        u16 cached_dac[8];
+        u16 cached_gp_ctrl;
+        u8 channel_modes[8];
+        u8 channel_offstate[8];
+        u8 gpio_map;
+        u8 gpio_out;
+        u8 gpio_in;
+        u8 gpio_val;
+        __be16 spi_msg ____cacheline_aligned;
+        __be16 spi_msg_nop;
+};
+int ad5592r_probe(struct device *dev, const char *name,
+                const struct ad5592r_rw_ops *ops);
+int ad5592r_remove(struct device *dev);
+#endif /* __DRIVERS_IIO_DAC_AD5592R_BASE_H__ */
diff --git a/drivers/iio/dac/ad5592r.c b/drivers/iio/dac/ad5592r.c
new file mode 100644
index 000000000000..0b235a2c7359
--- /dev/null
+++ b/drivers/iio/dac/ad5592r.c
@@ -0,0 +1,164 @@
+/*
+ * AD5592R Digital <-> Analog converters driver
+ *
+ * Copyright 2015-2016 Analog Devices Inc.
+ * Author: Paul Cercueil <paul.cercueil@analog.com>
+ *
+ * Licensed under the GPL-2.
+ */
+#include "ad5592r-base.h"
+#include <linux/bitops.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/spi/spi.h>
+#define AD5592R_GPIO_READBACK_EN        BIT(10)
+#define AD5592R_LDAC_READBACK_EN        BIT(6)
+static int ad5592r_spi_wnop_r16(struct ad5592r_state *st, u16 *buf)
+{
+        struct spi_device *spi = container_of(st->dev, struct spi_device, dev);
+        struct spi_transfer t = {
+                        .tx_buf = &st->spi_msg_nop,
+                        .rx_buf = buf,
+                        .len = 2
+                };
+        st->spi_msg_nop = 0; /* NOP */
+        return spi_sync_transfer(spi, &t, 1);
+}
+static int ad5592r_write_dac(struct ad5592r_state *st, unsigned chan, u16 value)
+{
+        struct spi_device *spi = container_of(st->dev, struct spi_device, dev);
+        st->spi_msg = cpu_to_be16(BIT(15) | (chan << 12) | value);
+        return spi_write(spi, &st->spi_msg, sizeof(st->spi_msg));
+}
+static int ad5592r_read_adc(struct ad5592r_state *st, unsigned chan, u16 *value)
+{
+        struct spi_device *spi = container_of(st->dev, struct spi_device, dev);
+        int ret;
+        st->spi_msg = cpu_to_be16((AD5592R_REG_ADC_SEQ << 11) | BIT(chan));
+        ret = spi_write(spi, &st->spi_msg, sizeof(st->spi_msg));
+        if (ret)
+                return ret;
+        /*
+         * Invalid data:
+         * See Figure 40. Single-Channel ADC Conversion Sequence
+         */
+        ret = ad5592r_spi_wnop_r16(st, &st->spi_msg);
+        if (ret)
+                return ret;
+        ret = ad5592r_spi_wnop_r16(st, &st->spi_msg);
+        if (ret)
+                return ret;
+        *value = be16_to_cpu(st->spi_msg);
+        return 0;
+}
+static int ad5592r_reg_write(struct ad5592r_state *st, u8 reg, u16 value)
+{
+        struct spi_device *spi = container_of(st->dev, struct spi_device, dev);
+        st->spi_msg = cpu_to_be16((reg << 11) | value);
+        return spi_write(spi, &st->spi_msg, sizeof(st->spi_msg));
+}
+static int ad5592r_reg_read(struct ad5592r_state *st, u8 reg, u16 *value)
+{
+        struct spi_device *spi = container_of(st->dev, struct spi_device, dev);
+        int ret;
+        st->spi_msg = cpu_to_be16((AD5592R_REG_LDAC << 11) |
+                                   AD5592R_LDAC_READBACK_EN | (reg << 2));
+        ret = spi_write(spi, &st->spi_msg, sizeof(st->spi_msg));
+        if (ret)
+                return ret;
+        ret = ad5592r_spi_wnop_r16(st, &st->spi_msg);
+        if (ret)
+                return ret;
+        *value = be16_to_cpu(st->spi_msg);
+        return 0;
+}
+static int ad5593r_gpio_read(struct ad5592r_state *st, u8 *value)
+{
+        int ret;
+        ret = ad5592r_reg_write(st, AD5592R_REG_GPIO_IN_EN,
+                                AD5592R_GPIO_READBACK_EN | st->gpio_in);
+        if (ret)
+                return ret;
+        ret = ad5592r_spi_wnop_r16(st, &st->spi_msg);
+        if (ret)
+                return ret;
+        *value = (u8) be16_to_cpu(st->spi_msg);
+        return 0;
+}
+static const struct ad5592r_rw_ops ad5592r_rw_ops = {
+        .write_dac = ad5592r_write_dac,
+        .read_adc = ad5592r_read_adc,
+        .reg_write = ad5592r_reg_write,
+        .reg_read = ad5592r_reg_read,
+        .gpio_read = ad5593r_gpio_read,
+};
+static int ad5592r_spi_probe(struct spi_device *spi)
+{
+        const struct spi_device_id *id = spi_get_device_id(spi);
+        return ad5592r_probe(&spi->dev, id->name, &ad5592r_rw_ops);
+}
+static int ad5592r_spi_remove(struct spi_device *spi)
+{
+        return ad5592r_remove(&spi->dev);
+}
+static const struct spi_device_id ad5592r_spi_ids[] = {
+        { .name = "ad5592r", },
+        {}
+};
+MODULE_DEVICE_TABLE(spi, ad5592r_spi_ids);
+static const struct of_device_id ad5592r_of_match[] = {
+        { .compatible = "adi,ad5592r", },
+        {},
+};
+MODULE_DEVICE_TABLE(of, ad5592r_of_match);
+static struct spi_driver ad5592r_spi_driver = {
+        .driver = {
+                .name = "ad5592r",
+                .of_match_table = of_match_ptr(ad5592r_of_match),
+        },
+        .probe = ad5592r_spi_probe,
+        .remove = ad5592r_spi_remove,
+        .id_table = ad5592r_spi_ids,
+};
+module_spi_driver(ad5592r_spi_driver);
+MODULE_AUTHOR("Paul Cercueil <paul.cercueil@analog.com>");
+MODULE_DESCRIPTION("Analog Devices AD5592R multi-channel converters");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/dac/ad5593r.c b/drivers/iio/dac/ad5593r.c
new file mode 100644
index 000000000000..dca158a88f47
--- /dev/null
+++ b/drivers/iio/dac/ad5593r.c
@@ -0,0 +1,131 @@
+/*
+ * AD5593R Digital <-> Analog converters driver
+ *
+ * Copyright 2015-2016 Analog Devices Inc.
+ * Author: Paul Cercueil <paul.cercueil@analog.com>
+ *
+ * Licensed under the GPL-2.
+ */
+#include "ad5592r-base.h"
+#include <linux/bitops.h>
+#include <linux/i2c.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#define AD5593R_MODE_CONF               (0 << 4)
+#define AD5593R_MODE_DAC_WRITE          (1 << 4)
+#define AD5593R_MODE_ADC_READBACK       (4 << 4)
+#define AD5593R_MODE_DAC_READBACK       (5 << 4)
+#define AD5593R_MODE_GPIO_READBACK      (6 << 4)
+#define AD5593R_MODE_REG_READBACK       (7 << 4)
+static int ad5593r_write_dac(struct ad5592r_state *st, unsigned chan, u16 value)
+{
+        struct i2c_client *i2c = to_i2c_client(st->dev);
+        return i2c_smbus_write_word_swapped(i2c,
+                        AD5593R_MODE_DAC_WRITE | chan, value);
+}
+static int ad5593r_read_adc(struct ad5592r_state *st, unsigned chan, u16 *value)
+{
+        struct i2c_client *i2c = to_i2c_client(st->dev);
+        s32 val;
+        val = i2c_smbus_write_word_swapped(i2c,
+                        AD5593R_MODE_CONF | AD5592R_REG_ADC_SEQ, BIT(chan));
+        if (val < 0)
+                return (int) val;
+        val = i2c_smbus_read_word_swapped(i2c, AD5593R_MODE_ADC_READBACK);
+        if (val < 0)
+                return (int) val;
+        *value = (u16) val;
+        return 0;
+}
+static int ad5593r_reg_write(struct ad5592r_state *st, u8 reg, u16 value)
+{
+        struct i2c_client *i2c = to_i2c_client(st->dev);
+        return i2c_smbus_write_word_swapped(i2c,
+                        AD5593R_MODE_CONF | reg, value);
+}
+static int ad5593r_reg_read(struct ad5592r_state *st, u8 reg, u16 *value)
+{
+        struct i2c_client *i2c = to_i2c_client(st->dev);
+        s32 val;
+        val = i2c_smbus_read_word_swapped(i2c, AD5593R_MODE_REG_READBACK | reg);
+        if (val < 0)
+                return (int) val;
+        *value = (u16) val;
+        return 0;
+}
+static int ad5593r_gpio_read(struct ad5592r_state *st, u8 *value)
+{
+        struct i2c_client *i2c = to_i2c_client(st->dev);
+        s32 val;
+        val = i2c_smbus_read_word_swapped(i2c, AD5593R_MODE_GPIO_READBACK);
+        if (val < 0)
+                return (int) val;
+        *value = (u8) val;
+        return 0;
+}
+static const struct ad5592r_rw_ops ad5593r_rw_ops = {
+        .write_dac = ad5593r_write_dac,
+        .read_adc = ad5593r_read_adc,
+        .reg_write = ad5593r_reg_write,
+        .reg_read = ad5593r_reg_read,
+        .gpio_read = ad5593r_gpio_read,
+};
+static int ad5593r_i2c_probe(struct i2c_client *i2c,
+                const struct i2c_device_id *id)
+{
+        return ad5592r_probe(&i2c->dev, id->name, &ad5593r_rw_ops);
+}
+static int ad5593r_i2c_remove(struct i2c_client *i2c)
+{
+        return ad5592r_remove(&i2c->dev);
+}
+static const struct i2c_device_id ad5593r_i2c_ids[] = {
+        { .name = "ad5593r", },
+        {},
+};
+MODULE_DEVICE_TABLE(i2c, ad5593r_i2c_ids);
+static const struct of_device_id ad5593r_of_match[] = {
+        { .compatible = "adi,ad5593r", },
+        {},
+};
+MODULE_DEVICE_TABLE(of, ad5593r_of_match);
+static struct i2c_driver ad5593r_driver = {
+        .driver = {
+                .name = "ad5593r",
+                .of_match_table = of_match_ptr(ad5593r_of_match),
+        },
+        .probe = ad5593r_i2c_probe,
+        .remove = ad5593r_i2c_remove,
+        .id_table = ad5593r_i2c_ids,
+};
+module_i2c_driver(ad5593r_driver);
+MODULE_AUTHOR("Paul Cercueil <paul.cercueil@analog.com>");
+MODULE_DESCRIPTION("Analog Devices AD5592R multi-channel converters");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/frequency/ad9523.c b/drivers/iio/frequency/ad9523.c
index 44a30f286de1..99eba524f6dd 100644
--- a/drivers/iio/frequency/ad9523.c
+++ b/drivers/iio/frequency/ad9523.c
@@ -284,7 +284,7 @@ struct ad9523_state {
        } data[2] ____cacheline_aligned;
 };
-static int ad9523_read(struct iio_dev *indio_dev, unsigned addr)
+static int ad9523_read(struct iio_dev *indio_dev, unsigned int addr)
 {
        struct ad9523_state *st = iio_priv(indio_dev);
        int ret;
@@ -318,7 +318,8 @@ static int ad9523_read(struct iio_dev *indio_dev, unsigned addr)
        return ret;
 };
-static int ad9523_write(struct iio_dev *indio_dev, unsigned addr, unsigned val)
+static int ad9523_write(struct iio_dev *indio_dev,
+                unsigned int addr, unsigned int val)
 {
        struct ad9523_state *st = iio_priv(indio_dev);
        int ret;
@@ -351,11 +352,11 @@ static int ad9523_io_update(struct iio_dev *indio_dev)
 }
 static int ad9523_vco_out_map(struct iio_dev *indio_dev,
-                              unsigned ch, unsigned out)
+                              unsigned int ch, unsigned int out)
 {
        struct ad9523_state *st = iio_priv(indio_dev);
        int ret;
-        unsigned mask;
+        unsigned int mask;
        switch (ch) {
        case 0 ... 3:
@@ -405,7 +406,7 @@ static int ad9523_vco_out_map(struct iio_dev *indio_dev,
 }
 static int ad9523_set_clock_provider(struct iio_dev *indio_dev,
-                              unsigned ch, unsigned long freq)
+                              unsigned int ch, unsigned long freq)
 {
        struct ad9523_state *st = iio_priv(indio_dev);
        long tmp1, tmp2;
@@ -619,7 +620,7 @@ static int ad9523_read_raw(struct iio_dev *indio_dev,
                           long m)
 {
        struct ad9523_state *st = iio_priv(indio_dev);
-        unsigned code;
+        unsigned int code;
        int ret;
        mutex_lock(&indio_dev->mlock);
@@ -655,7 +656,7 @@ static int ad9523_write_raw(struct iio_dev *indio_dev,
                            long mask)
 {
        struct ad9523_state *st = iio_priv(indio_dev);
-        unsigned reg;
+        unsigned int reg;
        int ret, tmp, code;
        mutex_lock(&indio_dev->mlock);
@@ -709,8 +710,8 @@ out:
 }
 static int ad9523_reg_access(struct iio_dev *indio_dev,
-                              unsigned reg, unsigned writeval,
+                              unsigned int reg, unsigned int writeval,
-                              unsigned *readval)
+                              unsigned int *readval)
 {
        int ret;
diff --git a/drivers/iio/gyro/Kconfig b/drivers/iio/gyro/Kconfig
index e816d29d6a62..205a84420ae9 100644
--- a/drivers/iio/gyro/Kconfig
+++ b/drivers/iio/gyro/Kconfig
@@ -93,7 +93,7 @@ config IIO_ST_GYRO_3AXIS
        select IIO_TRIGGERED_BUFFER if (IIO_BUFFER)
        help
          Say yes here to build support for STMicroelectronics gyroscopes:
-          L3G4200D, LSM330DL, L3GD20, LSM330DLC, L3G4IS, LSM330.
+          L3G4200D, LSM330DL, L3GD20, LSM330DLC, L3G4IS, LSM330, LSM9DS0.
          This driver can also be built as a module. If so, these modules
          will be created:
diff --git a/drivers/iio/gyro/bmg160_core.c b/drivers/iio/gyro/bmg160_core.c
index dd2f850a2f0b..7ccc044063f6 100644
--- a/drivers/iio/gyro/bmg160_core.c
+++ b/drivers/iio/gyro/bmg160_core.c
@@ -95,7 +95,6 @@
 #define BMG160_AUTO_SUSPEND_DELAY_MS    2000
 struct bmg160_data {
-        struct device *dev;
        struct regmap *regmap;
        struct iio_trigger *dready_trig;
        struct iio_trigger *motion_trig;
@@ -137,11 +136,12 @@ static const struct {
 static int bmg160_set_mode(struct bmg160_data *data, u8 mode)
 {
+        struct device *dev = regmap_get_device(data->regmap);
        int ret;
        ret = regmap_write(data->regmap, BMG160_REG_PMU_LPW, mode);
        if (ret < 0) {
-                dev_err(data->dev, "Error writing reg_pmu_lpw\n");
+                dev_err(dev, "Error writing reg_pmu_lpw\n");
                return ret;
        }
@@ -162,6 +162,7 @@ static int bmg160_convert_freq_to_bit(int val)
 static int bmg160_set_bw(struct bmg160_data *data, int val)
 {
+        struct device *dev = regmap_get_device(data->regmap);
        int ret;
        int bw_bits;
@@ -171,7 +172,7 @@ static int bmg160_set_bw(struct bmg160_data *data, int val)
        ret = regmap_write(data->regmap, BMG160_REG_PMU_BW, bw_bits);
        if (ret < 0) {
-                dev_err(data->dev, "Error writing reg_pmu_bw\n");
+                dev_err(dev, "Error writing reg_pmu_bw\n");
                return ret;
        }
@@ -182,18 +183,19 @@ static int bmg160_set_bw(struct bmg160_data *data, int val)
 static int bmg160_chip_init(struct bmg160_data *data)
 {
+        struct device *dev = regmap_get_device(data->regmap);
        int ret;
        unsigned int val;
        ret = regmap_read(data->regmap, BMG160_REG_CHIP_ID, &val);
        if (ret < 0) {
-                dev_err(data->dev, "Error reading reg_chip_id\n");
+                dev_err(dev, "Error reading reg_chip_id\n");
                return ret;
        }
-        dev_dbg(data->dev, "Chip Id %x\n", val);
+        dev_dbg(dev, "Chip Id %x\n", val);
        if (val != BMG160_CHIP_ID_VAL) {
-                dev_err(data->dev, "invalid chip %x\n", val);
+                dev_err(dev, "invalid chip %x\n", val);
                return -ENODEV;
        }
@@ -212,14 +214,14 @@ static int bmg160_chip_init(struct bmg160_data *data)
        /* Set Default Range */
        ret = regmap_write(data->regmap, BMG160_REG_RANGE, BMG160_RANGE_500DPS);
        if (ret < 0) {
-                dev_err(data->dev, "Error writing reg_range\n");
+                dev_err(dev, "Error writing reg_range\n");
                return ret;
        }
        data->dps_range = BMG160_RANGE_500DPS;
        ret = regmap_read(data->regmap, BMG160_REG_SLOPE_THRES, &val);
        if (ret < 0) {
-                dev_err(data->dev, "Error reading reg_slope_thres\n");
+                dev_err(dev, "Error reading reg_slope_thres\n");
                return ret;
        }
        data->slope_thres = val;
@@ -228,7 +230,7 @@ static int bmg160_chip_init(struct bmg160_data *data)
        ret = regmap_update_bits(data->regmap, BMG160_REG_INT_EN_1,
                                 BMG160_INT1_BIT_OD, 0);
        if (ret < 0) {
-                dev_err(data->dev, "Error updating bits in reg_int_en_1\n");
+                dev_err(dev, "Error updating bits in reg_int_en_1\n");
                return ret;
        }
@@ -236,7 +238,7 @@ static int bmg160_chip_init(struct bmg160_data *data)
                           BMG160_INT_MODE_LATCH_INT |
                           BMG160_INT_MODE_LATCH_RESET);
        if (ret < 0) {
-                dev_err(data->dev,
+                dev_err(dev,
                        "Error writing reg_motion_intr\n");
                return ret;
        }
@@ -247,20 +249,21 @@ static int bmg160_chip_init(struct bmg160_data *data)
 static int bmg160_set_power_state(struct bmg160_data *data, bool on)
 {
 #ifdef CONFIG_PM
+        struct device *dev = regmap_get_device(data->regmap);
        int ret;
        if (on)
-                ret = pm_runtime_get_sync(data->dev);
+                ret = pm_runtime_get_sync(dev);
        else {
-                pm_runtime_mark_last_busy(data->dev);
+                pm_runtime_mark_last_busy(dev);
-                ret = pm_runtime_put_autosuspend(data->dev);
+                ret = pm_runtime_put_autosuspend(dev);
        }
        if (ret < 0) {
-                dev_err(data->dev,
+                dev_err(dev, "Failed: bmg160_set_power_state for %d\n", on);
-                        "Failed: bmg160_set_power_state for %d\n", on);
                if (on)
-                        pm_runtime_put_noidle(data->dev);
+                        pm_runtime_put_noidle(dev);
                return ret;
        }
@@ -272,6 +275,7 @@ static int bmg160_set_power_state(struct bmg160_data *data, bool on)
 static int bmg160_setup_any_motion_interrupt(struct bmg160_data *data,
                                             bool status)
 {
+        struct device *dev = regmap_get_device(data->regmap);
        int ret;
        /* Enable/Disable INT_MAP0 mapping */
@@ -279,7 +283,7 @@ static int bmg160_setup_any_motion_interrupt(struct bmg160_data *data,
                                 BMG160_INT_MAP_0_BIT_ANY,
                                 (status ? BMG160_INT_MAP_0_BIT_ANY : 0));
        if (ret < 0) {
-                dev_err(data->dev, "Error updating bits reg_int_map0\n");
+                dev_err(dev, "Error updating bits reg_int_map0\n");
                return ret;
        }
@@ -289,8 +293,7 @@ static int bmg160_setup_any_motion_interrupt(struct bmg160_data *data,
                ret = regmap_write(data->regmap, BMG160_REG_SLOPE_THRES,
                                   data->slope_thres);
                if (ret < 0) {
-                        dev_err(data->dev,
+                        dev_err(dev, "Error writing reg_slope_thres\n");
-                                "Error writing reg_slope_thres\n");
                        return ret;
                }
@@ -298,8 +301,7 @@ static int bmg160_setup_any_motion_interrupt(struct bmg160_data *data,
                                   BMG160_INT_MOTION_X | BMG160_INT_MOTION_Y |
                                   BMG160_INT_MOTION_Z);
                if (ret < 0) {
-                        dev_err(data->dev,
+                        dev_err(dev, "Error writing reg_motion_intr\n");
-                                "Error writing reg_motion_intr\n");
                        return ret;
                }
@@ -314,8 +316,7 @@ static int bmg160_setup_any_motion_interrupt(struct bmg160_data *data,
                                           BMG160_INT_MODE_LATCH_INT |
                                           BMG160_INT_MODE_LATCH_RESET);
                        if (ret < 0) {
-                                dev_err(data->dev,
+                                dev_err(dev, "Error writing reg_rst_latch\n");
-                                        "Error writing reg_rst_latch\n");
                                return ret;
                        }
                }
@@ -328,7 +329,7 @@ static int bmg160_setup_any_motion_interrupt(struct bmg160_data *data,
        }
        if (ret < 0) {
-                dev_err(data->dev, "Error writing reg_int_en0\n");
+                dev_err(dev, "Error writing reg_int_en0\n");
                return ret;
        }
@@ -338,6 +339,7 @@ static int bmg160_setup_any_motion_interrupt(struct bmg160_data *data,
 static int bmg160_setup_new_data_interrupt(struct bmg160_data *data,
                                           bool status)
 {
+        struct device *dev = regmap_get_device(data->regmap);
        int ret;
        /* Enable/Disable INT_MAP1 mapping */
@@ -345,7 +347,7 @@ static int bmg160_setup_new_data_interrupt(struct bmg160_data *data,
                                 BMG160_INT_MAP_1_BIT_NEW_DATA,
                                 (status ? BMG160_INT_MAP_1_BIT_NEW_DATA : 0));
        if (ret < 0) {
-                dev_err(data->dev, "Error updating bits in reg_int_map1\n");
+                dev_err(dev, "Error updating bits in reg_int_map1\n");
                return ret;
        }
@@ -354,9 +356,8 @@ static int bmg160_setup_new_data_interrupt(struct bmg160_data *data,
                                   BMG160_INT_MODE_NON_LATCH_INT |
                                   BMG160_INT_MODE_LATCH_RESET);
                if (ret < 0) {
-                        dev_err(data->dev,
+                        dev_err(dev, "Error writing reg_rst_latch\n");
-                                "Error writing reg_rst_latch\n");
+                        return ret;
-                                return ret;
                }
                ret = regmap_write(data->regmap, BMG160_REG_INT_EN_0,
@@ -368,16 +369,15 @@ static int bmg160_setup_new_data_interrupt(struct bmg160_data *data,
                                   BMG160_INT_MODE_LATCH_INT |
                                   BMG160_INT_MODE_LATCH_RESET);
                if (ret < 0) {
-                        dev_err(data->dev,
+                        dev_err(dev, "Error writing reg_rst_latch\n");
-                                "Error writing reg_rst_latch\n");
+                        return ret;
-                                return ret;
                }
                ret = regmap_write(data->regmap, BMG160_REG_INT_EN_0, 0);
        }
        if (ret < 0) {
-                dev_err(data->dev, "Error writing reg_int_en0\n");
+                dev_err(dev, "Error writing reg_int_en0\n");
                return ret;
        }
@@ -400,6 +400,7 @@ static int bmg160_get_bw(struct bmg160_data *data, int *val)
 static int bmg160_set_scale(struct bmg160_data *data, int val)
 {
+        struct device *dev = regmap_get_device(data->regmap);
        int ret, i;
        for (i = 0; i < ARRAY_SIZE(bmg160_scale_table); ++i) {
@@ -407,8 +408,7 @@ static int bmg160_set_scale(struct bmg160_data *data, int val)
                        ret = regmap_write(data->regmap, BMG160_REG_RANGE,
                                           bmg160_scale_table[i].dps_range);
                        if (ret < 0) {
-                                dev_err(data->dev,
+                                dev_err(dev, "Error writing reg_range\n");
-                                        "Error writing reg_range\n");
                                return ret;
                        }
                        data->dps_range = bmg160_scale_table[i].dps_range;
@@ -421,6 +421,7 @@ static int bmg160_set_scale(struct bmg160_data *data, int val)
 static int bmg160_get_temp(struct bmg160_data *data, int *val)
 {
+        struct device *dev = regmap_get_device(data->regmap);
        int ret;
        unsigned int raw_val;
@@ -433,7 +434,7 @@ static int bmg160_get_temp(struct bmg160_data *data, int *val)
        ret = regmap_read(data->regmap, BMG160_REG_TEMP, &raw_val);
        if (ret < 0) {
-                dev_err(data->dev, "Error reading reg_temp\n");
+                dev_err(dev, "Error reading reg_temp\n");
                bmg160_set_power_state(data, false);
                mutex_unlock(&data->mutex);
                return ret;
@@ -450,6 +451,7 @@ static int bmg160_get_temp(struct bmg160_data *data, int *val)
 static int bmg160_get_axis(struct bmg160_data *data, int axis, int *val)
 {
+        struct device *dev = regmap_get_device(data->regmap);
        int ret;
        __le16 raw_val;
@@ -463,7 +465,7 @@ static int bmg160_get_axis(struct bmg160_data *data, int axis, int *val)
        ret = regmap_bulk_read(data->regmap, BMG160_AXIS_TO_REG(axis), &raw_val,
                               sizeof(raw_val));
        if (ret < 0) {
-                dev_err(data->dev, "Error reading axis %d\n", axis);
+                dev_err(dev, "Error reading axis %d\n", axis);
                bmg160_set_power_state(data, false);
                mutex_unlock(&data->mutex);
                return ret;
@@ -793,6 +795,7 @@ static int bmg160_trig_try_reen(struct iio_trigger *trig)
 {
        struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
        struct bmg160_data *data = iio_priv(indio_dev);
+        struct device *dev = regmap_get_device(data->regmap);
        int ret;
        /* new data interrupts don't need ack */
@@ -804,7 +807,7 @@ static int bmg160_trig_try_reen(struct iio_trigger *trig)
                           BMG160_INT_MODE_LATCH_INT |
                           BMG160_INT_MODE_LATCH_RESET);
        if (ret < 0) {
-                dev_err(data->dev, "Error writing reg_rst_latch\n");
+                dev_err(dev, "Error writing reg_rst_latch\n");
                return ret;
        }
@@ -864,13 +867,14 @@ static irqreturn_t bmg160_event_handler(int irq, void *private)
 {
        struct iio_dev *indio_dev = private;
        struct bmg160_data *data = iio_priv(indio_dev);
+        struct device *dev = regmap_get_device(data->regmap);
        int ret;
        int dir;
        unsigned int val;
        ret = regmap_read(data->regmap, BMG160_REG_INT_STATUS_2, &val);
        if (ret < 0) {
-                dev_err(data->dev, "Error reading reg_int_status2\n");
+                dev_err(dev, "Error reading reg_int_status2\n");
                goto ack_intr_status;
        }
@@ -907,8 +911,7 @@ ack_intr_status:
                                   BMG160_INT_MODE_LATCH_INT |
                                   BMG160_INT_MODE_LATCH_RESET);
                if (ret < 0)
-                        dev_err(data->dev,
+                        dev_err(dev, "Error writing reg_rst_latch\n");
-                                "Error writing reg_rst_latch\n");
        }
        return IRQ_HANDLED;
@@ -976,7 +979,6 @@ int bmg160_core_probe(struct device *dev, struct regmap *regmap, int irq,
        data = iio_priv(indio_dev);
        dev_set_drvdata(dev, indio_dev);
-        data->dev = dev;
        data->irq = irq;
        data->regmap = regmap;
@@ -1139,7 +1141,7 @@ static int bmg160_runtime_suspend(struct device *dev)
        ret = bmg160_set_mode(data, BMG160_MODE_SUSPEND);
        if (ret < 0) {
-                dev_err(data->dev, "set mode failed\n");
+                dev_err(dev, "set mode failed\n");
                return -EAGAIN;
        }
diff --git a/drivers/iio/gyro/st_gyro.h b/drivers/iio/gyro/st_gyro.h
index 5353d6328c54..a5c5c4e29add 100644
--- a/drivers/iio/gyro/st_gyro.h
+++ b/drivers/iio/gyro/st_gyro.h
@@ -21,6 +21,7 @@
 #define L3GD20_GYRO_DEV_NAME            "l3gd20"
 #define L3G4IS_GYRO_DEV_NAME            "l3g4is_ui"
 #define LSM330_GYRO_DEV_NAME            "lsm330_gyro"
+#define LSM9DS0_GYRO_DEV_NAME           "lsm9ds0_gyro"
 /**
 * struct st_sensors_platform_data - gyro platform data
diff --git a/drivers/iio/gyro/st_gyro_core.c b/drivers/iio/gyro/st_gyro_core.c
index 110f95b6e52f..52a3c87c375c 100644
--- a/drivers/iio/gyro/st_gyro_core.c
+++ b/drivers/iio/gyro/st_gyro_core.c
@@ -190,6 +190,7 @@ static const struct st_sensor_settings st_gyro_sensors_settings[] = {
                         * drain settings, but only for INT1 and not
                         * for the DRDY line on INT2.
                         */
+                        .addr_stat_drdy = ST_SENSORS_DEFAULT_STAT_ADDR,
                },
                .multi_read_bit = ST_GYRO_1_MULTIREAD_BIT,
                .bootime = 2,
@@ -203,6 +204,7 @@ static const struct st_sensor_settings st_gyro_sensors_settings[] = {
                        [2] = LSM330DLC_GYRO_DEV_NAME,
                        [3] = L3G4IS_GYRO_DEV_NAME,
                        [4] = LSM330_GYRO_DEV_NAME,
+                        [5] = LSM9DS0_GYRO_DEV_NAME,
                },
                .ch = (struct iio_chan_spec *)st_gyro_16bit_channels,
                .odr = {
@@ -258,6 +260,7 @@ static const struct st_sensor_settings st_gyro_sensors_settings[] = {
                         * drain settings, but only for INT1 and not
                         * for the DRDY line on INT2.
                         */
+                        .addr_stat_drdy = ST_SENSORS_DEFAULT_STAT_ADDR,
                },
                .multi_read_bit = ST_GYRO_2_MULTIREAD_BIT,
                .bootime = 2,
@@ -322,6 +325,7 @@ static const struct st_sensor_settings st_gyro_sensors_settings[] = {
                         * drain settings, but only for INT1 and not
                         * for the DRDY line on INT2.
                         */
+                        .addr_stat_drdy = ST_SENSORS_DEFAULT_STAT_ADDR,
                },
                .multi_read_bit = ST_GYRO_3_MULTIREAD_BIT,
                .bootime = 2,
diff --git a/drivers/iio/gyro/st_gyro_i2c.c b/drivers/iio/gyro/st_gyro_i2c.c
index 6848451f817a..40056b821036 100644
--- a/drivers/iio/gyro/st_gyro_i2c.c
+++ b/drivers/iio/gyro/st_gyro_i2c.c
@@ -48,6 +48,10 @@ static const struct of_device_id st_gyro_of_match[] = {
                .compatible = "st,lsm330-gyro",
                .data = LSM330_GYRO_DEV_NAME,
        },
+        {
+                .compatible = "st,lsm9ds0-gyro",
+                .data = LSM9DS0_GYRO_DEV_NAME,
+        },
        {},
 };
 MODULE_DEVICE_TABLE(of, st_gyro_of_match);
@@ -93,6 +97,7 @@ static const struct i2c_device_id st_gyro_id_table[] = {
        { L3GD20_GYRO_DEV_NAME },
        { L3G4IS_GYRO_DEV_NAME },
        { LSM330_GYRO_DEV_NAME },
+        { LSM9DS0_GYRO_DEV_NAME },
        {},
 };
 MODULE_DEVICE_TABLE(i2c, st_gyro_id_table);
diff --git a/drivers/iio/gyro/st_gyro_spi.c b/drivers/iio/gyro/st_gyro_spi.c
index d2b7a5fa344c..fbf2faed501c 100644
--- a/drivers/iio/gyro/st_gyro_spi.c
+++ b/drivers/iio/gyro/st_gyro_spi.c
@@ -54,6 +54,7 @@ static const struct spi_device_id st_gyro_id_table[] = {
        { L3GD20_GYRO_DEV_NAME },
        { L3G4IS_GYRO_DEV_NAME },
        { LSM330_GYRO_DEV_NAME },
+        { LSM9DS0_GYRO_DEV_NAME },
        {},
 };
 MODULE_DEVICE_TABLE(spi, st_gyro_id_table);
diff --git a/drivers/iio/humidity/Kconfig b/drivers/iio/humidity/Kconfig
index 866dda133336..738a86d9e4a9 100644
--- a/drivers/iio/humidity/Kconfig
+++ b/drivers/iio/humidity/Kconfig
@@ -3,6 +3,16 @@
 #
 menu "Humidity sensors"
+config AM2315
+    tristate "Aosong AM2315 relative humidity and temperature sensor"
+    depends on I2C
+    help
+      If you say yes here you get support for the Aosong AM2315
+      relative humidity and ambient temperature sensor.
+      This driver can also be built as a module. If so, the module will
+      be called am2315.
 config DHT11
        tristate "DHT11 (and compatible sensors) driver"
        depends on GPIOLIB || COMPILE_TEST
diff --git a/drivers/iio/humidity/Makefile b/drivers/iio/humidity/Makefile
index c9f089a9a6b8..4a73442fcd9c 100644
--- a/drivers/iio/humidity/Makefile
+++ b/drivers/iio/humidity/Makefile
@@ -2,6 +2,7 @@
 # Makefile for IIO humidity sensor drivers
 #
+obj-$(CONFIG_AM2315) += am2315.o
 obj-$(CONFIG_DHT11) += dht11.o
 obj-$(CONFIG_HDC100X) += hdc100x.o
 obj-$(CONFIG_HTU21) += htu21.o
diff --git a/drivers/iio/humidity/am2315.c b/drivers/iio/humidity/am2315.c
new file mode 100644
index 000000000000..3be6d209a159
--- /dev/null
+++ b/drivers/iio/humidity/am2315.c
@@ -0,0 +1,303 @@
+/**
+ * Aosong AM2315 relative humidity and temperature
+ *
+ * Copyright (c) 2016, Intel Corporation.
+ *
+ * This file is subject to the terms and conditions of version 2 of
+ * the GNU General Public License. See the file COPYING in the main
+ * directory of this archive for more details.
+ *
+ * 7-bit I2C address: 0x5C.
+ */
+#include <linux/acpi.h>
+#include <linux/delay.h>
+#include <linux/i2c.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/iio/buffer.h>
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+#include <linux/iio/trigger_consumer.h>
+#include <linux/iio/triggered_buffer.h>
+#define AM2315_REG_HUM_MSB                      0x00
+#define AM2315_REG_HUM_LSB                      0x01
+#define AM2315_REG_TEMP_MSB                     0x02
+#define AM2315_REG_TEMP_LSB                     0x03
+#define AM2315_FUNCTION_READ                    0x03
+#define AM2315_HUM_OFFSET                       2
+#define AM2315_TEMP_OFFSET                      4
+#define AM2315_ALL_CHANNEL_MASK                 GENMASK(1, 0)
+#define AM2315_DRIVER_NAME                      "am2315"
+struct am2315_data {
+        struct i2c_client *client;
+        struct mutex lock;
+        s16 buffer[8]; /* 2x16-bit channels + 2x16 padding + 4x16 timestamp */
+};
+struct am2315_sensor_data {
+        s16 hum_data;
+        s16 temp_data;
+};
+static const struct iio_chan_spec am2315_channels[] = {
+        {
+                .type = IIO_HUMIDITYRELATIVE,
+                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
+                                      BIT(IIO_CHAN_INFO_SCALE),
+                .scan_index = 0,
+                .scan_type = {
+                        .sign = 's',
+                        .realbits = 16,
+                        .storagebits = 16,
+                        .endianness = IIO_CPU,
+                },
+        },
+        {
+                .type = IIO_TEMP,
+                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
+                                      BIT(IIO_CHAN_INFO_SCALE),
+                .scan_index = 1,
+                .scan_type = {
+                        .sign = 's',
+                        .realbits = 16,
+                        .storagebits = 16,
+                        .endianness = IIO_CPU,
+                },
+        },
+        IIO_CHAN_SOFT_TIMESTAMP(2),
+};
+/* CRC calculation algorithm, as specified in the datasheet (page 13). */
+static u16 am2315_crc(u8 *data, u8 nr_bytes)
+{
+        int i;
+        u16 crc = 0xffff;
+        while (nr_bytes--) {
+                crc ^= *data++;
+                for (i = 0; i < 8; i++) {
+                        if (crc & 0x01) {
+                                crc >>= 1;
+                                crc ^= 0xA001;
+                        } else {
+                                crc >>= 1;
+                        }
+                }
+        }
+        return crc;
+}
+/* Simple function that sends a few bytes to the device to wake it up. */
+static void am2315_ping(struct i2c_client *client)
+{
+        i2c_smbus_read_byte_data(client, AM2315_REG_HUM_MSB);
+}
+static int am2315_read_data(struct am2315_data *data,
+                            struct am2315_sensor_data *sensor_data)
+{
+        int ret;
+        /* tx_buf format: <function code> <start addr> <nr of regs to read> */
+        u8 tx_buf[3] = { AM2315_FUNCTION_READ, AM2315_REG_HUM_MSB, 4 };
+        /*
+         * rx_buf format:
+         * <function code> <number of registers read>
+         * <humidity MSB> <humidity LSB> <temp MSB> <temp LSB>
+         * <CRC LSB> <CRC MSB>
+         */
+        u8 rx_buf[8];
+        u16 crc;
+        /* First wake up the device. */
+        am2315_ping(data->client);
+        mutex_lock(&data->lock);
+        ret = i2c_master_send(data->client, tx_buf, sizeof(tx_buf));
+        if (ret < 0) {
+                dev_err(&data->client->dev, "failed to send read request\n");
+                goto exit_unlock;
+        }
+        /* Wait 2-3 ms, then read back the data sent by the device. */
+        usleep_range(2000, 3000);
+        /* Do a bulk data read, then pick out what we need. */
+        ret = i2c_master_recv(data->client, rx_buf, sizeof(rx_buf));
+        if (ret < 0) {
+                dev_err(&data->client->dev, "failed to read sensor data\n");
+                goto exit_unlock;
+        }
+        mutex_unlock(&data->lock);
+        /*
+         * Do a CRC check on the data and compare it to the value
+         * calculated by the device.
+         */
+        crc = am2315_crc(rx_buf, sizeof(rx_buf) - 2);
+        if ((crc & 0xff) != rx_buf[6] || (crc >> 8) != rx_buf[7]) {
+                dev_err(&data->client->dev, "failed to verify sensor data\n");
+                return -EIO;
+        }
+        sensor_data->hum_data = (rx_buf[AM2315_HUM_OFFSET] << 8) |
+                                 rx_buf[AM2315_HUM_OFFSET + 1];
+        sensor_data->temp_data = (rx_buf[AM2315_TEMP_OFFSET] << 8) |
+                                  rx_buf[AM2315_TEMP_OFFSET + 1];
+        return ret;
+exit_unlock:
+        mutex_unlock(&data->lock);
+        return ret;
+}
+static irqreturn_t am2315_trigger_handler(int irq, void *p)
+{
+        int i;
+        int ret;
+        int bit;
+        struct iio_poll_func *pf = p;
+        struct iio_dev *indio_dev = pf->indio_dev;
+        struct am2315_data *data = iio_priv(indio_dev);
+        struct am2315_sensor_data sensor_data;
+        ret = am2315_read_data(data, &sensor_data);
+        if (ret < 0) {
+                mutex_unlock(&data->lock);
+                goto err;
+        }
+        mutex_lock(&data->lock);
+        if (*(indio_dev->active_scan_mask) == AM2315_ALL_CHANNEL_MASK) {
+                data->buffer[0] = sensor_data.hum_data;
+                data->buffer[1] = sensor_data.temp_data;
+        } else {
+                i = 0;
+                for_each_set_bit(bit, indio_dev->active_scan_mask,
+                                 indio_dev->masklength) {
+                        data->buffer[i] = (bit ? sensor_data.temp_data :
+                                                 sensor_data.hum_data);
+                        i++;
+                }
+        }
+        mutex_unlock(&data->lock);
+        iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
+                                           pf->timestamp);
+err:
+        iio_trigger_notify_done(indio_dev->trig);
+        return IRQ_HANDLED;
+}
+static int am2315_read_raw(struct iio_dev *indio_dev,
+                           struct iio_chan_spec const *chan,
+                           int *val, int *val2, long mask)
+{
+        int ret;
+        struct am2315_sensor_data sensor_data;
+        struct am2315_data *data = iio_priv(indio_dev);
+        switch (mask) {
+        case IIO_CHAN_INFO_RAW:
+                ret = am2315_read_data(data, &sensor_data);
+                if (ret < 0)
+                        return ret;
+                *val = (chan->type == IIO_HUMIDITYRELATIVE) ?
+                                sensor_data.hum_data : sensor_data.temp_data;
+                return IIO_VAL_INT;
+        case IIO_CHAN_INFO_SCALE:
+                *val = 100;
+                return IIO_VAL_INT;
+        }
+        return -EINVAL;
+}
+static const struct iio_info am2315_info = {
+        .driver_module          = THIS_MODULE,
+        .read_raw               = am2315_read_raw,
+};
+static int am2315_probe(struct i2c_client *client,
+                        const struct i2c_device_id *id)
+{
+        int ret;
+        struct iio_dev *indio_dev;
+        struct am2315_data *data;
+        indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
+        if (!indio_dev) {
+                dev_err(&client->dev, "iio allocation failed!\n");
+                return -ENOMEM;
+        }
+        data = iio_priv(indio_dev);
+        data->client = client;
+        i2c_set_clientdata(client, indio_dev);
+        mutex_init(&data->lock);
+        indio_dev->dev.parent = &client->dev;
+        indio_dev->info = &am2315_info;
+        indio_dev->name = AM2315_DRIVER_NAME;
+        indio_dev->modes = INDIO_DIRECT_MODE;
+        indio_dev->channels = am2315_channels;
+        indio_dev->num_channels = ARRAY_SIZE(am2315_channels);
+        ret = iio_triggered_buffer_setup(indio_dev, NULL,
+                                         am2315_trigger_handler, NULL);
+        if (ret < 0) {
+                dev_err(&client->dev, "iio triggered buffer setup failed\n");
+                return ret;
+        }
+        ret = iio_device_register(indio_dev);
+        if (ret < 0)
+                goto err_buffer_cleanup;
+        return 0;
+err_buffer_cleanup:
+        iio_triggered_buffer_cleanup(indio_dev);
+        return ret;
+}
+static int am2315_remove(struct i2c_client *client)
+{
+        struct iio_dev *indio_dev = i2c_get_clientdata(client);
+        iio_device_unregister(indio_dev);
+        iio_triggered_buffer_cleanup(indio_dev);
+        return 0;
+}
+static const struct i2c_device_id am2315_i2c_id[] = {
+        {"am2315", 0},
+        {}
+};
+static const struct acpi_device_id am2315_acpi_id[] = {
+        {"AOS2315", 0},
+        {}
+};
+MODULE_DEVICE_TABLE(acpi, am2315_acpi_id);
+static struct i2c_driver am2315_driver = {
+        .driver = {
+                .name = "am2315",
+                .acpi_match_table = ACPI_PTR(am2315_acpi_id),
+        },
+        .probe =            am2315_probe,
+        .remove =           am2315_remove,
+        .id_table =         am2315_i2c_id,
+};
+module_i2c_driver(am2315_driver);
+MODULE_AUTHOR("Tiberiu Breana <tiberiu.a.breana@intel.com>");
+MODULE_DESCRIPTION("Aosong AM2315 relative humidity and temperature");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/humidity/dht11.c b/drivers/iio/humidity/dht11.c
index 20b500da94db..9c47bc98f3ac 100644
--- a/drivers/iio/humidity/dht11.c
+++ b/drivers/iio/humidity/dht11.c
@@ -96,6 +96,24 @@ struct dht11 {
        struct {s64 ts; int value; }    edges[DHT11_EDGES_PER_READ];
 };
+#ifdef CONFIG_DYNAMIC_DEBUG
+/*
+ * dht11_edges_print: show the data as actually received by the
+ *                    driver.
+ */
+static void dht11_edges_print(struct dht11 *dht11)
+{
+        int i;
+        dev_dbg(dht11->dev, "%d edges detected:\n", dht11->num_edges);
+        for (i = 1; i < dht11->num_edges; ++i) {
+                dev_dbg(dht11->dev, "%d: %lld ns %s\n", i,
+                        dht11->edges[i].ts - dht11->edges[i - 1].ts,
+                        dht11->edges[i - 1].value ? "high" : "low");
+        }
+}
+#endif /* CONFIG_DYNAMIC_DEBUG */
 static unsigned char dht11_decode_byte(char *bits)
 {
        unsigned char ret = 0;
@@ -119,8 +137,12 @@ static int dht11_decode(struct dht11 *dht11, int offset)
        for (i = 0; i < DHT11_BITS_PER_READ; ++i) {
                t = dht11->edges[offset + 2 * i + 2].ts -
                        dht11->edges[offset + 2 * i + 1].ts;
-                if (!dht11->edges[offset + 2 * i + 1].value)
+                if (!dht11->edges[offset + 2 * i + 1].value) {
-                        return -EIO;  /* lost synchronisation */
+                        dev_dbg(dht11->dev,
+                                "lost synchronisation at edge %d\n",
+                                offset + 2 * i + 1);
+                        return -EIO;
+                }
                bits[i] = t > DHT11_THRESHOLD;
        }
@@ -130,8 +152,10 @@ static int dht11_decode(struct dht11 *dht11, int offset)
        temp_dec = dht11_decode_byte(&bits[24]);
        checksum = dht11_decode_byte(&bits[32]);
-        if (((hum_int + hum_dec + temp_int + temp_dec) & 0xff) != checksum)
+        if (((hum_int + hum_dec + temp_int + temp_dec) & 0xff) != checksum) {
+                dev_dbg(dht11->dev, "invalid checksum\n");
                return -EIO;
+        }
        dht11->timestamp = ktime_get_boot_ns();
        if (hum_int < 20) {  /* DHT22 */
@@ -182,6 +206,7 @@ static int dht11_read_raw(struct iio_dev *iio_dev,
        mutex_lock(&dht11->lock);
        if (dht11->timestamp + DHT11_DATA_VALID_TIME < ktime_get_boot_ns()) {
                timeres = ktime_get_resolution_ns();
+                dev_dbg(dht11->dev, "current timeresolution: %dns\n", timeres);
                if (timeres > DHT11_MIN_TIMERES) {
                        dev_err(dht11->dev, "timeresolution %dns too low\n",
                                timeres);
@@ -219,10 +244,13 @@ static int dht11_read_raw(struct iio_dev *iio_dev,
                free_irq(dht11->irq, iio_dev);
+#ifdef CONFIG_DYNAMIC_DEBUG
+                dht11_edges_print(dht11);
+#endif
                if (ret == 0 && dht11->num_edges < DHT11_EDGES_PER_READ - 1) {
-                        dev_err(&iio_dev->dev,
+                        dev_err(dht11->dev, "Only %d signal edges detected\n",
-                                "Only %d signal edges detected\n",
+                                dht11->num_edges);
-                                        dht11->num_edges);
                        ret = -ETIMEDOUT;
                }
                if (ret < 0)
diff --git a/drivers/iio/imu/Kconfig b/drivers/iio/imu/Kconfig
index 5e610f7de5aa..1f1ad41ef881 100644
--- a/drivers/iio/imu/Kconfig
+++ b/drivers/iio/imu/Kconfig
@@ -25,6 +25,8 @@ config ADIS16480
          Say yes here to build support for Analog Devices ADIS16375, ADIS16480,
          ADIS16485, ADIS16488 inertial sensors.
+source "drivers/iio/imu/bmi160/Kconfig"
 config KMX61
        tristate "Kionix KMX61 6-axis accelerometer and magnetometer"
        depends on I2C
diff --git a/drivers/iio/imu/Makefile b/drivers/iio/imu/Makefile
index e1e6e3d70e26..c71bcd30dc38 100644
--- a/drivers/iio/imu/Makefile
+++ b/drivers/iio/imu/Makefile
@@ -13,6 +13,7 @@ adis_lib-$(CONFIG_IIO_ADIS_LIB_BUFFER) += adis_trigger.o
 adis_lib-$(CONFIG_IIO_ADIS_LIB_BUFFER) += adis_buffer.o
 obj-$(CONFIG_IIO_ADIS_LIB) += adis_lib.o
+obj-y += bmi160/
 obj-y += inv_mpu6050/
 obj-$(CONFIG_KMX61) += kmx61.o
diff --git a/drivers/iio/imu/adis.c b/drivers/iio/imu/adis.c
index 911255d41c1a..ad6f91d06185 100644
--- a/drivers/iio/imu/adis.c
+++ b/drivers/iio/imu/adis.c
@@ -324,7 +324,12 @@ static int adis_self_test(struct adis *adis)
        msleep(adis->data->startup_delay);
-        return adis_check_status(adis);
+        ret = adis_check_status(adis);
+        if (adis->data->self_test_no_autoclear)
+                adis_write_reg_16(adis, adis->data->msc_ctrl_reg, 0x00);
+        return ret;
 }
 /**
diff --git a/drivers/iio/imu/bmi160/Kconfig b/drivers/iio/imu/bmi160/Kconfig
new file mode 100644
index 000000000000..005c17ccc2b0
--- /dev/null
+++ b/drivers/iio/imu/bmi160/Kconfig
@@ -0,0 +1,32 @@
+#
+# BMI160 IMU driver
+#
+config BMI160
+        tristate
+        select IIO_BUFFER
+        select IIO_TRIGGERED_BUFFER
+config BMI160_I2C
+        tristate "Bosch BMI160 I2C driver"
+        depends on I2C
+        select BMI160
+        select REGMAP_I2C
+        help
+          If you say yes here you get support for BMI160 IMU on I2C with
+          accelerometer, gyroscope and external BMG160 magnetometer.
+          This driver can also be built as a module. If so, the module will be
+          called bmi160_i2c.
+config BMI160_SPI
+        tristate "Bosch BMI160 SPI driver"
+        depends on SPI
+        select BMI160
+        select REGMAP_SPI
+        help
+          If you say yes here you get support for BMI160 IMU on SPI with
+          accelerometer, gyroscope and external BMG160 magnetometer.
+          This driver can also be built as a module. If so, the module will be
+          called bmi160_spi.
diff --git a/drivers/iio/imu/bmi160/Makefile b/drivers/iio/imu/bmi160/Makefile
new file mode 100644
index 000000000000..10365e493ae2
--- /dev/null
+++ b/drivers/iio/imu/bmi160/Makefile
@@ -0,0 +1,6 @@
+#
+# Makefile for Bosch BMI160 IMU
+#
+obj-$(CONFIG_BMI160) += bmi160_core.o
+obj-$(CONFIG_BMI160_I2C) += bmi160_i2c.o
+obj-$(CONFIG_BMI160_SPI) += bmi160_spi.o
diff --git a/drivers/iio/imu/bmi160/bmi160.h b/drivers/iio/imu/bmi160/bmi160.h
new file mode 100644
index 000000000000..d2ae6ed70271
--- /dev/null
+++ b/drivers/iio/imu/bmi160/bmi160.h
@@ -0,0 +1,10 @@
+#ifndef BMI160_H_
+#define BMI160_H_
+extern const struct regmap_config bmi160_regmap_config;
+int bmi160_core_probe(struct device *dev, struct regmap *regmap,
+                      const char *name, bool use_spi);
+void bmi160_core_remove(struct device *dev);
+#endif  /* BMI160_H_ */
diff --git a/drivers/iio/imu/bmi160/bmi160_core.c b/drivers/iio/imu/bmi160/bmi160_core.c
new file mode 100644
index 000000000000..0bf92b06d7d8
--- /dev/null
+++ b/drivers/iio/imu/bmi160/bmi160_core.c
@@ -0,0 +1,596 @@
+/*
+ * BMI160 - Bosch IMU (accel, gyro plus external magnetometer)
+ *
+ * Copyright (c) 2016, Intel Corporation.
+ *
+ * This file is subject to the terms and conditions of version 2 of
+ * the GNU General Public License.  See the file COPYING in the main
+ * directory of this archive for more details.
+ *
+ * IIO core driver for BMI160, with support for I2C/SPI busses
+ *
+ * TODO: magnetometer, interrupts, hardware FIFO
+ */
+#include <linux/module.h>
+#include <linux/regmap.h>
+#include <linux/acpi.h>
+#include <linux/delay.h>
+#include <linux/iio/iio.h>
+#include <linux/iio/triggered_buffer.h>
+#include <linux/iio/trigger_consumer.h>
+#include <linux/iio/buffer.h>
+#include "bmi160.h"
+#define BMI160_REG_CHIP_ID      0x00
+#define BMI160_CHIP_ID_VAL      0xD1
+#define BMI160_REG_PMU_STATUS   0x03
+/* X axis data low byte address, the rest can be obtained using axis offset */
+#define BMI160_REG_DATA_MAGN_XOUT_L     0x04
+#define BMI160_REG_DATA_GYRO_XOUT_L     0x0C
+#define BMI160_REG_DATA_ACCEL_XOUT_L    0x12
+#define BMI160_REG_ACCEL_CONFIG         0x40
+#define BMI160_ACCEL_CONFIG_ODR_MASK    GENMASK(3, 0)
+#define BMI160_ACCEL_CONFIG_BWP_MASK    GENMASK(6, 4)
+#define BMI160_REG_ACCEL_RANGE          0x41
+#define BMI160_ACCEL_RANGE_2G           0x03
+#define BMI160_ACCEL_RANGE_4G           0x05
+#define BMI160_ACCEL_RANGE_8G           0x08
+#define BMI160_ACCEL_RANGE_16G          0x0C
+#define BMI160_REG_GYRO_CONFIG          0x42
+#define BMI160_GYRO_CONFIG_ODR_MASK     GENMASK(3, 0)
+#define BMI160_GYRO_CONFIG_BWP_MASK     GENMASK(5, 4)
+#define BMI160_REG_GYRO_RANGE           0x43
+#define BMI160_GYRO_RANGE_2000DPS       0x00
+#define BMI160_GYRO_RANGE_1000DPS       0x01
+#define BMI160_GYRO_RANGE_500DPS        0x02
+#define BMI160_GYRO_RANGE_250DPS        0x03
+#define BMI160_GYRO_RANGE_125DPS        0x04
+#define BMI160_REG_CMD                  0x7E
+#define BMI160_CMD_ACCEL_PM_SUSPEND     0x10
+#define BMI160_CMD_ACCEL_PM_NORMAL      0x11
+#define BMI160_CMD_ACCEL_PM_LOW_POWER   0x12
+#define BMI160_CMD_GYRO_PM_SUSPEND      0x14
+#define BMI160_CMD_GYRO_PM_NORMAL       0x15
+#define BMI160_CMD_GYRO_PM_FAST_STARTUP 0x17
+#define BMI160_CMD_SOFTRESET            0xB6
+#define BMI160_REG_DUMMY                0x7F
+#define BMI160_ACCEL_PMU_MIN_USLEEP     3200
+#define BMI160_ACCEL_PMU_MAX_USLEEP     3800
+#define BMI160_GYRO_PMU_MIN_USLEEP      55000
+#define BMI160_GYRO_PMU_MAX_USLEEP      80000
+#define BMI160_SOFTRESET_USLEEP         1000
+#define BMI160_CHANNEL(_type, _axis, _index) {                  \
+        .type = _type,                                          \
+        .modified = 1,                                          \
+        .channel2 = IIO_MOD_##_axis,                            \
+        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),           \
+        .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |  \
+                BIT(IIO_CHAN_INFO_SAMP_FREQ),                   \
+        .scan_index = _index,                                   \
+        .scan_type = {                                          \
+                .sign = 's',                                    \
+                .realbits = 16,                                 \
+                .storagebits = 16,                              \
+                .endianness = IIO_LE,                           \
+        },                                                      \
+}
+/* scan indexes follow DATA register order */
+enum bmi160_scan_axis {
+        BMI160_SCAN_EXT_MAGN_X = 0,
+        BMI160_SCAN_EXT_MAGN_Y,
+        BMI160_SCAN_EXT_MAGN_Z,
+        BMI160_SCAN_RHALL,
+        BMI160_SCAN_GYRO_X,
+        BMI160_SCAN_GYRO_Y,
+        BMI160_SCAN_GYRO_Z,
+        BMI160_SCAN_ACCEL_X,
+        BMI160_SCAN_ACCEL_Y,
+        BMI160_SCAN_ACCEL_Z,
+        BMI160_SCAN_TIMESTAMP,
+};
+enum bmi160_sensor_type {
+        BMI160_ACCEL    = 0,
+        BMI160_GYRO,
+        BMI160_EXT_MAGN,
+        BMI160_NUM_SENSORS /* must be last */
+};
+struct bmi160_data {
+        struct regmap *regmap;
+};
+const struct regmap_config bmi160_regmap_config = {
+        .reg_bits = 8,
+        .val_bits = 8,
+};
+EXPORT_SYMBOL(bmi160_regmap_config);
+struct bmi160_regs {
+        u8 data; /* LSB byte register for X-axis */
+        u8 config;
+        u8 config_odr_mask;
+        u8 config_bwp_mask;
+        u8 range;
+        u8 pmu_cmd_normal;
+        u8 pmu_cmd_suspend;
+};
+static struct bmi160_regs bmi160_regs[] = {
+        [BMI160_ACCEL] = {
+                .data   = BMI160_REG_DATA_ACCEL_XOUT_L,
+                .config = BMI160_REG_ACCEL_CONFIG,
+                .config_odr_mask = BMI160_ACCEL_CONFIG_ODR_MASK,
+                .config_bwp_mask = BMI160_ACCEL_CONFIG_BWP_MASK,
+                .range  = BMI160_REG_ACCEL_RANGE,
+                .pmu_cmd_normal = BMI160_CMD_ACCEL_PM_NORMAL,
+                .pmu_cmd_suspend = BMI160_CMD_ACCEL_PM_SUSPEND,
+        },
+        [BMI160_GYRO] = {
+                .data   = BMI160_REG_DATA_GYRO_XOUT_L,
+                .config = BMI160_REG_GYRO_CONFIG,
+                .config_odr_mask = BMI160_GYRO_CONFIG_ODR_MASK,
+                .config_bwp_mask = BMI160_GYRO_CONFIG_BWP_MASK,
+                .range  = BMI160_REG_GYRO_RANGE,
+                .pmu_cmd_normal = BMI160_CMD_GYRO_PM_NORMAL,
+                .pmu_cmd_suspend = BMI160_CMD_GYRO_PM_SUSPEND,
+        },
+};
+struct bmi160_pmu_time {
+        unsigned long min;
+        unsigned long max;
+};
+static struct bmi160_pmu_time bmi160_pmu_time[] = {
+        [BMI160_ACCEL] = {
+                .min = BMI160_ACCEL_PMU_MIN_USLEEP,
+                .max = BMI160_ACCEL_PMU_MAX_USLEEP
+        },
+        [BMI160_GYRO] = {
+                .min = BMI160_GYRO_PMU_MIN_USLEEP,
+                .max = BMI160_GYRO_PMU_MIN_USLEEP,
+        },
+};
+struct bmi160_scale {
+        u8 bits;
+        int uscale;
+};
+struct bmi160_odr {
+        u8 bits;
+        int odr;
+        int uodr;
+};
+static const struct bmi160_scale bmi160_accel_scale[] = {
+        { BMI160_ACCEL_RANGE_2G, 598},
+        { BMI160_ACCEL_RANGE_4G, 1197},
+        { BMI160_ACCEL_RANGE_8G, 2394},
+        { BMI160_ACCEL_RANGE_16G, 4788},
+};
+static const struct bmi160_scale bmi160_gyro_scale[] = {
+        { BMI160_GYRO_RANGE_2000DPS, 1065},
+        { BMI160_GYRO_RANGE_1000DPS, 532},
+        { BMI160_GYRO_RANGE_500DPS, 266},
+        { BMI160_GYRO_RANGE_250DPS, 133},
+        { BMI160_GYRO_RANGE_125DPS, 66},
+};
+struct bmi160_scale_item {
+        const struct bmi160_scale *tbl;
+        int num;
+};
+static const struct  bmi160_scale_item bmi160_scale_table[] = {
+        [BMI160_ACCEL] = {
+                .tbl    = bmi160_accel_scale,
+                .num    = ARRAY_SIZE(bmi160_accel_scale),
+        },
+        [BMI160_GYRO] = {
+                .tbl    = bmi160_gyro_scale,
+                .num    = ARRAY_SIZE(bmi160_gyro_scale),
+        },
+};
+static const struct bmi160_odr bmi160_accel_odr[] = {
+        {0x01, 0, 78125},
+        {0x02, 1, 5625},
+        {0x03, 3, 125},
+        {0x04, 6, 25},
+        {0x05, 12, 5},
+        {0x06, 25, 0},
+        {0x07, 50, 0},
+        {0x08, 100, 0},
+        {0x09, 200, 0},
+        {0x0A, 400, 0},
+        {0x0B, 800, 0},
+        {0x0C, 1600, 0},
+};
+static const struct bmi160_odr bmi160_gyro_odr[] = {
+        {0x06, 25, 0},
+        {0x07, 50, 0},
+        {0x08, 100, 0},
+        {0x09, 200, 0},
+        {0x0A, 400, 0},
+        {0x0B, 8000, 0},
+        {0x0C, 1600, 0},
+        {0x0D, 3200, 0},
+};
+struct bmi160_odr_item {
+        const struct bmi160_odr *tbl;
+        int num;
+};
+static const struct  bmi160_odr_item bmi160_odr_table[] = {
+        [BMI160_ACCEL] = {
+                .tbl    = bmi160_accel_odr,
+                .num    = ARRAY_SIZE(bmi160_accel_odr),
+        },
+        [BMI160_GYRO] = {
+                .tbl    = bmi160_gyro_odr,
+                .num    = ARRAY_SIZE(bmi160_gyro_odr),
+        },
+};
+static const struct iio_chan_spec bmi160_channels[] = {
+        BMI160_CHANNEL(IIO_ACCEL, X, BMI160_SCAN_ACCEL_X),
+        BMI160_CHANNEL(IIO_ACCEL, Y, BMI160_SCAN_ACCEL_Y),
+        BMI160_CHANNEL(IIO_ACCEL, Z, BMI160_SCAN_ACCEL_Z),
+        BMI160_CHANNEL(IIO_ANGL_VEL, X, BMI160_SCAN_GYRO_X),
+        BMI160_CHANNEL(IIO_ANGL_VEL, Y, BMI160_SCAN_GYRO_Y),
+        BMI160_CHANNEL(IIO_ANGL_VEL, Z, BMI160_SCAN_GYRO_Z),
+        IIO_CHAN_SOFT_TIMESTAMP(BMI160_SCAN_TIMESTAMP),
+};
+static enum bmi160_sensor_type bmi160_to_sensor(enum iio_chan_type iio_type)
+{
+        switch (iio_type) {
+        case IIO_ACCEL:
+                return BMI160_ACCEL;
+        case IIO_ANGL_VEL:
+                return BMI160_GYRO;
+        default:
+                return -EINVAL;
+        }
+}
+static
+int bmi160_set_mode(struct bmi160_data *data, enum bmi160_sensor_type t,
+                    bool mode)
+{
+        int ret;
+        u8 cmd;
+        if (mode)
+                cmd = bmi160_regs[t].pmu_cmd_normal;
+        else
+                cmd = bmi160_regs[t].pmu_cmd_suspend;
+        ret = regmap_write(data->regmap, BMI160_REG_CMD, cmd);
+        if (ret < 0)
+                return ret;
+        usleep_range(bmi160_pmu_time[t].min, bmi160_pmu_time[t].max);
+        return 0;
+}
+static
+int bmi160_set_scale(struct bmi160_data *data, enum bmi160_sensor_type t,
+                     int uscale)
+{
+        int i;
+        for (i = 0; i < bmi160_scale_table[t].num; i++)
+                if (bmi160_scale_table[t].tbl[i].uscale == uscale)
+                        break;
+        if (i == bmi160_scale_table[t].num)
+                return -EINVAL;
+        return regmap_write(data->regmap, bmi160_regs[t].range,
+                            bmi160_scale_table[t].tbl[i].bits);
+}
+static
+int bmi160_get_scale(struct bmi160_data *data, enum bmi160_sensor_type t,
+                     int *uscale)
+{
+        int i, ret, val;
+        ret = regmap_read(data->regmap, bmi160_regs[t].range, &val);
+        if (ret < 0)
+                return ret;
+        for (i = 0; i < bmi160_scale_table[t].num; i++)
+                if (bmi160_scale_table[t].tbl[i].bits == val) {
+                        *uscale = bmi160_scale_table[t].tbl[i].uscale;
+                        return 0;
+                }
+        return -EINVAL;
+}
+static int bmi160_get_data(struct bmi160_data *data, int chan_type,
+                           int axis, int *val)
+{
+        u8 reg;
+        int ret;
+        __le16 sample;
+        enum bmi160_sensor_type t = bmi160_to_sensor(chan_type);
+        reg = bmi160_regs[t].data + (axis - IIO_MOD_X) * sizeof(__le16);
+        ret = regmap_bulk_read(data->regmap, reg, &sample, sizeof(__le16));
+        if (ret < 0)
+                return ret;
+        *val = sign_extend32(le16_to_cpu(sample), 15);
+        return 0;
+}
+static
+int bmi160_set_odr(struct bmi160_data *data, enum bmi160_sensor_type t,
+                   int odr, int uodr)
+{
+        int i;
+        for (i = 0; i < bmi160_odr_table[t].num; i++)
+                if (bmi160_odr_table[t].tbl[i].odr == odr &&
+                    bmi160_odr_table[t].tbl[i].uodr == uodr)
+                        break;
+        if (i >= bmi160_odr_table[t].num)
+                return -EINVAL;
+        return regmap_update_bits(data->regmap,
+                                  bmi160_regs[t].config,
+                                  bmi160_odr_table[t].tbl[i].bits,
+                                  bmi160_regs[t].config_odr_mask);
+}
+static int bmi160_get_odr(struct bmi160_data *data, enum bmi160_sensor_type t,
+                          int *odr, int *uodr)
+{
+        int i, val, ret;
+        ret = regmap_read(data->regmap, bmi160_regs[t].config, &val);
+        if (ret < 0)
+                return ret;
+        val &= bmi160_regs[t].config_odr_mask;
+        for (i = 0; i < bmi160_odr_table[t].num; i++)
+                if (val == bmi160_odr_table[t].tbl[i].bits)
+                        break;
+        if (i >= bmi160_odr_table[t].num)
+                return -EINVAL;
+        *odr = bmi160_odr_table[t].tbl[i].odr;
+        *uodr = bmi160_odr_table[t].tbl[i].uodr;
+        return 0;
+}
+static irqreturn_t bmi160_trigger_handler(int irq, void *p)
+{
+        struct iio_poll_func *pf = p;
+        struct iio_dev *indio_dev = pf->indio_dev;
+        struct bmi160_data *data = iio_priv(indio_dev);
+        s16 buf[16]; /* 3 sens x 3 axis x s16 + 3 x s16 pad + 4 x s16 tstamp */
+        int i, ret, j = 0, base = BMI160_REG_DATA_MAGN_XOUT_L;
+        __le16 sample;
+        for_each_set_bit(i, indio_dev->active_scan_mask,
+                         indio_dev->masklength) {
+                ret = regmap_bulk_read(data->regmap, base + i * sizeof(__le16),
+                                       &sample, sizeof(__le16));
+                if (ret < 0)
+                        goto done;
+                buf[j++] = sample;
+        }
+        iio_push_to_buffers_with_timestamp(indio_dev, buf, iio_get_time_ns());
+done:
+        iio_trigger_notify_done(indio_dev->trig);
+        return IRQ_HANDLED;
+}
+static int bmi160_read_raw(struct iio_dev *indio_dev,
+                           struct iio_chan_spec const *chan,
+                           int *val, int *val2, long mask)
+{
+        int ret;
+        struct bmi160_data *data = iio_priv(indio_dev);
+        switch (mask) {
+        case IIO_CHAN_INFO_RAW:
+                ret = bmi160_get_data(data, chan->type, chan->channel2, val);
+                if (ret < 0)
+                        return ret;
+                return IIO_VAL_INT;
+        case IIO_CHAN_INFO_SCALE:
+                *val = 0;
+                ret = bmi160_get_scale(data,
+                                       bmi160_to_sensor(chan->type), val2);
+                return ret < 0 ? ret : IIO_VAL_INT_PLUS_MICRO;
+        case IIO_CHAN_INFO_SAMP_FREQ:
+                ret = bmi160_get_odr(data, bmi160_to_sensor(chan->type),
+                                     val, val2);
+                return ret < 0 ? ret : IIO_VAL_INT_PLUS_MICRO;
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
+static int bmi160_write_raw(struct iio_dev *indio_dev,
+                            struct iio_chan_spec const *chan,
+                            int val, int val2, long mask)
+{
+        struct bmi160_data *data = iio_priv(indio_dev);
+        switch (mask) {
+        case IIO_CHAN_INFO_SCALE:
+                return bmi160_set_scale(data,
+                                        bmi160_to_sensor(chan->type), val2);
+                break;
+        case IIO_CHAN_INFO_SAMP_FREQ:
+                return bmi160_set_odr(data, bmi160_to_sensor(chan->type),
+                                      val, val2);
+        default:
+                return -EINVAL;
+        }
+        return 0;
+}
+static const struct iio_info bmi160_info = {
+        .driver_module = THIS_MODULE,
+        .read_raw = bmi160_read_raw,
+        .write_raw = bmi160_write_raw,
+};
+static const char *bmi160_match_acpi_device(struct device *dev)
+{
+        const struct acpi_device_id *id;
+        id = acpi_match_device(dev->driver->acpi_match_table, dev);
+        if (!id)
+                return NULL;
+        return dev_name(dev);
+}
+static int bmi160_chip_init(struct bmi160_data *data, bool use_spi)
+{
+        int ret;
+        unsigned int val;
+        struct device *dev = regmap_get_device(data->regmap);
+        ret = regmap_write(data->regmap, BMI160_REG_CMD, BMI160_CMD_SOFTRESET);
+        if (ret < 0)
+                return ret;
+        usleep_range(BMI160_SOFTRESET_USLEEP, BMI160_SOFTRESET_USLEEP + 1);
+        /*
+         * CS rising edge is needed before starting SPI, so do a dummy read
+         * See Section 3.2.1, page 86 of the datasheet
+         */
+        if (use_spi) {
+                ret = regmap_read(data->regmap, BMI160_REG_DUMMY, &val);
+                if (ret < 0)
+                        return ret;
+        }
+        ret = regmap_read(data->regmap, BMI160_REG_CHIP_ID, &val);
+        if (ret < 0) {
+                dev_err(dev, "Error reading chip id\n");
+                return ret;
+        }
+        if (val != BMI160_CHIP_ID_VAL) {
+                dev_err(dev, "Wrong chip id, got %x expected %x\n",
+                        val, BMI160_CHIP_ID_VAL);
+                return -ENODEV;
+        }
+        ret = bmi160_set_mode(data, BMI160_ACCEL, true);
+        if (ret < 0)
+                return ret;
+        ret = bmi160_set_mode(data, BMI160_GYRO, true);
+        if (ret < 0)
+                return ret;
+        return 0;
+}
+static void bmi160_chip_uninit(struct bmi160_data *data)
+{
+        bmi160_set_mode(data, BMI160_GYRO, false);
+        bmi160_set_mode(data, BMI160_ACCEL, false);
+}
+int bmi160_core_probe(struct device *dev, struct regmap *regmap,
+                      const char *name, bool use_spi)
+{
+        struct iio_dev *indio_dev;
+        struct bmi160_data *data;
+        int ret;
+        indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
+        if (!indio_dev)
+                return -ENOMEM;
+        data = iio_priv(indio_dev);
+        dev_set_drvdata(dev, indio_dev);
+        data->regmap = regmap;
+        ret = bmi160_chip_init(data, use_spi);
+        if (ret < 0)
+                return ret;
+        if (!name && ACPI_HANDLE(dev))
+                name = bmi160_match_acpi_device(dev);
+        indio_dev->dev.parent = dev;
+        indio_dev->channels = bmi160_channels;
+        indio_dev->num_channels = ARRAY_SIZE(bmi160_channels);
+        indio_dev->name = name;
+        indio_dev->modes = INDIO_DIRECT_MODE;
+        indio_dev->info = &bmi160_info;
+        ret = iio_triggered_buffer_setup(indio_dev, NULL,
+                                         bmi160_trigger_handler, NULL);
+        if (ret < 0)
+                goto uninit;
+        ret = iio_device_register(indio_dev);
+        if (ret < 0)
+                goto buffer_cleanup;
+        return 0;
+buffer_cleanup:
+        iio_triggered_buffer_cleanup(indio_dev);
+uninit:
+        bmi160_chip_uninit(data);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(bmi160_core_probe);
+void bmi160_core_remove(struct device *dev)
+{
+        struct iio_dev *indio_dev = dev_get_drvdata(dev);
+        struct bmi160_data *data = iio_priv(indio_dev);
+        iio_device_unregister(indio_dev);
+        iio_triggered_buffer_cleanup(indio_dev);
+        bmi160_chip_uninit(data);
+}
+EXPORT_SYMBOL_GPL(bmi160_core_remove);
+MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com");
+MODULE_DESCRIPTION("Bosch BMI160 driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/imu/bmi160/bmi160_i2c.c b/drivers/iio/imu/bmi160/bmi160_i2c.c
new file mode 100644
index 000000000000..07a179d8fb48
--- /dev/null
+++ b/drivers/iio/imu/bmi160/bmi160_i2c.c
@@ -0,0 +1,72 @@
+/*
+ * BMI160 - Bosch IMU, I2C bits
+ *
+ * Copyright (c) 2016, Intel Corporation.
+ *
+ * This file is subject to the terms and conditions of version 2 of
+ * the GNU General Public License.  See the file COPYING in the main
+ * directory of this archive for more details.
+ *
+ * 7-bit I2C slave address is:
+ *      - 0x68 if SDO is pulled to GND
+ *      - 0x69 if SDO is pulled to VDDIO
+ */
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/regmap.h>
+#include <linux/acpi.h>
+#include "bmi160.h"
+static int bmi160_i2c_probe(struct i2c_client *client,
+                            const struct i2c_device_id *id)
+{
+        struct regmap *regmap;
+        const char *name = NULL;
+        regmap = devm_regmap_init_i2c(client, &bmi160_regmap_config);
+        if (IS_ERR(regmap)) {
+                dev_err(&client->dev, "Failed to register i2c regmap %d\n",
+                        (int)PTR_ERR(regmap));
+                return PTR_ERR(regmap);
+        }
+        if (id)
+                name = id->name;
+        return bmi160_core_probe(&client->dev, regmap, name, false);
+}
+static int bmi160_i2c_remove(struct i2c_client *client)
+{
+        bmi160_core_remove(&client->dev);
+        return 0;
+}
+static const struct i2c_device_id bmi160_i2c_id[] = {
+        {"bmi160", 0},
+        {}
+};
+MODULE_DEVICE_TABLE(i2c, bmi160_i2c_id);
+static const struct acpi_device_id bmi160_acpi_match[] = {
+        {"BMI0160", 0},
+        { },
+};
+MODULE_DEVICE_TABLE(acpi, bmi160_acpi_match);
+static struct i2c_driver bmi160_i2c_driver = {
+        .driver = {
+                .name                   = "bmi160_i2c",
+                .acpi_match_table       = ACPI_PTR(bmi160_acpi_match),
+        },
+        .probe          = bmi160_i2c_probe,
+        .remove         = bmi160_i2c_remove,
+        .id_table       = bmi160_i2c_id,
+};
+module_i2c_driver(bmi160_i2c_driver);
+MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com>");
+MODULE_DESCRIPTION("BMI160 I2C driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/imu/bmi160/bmi160_spi.c b/drivers/iio/imu/bmi160/bmi160_spi.c
new file mode 100644
index 000000000000..1ec8b12bd984
--- /dev/null
+++ b/drivers/iio/imu/bmi160/bmi160_spi.c
@@ -0,0 +1,63 @@
+/*
+ * BMI160 - Bosch IMU, SPI bits
+ *
+ * Copyright (c) 2016, Intel Corporation.
+ *
+ * This file is subject to the terms and conditions of version 2 of
+ * the GNU General Public License.  See the file COPYING in the main
+ * directory of this archive for more details.
+ */
+#include <linux/module.h>
+#include <linux/spi/spi.h>
+#include <linux/regmap.h>
+#include <linux/acpi.h>
+#include "bmi160.h"
+static int bmi160_spi_probe(struct spi_device *spi)
+{
+        struct regmap *regmap;
+        const struct spi_device_id *id = spi_get_device_id(spi);
+        regmap = devm_regmap_init_spi(spi, &bmi160_regmap_config);
+        if (IS_ERR(regmap)) {
+                dev_err(&spi->dev, "Failed to register spi regmap %d\n",
+                        (int)PTR_ERR(regmap));
+                return PTR_ERR(regmap);
+        }
+        return bmi160_core_probe(&spi->dev, regmap, id->name, true);
+}
+static int bmi160_spi_remove(struct spi_device *spi)
+{
+        bmi160_core_remove(&spi->dev);
+        return 0;
+}
+static const struct spi_device_id bmi160_spi_id[] = {
+        {"bmi160", 0},
+        {}
+};
+MODULE_DEVICE_TABLE(spi, bmi160_spi_id);
+static const struct acpi_device_id bmi160_acpi_match[] = {
+        {"BMI0160", 0},
+        { },
+};
+MODULE_DEVICE_TABLE(acpi, bmi160_acpi_match);
+static struct spi_driver bmi160_spi_driver = {
+        .probe          = bmi160_spi_probe,
+        .remove         = bmi160_spi_remove,
+        .id_table       = bmi160_spi_id,
+        .driver = {
+                .acpi_match_table = ACPI_PTR(bmi160_acpi_match),
+                .name   = "bmi160_spi",
+        },
+};
+module_spi_driver(bmi160_spi_driver);
+MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com");
+MODULE_DESCRIPTION("Bosch BMI160 SPI driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/imu/inv_mpu6050/Kconfig b/drivers/iio/imu/inv_mpu6050/Kconfig
index 847455a2d6bb..f756feecfa4c 100644
--- a/drivers/iio/imu/inv_mpu6050/Kconfig
+++ b/drivers/iio/imu/inv_mpu6050/Kconfig
@@ -13,10 +13,8 @@ config INV_MPU6050_I2C
        select INV_MPU6050_IIO
        select REGMAP_I2C
        help
-          This driver supports the Invensense MPU6050 devices.
+          This driver supports the Invensense MPU6050/6500/9150 motion tracking
-          This driver can also support MPU6500 in MPU6050 compatibility mode
+          devices over I2C.
-          and also in MPU6500 mode with some limitations.
-          It is a gyroscope/accelerometer combo device.
          This driver can be built as a module. The module will be called
          inv-mpu6050-i2c.
@@ -26,7 +24,7 @@ config INV_MPU6050_SPI
        select INV_MPU6050_IIO
        select REGMAP_SPI
        help
-          This driver supports the Invensense MPU6050 devices.
+          This driver supports the Invensense MPU6000/6500/9150 motion tracking
-          It is a gyroscope/accelerometer combo device.
+          devices over SPI.
          This driver can be built as a module. The module will be called
          inv-mpu6050-spi.
diff --git a/drivers/iio/imu/inv_mpu6050/inv_mpu_core.c b/drivers/iio/imu/inv_mpu6050/inv_mpu_core.c
index d192953e9a38..b269b375ca34 100644
--- a/drivers/iio/imu/inv_mpu6050/inv_mpu_core.c
+++ b/drivers/iio/imu/inv_mpu6050/inv_mpu_core.c
@@ -88,16 +88,29 @@ static const struct inv_mpu6050_chip_config chip_config_6050 = {
        .accl_fs = INV_MPU6050_FS_02G,
 };
+/* Indexed by enum inv_devices */
 static const struct inv_mpu6050_hw hw_info[] = {
        {
-                .num_reg = 117,
+                .whoami = INV_MPU6050_WHOAMI_VALUE,
+                .name = "MPU6050",
+                .reg = &reg_set_6050,
+                .config = &chip_config_6050,
+        },
+        {
+                .whoami = INV_MPU6500_WHOAMI_VALUE,
                .name = "MPU6500",
                .reg = &reg_set_6500,
                .config = &chip_config_6050,
        },
        {
-                .num_reg = 117,
+                .whoami = INV_MPU6000_WHOAMI_VALUE,
-                .name = "MPU6050",
+                .name = "MPU6000",
+                .reg = &reg_set_6050,
+                .config = &chip_config_6050,
+        },
+        {
+                .whoami = INV_MPU9150_WHOAMI_VALUE,
+                .name = "MPU9150",
                .reg = &reg_set_6050,
                .config = &chip_config_6050,
        },
@@ -600,6 +613,10 @@ inv_fifo_rate_show(struct device *dev, struct device_attribute *attr,
 /**
 * inv_attr_show() - calling this function will show current
 *                    parameters.
+ *
+ * Deprecated in favor of IIO mounting matrix API.
+ *
+ * See inv_get_mount_matrix()
 */
 static ssize_t inv_attr_show(struct device *dev, struct device_attribute *attr,
                             char *buf)
@@ -644,6 +661,18 @@ static int inv_mpu6050_validate_trigger(struct iio_dev *indio_dev,
        return 0;
 }
+static const struct iio_mount_matrix *
+inv_get_mount_matrix(const struct iio_dev *indio_dev,
+                     const struct iio_chan_spec *chan)
+{
+        return &((struct inv_mpu6050_state *)iio_priv(indio_dev))->orientation;
+}
+static const struct iio_chan_spec_ext_info inv_ext_info[] = {
+        IIO_MOUNT_MATRIX(IIO_SHARED_BY_TYPE, inv_get_mount_matrix),
+        { },
+};
 #define INV_MPU6050_CHAN(_type, _channel2, _index)                    \
        {                                                             \
                .type = _type,                                        \
@@ -660,6 +689,7 @@ static int inv_mpu6050_validate_trigger(struct iio_dev *indio_dev,
                                .shift = 0,                           \
                                .endianness = IIO_BE,                 \
                             },                                       \
+                .ext_info = inv_ext_info,                             \
        }
 static const struct iio_chan_spec inv_mpu_channels[] = {
@@ -692,14 +722,16 @@ static IIO_CONST_ATTR(in_accel_scale_available,
                                          "0.000598 0.001196 0.002392 0.004785");
 static IIO_DEV_ATTR_SAMP_FREQ(S_IRUGO | S_IWUSR, inv_fifo_rate_show,
        inv_mpu6050_fifo_rate_store);
+/* Deprecated: kept for userspace backward compatibility. */
 static IIO_DEVICE_ATTR(in_gyro_matrix, S_IRUGO, inv_attr_show, NULL,
        ATTR_GYRO_MATRIX);
 static IIO_DEVICE_ATTR(in_accel_matrix, S_IRUGO, inv_attr_show, NULL,
        ATTR_ACCL_MATRIX);
 static struct attribute *inv_attributes[] = {
-        &iio_dev_attr_in_gyro_matrix.dev_attr.attr,
+        &iio_dev_attr_in_gyro_matrix.dev_attr.attr,  /* deprecated */
-        &iio_dev_attr_in_accel_matrix.dev_attr.attr,
+        &iio_dev_attr_in_accel_matrix.dev_attr.attr, /* deprecated */
        &iio_dev_attr_sampling_frequency.dev_attr.attr,
        &iio_const_attr_sampling_frequency_available.dev_attr.attr,
        &iio_const_attr_in_accel_scale_available.dev_attr.attr,
@@ -726,6 +758,7 @@ static const struct iio_info mpu_info = {
 static int inv_check_and_setup_chip(struct inv_mpu6050_state *st)
 {
        int result;
+        unsigned int regval;
        st->hw  = &hw_info[st->chip_type];
        st->reg = hw_info[st->chip_type].reg;
@@ -736,6 +769,17 @@ static int inv_check_and_setup_chip(struct inv_mpu6050_state *st)
        if (result)
                return result;
        msleep(INV_MPU6050_POWER_UP_TIME);
+        /* check chip self-identification */
+        result = regmap_read(st->map, INV_MPU6050_REG_WHOAMI, &regval);
+        if (result)
+                return result;
+        if (regval != st->hw->whoami) {
+                dev_warn(regmap_get_device(st->map),
+                                "whoami mismatch got %#02x expected %#02hhx for %s\n",
+                                regval, st->hw->whoami, st->hw->name);
+        }
        /*
         * toggle power state. After reset, the sleep bit could be on
         * or off depending on the OTP settings. Toggling power would
@@ -774,14 +818,31 @@ int inv_mpu_core_probe(struct regmap *regmap, int irq, const char *name,
        if (!indio_dev)
                return -ENOMEM;
+        BUILD_BUG_ON(ARRAY_SIZE(hw_info) != INV_NUM_PARTS);
+        if (chip_type < 0 || chip_type >= INV_NUM_PARTS) {
+                dev_err(dev, "Bad invensense chip_type=%d name=%s\n",
+                                chip_type, name);
+                return -ENODEV;
+        }
        st = iio_priv(indio_dev);
        st->chip_type = chip_type;
        st->powerup_count = 0;
        st->irq = irq;
        st->map = regmap;
        pdata = dev_get_platdata(dev);
-        if (pdata)
+        if (!pdata) {
+                result = of_iio_read_mount_matrix(dev, "mount-matrix",
+                                                  &st->orientation);
+                if (result) {
+                        dev_err(dev, "Failed to retrieve mounting matrix %d\n",
+                                result);
+                        return result;
+                }
+        } else {
                st->plat_data = *pdata;
+        }
        /* power is turned on inside check chip type*/
        result = inv_check_and_setup_chip(st);
        if (result)
diff --git a/drivers/iio/imu/inv_mpu6050/inv_mpu_i2c.c b/drivers/iio/imu/inv_mpu6050/inv_mpu_i2c.c
index 5ee4e0dc093e..1a424a6561de 100644
--- a/drivers/iio/imu/inv_mpu6050/inv_mpu_i2c.c
+++ b/drivers/iio/imu/inv_mpu6050/inv_mpu_i2c.c
@@ -202,13 +202,14 @@ static int inv_mpu_remove(struct i2c_client *client)
 static const struct i2c_device_id inv_mpu_id[] = {
        {"mpu6050", INV_MPU6050},
        {"mpu6500", INV_MPU6500},
+        {"mpu9150", INV_MPU9150},
        {}
 };
 MODULE_DEVICE_TABLE(i2c, inv_mpu_id);
 static const struct acpi_device_id inv_acpi_match[] = {
-        {"INVN6500", 0},
+        {"INVN6500", INV_MPU6500},
        { },
 };
diff --git a/drivers/iio/imu/inv_mpu6050/inv_mpu_iio.h b/drivers/iio/imu/inv_mpu6050/inv_mpu_iio.h
index e302a49703bf..47ca25b94a73 100644
--- a/drivers/iio/imu/inv_mpu6050/inv_mpu_iio.h
+++ b/drivers/iio/imu/inv_mpu6050/inv_mpu_iio.h
@@ -68,6 +68,7 @@ enum inv_devices {
        INV_MPU6050,
        INV_MPU6500,
        INV_MPU6000,
+        INV_MPU9150,
        INV_NUM_PARTS
 };
@@ -93,13 +94,13 @@ struct inv_mpu6050_chip_config {
 /**
 *  struct inv_mpu6050_hw - Other important hardware information.
- *  @num_reg:   Number of registers on device.
+ *  @whoami:    Self identification byte from WHO_AM_I register
 *  @name:      name of the chip.
 *  @reg:   register map of the chip.
 *  @config:    configuration of the chip.
 */
 struct inv_mpu6050_hw {
-        u8 num_reg;
+        u8 whoami;
        u8 *name;
        const struct inv_mpu6050_reg_map *reg;
        const struct inv_mpu6050_chip_config *config;
@@ -114,7 +115,8 @@ struct inv_mpu6050_hw {
 *  @hw:                Other hardware-specific information.
 *  @chip_type:         chip type.
 *  @time_stamp_lock:   spin lock to time stamp.
- *  @plat_data:         platform data.
+ *  @plat_data:         platform data (deprecated in favor of @orientation).
+ *  @orientation:       sensor chip orientation relative to main hardware.
 *  @timestamps:        kfifo queue to store time stamp.
 *  @map                regmap pointer.
 *  @irq                interrupt number.
@@ -131,6 +133,7 @@ struct inv_mpu6050_state {
        struct i2c_client *mux_client;
        unsigned int powerup_count;
        struct inv_mpu6050_platform_data plat_data;
+        struct iio_mount_matrix orientation;
        DECLARE_KFIFO(timestamps, long long, TIMESTAMP_FIFO_SIZE);
        struct regmap *map;
        int irq;
@@ -215,6 +218,13 @@ struct inv_mpu6050_state {
 #define INV_MPU6050_MIN_FIFO_RATE            4
 #define INV_MPU6050_ONE_K_HZ                 1000
+#define INV_MPU6050_REG_WHOAMI                  117
+#define INV_MPU6000_WHOAMI_VALUE                0x68
+#define INV_MPU6050_WHOAMI_VALUE                0x68
+#define INV_MPU6500_WHOAMI_VALUE                0x70
+#define INV_MPU9150_WHOAMI_VALUE                0x68
 /* scan element definition */
 enum inv_mpu6050_scan {
        INV_MPU6050_SCAN_ACCL_X,
diff --git a/drivers/iio/imu/inv_mpu6050/inv_mpu_spi.c b/drivers/iio/imu/inv_mpu6050/inv_mpu_spi.c
index 7bcb8d839f05..190a4a51c830 100644
--- a/drivers/iio/imu/inv_mpu6050/inv_mpu_spi.c
+++ b/drivers/iio/imu/inv_mpu6050/inv_mpu_spi.c
@@ -44,9 +44,19 @@ static int inv_mpu_i2c_disable(struct iio_dev *indio_dev)
 static int inv_mpu_probe(struct spi_device *spi)
 {
        struct regmap *regmap;
-        const struct spi_device_id *id = spi_get_device_id(spi);
+        const struct spi_device_id *spi_id;
-        const char *name = id ? id->name : NULL;
+        const struct acpi_device_id *acpi_id;
-        const int chip_type = id ? id->driver_data : 0;
+        const char *name = NULL;
+        enum inv_devices chip_type;
+        if ((spi_id = spi_get_device_id(spi))) {
+                chip_type = (enum inv_devices)spi_id->driver_data;
+                name = spi_id->name;
+        } else if ((acpi_id = acpi_match_device(spi->dev.driver->acpi_match_table, &spi->dev))) {
+                chip_type = (enum inv_devices)acpi_id->driver_data;
+        } else {
+                return -ENODEV;
+        }
        regmap = devm_regmap_init_spi(spi, &inv_mpu_regmap_config);
        if (IS_ERR(regmap)) {
@@ -70,13 +80,15 @@ static int inv_mpu_remove(struct spi_device *spi)
 */
 static const struct spi_device_id inv_mpu_id[] = {
        {"mpu6000", INV_MPU6000},
+        {"mpu6500", INV_MPU6500},
+        {"mpu9150", INV_MPU9150},
        {}
 };
 MODULE_DEVICE_TABLE(spi, inv_mpu_id);
 static const struct acpi_device_id inv_acpi_match[] = {
-        {"INVN6000", 0},
+        {"INVN6000", INV_MPU6000},
        { },
 };
 MODULE_DEVICE_TABLE(acpi, inv_acpi_match);
diff --git a/drivers/iio/industrialio-core.c b/drivers/iio/industrialio-core.c
index 190a5939fd8c..e6319a9346b2 100644
--- a/drivers/iio/industrialio-core.c
+++ b/drivers/iio/industrialio-core.c
@@ -412,6 +412,88 @@ ssize_t iio_enum_write(struct iio_dev *indio_dev,
 }
 EXPORT_SYMBOL_GPL(iio_enum_write);
+static const struct iio_mount_matrix iio_mount_idmatrix = {
+        .rotation = {
+                "1", "0", "0",
+                "0", "1", "0",
+                "0", "0", "1"
+        }
+};
+static int iio_setup_mount_idmatrix(const struct device *dev,
+                                    struct iio_mount_matrix *matrix)
+{
+        *matrix = iio_mount_idmatrix;
+        dev_info(dev, "mounting matrix not found: using identity...\n");
+        return 0;
+}
+ssize_t iio_show_mount_matrix(struct iio_dev *indio_dev, uintptr_t priv,
+                              const struct iio_chan_spec *chan, char *buf)
+{
+        const struct iio_mount_matrix *mtx = ((iio_get_mount_matrix_t *)
+                                              priv)(indio_dev, chan);
+        if (IS_ERR(mtx))
+                return PTR_ERR(mtx);
+        if (!mtx)
+                mtx = &iio_mount_idmatrix;
+        return snprintf(buf, PAGE_SIZE, "%s, %s, %s; %s, %s, %s; %s, %s, %s\n",
+                        mtx->rotation[0], mtx->rotation[1], mtx->rotation[2],
+                        mtx->rotation[3], mtx->rotation[4], mtx->rotation[5],
+                        mtx->rotation[6], mtx->rotation[7], mtx->rotation[8]);
+}
+EXPORT_SYMBOL_GPL(iio_show_mount_matrix);
+/**
+ * of_iio_read_mount_matrix() - retrieve iio device mounting matrix from
+ *                              device-tree "mount-matrix" property
+ * @dev:        device the mounting matrix property is assigned to
+ * @propname:   device specific mounting matrix property name
+ * @matrix:     where to store retrieved matrix
+ *
+ * If device is assigned no mounting matrix property, a default 3x3 identity
+ * matrix will be filled in.
+ *
+ * Return: 0 if success, or a negative error code on failure.
+ */
+#ifdef CONFIG_OF
+int of_iio_read_mount_matrix(const struct device *dev,
+                             const char *propname,
+                             struct iio_mount_matrix *matrix)
+{
+        if (dev->of_node) {
+                int err = of_property_read_string_array(dev->of_node,
+                                propname, matrix->rotation,
+                                ARRAY_SIZE(iio_mount_idmatrix.rotation));
+                if (err == ARRAY_SIZE(iio_mount_idmatrix.rotation))
+                        return 0;
+                if (err >= 0)
+                        /* Invalid number of matrix entries. */
+                        return -EINVAL;
+                if (err != -EINVAL)
+                        /* Invalid matrix declaration format. */
+                        return err;
+        }
+        /* Matrix was not declared at all: fallback to identity. */
+        return iio_setup_mount_idmatrix(dev, matrix);
+}
+#else
+int of_iio_read_mount_matrix(const struct device *dev,
+                             const char *propname,
+                             struct iio_mount_matrix *matrix)
+{
+        return iio_setup_mount_idmatrix(dev, matrix);
+}
+#endif
+EXPORT_SYMBOL(of_iio_read_mount_matrix);
 /**
 * iio_format_value() - Formats a IIO value into its string representation
 * @buf:        The buffer to which the formatted value gets written
diff --git a/drivers/iio/inkern.c b/drivers/iio/inkern.c
index 734a0042de0c..c4757e6367e7 100644
--- a/drivers/iio/inkern.c
+++ b/drivers/iio/inkern.c
@@ -356,6 +356,54 @@ void iio_channel_release(struct iio_channel *channel)
 }
 EXPORT_SYMBOL_GPL(iio_channel_release);
+static void devm_iio_channel_free(struct device *dev, void *res)
+{
+        struct iio_channel *channel = *(struct iio_channel **)res;
+        iio_channel_release(channel);
+}
+static int devm_iio_channel_match(struct device *dev, void *res, void *data)
+{
+        struct iio_channel **r = res;
+        if (!r || !*r) {
+                WARN_ON(!r || !*r);
+                return 0;
+        }
+        return *r == data;
+}
+struct iio_channel *devm_iio_channel_get(struct device *dev,
+                                         const char *channel_name)
+{
+        struct iio_channel **ptr, *channel;
+        ptr = devres_alloc(devm_iio_channel_free, sizeof(*ptr), GFP_KERNEL);
+        if (!ptr)
+                return ERR_PTR(-ENOMEM);
+        channel = iio_channel_get(dev, channel_name);
+        if (IS_ERR(channel)) {
+                devres_free(ptr);
+                return channel;
+        }
+        *ptr = channel;
+        devres_add(dev, ptr);
+        return channel;
+}
+EXPORT_SYMBOL_GPL(devm_iio_channel_get);
+void devm_iio_channel_release(struct device *dev, struct iio_channel *channel)
+{
+        WARN_ON(devres_release(dev, devm_iio_channel_free,
+                               devm_iio_channel_match, channel));
+}
+EXPORT_SYMBOL_GPL(devm_iio_channel_release);
 struct iio_channel *iio_channel_get_all(struct device *dev)
 {
        const char *name;
@@ -441,6 +489,42 @@ void iio_channel_release_all(struct iio_channel *channels)
 }
 EXPORT_SYMBOL_GPL(iio_channel_release_all);
+static void devm_iio_channel_free_all(struct device *dev, void *res)
+{
+        struct iio_channel *channels = *(struct iio_channel **)res;
+        iio_channel_release_all(channels);
+}
+struct iio_channel *devm_iio_channel_get_all(struct device *dev)
+{
+        struct iio_channel **ptr, *channels;
+        ptr = devres_alloc(devm_iio_channel_free_all, sizeof(*ptr), GFP_KERNEL);
+        if (!ptr)
+                return ERR_PTR(-ENOMEM);
+        channels = iio_channel_get_all(dev);
+        if (IS_ERR(channels)) {
+                devres_free(ptr);
+                return channels;
+        }
+        *ptr = channels;
+        devres_add(dev, ptr);
+        return channels;
+}
+EXPORT_SYMBOL_GPL(devm_iio_channel_get_all);
+void devm_iio_channel_release_all(struct device *dev,
+                                  struct iio_channel *channels)
+{
+        WARN_ON(devres_release(dev, devm_iio_channel_free_all,
+                               devm_iio_channel_match, channels));
+}
+EXPORT_SYMBOL_GPL(devm_iio_channel_release_all);
 static int iio_channel_read(struct iio_channel *chan, int *val, int *val2,
        enum iio_chan_info_enum info)
 {
@@ -452,7 +536,7 @@ static int iio_channel_read(struct iio_channel *chan, int *val, int *val2,
        if (val2 == NULL)
                val2 = &unused;
-        if(!iio_channel_has_info(chan->channel, info))
+        if (!iio_channel_has_info(chan->channel, info))
                return -EINVAL;
        if (chan->indio_dev->info->read_raw_multi) {
diff --git a/drivers/iio/light/Kconfig b/drivers/iio/light/Kconfig
index cfd3df8416bb..7c566f516572 100644
--- a/drivers/iio/light/Kconfig
+++ b/drivers/iio/light/Kconfig
@@ -73,6 +73,17 @@ config BH1750
         To compile this driver as a module, choose M here: the module will
         be called bh1750.
+config BH1780
+        tristate "ROHM BH1780 ambient light sensor"
+        depends on I2C
+        depends on !SENSORS_BH1780
+        help
+         Say Y here to build support for the ROHM BH1780GLI ambient
+         light sensor.
+         To compile this driver as a module, choose M here: the module will
+         be called bh1780.
 config CM32181
        depends on I2C
        tristate "CM32181 driver"
@@ -223,6 +234,17 @@ config LTR501
         This driver can also be built as a module.  If so, the module
         will be called ltr501.
+config MAX44000
+        tristate "MAX44000 Ambient and Infrared Proximity Sensor"
+        depends on I2C
+        select REGMAP_I2C
+        help
+         Say Y here if you want to build support for Maxim Integrated's
+         MAX44000 ambient and infrared proximity sensor device.
+         To compile this driver as a module, choose M here:
+         the module will be called max44000.
 config OPT3001
        tristate "Texas Instruments OPT3001 Light Sensor"
        depends on I2C
@@ -320,4 +342,14 @@ config VCNL4000
         To compile this driver as a module, choose M here: the
         module will be called vcnl4000.
+config VEML6070
+        tristate "VEML6070 UV A light sensor"
+        depends on I2C
+        help
+         Say Y here if you want to build a driver for the Vishay VEML6070 UV A
+         light sensor.
+         To compile this driver as a module, choose M here: the
+         module will be called veml6070.
 endmenu
diff --git a/drivers/iio/light/Makefile b/drivers/iio/light/Makefile
index b2c31053db0c..6f2a3c62de27 100644
--- a/drivers/iio/light/Makefile
+++ b/drivers/iio/light/Makefile
@@ -9,6 +9,7 @@ obj-$(CONFIG_AL3320A)		+= al3320a.o
 obj-$(CONFIG_APDS9300)          += apds9300.o
 obj-$(CONFIG_APDS9960)          += apds9960.o
 obj-$(CONFIG_BH1750)            += bh1750.o
+obj-$(CONFIG_BH1780)            += bh1780.o
 obj-$(CONFIG_CM32181)           += cm32181.o
 obj-$(CONFIG_CM3232)            += cm3232.o
 obj-$(CONFIG_CM3323)            += cm3323.o
@@ -20,6 +21,7 @@ obj-$(CONFIG_ISL29125)		+= isl29125.o
 obj-$(CONFIG_JSA1212)           += jsa1212.o
 obj-$(CONFIG_SENSORS_LM3533)    += lm3533-als.o
 obj-$(CONFIG_LTR501)            += ltr501.o
+obj-$(CONFIG_MAX44000)          += max44000.o
 obj-$(CONFIG_OPT3001)           += opt3001.o
 obj-$(CONFIG_PA12203001)        += pa12203001.o
 obj-$(CONFIG_RPR0521)           += rpr0521.o
@@ -30,3 +32,4 @@ obj-$(CONFIG_TCS3472)		+= tcs3472.o
 obj-$(CONFIG_TSL4531)           += tsl4531.o
 obj-$(CONFIG_US5182D)           += us5182d.o
 obj-$(CONFIG_VCNL4000)          += vcnl4000.o
+obj-$(CONFIG_VEML6070)          += veml6070.o
diff --git a/drivers/iio/light/apds9960.c b/drivers/iio/light/apds9960.c
index a6af56ad10e1..b4dbb3912977 100644
--- a/drivers/iio/light/apds9960.c
+++ b/drivers/iio/light/apds9960.c
@@ -321,8 +321,12 @@ static const struct iio_chan_spec apds9960_channels[] = {
 };
 /* integration time in us */
-static const int apds9960_int_time[][2] =
+static const int apds9960_int_time[][2] = {
-        { {28000, 246}, {100000, 219}, {200000, 182}, {700000, 0} };
+        { 28000, 246},
+        {100000, 219},
+        {200000, 182},
+        {700000,   0}
+};
 /* gain mapping */
 static const int apds9960_pxs_gain_map[] = {1, 2, 4, 8};
@@ -491,9 +495,10 @@ static int apds9960_read_raw(struct iio_dev *indio_dev,
                case IIO_INTENSITY:
                        ret = regmap_bulk_read(data->regmap, chan->address,
                                               &buf, 2);
-                        if (!ret)
+                        if (!ret) {
                                ret = IIO_VAL_INT;
-                        *val = le16_to_cpu(buf);
+                                *val = le16_to_cpu(buf);
+                        }
                        break;
                default:
                        ret = -EINVAL;
diff --git a/drivers/iio/light/bh1780.c b/drivers/iio/light/bh1780.c
new file mode 100644
index 000000000000..72b364e4aa72
--- /dev/null
+++ b/drivers/iio/light/bh1780.c
@@ -0,0 +1,297 @@
+/*
+ * ROHM 1780GLI Ambient Light Sensor Driver
+ *
+ * Copyright (C) 2016 Linaro Ltd.
+ * Author: Linus Walleij <linus.walleij@linaro.org>
+ * Loosely based on the previous BH1780 ALS misc driver
+ * Copyright (C) 2010 Texas Instruments
+ * Author: Hemanth V <hemanthv@ti.com>
+ */
+#include <linux/i2c.h>
+#include <linux/slab.h>
+#include <linux/platform_device.h>
+#include <linux/delay.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/pm_runtime.h>
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+#include <linux/bitops.h>
+#define BH1780_CMD_BIT          BIT(7)
+#define BH1780_REG_CONTROL      0x00
+#define BH1780_REG_PARTID       0x0A
+#define BH1780_REG_MANFID       0x0B
+#define BH1780_REG_DLOW         0x0C
+#define BH1780_REG_DHIGH        0x0D
+#define BH1780_REVMASK          GENMASK(3,0)
+#define BH1780_POWMASK          GENMASK(1,0)
+#define BH1780_POFF             (0x0)
+#define BH1780_PON              (0x3)
+/* power on settling time in ms */
+#define BH1780_PON_DELAY        2
+/* max time before value available in ms */
+#define BH1780_INTERVAL         250
+struct bh1780_data {
+        struct i2c_client *client;
+};
+static int bh1780_write(struct bh1780_data *bh1780, u8 reg, u8 val)
+{
+        int ret = i2c_smbus_write_byte_data(bh1780->client,
+                                            BH1780_CMD_BIT | reg,
+                                            val);
+        if (ret < 0)
+                dev_err(&bh1780->client->dev,
+                        "i2c_smbus_write_byte_data failed error "
+                        "%d, register %01x\n",
+                        ret, reg);
+        return ret;
+}
+static int bh1780_read(struct bh1780_data *bh1780, u8 reg)
+{
+        int ret = i2c_smbus_read_byte_data(bh1780->client,
+                                           BH1780_CMD_BIT | reg);
+        if (ret < 0)
+                dev_err(&bh1780->client->dev,
+                        "i2c_smbus_read_byte_data failed error "
+                        "%d, register %01x\n",
+                        ret, reg);
+        return ret;
+}
+static int bh1780_read_word(struct bh1780_data *bh1780, u8 reg)
+{
+        int ret = i2c_smbus_read_word_data(bh1780->client,
+                                           BH1780_CMD_BIT | reg);
+        if (ret < 0)
+                dev_err(&bh1780->client->dev,
+                        "i2c_smbus_read_word_data failed error "
+                        "%d, register %01x\n",
+                        ret, reg);
+        return ret;
+}
+static int bh1780_debugfs_reg_access(struct iio_dev *indio_dev,
+                              unsigned int reg, unsigned int writeval,
+                              unsigned int *readval)
+{
+        struct bh1780_data *bh1780 = iio_priv(indio_dev);
+        int ret;
+        if (!readval)
+                bh1780_write(bh1780, (u8)reg, (u8)writeval);
+        ret = bh1780_read(bh1780, (u8)reg);
+        if (ret < 0)
+                return ret;
+        *readval = ret;
+        return 0;
+}
+static int bh1780_read_raw(struct iio_dev *indio_dev,
+                           struct iio_chan_spec const *chan,
+                           int *val, int *val2, long mask)
+{
+        struct bh1780_data *bh1780 = iio_priv(indio_dev);
+        int value;
+        switch (mask) {
+        case IIO_CHAN_INFO_RAW:
+                switch (chan->type) {
+                case IIO_LIGHT:
+                        pm_runtime_get_sync(&bh1780->client->dev);
+                        value = bh1780_read_word(bh1780, BH1780_REG_DLOW);
+                        if (value < 0)
+                                return value;
+                        pm_runtime_mark_last_busy(&bh1780->client->dev);
+                        pm_runtime_put_autosuspend(&bh1780->client->dev);
+                        *val = value;
+                        return IIO_VAL_INT;
+                default:
+                        return -EINVAL;
+                }
+        case IIO_CHAN_INFO_INT_TIME:
+                *val = 0;
+                *val2 = BH1780_INTERVAL * 1000;
+                return IIO_VAL_INT_PLUS_MICRO;
+        default:
+                return -EINVAL;
+        }
+}
+static const struct iio_info bh1780_info = {
+        .driver_module = THIS_MODULE,
+        .read_raw = bh1780_read_raw,
+        .debugfs_reg_access = bh1780_debugfs_reg_access,
+};
+static const struct iio_chan_spec bh1780_channels[] = {
+        {
+                .type = IIO_LIGHT,
+                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
+                                      BIT(IIO_CHAN_INFO_INT_TIME)
+        }
+};
+static int bh1780_probe(struct i2c_client *client,
+                        const struct i2c_device_id *id)
+{
+        int ret;
+        struct bh1780_data *bh1780;
+        struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
+        struct iio_dev *indio_dev;
+        if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
+                return -EIO;
+        indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*bh1780));
+        if (!indio_dev)
+                return -ENOMEM;
+        bh1780 = iio_priv(indio_dev);
+        bh1780->client = client;
+        i2c_set_clientdata(client, indio_dev);
+        /* Power up the device */
+        ret = bh1780_write(bh1780, BH1780_REG_CONTROL, BH1780_PON);
+        if (ret < 0)
+                return ret;
+        msleep(BH1780_PON_DELAY);
+        pm_runtime_get_noresume(&client->dev);
+        pm_runtime_set_active(&client->dev);
+        pm_runtime_enable(&client->dev);
+        ret = bh1780_read(bh1780, BH1780_REG_PARTID);
+        if (ret < 0)
+                goto out_disable_pm;
+        dev_info(&client->dev,
+                 "Ambient Light Sensor, Rev : %lu\n",
+                 (ret & BH1780_REVMASK));
+        /*
+         * As the device takes 250 ms to even come up with a fresh
+         * measurement after power-on, do not shut it down unnecessarily.
+         * Set autosuspend to a five seconds.
+         */
+        pm_runtime_set_autosuspend_delay(&client->dev, 5000);
+        pm_runtime_use_autosuspend(&client->dev);
+        pm_runtime_put(&client->dev);
+        indio_dev->dev.parent = &client->dev;
+        indio_dev->info = &bh1780_info;
+        indio_dev->name = id->name;
+        indio_dev->channels = bh1780_channels;
+        indio_dev->num_channels = ARRAY_SIZE(bh1780_channels);
+        indio_dev->modes = INDIO_DIRECT_MODE;
+        ret = iio_device_register(indio_dev);
+        if (ret)
+                goto out_disable_pm;
+        return 0;
+out_disable_pm:
+        pm_runtime_put_noidle(&client->dev);
+        pm_runtime_disable(&client->dev);
+        return ret;
+}
+static int bh1780_remove(struct i2c_client *client)
+{
+        struct iio_dev *indio_dev = i2c_get_clientdata(client);
+        struct bh1780_data *bh1780 = iio_priv(indio_dev);
+        int ret;
+        iio_device_unregister(indio_dev);
+        pm_runtime_get_sync(&client->dev);
+        pm_runtime_put_noidle(&client->dev);
+        pm_runtime_disable(&client->dev);
+        ret = bh1780_write(bh1780, BH1780_REG_CONTROL, BH1780_POFF);
+        if (ret < 0) {
+                dev_err(&client->dev, "failed to power off\n");
+                return ret;
+        }
+        return 0;
+}
+#ifdef CONFIG_PM
+static int bh1780_runtime_suspend(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct bh1780_data *bh1780 = i2c_get_clientdata(client);
+        int ret;
+        ret = bh1780_write(bh1780, BH1780_REG_CONTROL, BH1780_POFF);
+        if (ret < 0) {
+                dev_err(dev, "failed to runtime suspend\n");
+                return ret;
+        }
+        return 0;
+}
+static int bh1780_runtime_resume(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct bh1780_data *bh1780 = i2c_get_clientdata(client);
+        int ret;
+        ret = bh1780_write(bh1780, BH1780_REG_CONTROL, BH1780_PON);
+        if (ret < 0) {
+                dev_err(dev, "failed to runtime resume\n");
+                return ret;
+        }
+        /* Wait for power on, then for a value to be available */
+        msleep(BH1780_PON_DELAY + BH1780_INTERVAL);
+        return 0;
+}
+#endif /* CONFIG_PM */
+static const struct dev_pm_ops bh1780_dev_pm_ops = {
+        SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
+                                pm_runtime_force_resume)
+        SET_RUNTIME_PM_OPS(bh1780_runtime_suspend,
+                           bh1780_runtime_resume, NULL)
+};
+static const struct i2c_device_id bh1780_id[] = {
+        { "bh1780", 0 },
+        { },
+};
+MODULE_DEVICE_TABLE(i2c, bh1780_id);
+#ifdef CONFIG_OF
+static const struct of_device_id of_bh1780_match[] = {
+        { .compatible = "rohm,bh1780gli", },
+        {},
+};
+MODULE_DEVICE_TABLE(of, of_bh1780_match);
+#endif
+static struct i2c_driver bh1780_driver = {
+        .probe          = bh1780_probe,
+        .remove         = bh1780_remove,
+        .id_table       = bh1780_id,
+        .driver = {
+                .name = "bh1780",
+                .pm = &bh1780_dev_pm_ops,
+                .of_match_table = of_match_ptr(of_bh1780_match),
+        },
+};
+module_i2c_driver(bh1780_driver);
+MODULE_DESCRIPTION("ROHM BH1780GLI Ambient Light Sensor Driver");
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Linus Walleij <linus.walleij@linaro.org>");
diff --git a/drivers/iio/light/max44000.c b/drivers/iio/light/max44000.c
new file mode 100644
index 000000000000..e01e58a9bd14
--- /dev/null
+++ b/drivers/iio/light/max44000.c
@@ -0,0 +1,639 @@
+/*
+ * MAX44000 Ambient and Infrared Proximity Sensor
+ *
+ * Copyright (c) 2016, Intel Corporation.
+ *
+ * This file is subject to the terms and conditions of version 2 of
+ * the GNU General Public License.  See the file COPYING in the main
+ * directory of this archive for more details.
+ *
+ * Data sheet: https://datasheets.maximintegrated.com/en/ds/MAX44000.pdf
+ *
+ * 7-bit I2C slave address 0x4a
+ */
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/i2c.h>
+#include <linux/regmap.h>
+#include <linux/util_macros.h>
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+#include <linux/iio/buffer.h>
+#include <linux/iio/trigger_consumer.h>
+#include <linux/iio/triggered_buffer.h>
+#include <linux/acpi.h>
+#define MAX44000_DRV_NAME               "max44000"
+/* Registers in datasheet order */
+#define MAX44000_REG_STATUS             0x00
+#define MAX44000_REG_CFG_MAIN           0x01
+#define MAX44000_REG_CFG_RX             0x02
+#define MAX44000_REG_CFG_TX             0x03
+#define MAX44000_REG_ALS_DATA_HI        0x04
+#define MAX44000_REG_ALS_DATA_LO        0x05
+#define MAX44000_REG_PRX_DATA           0x16
+#define MAX44000_REG_ALS_UPTHR_HI       0x06
+#define MAX44000_REG_ALS_UPTHR_LO       0x07
+#define MAX44000_REG_ALS_LOTHR_HI       0x08
+#define MAX44000_REG_ALS_LOTHR_LO       0x09
+#define MAX44000_REG_PST                0x0a
+#define MAX44000_REG_PRX_IND            0x0b
+#define MAX44000_REG_PRX_THR            0x0c
+#define MAX44000_REG_TRIM_GAIN_GREEN    0x0f
+#define MAX44000_REG_TRIM_GAIN_IR       0x10
+/* REG_CFG bits */
+#define MAX44000_CFG_ALSINTE            0x01
+#define MAX44000_CFG_PRXINTE            0x02
+#define MAX44000_CFG_MASK               0x1c
+#define MAX44000_CFG_MODE_SHUTDOWN      0x00
+#define MAX44000_CFG_MODE_ALS_GIR       0x04
+#define MAX44000_CFG_MODE_ALS_G         0x08
+#define MAX44000_CFG_MODE_ALS_IR        0x0c
+#define MAX44000_CFG_MODE_ALS_PRX       0x10
+#define MAX44000_CFG_MODE_PRX           0x14
+#define MAX44000_CFG_TRIM               0x20
+/*
+ * Upper 4 bits are not documented but start as 1 on powerup
+ * Setting them to 0 causes proximity to misbehave so set them to 1
+ */
+#define MAX44000_REG_CFG_RX_DEFAULT 0xf0
+/* REG_RX bits */
+#define MAX44000_CFG_RX_ALSTIM_MASK     0x0c
+#define MAX44000_CFG_RX_ALSTIM_SHIFT    2
+#define MAX44000_CFG_RX_ALSPGA_MASK     0x03
+#define MAX44000_CFG_RX_ALSPGA_SHIFT    0
+/* REG_TX bits */
+#define MAX44000_LED_CURRENT_MASK       0xf
+#define MAX44000_LED_CURRENT_MAX        11
+#define MAX44000_LED_CURRENT_DEFAULT    6
+#define MAX44000_ALSDATA_OVERFLOW       0x4000
+struct max44000_data {
+        struct mutex lock;
+        struct regmap *regmap;
+};
+/* Default scale is set to the minimum of 0.03125 or 1 / (1 << 5) lux */
+#define MAX44000_ALS_TO_LUX_DEFAULT_FRACTION_LOG2 5
+/* Scale can be multiplied by up to 128x via ALSPGA for measurement gain */
+static const int max44000_alspga_shift[] = {0, 2, 4, 7};
+#define MAX44000_ALSPGA_MAX_SHIFT 7
+/*
+ * Scale can be multiplied by up to 64x via ALSTIM because of lost resolution
+ *
+ * This scaling factor is hidden from userspace and instead accounted for when
+ * reading raw values from the device.
+ *
+ * This makes it possible to cleanly expose ALSPGA as IIO_CHAN_INFO_SCALE and
+ * ALSTIM as IIO_CHAN_INFO_INT_TIME without the values affecting each other.
+ *
+ * Handling this internally is also required for buffer support because the
+ * channel's scan_type can't be modified dynamically.
+ */
+static const int max44000_alstim_shift[] = {0, 2, 4, 6};
+#define MAX44000_ALSTIM_SHIFT(alstim) (2 * (alstim))
+/* Available integration times with pretty manual alignment: */
+static const int max44000_int_time_avail_ns_array[] = {
+           100000000,
+            25000000,
+             6250000,
+             1562500,
+};
+static const char max44000_int_time_avail_str[] =
+        "0.100 "
+        "0.025 "
+        "0.00625 "
+        "0.001625";
+/* Available scales (internal to ulux) with pretty manual alignment: */
+static const int max44000_scale_avail_ulux_array[] = {
+            31250,
+           125000,
+           500000,
+          4000000,
+};
+static const char max44000_scale_avail_str[] =
+        "0.03125 "
+        "0.125 "
+        "0.5 "
+         "4";
+#define MAX44000_SCAN_INDEX_ALS 0
+#define MAX44000_SCAN_INDEX_PRX 1
+static const struct iio_chan_spec max44000_channels[] = {
+        {
+                .type = IIO_LIGHT,
+                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
+                .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) |
+                                            BIT(IIO_CHAN_INFO_INT_TIME),
+                .scan_index = MAX44000_SCAN_INDEX_ALS,
+                .scan_type = {
+                        .sign           = 'u',
+                        .realbits       = 14,
+                        .storagebits    = 16,
+                }
+        },
+        {
+                .type = IIO_PROXIMITY,
+                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
+                .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
+                .scan_index = MAX44000_SCAN_INDEX_PRX,
+                .scan_type = {
+                        .sign           = 'u',
+                        .realbits       = 8,
+                        .storagebits    = 16,
+                }
+        },
+        IIO_CHAN_SOFT_TIMESTAMP(2),
+        {
+                .type = IIO_CURRENT,
+                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
+                                      BIT(IIO_CHAN_INFO_SCALE),
+                .extend_name = "led",
+                .output = 1,
+                .scan_index = -1,
+        },
+};
+static int max44000_read_alstim(struct max44000_data *data)
+{
+        unsigned int val;
+        int ret;
+        ret = regmap_read(data->regmap, MAX44000_REG_CFG_RX, &val);
+        if (ret < 0)
+                return ret;
+        return (val & MAX44000_CFG_RX_ALSTIM_MASK) >> MAX44000_CFG_RX_ALSTIM_SHIFT;
+}
+static int max44000_write_alstim(struct max44000_data *data, int val)
+{
+        return regmap_write_bits(data->regmap, MAX44000_REG_CFG_RX,
+                                 MAX44000_CFG_RX_ALSTIM_MASK,
+                                 val << MAX44000_CFG_RX_ALSTIM_SHIFT);
+}
+static int max44000_read_alspga(struct max44000_data *data)
+{
+        unsigned int val;
+        int ret;
+        ret = regmap_read(data->regmap, MAX44000_REG_CFG_RX, &val);
+        if (ret < 0)
+                return ret;
+        return (val & MAX44000_CFG_RX_ALSPGA_MASK) >> MAX44000_CFG_RX_ALSPGA_SHIFT;
+}
+static int max44000_write_alspga(struct max44000_data *data, int val)
+{
+        return regmap_write_bits(data->regmap, MAX44000_REG_CFG_RX,
+                                 MAX44000_CFG_RX_ALSPGA_MASK,
+                                 val << MAX44000_CFG_RX_ALSPGA_SHIFT);
+}
+static int max44000_read_alsval(struct max44000_data *data)
+{
+        u16 regval;
+        int alstim, ret;
+        ret = regmap_bulk_read(data->regmap, MAX44000_REG_ALS_DATA_HI,
+                               &regval, sizeof(regval));
+        if (ret < 0)
+                return ret;
+        alstim = ret = max44000_read_alstim(data);
+        if (ret < 0)
+                return ret;
+        regval = be16_to_cpu(regval);
+        /*
+         * Overflow is explained on datasheet page 17.
+         *
+         * It's a warning that either the G or IR channel has become saturated
+         * and that the value in the register is likely incorrect.
+         *
+         * The recommendation is to change the scale (ALSPGA).
+         * The driver just returns the max representable value.
+         */
+        if (regval & MAX44000_ALSDATA_OVERFLOW)
+                return 0x3FFF;
+        return regval << MAX44000_ALSTIM_SHIFT(alstim);
+}
+static int max44000_write_led_current_raw(struct max44000_data *data, int val)
+{
+        /* Maybe we should clamp the value instead? */
+        if (val < 0 || val > MAX44000_LED_CURRENT_MAX)
+                return -ERANGE;
+        if (val >= 8)
+                val += 4;
+        return regmap_write_bits(data->regmap, MAX44000_REG_CFG_TX,
+                                 MAX44000_LED_CURRENT_MASK, val);
+}
+static int max44000_read_led_current_raw(struct max44000_data *data)
+{
+        unsigned int regval;
+        int ret;
+        ret = regmap_read(data->regmap, MAX44000_REG_CFG_TX, &regval);
+        if (ret < 0)
+                return ret;
+        regval &= MAX44000_LED_CURRENT_MASK;
+        if (regval >= 8)
+                regval -= 4;
+        return regval;
+}
+static int max44000_read_raw(struct iio_dev *indio_dev,
+                             struct iio_chan_spec const *chan,
+                             int *val, int *val2, long mask)
+{
+        struct max44000_data *data = iio_priv(indio_dev);
+        int alstim, alspga;
+        unsigned int regval;
+        int ret;
+        switch (mask) {
+        case IIO_CHAN_INFO_RAW:
+                switch (chan->type) {
+                case IIO_LIGHT:
+                        mutex_lock(&data->lock);
+                        ret = max44000_read_alsval(data);
+                        mutex_unlock(&data->lock);
+                        if (ret < 0)
+                                return ret;
+                        *val = ret;
+                        return IIO_VAL_INT;
+                case IIO_PROXIMITY:
+                        mutex_lock(&data->lock);
+                        ret = regmap_read(data->regmap, MAX44000_REG_PRX_DATA, &regval);
+                        mutex_unlock(&data->lock);
+                        if (ret < 0)
+                                return ret;
+                        *val = regval;
+                        return IIO_VAL_INT;
+                case IIO_CURRENT:
+                        mutex_lock(&data->lock);
+                        ret = max44000_read_led_current_raw(data);
+                        mutex_unlock(&data->lock);
+                        if (ret < 0)
+                                return ret;
+                        *val = ret;
+                        return IIO_VAL_INT;
+                default:
+                        return -EINVAL;
+                }
+        case IIO_CHAN_INFO_SCALE:
+                switch (chan->type) {
+                case IIO_CURRENT:
+                        /* Output register is in 10s of miliamps */
+                        *val = 10;
+                        return IIO_VAL_INT;
+                case IIO_LIGHT:
+                        mutex_lock(&data->lock);
+                        alspga = ret = max44000_read_alspga(data);
+                        mutex_unlock(&data->lock);
+                        if (ret < 0)
+                                return ret;
+                        /* Avoid negative shifts */
+                        *val = (1 << MAX44000_ALSPGA_MAX_SHIFT);
+                        *val2 = MAX44000_ALS_TO_LUX_DEFAULT_FRACTION_LOG2
+                                        + MAX44000_ALSPGA_MAX_SHIFT
+                                        - max44000_alspga_shift[alspga];
+                        return IIO_VAL_FRACTIONAL_LOG2;
+                default:
+                        return -EINVAL;
+                }
+        case IIO_CHAN_INFO_INT_TIME:
+                mutex_lock(&data->lock);
+                alstim = ret = max44000_read_alstim(data);
+                mutex_unlock(&data->lock);
+                if (ret < 0)
+                        return ret;
+                *val = 0;
+                *val2 = max44000_int_time_avail_ns_array[alstim];
+                return IIO_VAL_INT_PLUS_NANO;
+        default:
+                return -EINVAL;
+        }
+}
+static int max44000_write_raw(struct iio_dev *indio_dev,
+                              struct iio_chan_spec const *chan,
+                              int val, int val2, long mask)
+{
+        struct max44000_data *data = iio_priv(indio_dev);
+        int ret;
+        if (mask == IIO_CHAN_INFO_RAW && chan->type == IIO_CURRENT) {
+                mutex_lock(&data->lock);
+                ret = max44000_write_led_current_raw(data, val);
+                mutex_unlock(&data->lock);
+                return ret;
+        } else if (mask == IIO_CHAN_INFO_INT_TIME && chan->type == IIO_LIGHT) {
+                s64 valns = val * NSEC_PER_SEC + val2;
+                int alstim = find_closest_descending(valns,
+                                max44000_int_time_avail_ns_array,
+                                ARRAY_SIZE(max44000_int_time_avail_ns_array));
+                mutex_lock(&data->lock);
+                ret = max44000_write_alstim(data, alstim);
+                mutex_unlock(&data->lock);
+                return ret;
+        } else if (mask == IIO_CHAN_INFO_SCALE && chan->type == IIO_LIGHT) {
+                s64 valus = val * USEC_PER_SEC + val2;
+                int alspga = find_closest(valus,
+                                max44000_scale_avail_ulux_array,
+                                ARRAY_SIZE(max44000_scale_avail_ulux_array));
+                mutex_lock(&data->lock);
+                ret = max44000_write_alspga(data, alspga);
+                mutex_unlock(&data->lock);
+                return ret;
+        }
+        return -EINVAL;
+}
+static int max44000_write_raw_get_fmt(struct iio_dev *indio_dev,
+                                      struct iio_chan_spec const *chan,
+                                      long mask)
+{
+        if (mask == IIO_CHAN_INFO_INT_TIME && chan->type == IIO_LIGHT)
+                return IIO_VAL_INT_PLUS_NANO;
+        else if (mask == IIO_CHAN_INFO_SCALE && chan->type == IIO_LIGHT)
+                return IIO_VAL_INT_PLUS_MICRO;
+        else
+                return IIO_VAL_INT;
+}
+static IIO_CONST_ATTR(illuminance_integration_time_available, max44000_int_time_avail_str);
+static IIO_CONST_ATTR(illuminance_scale_available, max44000_scale_avail_str);
+static struct attribute *max44000_attributes[] = {
+        &iio_const_attr_illuminance_integration_time_available.dev_attr.attr,
+        &iio_const_attr_illuminance_scale_available.dev_attr.attr,
+        NULL
+};
+static const struct attribute_group max44000_attribute_group = {
+        .attrs = max44000_attributes,
+};
+static const struct iio_info max44000_info = {
+        .driver_module          = THIS_MODULE,
+        .read_raw               = max44000_read_raw,
+        .write_raw              = max44000_write_raw,
+        .write_raw_get_fmt      = max44000_write_raw_get_fmt,
+        .attrs                  = &max44000_attribute_group,
+};
+static bool max44000_readable_reg(struct device *dev, unsigned int reg)
+{
+        switch (reg) {
+        case MAX44000_REG_STATUS:
+        case MAX44000_REG_CFG_MAIN:
+        case MAX44000_REG_CFG_RX:
+        case MAX44000_REG_CFG_TX:
+        case MAX44000_REG_ALS_DATA_HI:
+        case MAX44000_REG_ALS_DATA_LO:
+        case MAX44000_REG_PRX_DATA:
+        case MAX44000_REG_ALS_UPTHR_HI:
+        case MAX44000_REG_ALS_UPTHR_LO:
+        case MAX44000_REG_ALS_LOTHR_HI:
+        case MAX44000_REG_ALS_LOTHR_LO:
+        case MAX44000_REG_PST:
+        case MAX44000_REG_PRX_IND:
+        case MAX44000_REG_PRX_THR:
+        case MAX44000_REG_TRIM_GAIN_GREEN:
+        case MAX44000_REG_TRIM_GAIN_IR:
+                return true;
+        default:
+                return false;
+        }
+}
+static bool max44000_writeable_reg(struct device *dev, unsigned int reg)
+{
+        switch (reg) {
+        case MAX44000_REG_CFG_MAIN:
+        case MAX44000_REG_CFG_RX:
+        case MAX44000_REG_CFG_TX:
+        case MAX44000_REG_ALS_UPTHR_HI:
+        case MAX44000_REG_ALS_UPTHR_LO:
+        case MAX44000_REG_ALS_LOTHR_HI:
+        case MAX44000_REG_ALS_LOTHR_LO:
+        case MAX44000_REG_PST:
+        case MAX44000_REG_PRX_IND:
+        case MAX44000_REG_PRX_THR:
+        case MAX44000_REG_TRIM_GAIN_GREEN:
+        case MAX44000_REG_TRIM_GAIN_IR:
+                return true;
+        default:
+                return false;
+        }
+}
+static bool max44000_volatile_reg(struct device *dev, unsigned int reg)
+{
+        switch (reg) {
+        case MAX44000_REG_STATUS:
+        case MAX44000_REG_ALS_DATA_HI:
+        case MAX44000_REG_ALS_DATA_LO:
+        case MAX44000_REG_PRX_DATA:
+                return true;
+        default:
+                return false;
+        }
+}
+static bool max44000_precious_reg(struct device *dev, unsigned int reg)
+{
+        return reg == MAX44000_REG_STATUS;
+}
+static const struct regmap_config max44000_regmap_config = {
+        .reg_bits       = 8,
+        .val_bits       = 8,
+        .max_register   = MAX44000_REG_PRX_DATA,
+        .readable_reg   = max44000_readable_reg,
+        .writeable_reg  = max44000_writeable_reg,
+        .volatile_reg   = max44000_volatile_reg,
+        .precious_reg   = max44000_precious_reg,
+        .use_single_rw  = 1,
+        .cache_type     = REGCACHE_RBTREE,
+};
+static irqreturn_t max44000_trigger_handler(int irq, void *p)
+{
+        struct iio_poll_func *pf = p;
+        struct iio_dev *indio_dev = pf->indio_dev;
+        struct max44000_data *data = iio_priv(indio_dev);
+        u16 buf[8]; /* 2x u16 + padding + 8 bytes timestamp */
+        int index = 0;
+        unsigned int regval;
+        int ret;
+        mutex_lock(&data->lock);
+        if (test_bit(MAX44000_SCAN_INDEX_ALS, indio_dev->active_scan_mask)) {
+                ret = max44000_read_alsval(data);
+                if (ret < 0)
+                        goto out_unlock;
+                buf[index++] = ret;
+        }
+        if (test_bit(MAX44000_SCAN_INDEX_PRX, indio_dev->active_scan_mask)) {
+                ret = regmap_read(data->regmap, MAX44000_REG_PRX_DATA, &regval);
+                if (ret < 0)
+                        goto out_unlock;
+                buf[index] = regval;
+        }
+        mutex_unlock(&data->lock);
+        iio_push_to_buffers_with_timestamp(indio_dev, buf, iio_get_time_ns());
+        iio_trigger_notify_done(indio_dev->trig);
+        return IRQ_HANDLED;
+out_unlock:
+        mutex_unlock(&data->lock);
+        iio_trigger_notify_done(indio_dev->trig);
+        return IRQ_HANDLED;
+}
+static int max44000_probe(struct i2c_client *client,
+                          const struct i2c_device_id *id)
+{
+        struct max44000_data *data;
+        struct iio_dev *indio_dev;
+        int ret, reg;
+        indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
+        if (!indio_dev)
+                return -ENOMEM;
+        data = iio_priv(indio_dev);
+        data->regmap = devm_regmap_init_i2c(client, &max44000_regmap_config);
+        if (IS_ERR(data->regmap)) {
+                dev_err(&client->dev, "regmap_init failed!\n");
+                return PTR_ERR(data->regmap);
+        }
+        i2c_set_clientdata(client, indio_dev);
+        mutex_init(&data->lock);
+        indio_dev->dev.parent = &client->dev;
+        indio_dev->info = &max44000_info;
+        indio_dev->name = MAX44000_DRV_NAME;
+        indio_dev->channels = max44000_channels;
+        indio_dev->num_channels = ARRAY_SIZE(max44000_channels);
+        /*
+         * The device doesn't have a reset function so we just clear some
+         * important bits at probe time to ensure sane operation.
+         *
+         * Since we don't support interrupts/events the threshold values are
+         * not important. We also don't touch trim values.
+         */
+        /* Reset ALS scaling bits */
+        ret = regmap_write(data->regmap, MAX44000_REG_CFG_RX,
+                           MAX44000_REG_CFG_RX_DEFAULT);
+        if (ret < 0) {
+                dev_err(&client->dev, "failed to write default CFG_RX: %d\n",
+                        ret);
+                return ret;
+        }
+        /*
+         * By default the LED pulse used for the proximity sensor is disabled.
+         * Set a middle value so that we get some sort of valid data by default.
+         */
+        ret = max44000_write_led_current_raw(data, MAX44000_LED_CURRENT_DEFAULT);
+        if (ret < 0) {
+                dev_err(&client->dev, "failed to write init config: %d\n", ret);
+                return ret;
+        }
+        /* Reset CFG bits to ALS_PRX mode which allows easy reading of both values. */
+        reg = MAX44000_CFG_TRIM | MAX44000_CFG_MODE_ALS_PRX;
+        ret = regmap_write(data->regmap, MAX44000_REG_CFG_MAIN, reg);
+        if (ret < 0) {
+                dev_err(&client->dev, "failed to write init config: %d\n", ret);
+                return ret;
+        }
+        /* Read status at least once to clear any stale interrupt bits. */
+        ret = regmap_read(data->regmap, MAX44000_REG_STATUS, &reg);
+        if (ret < 0) {
+                dev_err(&client->dev, "failed to read init status: %d\n", ret);
+                return ret;
+        }
+        ret = iio_triggered_buffer_setup(indio_dev, NULL, max44000_trigger_handler, NULL);
+        if (ret < 0) {
+                dev_err(&client->dev, "iio triggered buffer setup failed\n");
+                return ret;
+        }
+        return iio_device_register(indio_dev);
+}
+static int max44000_remove(struct i2c_client *client)
+{
+        struct iio_dev *indio_dev = i2c_get_clientdata(client);
+        iio_device_unregister(indio_dev);
+        iio_triggered_buffer_cleanup(indio_dev);
+        return 0;
+}
+static const struct i2c_device_id max44000_id[] = {
+        {"max44000", 0},
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, max44000_id);
+#ifdef CONFIG_ACPI
+static const struct acpi_device_id max44000_acpi_match[] = {
+        {"MAX44000", 0},
+        { }
+};
+MODULE_DEVICE_TABLE(acpi, max44000_acpi_match);
+#endif
+static struct i2c_driver max44000_driver = {
+        .driver = {
+                .name   = MAX44000_DRV_NAME,
+                .acpi_match_table = ACPI_PTR(max44000_acpi_match),
+        },
+        .probe          = max44000_probe,
+        .remove         = max44000_remove,
+        .id_table       = max44000_id,
+};
+module_i2c_driver(max44000_driver);
+MODULE_AUTHOR("Crestez Dan Leonard <leonard.crestez@intel.com>");
+MODULE_DESCRIPTION("MAX44000 Ambient and Infrared Proximity Sensor");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/light/veml6070.c b/drivers/iio/light/veml6070.c
new file mode 100644
index 000000000000..bc1c4cb782cd
--- /dev/null
+++ b/drivers/iio/light/veml6070.c
@@ -0,0 +1,218 @@
+/*
+ * veml6070.c - Support for Vishay VEML6070 UV A light sensor
+ *
+ * Copyright 2016 Peter Meerwald-Stadler <pmeerw@pmeerw.net>
+ *
+ * This file is subject to the terms and conditions of version 2 of
+ * the GNU General Public License.  See the file COPYING in the main
+ * directory of this archive for more details.
+ *
+ * IIO driver for VEML6070 (7-bit I2C slave addresses 0x38 and 0x39)
+ *
+ * TODO: integration time, ACK signal
+ */
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/mutex.h>
+#include <linux/err.h>
+#include <linux/delay.h>
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+#define VEML6070_DRV_NAME "veml6070"
+#define VEML6070_ADDR_CONFIG_DATA_MSB 0x38 /* read: MSB data, write: config */
+#define VEML6070_ADDR_DATA_LSB  0x39 /* LSB data */
+#define VEML6070_COMMAND_ACK    BIT(5) /* raise interrupt when over threshold */
+#define VEML6070_COMMAND_IT     GENMASK(3, 2) /* bit mask integration time */
+#define VEML6070_COMMAND_RSRVD  BIT(1) /* reserved, set to 1 */
+#define VEML6070_COMMAND_SD     BIT(0) /* shutdown mode when set */
+#define VEML6070_IT_10  0x04 /* integration time 1x */
+struct veml6070_data {
+        struct i2c_client *client1;
+        struct i2c_client *client2;
+        u8 config;
+        struct mutex lock;
+};
+static int veml6070_read(struct veml6070_data *data)
+{
+        int ret;
+        u8 msb, lsb;
+        mutex_lock(&data->lock);
+        /* disable shutdown */
+        ret = i2c_smbus_write_byte(data->client1,
+            data->config & ~VEML6070_COMMAND_SD);
+        if (ret < 0)
+                goto out;
+        msleep(125 + 10); /* measurement takes up to 125 ms for IT 1x */
+        ret = i2c_smbus_read_byte(data->client2); /* read MSB, address 0x39 */
+        if (ret < 0)
+                goto out;
+        msb = ret;
+        ret = i2c_smbus_read_byte(data->client1); /* read LSB, address 0x38 */
+        if (ret < 0)
+                goto out;
+        lsb = ret;
+        /* shutdown again */
+        ret = i2c_smbus_write_byte(data->client1, data->config);
+        if (ret < 0)
+                goto out;
+        ret = (msb << 8) | lsb;
+out:
+        mutex_unlock(&data->lock);
+        return ret;
+}
+static const struct iio_chan_spec veml6070_channels[] = {
+        {
+                .type = IIO_INTENSITY,
+                .modified = 1,
+                .channel2 = IIO_MOD_LIGHT_UV,
+                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
+        },
+        {
+                .type = IIO_UVINDEX,
+                .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
+        }
+};
+static int veml6070_to_uv_index(unsigned val)
+{
+        /*
+         * conversion of raw UV intensity values to UV index depends on
+         * integration time (IT) and value of the resistor connected to
+         * the RSET pin (default: 270 KOhm)
+         */
+        unsigned uvi[11] = {
+                187, 373, 560, /* low */
+                746, 933, 1120, /* moderate */
+                1308, 1494, /* high */
+                1681, 1868, 2054}; /* very high */
+        int i;
+        for (i = 0; i < ARRAY_SIZE(uvi); i++)
+                if (val <= uvi[i])
+                        return i;
+        return 11; /* extreme */
+}
+static int veml6070_read_raw(struct iio_dev *indio_dev,
+                                struct iio_chan_spec const *chan,
+                                int *val, int *val2, long mask)
+{
+        struct veml6070_data *data = iio_priv(indio_dev);
+        int ret;
+        switch (mask) {
+        case IIO_CHAN_INFO_RAW:
+        case IIO_CHAN_INFO_PROCESSED:
+                ret = veml6070_read(data);
+                if (ret < 0)
+                        return ret;
+                if (mask == IIO_CHAN_INFO_PROCESSED)
+                        *val = veml6070_to_uv_index(ret);
+                else
+                        *val = ret;
+                return IIO_VAL_INT;
+        default:
+                return -EINVAL;
+        }
+}
+static const struct iio_info veml6070_info = {
+        .read_raw = veml6070_read_raw,
+        .driver_module = THIS_MODULE,
+};
+static int veml6070_probe(struct i2c_client *client,
+                          const struct i2c_device_id *id)
+{
+        struct veml6070_data *data;
+        struct iio_dev *indio_dev;
+        int ret;
+        indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
+        if (!indio_dev)
+                return -ENOMEM;
+        data = iio_priv(indio_dev);
+        i2c_set_clientdata(client, indio_dev);
+        data->client1 = client;
+        mutex_init(&data->lock);
+        indio_dev->dev.parent = &client->dev;
+        indio_dev->info = &veml6070_info;
+        indio_dev->channels = veml6070_channels;
+        indio_dev->num_channels = ARRAY_SIZE(veml6070_channels);
+        indio_dev->name = VEML6070_DRV_NAME;
+        indio_dev->modes = INDIO_DIRECT_MODE;
+        data->client2 = i2c_new_dummy(client->adapter, VEML6070_ADDR_DATA_LSB);
+        if (!data->client2) {
+                dev_err(&client->dev, "i2c device for second chip address failed\n");
+                return -ENODEV;
+        }
+        data->config = VEML6070_IT_10 | VEML6070_COMMAND_RSRVD |
+                VEML6070_COMMAND_SD;
+        ret = i2c_smbus_write_byte(data->client1, data->config);
+        if (ret < 0)
+                goto fail;
+        ret = iio_device_register(indio_dev);
+        if (ret < 0)
+                goto fail;
+        return ret;
+fail:
+        i2c_unregister_device(data->client2);
+        return ret;
+}
+static int veml6070_remove(struct i2c_client *client)
+{
+        struct iio_dev *indio_dev = i2c_get_clientdata(client);
+        struct veml6070_data *data = iio_priv(indio_dev);
+        iio_device_unregister(indio_dev);
+        i2c_unregister_device(data->client2);
+        return 0;
+}
+static const struct i2c_device_id veml6070_id[] = {
+        { "veml6070", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, veml6070_id);
+static struct i2c_driver veml6070_driver = {
+        .driver = {
+                .name   = VEML6070_DRV_NAME,
+        },
+        .probe  = veml6070_probe,
+        .remove  = veml6070_remove,
+        .id_table = veml6070_id,
+};
+module_i2c_driver(veml6070_driver);
+MODULE_AUTHOR("Peter Meerwald-Stadler <pmeerw@pmeerw.net>");
+MODULE_DESCRIPTION("Vishay VEML6070 UV A light sensor driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/iio/magnetometer/Kconfig b/drivers/iio/magnetometer/Kconfig
index 021dc5361f53..84e6559ccc65 100644
--- a/drivers/iio/magnetometer/Kconfig
+++ b/drivers/iio/magnetometer/Kconfig
@@ -9,6 +9,8 @@ config AK8975
        tristate "Asahi Kasei AK 3-Axis Magnetometer"
        depends on I2C
        depends on GPIOLIB || COMPILE_TEST
+        select IIO_BUFFER
+        select IIO_TRIGGERED_BUFFER
        help
          Say yes here to build support for Asahi Kasei AK8975, AK8963,
          AK09911 or AK09912 3-Axis Magnetometer.
@@ -25,22 +27,41 @@ config AK09911
          Deprecated: AK09911 is now supported by AK8975 driver.
 config BMC150_MAGN
-        tristate "Bosch BMC150 Magnetometer Driver"
+        tristate
-        depends on I2C
-        select REGMAP_I2C
        select IIO_BUFFER
        select IIO_TRIGGERED_BUFFER
+config BMC150_MAGN_I2C
+        tristate "Bosch BMC150 I2C Magnetometer Driver"
+        depends on I2C
+        select BMC150_MAGN
+        select REGMAP_I2C
        help
-          Say yes here to build support for the BMC150 magnetometer.
+          Say yes here to build support for the BMC150 magnetometer with
+          I2C interface.
-          Currently this only supports the device via an i2c interface.
+          This is a combo module with both accelerometer and magnetometer.
+          This driver is only implementing magnetometer part, which has
+          its own address and register map.
+          To compile this driver as a module, choose M here: the module will be
+          called bmc150_magn_i2c.
+config BMC150_MAGN_SPI
+        tristate "Bosch BMC150 SPI Magnetometer Driver"
+        depends on SPI
+        select BMC150_MAGN
+        select REGMAP_SPI
+        help
+          Say yes here to build support for the BMC150 magnetometer with
+          SPI interface.
          This is a combo module with both accelerometer and magnetometer.
          This driver is only implementing magnetometer part, which has
          its own address and register map.
          To compile this driver as a module, choose M here: the module will be
-          called bmc150_magn.
+          called bmc150_magn_spi.
 config MAG3110
        tristate "Freescale MAG3110 3-Axis Magnetometer"
diff --git a/drivers/iio/magnetometer/Makefile b/drivers/iio/magnetometer/Makefile
index dd03fe524481..92a745c9a6e8 100644
--- a/drivers/iio/magnetometer/Makefile
+++ b/drivers/iio/magnetometer/Makefile
@@ -5,6 +5,9 @@
 # When adding new entries keep the list in alphabetical order
 obj-$(CONFIG_AK8975)    += ak8975.o
 obj-$(CONFIG_BMC150_MAGN) += bmc150_magn.o
+obj-$(CONFIG_BMC150_MAGN_I2C) += bmc150_magn_i2c.o
+obj-$(CONFIG_BMC150_MAGN_SPI) += bmc150_magn_spi.o
 obj-$(CONFIG_MAG3110)   += mag3110.o
 obj-$(CONFIG_HID_SENSOR_MAGNETOMETER_3D) += hid-sensor-magn-3d.o
 obj-$(CONFIG_MMC35240)  += mmc35240.o
diff --git a/drivers/iio/magnetometer/ak8975.c b/drivers/iio/magnetometer/ak8975.c
index 48d127a45d90..dbf066129a04 100644
--- a/drivers/iio/magnetometer/ak8975.c
+++ b/drivers/iio/magnetometer/ak8975.c
@@ -36,6 +36,13 @@
 #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 <linux/iio/magnetometer/ak8975.h>
 /*
 * Register definitions, as well as various shifts and masks to get at the
 * individual fields of the registers.
@@ -370,6 +377,7 @@ struct ak8975_data {
        wait_queue_head_t       data_ready_queue;
        unsigned long           flags;
        u8                      cntl_cache;
+        struct iio_mount_matrix orientation;
        struct regulator        *vdd;
 };
@@ -633,22 +641,15 @@ static int wait_conversion_complete_interrupt(struct ak8975_data *data)
        return ret > 0 ? 0 : -ETIME;
 }
-/*
+static int ak8975_start_read_axis(struct ak8975_data *data,
- * Emits the raw flux value for the x, y, or z axis.
+                                  const struct i2c_client *client)
- */
-static int ak8975_read_axis(struct iio_dev *indio_dev, int index, int *val)
 {
-        struct ak8975_data *data = iio_priv(indio_dev);
-        struct i2c_client *client = data->client;
-        int ret;
-        mutex_lock(&data->lock);
        /* Set up the device for taking a sample. */
-        ret = ak8975_set_mode(data, MODE_ONCE);
+        int ret = ak8975_set_mode(data, MODE_ONCE);
        if (ret < 0) {
                dev_err(&client->dev, "Error in setting operating mode\n");
-                goto exit;
+                return ret;
        }
        /* Wait for the conversion to complete. */
@@ -659,7 +660,7 @@ static int ak8975_read_axis(struct iio_dev *indio_dev, int index, int *val)
        else
                ret = wait_conversion_complete_polled(data);
        if (ret < 0)
-                goto exit;
+                return ret;
        /* This will be executed only for non-interrupt based waiting case */
        if (ret & data->def->ctrl_masks[ST1_DRDY]) {
@@ -667,32 +668,45 @@ static int ak8975_read_axis(struct iio_dev *indio_dev, int index, int *val)
                                               data->def->ctrl_regs[ST2]);
                if (ret < 0) {
                        dev_err(&client->dev, "Error in reading ST2\n");
-                        goto exit;
+                        return ret;
                }
                if (ret & (data->def->ctrl_masks[ST2_DERR] |
                           data->def->ctrl_masks[ST2_HOFL])) {
                        dev_err(&client->dev, "ST2 status error 0x%x\n", ret);
-                        ret = -EINVAL;
+                        return -EINVAL;
-                        goto exit;
                }
        }
-        /* Read the flux value from the appropriate register
+        return 0;
-           (the register is specified in the iio device attributes). */
+}
-        ret = i2c_smbus_read_word_data(client, data->def->data_regs[index]);
-        if (ret < 0) {
+/* Retrieve raw flux value for one of the x, y, or z axis.  */
-                dev_err(&client->dev, "Read axis data fails\n");
+static int ak8975_read_axis(struct iio_dev *indio_dev, int index, int *val)
+{
+        struct ak8975_data *data = iio_priv(indio_dev);
+        const struct i2c_client *client = data->client;
+        const struct ak_def *def = data->def;
+        int ret;
+        mutex_lock(&data->lock);
+        ret = ak8975_start_read_axis(data, client);
+        if (ret)
+                goto exit;
+        ret = i2c_smbus_read_word_data(client, def->data_regs[index]);
+        if (ret < 0)
                goto exit;
-        }
        mutex_unlock(&data->lock);
        /* Clamp to valid range. */
-        *val = clamp_t(s16, ret, -data->def->range, data->def->range);
+        *val = clamp_t(s16, ret, -def->range, def->range);
        return IIO_VAL_INT;
 exit:
        mutex_unlock(&data->lock);
+        dev_err(&client->dev, "Error in reading axis\n");
        return ret;
 }
@@ -714,6 +728,18 @@ static int ak8975_read_raw(struct iio_dev *indio_dev,
        return -EINVAL;
 }
+static const struct iio_mount_matrix *
+ak8975_get_mount_matrix(const struct iio_dev *indio_dev,
+                        const struct iio_chan_spec *chan)
+{
+        return &((struct ak8975_data *)iio_priv(indio_dev))->orientation;
+}
+static const struct iio_chan_spec_ext_info ak8975_ext_info[] = {
+        IIO_MOUNT_MATRIX(IIO_SHARED_BY_DIR, ak8975_get_mount_matrix),
+        { },
+};
 #define AK8975_CHANNEL(axis, index)                                     \
        {                                                               \
                .type = IIO_MAGN,                                       \
@@ -722,12 +748,23 @@ static int ak8975_read_raw(struct iio_dev *indio_dev,
                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |          \
                             BIT(IIO_CHAN_INFO_SCALE),                  \
                .address = index,                                       \
+                .scan_index = index,                                    \
+                .scan_type = {                                          \
+                        .sign = 's',                                    \
+                        .realbits = 16,                                 \
+                        .storagebits = 16,                              \
+                        .endianness = IIO_CPU                           \
+                },                                                      \
+                .ext_info = ak8975_ext_info,                            \
        }
 static const struct iio_chan_spec ak8975_channels[] = {
        AK8975_CHANNEL(X, 0), AK8975_CHANNEL(Y, 1), AK8975_CHANNEL(Z, 2),
+        IIO_CHAN_SOFT_TIMESTAMP(3),
 };
+static const unsigned long ak8975_scan_masks[] = { 0x7, 0 };
 static const struct iio_info ak8975_info = {
        .read_raw = &ak8975_read_raw,
        .driver_module = THIS_MODULE,
@@ -756,6 +793,56 @@ static const char *ak8975_match_acpi_device(struct device *dev,
        return dev_name(dev);
 }
+static void ak8975_fill_buffer(struct iio_dev *indio_dev)
+{
+        struct ak8975_data *data = iio_priv(indio_dev);
+        const struct i2c_client *client = data->client;
+        const struct ak_def *def = data->def;
+        int ret;
+        s16 buff[8]; /* 3 x 16 bits axis values + 1 aligned 64 bits timestamp */
+        mutex_lock(&data->lock);
+        ret = ak8975_start_read_axis(data, client);
+        if (ret)
+                goto unlock;
+        /*
+         * For each axis, read the flux value from the appropriate register
+         * (the register is specified in the iio device attributes).
+         */
+        ret = i2c_smbus_read_i2c_block_data_or_emulated(client,
+                                                        def->data_regs[0],
+                                                        3 * sizeof(buff[0]),
+                                                        (u8 *)buff);
+        if (ret < 0)
+                goto unlock;
+        mutex_unlock(&data->lock);
+        /* Clamp to valid range. */
+        buff[0] = clamp_t(s16, le16_to_cpu(buff[0]), -def->range, def->range);
+        buff[1] = clamp_t(s16, le16_to_cpu(buff[1]), -def->range, def->range);
+        buff[2] = clamp_t(s16, le16_to_cpu(buff[2]), -def->range, def->range);
+        iio_push_to_buffers_with_timestamp(indio_dev, buff, iio_get_time_ns());
+        return;
+unlock:
+        mutex_unlock(&data->lock);
+        dev_err(&client->dev, "Error in reading axes block\n");
+}
+static irqreturn_t ak8975_handle_trigger(int irq, void *p)
+{
+        const struct iio_poll_func *pf = p;
+        struct iio_dev *indio_dev = pf->indio_dev;
+        ak8975_fill_buffer(indio_dev);
+        iio_trigger_notify_done(indio_dev->trig);
+        return IRQ_HANDLED;
+}
 static int ak8975_probe(struct i2c_client *client,
                        const struct i2c_device_id *id)
 {
@@ -765,10 +852,12 @@ static int ak8975_probe(struct i2c_client *client,
        int err;
        const char *name = NULL;
        enum asahi_compass_chipset chipset;
+        const struct ak8975_platform_data *pdata =
+                dev_get_platdata(&client->dev);
        /* Grab and set up the supplied GPIO. */
-        if (client->dev.platform_data)
+        if (pdata)
-                eoc_gpio = *(int *)(client->dev.platform_data);
+                eoc_gpio = pdata->eoc_gpio;
        else if (client->dev.of_node)
                eoc_gpio = of_get_gpio(client->dev.of_node, 0);
        else
@@ -802,6 +891,15 @@ static int ak8975_probe(struct i2c_client *client,
        data->eoc_gpio = eoc_gpio;
        data->eoc_irq = 0;
+        if (!pdata) {
+                err = of_iio_read_mount_matrix(&client->dev,
+                                               "mount-matrix",
+                                               &data->orientation);
+                if (err)
+                        return err;
+        } else
+                data->orientation = pdata->orientation;
        /* id will be NULL when enumerated via ACPI */
        if (id) {
                chipset = (enum asahi_compass_chipset)(id->driver_data);
@@ -810,8 +908,7 @@ static int ak8975_probe(struct i2c_client *client,
                name = ak8975_match_acpi_device(&client->dev, &chipset);
                if (!name)
                        return -ENODEV;
-        }
+        } else
-        else
                return -ENOSYS;
        if (chipset >= AK_MAX_TYPE) {
@@ -845,15 +942,27 @@ static int ak8975_probe(struct i2c_client *client,
        indio_dev->channels = ak8975_channels;
        indio_dev->num_channels = ARRAY_SIZE(ak8975_channels);
        indio_dev->info = &ak8975_info;
+        indio_dev->available_scan_masks = ak8975_scan_masks;
        indio_dev->modes = INDIO_DIRECT_MODE;
        indio_dev->name = name;
-        err = iio_device_register(indio_dev);
+        err = iio_triggered_buffer_setup(indio_dev, NULL, ak8975_handle_trigger,
-        if (err)
+                                         NULL);
+        if (err) {
+                dev_err(&client->dev, "triggered buffer setup failed\n");
                goto power_off;
+        }
+        err = iio_device_register(indio_dev);
+        if (err) {
+                dev_err(&client->dev, "device register failed\n");
+                goto cleanup_buffer;
+        }
        return 0;
+cleanup_buffer:
+        iio_triggered_buffer_cleanup(indio_dev);
 power_off:
        ak8975_power_off(client);
        return err;
@@ -864,6 +973,7 @@ static int ak8975_remove(struct i2c_client *client)
        struct iio_dev *indio_dev = i2c_get_clientdata(client);
        iio_device_unregister(indio_dev);
+        iio_triggered_buffer_cleanup(indio_dev);
        ak8975_power_off(client);
        return 0;
diff --git a/drivers/iio/magnetometer/bmc150_magn.c b/drivers/iio/magnetometer/bmc150_magn.c
index 0e9da189dc4c..d104fb8d9379 100644
--- a/drivers/iio/magnetometer/bmc150_magn.c
+++ b/drivers/iio/magnetometer/bmc150_magn.c
@@ -34,6 +34,8 @@
 #include <linux/iio/triggered_buffer.h>
 #include <linux/regmap.h>
+#include "bmc150_magn.h"
 #define BMC150_MAGN_DRV_NAME                    "bmc150_magn"
 #define BMC150_MAGN_IRQ_NAME                    "bmc150_magn_event"
@@ -134,7 +136,7 @@ struct bmc150_magn_trim_regs {
 } __packed;
 struct bmc150_magn_data {
-        struct i2c_client *client;
+        struct device *dev;
        /*
         * 1. Protect this structure.
         * 2. Serialize sequences that power on/off the device and access HW.
@@ -146,6 +148,7 @@ struct bmc150_magn_data {
        struct iio_trigger *dready_trig;
        bool dready_trigger_on;
        int max_odr;
+        int irq;
 };
 static const struct {
@@ -215,7 +218,7 @@ static bool bmc150_magn_is_volatile_reg(struct device *dev, unsigned int reg)
        }
 }
-static const struct regmap_config bmc150_magn_regmap_config = {
+const struct regmap_config bmc150_magn_regmap_config = {
        .reg_bits = 8,
        .val_bits = 8,
@@ -225,6 +228,7 @@ static const struct regmap_config bmc150_magn_regmap_config = {
        .writeable_reg = bmc150_magn_is_writeable_reg,
        .volatile_reg = bmc150_magn_is_volatile_reg,
 };
+EXPORT_SYMBOL(bmc150_magn_regmap_config);
 static int bmc150_magn_set_power_mode(struct bmc150_magn_data *data,
                                      enum bmc150_magn_power_modes mode,
@@ -263,17 +267,17 @@ static int bmc150_magn_set_power_state(struct bmc150_magn_data *data, bool on)
        int ret;
        if (on) {
-                ret = pm_runtime_get_sync(&data->client->dev);
+                ret = pm_runtime_get_sync(data->dev);
        } else {
-                pm_runtime_mark_last_busy(&data->client->dev);
+                pm_runtime_mark_last_busy(data->dev);
-                ret = pm_runtime_put_autosuspend(&data->client->dev);
+                ret = pm_runtime_put_autosuspend(data->dev);
        }
        if (ret < 0) {
-                dev_err(&data->client->dev,
+                dev_err(data->dev,
                        "failed to change power state to %d\n", on);
                if (on)
-                        pm_runtime_put_noidle(&data->client->dev);
+                        pm_runtime_put_noidle(data->dev);
                return ret;
        }
@@ -350,7 +354,7 @@ static int bmc150_magn_set_max_odr(struct bmc150_magn_data *data, int rep_xy,
        /* the maximum selectable read-out frequency from datasheet */
        max_odr = 1000000 / (145 * rep_xy + 500 * rep_z + 980);
        if (odr > max_odr) {
-                dev_err(&data->client->dev,
+                dev_err(data->dev,
                        "Can't set oversampling with sampling freq %d\n",
                        odr);
                return -EINVAL;
@@ -684,27 +688,27 @@ static int bmc150_magn_init(struct bmc150_magn_data *data)
        ret = bmc150_magn_set_power_mode(data, BMC150_MAGN_POWER_MODE_SUSPEND,
                                         false);
        if (ret < 0) {
-                dev_err(&data->client->dev,
+                dev_err(data->dev,
                        "Failed to bring up device from suspend mode\n");
                return ret;
        }
        ret = regmap_read(data->regmap, BMC150_MAGN_REG_CHIP_ID, &chip_id);
        if (ret < 0) {
-                dev_err(&data->client->dev, "Failed reading chip id\n");
+                dev_err(data->dev, "Failed reading chip id\n");
                goto err_poweroff;
        }
        if (chip_id != BMC150_MAGN_CHIP_ID_VAL) {
-                dev_err(&data->client->dev, "Invalid chip id 0x%x\n", chip_id);
+                dev_err(data->dev, "Invalid chip id 0x%x\n", chip_id);
                ret = -ENODEV;
                goto err_poweroff;
        }
-        dev_dbg(&data->client->dev, "Chip id %x\n", chip_id);
+        dev_dbg(data->dev, "Chip id %x\n", chip_id);
        preset = bmc150_magn_presets_table[BMC150_MAGN_DEFAULT_PRESET];
        ret = bmc150_magn_set_odr(data, preset.odr);
        if (ret < 0) {
-                dev_err(&data->client->dev, "Failed to set ODR to %d\n",
+                dev_err(data->dev, "Failed to set ODR to %d\n",
                        preset.odr);
                goto err_poweroff;
        }
@@ -712,7 +716,7 @@ static int bmc150_magn_init(struct bmc150_magn_data *data)
        ret = regmap_write(data->regmap, BMC150_MAGN_REG_REP_XY,
                           BMC150_MAGN_REPXY_TO_REGVAL(preset.rep_xy));
        if (ret < 0) {
-                dev_err(&data->client->dev, "Failed to set REP XY to %d\n",
+                dev_err(data->dev, "Failed to set REP XY to %d\n",
                        preset.rep_xy);
                goto err_poweroff;
        }
@@ -720,7 +724,7 @@ static int bmc150_magn_init(struct bmc150_magn_data *data)
        ret = regmap_write(data->regmap, BMC150_MAGN_REG_REP_Z,
                           BMC150_MAGN_REPZ_TO_REGVAL(preset.rep_z));
        if (ret < 0) {
-                dev_err(&data->client->dev, "Failed to set REP Z to %d\n",
+                dev_err(data->dev, "Failed to set REP Z to %d\n",
                        preset.rep_z);
                goto err_poweroff;
        }
@@ -733,7 +737,7 @@ static int bmc150_magn_init(struct bmc150_magn_data *data)
        ret = bmc150_magn_set_power_mode(data, BMC150_MAGN_POWER_MODE_NORMAL,
                                         true);
        if (ret < 0) {
-                dev_err(&data->client->dev, "Failed to power on device\n");
+                dev_err(data->dev, "Failed to power on device\n");
                goto err_poweroff;
        }
@@ -842,41 +846,33 @@ static const char *bmc150_magn_match_acpi_device(struct device *dev)
        return dev_name(dev);
 }
-static int bmc150_magn_probe(struct i2c_client *client,
+int bmc150_magn_probe(struct device *dev, struct regmap *regmap,
-                             const struct i2c_device_id *id)
+                      int irq, const char *name)
 {
        struct bmc150_magn_data *data;
        struct iio_dev *indio_dev;
-        const char *name = NULL;
        int ret;
-        indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
+        indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
        if (!indio_dev)
                return -ENOMEM;
        data = iio_priv(indio_dev);
-        i2c_set_clientdata(client, indio_dev);
+        dev_set_drvdata(dev, indio_dev);
-        data->client = client;
+        data->regmap = regmap;
+        data->irq = irq;
+        data->dev = dev;
-        if (id)
+        if (!name && ACPI_HANDLE(dev))
-                name = id->name;
+                name = bmc150_magn_match_acpi_device(dev);
-        else if (ACPI_HANDLE(&client->dev))
-                name = bmc150_magn_match_acpi_device(&client->dev);
-        else
-                return -ENOSYS;
        mutex_init(&data->mutex);
-        data->regmap = devm_regmap_init_i2c(client, &bmc150_magn_regmap_config);
-        if (IS_ERR(data->regmap)) {
-                dev_err(&client->dev, "Failed to allocate register map\n");
-                return PTR_ERR(data->regmap);
-        }
        ret = bmc150_magn_init(data);
        if (ret < 0)
                return ret;
-        indio_dev->dev.parent = &client->dev;
+        indio_dev->dev.parent = dev;
        indio_dev->channels = bmc150_magn_channels;
        indio_dev->num_channels = ARRAY_SIZE(bmc150_magn_channels);
        indio_dev->available_scan_masks = bmc150_magn_scan_masks;
@@ -884,35 +880,34 @@ static int bmc150_magn_probe(struct i2c_client *client,
        indio_dev->modes = INDIO_DIRECT_MODE;
        indio_dev->info = &bmc150_magn_info;
-        if (client->irq > 0) {
+        if (irq > 0) {
-                data->dready_trig = devm_iio_trigger_alloc(&client->dev,
+                data->dready_trig = devm_iio_trigger_alloc(dev,
                                                           "%s-dev%d",
                                                           indio_dev->name,
                                                           indio_dev->id);
                if (!data->dready_trig) {
                        ret = -ENOMEM;
-                        dev_err(&client->dev, "iio trigger alloc failed\n");
+                        dev_err(dev, "iio trigger alloc failed\n");
                        goto err_poweroff;
                }
-                data->dready_trig->dev.parent = &client->dev;
+                data->dready_trig->dev.parent = dev;
                data->dready_trig->ops = &bmc150_magn_trigger_ops;
                iio_trigger_set_drvdata(data->dready_trig, indio_dev);
                ret = iio_trigger_register(data->dready_trig);
                if (ret) {
-                        dev_err(&client->dev, "iio trigger register failed\n");
+                        dev_err(dev, "iio trigger register failed\n");
                        goto err_poweroff;
                }
-                ret = request_threaded_irq(client->irq,
+                ret = request_threaded_irq(irq,
                                           iio_trigger_generic_data_rdy_poll,
                                           NULL,
                                           IRQF_TRIGGER_RISING | IRQF_ONESHOT,
                                           BMC150_MAGN_IRQ_NAME,
                                           data->dready_trig);
                if (ret < 0) {
-                        dev_err(&client->dev, "request irq %d failed\n",
+                        dev_err(dev, "request irq %d failed\n", irq);
-                                client->irq);
                        goto err_trigger_unregister;
                }
        }
@@ -922,34 +917,33 @@ static int bmc150_magn_probe(struct i2c_client *client,
                                         bmc150_magn_trigger_handler,
                                         &bmc150_magn_buffer_setup_ops);
        if (ret < 0) {
-                dev_err(&client->dev,
+                dev_err(dev, "iio triggered buffer setup failed\n");
-                        "iio triggered buffer setup failed\n");
                goto err_free_irq;
        }
-        ret = pm_runtime_set_active(&client->dev);
+        ret = pm_runtime_set_active(dev);
        if (ret)
                goto err_buffer_cleanup;
-        pm_runtime_enable(&client->dev);
+        pm_runtime_enable(dev);
-        pm_runtime_set_autosuspend_delay(&client->dev,
+        pm_runtime_set_autosuspend_delay(dev,
                                         BMC150_MAGN_AUTO_SUSPEND_DELAY_MS);
-        pm_runtime_use_autosuspend(&client->dev);
+        pm_runtime_use_autosuspend(dev);
        ret = iio_device_register(indio_dev);
        if (ret < 0) {
-                dev_err(&client->dev, "unable to register iio device\n");
+                dev_err(dev, "unable to register iio device\n");
                goto err_buffer_cleanup;
        }
-        dev_dbg(&indio_dev->dev, "Registered device %s\n", name);
+        dev_dbg(dev, "Registered device %s\n", name);
        return 0;
 err_buffer_cleanup:
        iio_triggered_buffer_cleanup(indio_dev);
 err_free_irq:
-        if (client->irq > 0)
+        if (irq > 0)
-                free_irq(client->irq, data->dready_trig);
+                free_irq(irq, data->dready_trig);
 err_trigger_unregister:
        if (data->dready_trig)
                iio_trigger_unregister(data->dready_trig);
@@ -957,22 +951,23 @@ err_poweroff:
        bmc150_magn_set_power_mode(data, BMC150_MAGN_POWER_MODE_SUSPEND, true);
        return ret;
 }
+EXPORT_SYMBOL(bmc150_magn_probe);
-static int bmc150_magn_remove(struct i2c_client *client)
+int bmc150_magn_remove(struct device *dev)
 {
-        struct iio_dev *indio_dev = i2c_get_clientdata(client);
+        struct iio_dev *indio_dev = dev_get_drvdata(dev);
        struct bmc150_magn_data *data = iio_priv(indio_dev);
        iio_device_unregister(indio_dev);
-        pm_runtime_disable(&client->dev);
+        pm_runtime_disable(dev);
-        pm_runtime_set_suspended(&client->dev);
+        pm_runtime_set_suspended(dev);
-        pm_runtime_put_noidle(&client->dev);
+        pm_runtime_put_noidle(dev);
        iio_triggered_buffer_cleanup(indio_dev);
-        if (client->irq > 0)
+        if (data->irq > 0)
-                free_irq(data->client->irq, data->dready_trig);
+                free_irq(data->irq, data->dready_trig);
        if (data->dready_trig)
                iio_trigger_unregister(data->dready_trig);
@@ -983,11 +978,12 @@ static int bmc150_magn_remove(struct i2c_client *client)
        return 0;
 }
+EXPORT_SYMBOL(bmc150_magn_remove);
 #ifdef CONFIG_PM
 static int bmc150_magn_runtime_suspend(struct device *dev)
 {
-        struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
+        struct iio_dev *indio_dev = dev_get_drvdata(dev);
        struct bmc150_magn_data *data = iio_priv(indio_dev);
        int ret;
@@ -996,7 +992,7 @@ static int bmc150_magn_runtime_suspend(struct device *dev)
                                         true);
        mutex_unlock(&data->mutex);
        if (ret < 0) {
-                dev_err(&data->client->dev, "powering off device failed\n");
+                dev_err(dev, "powering off device failed\n");
                return ret;
        }
        return 0;
@@ -1007,7 +1003,7 @@ static int bmc150_magn_runtime_suspend(struct device *dev)
 */
 static int bmc150_magn_runtime_resume(struct device *dev)
 {
-        struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
+        struct iio_dev *indio_dev = dev_get_drvdata(dev);
        struct bmc150_magn_data *data = iio_priv(indio_dev);
        return bmc150_magn_set_power_mode(data, BMC150_MAGN_POWER_MODE_NORMAL,
@@ -1018,7 +1014,7 @@ static int bmc150_magn_runtime_resume(struct device *dev)
 #ifdef CONFIG_PM_SLEEP
 static int bmc150_magn_suspend(struct device *dev)
 {
-        struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
+        struct iio_dev *indio_dev = dev_get_drvdata(dev);
        struct bmc150_magn_data *data = iio_priv(indio_dev);
        int ret;
@@ -1032,7 +1028,7 @@ static int bmc150_magn_suspend(struct device *dev)
 static int bmc150_magn_resume(struct device *dev)
 {
-        struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
+        struct iio_dev *indio_dev = dev_get_drvdata(dev);
        struct bmc150_magn_data *data = iio_priv(indio_dev);
        int ret;
@@ -1045,38 +1041,13 @@ static int bmc150_magn_resume(struct device *dev)
 }
 #endif
-static const struct dev_pm_ops bmc150_magn_pm_ops = {
+const struct dev_pm_ops bmc150_magn_pm_ops = {
        SET_SYSTEM_SLEEP_PM_OPS(bmc150_magn_suspend, bmc150_magn_resume)
        SET_RUNTIME_PM_OPS(bmc150_magn_runtime_suspend,
                           bmc150_magn_runtime_resume, NULL)
 };
+EXPORT_SYMBOL(bmc150_magn_pm_ops);
-static const struct acpi_device_id bmc150_magn_acpi_match[] = {
-        {"BMC150B", 0},
-        {"BMC156B", 0},
-        {},
-};
-MODULE_DEVICE_TABLE(acpi, bmc150_magn_acpi_match);
-static const struct i2c_device_id bmc150_magn_id[] = {
-        {"bmc150_magn", 0},
-        {"bmc156_magn", 0},
-        {},
-};
-MODULE_DEVICE_TABLE(i2c, bmc150_magn_id);
-static struct i2c_driver bmc150_magn_driver = {
-        .driver = {
-                   .name = BMC150_MAGN_DRV_NAME,
-                   .acpi_match_table = ACPI_PTR(bmc150_magn_acpi_match),
-                   .pm = &bmc150_magn_pm_ops,
-                   },
-        .probe = bmc150_magn_probe,
-        .remove = bmc150_magn_remove,
-        .id_table = bmc150_magn_id,
-};
-module_i2c_driver(bmc150_magn_driver);
 MODULE_AUTHOR("Irina Tirdea <irina.tirdea@intel.com>");
 MODULE_LICENSE("GPL v2");
-MODULE_DESCRIPTION("BMC150 magnetometer driver");
+MODULE_DESCRIPTION("BMC150 magnetometer core driver");
diff --git a/drivers/iio/magnetometer/bmc150_magn.h b/drivers/iio/magnetometer/bmc150_magn.h
new file mode 100644
index 000000000000..9a8e26812ca8
--- /dev/null
+++ b/drivers/iio/magnetometer/bmc150_magn.h
@@ -0,0 +1,11 @@
+#ifndef _BMC150_MAGN_H_
+#define _BMC150_MAGN_H_
+extern const struct regmap_config bmc150_magn_regmap_config;
+extern const struct dev_pm_ops bmc150_magn_pm_ops;
+int bmc150_magn_probe(struct device *dev, struct regmap *regmap, int irq,
+                      const char *name);
+int bmc150_magn_remove(struct device *dev);
+#endif /* _BMC150_MAGN_H_ */
diff --git a/drivers/iio/magnetometer/bmc150_magn_i2c.c b/drivers/iio/magnetometer/bmc150_magn_i2c.c
new file mode 100644
index 000000000000..eddc7f0d0096
--- /dev/null
+++ b/drivers/iio/magnetometer/bmc150_magn_i2c.c
@@ -0,0 +1,77 @@
+/*
+ * 3-axis magnetometer driver supporting following I2C Bosch-Sensortec chips:
+ *  - BMC150
+ *  - BMC156
+ *
+ * Copyright (c) 2016, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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/device.h>
+#include <linux/mod_devicetable.h>
+#include <linux/i2c.h>
+#include <linux/module.h>
+#include <linux/acpi.h>
+#include <linux/regmap.h>
+#include "bmc150_magn.h"
+static int bmc150_magn_i2c_probe(struct i2c_client *client,
+                                 const struct i2c_device_id *id)
+{
+        struct regmap *regmap;
+        const char *name = NULL;
+        regmap = devm_regmap_init_i2c(client, &bmc150_magn_regmap_config);
+        if (IS_ERR(regmap)) {
+                dev_err(&client->dev, "Failed to initialize i2c regmap\n");
+                return PTR_ERR(regmap);
+        }
+        if (id)
+                name = id->name;
+        return bmc150_magn_probe(&client->dev, regmap, client->irq, name);
+}
+static int bmc150_magn_i2c_remove(struct i2c_client *client)
+{
+        return bmc150_magn_remove(&client->dev);
+}
+static const struct acpi_device_id bmc150_magn_acpi_match[] = {
+        {"BMC150B", 0},
+        {"BMC156B", 0},
+        {},
+};
+MODULE_DEVICE_TABLE(acpi, bmc150_magn_acpi_match);
+static const struct i2c_device_id bmc150_magn_i2c_id[] = {
+        {"bmc150_magn", 0},
+        {"bmc156_magn", 0},
+        {}
+};
+MODULE_DEVICE_TABLE(i2c, bmc150_magn_i2c_id);
+static struct i2c_driver bmc150_magn_driver = {
+        .driver = {
+                .name   = "bmc150_magn_i2c",
+                .acpi_match_table = ACPI_PTR(bmc150_magn_acpi_match),
+                .pm     = &bmc150_magn_pm_ops,
+        },
+        .probe          = bmc150_magn_i2c_probe,
+        .remove         = bmc150_magn_i2c_remove,
+        .id_table       = bmc150_magn_i2c_id,
+};
+module_i2c_driver(bmc150_magn_driver);
+MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com");
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("BMC150 I2C magnetometer driver");
diff --git a/drivers/iio/magnetometer/bmc150_magn_spi.c b/drivers/iio/magnetometer/bmc150_magn_spi.c
new file mode 100644
index 000000000000..c4c738a07695
--- /dev/null
+++ b/drivers/iio/magnetometer/bmc150_magn_spi.c
@@ -0,0 +1,68 @@
+/*
+ * 3-axis magnetometer driver support following SPI Bosch-Sensortec chips:
+ *  - BMC150
+ *  - BMC156
+ *
+ * Copyright (c) 2016, Intel Corporation.
+ *
+ * This file is subject to the terms and conditions of version 2 of
+ * the GNU General Public License.  See the file COPYING in the main
+ * directory of this archive for more details.
+ */
+#include <linux/module.h>
+#include <linux/mod_devicetable.h>
+#include <linux/spi/spi.h>
+#include <linux/acpi.h>
+#include <linux/regmap.h>
+#include "bmc150_magn.h"
+static int bmc150_magn_spi_probe(struct spi_device *spi)
+{
+        struct regmap *regmap;
+        const struct spi_device_id *id = spi_get_device_id(spi);
+        regmap = devm_regmap_init_spi(spi, &bmc150_magn_regmap_config);
+        if (IS_ERR(regmap)) {
+                dev_err(&spi->dev, "Failed to register spi regmap %d\n",
+                        (int)PTR_ERR(regmap));
+                return PTR_ERR(regmap);
+        }
+        return bmc150_magn_probe(&spi->dev, regmap, spi->irq, id->name);
+}
+static int bmc150_magn_spi_remove(struct spi_device *spi)
+{
+        bmc150_magn_remove(&spi->dev);
+        return 0;
+}
+static const struct spi_device_id bmc150_magn_spi_id[] = {
+        {"bmc150_magn", 0},
+        {"bmc156_magn", 0},
+        {}
+};
+MODULE_DEVICE_TABLE(spi, bmc150_magn_spi_id);
+static const struct acpi_device_id bmc150_magn_acpi_match[] = {
+        {"BMC150B", 0},
+        {"BMC156B", 0},
+        {},
+};
+MODULE_DEVICE_TABLE(acpi, bmc150_magn_acpi_match);
+static struct spi_driver bmc150_magn_spi_driver = {
+        .probe          = bmc150_magn_spi_probe,
+        .remove         = bmc150_magn_spi_remove,
+        .id_table       = bmc150_magn_spi_id,
+        .driver = {
+                .acpi_match_table = ACPI_PTR(bmc150_magn_acpi_match),
+                .name   = "bmc150_magn_spi",
+        },
+};
+module_spi_driver(bmc150_magn_spi_driver);
+MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com");
+MODULE_DESCRIPTION("BMC150 magnetometer SPI driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/magnetometer/st_magn_core.c b/drivers/iio/magnetometer/st_magn_core.c
index 501f858df413..62036d2a9956 100644
--- a/drivers/iio/magnetometer/st_magn_core.c
+++ b/drivers/iio/magnetometer/st_magn_core.c
@@ -484,6 +484,7 @@ static const struct st_sensor_settings st_magn_sensors_settings[] = {
                        .mask_int1 = ST_MAGN_3_DRDY_INT_MASK,
                        .addr_ihl = ST_MAGN_3_IHL_IRQ_ADDR,
                        .mask_ihl = ST_MAGN_3_IHL_IRQ_MASK,
+                        .addr_stat_drdy = ST_SENSORS_DEFAULT_STAT_ADDR,
                },
                .multi_read_bit = ST_MAGN_3_MULTIREAD_BIT,
                .bootime = 2,
diff --git a/drivers/iio/potentiometer/Kconfig b/drivers/iio/potentiometer/Kconfig
index 7ea069bbca2d..6acb23810bb4 100644
--- a/drivers/iio/potentiometer/Kconfig
+++ b/drivers/iio/potentiometer/Kconfig
@@ -5,6 +5,16 @@
 menu "Digital potentiometers"
+config DS1803
+        tristate "Maxim Integrated DS1803 Digital Potentiometer driver"
+        depends on I2C
+        help
+          Say yes here to build support for the Maxim Integrated DS1803
+          digital potentiomenter chip.
+          To compile this driver as a module, choose M here: the
+          module will be called ds1803.
 config MCP4131
        tristate "Microchip MCP413X/414X/415X/416X/423X/424X/425X/426X Digital Potentiometer driver"
        depends on SPI
diff --git a/drivers/iio/potentiometer/Makefile b/drivers/iio/potentiometer/Makefile
index 91a80f8db24d..6007faa2fb02 100644
--- a/drivers/iio/potentiometer/Makefile
+++ b/drivers/iio/potentiometer/Makefile
@@ -3,6 +3,7 @@
 #
 # When adding new entries keep the list in alphabetical order
+obj-$(CONFIG_DS1803) += ds1803.o
 obj-$(CONFIG_MCP4131) += mcp4131.o
 obj-$(CONFIG_MCP4531) += mcp4531.o
 obj-$(CONFIG_TPL0102) += tpl0102.o
diff --git a/drivers/iio/potentiometer/ds1803.c b/drivers/iio/potentiometer/ds1803.c
new file mode 100644
index 000000000000..fb9e2a337dc2
--- /dev/null
+++ b/drivers/iio/potentiometer/ds1803.c
@@ -0,0 +1,173 @@
+/*
+ * Maxim Integrated DS1803 digital potentiometer driver
+ * Copyright (c) 2016 Slawomir Stepien
+ *
+ * Datasheet: https://datasheets.maximintegrated.com/en/ds/DS1803.pdf
+ *
+ * DEVID        #Wipers #Positions      Resistor Opts (kOhm)    i2c address
+ * ds1803       2       256             10, 50, 100             0101xxx
+ *
+ * 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.
+ */
+#include <linux/err.h>
+#include <linux/export.h>
+#include <linux/i2c.h>
+#include <linux/iio/iio.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#define DS1803_MAX_POS          255
+#define DS1803_WRITE(chan)      (0xa8 | ((chan) + 1))
+enum ds1803_type {
+        DS1803_010,
+        DS1803_050,
+        DS1803_100,
+};
+struct ds1803_cfg {
+        int kohms;
+};
+static const struct ds1803_cfg ds1803_cfg[] = {
+        [DS1803_010] = { .kohms =  10, },
+        [DS1803_050] = { .kohms =  50, },
+        [DS1803_100] = { .kohms = 100, },
+};
+struct ds1803_data {
+        struct i2c_client *client;
+        const struct ds1803_cfg *cfg;
+};
+#define DS1803_CHANNEL(ch) {                                    \
+        .type = IIO_RESISTANCE,                                 \
+        .indexed = 1,                                           \
+        .output = 1,                                            \
+        .channel = (ch),                                        \
+        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),           \
+        .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),   \
+}
+static const struct iio_chan_spec ds1803_channels[] = {
+        DS1803_CHANNEL(0),
+        DS1803_CHANNEL(1),
+};
+static int ds1803_read_raw(struct iio_dev *indio_dev,
+                            struct iio_chan_spec const *chan,
+                            int *val, int *val2, long mask)
+{
+        struct ds1803_data *data = iio_priv(indio_dev);
+        int pot = chan->channel;
+        int ret;
+        u8 result[indio_dev->num_channels];
+        switch (mask) {
+        case IIO_CHAN_INFO_RAW:
+                ret = i2c_master_recv(data->client, result,
+                                indio_dev->num_channels);
+                if (ret < 0)
+                        return ret;
+                *val = result[pot];
+                return IIO_VAL_INT;
+        case IIO_CHAN_INFO_SCALE:
+                *val = 1000 * data->cfg->kohms;
+                *val2 = DS1803_MAX_POS;
+                return IIO_VAL_FRACTIONAL;
+        }
+        return -EINVAL;
+}
+static int ds1803_write_raw(struct iio_dev *indio_dev,
+                             struct iio_chan_spec const *chan,
+                             int val, int val2, long mask)
+{
+        struct ds1803_data *data = iio_priv(indio_dev);
+        int pot = chan->channel;
+        if (val2 != 0)
+                return -EINVAL;
+        switch (mask) {
+        case IIO_CHAN_INFO_RAW:
+                if (val > DS1803_MAX_POS || val < 0)
+                        return -EINVAL;
+                break;
+        default:
+                return -EINVAL;
+        }
+        return i2c_smbus_write_byte_data(data->client, DS1803_WRITE(pot), val);
+}
+static const struct iio_info ds1803_info = {
+        .read_raw = ds1803_read_raw,
+        .write_raw = ds1803_write_raw,
+        .driver_module = THIS_MODULE,
+};
+static int ds1803_probe(struct i2c_client *client,
+                         const struct i2c_device_id *id)
+{
+        struct device *dev = &client->dev;
+        struct ds1803_data *data;
+        struct iio_dev *indio_dev;
+        indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
+        if (!indio_dev)
+                return -ENOMEM;
+        i2c_set_clientdata(client, indio_dev);
+        data = iio_priv(indio_dev);
+        data->client = client;
+        data->cfg = &ds1803_cfg[id->driver_data];
+        indio_dev->dev.parent = dev;
+        indio_dev->info = &ds1803_info;
+        indio_dev->channels = ds1803_channels;
+        indio_dev->num_channels = ARRAY_SIZE(ds1803_channels);
+        indio_dev->name = client->name;
+        return devm_iio_device_register(dev, indio_dev);
+}
+#if defined(CONFIG_OF)
+static const struct of_device_id ds1803_dt_ids[] = {
+        { .compatible = "maxim,ds1803-010", .data = &ds1803_cfg[DS1803_010] },
+        { .compatible = "maxim,ds1803-050", .data = &ds1803_cfg[DS1803_050] },
+        { .compatible = "maxim,ds1803-100", .data = &ds1803_cfg[DS1803_100] },
+        {}
+};
+MODULE_DEVICE_TABLE(of, ds1803_dt_ids);
+#endif /* CONFIG_OF */
+static const struct i2c_device_id ds1803_id[] = {
+        { "ds1803-010", DS1803_010 },
+        { "ds1803-050", DS1803_050 },
+        { "ds1803-100", DS1803_100 },
+        {}
+};
+MODULE_DEVICE_TABLE(i2c, ds1803_id);
+static struct i2c_driver ds1803_driver = {
+        .driver = {
+                .name   = "ds1803",
+                .of_match_table = of_match_ptr(ds1803_dt_ids),
+        },
+        .probe          = ds1803_probe,
+        .id_table       = ds1803_id,
+};
+module_i2c_driver(ds1803_driver);
+MODULE_AUTHOR("Slawomir Stepien <sst@poczta.fm>");
+MODULE_DESCRIPTION("DS1803 digital potentiometer");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/pressure/Kconfig b/drivers/iio/pressure/Kconfig
index 8de0192adea6..cda9f128f3a4 100644
--- a/drivers/iio/pressure/Kconfig
+++ b/drivers/iio/pressure/Kconfig
@@ -6,12 +6,13 @@
 menu "Pressure sensors"
 config BMP280
-        tristate "Bosch Sensortec BMP280 pressure sensor driver"
+        tristate "Bosch Sensortec BMP180 and BMP280 pressure sensor driver"
        depends on I2C
+        depends on !(BMP085_I2C=y || BMP085_I2C=m)
        select REGMAP_I2C
        help
-          Say yes here to build support for Bosch Sensortec BMP280
+          Say yes here to build support for Bosch Sensortec BMP180 and BMP280
-          pressure and temperature sensor.
+          pressure and temperature sensors.
          To compile this driver as a module, choose M here: the module
          will be called bmp280.
@@ -30,6 +31,17 @@ config HID_SENSOR_PRESS
          To compile this driver as a module, choose M here: the module
          will be called hid-sensor-press.
+config HP03
+        tristate "Hope RF HP03 temperature and pressure sensor driver"
+        depends on I2C
+        select REGMAP_I2C
+        help
+          Say yes here to build support for Hope RF HP03 pressure and
+          temperature sensor.
+          To compile this driver as a module, choose M here: the module
+          will be called hp03.
 config MPL115
        tristate
diff --git a/drivers/iio/pressure/Makefile b/drivers/iio/pressure/Makefile
index 6e60863c1086..17d6e7afa1ff 100644
--- a/drivers/iio/pressure/Makefile
+++ b/drivers/iio/pressure/Makefile
@@ -5,6 +5,7 @@
 # When adding new entries keep the list in alphabetical order
 obj-$(CONFIG_BMP280) += bmp280.o
 obj-$(CONFIG_HID_SENSOR_PRESS)   += hid-sensor-press.o
+obj-$(CONFIG_HP03) += hp03.o
 obj-$(CONFIG_MPL115) += mpl115.o
 obj-$(CONFIG_MPL115_I2C) += mpl115_i2c.o
 obj-$(CONFIG_MPL115_SPI) += mpl115_spi.o
diff --git a/drivers/iio/pressure/bmp280.c b/drivers/iio/pressure/bmp280.c
index a2602d8dd6d5..2f1498e12bb2 100644
--- a/drivers/iio/pressure/bmp280.c
+++ b/drivers/iio/pressure/bmp280.c
@@ -1,12 +1,15 @@
 /*
 * Copyright (c) 2014 Intel Corporation
 *
- * Driver for Bosch Sensortec BMP280 digital pressure sensor.
+ * Driver for Bosch Sensortec BMP180 and BMP280 digital pressure sensor.
 *
 * 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.
 *
+ * Datasheet:
+ * https://ae-bst.resource.bosch.com/media/_tech/media/datasheets/BST-BMP180-DS000-121.pdf
+ * https://ae-bst.resource.bosch.com/media/_tech/media/datasheets/BST-BMP280-DS001-12.pdf
 */
 #define pr_fmt(fmt) "bmp280: " fmt
@@ -15,9 +18,11 @@
 #include <linux/i2c.h>
 #include <linux/acpi.h>
 #include <linux/regmap.h>
+#include <linux/delay.h>
 #include <linux/iio/iio.h>
 #include <linux/iio/sysfs.h>
+/* BMP280 specific registers */
 #define BMP280_REG_TEMP_XLSB            0xFC
 #define BMP280_REG_TEMP_LSB             0xFB
 #define BMP280_REG_TEMP_MSB             0xFA
@@ -26,10 +31,7 @@
 #define BMP280_REG_PRESS_MSB            0xF7
 #define BMP280_REG_CONFIG               0xF5
-#define BMP280_REG_CTRL_MEAS            0xF4
 #define BMP280_REG_STATUS               0xF3
-#define BMP280_REG_RESET                0xE0
-#define BMP280_REG_ID                   0xD0
 #define BMP280_REG_COMP_TEMP_START      0x88
 #define BMP280_COMP_TEMP_REG_COUNT      6
@@ -46,25 +48,49 @@
 #define BMP280_OSRS_TEMP_MASK           (BIT(7) | BIT(6) | BIT(5))
 #define BMP280_OSRS_TEMP_SKIP           0
-#define BMP280_OSRS_TEMP_1X             BIT(5)
+#define BMP280_OSRS_TEMP_X(osrs_t)      ((osrs_t) << 5)
-#define BMP280_OSRS_TEMP_2X             BIT(6)
+#define BMP280_OSRS_TEMP_1X             BMP280_OSRS_TEMP_X(1)
-#define BMP280_OSRS_TEMP_4X             (BIT(6) | BIT(5))
+#define BMP280_OSRS_TEMP_2X             BMP280_OSRS_TEMP_X(2)
-#define BMP280_OSRS_TEMP_8X             BIT(7)
+#define BMP280_OSRS_TEMP_4X             BMP280_OSRS_TEMP_X(3)
-#define BMP280_OSRS_TEMP_16X            (BIT(7) | BIT(5))
+#define BMP280_OSRS_TEMP_8X             BMP280_OSRS_TEMP_X(4)
+#define BMP280_OSRS_TEMP_16X            BMP280_OSRS_TEMP_X(5)
 #define BMP280_OSRS_PRESS_MASK          (BIT(4) | BIT(3) | BIT(2))
 #define BMP280_OSRS_PRESS_SKIP          0
-#define BMP280_OSRS_PRESS_1X            BIT(2)
+#define BMP280_OSRS_PRESS_X(osrs_p)     ((osrs_p) << 2)
-#define BMP280_OSRS_PRESS_2X            BIT(3)
+#define BMP280_OSRS_PRESS_1X            BMP280_OSRS_PRESS_X(1)
-#define BMP280_OSRS_PRESS_4X            (BIT(3) | BIT(2))
+#define BMP280_OSRS_PRESS_2X            BMP280_OSRS_PRESS_X(2)
-#define BMP280_OSRS_PRESS_8X            BIT(4)
+#define BMP280_OSRS_PRESS_4X            BMP280_OSRS_PRESS_X(3)
-#define BMP280_OSRS_PRESS_16X           (BIT(4) | BIT(2))
+#define BMP280_OSRS_PRESS_8X            BMP280_OSRS_PRESS_X(4)
+#define BMP280_OSRS_PRESS_16X           BMP280_OSRS_PRESS_X(5)
 #define BMP280_MODE_MASK                (BIT(1) | BIT(0))
 #define BMP280_MODE_SLEEP               0
 #define BMP280_MODE_FORCED              BIT(0)
 #define BMP280_MODE_NORMAL              (BIT(1) | BIT(0))
+/* BMP180 specific registers */
+#define BMP180_REG_OUT_XLSB             0xF8
+#define BMP180_REG_OUT_LSB              0xF7
+#define BMP180_REG_OUT_MSB              0xF6
+#define BMP180_REG_CALIB_START          0xAA
+#define BMP180_REG_CALIB_COUNT          22
+#define BMP180_MEAS_SCO                 BIT(5)
+#define BMP180_MEAS_TEMP                (0x0E | BMP180_MEAS_SCO)
+#define BMP180_MEAS_PRESS_X(oss)        ((oss) << 6 | 0x14 | BMP180_MEAS_SCO)
+#define BMP180_MEAS_PRESS_1X            BMP180_MEAS_PRESS_X(0)
+#define BMP180_MEAS_PRESS_2X            BMP180_MEAS_PRESS_X(1)
+#define BMP180_MEAS_PRESS_4X            BMP180_MEAS_PRESS_X(2)
+#define BMP180_MEAS_PRESS_8X            BMP180_MEAS_PRESS_X(3)
+/* BMP180 and BMP280 common registers */
+#define BMP280_REG_CTRL_MEAS            0xF4
+#define BMP280_REG_RESET                0xE0
+#define BMP280_REG_ID                   0xD0
+#define BMP180_CHIP_ID                  0x55
 #define BMP280_CHIP_ID                  0x58
 #define BMP280_SOFT_RESET_VAL           0xB6
@@ -72,6 +98,11 @@ struct bmp280_data {
        struct i2c_client *client;
        struct mutex lock;
        struct regmap *regmap;
+        const struct bmp280_chip_info *chip_info;
+        /* log of base 2 of oversampling rate */
+        u8 oversampling_press;
+        u8 oversampling_temp;
        /*
         * Carryover value from temperature conversion, used in pressure
@@ -80,9 +111,23 @@ struct bmp280_data {
        s32 t_fine;
 };
+struct bmp280_chip_info {
+        const struct regmap_config *regmap_config;
+        const int *oversampling_temp_avail;
+        int num_oversampling_temp_avail;
+        const int *oversampling_press_avail;
+        int num_oversampling_press_avail;
+        int (*chip_config)(struct bmp280_data *);
+        int (*read_temp)(struct bmp280_data *, int *);
+        int (*read_press)(struct bmp280_data *, int *, int *);
+};
 /*
 * These enums are used for indexing into the array of compensation
- * parameters.
+ * parameters for BMP280.
 */
 enum { T1, T2, T3 };
 enum { P1, P2, P3, P4, P5, P6, P7, P8, P9 };
@@ -90,11 +135,13 @@ enum { P1, P2, P3, P4, P5, P6, P7, P8, P9 };
 static const struct iio_chan_spec bmp280_channels[] = {
        {
                .type = IIO_PRESSURE,
-                .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
+                .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
+                                      BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
        },
        {
                .type = IIO_TEMP,
-                .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
+                .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
+                                      BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
        },
 };
@@ -290,10 +337,25 @@ static int bmp280_read_raw(struct iio_dev *indio_dev,
        case IIO_CHAN_INFO_PROCESSED:
                switch (chan->type) {
                case IIO_PRESSURE:
-                        ret = bmp280_read_press(data, val, val2);
+                        ret = data->chip_info->read_press(data, val, val2);
                        break;
                case IIO_TEMP:
-                        ret = bmp280_read_temp(data, val);
+                        ret = data->chip_info->read_temp(data, val);
+                        break;
+                default:
+                        ret = -EINVAL;
+                        break;
+                }
+                break;
+        case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
+                switch (chan->type) {
+                case IIO_PRESSURE:
+                        *val = 1 << data->oversampling_press;
+                        ret = IIO_VAL_INT;
+                        break;
+                case IIO_TEMP:
+                        *val = 1 << data->oversampling_temp;
+                        ret = IIO_VAL_INT;
                        break;
                default:
                        ret = -EINVAL;
@@ -310,22 +372,135 @@ static int bmp280_read_raw(struct iio_dev *indio_dev,
        return ret;
 }
+static int bmp280_write_oversampling_ratio_temp(struct bmp280_data *data,
+                                               int val)
+{
+        int i;
+        const int *avail = data->chip_info->oversampling_temp_avail;
+        const int n = data->chip_info->num_oversampling_temp_avail;
+        for (i = 0; i < n; i++) {
+                if (avail[i] == val) {
+                        data->oversampling_temp = ilog2(val);
+                        return data->chip_info->chip_config(data);
+                }
+        }
+        return -EINVAL;
+}
+static int bmp280_write_oversampling_ratio_press(struct bmp280_data *data,
+                                               int val)
+{
+        int i;
+        const int *avail = data->chip_info->oversampling_press_avail;
+        const int n = data->chip_info->num_oversampling_press_avail;
+        for (i = 0; i < n; i++) {
+                if (avail[i] == val) {
+                        data->oversampling_press = ilog2(val);
+                        return data->chip_info->chip_config(data);
+                }
+        }
+        return -EINVAL;
+}
+static int bmp280_write_raw(struct iio_dev *indio_dev,
+                            struct iio_chan_spec const *chan,
+                            int val, int val2, long mask)
+{
+        int ret = 0;
+        struct bmp280_data *data = iio_priv(indio_dev);
+        switch (mask) {
+        case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
+                mutex_lock(&data->lock);
+                switch (chan->type) {
+                case IIO_PRESSURE:
+                        ret = bmp280_write_oversampling_ratio_press(data, val);
+                        break;
+                case IIO_TEMP:
+                        ret = bmp280_write_oversampling_ratio_temp(data, val);
+                        break;
+                default:
+                        ret = -EINVAL;
+                        break;
+                }
+                mutex_unlock(&data->lock);
+                break;
+        default:
+                return -EINVAL;
+        }
+        return ret;
+}
+static ssize_t bmp280_show_avail(char *buf, const int *vals, const int n)
+{
+        size_t len = 0;
+        int i;
+        for (i = 0; i < n; i++)
+                len += scnprintf(buf + len, PAGE_SIZE - len, "%d ", vals[i]);
+        buf[len - 1] = '\n';
+        return len;
+}
+static ssize_t bmp280_show_temp_oversampling_avail(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct bmp280_data *data = iio_priv(dev_to_iio_dev(dev));
+        return bmp280_show_avail(buf, data->chip_info->oversampling_temp_avail,
+                                 data->chip_info->num_oversampling_temp_avail);
+}
+static ssize_t bmp280_show_press_oversampling_avail(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct bmp280_data *data = iio_priv(dev_to_iio_dev(dev));
+        return bmp280_show_avail(buf, data->chip_info->oversampling_press_avail,
+                                 data->chip_info->num_oversampling_press_avail);
+}
+static IIO_DEVICE_ATTR(in_temp_oversampling_ratio_available,
+        S_IRUGO, bmp280_show_temp_oversampling_avail, NULL, 0);
+static IIO_DEVICE_ATTR(in_pressure_oversampling_ratio_available,
+        S_IRUGO, bmp280_show_press_oversampling_avail, NULL, 0);
+static struct attribute *bmp280_attributes[] = {
+        &iio_dev_attr_in_temp_oversampling_ratio_available.dev_attr.attr,
+        &iio_dev_attr_in_pressure_oversampling_ratio_available.dev_attr.attr,
+        NULL,
+};
+static const struct attribute_group bmp280_attrs_group = {
+        .attrs = bmp280_attributes,
+};
 static const struct iio_info bmp280_info = {
        .driver_module = THIS_MODULE,
        .read_raw = &bmp280_read_raw,
+        .write_raw = &bmp280_write_raw,
+        .attrs = &bmp280_attrs_group,
 };
-static int bmp280_chip_init(struct bmp280_data *data)
+static int bmp280_chip_config(struct bmp280_data *data)
 {
        int ret;
+        u8 osrs = BMP280_OSRS_TEMP_X(data->oversampling_temp + 1) |
+                  BMP280_OSRS_PRESS_X(data->oversampling_press + 1);
        ret = regmap_update_bits(data->regmap, BMP280_REG_CTRL_MEAS,
                                 BMP280_OSRS_TEMP_MASK |
                                 BMP280_OSRS_PRESS_MASK |
                                 BMP280_MODE_MASK,
-                                 BMP280_OSRS_TEMP_2X |
+                                 osrs | BMP280_MODE_NORMAL);
-                                 BMP280_OSRS_PRESS_16X |
-                                 BMP280_MODE_NORMAL);
        if (ret < 0) {
                dev_err(&data->client->dev,
                        "failed to write ctrl_meas register\n");
@@ -344,6 +519,317 @@ static int bmp280_chip_init(struct bmp280_data *data)
        return ret;
 }
+static const int bmp280_oversampling_avail[] = { 1, 2, 4, 8, 16 };
+static const struct bmp280_chip_info bmp280_chip_info = {
+        .regmap_config = &bmp280_regmap_config,
+        .oversampling_temp_avail = bmp280_oversampling_avail,
+        .num_oversampling_temp_avail = ARRAY_SIZE(bmp280_oversampling_avail),
+        .oversampling_press_avail = bmp280_oversampling_avail,
+        .num_oversampling_press_avail = ARRAY_SIZE(bmp280_oversampling_avail),
+        .chip_config = bmp280_chip_config,
+        .read_temp = bmp280_read_temp,
+        .read_press = bmp280_read_press,
+};
+static bool bmp180_is_writeable_reg(struct device *dev, unsigned int reg)
+{
+        switch (reg) {
+        case BMP280_REG_CTRL_MEAS:
+        case BMP280_REG_RESET:
+                return true;
+        default:
+                return false;
+        };
+}
+static bool bmp180_is_volatile_reg(struct device *dev, unsigned int reg)
+{
+        switch (reg) {
+        case BMP180_REG_OUT_XLSB:
+        case BMP180_REG_OUT_LSB:
+        case BMP180_REG_OUT_MSB:
+        case BMP280_REG_CTRL_MEAS:
+                return true;
+        default:
+                return false;
+        }
+}
+static const struct regmap_config bmp180_regmap_config = {
+        .reg_bits = 8,
+        .val_bits = 8,
+        .max_register = BMP180_REG_OUT_XLSB,
+        .cache_type = REGCACHE_RBTREE,
+        .writeable_reg = bmp180_is_writeable_reg,
+        .volatile_reg = bmp180_is_volatile_reg,
+};
+static int bmp180_measure(struct bmp280_data *data, u8 ctrl_meas)
+{
+        int ret;
+        const int conversion_time_max[] = { 4500, 7500, 13500, 25500 };
+        unsigned int delay_us;
+        unsigned int ctrl;
+        ret = regmap_write(data->regmap, BMP280_REG_CTRL_MEAS, ctrl_meas);
+        if (ret)
+                return ret;
+        if (ctrl_meas == BMP180_MEAS_TEMP)
+                delay_us = 4500;
+        else
+                delay_us = conversion_time_max[data->oversampling_press];
+        usleep_range(delay_us, delay_us + 1000);
+        ret = regmap_read(data->regmap, BMP280_REG_CTRL_MEAS, &ctrl);
+        if (ret)
+                return ret;
+        /* The value of this bit reset to "0" after conversion is complete */
+        if (ctrl & BMP180_MEAS_SCO)
+                return -EIO;
+        return 0;
+}
+static int bmp180_read_adc_temp(struct bmp280_data *data, int *val)
+{
+        int ret;
+        __be16 tmp = 0;
+        ret = bmp180_measure(data, BMP180_MEAS_TEMP);
+        if (ret)
+                return ret;
+        ret = regmap_bulk_read(data->regmap, BMP180_REG_OUT_MSB, (u8 *)&tmp, 2);
+        if (ret)
+                return ret;
+        *val = be16_to_cpu(tmp);
+        return 0;
+}
+/*
+ * These enums are used for indexing into the array of calibration
+ * coefficients for BMP180.
+ */
+enum { AC1, AC2, AC3, AC4, AC5, AC6, B1, B2, MB, MC, MD };
+struct bmp180_calib {
+        s16 AC1;
+        s16 AC2;
+        s16 AC3;
+        u16 AC4;
+        u16 AC5;
+        u16 AC6;
+        s16 B1;
+        s16 B2;
+        s16 MB;
+        s16 MC;
+        s16 MD;
+};
+static int bmp180_read_calib(struct bmp280_data *data,
+                             struct bmp180_calib *calib)
+{
+        int ret;
+        int i;
+        __be16 buf[BMP180_REG_CALIB_COUNT / 2];
+        ret = regmap_bulk_read(data->regmap, BMP180_REG_CALIB_START, buf,
+                               sizeof(buf));
+        if (ret < 0)
+                return ret;
+        /* None of the words has the value 0 or 0xFFFF */
+        for (i = 0; i < ARRAY_SIZE(buf); i++) {
+                if (buf[i] == cpu_to_be16(0) || buf[i] == cpu_to_be16(0xffff))
+                        return -EIO;
+        }
+        calib->AC1 = be16_to_cpu(buf[AC1]);
+        calib->AC2 = be16_to_cpu(buf[AC2]);
+        calib->AC3 = be16_to_cpu(buf[AC3]);
+        calib->AC4 = be16_to_cpu(buf[AC4]);
+        calib->AC5 = be16_to_cpu(buf[AC5]);
+        calib->AC6 = be16_to_cpu(buf[AC6]);
+        calib->B1 = be16_to_cpu(buf[B1]);
+        calib->B2 = be16_to_cpu(buf[B2]);
+        calib->MB = be16_to_cpu(buf[MB]);
+        calib->MC = be16_to_cpu(buf[MC]);
+        calib->MD = be16_to_cpu(buf[MD]);
+        return 0;
+}
+/*
+ * Returns temperature in DegC, resolution is 0.1 DegC.
+ * t_fine carries fine temperature as global value.
+ *
+ * Taken from datasheet, Section 3.5, "Calculating pressure and temperature".
+ */
+static s32 bmp180_compensate_temp(struct bmp280_data *data, s32 adc_temp)
+{
+        int ret;
+        s32 x1, x2;
+        struct bmp180_calib calib;
+        ret = bmp180_read_calib(data, &calib);
+        if (ret < 0) {
+                dev_err(&data->client->dev,
+                        "failed to read calibration coefficients\n");
+                return ret;
+        }
+        x1 = ((adc_temp - calib.AC6) * calib.AC5) >> 15;
+        x2 = (calib.MC << 11) / (x1 + calib.MD);
+        data->t_fine = x1 + x2;
+        return (data->t_fine + 8) >> 4;
+}
+static int bmp180_read_temp(struct bmp280_data *data, int *val)
+{
+        int ret;
+        s32 adc_temp, comp_temp;
+        ret = bmp180_read_adc_temp(data, &adc_temp);
+        if (ret)
+                return ret;
+        comp_temp = bmp180_compensate_temp(data, adc_temp);
+        /*
+         * val might be NULL if we're called by the read_press routine,
+         * who only cares about the carry over t_fine value.
+         */
+        if (val) {
+                *val = comp_temp * 100;
+                return IIO_VAL_INT;
+        }
+        return 0;
+}
+static int bmp180_read_adc_press(struct bmp280_data *data, int *val)
+{
+        int ret;
+        __be32 tmp = 0;
+        u8 oss = data->oversampling_press;
+        ret = bmp180_measure(data, BMP180_MEAS_PRESS_X(oss));
+        if (ret)
+                return ret;
+        ret = regmap_bulk_read(data->regmap, BMP180_REG_OUT_MSB, (u8 *)&tmp, 3);
+        if (ret)
+                return ret;
+        *val = (be32_to_cpu(tmp) >> 8) >> (8 - oss);
+        return 0;
+}
+/*
+ * Returns pressure in Pa, resolution is 1 Pa.
+ *
+ * Taken from datasheet, Section 3.5, "Calculating pressure and temperature".
+ */
+static u32 bmp180_compensate_press(struct bmp280_data *data, s32 adc_press)
+{
+        int ret;
+        s32 x1, x2, x3, p;
+        s32 b3, b6;
+        u32 b4, b7;
+        s32 oss = data->oversampling_press;
+        struct bmp180_calib calib;
+        ret = bmp180_read_calib(data, &calib);
+        if (ret < 0) {
+                dev_err(&data->client->dev,
+                        "failed to read calibration coefficients\n");
+                return ret;
+        }
+        b6 = data->t_fine - 4000;
+        x1 = (calib.B2 * (b6 * b6 >> 12)) >> 11;
+        x2 = calib.AC2 * b6 >> 11;
+        x3 = x1 + x2;
+        b3 = ((((s32)calib.AC1 * 4 + x3) << oss) + 2) / 4;
+        x1 = calib.AC3 * b6 >> 13;
+        x2 = (calib.B1 * ((b6 * b6) >> 12)) >> 16;
+        x3 = (x1 + x2 + 2) >> 2;
+        b4 = calib.AC4 * (u32)(x3 + 32768) >> 15;
+        b7 = ((u32)adc_press - b3) * (50000 >> oss);
+        if (b7 < 0x80000000)
+                p = (b7 * 2) / b4;
+        else
+                p = (b7 / b4) * 2;
+        x1 = (p >> 8) * (p >> 8);
+        x1 = (x1 * 3038) >> 16;
+        x2 = (-7357 * p) >> 16;
+        return p + ((x1 + x2 + 3791) >> 4);
+}
+static int bmp180_read_press(struct bmp280_data *data,
+                             int *val, int *val2)
+{
+        int ret;
+        s32 adc_press;
+        u32 comp_press;
+        /* Read and compensate temperature so we get a reading of t_fine. */
+        ret = bmp180_read_temp(data, NULL);
+        if (ret)
+                return ret;
+        ret = bmp180_read_adc_press(data, &adc_press);
+        if (ret)
+                return ret;
+        comp_press = bmp180_compensate_press(data, adc_press);
+        *val = comp_press;
+        *val2 = 1000;
+        return IIO_VAL_FRACTIONAL;
+}
+static int bmp180_chip_config(struct bmp280_data *data)
+{
+        return 0;
+}
+static const int bmp180_oversampling_temp_avail[] = { 1 };
+static const int bmp180_oversampling_press_avail[] = { 1, 2, 4, 8 };
+static const struct bmp280_chip_info bmp180_chip_info = {
+        .regmap_config = &bmp180_regmap_config,
+        .oversampling_temp_avail = bmp180_oversampling_temp_avail,
+        .num_oversampling_temp_avail =
+                ARRAY_SIZE(bmp180_oversampling_temp_avail),
+        .oversampling_press_avail = bmp180_oversampling_press_avail,
+        .num_oversampling_press_avail =
+                ARRAY_SIZE(bmp180_oversampling_press_avail),
+        .chip_config = bmp180_chip_config,
+        .read_temp = bmp180_read_temp,
+        .read_press = bmp180_read_press,
+};
 static int bmp280_probe(struct i2c_client *client,
                        const struct i2c_device_id *id)
 {
@@ -367,7 +853,23 @@ static int bmp280_probe(struct i2c_client *client,
        indio_dev->info = &bmp280_info;
        indio_dev->modes = INDIO_DIRECT_MODE;
-        data->regmap = devm_regmap_init_i2c(client, &bmp280_regmap_config);
+        switch (id->driver_data) {
+        case BMP180_CHIP_ID:
+                data->chip_info = &bmp180_chip_info;
+                data->oversampling_press = ilog2(8);
+                data->oversampling_temp = ilog2(1);
+                break;
+        case BMP280_CHIP_ID:
+                data->chip_info = &bmp280_chip_info;
+                data->oversampling_press = ilog2(16);
+                data->oversampling_temp = ilog2(2);
+                break;
+        default:
+                return -EINVAL;
+        }
+        data->regmap = devm_regmap_init_i2c(client,
+                                        data->chip_info->regmap_config);
        if (IS_ERR(data->regmap)) {
                dev_err(&client->dev, "failed to allocate register map\n");
                return PTR_ERR(data->regmap);
@@ -376,13 +878,13 @@ static int bmp280_probe(struct i2c_client *client,
        ret = regmap_read(data->regmap, BMP280_REG_ID, &chip_id);
        if (ret < 0)
                return ret;
-        if (chip_id != BMP280_CHIP_ID) {
+        if (chip_id != id->driver_data) {
                dev_err(&client->dev, "bad chip id.  expected %x got %x\n",
                        BMP280_CHIP_ID, chip_id);
                return -EINVAL;
        }
-        ret = bmp280_chip_init(data);
+        ret = data->chip_info->chip_config(data);
        if (ret < 0)
                return ret;
@@ -390,13 +892,17 @@ static int bmp280_probe(struct i2c_client *client,
 }
 static const struct acpi_device_id bmp280_acpi_match[] = {
-        {"BMP0280", 0},
+        {"BMP0280", BMP280_CHIP_ID },
+        {"BMP0180", BMP180_CHIP_ID },
+        {"BMP0085", BMP180_CHIP_ID },
        { },
 };
 MODULE_DEVICE_TABLE(acpi, bmp280_acpi_match);
 static const struct i2c_device_id bmp280_id[] = {
-        {"bmp280", 0},
+        {"bmp280", BMP280_CHIP_ID },
+        {"bmp180", BMP180_CHIP_ID },
+        {"bmp085", BMP180_CHIP_ID },
        { },
 };
 MODULE_DEVICE_TABLE(i2c, bmp280_id);
@@ -412,5 +918,5 @@ static struct i2c_driver bmp280_driver = {
 module_i2c_driver(bmp280_driver);
 MODULE_AUTHOR("Vlad Dogaru <vlad.dogaru@intel.com>");
-MODULE_DESCRIPTION("Driver for Bosch Sensortec BMP280 pressure and temperature sensor");
+MODULE_DESCRIPTION("Driver for Bosch Sensortec BMP180/BMP280 pressure and temperature sensor");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/pressure/hp03.c b/drivers/iio/pressure/hp03.c
new file mode 100644
index 000000000000..ac76515d5d49
--- /dev/null
+++ b/drivers/iio/pressure/hp03.c
@@ -0,0 +1,312 @@
+/*
+ * Copyright (c) 2016 Marek Vasut <marex@denx.de>
+ *
+ * Driver for Hope RF HP03 digital temperature and pressure sensor.
+ *
+ * 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.
+ */
+#define pr_fmt(fmt) "hp03: " fmt
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/gpio/consumer.h>
+#include <linux/i2c.h>
+#include <linux/regmap.h>
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+/*
+ * The HP03 sensor occupies two fixed I2C addresses:
+ *  0x50 ... read-only EEPROM with calibration data
+ *  0x77 ... read-write ADC for pressure and temperature
+ */
+#define HP03_EEPROM_ADDR                0x50
+#define HP03_ADC_ADDR                   0x77
+#define HP03_EEPROM_CX_OFFSET           0x10
+#define HP03_EEPROM_AB_OFFSET           0x1e
+#define HP03_EEPROM_CD_OFFSET           0x20
+#define HP03_ADC_WRITE_REG              0xff
+#define HP03_ADC_READ_REG               0xfd
+#define HP03_ADC_READ_PRESSURE          0xf0    /* D1 in datasheet */
+#define HP03_ADC_READ_TEMP              0xe8    /* D2 in datasheet */
+struct hp03_priv {
+        struct i2c_client       *client;
+        struct mutex            lock;
+        struct gpio_desc        *xclr_gpio;
+        struct i2c_client       *eeprom_client;
+        struct regmap           *eeprom_regmap;
+        s32                     pressure;       /* kPa */
+        s32                     temp;           /* Deg. C */
+};
+static const struct iio_chan_spec hp03_channels[] = {
+        {
+                .type = IIO_PRESSURE,
+                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
+                .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
+        },
+        {
+                .type = IIO_TEMP,
+                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
+                .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
+        },
+};
+static bool hp03_is_writeable_reg(struct device *dev, unsigned int reg)
+{
+        return false;
+}
+static bool hp03_is_volatile_reg(struct device *dev, unsigned int reg)
+{
+        return false;
+}
+static const struct regmap_config hp03_regmap_config = {
+        .reg_bits       = 8,
+        .val_bits       = 8,
+        .max_register   = HP03_EEPROM_CD_OFFSET + 1,
+        .cache_type     = REGCACHE_RBTREE,
+        .writeable_reg  = hp03_is_writeable_reg,
+        .volatile_reg   = hp03_is_volatile_reg,
+};
+static int hp03_get_temp_pressure(struct hp03_priv *priv, const u8 reg)
+{
+        int ret;
+        ret = i2c_smbus_write_byte_data(priv->client, HP03_ADC_WRITE_REG, reg);
+        if (ret < 0)
+                return ret;
+        msleep(50);     /* Wait for conversion to finish */
+        return i2c_smbus_read_word_data(priv->client, HP03_ADC_READ_REG);
+}
+static int hp03_update_temp_pressure(struct hp03_priv *priv)
+{
+        struct device *dev = &priv->client->dev;
+        u8 coefs[18];
+        u16 cx_val[7];
+        int ab_val, d1_val, d2_val, diff_val, dut, off, sens, x;
+        int i, ret;
+        /* Sample coefficients from EEPROM */
+        ret = regmap_bulk_read(priv->eeprom_regmap, HP03_EEPROM_CX_OFFSET,
+                               coefs, sizeof(coefs));
+        if (ret < 0) {
+                dev_err(dev, "Failed to read EEPROM (reg=%02x)\n",
+                        HP03_EEPROM_CX_OFFSET);
+                return ret;
+        }
+        /* Sample Temperature and Pressure */
+        gpiod_set_value_cansleep(priv->xclr_gpio, 1);
+        ret = hp03_get_temp_pressure(priv, HP03_ADC_READ_PRESSURE);
+        if (ret < 0) {
+                dev_err(dev, "Failed to read pressure\n");
+                goto err_adc;
+        }
+        d1_val = ret;
+        ret = hp03_get_temp_pressure(priv, HP03_ADC_READ_TEMP);
+        if (ret < 0) {
+                dev_err(dev, "Failed to read temperature\n");
+                goto err_adc;
+        }
+        d2_val = ret;
+        gpiod_set_value_cansleep(priv->xclr_gpio, 0);
+        /* The Cx coefficients and Temp/Pressure values are MSB first. */
+        for (i = 0; i < 7; i++)
+                cx_val[i] = (coefs[2 * i] << 8) | (coefs[(2 * i) + 1] << 0);
+        d1_val = ((d1_val >> 8) & 0xff) | ((d1_val & 0xff) << 8);
+        d2_val = ((d2_val >> 8) & 0xff) | ((d2_val & 0xff) << 8);
+        /* Coefficient voodoo from the HP03 datasheet. */
+        if (d2_val >= cx_val[4])
+                ab_val = coefs[14];     /* A-value */
+        else
+                ab_val = coefs[15];     /* B-value */
+        diff_val = d2_val - cx_val[4];
+        dut = (ab_val * (diff_val >> 7) * (diff_val >> 7)) >> coefs[16];
+        dut = diff_val - dut;
+        off = (cx_val[1] + (((cx_val[3] - 1024) * dut) >> 14)) * 4;
+        sens = cx_val[0] + ((cx_val[2] * dut) >> 10);
+        x = ((sens * (d1_val - 7168)) >> 14) - off;
+        priv->pressure = ((x * 100) >> 5) + (cx_val[6] * 10);
+        priv->temp = 250 + ((dut * cx_val[5]) >> 16) - (dut >> coefs[17]);
+        return 0;
+err_adc:
+        gpiod_set_value_cansleep(priv->xclr_gpio, 0);
+        return ret;
+}
+static int hp03_read_raw(struct iio_dev *indio_dev,
+                         struct iio_chan_spec const *chan,
+                         int *val, int *val2, long mask)
+{
+        struct hp03_priv *priv = iio_priv(indio_dev);
+        int ret;
+        mutex_lock(&priv->lock);
+        ret = hp03_update_temp_pressure(priv);
+        mutex_unlock(&priv->lock);
+        if (ret)
+                return ret;
+        switch (mask) {
+        case IIO_CHAN_INFO_RAW:
+                switch (chan->type) {
+                case IIO_PRESSURE:
+                        *val = priv->pressure;
+                        return IIO_VAL_INT;
+                case IIO_TEMP:
+                        *val = priv->temp;
+                        return IIO_VAL_INT;
+                default:
+                        return -EINVAL;
+                }
+                break;
+        case IIO_CHAN_INFO_SCALE:
+                switch (chan->type) {
+                case IIO_PRESSURE:
+                        *val = 0;
+                        *val2 = 1000;
+                        return IIO_VAL_INT_PLUS_MICRO;
+                case IIO_TEMP:
+                        *val = 10;
+                        return IIO_VAL_INT;
+                default:
+                        return -EINVAL;
+                }
+                break;
+        default:
+                return -EINVAL;
+        }
+        return -EINVAL;
+}
+static const struct iio_info hp03_info = {
+        .driver_module  = THIS_MODULE,
+        .read_raw       = &hp03_read_raw,
+};
+static int hp03_probe(struct i2c_client *client,
+                      const struct i2c_device_id *id)
+{
+        struct device *dev = &client->dev;
+        struct iio_dev *indio_dev;
+        struct hp03_priv *priv;
+        int ret;
+        indio_dev = devm_iio_device_alloc(dev, sizeof(*priv));
+        if (!indio_dev)
+                return -ENOMEM;
+        priv = iio_priv(indio_dev);
+        priv->client = client;
+        mutex_init(&priv->lock);
+        indio_dev->dev.parent = dev;
+        indio_dev->name = id->name;
+        indio_dev->channels = hp03_channels;
+        indio_dev->num_channels = ARRAY_SIZE(hp03_channels);
+        indio_dev->info = &hp03_info;
+        indio_dev->modes = INDIO_DIRECT_MODE;
+        priv->xclr_gpio = devm_gpiod_get_index(dev, "xclr", 0, GPIOD_OUT_HIGH);
+        if (IS_ERR(priv->xclr_gpio)) {
+                dev_err(dev, "Failed to claim XCLR GPIO\n");
+                ret = PTR_ERR(priv->xclr_gpio);
+                return ret;
+        }
+        /*
+         * Allocate another device for the on-sensor EEPROM,
+         * which has it's dedicated I2C address and contains
+         * the calibration constants for the sensor.
+         */
+        priv->eeprom_client = i2c_new_dummy(client->adapter, HP03_EEPROM_ADDR);
+        if (!priv->eeprom_client) {
+                dev_err(dev, "New EEPROM I2C device failed\n");
+                return -ENODEV;
+        }
+        priv->eeprom_regmap = regmap_init_i2c(priv->eeprom_client,
+                                              &hp03_regmap_config);
+        if (IS_ERR(priv->eeprom_regmap)) {
+                dev_err(dev, "Failed to allocate EEPROM regmap\n");
+                ret = PTR_ERR(priv->eeprom_regmap);
+                goto err_cleanup_eeprom_client;
+        }
+        ret = iio_device_register(indio_dev);
+        if (ret) {
+                dev_err(dev, "Failed to register IIO device\n");
+                goto err_cleanup_eeprom_regmap;
+        }
+        i2c_set_clientdata(client, indio_dev);
+        return 0;
+err_cleanup_eeprom_regmap:
+        regmap_exit(priv->eeprom_regmap);
+err_cleanup_eeprom_client:
+        i2c_unregister_device(priv->eeprom_client);
+        return ret;
+}
+static int hp03_remove(struct i2c_client *client)
+{
+        struct iio_dev *indio_dev = i2c_get_clientdata(client);
+        struct hp03_priv *priv = iio_priv(indio_dev);
+        iio_device_unregister(indio_dev);
+        regmap_exit(priv->eeprom_regmap);
+        i2c_unregister_device(priv->eeprom_client);
+        return 0;
+}
+static const struct i2c_device_id hp03_id[] = {
+        { "hp03", 0 },
+        { },
+};
+MODULE_DEVICE_TABLE(i2c, hp03_id);
+static struct i2c_driver hp03_driver = {
+        .driver = {
+                .name   = "hp03",
+        },
+        .probe          = hp03_probe,
+        .remove         = hp03_remove,
+        .id_table       = hp03_id,
+};
+module_i2c_driver(hp03_driver);
+MODULE_AUTHOR("Marek Vasut <marex@denx.de>");
+MODULE_DESCRIPTION("Driver for Hope RF HP03 pressure and temperature sensor");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/pressure/ms5611_core.c b/drivers/iio/pressure/ms5611_core.c
index c4e65868bc28..76578b07bb6e 100644
--- a/drivers/iio/pressure/ms5611_core.c
+++ b/drivers/iio/pressure/ms5611_core.c
@@ -429,7 +429,7 @@ static void ms5611_fini(const struct iio_dev *indio_dev)
 }
 int ms5611_probe(struct iio_dev *indio_dev, struct device *dev,
-                 const char *name, int type)
+                 const char *name, int type)
 {
        int ret;
        struct ms5611_state *st = iio_priv(indio_dev);
diff --git a/drivers/iio/pressure/ms5611_spi.c b/drivers/iio/pressure/ms5611_spi.c
index 7600483e8cb4..932e05001e1a 100644
--- a/drivers/iio/pressure/ms5611_spi.c
+++ b/drivers/iio/pressure/ms5611_spi.c
@@ -108,7 +108,7 @@ static int ms5611_spi_probe(struct spi_device *spi)
        st->client = spi;
        return ms5611_probe(indio_dev, &spi->dev, spi_get_device_id(spi)->name,
-                            spi_get_device_id(spi)->driver_data);
+                            spi_get_device_id(spi)->driver_data);
 }
 static int ms5611_spi_remove(struct spi_device *spi)
diff --git a/drivers/iio/pressure/st_pressure_core.c b/drivers/iio/pressure/st_pressure_core.c
index 172393ad34af..9e9b72a8f18f 100644
--- a/drivers/iio/pressure/st_pressure_core.c
+++ b/drivers/iio/pressure/st_pressure_core.c
@@ -64,6 +64,8 @@
 #define ST_PRESS_LPS331AP_DRDY_IRQ_INT2_MASK    0x20
 #define ST_PRESS_LPS331AP_IHL_IRQ_ADDR          0x22
 #define ST_PRESS_LPS331AP_IHL_IRQ_MASK          0x80
+#define ST_PRESS_LPS331AP_OD_IRQ_ADDR           0x22
+#define ST_PRESS_LPS331AP_OD_IRQ_MASK           0x40
 #define ST_PRESS_LPS331AP_MULTIREAD_BIT         true
 #define ST_PRESS_LPS331AP_TEMP_OFFSET           42500
@@ -104,6 +106,8 @@
 #define ST_PRESS_LPS25H_DRDY_IRQ_INT2_MASK      0x10
 #define ST_PRESS_LPS25H_IHL_IRQ_ADDR            0x22
 #define ST_PRESS_LPS25H_IHL_IRQ_MASK            0x80
+#define ST_PRESS_LPS25H_OD_IRQ_ADDR             0x22
+#define ST_PRESS_LPS25H_OD_IRQ_MASK             0x40
 #define ST_PRESS_LPS25H_MULTIREAD_BIT           true
 #define ST_PRESS_LPS25H_TEMP_OFFSET             42500
 #define ST_PRESS_LPS25H_OUT_XL_ADDR             0x28
@@ -226,6 +230,9 @@ static const struct st_sensor_settings st_press_sensors_settings[] = {
                        .mask_int2 = ST_PRESS_LPS331AP_DRDY_IRQ_INT2_MASK,
                        .addr_ihl = ST_PRESS_LPS331AP_IHL_IRQ_ADDR,
                        .mask_ihl = ST_PRESS_LPS331AP_IHL_IRQ_MASK,
+                        .addr_od = ST_PRESS_LPS331AP_OD_IRQ_ADDR,
+                        .mask_od = ST_PRESS_LPS331AP_OD_IRQ_MASK,
+                        .addr_stat_drdy = ST_SENSORS_DEFAULT_STAT_ADDR,
                },
                .multi_read_bit = ST_PRESS_LPS331AP_MULTIREAD_BIT,
                .bootime = 2,
@@ -312,6 +319,9 @@ static const struct st_sensor_settings st_press_sensors_settings[] = {
                        .mask_int2 = ST_PRESS_LPS25H_DRDY_IRQ_INT2_MASK,
                        .addr_ihl = ST_PRESS_LPS25H_IHL_IRQ_ADDR,
                        .mask_ihl = ST_PRESS_LPS25H_IHL_IRQ_MASK,
+                        .addr_od = ST_PRESS_LPS25H_OD_IRQ_ADDR,
+                        .mask_od = ST_PRESS_LPS25H_OD_IRQ_MASK,
+                        .addr_stat_drdy = ST_SENSORS_DEFAULT_STAT_ADDR,
                },
                .multi_read_bit = ST_PRESS_LPS25H_MULTIREAD_BIT,
                .bootime = 2,
diff --git a/drivers/staging/iio/accel/adis16201_core.c b/drivers/staging/iio/accel/adis16201_core.c
index 06c0b75ed26a..6f3f8ff2a066 100644
--- a/drivers/staging/iio/accel/adis16201_core.c
+++ b/drivers/staging/iio/accel/adis16201_core.c
@@ -167,6 +167,7 @@ static const struct adis_data adis16201_data = {
        .diag_stat_reg = ADIS16201_DIAG_STAT,
        .self_test_mask = ADIS16201_MSC_CTRL_SELF_TEST_EN,
+        .self_test_no_autoclear = true,
        .startup_delay = ADIS16201_STARTUP_DELAY,
        .status_error_msgs = adis16201_status_error_msgs,
diff --git a/drivers/staging/iio/accel/adis16203_core.c b/drivers/staging/iio/accel/adis16203_core.c
index de5b84ac842b..c70671778bae 100644
--- a/drivers/staging/iio/accel/adis16203_core.c
+++ b/drivers/staging/iio/accel/adis16203_core.c
@@ -134,6 +134,7 @@ static const struct adis_data adis16203_data = {
        .diag_stat_reg = ADIS16203_DIAG_STAT,
        .self_test_mask = ADIS16203_MSC_CTRL_SELF_TEST_EN,
+        .self_test_no_autoclear = true,
        .startup_delay = ADIS16203_STARTUP_DELAY,
        .status_error_msgs = adis16203_status_error_msgs,
diff --git a/drivers/staging/iio/accel/adis16209_core.c b/drivers/staging/iio/accel/adis16209_core.c
index 8b42bf8c3f60..8dbad58628a1 100644
--- a/drivers/staging/iio/accel/adis16209_core.c
+++ b/drivers/staging/iio/accel/adis16209_core.c
@@ -168,6 +168,7 @@ static const struct adis_data adis16209_data = {
        .diag_stat_reg = ADIS16209_DIAG_STAT,
        .self_test_mask = ADIS16209_MSC_CTRL_SELF_TEST_EN,
+        .self_test_no_autoclear = true,
        .startup_delay = ADIS16209_STARTUP_DELAY,
        .status_error_msgs = adis16209_status_error_msgs,
diff --git a/drivers/staging/iio/accel/adis16240_core.c b/drivers/staging/iio/accel/adis16240_core.c
index a425e1894863..d5b99e610d08 100644
--- a/drivers/staging/iio/accel/adis16240_core.c
+++ b/drivers/staging/iio/accel/adis16240_core.c
@@ -222,6 +222,7 @@ static const struct adis_data adis16240_data = {
        .diag_stat_reg = ADIS16240_DIAG_STAT,
        .self_test_mask = ADIS16240_MSC_CTRL_SELF_TEST_EN,
+        .self_test_no_autoclear = true,
        .startup_delay = ADIS16240_STARTUP_DELAY,
        .status_error_msgs = adis16240_status_error_msgs,
diff --git a/drivers/staging/iio/adc/ad7606_core.c b/drivers/staging/iio/adc/ad7606_core.c
index 6dbc811730ae..f79ee61851f6 100644
--- a/drivers/staging/iio/adc/ad7606_core.c
+++ b/drivers/staging/iio/adc/ad7606_core.c
@@ -88,12 +88,12 @@ static int ad7606_read_raw(struct iio_dev *indio_dev,
        switch (m) {
        case IIO_CHAN_INFO_RAW:
-                mutex_lock(&indio_dev->mlock);
+                ret = iio_device_claim_direct_mode(indio_dev);
-                if (iio_buffer_enabled(indio_dev))
+                if (ret)
-                        ret = -EBUSY;
+                        return ret;
-                else
-                        ret = ad7606_scan_direct(indio_dev, chan->address);
+                ret = ad7606_scan_direct(indio_dev, chan->address);
-                mutex_unlock(&indio_dev->mlock);
+                iio_device_release_direct_mode(indio_dev);
                if (ret < 0)
                        return ret;
diff --git a/include/dt-bindings/iio/adi,ad5592r.h b/include/dt-bindings/iio/adi,ad5592r.h
new file mode 100644
index 000000000000..c48aca1dcade
--- /dev/null
+++ b/include/dt-bindings/iio/adi,ad5592r.h
@@ -0,0 +1,16 @@
+#ifndef _DT_BINDINGS_ADI_AD5592R_H
+#define _DT_BINDINGS_ADI_AD5592R_H
+#define CH_MODE_UNUSED                  0
+#define CH_MODE_ADC                     1
+#define CH_MODE_DAC                     2
+#define CH_MODE_DAC_AND_ADC             3
+#define CH_MODE_GPIO                    8
+#define CH_OFFSTATE_PULLDOWN            0
+#define CH_OFFSTATE_OUT_LOW             1
+#define CH_OFFSTATE_OUT_HIGH            2
+#define CH_OFFSTATE_OUT_TRISTATE        3
+#endif /* _DT_BINDINGS_ADI_AD5592R_H */
diff --git a/include/linux/iio/common/st_sensors.h b/include/linux/iio/common/st_sensors.h
index 6670c3d25c58..d029ffac0d69 100644
--- a/include/linux/iio/common/st_sensors.h
+++ b/include/linux/iio/common/st_sensors.h
@@ -37,6 +37,7 @@
 #define ST_SENSORS_DEFAULT_AXIS_ADDR            0x20
 #define ST_SENSORS_DEFAULT_AXIS_MASK            0x07
 #define ST_SENSORS_DEFAULT_AXIS_N_BIT           3
+#define ST_SENSORS_DEFAULT_STAT_ADDR            0x27
 #define ST_SENSORS_MAX_NAME                     17
 #define ST_SENSORS_MAX_4WAI                     7
@@ -121,6 +122,9 @@ struct st_sensor_bdu {
 * @mask_int2: mask to enable/disable IRQ on INT2 pin.
 * @addr_ihl: address to enable/disable active low on the INT lines.
 * @mask_ihl: mask to enable/disable active low on the INT lines.
+ * @addr_od: address to enable/disable Open Drain on the INT lines.
+ * @mask_od: mask to enable/disable Open Drain on the INT lines.
+ * @addr_stat_drdy: address to read status of DRDY (data ready) interrupt
 * struct ig1 - represents the Interrupt Generator 1 of sensors.
 * @en_addr: address of the enable ig1 register.
 * @en_mask: mask to write the on/off value for enable.
@@ -131,6 +135,9 @@ struct st_sensor_data_ready_irq {
        u8 mask_int2;
        u8 addr_ihl;
        u8 mask_ihl;
+        u8 addr_od;
+        u8 mask_od;
+        u8 addr_stat_drdy;
        struct {
                u8 en_addr;
                u8 en_mask;
@@ -212,6 +219,7 @@ struct st_sensor_settings {
 * @odr: Output data rate of the sensor [Hz].
 * num_data_channels: Number of data channels used in buffer.
 * @drdy_int_pin: Redirect DRDY on pin 1 (1) or pin 2 (2).
+ * @int_pin_open_drain: Set the interrupt/DRDY to open drain.
 * @get_irq_data_ready: Function to get the IRQ used for data ready signal.
 * @tf: Transfer function structure used by I/O operations.
 * @tb: Transfer buffers and mutex used by I/O operations.
@@ -233,6 +241,7 @@ struct st_sensor_data {
        unsigned int num_data_channels;
        u8 drdy_int_pin;
+        bool int_pin_open_drain;
        unsigned int (*get_irq_data_ready) (struct iio_dev *indio_dev);
diff --git a/include/linux/iio/consumer.h b/include/linux/iio/consumer.h
index fad58671c49e..3d672f72e7ec 100644
--- a/include/linux/iio/consumer.h
+++ b/include/linux/iio/consumer.h
@@ -49,6 +49,33 @@ struct iio_channel *iio_channel_get(struct device *dev,
 void iio_channel_release(struct iio_channel *chan);
 /**
+ * devm_iio_channel_get() - Resource managed version of iio_channel_get().
+ * @dev:                Pointer to consumer device. Device name must match
+ *                      the name of the device as provided in the iio_map
+ *                      with which the desired provider to consumer mapping
+ *                      was registered.
+ * @consumer_channel:   Unique name to identify the channel on the consumer
+ *                      side. This typically describes the channels use within
+ *                      the consumer. E.g. 'battery_voltage'
+ *
+ * Returns a pointer to negative errno if it is not able to get the iio channel
+ * otherwise returns valid pointer for iio channel.
+ *
+ * The allocated iio channel is automatically released when the device is
+ * unbound.
+ */
+struct iio_channel *devm_iio_channel_get(struct device *dev,
+                                         const char *consumer_channel);
+/**
+ * devm_iio_channel_release() - Resource managed version of
+ *                              iio_channel_release().
+ * @dev:                Pointer to consumer device for which resource
+ *                      is allocared.
+ * @chan:               The channel to be released.
+ */
+void devm_iio_channel_release(struct device *dev, struct iio_channel *chan);
+/**
 * iio_channel_get_all() - get all channels associated with a client
 * @dev:                Pointer to consumer device.
 *
@@ -65,6 +92,32 @@ struct iio_channel *iio_channel_get_all(struct device *dev);
 */
 void iio_channel_release_all(struct iio_channel *chan);
+/**
+ * devm_iio_channel_get_all() - Resource managed version of
+ *                              iio_channel_get_all().
+ * @dev: Pointer to consumer device.
+ *
+ * Returns a pointer to negative errno if it is not able to get the iio channel
+ * otherwise returns an array of iio_channel structures terminated with one with
+ * null iio_dev pointer.
+ *
+ * This function is used by fairly generic consumers to get all the
+ * channels registered as having this consumer.
+ *
+ * The allocated iio channels are automatically released when the device is
+ * unbounded.
+ */
+struct iio_channel *devm_iio_channel_get_all(struct device *dev);
+/**
+ * devm_iio_channel_release_all() - Resource managed version of
+ *                                  iio_channel_release_all().
+ * @dev:                Pointer to consumer device for which resource
+ *                      is allocared.
+ * @chan:               Array channel to be released.
+ */
+void devm_iio_channel_release_all(struct device *dev, struct iio_channel *chan);
 struct iio_cb_buffer;
 /**
 * iio_channel_get_all_cb() - register callback for triggered capture
diff --git a/include/linux/iio/iio.h b/include/linux/iio/iio.h
index 0b2773ada0ba..7c29cb0124ae 100644
--- a/include/linux/iio/iio.h
+++ b/include/linux/iio/iio.h
@@ -148,6 +148,37 @@ ssize_t iio_enum_write(struct iio_dev *indio_dev,
 }
 /**
+ * struct iio_mount_matrix - iio mounting matrix
+ * @rotation: 3 dimensional space rotation matrix defining sensor alignment with
+ *            main hardware
+ */
+struct iio_mount_matrix {
+        const char *rotation[9];
+};
+ssize_t iio_show_mount_matrix(struct iio_dev *indio_dev, uintptr_t priv,
+                              const struct iio_chan_spec *chan, char *buf);
+int of_iio_read_mount_matrix(const struct device *dev, const char *propname,
+                             struct iio_mount_matrix *matrix);
+typedef const struct iio_mount_matrix *
+        (iio_get_mount_matrix_t)(const struct iio_dev *indio_dev,
+                                 const struct iio_chan_spec *chan);
+/**
+ * IIO_MOUNT_MATRIX() - Initialize mount matrix extended channel attribute
+ * @_shared:    Whether the attribute is shared between all channels
+ * @_get:       Pointer to an iio_get_mount_matrix_t accessor
+ */
+#define IIO_MOUNT_MATRIX(_shared, _get) \
+{ \
+        .name = "mount_matrix", \
+        .shared = (_shared), \
+        .read = iio_show_mount_matrix, \
+        .private = (uintptr_t)(_get), \
+}
+/**
 * struct iio_event_spec - specification for a channel event
 * @type:                   Type of the event
 * @dir:                    Direction of the event
diff --git a/include/linux/iio/imu/adis.h b/include/linux/iio/imu/adis.h
index fa2d01ef8f55..360da7d18a3d 100644
--- a/include/linux/iio/imu/adis.h
+++ b/include/linux/iio/imu/adis.h
@@ -41,6 +41,7 @@ struct adis_data {
        unsigned int diag_stat_reg;
        unsigned int self_test_mask;
+        bool self_test_no_autoclear;
        unsigned int startup_delay;
        const char * const *status_error_msgs;
diff --git a/include/linux/iio/magnetometer/ak8975.h b/include/linux/iio/magnetometer/ak8975.h
new file mode 100644
index 000000000000..c8400959d197
--- /dev/null
+++ b/include/linux/iio/magnetometer/ak8975.h
@@ -0,0 +1,16 @@
+#ifndef __IIO_MAGNETOMETER_AK8975_H__
+#define __IIO_MAGNETOMETER_AK8975_H__
+#include <linux/iio/iio.h>
+/**
+ * struct ak8975_platform_data - AK8975 magnetometer driver platform data
+ * @eoc_gpio:    data ready event gpio
+ * @orientation: mounting matrix relative to main hardware
+ */
+struct ak8975_platform_data {
+        int                     eoc_gpio;
+        struct iio_mount_matrix orientation;
+};
+#endif
diff --git a/include/linux/platform_data/invensense_mpu6050.h b/include/linux/platform_data/invensense_mpu6050.h
index ad3aa7b95f35..554b59801aa8 100644
--- a/include/linux/platform_data/invensense_mpu6050.h
+++ b/include/linux/platform_data/invensense_mpu6050.h
@@ -16,13 +16,16 @@
 /**
 * struct inv_mpu6050_platform_data - Platform data for the mpu driver
- * @orientation:        Orientation matrix of the chip
+ * @orientation:        Orientation matrix of the chip (deprecated in favor of
+ *                      mounting matrix retrieved from device-tree)
 *
 * Contains platform specific information on how to configure the MPU6050 to
 * work on this platform.  The orientation matricies are 3x3 rotation matricies
 * that are applied to the data to rotate from the mounting orientation to the
 * platform orientation.  The values must be one of 0, 1, or -1 and each row and
 * column should have exactly 1 non-zero value.
+ *
+ * Deprecated in favor of mounting matrix retrieved from device-tree.
 */
 struct inv_mpu6050_platform_data {
        __s8 orientation[9];
diff --git a/include/linux/platform_data/st_sensors_pdata.h b/include/linux/platform_data/st_sensors_pdata.h
index 753839187ba0..79b0e4cdb814 100644
--- a/include/linux/platform_data/st_sensors_pdata.h
+++ b/include/linux/platform_data/st_sensors_pdata.h
@@ -16,9 +16,11 @@
 * @drdy_int_pin: Redirect DRDY on pin 1 (1) or pin 2 (2).
 *      Available only for accelerometer and pressure sensors.
 *      Accelerometer DRDY on LSM330 available only on pin 1 (see datasheet).
+ * @open_drain: set the interrupt line to be open drain if possible.
 */
 struct st_sensors_platform_data {
        u8 drdy_int_pin;
+        bool open_drain;
 };
 #endif /* ST_SENSORS_PDATA_H */
diff --git a/tools/iio/generic_buffer.c b/tools/iio/generic_buffer.c
index c42b7f836b48..2429c78de940 100644
--- a/tools/iio/generic_buffer.c
+++ b/tools/iio/generic_buffer.c
@@ -35,6 +35,15 @@
 #include "iio_utils.h"
 /**
+ * enum autochan - state for the automatic channel enabling mechanism
+ */
+enum autochan {
+        AUTOCHANNELS_DISABLED,
+        AUTOCHANNELS_ENABLED,
+        AUTOCHANNELS_ACTIVE,
+};
+/**
 * size_from_channelarray() - calculate the storage size of a scan
 * @channels:           the channel info array
 * @num_channels:       number of channels
@@ -191,10 +200,51 @@ void process_scan(char *data,
        printf("\n");
 }
+static int enable_disable_all_channels(char *dev_dir_name, int enable)
+{
+        const struct dirent *ent;
+        char scanelemdir[256];
+        DIR *dp;
+        int ret;
+        snprintf(scanelemdir, sizeof(scanelemdir),
+                 FORMAT_SCAN_ELEMENTS_DIR, dev_dir_name);
+        scanelemdir[sizeof(scanelemdir)-1] = '\0';
+        dp = opendir(scanelemdir);
+        if (!dp) {
+                fprintf(stderr, "Enabling/disabling channels: can't open %s\n",
+                        scanelemdir);
+                return -EIO;
+        }
+        ret = -ENOENT;
+        while (ent = readdir(dp), ent) {
+                if (iioutils_check_suffix(ent->d_name, "_en")) {
+                        printf("%sabling: %s\n",
+                               enable ? "En" : "Dis",
+                               ent->d_name);
+                        ret = write_sysfs_int(ent->d_name, scanelemdir,
+                                              enable);
+                        if (ret < 0)
+                                fprintf(stderr, "Failed to enable/disable %s\n",
+                                        ent->d_name);
+                }
+        }
+        if (closedir(dp) == -1) {
+                perror("Enabling/disabling channels: "
+                       "Failed to close directory");
+                return -errno;
+        }
+        return 0;
+}
 void print_usage(void)
 {
        fprintf(stderr, "Usage: generic_buffer [options]...\n"
                "Capture, convert and output data from IIO device buffer\n"
+                "  -a         Auto-activate all available channels\n"
                "  -c <n>     Do n conversions\n"
                "  -e         Disable wait for event (new data)\n"
                "  -g         Use trigger-less mode\n"
@@ -225,12 +275,16 @@ int main(int argc, char **argv)
        int scan_size;
        int noevents = 0;
        int notrigger = 0;
+        enum autochan autochannels = AUTOCHANNELS_DISABLED;
        char *dummy;
        struct iio_channel_info *channels;
-        while ((c = getopt(argc, argv, "c:egl:n:t:w:")) != -1) {
+        while ((c = getopt(argc, argv, "ac:egl:n:t:w:")) != -1) {
                switch (c) {
+                case 'a':
+                        autochannels = AUTOCHANNELS_ENABLED;
+                        break;
                case 'c':
                        errno = 0;
                        num_loops = strtoul(optarg, &dummy, 10);
@@ -340,12 +394,47 @@ int main(int argc, char **argv)
                        "diag %s\n", dev_dir_name);
                goto error_free_triggername;
        }
-        if (!num_channels) {
+        if (num_channels && autochannels == AUTOCHANNELS_ENABLED) {
+                fprintf(stderr, "Auto-channels selected but some channels "
+                        "are already activated in sysfs\n");
+                fprintf(stderr, "Proceeding without activating any channels\n");
+        }
+        if (!num_channels && autochannels == AUTOCHANNELS_ENABLED) {
+                fprintf(stderr,
+                        "No channels are enabled, enabling all channels\n");
+                ret = enable_disable_all_channels(dev_dir_name, 1);
+                if (ret) {
+                        fprintf(stderr, "Failed to enable all channels\n");
+                        goto error_free_triggername;
+                }
+                /* This flags that we need to disable the channels again */
+                autochannels = AUTOCHANNELS_ACTIVE;
+                ret = build_channel_array(dev_dir_name, &channels,
+                                          &num_channels);
+                if (ret) {
+                        fprintf(stderr, "Problem reading scan element "
+                                "information\n"
+                                "diag %s\n", dev_dir_name);
+                        goto error_disable_channels;
+                }
+                if (!num_channels) {
+                        fprintf(stderr, "Still no channels after "
+                                "auto-enabling, giving up\n");
+                        goto error_disable_channels;
+                }
+        }
+        if (!num_channels && autochannels == AUTOCHANNELS_DISABLED) {
                fprintf(stderr,
                        "No channels are enabled, we have nothing to scan.\n");
                fprintf(stderr, "Enable channels manually in "
                        FORMAT_SCAN_ELEMENTS_DIR
-                        "/*_en and try again.\n", dev_dir_name);
+                        "/*_en or pass -a to autoenable channels and "
+                        "try again.\n", dev_dir_name);
                ret = -ENOENT;
                goto error_free_triggername;
        }
@@ -479,7 +568,12 @@ error_free_channels:
 error_free_triggername:
        if (datardytrigger)
                free(trigger_name);
+error_disable_channels:
+        if (autochannels == AUTOCHANNELS_ACTIVE) {
+                ret = enable_disable_all_channels(dev_dir_name, 0);
+                if (ret)
+                        fprintf(stderr, "Failed to disable all channels\n");
+        }
 error_free_dev_dir_name:
        free(dev_dir_name);
diff --git a/tools/iio/iio_utils.h b/tools/iio/iio_utils.h
index e3503bfe538b..780f2014f8fa 100644
--- a/tools/iio/iio_utils.h
+++ b/tools/iio/iio_utils.h
@@ -52,6 +52,13 @@ struct iio_channel_info {
        unsigned location;
 };
+static inline int iioutils_check_suffix(const char *str, const char *suffix)
+{
+        return strlen(str) >= strlen(suffix) &&
+                strncmp(str+strlen(str)-strlen(suffix),
+                        suffix, strlen(suffix)) == 0;
+}
 int iioutils_break_up_name(const char *full_name, char **generic_name);
 int iioutils_get_type(unsigned *is_signed, unsigned *bytes, unsigned *bits_used,
                      unsigned *shift, uint64_t *mask, unsigned *be,