Merge tag 'staging-4.7-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging

Pull staging and IIO driver updates from Greg KH:
 "Here's the big staging and iio driver update for 4.7-rc1.

  I think we almost broke even with this release, only adding a few more
  lines than we removed, which isn't bad overall given that there's a
  bunch of new iio drivers added.

  The Lustre developers seem to have woken up from their sleep and have
  been doing a great job in cleaning up the code and pruning unused or
  old cruft, the filesystem is almost readable :)

  Other than that, just a lot of basic coding style cleanups in the
  churn.  All have been in linux-next for a while with no reported
  issues"

* tag 'staging-4.7-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/staging: (938 commits)
  Staging: emxx_udc: emxx_udc: fixed coding style issue
  staging/gdm724x: fix "alignment should match open parenthesis" issues
  staging/gdm724x: Fix avoid CamelCase
  staging: unisys: rename misleading var ii with frag
  staging: unisys: visorhba: switch success handling to error handling
  staging: unisys: visorhba: main path needs to flow down the left margin
  staging: unisys: visorinput: handle_locking_key() simplifications
  staging: unisys: visorhba: fail gracefully for thread creation failures
  staging: unisys: visornic: comment restructuring and removing bad diction
  staging: unisys: fix format string %Lx to %llx for u64
  staging: unisys: remove unused struct members
  staging: unisys: visorchannel: correct variable misspelling
  staging: unisys: visorhba: replace functionlike macro with function
  staging: dgnc: Need to check for NULL of ch
  staging: dgnc: remove redundant condition check
  staging: dgnc: fix 'line over 80 characters'
  staging: dgnc: clean up the dgnc_get_modem_info()
  staging: lustre: lnet: enable configuration per NI interface
  staging: lustre: o2iblnd: properly set ibr_why
  staging: lustre: o2iblnd: remove last of kiblnd_tunables_fini
  ...

99 files changed, 7634 insertions, 643 deletions

diff --git a/drivers/iio/accel/Kconfig b/drivers/iio/accel/Kconfig
index b0d3ecf3318b..e4a758cd7d35 100644
--- a/drivers/iio/accel/Kconfig
+++ b/drivers/iio/accel/Kconfig
@@ -64,7 +64,7 @@ config IIO_ST_ACCEL_3AXIS
         help
           Say yes here to build support for STMicroelectronics accelerometers:
           LSM303DLH, LSM303DLHC, LIS3DH, LSM330D, LSM330DL, LSM330DLC,
-          LIS331DLH, LSM303DL, LSM303DLM, LSM330, LIS2DH12.
+          LIS331DLH, LSM303DL, LSM303DLM, LSM330, LIS2DH12, H3LIS331DL.
 
           This driver can also be built as a module. If so, these modules
           will be created:
@@ -143,7 +143,8 @@ config MMA8452
         select IIO_TRIGGERED_BUFFER
         help
           Say yes here to build support for the following Freescale 3-axis
-          accelerometers: MMA8451Q, MMA8452Q, MMA8453Q, MMA8652FC, MMA8653FC.
+          accelerometers: MMA8451Q, MMA8452Q, MMA8453Q, MMA8652FC, MMA8653FC,
+          FXLS8471Q.
 
           To compile this driver as a module, choose M here: the module
           will be called mma8452.
diff --git a/drivers/iio/accel/bmc150-accel-core.c b/drivers/iio/accel/bmc150-accel-core.c
index 2072a31e813b..197e693e7e7b 100644
--- a/drivers/iio/accel/bmc150-accel-core.c
+++ b/drivers/iio/accel/bmc150-accel-core.c
@@ -25,7 +25,6 @@
 #include <linux/delay.h>
 #include <linux/slab.h>
 #include <linux/acpi.h>
-#include <linux/gpio/consumer.h>
 #include <linux/pm.h>
 #include <linux/pm_runtime.h>
 #include <linux/iio/iio.h>
@@ -138,6 +137,7 @@ enum bmc150_accel_axis {
         AXIS_X,
         AXIS_Y,
         AXIS_Z,
+        AXIS_MAX,
 };
 
 enum bmc150_power_modes {
@@ -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;
@@ -246,16 +245,18 @@ static const struct {
                                        {500000, BMC150_ACCEL_SLEEP_500_MS},
                                        {1000000, BMC150_ACCEL_SLEEP_1_SEC} };
 
-static const struct regmap_config bmc150_i2c_regmap_conf = {
+const struct regmap_config bmc150_regmap_conf = {
         .reg_bits = 8,
         .val_bits = 8,
         .max_register = 0x3f,
 };
+EXPORT_SYMBOL_GPL(bmc150_regmap_conf);
 
 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;
@@ -279,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;
         }
 
@@ -316,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;
@@ -378,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);
-                ret = pm_runtime_put_autosuspend(data->dev);
+                pm_runtime_mark_last_busy(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;
         }
@@ -445,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;
@@ -474,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;
         }
 
@@ -482,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;
         }
 
@@ -500,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) {
@@ -508,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,
-                                        "Error writing pmu_range\n");
+                                dev_err(dev, "Error writing pmu_range\n");
                                 return ret;
                         }
 
@@ -523,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;
 
@@ -530,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;
         }
@@ -545,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;
@@ -559,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;
@@ -831,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;
@@ -854,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;
@@ -864,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];
@@ -873,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;
         }
 
@@ -1105,27 +1114,23 @@ static const struct iio_info bmc150_accel_info_fifo = {
         .driver_module          = THIS_MODULE,
 };
 
+static const unsigned long bmc150_accel_scan_masks[] = {
+                                        BIT(AXIS_X) | BIT(AXIS_Y) | BIT(AXIS_Z),
+                                        0};
+
 static irqreturn_t bmc150_accel_trigger_handler(int irq, void *p)
 {
         struct iio_poll_func *pf = p;
         struct iio_dev *indio_dev = pf->indio_dev;
         struct bmc150_accel_data *data = iio_priv(indio_dev);
-        int bit, ret, i = 0;
-        unsigned int raw_val;
+        int ret;
 
         mutex_lock(&data->mutex);
-        for_each_set_bit(bit, indio_dev->active_scan_mask,
-                         indio_dev->masklength) {
-                ret = regmap_bulk_read(data->regmap,
-                                       BMC150_ACCEL_AXIS_TO_REG(bit), &raw_val,
-                                       2);
-                if (ret < 0) {
-                        mutex_unlock(&data->mutex);
-                        goto err_read;
-                }
-                data->buffer[i++] = raw_val;
-        }
+        ret = regmap_bulk_read(data->regmap, BMC150_ACCEL_REG_XOUT_L,
+                               data->buffer, AXIS_MAX * 2);
         mutex_unlock(&data->mutex);
+        if (ret < 0)
+                goto err_read;
 
         iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
                                            pf->timestamp);
@@ -1139,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 */
@@ -1152,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,
-                        "Error writing reg_int_rst_latch\n");
+                dev_err(dev, "Error writing reg_int_rst_latch\n");
                 return ret;
         }
 
@@ -1204,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;
         }
 
@@ -1253,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;
 
@@ -1276,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 {
@@ -1347,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,
-                                               bmc150_accel_triggers[i].name,
+                t->indio_trig = devm_iio_trigger_alloc(dev,
+                                        bmc150_accel_triggers[i].name,
                                                        indio_dev->name,
                                                        indio_dev->id);
                 if (!t->indio_trig) {
@@ -1361,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;
@@ -1385,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;
         }
 
@@ -1400,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;
 }
@@ -1484,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,
-                        "Error: Reading chip id\n");
+                dev_err(dev, "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];
@@ -1503,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;
         }
 
@@ -1520,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,
-                                        "Error writing reg_pmu_range\n");
+                dev_err(dev, "Error writing reg_pmu_range\n");
                 return ret;
         }
 
@@ -1539,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,
-                        "Error writing reg_int_rst_latch\n");
+                dev_err(dev, "Error writing reg_int_rst_latch\n");
                 return ret;
         }
 
@@ -1560,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;
@@ -1575,6 +1581,7 @@ int bmc150_accel_core_probe(struct device *dev, struct regmap *regmap, int irq,
         indio_dev->channels = data->chip_info->channels;
         indio_dev->num_channels = data->chip_info->num_channels;
         indio_dev->name = name ? name : data->chip_info->name;
+        indio_dev->available_scan_masks = bmc150_accel_scan_masks;
         indio_dev->modes = INDIO_DIRECT_MODE;
         indio_dev->info = &bmc150_accel_info;
 
@@ -1583,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,
@@ -1607,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;
                 }
 
@@ -1656,9 +1663,9 @@ int bmc150_accel_core_remove(struct device *dev)
 
         iio_device_unregister(indio_dev);
 
-        pm_runtime_disable(data->dev);
-        pm_runtime_set_suspended(data->dev);
-        pm_runtime_put_noidle(data->dev);
+        pm_runtime_disable(dev);
+        pm_runtime_set_suspended(dev);
+        pm_runtime_put_noidle(dev);
 
         bmc150_accel_unregister_triggers(data, BMC150_ACCEL_TRIGGERS - 1);
 
@@ -1707,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;
@@ -1722,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/bmc150-accel-i2c.c b/drivers/iio/accel/bmc150-accel-i2c.c
index b41404ba32fc..8ca8041267ef 100644
--- a/drivers/iio/accel/bmc150-accel-i2c.c
+++ b/drivers/iio/accel/bmc150-accel-i2c.c
@@ -28,11 +28,6 @@
 
 #include "bmc150-accel.h"
 
-static const struct regmap_config bmc150_i2c_regmap_conf = {
-        .reg_bits = 8,
-        .val_bits = 8,
-};
-
 static int bmc150_accel_probe(struct i2c_client *client,
                               const struct i2c_device_id *id)
 {
@@ -43,7 +38,7 @@ static int bmc150_accel_probe(struct i2c_client *client,
                 i2c_check_functionality(client->adapter,
                                         I2C_FUNC_SMBUS_READ_I2C_BLOCK);
 
-        regmap = devm_regmap_init_i2c(client, &bmc150_i2c_regmap_conf);
+        regmap = devm_regmap_init_i2c(client, &bmc150_regmap_conf);
         if (IS_ERR(regmap)) {
                 dev_err(&client->dev, "Failed to initialize i2c regmap\n");
                 return PTR_ERR(regmap);
diff --git a/drivers/iio/accel/bmc150-accel-spi.c b/drivers/iio/accel/bmc150-accel-spi.c
index 16b66f2a7204..006794a70a1f 100644
--- a/drivers/iio/accel/bmc150-accel-spi.c
+++ b/drivers/iio/accel/bmc150-accel-spi.c
@@ -25,18 +25,12 @@
 
 #include "bmc150-accel.h"
 
-static const struct regmap_config bmc150_spi_regmap_conf = {
-        .reg_bits = 8,
-        .val_bits = 8,
-        .max_register = 0x3f,
-};
-
 static int bmc150_accel_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_spi_regmap_conf);
+        regmap = devm_regmap_init_spi(spi, &bmc150_regmap_conf);
         if (IS_ERR(regmap)) {
                 dev_err(&spi->dev, "Failed to initialize spi regmap\n");
                 return PTR_ERR(regmap);
diff --git a/drivers/iio/accel/bmc150-accel.h b/drivers/iio/accel/bmc150-accel.h
index ba0335987f94..38a8b11f8c19 100644
--- a/drivers/iio/accel/bmc150-accel.h
+++ b/drivers/iio/accel/bmc150-accel.h
@@ -16,5 +16,6 @@ int bmc150_accel_core_probe(struct device *dev, struct regmap *regmap, int irq,
                             const char *name, bool block_supported);
 int bmc150_accel_core_remove(struct device *dev);
 extern const struct dev_pm_ops bmc150_accel_pm_ops;
+extern const struct regmap_config bmc150_regmap_conf;
 
 #endif  /* _BMC150_ACCEL_H_ */
diff --git a/drivers/iio/accel/kxcjk-1013.c b/drivers/iio/accel/kxcjk-1013.c
index edec1d099e91..bfe219a8bea2 100644
--- a/drivers/iio/accel/kxcjk-1013.c
+++ b/drivers/iio/accel/kxcjk-1013.c
@@ -20,7 +20,6 @@
 #include <linux/slab.h>
 #include <linux/string.h>
 #include <linux/acpi.h>
-#include <linux/gpio/consumer.h>
 #include <linux/pm.h>
 #include <linux/pm_runtime.h>
 #include <linux/iio/iio.h>
@@ -115,6 +114,7 @@ enum kxcjk1013_axis {
         AXIS_X,
         AXIS_Y,
         AXIS_Z,
+        AXIS_MAX,
 };
 
 enum kxcjk1013_mode {
@@ -922,7 +922,7 @@ static const struct iio_event_spec kxcjk1013_event = {
                 .realbits = 12,                                         \
                 .storagebits = 16,                                      \
                 .shift = 4,                                             \
-                .endianness = IIO_CPU,                                  \
+                .endianness = IIO_LE,                                   \
         },                                                              \
         .event_spec = &kxcjk1013_event,                         \
         .num_event_specs = 1                                            \
@@ -953,25 +953,23 @@ static const struct iio_info kxcjk1013_info = {
         .driver_module          = THIS_MODULE,
 };
 
+static const unsigned long kxcjk1013_scan_masks[] = {0x7, 0};
+
 static irqreturn_t kxcjk1013_trigger_handler(int irq, void *p)
 {
         struct iio_poll_func *pf = p;
         struct iio_dev *indio_dev = pf->indio_dev;
         struct kxcjk1013_data *data = iio_priv(indio_dev);
-        int bit, ret, i = 0;
+        int ret;
 
         mutex_lock(&data->mutex);
-
-        for_each_set_bit(bit, indio_dev->active_scan_mask,
-                         indio_dev->masklength) {
-                ret = kxcjk1013_get_acc_reg(data, bit);
-                if (ret < 0) {
-                        mutex_unlock(&data->mutex);
-                        goto err;
-                }
-                data->buffer[i++] = ret;
-        }
+        ret = i2c_smbus_read_i2c_block_data_or_emulated(data->client,
+                                                        KXCJK1013_REG_XOUT_L,
+                                                        AXIS_MAX * 2,
+                                                        (u8 *)data->buffer);
         mutex_unlock(&data->mutex);
+        if (ret < 0)
+                goto err;
 
         iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
                                            data->timestamp);
@@ -1204,6 +1202,7 @@ static int kxcjk1013_probe(struct i2c_client *client,
         indio_dev->dev.parent = &client->dev;
         indio_dev->channels = kxcjk1013_channels;
         indio_dev->num_channels = ARRAY_SIZE(kxcjk1013_channels);
+        indio_dev->available_scan_masks = kxcjk1013_scan_masks;
         indio_dev->name = name;
         indio_dev->modes = INDIO_DIRECT_MODE;
         indio_dev->info = &kxcjk1013_info;
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/mma8452.c b/drivers/iio/accel/mma8452.c
index 7f4994f32a90..e225d3c53bd5 100644
--- a/drivers/iio/accel/mma8452.c
+++ b/drivers/iio/accel/mma8452.c
@@ -6,6 +6,7 @@
  * MMA8453Q (10 bit)
  * MMA8652FC (12 bit)
  * MMA8653FC (10 bit)
+ * FXLS8471Q (14 bit)
  *
  * Copyright 2015 Martin Kepplinger <martin.kepplinger@theobroma-systems.com>
  * Copyright 2014 Peter Meerwald <pmeerw@pmeerw.net>
@@ -16,7 +17,7 @@
  *
  * 7-bit I2C slave address 0x1c/0x1d (pin selectable)
  *
- * TODO: orientation events, autosleep
+ * TODO: orientation events
  */
 
 #include <linux/module.h>
@@ -31,6 +32,7 @@
 #include <linux/delay.h>
 #include <linux/of_device.h>
 #include <linux/of_irq.h>
+#include <linux/pm_runtime.h>
 
 #define MMA8452_STATUS                          0x00
 #define  MMA8452_STATUS_DRDY                    (BIT(2) | BIT(1) | BIT(0))
@@ -91,6 +93,9 @@
 #define MMA8453_DEVICE_ID                       0x3a
 #define MMA8652_DEVICE_ID                       0x4a
 #define MMA8653_DEVICE_ID                       0x5a
+#define FXLS8471_DEVICE_ID                      0x6a
+
+#define MMA8452_AUTO_SUSPEND_DELAY_MS           2000
 
 struct mma8452_data {
         struct i2c_client *client;
@@ -172,6 +177,31 @@ static int mma8452_drdy(struct mma8452_data *data)
         return -EIO;
 }
 
+static int mma8452_set_runtime_pm_state(struct i2c_client *client, bool on)
+{
+#ifdef CONFIG_PM
+        int ret;
+
+        if (on) {
+                ret = pm_runtime_get_sync(&client->dev);
+        } else {
+                pm_runtime_mark_last_busy(&client->dev);
+                ret = pm_runtime_put_autosuspend(&client->dev);
+        }
+
+        if (ret < 0) {
+                dev_err(&client->dev,
+                        "failed to change power state to %d\n", on);
+                if (on)
+                        pm_runtime_put_noidle(&client->dev);
+
+                return ret;
+        }
+#endif
+
+        return 0;
+}
+
 static int mma8452_read(struct mma8452_data *data, __be16 buf[3])
 {
         int ret = mma8452_drdy(data);
@@ -179,8 +209,16 @@ static int mma8452_read(struct mma8452_data *data, __be16 buf[3])
         if (ret < 0)
                 return ret;
 
-        return i2c_smbus_read_i2c_block_data(data->client, MMA8452_OUT_X,
-                                             3 * sizeof(__be16), (u8 *)buf);
+        ret = mma8452_set_runtime_pm_state(data->client, true);
+        if (ret)
+                return ret;
+
+        ret = i2c_smbus_read_i2c_block_data(data->client, MMA8452_OUT_X,
+                                            3 * sizeof(__be16), (u8 *)buf);
+
+        ret = mma8452_set_runtime_pm_state(data->client, false);
+
+        return ret;
 }
 
 static ssize_t mma8452_show_int_plus_micros(char *buf, const int (*vals)[2],
@@ -357,7 +395,8 @@ static int mma8452_read_raw(struct iio_dev *indio_dev,
                 return IIO_VAL_INT_PLUS_MICRO;
         case IIO_CHAN_INFO_CALIBBIAS:
                 ret = i2c_smbus_read_byte_data(data->client,
-                                              MMA8452_OFF_X + chan->scan_index);
+                                               MMA8452_OFF_X +
+                                               chan->scan_index);
                 if (ret < 0)
                         return ret;
 
@@ -392,24 +431,47 @@ static int mma8452_active(struct mma8452_data *data)
                                          data->ctrl_reg1);
 }
 
+/* returns >0 if active, 0 if in standby and <0 on error */
+static int mma8452_is_active(struct mma8452_data *data)
+{
+        int reg;
+
+        reg = i2c_smbus_read_byte_data(data->client, MMA8452_CTRL_REG1);
+        if (reg < 0)
+                return reg;
+
+        return reg & MMA8452_CTRL_ACTIVE;
+}
+
 static int mma8452_change_config(struct mma8452_data *data, u8 reg, u8 val)
 {
         int ret;
+        int is_active;
 
         mutex_lock(&data->lock);
 
-        /* config can only be changed when in standby */
-        ret = mma8452_standby(data);
-        if (ret < 0)
+        is_active = mma8452_is_active(data);
+        if (is_active < 0) {
+                ret = is_active;
                 goto fail;
+        }
+
+        /* config can only be changed when in standby */
+        if (is_active > 0) {
+                ret = mma8452_standby(data);
+                if (ret < 0)
+                        goto fail;
+        }
 
         ret = i2c_smbus_write_byte_data(data->client, reg, val);
         if (ret < 0)
                 goto fail;
 
-        ret = mma8452_active(data);
-        if (ret < 0)
-                goto fail;
+        if (is_active > 0) {
+                ret = mma8452_active(data);
+                if (ret < 0)
+                        goto fail;
+        }
 
         ret = 0;
 fail:
@@ -418,7 +480,7 @@ fail:
         return ret;
 }
 
-/* returns >0 if in freefall mode, 0 if not or <0 if an error occured */
+/* returns >0 if in freefall mode, 0 if not or <0 if an error occurred */
 static int mma8452_freefall_mode_enabled(struct mma8452_data *data)
 {
         int val;
@@ -668,7 +730,8 @@ static int mma8452_read_event_config(struct iio_dev *indio_dev,
                 if (ret < 0)
                         return ret;
 
-                return !!(ret & BIT(chan->scan_index + chip->ev_cfg_chan_shift));
+                return !!(ret & BIT(chan->scan_index +
+                                    chip->ev_cfg_chan_shift));
         default:
                 return -EINVAL;
         }
@@ -682,7 +745,11 @@ static int mma8452_write_event_config(struct iio_dev *indio_dev,
 {
         struct mma8452_data *data = iio_priv(indio_dev);
         const struct mma_chip_info *chip = data->chip_info;
-        int val;
+        int val, ret;
+
+        ret = mma8452_set_runtime_pm_state(data->client, state);
+        if (ret)
+                return ret;
 
         switch (dir) {
         case IIO_EV_DIR_FALLING:
@@ -990,6 +1057,7 @@ enum {
         mma8453,
         mma8652,
         mma8653,
+        fxls8471,
 };
 
 static const struct mma_chip_info mma_chip_info_table[] = {
@@ -1003,7 +1071,7 @@ static const struct mma_chip_info mma_chip_info_table[] = {
                  * bit.
                  * The userspace interface uses m/s^2 and we declare micro units
                  * So scale factor for 12 bit here is given by:
-                 *      g * N * 1000000 / 2048 for N = 2, 4, 8 and g=9.80665
+                 *      g * N * 1000000 / 2048 for N = 2, 4, 8 and g=9.80665
                  */
                 .mma_scales = { {0, 2394}, {0, 4788}, {0, 9577} },
                 .ev_cfg = MMA8452_TRANSIENT_CFG,
@@ -1081,6 +1149,22 @@ static const struct mma_chip_info mma_chip_info_table[] = {
                 .ev_ths_mask = MMA8452_FF_MT_THS_MASK,
                 .ev_count = MMA8452_FF_MT_COUNT,
         },
+        [fxls8471] = {
+                .chip_id = FXLS8471_DEVICE_ID,
+                .channels = mma8451_channels,
+                .num_channels = ARRAY_SIZE(mma8451_channels),
+                .mma_scales = { {0, 2394}, {0, 4788}, {0, 9577} },
+                .ev_cfg = MMA8452_TRANSIENT_CFG,
+                .ev_cfg_ele = MMA8452_TRANSIENT_CFG_ELE,
+                .ev_cfg_chan_shift = 1,
+                .ev_src = MMA8452_TRANSIENT_SRC,
+                .ev_src_xe = MMA8452_TRANSIENT_SRC_XTRANSE,
+                .ev_src_ye = MMA8452_TRANSIENT_SRC_YTRANSE,
+                .ev_src_ze = MMA8452_TRANSIENT_SRC_ZTRANSE,
+                .ev_ths = MMA8452_TRANSIENT_THS,
+                .ev_ths_mask = MMA8452_TRANSIENT_THS_MASK,
+                .ev_count = MMA8452_TRANSIENT_COUNT,
+        },
 };
 
 static struct attribute *mma8452_attributes[] = {
@@ -1114,7 +1198,11 @@ static int mma8452_data_rdy_trigger_set_state(struct iio_trigger *trig,
 {
         struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
         struct mma8452_data *data = iio_priv(indio_dev);
-        int reg;
+        int reg, ret;
+
+        ret = mma8452_set_runtime_pm_state(data->client, state);
+        if (ret)
+                return ret;
 
         reg = i2c_smbus_read_byte_data(data->client, MMA8452_CTRL_REG4);
         if (reg < 0)
@@ -1206,6 +1294,7 @@ static const struct of_device_id mma8452_dt_ids[] = {
         { .compatible = "fsl,mma8453", .data = &mma_chip_info_table[mma8453] },
         { .compatible = "fsl,mma8652", .data = &mma_chip_info_table[mma8652] },
         { .compatible = "fsl,mma8653", .data = &mma_chip_info_table[mma8653] },
+        { .compatible = "fsl,fxls8471", .data = &mma_chip_info_table[fxls8471] },
         { }
 };
 MODULE_DEVICE_TABLE(of, mma8452_dt_ids);
@@ -1243,6 +1332,7 @@ static int mma8452_probe(struct i2c_client *client,
         case MMA8453_DEVICE_ID:
         case MMA8652_DEVICE_ID:
         case MMA8653_DEVICE_ID:
+        case FXLS8471_DEVICE_ID:
                 if (ret == data->chip_info->chip_id)
                         break;
         default:
@@ -1340,6 +1430,15 @@ static int mma8452_probe(struct i2c_client *client,
                         goto buffer_cleanup;
         }
 
+        ret = pm_runtime_set_active(&client->dev);
+        if (ret < 0)
+                goto buffer_cleanup;
+
+        pm_runtime_enable(&client->dev);
+        pm_runtime_set_autosuspend_delay(&client->dev,
+                                         MMA8452_AUTO_SUSPEND_DELAY_MS);
+        pm_runtime_use_autosuspend(&client->dev);
+
         ret = iio_device_register(indio_dev);
         if (ret < 0)
                 goto buffer_cleanup;
@@ -1364,6 +1463,11 @@ static int mma8452_remove(struct i2c_client *client)
         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 
         iio_device_unregister(indio_dev);
+
+        pm_runtime_disable(&client->dev);
+        pm_runtime_set_suspended(&client->dev);
+        pm_runtime_put_noidle(&client->dev);
+
         iio_triggered_buffer_cleanup(indio_dev);
         mma8452_trigger_cleanup(indio_dev);
         mma8452_standby(iio_priv(indio_dev));
@@ -1371,6 +1475,45 @@ static int mma8452_remove(struct i2c_client *client)
         return 0;
 }
 
+#ifdef CONFIG_PM
+static int mma8452_runtime_suspend(struct device *dev)
+{
+        struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
+        struct mma8452_data *data = iio_priv(indio_dev);
+        int ret;
+
+        mutex_lock(&data->lock);
+        ret = mma8452_standby(data);
+        mutex_unlock(&data->lock);
+        if (ret < 0) {
+                dev_err(&data->client->dev, "powering off device failed\n");
+                return -EAGAIN;
+        }
+
+        return 0;
+}
+
+static int mma8452_runtime_resume(struct device *dev)
+{
+        struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
+        struct mma8452_data *data = iio_priv(indio_dev);
+        int ret, sleep_val;
+
+        ret = mma8452_active(data);
+        if (ret < 0)
+                return ret;
+
+        ret = mma8452_get_odr_index(data);
+        sleep_val = 1000 / mma8452_samp_freq[ret][0];
+        if (sleep_val < 20)
+                usleep_range(sleep_val * 1000, 20000);
+        else
+                msleep_interruptible(sleep_val);
+
+        return 0;
+}
+#endif
+
 #ifdef CONFIG_PM_SLEEP
 static int mma8452_suspend(struct device *dev)
 {
@@ -1383,18 +1526,21 @@ static int mma8452_resume(struct device *dev)
         return mma8452_active(iio_priv(i2c_get_clientdata(
                 to_i2c_client(dev))));
 }
-
-static SIMPLE_DEV_PM_OPS(mma8452_pm_ops, mma8452_suspend, mma8452_resume);
-#define MMA8452_PM_OPS (&mma8452_pm_ops)
-#else
-#define MMA8452_PM_OPS NULL
 #endif
 
+static const struct dev_pm_ops mma8452_pm_ops = {
+        SET_SYSTEM_SLEEP_PM_OPS(mma8452_suspend, mma8452_resume)
+        SET_RUNTIME_PM_OPS(mma8452_runtime_suspend,
+                           mma8452_runtime_resume, NULL)
+};
+
 static const struct i2c_device_id mma8452_id[] = {
+        { "mma8451", mma8451 },
         { "mma8452", mma8452 },
         { "mma8453", mma8453 },
         { "mma8652", mma8652 },
         { "mma8653", mma8653 },
+        { "fxls8471", fxls8471 },
         { }
 };
 MODULE_DEVICE_TABLE(i2c, mma8452_id);
@@ -1403,7 +1549,7 @@ static struct i2c_driver mma8452_driver = {
         .driver = {
                 .name   = "mma8452",
                 .of_match_table = of_match_ptr(mma8452_dt_ids),
-                .pm     = MMA8452_PM_OPS,
+                .pm     = &mma8452_pm_ops,
         },
         .probe = mma8452_probe,
         .remove = mma8452_remove,
diff --git a/drivers/iio/accel/mma9553.c b/drivers/iio/accel/mma9553.c
index fa7d36217c4b..bb05f3efddca 100644
--- a/drivers/iio/accel/mma9553.c
+++ b/drivers/iio/accel/mma9553.c
@@ -17,7 +17,6 @@
 #include <linux/interrupt.h>
 #include <linux/slab.h>
 #include <linux/acpi.h>
-#include <linux/gpio/consumer.h>
 #include <linux/iio/iio.h>
 #include <linux/iio/sysfs.h>
 #include <linux/iio/events.h>
diff --git a/drivers/iio/accel/mxc4005.c b/drivers/iio/accel/mxc4005.c
index e72e218c2696..c23f47af7256 100644
--- a/drivers/iio/accel/mxc4005.c
+++ b/drivers/iio/accel/mxc4005.c
@@ -17,7 +17,6 @@
 #include <linux/i2c.h>
 #include <linux/iio/iio.h>
 #include <linux/acpi.h>
-#include <linux/gpio/consumer.h>
 #include <linux/regmap.h>
 #include <linux/iio/sysfs.h>
 #include <linux/iio/trigger.h>
@@ -380,31 +379,6 @@ static const struct iio_trigger_ops mxc4005_trigger_ops = {
         .owner = THIS_MODULE,
 };
 
-static int mxc4005_gpio_probe(struct i2c_client *client,
-                              struct mxc4005_data *data)
-{
-        struct device *dev;
-        struct gpio_desc *gpio;
-        int ret;
-
-        if (!client)
-                return -EINVAL;
-
-        dev = &client->dev;
-
-        gpio = devm_gpiod_get_index(dev, "mxc4005_int", 0, GPIOD_IN);
-        if (IS_ERR(gpio)) {
-                dev_err(dev, "failed to get acpi gpio index\n");
-                return PTR_ERR(gpio);
-        }
-
-        ret = gpiod_to_irq(gpio);
-
-        dev_dbg(dev, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio), ret);
-
-        return ret;
-}
-
 static int mxc4005_chip_init(struct mxc4005_data *data)
 {
         int ret;
@@ -470,9 +444,6 @@ static int mxc4005_probe(struct i2c_client *client,
                 return ret;
         }
 
-        if (client->irq < 0)
-                client->irq = mxc4005_gpio_probe(client, data);
-
         if (client->irq > 0) {
                 data->dready_trig = devm_iio_trigger_alloc(&client->dev,
                                                            "%s-dev%d",
diff --git a/drivers/iio/accel/st_accel.h b/drivers/iio/accel/st_accel.h
index 5d4a1897b293..57f83a67948c 100644
--- a/drivers/iio/accel/st_accel.h
+++ b/drivers/iio/accel/st_accel.h
@@ -14,6 +14,7 @@
 #include <linux/types.h>
 #include <linux/iio/common/st_sensors.h>
 
+#define H3LIS331DL_DRIVER_NAME          "h3lis331dl_accel"
 #define LIS3LV02DL_ACCEL_DEV_NAME       "lis3lv02dl_accel"
 #define LSM303DLHC_ACCEL_DEV_NAME       "lsm303dlhc_accel"
 #define LIS3DH_ACCEL_DEV_NAME           "lis3dh"
diff --git a/drivers/iio/accel/st_accel_core.c b/drivers/iio/accel/st_accel_core.c
index a03a1417dd63..dc73f2d85e6d 100644
--- a/drivers/iio/accel/st_accel_core.c
+++ b/drivers/iio/accel/st_accel_core.c
@@ -39,6 +39,9 @@
 #define ST_ACCEL_FS_AVL_6G                      6
 #define ST_ACCEL_FS_AVL_8G                      8
 #define ST_ACCEL_FS_AVL_16G                     16
+#define ST_ACCEL_FS_AVL_100G                    100
+#define ST_ACCEL_FS_AVL_200G                    200
+#define ST_ACCEL_FS_AVL_400G                    400
 
 /* CUSTOM VALUES FOR SENSOR 1 */
 #define ST_ACCEL_1_WAI_EXP                      0x33
@@ -96,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 */
@@ -177,10 +182,39 @@
 #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
 
+/* CUSTOM VALUES FOR SENSOR 6 */
+#define ST_ACCEL_6_WAI_EXP                      0x32
+#define ST_ACCEL_6_ODR_ADDR                     0x20
+#define ST_ACCEL_6_ODR_MASK                     0x18
+#define ST_ACCEL_6_ODR_AVL_50HZ_VAL             0x00
+#define ST_ACCEL_6_ODR_AVL_100HZ_VAL            0x01
+#define ST_ACCEL_6_ODR_AVL_400HZ_VAL            0x02
+#define ST_ACCEL_6_ODR_AVL_1000HZ_VAL           0x03
+#define ST_ACCEL_6_PW_ADDR                      0x20
+#define ST_ACCEL_6_PW_MASK                      0x20
+#define ST_ACCEL_6_FS_ADDR                      0x23
+#define ST_ACCEL_6_FS_MASK                      0x30
+#define ST_ACCEL_6_FS_AVL_100_VAL               0x00
+#define ST_ACCEL_6_FS_AVL_200_VAL               0x01
+#define ST_ACCEL_6_FS_AVL_400_VAL               0x03
+#define ST_ACCEL_6_FS_AVL_100_GAIN              IIO_G_TO_M_S_2(49000)
+#define ST_ACCEL_6_FS_AVL_200_GAIN              IIO_G_TO_M_S_2(98000)
+#define ST_ACCEL_6_FS_AVL_400_GAIN              IIO_G_TO_M_S_2(195000)
+#define ST_ACCEL_6_BDU_ADDR                     0x23
+#define ST_ACCEL_6_BDU_MASK                     0x80
+#define ST_ACCEL_6_DRDY_IRQ_ADDR                0x22
+#define ST_ACCEL_6_DRDY_IRQ_INT1_MASK           0x02
+#define ST_ACCEL_6_DRDY_IRQ_INT2_MASK           0x10
+#define ST_ACCEL_6_IHL_IRQ_ADDR                 0x22
+#define ST_ACCEL_6_IHL_IRQ_MASK                 0x80
+#define ST_ACCEL_6_MULTIREAD_BIT                true
+
 static const struct iio_chan_spec st_accel_8bit_channels[] = {
         ST_SENSORS_LSM_CHANNELS(IIO_ACCEL,
                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
@@ -302,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,
@@ -367,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,
@@ -444,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,
@@ -502,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 */
@@ -553,10 +593,75 @@ 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 */
         },
+        {
+                .wai = ST_ACCEL_6_WAI_EXP,
+                .wai_addr = ST_SENSORS_DEFAULT_WAI_ADDRESS,
+                .sensors_supported = {
+                        [0] = H3LIS331DL_DRIVER_NAME,
+                },
+                .ch = (struct iio_chan_spec *)st_accel_12bit_channels,
+                .odr = {
+                        .addr = ST_ACCEL_6_ODR_ADDR,
+                        .mask = ST_ACCEL_6_ODR_MASK,
+                        .odr_avl = {
+                                { 50, ST_ACCEL_6_ODR_AVL_50HZ_VAL },
+                                { 100, ST_ACCEL_6_ODR_AVL_100HZ_VAL, },
+                                { 400, ST_ACCEL_6_ODR_AVL_400HZ_VAL, },
+                                { 1000, ST_ACCEL_6_ODR_AVL_1000HZ_VAL, },
+                        },
+                },
+                .pw = {
+                        .addr = ST_ACCEL_6_PW_ADDR,
+                        .mask = ST_ACCEL_6_PW_MASK,
+                        .value_on = ST_SENSORS_DEFAULT_POWER_ON_VALUE,
+                        .value_off = ST_SENSORS_DEFAULT_POWER_OFF_VALUE,
+                },
+                .enable_axis = {
+                        .addr = ST_SENSORS_DEFAULT_AXIS_ADDR,
+                        .mask = ST_SENSORS_DEFAULT_AXIS_MASK,
+                },
+                .fs = {
+                        .addr = ST_ACCEL_6_FS_ADDR,
+                        .mask = ST_ACCEL_6_FS_MASK,
+                        .fs_avl = {
+                                [0] = {
+                                        .num = ST_ACCEL_FS_AVL_100G,
+                                        .value = ST_ACCEL_6_FS_AVL_100_VAL,
+                                        .gain = ST_ACCEL_6_FS_AVL_100_GAIN,
+                                },
+                                [1] = {
+                                        .num = ST_ACCEL_FS_AVL_200G,
+                                        .value = ST_ACCEL_6_FS_AVL_200_VAL,
+                                        .gain = ST_ACCEL_6_FS_AVL_200_GAIN,
+                                },
+                                [2] = {
+                                        .num = ST_ACCEL_FS_AVL_400G,
+                                        .value = ST_ACCEL_6_FS_AVL_400_VAL,
+                                        .gain = ST_ACCEL_6_FS_AVL_400_GAIN,
+                                },
+                        },
+                },
+                .bdu = {
+                        .addr = ST_ACCEL_6_BDU_ADDR,
+                        .mask = ST_ACCEL_6_BDU_MASK,
+                },
+                .drdy_irq = {
+                        .addr = ST_ACCEL_6_DRDY_IRQ_ADDR,
+                        .mask_int1 = ST_ACCEL_6_DRDY_IRQ_INT1_MASK,
+                        .mask_int2 = ST_ACCEL_6_DRDY_IRQ_INT2_MASK,
+                        .addr_ihl = ST_ACCEL_6_IHL_IRQ_ADDR,
+                        .mask_ihl = ST_ACCEL_6_IHL_IRQ_MASK,
+                },
+                .multi_read_bit = ST_ACCEL_6_MULTIREAD_BIT,
+                .bootime = 2,
+        },
 };
 
 static int st_accel_read_raw(struct iio_dev *indio_dev,
diff --git a/drivers/iio/accel/st_accel_i2c.c b/drivers/iio/accel/st_accel_i2c.c
index 294a32f89367..7333ee9fb11b 100644
--- a/drivers/iio/accel/st_accel_i2c.c
+++ b/drivers/iio/accel/st_accel_i2c.c
@@ -76,6 +76,10 @@ static const struct of_device_id st_accel_of_match[] = {
                 .compatible = "st,lis2dh12-accel",
                 .data = LIS2DH12_ACCEL_DEV_NAME,
         },
+        {
+                .compatible = "st,h3lis331dl-accel",
+                .data = H3LIS331DL_DRIVER_NAME,
+        },
         {},
 };
 MODULE_DEVICE_TABLE(of, st_accel_of_match);
diff --git a/drivers/iio/accel/stk8312.c b/drivers/iio/accel/stk8312.c
index 85fe7f7247c1..e31023dc5f1b 100644
--- a/drivers/iio/accel/stk8312.c
+++ b/drivers/iio/accel/stk8312.c
@@ -11,7 +11,6 @@
  */
 
 #include <linux/acpi.h>
-#include <linux/gpio/consumer.h>
 #include <linux/i2c.h>
 #include <linux/interrupt.h>
 #include <linux/kernel.h>
diff --git a/drivers/iio/accel/stk8ba50.c b/drivers/iio/accel/stk8ba50.c
index 5709d9eb8f34..300d955bad00 100644
--- a/drivers/iio/accel/stk8ba50.c
+++ b/drivers/iio/accel/stk8ba50.c
@@ -11,7 +11,6 @@
  */
 
 #include <linux/acpi.h>
-#include <linux/gpio/consumer.h>
 #include <linux/i2c.h>
 #include <linux/interrupt.h>
 #include <linux/kernel.h>
diff --git a/drivers/iio/adc/Kconfig b/drivers/iio/adc/Kconfig
index 82c718c515a0..25378c5882e2 100644
--- a/drivers/iio/adc/Kconfig
+++ b/drivers/iio/adc/Kconfig
@@ -242,6 +242,16 @@ config LP8788_ADC
           To compile this driver as a module, choose M here: the module will be
           called lp8788_adc.
 
+config LPC18XX_ADC
+        tristate "NXP LPC18xx ADC driver"
+        depends on ARCH_LPC18XX || COMPILE_TEST
+        depends on OF && HAS_IOMEM
+        help
+          Say yes here to build support for NXP LPC18XX ADC.
+
+          To compile this driver as a module, choose M here: the module will be
+          called lpc18xx_adc.
+
 config MAX1027
         tristate "Maxim max1027 ADC driver"
         depends on SPI
@@ -375,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
-          and ADC081C027 ADC chips.
+          If you say yes here you get support for Texas Instruments ADC081C,
+          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/Makefile b/drivers/iio/adc/Makefile
index 0cb79210a4b0..38638d46f972 100644
--- a/drivers/iio/adc/Makefile
+++ b/drivers/iio/adc/Makefile
@@ -25,6 +25,7 @@ obj-$(CONFIG_HI8435) += hi8435.o
 obj-$(CONFIG_IMX7D_ADC) += imx7d_adc.o
 obj-$(CONFIG_INA2XX_ADC) += ina2xx-adc.o
 obj-$(CONFIG_LP8788_ADC) += lp8788_adc.o
+obj-$(CONFIG_LPC18XX_ADC) += lpc18xx_adc.o
 obj-$(CONFIG_MAX1027) += max1027.o
 obj-$(CONFIG_MAX1363) += max1363.o
 obj-$(CONFIG_MCP320X) += mcp320x.o
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-sama5d2_adc.c b/drivers/iio/adc/at91-sama5d2_adc.c
index 2e154cb51685..e10dca3ed74b 100644
--- a/drivers/iio/adc/at91-sama5d2_adc.c
+++ b/drivers/iio/adc/at91-sama5d2_adc.c
@@ -66,8 +66,10 @@
 #define AT91_SAMA5D2_MR_PRESCAL(v)      ((v) << AT91_SAMA5D2_MR_PRESCAL_OFFSET)
 #define AT91_SAMA5D2_MR_PRESCAL_OFFSET  8
 #define AT91_SAMA5D2_MR_PRESCAL_MAX     0xff
+#define AT91_SAMA5D2_MR_PRESCAL_MASK    GENMASK(15, 8)
 /* Startup Time */
 #define AT91_SAMA5D2_MR_STARTUP(v)      ((v) << 16)
+#define AT91_SAMA5D2_MR_STARTUP_MASK    GENMASK(19, 16)
 /* Analog Change */
 #define AT91_SAMA5D2_MR_ANACH           BIT(23)
 /* Tracking Time */
@@ -92,13 +94,13 @@
 /* Last Converted Data Register */
 #define AT91_SAMA5D2_LCDR       0x20
 /* Interrupt Enable Register */
-#define AT91_SAMA5D2_IER                0x24
+#define AT91_SAMA5D2_IER        0x24
 /* Interrupt Disable Register */
-#define AT91_SAMA5D2_IDR                0x28
+#define AT91_SAMA5D2_IDR        0x28
 /* Interrupt Mask Register */
-#define AT91_SAMA5D2_IMR                0x2c
+#define AT91_SAMA5D2_IMR        0x2c
 /* Interrupt Status Register */
-#define AT91_SAMA5D2_ISR                0x30
+#define AT91_SAMA5D2_ISR        0x30
 /* Last Channel Trigger Mode Register */
 #define AT91_SAMA5D2_LCTMR      0x34
 /* Last Channel Compare Window Register */
@@ -106,17 +108,20 @@
 /* Overrun Status Register */
 #define AT91_SAMA5D2_OVER       0x3c
 /* Extended Mode Register */
-#define AT91_SAMA5D2_EMR                0x40
+#define AT91_SAMA5D2_EMR        0x40
 /* Compare Window Register */
-#define AT91_SAMA5D2_CWR                0x44
+#define AT91_SAMA5D2_CWR        0x44
 /* Channel Gain Register */
-#define AT91_SAMA5D2_CGR                0x48
+#define AT91_SAMA5D2_CGR        0x48
+
 /* Channel Offset Register */
-#define AT91_SAMA5D2_COR                0x4c
+#define AT91_SAMA5D2_COR        0x4c
+#define AT91_SAMA5D2_COR_DIFF_OFFSET    16
+
 /* Channel Data Register 0 */
 #define AT91_SAMA5D2_CDR0       0x50
 /* Analog Control Register */
-#define AT91_SAMA5D2_ACR                0x94
+#define AT91_SAMA5D2_ACR        0x94
 /* Touchscreen Mode Register */
 #define AT91_SAMA5D2_TSMR       0xb0
 /* Touchscreen X Position Register */
@@ -130,7 +135,7 @@
 /* Correction Select Register */
 #define AT91_SAMA5D2_COSR       0xd0
 /* Correction Value Register */
-#define AT91_SAMA5D2_CVR                0xd4
+#define AT91_SAMA5D2_CVR        0xd4
 /* Channel Error Correction Register */
 #define AT91_SAMA5D2_CECR       0xd8
 /* Write Protection Mode Register */
@@ -140,7 +145,7 @@
 /* Version Register */
 #define AT91_SAMA5D2_VERSION    0xfc
 
-#define AT91_AT91_SAMA5D2_CHAN(num, addr)                               \
+#define AT91_SAMA5D2_CHAN_SINGLE(num, addr)                             \
         {                                                               \
                 .type = IIO_VOLTAGE,                                    \
                 .channel = num,                                         \
@@ -156,6 +161,24 @@
                 .indexed = 1,                                           \
         }
 
+#define AT91_SAMA5D2_CHAN_DIFF(num, num2, addr)                         \
+        {                                                               \
+                .type = IIO_VOLTAGE,                                    \
+                .differential = 1,                                      \
+                .channel = num,                                         \
+                .channel2 = num2,                                       \
+                .address = addr,                                        \
+                .scan_type = {                                          \
+                        .sign = 's',                                    \
+                        .realbits = 12,                                 \
+                },                                                      \
+                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),           \
+                .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),   \
+                .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ),\
+                .datasheet_name = "CH"#num"-CH"#num2,                   \
+                .indexed = 1,                                           \
+        }
+
 #define at91_adc_readl(st, reg)         readl_relaxed(st->base + reg)
 #define at91_adc_writel(st, reg, val)   writel_relaxed(val, st->base + reg)
 
@@ -185,18 +208,24 @@ struct at91_adc_state {
 };
 
 static const struct iio_chan_spec at91_adc_channels[] = {
-        AT91_AT91_SAMA5D2_CHAN(0, 0x50),
-        AT91_AT91_SAMA5D2_CHAN(1, 0x54),
-        AT91_AT91_SAMA5D2_CHAN(2, 0x58),
-        AT91_AT91_SAMA5D2_CHAN(3, 0x5c),
-        AT91_AT91_SAMA5D2_CHAN(4, 0x60),
-        AT91_AT91_SAMA5D2_CHAN(5, 0x64),
-        AT91_AT91_SAMA5D2_CHAN(6, 0x68),
-        AT91_AT91_SAMA5D2_CHAN(7, 0x6c),
-        AT91_AT91_SAMA5D2_CHAN(8, 0x70),
-        AT91_AT91_SAMA5D2_CHAN(9, 0x74),
-        AT91_AT91_SAMA5D2_CHAN(10, 0x78),
-        AT91_AT91_SAMA5D2_CHAN(11, 0x7c),
+        AT91_SAMA5D2_CHAN_SINGLE(0, 0x50),
+        AT91_SAMA5D2_CHAN_SINGLE(1, 0x54),
+        AT91_SAMA5D2_CHAN_SINGLE(2, 0x58),
+        AT91_SAMA5D2_CHAN_SINGLE(3, 0x5c),
+        AT91_SAMA5D2_CHAN_SINGLE(4, 0x60),
+        AT91_SAMA5D2_CHAN_SINGLE(5, 0x64),
+        AT91_SAMA5D2_CHAN_SINGLE(6, 0x68),
+        AT91_SAMA5D2_CHAN_SINGLE(7, 0x6c),
+        AT91_SAMA5D2_CHAN_SINGLE(8, 0x70),
+        AT91_SAMA5D2_CHAN_SINGLE(9, 0x74),
+        AT91_SAMA5D2_CHAN_SINGLE(10, 0x78),
+        AT91_SAMA5D2_CHAN_SINGLE(11, 0x7c),
+        AT91_SAMA5D2_CHAN_DIFF(0, 1, 0x50),
+        AT91_SAMA5D2_CHAN_DIFF(2, 3, 0x58),
+        AT91_SAMA5D2_CHAN_DIFF(4, 5, 0x60),
+        AT91_SAMA5D2_CHAN_DIFF(6, 7, 0x68),
+        AT91_SAMA5D2_CHAN_DIFF(8, 9, 0x70),
+        AT91_SAMA5D2_CHAN_DIFF(10, 11, 0x78),
 };
 
 static unsigned at91_adc_startup_time(unsigned startup_time_min,
@@ -226,7 +255,7 @@ static unsigned at91_adc_startup_time(unsigned startup_time_min,
 static void at91_adc_setup_samp_freq(struct at91_adc_state *st, unsigned freq)
 {
         struct iio_dev *indio_dev = iio_priv_to_dev(st);
-        unsigned f_per, prescal, startup;
+        unsigned f_per, prescal, startup, mr;
 
         f_per = clk_get_rate(st->per_clk);
         prescal = (f_per / (2 * freq)) - 1;
@@ -234,10 +263,11 @@ static void at91_adc_setup_samp_freq(struct at91_adc_state *st, unsigned freq)
         startup = at91_adc_startup_time(st->soc_info.startup_time,
                                         freq / 1000);
 
-        at91_adc_writel(st, AT91_SAMA5D2_MR,
-                        AT91_SAMA5D2_MR_TRANSFER(2)
-                        | AT91_SAMA5D2_MR_STARTUP(startup)
-                        | AT91_SAMA5D2_MR_PRESCAL(prescal));
+        mr = at91_adc_readl(st, AT91_SAMA5D2_MR);
+        mr &= ~(AT91_SAMA5D2_MR_STARTUP_MASK | AT91_SAMA5D2_MR_PRESCAL_MASK);
+        mr |= AT91_SAMA5D2_MR_STARTUP(startup);
+        mr |= AT91_SAMA5D2_MR_PRESCAL(prescal);
+        at91_adc_writel(st, AT91_SAMA5D2_MR, mr);
 
         dev_dbg(&indio_dev->dev, "freq: %u, startup: %u, prescal: %u\n",
                 freq, startup, prescal);
@@ -278,6 +308,7 @@ static int at91_adc_read_raw(struct iio_dev *indio_dev,
                              int *val, int *val2, long mask)
 {
         struct at91_adc_state *st = iio_priv(indio_dev);
+        u32 cor = 0;
         int ret;
 
         switch (mask) {
@@ -286,6 +317,11 @@ static int at91_adc_read_raw(struct iio_dev *indio_dev,
 
                 st->chan = chan;
 
+                if (chan->differential)
+                        cor = (BIT(chan->channel) | BIT(chan->channel2)) <<
+                              AT91_SAMA5D2_COR_DIFF_OFFSET;
+
+                at91_adc_writel(st, AT91_SAMA5D2_COR, cor);
                 at91_adc_writel(st, AT91_SAMA5D2_CHER, BIT(chan->channel));
                 at91_adc_writel(st, AT91_SAMA5D2_IER, BIT(chan->channel));
                 at91_adc_writel(st, AT91_SAMA5D2_CR, AT91_SAMA5D2_CR_START);
@@ -298,6 +334,8 @@ static int at91_adc_read_raw(struct iio_dev *indio_dev,
 
                 if (ret > 0) {
                         *val = st->conversion_value;
+                        if (chan->scan_type.sign == 's')
+                                *val = sign_extend32(*val, 11);
                         ret = IIO_VAL_INT;
                         st->conversion_done = false;
                 }
@@ -310,6 +348,8 @@ static int at91_adc_read_raw(struct iio_dev *indio_dev,
 
         case IIO_CHAN_INFO_SCALE:
                 *val = st->vref_uv / 1000;
+                if (chan->differential)
+                        *val *= 2;
                 *val2 = chan->scan_type.realbits;
                 return IIO_VAL_FRACTIONAL_LOG2;
 
@@ -444,6 +484,12 @@ static int at91_adc_probe(struct platform_device *pdev)
 
         at91_adc_writel(st, AT91_SAMA5D2_CR, AT91_SAMA5D2_CR_SWRST);
         at91_adc_writel(st, AT91_SAMA5D2_IDR, 0xffffffff);
+        /*
+         * Transfer field must be set to 2 according to the datasheet and
+         * allows different analog settings for each channel.
+         */
+        at91_adc_writel(st, AT91_SAMA5D2_MR,
+                        AT91_SAMA5D2_MR_TRANSFER(2) | AT91_SAMA5D2_MR_ANACH);
 
         at91_adc_setup_samp_freq(st, st->soc_info.min_sample_rate);
 
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 ,
-                64 , 80 , 96 , 112,
+                0,   8,   16,  24,
+                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/ina2xx-adc.c b/drivers/iio/adc/ina2xx-adc.c
index 65909d5858b1..502f2fbe8aef 100644
--- a/drivers/iio/adc/ina2xx-adc.c
+++ b/drivers/iio/adc/ina2xx-adc.c
@@ -185,9 +185,9 @@ static int ina2xx_read_raw(struct iio_dev *indio_dev,
         case IIO_CHAN_INFO_SCALE:
                 switch (chan->address) {
                 case INA2XX_SHUNT_VOLTAGE:
-                        /* processed (mV) = raw*1000/shunt_div */
+                        /* processed (mV) = raw/shunt_div */
                         *val2 = chip->config->shunt_div;
-                        *val = 1000;
+                        *val = 1;
                         return IIO_VAL_FRACTIONAL;
 
                 case INA2XX_BUS_VOLTAGE:
@@ -350,6 +350,23 @@ static ssize_t ina2xx_allow_async_readout_store(struct device *dev,
         return len;
 }
 
+/*
+ * Set current LSB to 1mA, shunt is in uOhms
+ * (equation 13 in datasheet). We hardcode a Current_LSB
+ * of 1.0 x10-6. The only remaining parameter is RShunt.
+ * There is no need to expose the CALIBRATION register
+ * to the user for now. But we need to reset this register
+ * if the user updates RShunt after driver init, e.g upon
+ * reading an EEPROM/Probe-type value.
+ */
+static int ina2xx_set_calibration(struct ina2xx_chip_info *chip)
+{
+        u16 regval = DIV_ROUND_CLOSEST(chip->config->calibration_factor,
+                                   chip->shunt_resistor);
+
+        return regmap_write(chip->regmap, INA2XX_CALIBRATION, regval);
+}
+
 static int set_shunt_resistor(struct ina2xx_chip_info *chip, unsigned int val)
 {
         if (val <= 0 || val > chip->config->calibration_factor)
@@ -385,6 +402,11 @@ static ssize_t ina2xx_shunt_resistor_store(struct device *dev,
         if (ret)
                 return ret;
 
+        /* Update the Calibration register */
+        ret = ina2xx_set_calibration(chip);
+        if (ret)
+                return ret;
+
         return len;
 }
 
@@ -602,24 +624,11 @@ static const struct iio_info ina2xx_info = {
 /* Initialize the configuration and calibration registers. */
 static int ina2xx_init(struct ina2xx_chip_info *chip, unsigned int config)
 {
-        u16 regval;
-        int ret;
-
-        ret = regmap_write(chip->regmap, INA2XX_CONFIG, config);
+        int ret = regmap_write(chip->regmap, INA2XX_CONFIG, config);
         if (ret)
                 return ret;
 
-        /*
-         * Set current LSB to 1mA, shunt is in uOhms
-         * (equation 13 in datasheet). We hardcode a Current_LSB
-         * of 1.0 x10-6. The only remaining parameter is RShunt.
-         * There is no need to expose the CALIBRATION register
-         * to the user for now.
-         */
-        regval = DIV_ROUND_CLOSEST(chip->config->calibration_factor,
-                                   chip->shunt_resistor);
-
-        return regmap_write(chip->regmap, INA2XX_CALIBRATION, regval);
+        return ina2xx_set_calibration(chip);
 }
 
 static int ina2xx_probe(struct i2c_client *client,
diff --git a/drivers/iio/adc/lpc18xx_adc.c b/drivers/iio/adc/lpc18xx_adc.c
new file mode 100644
index 000000000000..3ef18f4b27f0
--- /dev/null
+++ b/drivers/iio/adc/lpc18xx_adc.c
@@ -0,0 +1,231 @@
+/*
+ * IIO ADC driver for NXP LPC18xx ADC
+ *
+ * Copyright (C) 2016 Joachim Eastwood <manabian@gmail.com>
+ *
+ * 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.
+ *
+ * UNSUPPORTED hardware features:
+ *  - Hardware triggers
+ *  - Burst mode
+ *  - Interrupts
+ *  - DMA
+ */
+
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/iio/iio.h>
+#include <linux/iio/driver.h>
+#include <linux/io.h>
+#include <linux/iopoll.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/consumer.h>
+
+/* LPC18XX ADC registers and bits */
+#define LPC18XX_ADC_CR                  0x000
+#define  LPC18XX_ADC_CR_CLKDIV_SHIFT    8
+#define  LPC18XX_ADC_CR_PDN             BIT(21)
+#define  LPC18XX_ADC_CR_START_NOW       (0x1 << 24)
+#define LPC18XX_ADC_GDR                 0x004
+
+/* Data register bits */
+#define LPC18XX_ADC_SAMPLE_SHIFT        6
+#define LPC18XX_ADC_SAMPLE_MASK         0x3ff
+#define LPC18XX_ADC_CONV_DONE           BIT(31)
+
+/* Clock should be 4.5 MHz or less */
+#define LPC18XX_ADC_CLK_TARGET          4500000
+
+struct lpc18xx_adc {
+        struct regulator *vref;
+        void __iomem *base;
+        struct device *dev;
+        struct mutex lock;
+        struct clk *clk;
+        u32 cr_reg;
+};
+
+#define LPC18XX_ADC_CHAN(_idx) {                                \
+        .type = IIO_VOLTAGE,                                    \
+        .indexed = 1,                                           \
+        .channel = _idx,                                        \
+        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),           \
+        .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),   \
+}
+
+static const struct iio_chan_spec lpc18xx_adc_iio_channels[] = {
+        LPC18XX_ADC_CHAN(0),
+        LPC18XX_ADC_CHAN(1),
+        LPC18XX_ADC_CHAN(2),
+        LPC18XX_ADC_CHAN(3),
+        LPC18XX_ADC_CHAN(4),
+        LPC18XX_ADC_CHAN(5),
+        LPC18XX_ADC_CHAN(6),
+        LPC18XX_ADC_CHAN(7),
+};
+
+static int lpc18xx_adc_read_chan(struct lpc18xx_adc *adc, unsigned int ch)
+{
+        int ret;
+        u32 reg;
+
+        reg = adc->cr_reg | BIT(ch) | LPC18XX_ADC_CR_START_NOW;
+        writel(reg, adc->base + LPC18XX_ADC_CR);
+
+        ret = readl_poll_timeout(adc->base + LPC18XX_ADC_GDR, reg,
+                                 reg & LPC18XX_ADC_CONV_DONE, 3, 9);
+        if (ret) {
+                dev_warn(adc->dev, "adc read timed out\n");
+                return ret;
+        }
+
+        return (reg >> LPC18XX_ADC_SAMPLE_SHIFT) & LPC18XX_ADC_SAMPLE_MASK;
+}
+
+static int lpc18xx_adc_read_raw(struct iio_dev *indio_dev,
+                                struct iio_chan_spec const *chan,
+                                int *val, int *val2, long mask)
+{
+        struct lpc18xx_adc *adc = iio_priv(indio_dev);
+
+        switch (mask) {
+        case IIO_CHAN_INFO_RAW:
+                mutex_lock(&adc->lock);
+                *val = lpc18xx_adc_read_chan(adc, chan->channel);
+                mutex_unlock(&adc->lock);
+                if (*val < 0)
+                        return *val;
+
+                return IIO_VAL_INT;
+
+        case IIO_CHAN_INFO_SCALE:
+                *val = regulator_get_voltage(adc->vref) / 1000;
+                *val2 = 10;
+
+                return IIO_VAL_FRACTIONAL_LOG2;
+        }
+
+        return -EINVAL;
+}
+
+static const struct iio_info lpc18xx_adc_info = {
+        .read_raw = lpc18xx_adc_read_raw,
+        .driver_module = THIS_MODULE,
+};
+
+static int lpc18xx_adc_probe(struct platform_device *pdev)
+{
+        struct iio_dev *indio_dev;
+        struct lpc18xx_adc *adc;
+        struct resource *res;
+        unsigned int clkdiv;
+        unsigned long rate;
+        int ret;
+
+        indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*adc));
+        if (!indio_dev)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, indio_dev);
+        adc = iio_priv(indio_dev);
+        adc->dev = &pdev->dev;
+        mutex_init(&adc->lock);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        adc->base = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(adc->base))
+                return PTR_ERR(adc->base);
+
+        adc->clk = devm_clk_get(&pdev->dev, NULL);
+        if (IS_ERR(adc->clk)) {
+                dev_err(&pdev->dev, "error getting clock\n");
+                return PTR_ERR(adc->clk);
+        }
+
+        rate = clk_get_rate(adc->clk);
+        clkdiv = DIV_ROUND_UP(rate, LPC18XX_ADC_CLK_TARGET);
+
+        adc->vref = devm_regulator_get(&pdev->dev, "vref");
+        if (IS_ERR(adc->vref)) {
+                dev_err(&pdev->dev, "error getting regulator\n");
+                return PTR_ERR(adc->vref);
+        }
+
+        indio_dev->name = dev_name(&pdev->dev);
+        indio_dev->dev.parent = &pdev->dev;
+        indio_dev->info = &lpc18xx_adc_info;
+        indio_dev->modes = INDIO_DIRECT_MODE;
+        indio_dev->channels = lpc18xx_adc_iio_channels;
+        indio_dev->num_channels = ARRAY_SIZE(lpc18xx_adc_iio_channels);
+
+        ret = regulator_enable(adc->vref);
+        if (ret) {
+                dev_err(&pdev->dev, "unable to enable regulator\n");
+                return ret;
+        }
+
+        ret = clk_prepare_enable(adc->clk);
+        if (ret) {
+                dev_err(&pdev->dev, "unable to enable clock\n");
+                goto dis_reg;
+        }
+
+        adc->cr_reg = (clkdiv << LPC18XX_ADC_CR_CLKDIV_SHIFT) |
+                        LPC18XX_ADC_CR_PDN;
+        writel(adc->cr_reg, adc->base + LPC18XX_ADC_CR);
+
+        ret = iio_device_register(indio_dev);
+        if (ret) {
+                dev_err(&pdev->dev, "unable to register device\n");
+                goto dis_clk;
+        }
+
+        return 0;
+
+dis_clk:
+        writel(0, adc->base + LPC18XX_ADC_CR);
+        clk_disable_unprepare(adc->clk);
+dis_reg:
+        regulator_disable(adc->vref);
+        return ret;
+}
+
+static int lpc18xx_adc_remove(struct platform_device *pdev)
+{
+        struct iio_dev *indio_dev = platform_get_drvdata(pdev);
+        struct lpc18xx_adc *adc = iio_priv(indio_dev);
+
+        iio_device_unregister(indio_dev);
+
+        writel(0, adc->base + LPC18XX_ADC_CR);
+        clk_disable_unprepare(adc->clk);
+        regulator_disable(adc->vref);
+
+        return 0;
+}
+
+static const struct of_device_id lpc18xx_adc_match[] = {
+        { .compatible = "nxp,lpc1850-adc" },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, lpc18xx_adc_match);
+
+static struct platform_driver lpc18xx_adc_driver = {
+        .probe  = lpc18xx_adc_probe,
+        .remove = lpc18xx_adc_remove,
+        .driver = {
+                .name = "lpc18xx-adc",
+                .of_match_table = lpc18xx_adc_match,
+        },
+};
+module_platform_driver(lpc18xx_adc_driver);
+
+MODULE_DESCRIPTION("LPC18xx ADC driver");
+MODULE_AUTHOR("Joachim Eastwood <manabian@gmail.com>");
+MODULE_LICENSE("GPL v2");
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  },
-        { 62500  , 31250 , 15625 , 7812   },
-        { 15625  , 7812  , 3906  , 1953   } };
+        { 250000,  125000, 62500,  31250  },
+        { 62500,   31250,  15625,  7812   },
+        { 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 = mxs_lradc_hw_init(lradc);
+        ret = stmp_reset_block(lradc->base);
         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/rockchip_saradc.c b/drivers/iio/adc/rockchip_saradc.c
index 9c311c1e1ac7..f9ad6c2d6821 100644
--- a/drivers/iio/adc/rockchip_saradc.c
+++ b/drivers/iio/adc/rockchip_saradc.c
@@ -159,6 +159,22 @@ static const struct rockchip_saradc_data rk3066_tsadc_data = {
         .clk_rate = 50000,
 };
 
+static const struct iio_chan_spec rockchip_rk3399_saradc_iio_channels[] = {
+        ADC_CHANNEL(0, "adc0"),
+        ADC_CHANNEL(1, "adc1"),
+        ADC_CHANNEL(2, "adc2"),
+        ADC_CHANNEL(3, "adc3"),
+        ADC_CHANNEL(4, "adc4"),
+        ADC_CHANNEL(5, "adc5"),
+};
+
+static const struct rockchip_saradc_data rk3399_saradc_data = {
+        .num_bits = 10,
+        .channels = rockchip_rk3399_saradc_iio_channels,
+        .num_channels = ARRAY_SIZE(rockchip_rk3399_saradc_iio_channels),
+        .clk_rate = 1000000,
+};
+
 static const struct of_device_id rockchip_saradc_match[] = {
         {
                 .compatible = "rockchip,saradc",
@@ -166,6 +182,9 @@ static const struct of_device_id rockchip_saradc_match[] = {
         }, {
                 .compatible = "rockchip,rk3066-tsadc",
                 .data = &rk3066_tsadc_data,
+        }, {
+                .compatible = "rockchip,rk3399-saradc",
+                .data = &rk3399_saradc_data,
         },
         {},
 };
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 = {
-        .type = IIO_VOLTAGE,
-        .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
-        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
+#define ADCxx1C_CHAN(_bits) {                                   \
+        .type = IIO_VOLTAGE,                                    \
+        .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),   \
+        .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->num_channels = 1;
+        iio->channels = model->channels;
+        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:
-                        for (i = 0;
-                                i < ARRAY_SIZE(info->sample_freq_avail);
-                                i++)
-                                if (val == info->sample_freq_avail[i]) {
-                                        info->adc_feature.sample_rate = i;
-                                        vf610_adc_sample_set(info);
-                                        return 0;
-                                }
-                        break;
+        case IIO_CHAN_INFO_SAMP_FREQ:
+                for (i = 0;
+                        i < ARRAY_SIZE(info->sample_freq_avail);
+                        i++)
+                        if (val == info->sample_freq_avail[i]) {
+                                info->adc_feature.sample_rate = i;
+                                vf610_adc_sample_set(info);
+                                return 0;
+                        }
+                break;
 
-                default:
-                        break;
+        default:
+                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 e18bc6782256..c55898543a47 100644
--- a/drivers/iio/common/st_sensors/st_sensors_buffer.c
+++ b/drivers/iio/common/st_sensors/st_sensors_buffer.c
@@ -24,81 +24,30 @@
 
 int st_sensors_get_buffer_element(struct iio_dev *indio_dev, u8 *buf)
 {
-        u8 *addr;
-        int i, n = 0, len;
+        int i, 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;
-
-        addr = kmalloc(num_data_channels, GFP_KERNEL);
-        if (!addr) {
-                len = -ENOMEM;
-                goto st_sensors_get_buffer_element_error;
-        }
 
         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;
-                        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) {
+                        bytes_to_read = indio_dev->channels[i].scan_type.storagebits >> 3;
                         len = sdata->tf->read_multiple_byte(&sdata->tb,
-                                sdata->dev, addr[0], byte_for_channel * n,
-                                buf, sdata->multiread_bit);
-                } else {
-                        u8 *rx_array;
-                        rx_array = kmalloc(byte_for_channel * num_data_channels,
-                                           GFP_KERNEL);
-                        if (!rx_array) {
-                                len = -ENOMEM;
-                                goto st_sensors_free_memory;
-                        }
+                                sdata->dev, indio_dev->channels[i].address,
+                                bytes_to_read,
+                                buf + total, sdata->multiread_bit);
 
-                        len = sdata->tf->read_multiple_byte(&sdata->tb,
-                                sdata->dev, addr[0],
-                                byte_for_channel * num_data_channels,
-                                rx_array, sdata->multiread_bit);
-                        if (len < 0) {
-                                kfree(rx_array);
-                                goto st_sensors_free_memory;
-                        }
-
-                        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;
+                        if (len < bytes_to_read)
+                                return -EIO;
+
+                        /* Advance the buffer pointer */
+                        total += len;
                 }
-                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:
-                len = -EINVAL;
-                goto st_sensors_free_memory;
-        }
-        if (len != byte_for_channel * n) {
-                len = -EIO;
-                goto st_sensors_free_memory;
         }
 
-st_sensors_free_memory:
-        kfree(addr);
-st_sensors_get_buffer_element_error:
-        return len;
+        return total;
 }
 EXPORT_SYMBOL(st_sensors_get_buffer_element);
 
@@ -109,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 6abcfb8597d9..e63b957c985f 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
@@ -154,6 +181,16 @@ config AD7303
           To compile this driver as module choose M here: the module will be called
           ad7303.
 
+config LPC18XX_DAC
+        tristate "NXP LPC18xx DAC driver"
+        depends on ARCH_LPC18XX || COMPILE_TEST
+        depends on OF && HAS_IOMEM
+        help
+          Say yes here to build support for NXP LPC18XX DAC.
+
+          To compile this driver as a module, choose M here: the module will be
+          called lpc18xx_dac.
+
 config M62332
         tristate "Mitsubishi M62332 DAC driver"
         depends on I2C
diff --git a/drivers/iio/dac/Makefile b/drivers/iio/dac/Makefile
index 67b48429686d..8b78d5ca9b11 100644
--- a/drivers/iio/dac/Makefile
+++ b/drivers/iio/dac/Makefile
@@ -11,12 +11,16 @@ 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
 obj-$(CONFIG_AD5791) += ad5791.o
 obj-$(CONFIG_AD5686) += ad5686.o
 obj-$(CONFIG_AD7303) += ad7303.o
+obj-$(CONFIG_LPC18XX_DAC) += lpc18xx_dac.o
 obj-$(CONFIG_M62332) += m62332.o
 obj-$(CONFIG_MAX517) += max517.o
 obj-$(CONFIG_MAX5821) += max5821.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/dac/lpc18xx_dac.c b/drivers/iio/dac/lpc18xx_dac.c
new file mode 100644
index 000000000000..55d1456a059d
--- /dev/null
+++ b/drivers/iio/dac/lpc18xx_dac.c
@@ -0,0 +1,210 @@
+/*
+ * IIO DAC driver for NXP LPC18xx DAC
+ *
+ * Copyright (C) 2016 Joachim Eastwood <manabian@gmail.com>
+ *
+ * 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.
+ *
+ * UNSUPPORTED hardware features:
+ *  - Interrupts
+ *  - DMA
+ */
+
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/iio/iio.h>
+#include <linux/iio/driver.h>
+#include <linux/io.h>
+#include <linux/iopoll.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/consumer.h>
+
+/* LPC18XX DAC registers and bits */
+#define LPC18XX_DAC_CR                  0x000
+#define  LPC18XX_DAC_CR_VALUE_SHIFT     6
+#define  LPC18XX_DAC_CR_VALUE_MASK      0x3ff
+#define  LPC18XX_DAC_CR_BIAS            BIT(16)
+#define LPC18XX_DAC_CTRL                0x004
+#define  LPC18XX_DAC_CTRL_DMA_ENA       BIT(3)
+
+struct lpc18xx_dac {
+        struct regulator *vref;
+        void __iomem *base;
+        struct mutex lock;
+        struct clk *clk;
+};
+
+static const struct iio_chan_spec lpc18xx_dac_iio_channels[] = {
+        {
+                .type = IIO_VOLTAGE,
+                .output = 1,
+                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
+                                      BIT(IIO_CHAN_INFO_SCALE),
+        },
+};
+
+static int lpc18xx_dac_read_raw(struct iio_dev *indio_dev,
+                                struct iio_chan_spec const *chan,
+                                int *val, int *val2, long mask)
+{
+        struct lpc18xx_dac *dac = iio_priv(indio_dev);
+        u32 reg;
+
+        switch (mask) {
+        case IIO_CHAN_INFO_RAW:
+                reg = readl(dac->base + LPC18XX_DAC_CR);
+                *val = reg >> LPC18XX_DAC_CR_VALUE_SHIFT;
+                *val &= LPC18XX_DAC_CR_VALUE_MASK;
+
+                return IIO_VAL_INT;
+
+        case IIO_CHAN_INFO_SCALE:
+                *val = regulator_get_voltage(dac->vref) / 1000;
+                *val2 = 10;
+
+                return IIO_VAL_FRACTIONAL_LOG2;
+        }
+
+        return -EINVAL;
+}
+
+static int lpc18xx_dac_write_raw(struct iio_dev *indio_dev,
+                                 struct iio_chan_spec const *chan,
+                                 int val, int val2, long mask)
+{
+        struct lpc18xx_dac *dac = iio_priv(indio_dev);
+        u32 reg;
+
+        switch (mask) {
+        case IIO_CHAN_INFO_RAW:
+                if (val < 0 || val > LPC18XX_DAC_CR_VALUE_MASK)
+                        return -EINVAL;
+
+                reg = LPC18XX_DAC_CR_BIAS;
+                reg |= val << LPC18XX_DAC_CR_VALUE_SHIFT;
+
+                mutex_lock(&dac->lock);
+                writel(reg, dac->base + LPC18XX_DAC_CR);
+                writel(LPC18XX_DAC_CTRL_DMA_ENA, dac->base + LPC18XX_DAC_CTRL);
+                mutex_unlock(&dac->lock);
+
+                return 0;
+        }
+
+        return -EINVAL;
+}
+
+static const struct iio_info lpc18xx_dac_info = {
+        .read_raw = lpc18xx_dac_read_raw,
+        .write_raw = lpc18xx_dac_write_raw,
+        .driver_module = THIS_MODULE,
+};
+
+static int lpc18xx_dac_probe(struct platform_device *pdev)
+{
+        struct iio_dev *indio_dev;
+        struct lpc18xx_dac *dac;
+        struct resource *res;
+        int ret;
+
+        indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*dac));
+        if (!indio_dev)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, indio_dev);
+        dac = iio_priv(indio_dev);
+        mutex_init(&dac->lock);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        dac->base = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(dac->base))
+                return PTR_ERR(dac->base);
+
+        dac->clk = devm_clk_get(&pdev->dev, NULL);
+        if (IS_ERR(dac->clk)) {
+                dev_err(&pdev->dev, "error getting clock\n");
+                return PTR_ERR(dac->clk);
+        }
+
+        dac->vref = devm_regulator_get(&pdev->dev, "vref");
+        if (IS_ERR(dac->vref)) {
+                dev_err(&pdev->dev, "error getting regulator\n");
+                return PTR_ERR(dac->vref);
+        }
+
+        indio_dev->name = dev_name(&pdev->dev);
+        indio_dev->dev.parent = &pdev->dev;
+        indio_dev->info = &lpc18xx_dac_info;
+        indio_dev->modes = INDIO_DIRECT_MODE;
+        indio_dev->channels = lpc18xx_dac_iio_channels;
+        indio_dev->num_channels = ARRAY_SIZE(lpc18xx_dac_iio_channels);
+
+        ret = regulator_enable(dac->vref);
+        if (ret) {
+                dev_err(&pdev->dev, "unable to enable regulator\n");
+                return ret;
+        }
+
+        ret = clk_prepare_enable(dac->clk);
+        if (ret) {
+                dev_err(&pdev->dev, "unable to enable clock\n");
+                goto dis_reg;
+        }
+
+        writel(0, dac->base + LPC18XX_DAC_CTRL);
+        writel(0, dac->base + LPC18XX_DAC_CR);
+
+        ret = iio_device_register(indio_dev);
+        if (ret) {
+                dev_err(&pdev->dev, "unable to register device\n");
+                goto dis_clk;
+        }
+
+        return 0;
+
+dis_clk:
+        clk_disable_unprepare(dac->clk);
+dis_reg:
+        regulator_disable(dac->vref);
+        return ret;
+}
+
+static int lpc18xx_dac_remove(struct platform_device *pdev)
+{
+        struct iio_dev *indio_dev = platform_get_drvdata(pdev);
+        struct lpc18xx_dac *dac = iio_priv(indio_dev);
+
+        iio_device_unregister(indio_dev);
+
+        writel(0, dac->base + LPC18XX_DAC_CTRL);
+        clk_disable_unprepare(dac->clk);
+        regulator_disable(dac->vref);
+
+        return 0;
+}
+
+static const struct of_device_id lpc18xx_dac_match[] = {
+        { .compatible = "nxp,lpc1850-dac" },
+        { /* sentinel */ }
+};
+MODULE_DEVICE_TABLE(of, lpc18xx_dac_match);
+
+static struct platform_driver lpc18xx_dac_driver = {
+        .probe  = lpc18xx_dac_probe,
+        .remove = lpc18xx_dac_remove,
+        .driver = {
+                .name = "lpc18xx-dac",
+                .of_match_table = lpc18xx_dac_match,
+        },
+};
+module_platform_driver(lpc18xx_dac_driver);
+
+MODULE_DESCRIPTION("LPC18xx DAC driver");
+MODULE_AUTHOR("Joachim Eastwood <manabian@gmail.com>");
+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 *readval)
+                              unsigned int reg, unsigned int writeval,
+                              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 4dac567e75b4..7ccc044063f6 100644
--- a/drivers/iio/gyro/bmg160_core.c
+++ b/drivers/iio/gyro/bmg160_core.c
@@ -17,7 +17,6 @@
 #include <linux/delay.h>
 #include <linux/slab.h>
 #include <linux/acpi.h>
-#include <linux/gpio/consumer.h>
 #include <linux/pm.h>
 #include <linux/pm_runtime.h>
 #include <linux/iio/iio.h>
@@ -31,7 +30,6 @@
 #include "bmg160.h"
 
 #define BMG160_IRQ_NAME         "bmg160_event"
-#define BMG160_GPIO_NAME                "gpio_int"
 
 #define BMG160_REG_CHIP_ID              0x00
 #define BMG160_CHIP_ID_VAL              0x0F
@@ -97,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;
@@ -116,6 +113,7 @@ enum bmg160_axis {
         AXIS_X,
         AXIS_Y,
         AXIS_Z,
+        AXIS_MAX,
 };
 
 static const struct {
@@ -138,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;
         }
 
@@ -163,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;
 
@@ -172,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;
         }
 
@@ -183,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;
         }
 
@@ -213,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;
@@ -229,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;
         }
 
@@ -237,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;
         }
@@ -248,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);
-                ret = pm_runtime_put_autosuspend(data->dev);
+                pm_runtime_mark_last_busy(dev);
+                ret = pm_runtime_put_autosuspend(dev);
         }
 
         if (ret < 0) {
-                dev_err(data->dev,
-                        "Failed: bmg160_set_power_state for %d\n", on);
+                dev_err(dev, "Failed: bmg160_set_power_state for %d\n", on);
+
                 if (on)
-                        pm_runtime_put_noidle(data->dev);
+                        pm_runtime_put_noidle(dev);
 
                 return ret;
         }
@@ -273,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 */
@@ -280,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;
         }
 
@@ -290,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,
-                                "Error writing reg_slope_thres\n");
+                        dev_err(dev, "Error writing reg_slope_thres\n");
                         return ret;
                 }
 
@@ -299,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,
-                                "Error writing reg_motion_intr\n");
+                        dev_err(dev, "Error writing reg_motion_intr\n");
                         return ret;
                 }
 
@@ -315,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,
-                                        "Error writing reg_rst_latch\n");
+                                dev_err(dev, "Error writing reg_rst_latch\n");
                                 return ret;
                         }
                 }
@@ -329,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;
         }
 
@@ -339,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 */
@@ -346,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;
         }
 
@@ -355,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,
-                                "Error writing reg_rst_latch\n");
-                                return ret;
+                        dev_err(dev, "Error writing reg_rst_latch\n");
+                        return ret;
                 }
 
                 ret = regmap_write(data->regmap, BMG160_REG_INT_EN_0,
@@ -369,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,
-                                "Error writing reg_rst_latch\n");
-                                return ret;
+                        dev_err(dev, "Error writing reg_rst_latch\n");
+                        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;
         }
 
@@ -401,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) {
@@ -408,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,
-                                        "Error writing reg_range\n");
+                                dev_err(dev, "Error writing reg_range\n");
                                 return ret;
                         }
                         data->dps_range = bmg160_scale_table[i].dps_range;
@@ -422,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;
 
@@ -434,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;
@@ -451,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;
 
@@ -464,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;
@@ -764,26 +765,23 @@ static const struct iio_info bmg160_info = {
         .driver_module          = THIS_MODULE,
 };
 
+static const unsigned long bmg160_accel_scan_masks[] = {
+                                        BIT(AXIS_X) | BIT(AXIS_Y) | BIT(AXIS_Z),
+                                        0};
+
 static irqreturn_t bmg160_trigger_handler(int irq, void *p)
 {
         struct iio_poll_func *pf = p;
         struct iio_dev *indio_dev = pf->indio_dev;
         struct bmg160_data *data = iio_priv(indio_dev);
-        int bit, ret, i = 0;
-        unsigned int val;
+        int ret;
 
         mutex_lock(&data->mutex);
-        for_each_set_bit(bit, indio_dev->active_scan_mask,
-                         indio_dev->masklength) {
-                ret = regmap_bulk_read(data->regmap, BMG160_AXIS_TO_REG(bit),
-                                       &val, 2);
-                if (ret < 0) {
-                        mutex_unlock(&data->mutex);
-                        goto err;
-                }
-                data->buffer[i++] = val;
-        }
+        ret = regmap_bulk_read(data->regmap, BMG160_REG_XOUT_L,
+                               data->buffer, AXIS_MAX * 2);
         mutex_unlock(&data->mutex);
+        if (ret < 0)
+                goto err;
 
         iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
                                            pf->timestamp);
@@ -797,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 */
@@ -808,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;
         }
 
@@ -868,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;
         }
 
@@ -911,8 +911,7 @@ ack_intr_status:
                                    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 IRQ_HANDLED;
@@ -956,29 +955,6 @@ static const struct iio_buffer_setup_ops bmg160_buffer_setup_ops = {
         .postdisable = bmg160_buffer_postdisable,
 };
 
-static int bmg160_gpio_probe(struct bmg160_data *data)
-
-{
-        struct device *dev;
-        struct gpio_desc *gpio;
-
-        dev = data->dev;
-
-        /* data ready gpio interrupt pin */
-        gpio = devm_gpiod_get_index(dev, BMG160_GPIO_NAME, 0, GPIOD_IN);
-        if (IS_ERR(gpio)) {
-                dev_err(dev, "acpi gpio get index failed\n");
-                return PTR_ERR(gpio);
-        }
-
-        data->irq = gpiod_to_irq(gpio);
-
-        dev_dbg(dev, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio),
-                data->irq);
-
-        return 0;
-}
-
 static const char *bmg160_match_acpi_device(struct device *dev)
 {
         const struct acpi_device_id *id;
@@ -1003,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;
 
@@ -1020,12 +995,10 @@ int bmg160_core_probe(struct device *dev, struct regmap *regmap, int irq,
         indio_dev->channels = bmg160_channels;
         indio_dev->num_channels = ARRAY_SIZE(bmg160_channels);
         indio_dev->name = name;
+        indio_dev->available_scan_masks = bmg160_accel_scan_masks;
         indio_dev->modes = INDIO_DIRECT_MODE;
         indio_dev->info = &bmg160_info;
 
-        if (data->irq <= 0)
-                bmg160_gpio_probe(data);
-
         if (data->irq > 0) {
                 ret = devm_request_threaded_irq(dev,
                                                 data->irq,
@@ -1168,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)
-                        return -EIO;  /* lost synchronisation */
+                if (!dht11->edges[offset + 2 * i + 1].value) {
+                        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,
-                                "Only %d signal edges detected\n",
-                                        dht11->num_edges);
+                        dev_err(dht11->dev, "Only %d signal edges detected\n",
+                                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 can also support MPU6500 in MPU6050 compatibility mode
-          and also in MPU6500 mode with some limitations.
-          It is a gyroscope/accelerometer combo device.
+          This driver supports the Invensense MPU6050/6500/9150 motion tracking
+          devices over I2C.
           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.
-          It is a gyroscope/accelerometer combo device.
+          This driver supports the Invensense MPU6000/6500/9150 motion tracking
+          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 0c2bded2b5b7..ee40dae5ab58 100644
--- a/drivers/iio/imu/inv_mpu6050/inv_mpu_core.c
+++ b/drivers/iio/imu/inv_mpu6050/inv_mpu_core.c
@@ -87,16 +87,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,
-                .name = "MPU6050",
+                .whoami = INV_MPU6000_WHOAMI_VALUE,
+                .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,
         },
@@ -599,6 +612,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)
@@ -643,6 +660,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,                                        \
@@ -659,6 +688,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[] = {
@@ -691,14 +721,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_accel_matrix.dev_attr.attr,
+        &iio_dev_attr_in_gyro_matrix.dev_attr.attr,  /* deprecated */
+        &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,
@@ -725,6 +757,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;
@@ -735,6 +768,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
@@ -773,14 +817,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 9ba1179105bd..e1fd7fa53e3b 100644
--- a/drivers/iio/imu/inv_mpu6050/inv_mpu_i2c.c
+++ b/drivers/iio/imu/inv_mpu6050/inv_mpu_i2c.c
@@ -169,13 +169,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 bb3cef6d7059..3bf8544ccc9f 100644
--- a/drivers/iio/imu/inv_mpu6050/inv_mpu_iio.h
+++ b/drivers/iio/imu/inv_mpu6050/inv_mpu_iio.h
@@ -69,6 +69,7 @@ enum inv_devices {
         INV_MPU6050,
         INV_MPU6500,
         INV_MPU6000,
+        INV_MPU9150,
         INV_NUM_PARTS
 };
 
@@ -94,13 +95,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;
@@ -115,7 +116,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.
@@ -132,6 +134,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;
@@ -216,6 +219,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 char *name = id ? id->name : NULL;
-        const int chip_type = id ? id->driver_data : 0;
+        const struct spi_device_id *spi_id;
+        const struct acpi_device_id *acpi_id;
+        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/imu/kmx61.c b/drivers/iio/imu/kmx61.c
index e5306b4e020e..2e7dd5754a56 100644
--- a/drivers/iio/imu/kmx61.c
+++ b/drivers/iio/imu/kmx61.c
@@ -14,7 +14,6 @@
 #include <linux/module.h>
 #include <linux/i2c.h>
 #include <linux/acpi.h>
-#include <linux/gpio/consumer.h>
 #include <linux/interrupt.h>
 #include <linux/pm.h>
 #include <linux/pm_runtime.h>
diff --git a/drivers/iio/industrialio-core.c b/drivers/iio/industrialio-core.c
index 70cb7eb0a75c..e6319a9346b2 100644
--- a/drivers/iio/industrialio-core.c
+++ b/drivers/iio/industrialio-core.c
@@ -25,6 +25,7 @@
 #include <linux/slab.h>
 #include <linux/anon_inodes.h>
 #include <linux/debugfs.h>
+#include <linux/mutex.h>
 #include <linux/iio/iio.h>
 #include "iio_core.h"
 #include "iio_core_trigger.h"
@@ -78,6 +79,7 @@ static const char * const iio_chan_type_name_spec[] = {
         [IIO_CONCENTRATION] = "concentration",
         [IIO_RESISTANCE] = "resistance",
         [IIO_PH] = "ph",
+        [IIO_UVINDEX] = "uvindex",
 };
 
 static const char * const iio_modifier_names[] = {
@@ -100,6 +102,7 @@ static const char * const iio_modifier_names[] = {
         [IIO_MOD_LIGHT_RED] = "red",
         [IIO_MOD_LIGHT_GREEN] = "green",
         [IIO_MOD_LIGHT_BLUE] = "blue",
+        [IIO_MOD_LIGHT_UV] = "uv",
         [IIO_MOD_QUATERNION] = "quaternion",
         [IIO_MOD_TEMP_AMBIENT] = "ambient",
         [IIO_MOD_TEMP_OBJECT] = "object",
@@ -409,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
@@ -1375,6 +1460,44 @@ void devm_iio_device_unregister(struct device *dev, struct iio_dev *indio_dev)
 }
 EXPORT_SYMBOL_GPL(devm_iio_device_unregister);
 
+/**
+ * iio_device_claim_direct_mode - Keep device in direct mode
+ * @indio_dev:  the iio_dev associated with the device
+ *
+ * If the device is in direct mode it is guaranteed to stay
+ * that way until iio_device_release_direct_mode() is called.
+ *
+ * Use with iio_device_release_direct_mode()
+ *
+ * Returns: 0 on success, -EBUSY on failure
+ */
+int iio_device_claim_direct_mode(struct iio_dev *indio_dev)
+{
+        mutex_lock(&indio_dev->mlock);
+
+        if (iio_buffer_enabled(indio_dev)) {
+                mutex_unlock(&indio_dev->mlock);
+                return -EBUSY;
+        }
+        return 0;
+}
+EXPORT_SYMBOL_GPL(iio_device_claim_direct_mode);
+
+/**
+ * iio_device_release_direct_mode - releases claim on direct mode
+ * @indio_dev:  the iio_dev associated with the device
+ *
+ * Release the claim. Device is no longer guaranteed to stay
+ * in direct mode.
+ *
+ * Use with iio_device_claim_direct_mode()
+ */
+void iio_device_release_direct_mode(struct iio_dev *indio_dev)
+{
+        mutex_unlock(&indio_dev->mlock);
+}
+EXPORT_SYMBOL_GPL(iio_device_release_direct_mode);
+
 subsys_initcall(iio_init);
 module_exit(iio_exit);
 
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] =
-        { {28000, 246}, {100000, 219}, {200000, 182}, {700000, 0} };
+static const int apds9960_int_time[][2] = {
+        { 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/stk3310.c b/drivers/iio/light/stk3310.c
index 42d334ba612e..9e847f8f4f0c 100644
--- a/drivers/iio/light/stk3310.c
+++ b/drivers/iio/light/stk3310.c
@@ -16,7 +16,6 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/regmap.h>
-#include <linux/gpio/consumer.h>
 #include <linux/iio/events.h>
 #include <linux/iio/iio.h>
 #include <linux/iio/sysfs.h>
diff --git a/drivers/iio/light/tsl2563.c b/drivers/iio/light/tsl2563.c
index 12731d6b89ec..57b108c30e98 100644
--- a/drivers/iio/light/tsl2563.c
+++ b/drivers/iio/light/tsl2563.c
@@ -806,8 +806,7 @@ static int tsl2563_probe(struct i2c_client *client,
         return 0;
 
 fail:
-        cancel_delayed_work(&chip->poweroff_work);
-        flush_scheduled_work();
+        cancel_delayed_work_sync(&chip->poweroff_work);
         return err;
 }
 
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"
-        depends on I2C
-        select REGMAP_I2C
+        tristate
         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 0e931a9a1669..609a2c401b5d 100644
--- a/drivers/iio/magnetometer/ak8975.c
+++ b/drivers/iio/magnetometer/ak8975.c
@@ -32,9 +32,17 @@
 #include <linux/gpio.h>
 #include <linux/of_gpio.h>
 #include <linux/acpi.h>
+#include <linux/regulator/consumer.h>
 
 #include <linux/iio/iio.h>
 #include <linux/iio/sysfs.h>
+#include <linux/iio/buffer.h>
+#include <linux/iio/trigger.h>
+#include <linux/iio/trigger_consumer.h>
+#include <linux/iio/triggered_buffer.h>
+
+#include <linux/iio/magnetometer/ak8975.h>
+
 /*
  * Register definitions, as well as various shifts and masks to get at the
  * individual fields of the registers.
@@ -361,7 +369,6 @@ static const struct ak_def ak_def_array[AK_MAX_TYPE] = {
 struct ak8975_data {
         struct i2c_client       *client;
         const struct ak_def     *def;
-        struct attribute_group  attrs;
         struct mutex            lock;
         u8                      asa[3];
         long                    raw_to_gauss[3];
@@ -370,8 +377,41 @@ struct ak8975_data {
         wait_queue_head_t       data_ready_queue;
         unsigned long           flags;
         u8                      cntl_cache;
+        struct iio_mount_matrix orientation;
+        struct regulator        *vdd;
 };
 
+/* Enable attached power regulator if any. */
+static int ak8975_power_on(struct i2c_client *client)
+{
+        const struct iio_dev *indio_dev = i2c_get_clientdata(client);
+        struct ak8975_data *data = iio_priv(indio_dev);
+        int ret;
+
+        data->vdd = devm_regulator_get(&client->dev, "vdd");
+        if (IS_ERR_OR_NULL(data->vdd)) {
+                ret = PTR_ERR(data->vdd);
+                if (ret == -ENODEV)
+                        ret = 0;
+        } else {
+                ret = regulator_enable(data->vdd);
+        }
+
+        if (ret)
+                dev_err(&client->dev, "failed to enable Vdd supply: %d\n", ret);
+        return ret;
+}
+
+/* Disable attached power regulator if any. */
+static void ak8975_power_off(const struct i2c_client *client)
+{
+        const struct iio_dev *indio_dev = i2c_get_clientdata(client);
+        const struct ak8975_data *data = iio_priv(indio_dev);
+
+        if (!IS_ERR_OR_NULL(data->vdd))
+                regulator_disable(data->vdd);
+}
+
 /*
  * Return 0 if the i2c device is the one we expect.
  * return a negative error number otherwise
@@ -601,22 +641,15 @@ static int wait_conversion_complete_interrupt(struct ak8975_data *data)
         return ret > 0 ? 0 : -ETIME;
 }
 
-/*
- * Emits the raw flux value for the x, y, or z axis.
- */
-static int ak8975_read_axis(struct iio_dev *indio_dev, int index, int *val)
+static int ak8975_start_read_axis(struct ak8975_data *data,
+                                  const struct i2c_client *client)
 {
-        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. */
@@ -627,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]) {
@@ -635,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;
-                        goto exit;
+                        return -EINVAL;
                 }
         }
 
-        /* Read the flux value from the appropriate register
-           (the register is specified in the iio device attributes). */
-        ret = i2c_smbus_read_word_data(client, data->def->data_regs[index]);
-        if (ret < 0) {
-                dev_err(&client->dev, "Read axis data fails\n");
+        return 0;
+}
+
+/* Retrieve raw flux value for one of the x, y, or z axis.  */
+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;
 }
 
@@ -682,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,                                       \
@@ -690,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,
@@ -724,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)
 {
@@ -733,10 +852,12 @@ static int ak8975_probe(struct i2c_client *client,
         int err;
         const char *name = NULL;
         enum asahi_compass_chipset chipset = AK_MAX_TYPE;
+        const struct ak8975_platform_data *pdata =
+                dev_get_platdata(&client->dev);
 
         /* Grab and set up the supplied GPIO. */
-        if (client->dev.platform_data)
-                eoc_gpio = *(int *)(client->dev.platform_data);
+        if (pdata)
+                eoc_gpio = pdata->eoc_gpio;
         else if (client->dev.of_node)
                 eoc_gpio = of_get_gpio(client->dev.of_node, 0);
         else
@@ -770,13 +891,24 @@ 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);
                 name = id->name;
-        } else if (ACPI_HANDLE(&client->dev))
+        } else if (ACPI_HANDLE(&client->dev)) {
                 name = ak8975_match_acpi_device(&client->dev, &chipset);
-        else
+                if (!name)
+                        return -ENODEV;
+        } else
                 return -ENOSYS;
 
         if (chipset >= AK_MAX_TYPE) {
@@ -786,10 +918,15 @@ static int ak8975_probe(struct i2c_client *client,
         }
 
         data->def = &ak_def_array[chipset];
+
+        err = ak8975_power_on(client);
+        if (err)
+                return err;
+
         err = ak8975_who_i_am(client, data->def->type);
         if (err < 0) {
                 dev_err(&client->dev, "Unexpected device\n");
-                return err;
+                goto power_off;
         }
         dev_dbg(&client->dev, "Asahi compass chip %s\n", name);
 
@@ -797,7 +934,7 @@ static int ak8975_probe(struct i2c_client *client,
         err = ak8975_setup(client);
         if (err < 0) {
                 dev_err(&client->dev, "%s initialization fails\n", name);
-                return err;
+                goto power_off;
         }
 
         mutex_init(&data->lock);
@@ -805,9 +942,41 @@ 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;
-        return devm_iio_device_register(&client->dev, indio_dev);
+
+        err = iio_triggered_buffer_setup(indio_dev, NULL, ak8975_handle_trigger,
+                                         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;
+}
+
+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;
 }
 
 static const struct i2c_device_id ak8975_id[] = {
@@ -841,6 +1010,7 @@ static struct i2c_driver ak8975_driver = {
                 .acpi_match_table = ACPI_PTR(ak_acpi_match),
         },
         .probe          = ak8975_probe,
+        .remove         = ak8975_remove,
         .id_table       = ak8975_id,
 };
 module_i2c_driver(ak8975_driver);
diff --git a/drivers/iio/magnetometer/bmc150_magn.c b/drivers/iio/magnetometer/bmc150_magn.c
index ffcb75ea64fb..d104fb8d9379 100644
--- a/drivers/iio/magnetometer/bmc150_magn.c
+++ b/drivers/iio/magnetometer/bmc150_magn.c
@@ -23,7 +23,6 @@
 #include <linux/delay.h>
 #include <linux/slab.h>
 #include <linux/acpi.h>
-#include <linux/gpio/consumer.h>
 #include <linux/pm.h>
 #include <linux/pm_runtime.h>
 #include <linux/iio/iio.h>
@@ -35,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"
 
@@ -135,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.
@@ -147,6 +148,7 @@ struct bmc150_magn_data {
         struct iio_trigger *dready_trig;
         bool dready_trigger_on;
         int max_odr;
+        int irq;
 };
 
 static const struct {
@@ -216,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,
 
@@ -226,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,
@@ -264,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);
-                ret = pm_runtime_put_autosuspend(&data->client->dev);
+                pm_runtime_mark_last_busy(data->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;
         }
@@ -351,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;
@@ -685,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;
         }
@@ -713,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;
         }
@@ -721,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;
         }
@@ -734,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;
         }
 
@@ -843,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,
-                             const struct i2c_device_id *id)
+int bmc150_magn_probe(struct device *dev, struct regmap *regmap,
+                      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);
-        data->client = client;
+        dev_set_drvdata(dev, indio_dev);
+        data->regmap = regmap;
+        data->irq = irq;
+        data->dev = dev;
 
-        if (id)
-                name = id->name;
-        else if (ACPI_HANDLE(&client->dev))
-                name = bmc150_magn_match_acpi_device(&client->dev);
-        else
-                return -ENOSYS;
+        if (!name && ACPI_HANDLE(dev))
+                name = bmc150_magn_match_acpi_device(dev);
 
         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;
@@ -885,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) {
-                data->dready_trig = devm_iio_trigger_alloc(&client->dev,
+        if (irq > 0) {
+                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",
-                                client->irq);
+                        dev_err(dev, "request irq %d failed\n", irq);
                         goto err_trigger_unregister;
                 }
         }
@@ -923,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,
-                        "iio triggered buffer setup failed\n");
+                dev_err(dev, "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_set_autosuspend_delay(&client->dev,
+        pm_runtime_enable(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)
-                free_irq(client->irq, data->dready_trig);
+        if (irq > 0)
+                free_irq(irq, data->dready_trig);
 err_trigger_unregister:
         if (data->dready_trig)
                 iio_trigger_unregister(data->dready_trig);
@@ -958,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_set_suspended(&client->dev);
-        pm_runtime_put_noidle(&client->dev);
+        pm_runtime_disable(dev);
+        pm_runtime_set_suspended(dev);
+        pm_runtime_put_noidle(dev);
 
         iio_triggered_buffer_cleanup(indio_dev);
 
-        if (client->irq > 0)
-                free_irq(data->client->irq, data->dready_trig);
+        if (data->irq > 0)
+                free_irq(data->irq, data->dready_trig);
 
         if (data->dready_trig)
                 iio_trigger_unregister(data->dready_trig);
@@ -984,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;
 
@@ -997,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;
@@ -1008,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,
@@ -1019,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;
 
@@ -1033,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;
 
@@ -1046,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)
 };
-
-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);
+EXPORT_SYMBOL(bmc150_magn_pm_ops);
 
 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 ffc735c168fb..6acb23810bb4 100644
--- a/drivers/iio/potentiometer/Kconfig
+++ b/drivers/iio/potentiometer/Kconfig
@@ -5,6 +5,34 @@
 
 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
+        help
+          Say yes here to build support for the Microchip
+          MCP4131, MCP4132,
+          MCP4141, MCP4142,
+          MCP4151, MCP4152,
+          MCP4161, MCP4162,
+          MCP4231, MCP4232,
+          MCP4241, MCP4242,
+          MCP4251, MCP4252,
+          MCP4261, MCP4262,
+          digital potentiomenter chips.
+
+          To compile this driver as a module, choose M here: the
+          module will be called mcp4131.
+
 config MCP4531
         tristate "Microchip MCP45xx/MCP46xx Digital Potentiometer driver"
         depends on I2C
diff --git a/drivers/iio/potentiometer/Makefile b/drivers/iio/potentiometer/Makefile
index b563b492b486..6007faa2fb02 100644
--- a/drivers/iio/potentiometer/Makefile
+++ b/drivers/iio/potentiometer/Makefile
@@ -3,5 +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/potentiometer/mcp4131.c b/drivers/iio/potentiometer/mcp4131.c
new file mode 100644
index 000000000000..4e7e2c6c522c
--- /dev/null
+++ b/drivers/iio/potentiometer/mcp4131.c
@@ -0,0 +1,494 @@
+/*
+ * Industrial I/O driver for Microchip digital potentiometers
+ *
+ * Copyright (c) 2016 Slawomir Stepien
+ * Based on: Peter Rosin's code from mcp4531.c
+ *
+ * Datasheet: http://ww1.microchip.com/downloads/en/DeviceDoc/22060b.pdf
+ *
+ * DEVID        #Wipers #Positions      Resistor Opts (kOhm)
+ * mcp4131      1       129             5, 10, 50, 100
+ * mcp4132      1       129             5, 10, 50, 100
+ * mcp4141      1       129             5, 10, 50, 100
+ * mcp4142      1       129             5, 10, 50, 100
+ * mcp4151      1       257             5, 10, 50, 100
+ * mcp4152      1       257             5, 10, 50, 100
+ * mcp4161      1       257             5, 10, 50, 100
+ * mcp4162      1       257             5, 10, 50, 100
+ * mcp4231      2       129             5, 10, 50, 100
+ * mcp4232      2       129             5, 10, 50, 100
+ * mcp4241      2       129             5, 10, 50, 100
+ * mcp4242      2       129             5, 10, 50, 100
+ * mcp4251      2       257             5, 10, 50, 100
+ * mcp4252      2       257             5, 10, 50, 100
+ * mcp4261      2       257             5, 10, 50, 100
+ * mcp4262      2       257             5, 10, 50, 100
+ *
+ * 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.
+ */
+
+/*
+ * TODO:
+ * 1. Write wiper setting to EEPROM for EEPROM capable models.
+ */
+
+#include <linux/cache.h>
+#include <linux/err.h>
+#include <linux/export.h>
+#include <linux/iio/iio.h>
+#include <linux/iio/types.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/of.h>
+#include <linux/spi/spi.h>
+
+#define MCP4131_WRITE           (0x00 << 2)
+#define MCP4131_READ            (0x03 << 2)
+
+#define MCP4131_WIPER_SHIFT     4
+#define MCP4131_CMDERR(r)       ((r[0]) & 0x02)
+#define MCP4131_RAW(r)          ((r[0]) == 0xff ? 0x100 : (r[1]))
+
+struct mcp4131_cfg {
+        int wipers;
+        int max_pos;
+        int kohms;
+};
+
+enum mcp4131_type {
+        MCP413x_502 = 0,
+        MCP413x_103,
+        MCP413x_503,
+        MCP413x_104,
+        MCP414x_502,
+        MCP414x_103,
+        MCP414x_503,
+        MCP414x_104,
+        MCP415x_502,
+        MCP415x_103,
+        MCP415x_503,
+        MCP415x_104,
+        MCP416x_502,
+        MCP416x_103,
+        MCP416x_503,
+        MCP416x_104,
+        MCP423x_502,
+        MCP423x_103,
+        MCP423x_503,
+        MCP423x_104,
+        MCP424x_502,
+        MCP424x_103,
+        MCP424x_503,
+        MCP424x_104,
+        MCP425x_502,
+        MCP425x_103,
+        MCP425x_503,
+        MCP425x_104,
+        MCP426x_502,
+        MCP426x_103,
+        MCP426x_503,
+        MCP426x_104,
+};
+
+static const struct mcp4131_cfg mcp4131_cfg[] = {
+        [MCP413x_502] = { .wipers = 1, .max_pos = 128, .kohms =   5, },
+        [MCP413x_103] = { .wipers = 1, .max_pos = 128, .kohms =  10, },
+        [MCP413x_503] = { .wipers = 1, .max_pos = 128, .kohms =  50, },
+        [MCP413x_104] = { .wipers = 1, .max_pos = 128, .kohms = 100, },
+        [MCP414x_502] = { .wipers = 1, .max_pos = 128, .kohms =   5, },
+        [MCP414x_103] = { .wipers = 1, .max_pos = 128, .kohms =  10, },
+        [MCP414x_503] = { .wipers = 1, .max_pos = 128, .kohms =  50, },
+        [MCP414x_104] = { .wipers = 1, .max_pos = 128, .kohms = 100, },
+        [MCP415x_502] = { .wipers = 1, .max_pos = 256, .kohms =   5, },
+        [MCP415x_103] = { .wipers = 1, .max_pos = 256, .kohms =  10, },
+        [MCP415x_503] = { .wipers = 1, .max_pos = 256, .kohms =  50, },
+        [MCP415x_104] = { .wipers = 1, .max_pos = 256, .kohms = 100, },
+        [MCP416x_502] = { .wipers = 1, .max_pos = 256, .kohms =   5, },
+        [MCP416x_103] = { .wipers = 1, .max_pos = 256, .kohms =  10, },
+        [MCP416x_503] = { .wipers = 1, .max_pos = 256, .kohms =  50, },
+        [MCP416x_104] = { .wipers = 1, .max_pos = 256, .kohms = 100, },
+        [MCP423x_502] = { .wipers = 2, .max_pos = 128, .kohms =   5, },
+        [MCP423x_103] = { .wipers = 2, .max_pos = 128, .kohms =  10, },
+        [MCP423x_503] = { .wipers = 2, .max_pos = 128, .kohms =  50, },
+        [MCP423x_104] = { .wipers = 2, .max_pos = 128, .kohms = 100, },
+        [MCP424x_502] = { .wipers = 2, .max_pos = 128, .kohms =   5, },
+        [MCP424x_103] = { .wipers = 2, .max_pos = 128, .kohms =  10, },
+        [MCP424x_503] = { .wipers = 2, .max_pos = 128, .kohms =  50, },
+        [MCP424x_104] = { .wipers = 2, .max_pos = 128, .kohms = 100, },
+        [MCP425x_502] = { .wipers = 2, .max_pos = 256, .kohms =   5, },
+        [MCP425x_103] = { .wipers = 2, .max_pos = 256, .kohms =  10, },
+        [MCP425x_503] = { .wipers = 2, .max_pos = 256, .kohms =  50, },
+        [MCP425x_104] = { .wipers = 2, .max_pos = 256, .kohms = 100, },
+        [MCP426x_502] = { .wipers = 2, .max_pos = 256, .kohms =   5, },
+        [MCP426x_103] = { .wipers = 2, .max_pos = 256, .kohms =  10, },
+        [MCP426x_503] = { .wipers = 2, .max_pos = 256, .kohms =  50, },
+        [MCP426x_104] = { .wipers = 2, .max_pos = 256, .kohms = 100, },
+};
+
+struct mcp4131_data {
+        struct spi_device *spi;
+        const struct mcp4131_cfg *cfg;
+        struct mutex lock;
+        u8 buf[2] ____cacheline_aligned;
+};
+
+#define MCP4131_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 mcp4131_channels[] = {
+        MCP4131_CHANNEL(0),
+        MCP4131_CHANNEL(1),
+};
+
+static int mcp4131_read(struct spi_device *spi, void *buf, size_t len)
+{
+        struct spi_transfer t = {
+                .tx_buf = buf, /* We need to send addr, cmd and 12 bits */
+                .rx_buf = buf,
+                .len = len,
+        };
+        struct spi_message m;
+
+        spi_message_init(&m);
+        spi_message_add_tail(&t, &m);
+
+        return spi_sync(spi, &m);
+}
+
+static int mcp4131_read_raw(struct iio_dev *indio_dev,
+                            struct iio_chan_spec const *chan,
+                            int *val, int *val2, long mask)
+{
+        int err;
+        struct mcp4131_data *data = iio_priv(indio_dev);
+        int address = chan->channel;
+
+        switch (mask) {
+        case IIO_CHAN_INFO_RAW:
+                mutex_lock(&data->lock);
+
+                data->buf[0] = (address << MCP4131_WIPER_SHIFT) | MCP4131_READ;
+                data->buf[1] = 0;
+
+                err = mcp4131_read(data->spi, data->buf, 2);
+                if (err) {
+                        mutex_unlock(&data->lock);
+                        return err;
+                }
+
+                /* Error, bad address/command combination */
+                if (!MCP4131_CMDERR(data->buf)) {
+                        mutex_unlock(&data->lock);
+                        return -EIO;
+                }
+
+                *val = MCP4131_RAW(data->buf);
+                mutex_unlock(&data->lock);
+
+                return IIO_VAL_INT;
+
+        case IIO_CHAN_INFO_SCALE:
+                *val = 1000 * data->cfg->kohms;
+                *val2 = data->cfg->max_pos;
+                return IIO_VAL_FRACTIONAL;
+        }
+
+        return -EINVAL;
+}
+
+static int mcp4131_write_raw(struct iio_dev *indio_dev,
+                             struct iio_chan_spec const *chan,
+                             int val, int val2, long mask)
+{
+        int err;
+        struct mcp4131_data *data = iio_priv(indio_dev);
+        int address = chan->channel << MCP4131_WIPER_SHIFT;
+
+        switch (mask) {
+        case IIO_CHAN_INFO_RAW:
+                if (val > data->cfg->max_pos || val < 0)
+                        return -EINVAL;
+                break;
+
+        default:
+                return -EINVAL;
+        }
+
+        mutex_lock(&data->lock);
+
+        data->buf[0] = address << MCP4131_WIPER_SHIFT;
+        data->buf[0] |= MCP4131_WRITE | (val >> 8);
+        data->buf[1] = val & 0xFF; /* 8 bits here */
+
+        err = spi_write(data->spi, data->buf, 2);
+        mutex_unlock(&data->lock);
+
+        return err;
+}
+
+static const struct iio_info mcp4131_info = {
+        .read_raw = mcp4131_read_raw,
+        .write_raw = mcp4131_write_raw,
+        .driver_module = THIS_MODULE,
+};
+
+static int mcp4131_probe(struct spi_device *spi)
+{
+        int err;
+        struct device *dev = &spi->dev;
+        unsigned long devid = spi_get_device_id(spi)->driver_data;
+        struct mcp4131_data *data;
+        struct iio_dev *indio_dev;
+
+        indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
+        if (!indio_dev)
+                return -ENOMEM;
+
+        data = iio_priv(indio_dev);
+        spi_set_drvdata(spi, indio_dev);
+        data->spi = spi;
+        data->cfg = &mcp4131_cfg[devid];
+
+        mutex_init(&data->lock);
+
+        indio_dev->dev.parent = dev;
+        indio_dev->info = &mcp4131_info;
+        indio_dev->channels = mcp4131_channels;
+        indio_dev->num_channels = data->cfg->wipers;
+        indio_dev->name = spi_get_device_id(spi)->name;
+
+        err = devm_iio_device_register(dev, indio_dev);
+        if (err) {
+                dev_info(&spi->dev, "Unable to register %s\n", indio_dev->name);
+                return err;
+        }
+
+        return 0;
+}
+
+#if defined(CONFIG_OF)
+static const struct of_device_id mcp4131_dt_ids[] = {
+        { .compatible = "microchip,mcp4131-502",
+                .data = &mcp4131_cfg[MCP413x_502] },
+        { .compatible = "microchip,mcp4131-103",
+                .data = &mcp4131_cfg[MCP413x_103] },
+        { .compatible = "microchip,mcp4131-503",
+                .data = &mcp4131_cfg[MCP413x_503] },
+        { .compatible = "microchip,mcp4131-104",
+                .data = &mcp4131_cfg[MCP413x_104] },
+        { .compatible = "microchip,mcp4132-502",
+                .data = &mcp4131_cfg[MCP413x_502] },
+        { .compatible = "microchip,mcp4132-103",
+                .data = &mcp4131_cfg[MCP413x_103] },
+        { .compatible = "microchip,mcp4132-503",
+                .data = &mcp4131_cfg[MCP413x_503] },
+        { .compatible = "microchip,mcp4132-104",
+                .data = &mcp4131_cfg[MCP413x_104] },
+        { .compatible = "microchip,mcp4141-502",
+                .data = &mcp4131_cfg[MCP414x_502] },
+        { .compatible = "microchip,mcp4141-103",
+                .data = &mcp4131_cfg[MCP414x_103] },
+        { .compatible = "microchip,mcp4141-503",
+                .data = &mcp4131_cfg[MCP414x_503] },
+        { .compatible = "microchip,mcp4141-104",
+                .data = &mcp4131_cfg[MCP414x_104] },
+        { .compatible = "microchip,mcp4142-502",
+                .data = &mcp4131_cfg[MCP414x_502] },
+        { .compatible = "microchip,mcp4142-103",
+                .data = &mcp4131_cfg[MCP414x_103] },
+        { .compatible = "microchip,mcp4142-503",
+                .data = &mcp4131_cfg[MCP414x_503] },
+        { .compatible = "microchip,mcp4142-104",
+                .data = &mcp4131_cfg[MCP414x_104] },
+        { .compatible = "microchip,mcp4151-502",
+                .data = &mcp4131_cfg[MCP415x_502] },
+        { .compatible = "microchip,mcp4151-103",
+                .data = &mcp4131_cfg[MCP415x_103] },
+        { .compatible = "microchip,mcp4151-503",
+                .data = &mcp4131_cfg[MCP415x_503] },
+        { .compatible = "microchip,mcp4151-104",
+                .data = &mcp4131_cfg[MCP415x_104] },
+        { .compatible = "microchip,mcp4152-502",
+                .data = &mcp4131_cfg[MCP415x_502] },
+        { .compatible = "microchip,mcp4152-103",
+                .data = &mcp4131_cfg[MCP415x_103] },
+        { .compatible = "microchip,mcp4152-503",
+                .data = &mcp4131_cfg[MCP415x_503] },
+        { .compatible = "microchip,mcp4152-104",
+                .data = &mcp4131_cfg[MCP415x_104] },
+        { .compatible = "microchip,mcp4161-502",
+                .data = &mcp4131_cfg[MCP416x_502] },
+        { .compatible = "microchip,mcp4161-103",
+                .data = &mcp4131_cfg[MCP416x_103] },
+        { .compatible = "microchip,mcp4161-503",
+                .data = &mcp4131_cfg[MCP416x_503] },
+        { .compatible = "microchip,mcp4161-104",
+                .data = &mcp4131_cfg[MCP416x_104] },
+        { .compatible = "microchip,mcp4162-502",
+                .data = &mcp4131_cfg[MCP416x_502] },
+        { .compatible = "microchip,mcp4162-103",
+                .data = &mcp4131_cfg[MCP416x_103] },
+        { .compatible = "microchip,mcp4162-503",
+                .data = &mcp4131_cfg[MCP416x_503] },
+        { .compatible = "microchip,mcp4162-104",
+                .data = &mcp4131_cfg[MCP416x_104] },
+        { .compatible = "microchip,mcp4231-502",
+                .data = &mcp4131_cfg[MCP423x_502] },
+        { .compatible = "microchip,mcp4231-103",
+                .data = &mcp4131_cfg[MCP423x_103] },
+        { .compatible = "microchip,mcp4231-503",
+                .data = &mcp4131_cfg[MCP423x_503] },
+        { .compatible = "microchip,mcp4231-104",
+                .data = &mcp4131_cfg[MCP423x_104] },
+        { .compatible = "microchip,mcp4232-502",
+                .data = &mcp4131_cfg[MCP423x_502] },
+        { .compatible = "microchip,mcp4232-103",
+                .data = &mcp4131_cfg[MCP423x_103] },
+        { .compatible = "microchip,mcp4232-503",
+                .data = &mcp4131_cfg[MCP423x_503] },
+        { .compatible = "microchip,mcp4232-104",
+                .data = &mcp4131_cfg[MCP423x_104] },
+        { .compatible = "microchip,mcp4241-502",
+                .data = &mcp4131_cfg[MCP424x_502] },
+        { .compatible = "microchip,mcp4241-103",
+                .data = &mcp4131_cfg[MCP424x_103] },
+        { .compatible = "microchip,mcp4241-503",
+                .data = &mcp4131_cfg[MCP424x_503] },
+        { .compatible = "microchip,mcp4241-104",
+                .data = &mcp4131_cfg[MCP424x_104] },
+        { .compatible = "microchip,mcp4242-502",
+                .data = &mcp4131_cfg[MCP424x_502] },
+        { .compatible = "microchip,mcp4242-103",
+                .data = &mcp4131_cfg[MCP424x_103] },
+        { .compatible = "microchip,mcp4242-503",
+                .data = &mcp4131_cfg[MCP424x_503] },
+        { .compatible = "microchip,mcp4242-104",
+                .data = &mcp4131_cfg[MCP424x_104] },
+        { .compatible = "microchip,mcp4251-502",
+                .data = &mcp4131_cfg[MCP425x_502] },
+        { .compatible = "microchip,mcp4251-103",
+                .data = &mcp4131_cfg[MCP425x_103] },
+        { .compatible = "microchip,mcp4251-503",
+                .data = &mcp4131_cfg[MCP425x_503] },
+        { .compatible = "microchip,mcp4251-104",
+                .data = &mcp4131_cfg[MCP425x_104] },
+        { .compatible = "microchip,mcp4252-502",
+                .data = &mcp4131_cfg[MCP425x_502] },
+        { .compatible = "microchip,mcp4252-103",
+                .data = &mcp4131_cfg[MCP425x_103] },
+        { .compatible = "microchip,mcp4252-503",
+                .data = &mcp4131_cfg[MCP425x_503] },
+        { .compatible = "microchip,mcp4252-104",
+                .data = &mcp4131_cfg[MCP425x_104] },
+        { .compatible = "microchip,mcp4261-502",
+                .data = &mcp4131_cfg[MCP426x_502] },
+        { .compatible = "microchip,mcp4261-103",
+                .data = &mcp4131_cfg[MCP426x_103] },
+        { .compatible = "microchip,mcp4261-503",
+                .data = &mcp4131_cfg[MCP426x_503] },
+        { .compatible = "microchip,mcp4261-104",
+                .data = &mcp4131_cfg[MCP426x_104] },
+        { .compatible = "microchip,mcp4262-502",
+                .data = &mcp4131_cfg[MCP426x_502] },
+        { .compatible = "microchip,mcp4262-103",
+                .data = &mcp4131_cfg[MCP426x_103] },
+        { .compatible = "microchip,mcp4262-503",
+                .data = &mcp4131_cfg[MCP426x_503] },
+        { .compatible = "microchip,mcp4262-104",
+                .data = &mcp4131_cfg[MCP426x_104] },
+        {}
+};
+MODULE_DEVICE_TABLE(of, mcp4131_dt_ids);
+#endif /* CONFIG_OF */
+
+static const struct spi_device_id mcp4131_id[] = {
+        { "mcp4131-502", MCP413x_502 },
+        { "mcp4131-103", MCP413x_103 },
+        { "mcp4131-503", MCP413x_503 },
+        { "mcp4131-104", MCP413x_104 },
+        { "mcp4132-502", MCP413x_502 },
+        { "mcp4132-103", MCP413x_103 },
+        { "mcp4132-503", MCP413x_503 },
+        { "mcp4132-104", MCP413x_104 },
+        { "mcp4141-502", MCP414x_502 },
+        { "mcp4141-103", MCP414x_103 },
+        { "mcp4141-503", MCP414x_503 },
+        { "mcp4141-104", MCP414x_104 },
+        { "mcp4142-502", MCP414x_502 },
+        { "mcp4142-103", MCP414x_103 },
+        { "mcp4142-503", MCP414x_503 },
+        { "mcp4142-104", MCP414x_104 },
+        { "mcp4151-502", MCP415x_502 },
+        { "mcp4151-103", MCP415x_103 },
+        { "mcp4151-503", MCP415x_503 },
+        { "mcp4151-104", MCP415x_104 },
+        { "mcp4152-502", MCP415x_502 },
+        { "mcp4152-103", MCP415x_103 },
+        { "mcp4152-503", MCP415x_503 },
+        { "mcp4152-104", MCP415x_104 },
+        { "mcp4161-502", MCP416x_502 },
+        { "mcp4161-103", MCP416x_103 },
+        { "mcp4161-503", MCP416x_503 },
+        { "mcp4161-104", MCP416x_104 },
+        { "mcp4162-502", MCP416x_502 },
+        { "mcp4162-103", MCP416x_103 },
+        { "mcp4162-503", MCP416x_503 },
+        { "mcp4162-104", MCP416x_104 },
+        { "mcp4231-502", MCP423x_502 },
+        { "mcp4231-103", MCP423x_103 },
+        { "mcp4231-503", MCP423x_503 },
+        { "mcp4231-104", MCP423x_104 },
+        { "mcp4232-502", MCP423x_502 },
+        { "mcp4232-103", MCP423x_103 },
+        { "mcp4232-503", MCP423x_503 },
+        { "mcp4232-104", MCP423x_104 },
+        { "mcp4241-502", MCP424x_502 },
+        { "mcp4241-103", MCP424x_103 },
+        { "mcp4241-503", MCP424x_503 },
+        { "mcp4241-104", MCP424x_104 },
+        { "mcp4242-502", MCP424x_502 },
+        { "mcp4242-103", MCP424x_103 },
+        { "mcp4242-503", MCP424x_503 },
+        { "mcp4242-104", MCP424x_104 },
+        { "mcp4251-502", MCP425x_502 },
+        { "mcp4251-103", MCP425x_103 },
+        { "mcp4251-503", MCP425x_503 },
+        { "mcp4251-104", MCP425x_104 },
+        { "mcp4252-502", MCP425x_502 },
+        { "mcp4252-103", MCP425x_103 },
+        { "mcp4252-503", MCP425x_503 },
+        { "mcp4252-104", MCP425x_104 },
+        { "mcp4261-502", MCP426x_502 },
+        { "mcp4261-103", MCP426x_103 },
+        { "mcp4261-503", MCP426x_503 },
+        { "mcp4261-104", MCP426x_104 },
+        { "mcp4262-502", MCP426x_502 },
+        { "mcp4262-103", MCP426x_103 },
+        { "mcp4262-503", MCP426x_503 },
+        { "mcp4262-104", MCP426x_104 },
+        {}
+};
+MODULE_DEVICE_TABLE(spi, mcp4131_id);
+
+static struct spi_driver mcp4131_driver = {
+        .driver = {
+                .name   = "mcp4131",
+                .of_match_table = of_match_ptr(mcp4131_dt_ids),
+        },
+        .probe          = mcp4131_probe,
+        .id_table       = mcp4131_id,
+};
+
+module_spi_driver(mcp4131_driver);
+
+MODULE_AUTHOR("Slawomir Stepien <sst@poczta.fm>");
+MODULE_DESCRIPTION("MCP4131 digital potentiometer");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/potentiometer/mcp4531.c b/drivers/iio/potentiometer/mcp4531.c
index 0db67fe14766..3b72e1a595db 100644
--- a/drivers/iio/potentiometer/mcp4531.c
+++ b/drivers/iio/potentiometer/mcp4531.c
@@ -79,7 +79,7 @@ static const struct mcp4531_cfg mcp4531_cfg[] = {
 
 struct mcp4531_data {
         struct i2c_client *client;
-        unsigned long devid;
+        const struct mcp4531_cfg *cfg;
 };
 
 #define MCP4531_CHANNEL(ch) {                                   \
@@ -113,8 +113,8 @@ static int mcp4531_read_raw(struct iio_dev *indio_dev,
                 *val = ret;
                 return IIO_VAL_INT;
         case IIO_CHAN_INFO_SCALE:
-                *val = 1000 * mcp4531_cfg[data->devid].kohms;
-                *val2 = mcp4531_cfg[data->devid].max_pos;
+                *val = 1000 * data->cfg->kohms;
+                *val2 = data->cfg->max_pos;
                 return IIO_VAL_FRACTIONAL;
         }
 
@@ -130,7 +130,7 @@ static int mcp4531_write_raw(struct iio_dev *indio_dev,
 
         switch (mask) {
         case IIO_CHAN_INFO_RAW:
-                if (val > mcp4531_cfg[data->devid].max_pos || val < 0)
+                if (val > data->cfg->max_pos || val < 0)
                         return -EINVAL;
                 break;
         default:
@@ -152,7 +152,6 @@ static int mcp4531_probe(struct i2c_client *client,
                          const struct i2c_device_id *id)
 {
         struct device *dev = &client->dev;
-        unsigned long devid = id->driver_data;
         struct mcp4531_data *data;
         struct iio_dev *indio_dev;
 
@@ -168,12 +167,12 @@ static int mcp4531_probe(struct i2c_client *client,
         data = iio_priv(indio_dev);
         i2c_set_clientdata(client, indio_dev);
         data->client = client;
-        data->devid = devid;
+        data->cfg = &mcp4531_cfg[id->driver_data];
 
         indio_dev->dev.parent = dev;
         indio_dev->info = &mcp4531_info;
         indio_dev->channels = mcp4531_channels;
-        indio_dev->num_channels = mcp4531_cfg[devid].wipers;
+        indio_dev->num_channels = data->cfg->wipers;
         indio_dev->name = client->name;
 
         return devm_iio_device_register(dev, indio_dev);
diff --git a/drivers/iio/potentiometer/tpl0102.c b/drivers/iio/potentiometer/tpl0102.c
index 313124b6fd59..5c304d42d713 100644
--- a/drivers/iio/potentiometer/tpl0102.c
+++ b/drivers/iio/potentiometer/tpl0102.c
@@ -118,7 +118,7 @@ static int tpl0102_probe(struct i2c_client *client,
 
         if (!i2c_check_functionality(client->adapter,
                                      I2C_FUNC_SMBUS_WORD_DATA))
-                return -ENOTSUPP;
+                return -EOPNOTSUPP;
 
         indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
         if (!indio_dev)
diff --git a/drivers/iio/pressure/Kconfig b/drivers/iio/pressure/Kconfig
index 31c0e1fd2202..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
-          pressure and temperature sensor.
+          Say yes here to build support for Bosch Sensortec BMP180 and BMP280
+          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
 
@@ -148,4 +160,14 @@ config T5403
           To compile this driver as a module, choose M here: the module
           will be called t5403.
 
+config HP206C
+        tristate "HOPERF HP206C precision barometer and altimeter sensor"
+        depends on I2C
+        help
+          Say yes here to build support for the HOPREF HP206C precision
+          barometer and altimeter sensor.
+
+          This driver can also be built as a module. If so, the module will
+          be called hp206c.
+
 endmenu
diff --git a/drivers/iio/pressure/Makefile b/drivers/iio/pressure/Makefile
index d336af14f3fe..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
@@ -17,6 +18,7 @@ obj-$(CONFIG_IIO_ST_PRESS) += st_pressure.o
 st_pressure-y := st_pressure_core.o
 st_pressure-$(CONFIG_IIO_BUFFER) += st_pressure_buffer.o
 obj-$(CONFIG_T5403) += t5403.o
+obj-$(CONFIG_HP206C) += hp206c.o
 
 obj-$(CONFIG_IIO_ST_PRESS_I2C) += st_pressure_i2c.o
 obj-$(CONFIG_IIO_ST_PRESS_SPI) += st_pressure_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_2X             BIT(6)
-#define BMP280_OSRS_TEMP_4X             (BIT(6) | BIT(5))
-#define BMP280_OSRS_TEMP_8X             BIT(7)
-#define BMP280_OSRS_TEMP_16X            (BIT(7) | BIT(5))
+#define BMP280_OSRS_TEMP_X(osrs_t)      ((osrs_t) << 5)
+#define BMP280_OSRS_TEMP_1X             BMP280_OSRS_TEMP_X(1)
+#define BMP280_OSRS_TEMP_2X             BMP280_OSRS_TEMP_X(2)
+#define BMP280_OSRS_TEMP_4X             BMP280_OSRS_TEMP_X(3)
+#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_2X            BIT(3)
-#define BMP280_OSRS_PRESS_4X            (BIT(3) | BIT(2))
-#define BMP280_OSRS_PRESS_8X            BIT(4)
-#define BMP280_OSRS_PRESS_16X           (BIT(4) | BIT(2))
+#define BMP280_OSRS_PRESS_X(osrs_p)     ((osrs_p) << 2)
+#define BMP280_OSRS_PRESS_1X            BMP280_OSRS_PRESS_X(1)
+#define BMP280_OSRS_PRESS_2X            BMP280_OSRS_PRESS_X(2)
+#define BMP280_OSRS_PRESS_4X            BMP280_OSRS_PRESS_X(3)
+#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 |
-                                 BMP280_OSRS_PRESS_16X |
-                                 BMP280_MODE_NORMAL);
+                                 osrs | 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/hp206c.c b/drivers/iio/pressure/hp206c.c
new file mode 100644
index 000000000000..90f2b6e4a920
--- /dev/null
+++ b/drivers/iio/pressure/hp206c.c
@@ -0,0 +1,426 @@
+/*
+ * hp206c.c - HOPERF HP206C precision barometer and altimeter 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.
+ *
+ * (7-bit I2C slave address 0x76)
+ *
+ * Datasheet:
+ *  http://www.hoperf.com/upload/sensor/HP206C_DataSheet_EN_V2.0.pdf
+ */
+
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+#include <linux/delay.h>
+#include <linux/util_macros.h>
+#include <linux/acpi.h>
+
+/* I2C commands: */
+#define HP206C_CMD_SOFT_RST     0x06
+
+#define HP206C_CMD_ADC_CVT      0x40
+
+#define HP206C_CMD_ADC_CVT_OSR_4096     0x00
+#define HP206C_CMD_ADC_CVT_OSR_2048     0x04
+#define HP206C_CMD_ADC_CVT_OSR_1024     0x08
+#define HP206C_CMD_ADC_CVT_OSR_512      0x0c
+#define HP206C_CMD_ADC_CVT_OSR_256      0x10
+#define HP206C_CMD_ADC_CVT_OSR_128      0x14
+
+#define HP206C_CMD_ADC_CVT_CHNL_PT      0x00
+#define HP206C_CMD_ADC_CVT_CHNL_T       0x02
+
+#define HP206C_CMD_READ_P       0x30
+#define HP206C_CMD_READ_T       0x32
+
+#define HP206C_CMD_READ_REG     0x80
+#define HP206C_CMD_WRITE_REG    0xc0
+
+#define HP206C_REG_INT_EN       0x0b
+#define HP206C_REG_INT_CFG      0x0c
+
+#define HP206C_REG_INT_SRC      0x0d
+#define HP206C_FLAG_DEV_RDY     0x40
+
+#define HP206C_REG_PARA         0x0f
+#define HP206C_FLAG_CMPS_EN     0x80
+
+/* Maximum spin for DEV_RDY */
+#define HP206C_MAX_DEV_RDY_WAIT_COUNT 20
+#define HP206C_DEV_RDY_WAIT_US    20000
+
+struct hp206c_data {
+        struct mutex mutex;
+        struct i2c_client *client;
+        int temp_osr_index;
+        int pres_osr_index;
+};
+
+struct hp206c_osr_setting {
+        u8 osr_mask;
+        unsigned int temp_conv_time_us;
+        unsigned int pres_conv_time_us;
+};
+
+/* Data from Table 5 in datasheet. */
+static const struct hp206c_osr_setting hp206c_osr_settings[] = {
+        { HP206C_CMD_ADC_CVT_OSR_4096,  65600,  131100  },
+        { HP206C_CMD_ADC_CVT_OSR_2048,  32800,  65600   },
+        { HP206C_CMD_ADC_CVT_OSR_1024,  16400,  32800   },
+        { HP206C_CMD_ADC_CVT_OSR_512,   8200,   16400   },
+        { HP206C_CMD_ADC_CVT_OSR_256,   4100,   8200    },
+        { HP206C_CMD_ADC_CVT_OSR_128,   2100,   4100    },
+};
+static const int hp206c_osr_rates[] = { 4096, 2048, 1024, 512, 256, 128 };
+static const char hp206c_osr_rates_str[] = "4096 2048 1024 512 256 128";
+
+static inline int hp206c_read_reg(struct i2c_client *client, u8 reg)
+{
+        return i2c_smbus_read_byte_data(client, HP206C_CMD_READ_REG | reg);
+}
+
+static inline int hp206c_write_reg(struct i2c_client *client, u8 reg, u8 val)
+{
+        return i2c_smbus_write_byte_data(client,
+                        HP206C_CMD_WRITE_REG | reg, val);
+}
+
+static int hp206c_read_20bit(struct i2c_client *client, u8 cmd)
+{
+        int ret;
+        u8 values[3];
+
+        ret = i2c_smbus_read_i2c_block_data(client, cmd, 3, values);
+        if (ret < 0)
+                return ret;
+        if (ret != 3)
+                return -EIO;
+        return ((values[0] & 0xF) << 16) | (values[1] << 8) | (values[2]);
+}
+
+/* Spin for max 160ms until DEV_RDY is 1, or return error. */
+static int hp206c_wait_dev_rdy(struct iio_dev *indio_dev)
+{
+        int ret;
+        int count = 0;
+        struct hp206c_data *data = iio_priv(indio_dev);
+        struct i2c_client *client = data->client;
+
+        while (++count <= HP206C_MAX_DEV_RDY_WAIT_COUNT) {
+                ret = hp206c_read_reg(client, HP206C_REG_INT_SRC);
+                if (ret < 0) {
+                        dev_err(&indio_dev->dev, "Failed READ_REG INT_SRC: %d\n", ret);
+                        return ret;
+                }
+                if (ret & HP206C_FLAG_DEV_RDY)
+                        return 0;
+                usleep_range(HP206C_DEV_RDY_WAIT_US, HP206C_DEV_RDY_WAIT_US * 3 / 2);
+        }
+        return -ETIMEDOUT;
+}
+
+static int hp206c_set_compensation(struct i2c_client *client, bool enabled)
+{
+        int val;
+
+        val = hp206c_read_reg(client, HP206C_REG_PARA);
+        if (val < 0)
+                return val;
+        if (enabled)
+                val |= HP206C_FLAG_CMPS_EN;
+        else
+                val &= ~HP206C_FLAG_CMPS_EN;
+
+        return hp206c_write_reg(client, HP206C_REG_PARA, val);
+}
+
+/* Do a soft reset */
+static int hp206c_soft_reset(struct iio_dev *indio_dev)
+{
+        int ret;
+        struct hp206c_data *data = iio_priv(indio_dev);
+        struct i2c_client *client = data->client;
+
+        ret = i2c_smbus_write_byte(client, HP206C_CMD_SOFT_RST);
+        if (ret) {
+                dev_err(&client->dev, "Failed to reset device: %d\n", ret);
+                return ret;
+        }
+
+        usleep_range(400, 600);
+
+        ret = hp206c_wait_dev_rdy(indio_dev);
+        if (ret) {
+                dev_err(&client->dev, "Device not ready after soft reset: %d\n", ret);
+                return ret;
+        }
+
+        ret = hp206c_set_compensation(client, true);
+        if (ret)
+                dev_err(&client->dev, "Failed to enable compensation: %d\n", ret);
+        return ret;
+}
+
+static int hp206c_conv_and_read(struct iio_dev *indio_dev,
+                                u8 conv_cmd, u8 read_cmd,
+                                unsigned int sleep_us)
+{
+        int ret;
+        struct hp206c_data *data = iio_priv(indio_dev);
+        struct i2c_client *client = data->client;
+
+        ret = hp206c_wait_dev_rdy(indio_dev);
+        if (ret < 0) {
+                dev_err(&indio_dev->dev, "Device not ready: %d\n", ret);
+                return ret;
+        }
+
+        ret = i2c_smbus_write_byte(client, conv_cmd);
+        if (ret < 0) {
+                dev_err(&indio_dev->dev, "Failed convert: %d\n", ret);
+                return ret;
+        }
+
+        usleep_range(sleep_us, sleep_us * 3 / 2);
+
+        ret = hp206c_wait_dev_rdy(indio_dev);
+        if (ret < 0) {
+                dev_err(&indio_dev->dev, "Device not ready: %d\n", ret);
+                return ret;
+        }
+
+        ret = hp206c_read_20bit(client, read_cmd);
+        if (ret < 0)
+                dev_err(&indio_dev->dev, "Failed read: %d\n", ret);
+
+        return ret;
+}
+
+static int hp206c_read_raw(struct iio_dev *indio_dev,
+                           struct iio_chan_spec const *chan, int *val,
+                           int *val2, long mask)
+{
+        int ret;
+        struct hp206c_data *data = iio_priv(indio_dev);
+        const struct hp206c_osr_setting *osr_setting;
+        u8 conv_cmd;
+
+        mutex_lock(&data->mutex);
+
+        switch (mask) {
+        case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
+                switch (chan->type) {
+                case IIO_TEMP:
+                        *val = hp206c_osr_rates[data->temp_osr_index];
+                        ret = IIO_VAL_INT;
+                        break;
+
+                case IIO_PRESSURE:
+                        *val = hp206c_osr_rates[data->pres_osr_index];
+                        ret = IIO_VAL_INT;
+                        break;
+                default:
+                        ret = -EINVAL;
+                }
+                break;
+
+        case IIO_CHAN_INFO_RAW:
+                switch (chan->type) {
+                case IIO_TEMP:
+                        osr_setting = &hp206c_osr_settings[data->temp_osr_index];
+                        conv_cmd = HP206C_CMD_ADC_CVT |
+                                        osr_setting->osr_mask |
+                                        HP206C_CMD_ADC_CVT_CHNL_T;
+                        ret = hp206c_conv_and_read(indio_dev,
+                                        conv_cmd,
+                                        HP206C_CMD_READ_T,
+                                        osr_setting->temp_conv_time_us);
+                        if (ret >= 0) {
+                                /* 20 significant bits are provided.
+                                 * Extend sign over the rest.
+                                 */
+                                *val = sign_extend32(ret, 19);
+                                ret = IIO_VAL_INT;
+                        }
+                        break;
+
+                case IIO_PRESSURE:
+                        osr_setting = &hp206c_osr_settings[data->pres_osr_index];
+                        conv_cmd = HP206C_CMD_ADC_CVT |
+                                        osr_setting->osr_mask |
+                                        HP206C_CMD_ADC_CVT_CHNL_PT;
+                        ret = hp206c_conv_and_read(indio_dev,
+                                        conv_cmd,
+                                        HP206C_CMD_READ_P,
+                                        osr_setting->pres_conv_time_us);
+                        if (ret >= 0) {
+                                *val = ret;
+                                ret = IIO_VAL_INT;
+                        }
+                        break;
+                default:
+                        ret = -EINVAL;
+                }
+                break;
+
+        case IIO_CHAN_INFO_SCALE:
+                switch (chan->type) {
+                case IIO_TEMP:
+                        *val = 0;
+                        *val2 = 10000;
+                        ret = IIO_VAL_INT_PLUS_MICRO;
+                        break;
+
+                case IIO_PRESSURE:
+                        *val = 0;
+                        *val2 = 1000;
+                        ret = IIO_VAL_INT_PLUS_MICRO;
+                        break;
+                default:
+                        ret = -EINVAL;
+                }
+                break;
+
+        default:
+                ret = -EINVAL;
+        }
+
+        mutex_unlock(&data->mutex);
+        return ret;
+}
+
+static int hp206c_write_raw(struct iio_dev *indio_dev,
+                            struct iio_chan_spec const *chan,
+                            int val, int val2, long mask)
+{
+        int ret = 0;
+        struct hp206c_data *data = iio_priv(indio_dev);
+
+        if (mask != IIO_CHAN_INFO_OVERSAMPLING_RATIO)
+                return -EINVAL;
+        mutex_lock(&data->mutex);
+        switch (chan->type) {
+        case IIO_TEMP:
+                data->temp_osr_index = find_closest_descending(val,
+                        hp206c_osr_rates, ARRAY_SIZE(hp206c_osr_rates));
+                break;
+        case IIO_PRESSURE:
+                data->pres_osr_index = find_closest_descending(val,
+                        hp206c_osr_rates, ARRAY_SIZE(hp206c_osr_rates));
+                break;
+        default:
+                ret = -EINVAL;
+        }
+        mutex_unlock(&data->mutex);
+        return ret;
+}
+
+static const struct iio_chan_spec hp206c_channels[] = {
+        {
+                .type = IIO_TEMP,
+                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
+                                      BIT(IIO_CHAN_INFO_SCALE) |
+                                      BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
+        },
+        {
+                .type = IIO_PRESSURE,
+                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
+                                      BIT(IIO_CHAN_INFO_SCALE) |
+                                      BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
+        }
+};
+
+static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(hp206c_osr_rates_str);
+
+static struct attribute *hp206c_attributes[] = {
+        &iio_const_attr_sampling_frequency_available.dev_attr.attr,
+        NULL,
+};
+
+static const struct attribute_group hp206c_attribute_group = {
+        .attrs = hp206c_attributes,
+};
+
+static const struct iio_info hp206c_info = {
+        .attrs = &hp206c_attribute_group,
+        .read_raw = hp206c_read_raw,
+        .write_raw = hp206c_write_raw,
+        .driver_module = THIS_MODULE,
+};
+
+static int hp206c_probe(struct i2c_client *client,
+                        const struct i2c_device_id *id)
+{
+        struct iio_dev *indio_dev;
+        struct hp206c_data *data;
+        int ret;
+
+        if (!i2c_check_functionality(client->adapter,
+                                     I2C_FUNC_SMBUS_BYTE |
+                                     I2C_FUNC_SMBUS_BYTE_DATA |
+                                     I2C_FUNC_SMBUS_READ_I2C_BLOCK)) {
+                dev_err(&client->dev, "Adapter does not support "
+                                "all required i2c functionality\n");
+                return -ENODEV;
+        }
+
+        indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
+        if (!indio_dev)
+                return -ENOMEM;
+
+        data = iio_priv(indio_dev);
+        data->client = client;
+        mutex_init(&data->mutex);
+
+        indio_dev->info = &hp206c_info;
+        indio_dev->name = id->name;
+        indio_dev->dev.parent = &client->dev;
+        indio_dev->modes = INDIO_DIRECT_MODE;
+        indio_dev->channels = hp206c_channels;
+        indio_dev->num_channels = ARRAY_SIZE(hp206c_channels);
+
+        i2c_set_clientdata(client, indio_dev);
+
+        /* Do a soft reset on probe */
+        ret = hp206c_soft_reset(indio_dev);
+        if (ret) {
+                dev_err(&client->dev, "Failed to reset on startup: %d\n", ret);
+                return -ENODEV;
+        }
+
+        return devm_iio_device_register(&client->dev, indio_dev);
+}
+
+static const struct i2c_device_id hp206c_id[] = {
+        {"hp206c"},
+        {}
+};
+
+#ifdef CONFIG_ACPI
+static const struct acpi_device_id hp206c_acpi_match[] = {
+        {"HOP206C", 0},
+        { },
+};
+MODULE_DEVICE_TABLE(acpi, hp206c_acpi_match);
+#endif
+
+static struct i2c_driver hp206c_driver = {
+        .probe = hp206c_probe,
+        .id_table = hp206c_id,
+        .driver = {
+                .name = "hp206c",
+                .acpi_match_table = ACPI_PTR(hp206c_acpi_match),
+        },
+};
+
+module_i2c_driver(hp206c_driver);
+
+MODULE_DESCRIPTION("HOPERF HP206C precision barometer and altimeter sensor");
+MODULE_AUTHOR("Leonard Crestez <leonard.crestez@intel.com>");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/iio/pressure/ms5611.h b/drivers/iio/pressure/ms5611.h
index 8b08e4b7e3a9..ccda63c5b3c3 100644
--- a/drivers/iio/pressure/ms5611.h
+++ b/drivers/iio/pressure/ms5611.h
@@ -16,15 +16,11 @@
 #include <linux/iio/iio.h>
 #include <linux/mutex.h>
 
+struct regulator;
+
 #define MS5611_RESET                    0x1e
 #define MS5611_READ_ADC                 0x00
 #define MS5611_READ_PROM_WORD           0xA0
-#define MS5611_START_TEMP_CONV          0x58
-#define MS5611_START_PRESSURE_CONV      0x48
-
-#define MS5611_CONV_TIME_MIN            9040
-#define MS5611_CONV_TIME_MAX            10000
-
 #define MS5611_PROM_WORDS_NB            8
 
 enum {
@@ -39,16 +35,31 @@ struct ms5611_chip_info {
                                             s32 *temp, s32 *pressure);
 };
 
+/*
+ * OverSampling Rate descriptor.
+ * Warning: cmd MUST be kept aligned on a word boundary (see
+ * m5611_spi_read_adc_temp_and_pressure in ms5611_spi.c).
+ */
+struct ms5611_osr {
+        unsigned long conv_usec;
+        u8 cmd;
+        unsigned short rate;
+};
+
 struct ms5611_state {
         void *client;
         struct mutex lock;
 
+        const struct ms5611_osr *pressure_osr;
+        const struct ms5611_osr *temp_osr;
+
         int (*reset)(struct device *dev);
         int (*read_prom_word)(struct device *dev, int index, u16 *word);
         int (*read_adc_temp_and_pressure)(struct device *dev,
                                           s32 *temp, s32 *pressure);
 
         struct ms5611_chip_info *chip_info;
+        struct regulator *vdd;
 };
 
 int ms5611_probe(struct iio_dev *indio_dev, struct device *dev,
diff --git a/drivers/iio/pressure/ms5611_core.c b/drivers/iio/pressure/ms5611_core.c
index 992ad8d3b67a..76578b07bb6e 100644
--- a/drivers/iio/pressure/ms5611_core.c
+++ b/drivers/iio/pressure/ms5611_core.c
@@ -18,11 +18,44 @@
 #include <linux/delay.h>
 #include <linux/regulator/consumer.h>
 
+#include <linux/iio/sysfs.h>
 #include <linux/iio/buffer.h>
 #include <linux/iio/triggered_buffer.h>
 #include <linux/iio/trigger_consumer.h>
 #include "ms5611.h"
 
+#define MS5611_INIT_OSR(_cmd, _conv_usec, _rate) \
+        { .cmd = _cmd, .conv_usec = _conv_usec, .rate = _rate }
+
+static const struct ms5611_osr ms5611_avail_pressure_osr[] = {
+        MS5611_INIT_OSR(0x40, 600,  256),
+        MS5611_INIT_OSR(0x42, 1170, 512),
+        MS5611_INIT_OSR(0x44, 2280, 1024),
+        MS5611_INIT_OSR(0x46, 4540, 2048),
+        MS5611_INIT_OSR(0x48, 9040, 4096)
+};
+
+static const struct ms5611_osr ms5611_avail_temp_osr[] = {
+        MS5611_INIT_OSR(0x50, 600,  256),
+        MS5611_INIT_OSR(0x52, 1170, 512),
+        MS5611_INIT_OSR(0x54, 2280, 1024),
+        MS5611_INIT_OSR(0x56, 4540, 2048),
+        MS5611_INIT_OSR(0x58, 9040, 4096)
+};
+
+static const char ms5611_show_osr[] = "256 512 1024 2048 4096";
+
+static IIO_CONST_ATTR(oversampling_ratio_available, ms5611_show_osr);
+
+static struct attribute *ms5611_attributes[] = {
+        &iio_const_attr_oversampling_ratio_available.dev_attr.attr,
+        NULL,
+};
+
+static const struct attribute_group ms5611_attribute_group = {
+        .attrs = ms5611_attributes,
+};
+
 static bool ms5611_prom_is_valid(u16 *prom, size_t len)
 {
         int i, j;
@@ -239,11 +272,70 @@ static int ms5611_read_raw(struct iio_dev *indio_dev,
                 default:
                         return -EINVAL;
                 }
+        case IIO_CHAN_INFO_OVERSAMPLING_RATIO:
+                if (chan->type != IIO_TEMP && chan->type != IIO_PRESSURE)
+                        break;
+                mutex_lock(&st->lock);
+                if (chan->type == IIO_TEMP)
+                        *val = (int)st->temp_osr->rate;
+                else
+                        *val = (int)st->pressure_osr->rate;
+                mutex_unlock(&st->lock);
+                return IIO_VAL_INT;
         }
 
         return -EINVAL;
 }
 
+static const struct ms5611_osr *ms5611_find_osr(int rate,
+                                                const struct ms5611_osr *osr,
+                                                size_t count)
+{
+        unsigned int r;
+
+        for (r = 0; r < count; r++)
+                if ((unsigned short)rate == osr[r].rate)
+                        break;
+        if (r >= count)
+                return NULL;
+        return &osr[r];
+}
+
+static int ms5611_write_raw(struct iio_dev *indio_dev,
+                            struct iio_chan_spec const *chan,
+                            int val, int val2, long mask)
+{
+        struct ms5611_state *st = iio_priv(indio_dev);
+        const struct ms5611_osr *osr = NULL;
+
+        if (mask != IIO_CHAN_INFO_OVERSAMPLING_RATIO)
+                return -EINVAL;
+
+        if (chan->type == IIO_TEMP)
+                osr = ms5611_find_osr(val, ms5611_avail_temp_osr,
+                                      ARRAY_SIZE(ms5611_avail_temp_osr));
+        else if (chan->type == IIO_PRESSURE)
+                osr = ms5611_find_osr(val, ms5611_avail_pressure_osr,
+                                      ARRAY_SIZE(ms5611_avail_pressure_osr));
+        if (!osr)
+                return -EINVAL;
+
+        mutex_lock(&st->lock);
+
+        if (iio_buffer_enabled(indio_dev)) {
+                mutex_unlock(&st->lock);
+                return -EBUSY;
+        }
+
+        if (chan->type == IIO_TEMP)
+                st->temp_osr = osr;
+        else
+                st->pressure_osr = osr;
+
+        mutex_unlock(&st->lock);
+        return 0;
+}
+
 static const unsigned long ms5611_scan_masks[] = {0x3, 0};
 
 static struct ms5611_chip_info chip_info_tbl[] = {
@@ -259,7 +351,8 @@ static const struct iio_chan_spec ms5611_channels[] = {
         {
                 .type = IIO_PRESSURE,
                 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
-                        BIT(IIO_CHAN_INFO_SCALE),
+                        BIT(IIO_CHAN_INFO_SCALE) |
+                        BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
                 .scan_index = 0,
                 .scan_type = {
                         .sign = 's',
@@ -271,7 +364,8 @@ static const struct iio_chan_spec ms5611_channels[] = {
         {
                 .type = IIO_TEMP,
                 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED) |
-                        BIT(IIO_CHAN_INFO_SCALE),
+                        BIT(IIO_CHAN_INFO_SCALE) |
+                        BIT(IIO_CHAN_INFO_OVERSAMPLING_RATIO),
                 .scan_index = 1,
                 .scan_type = {
                         .sign = 's',
@@ -285,40 +379,68 @@ static const struct iio_chan_spec ms5611_channels[] = {
 
 static const struct iio_info ms5611_info = {
         .read_raw = &ms5611_read_raw,
+        .write_raw = &ms5611_write_raw,
+        .attrs = &ms5611_attribute_group,
         .driver_module = THIS_MODULE,
 };
 
 static int ms5611_init(struct iio_dev *indio_dev)
 {
         int ret;
-        struct regulator *vdd = devm_regulator_get(indio_dev->dev.parent,
-                                                   "vdd");
+        struct ms5611_state *st = iio_priv(indio_dev);
 
         /* Enable attached regulator if any. */
-        if (!IS_ERR(vdd)) {
-                ret = regulator_enable(vdd);
+        st->vdd = devm_regulator_get(indio_dev->dev.parent, "vdd");
+        if (!IS_ERR(st->vdd)) {
+                ret = regulator_enable(st->vdd);
                 if (ret) {
                         dev_err(indio_dev->dev.parent,
-                                "failed to enable Vdd supply: %d\n", ret);
+                                "failed to enable Vdd supply: %d\n", ret);
                         return ret;
                 }
+        } else {
+                ret = PTR_ERR(st->vdd);
+                if (ret != -ENODEV)
+                        return ret;
         }
 
         ret = ms5611_reset(indio_dev);
         if (ret < 0)
-                return ret;
+                goto err_regulator_disable;
 
-        return ms5611_read_prom(indio_dev);
+        ret = ms5611_read_prom(indio_dev);
+        if (ret < 0)
+                goto err_regulator_disable;
+
+        return 0;
+
+err_regulator_disable:
+        if (!IS_ERR_OR_NULL(st->vdd))
+                regulator_disable(st->vdd);
+        return ret;
+}
+
+static void ms5611_fini(const struct iio_dev *indio_dev)
+{
+        const struct ms5611_state *st = iio_priv(indio_dev);
+
+        if (!IS_ERR_OR_NULL(st->vdd))
+                regulator_disable(st->vdd);
 }
 
 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);
 
         mutex_init(&st->lock);
         st->chip_info = &chip_info_tbl[type];
+        st->temp_osr =
+                &ms5611_avail_temp_osr[ARRAY_SIZE(ms5611_avail_temp_osr) - 1];
+        st->pressure_osr =
+                &ms5611_avail_pressure_osr[ARRAY_SIZE(ms5611_avail_pressure_osr)
+                                           - 1];
         indio_dev->dev.parent = dev;
         indio_dev->name = name;
         indio_dev->info = &ms5611_info;
@@ -335,7 +457,7 @@ int ms5611_probe(struct iio_dev *indio_dev, struct device *dev,
                                          ms5611_trigger_handler, NULL);
         if (ret < 0) {
                 dev_err(dev, "iio triggered buffer setup failed\n");
-                return ret;
+                goto err_fini;
         }
 
         ret = iio_device_register(indio_dev);
@@ -348,7 +470,8 @@ int ms5611_probe(struct iio_dev *indio_dev, struct device *dev,
 
 err_buffer_cleanup:
         iio_triggered_buffer_cleanup(indio_dev);
-
+err_fini:
+        ms5611_fini(indio_dev);
         return ret;
 }
 EXPORT_SYMBOL(ms5611_probe);
@@ -357,6 +480,7 @@ int ms5611_remove(struct iio_dev *indio_dev)
 {
         iio_device_unregister(indio_dev);
         iio_triggered_buffer_cleanup(indio_dev);
+        ms5611_fini(indio_dev);
 
         return 0;
 }
diff --git a/drivers/iio/pressure/ms5611_i2c.c b/drivers/iio/pressure/ms5611_i2c.c
index 7f6fc8eee922..55fb5fc0b6ea 100644
--- a/drivers/iio/pressure/ms5611_i2c.c
+++ b/drivers/iio/pressure/ms5611_i2c.c
@@ -17,6 +17,7 @@
 #include <linux/delay.h>
 #include <linux/i2c.h>
 #include <linux/module.h>
+#include <linux/of_device.h>
 
 #include "ms5611.h"
 
@@ -62,23 +63,23 @@ static int ms5611_i2c_read_adc_temp_and_pressure(struct device *dev,
 {
         int ret;
         struct ms5611_state *st = iio_priv(dev_to_iio_dev(dev));
+        const struct ms5611_osr *osr = st->temp_osr;
 
-        ret = i2c_smbus_write_byte(st->client, MS5611_START_TEMP_CONV);
+        ret = i2c_smbus_write_byte(st->client, osr->cmd);
         if (ret < 0)
                 return ret;
 
-        usleep_range(MS5611_CONV_TIME_MIN, MS5611_CONV_TIME_MAX);
-
+        usleep_range(osr->conv_usec, osr->conv_usec + (osr->conv_usec / 10UL));
         ret = ms5611_i2c_read_adc(st, temp);
         if (ret < 0)
                 return ret;
 
-        ret = i2c_smbus_write_byte(st->client, MS5611_START_PRESSURE_CONV);
+        osr = st->pressure_osr;
+        ret = i2c_smbus_write_byte(st->client, osr->cmd);
         if (ret < 0)
                 return ret;
 
-        usleep_range(MS5611_CONV_TIME_MIN, MS5611_CONV_TIME_MAX);
-
+        usleep_range(osr->conv_usec, osr->conv_usec + (osr->conv_usec / 10UL));
         return ms5611_i2c_read_adc(st, pressure);
 }
 
@@ -113,6 +114,17 @@ static int ms5611_i2c_remove(struct i2c_client *client)
         return ms5611_remove(i2c_get_clientdata(client));
 }
 
+#if defined(CONFIG_OF)
+static const struct of_device_id ms5611_i2c_matches[] = {
+        { .compatible = "meas,ms5611" },
+        { .compatible = "ms5611" },
+        { .compatible = "meas,ms5607" },
+        { .compatible = "ms5607" },
+        { }
+};
+MODULE_DEVICE_TABLE(of, ms5611_i2c_matches);
+#endif
+
 static const struct i2c_device_id ms5611_id[] = {
         { "ms5611", MS5611 },
         { "ms5607", MS5607 },
@@ -123,6 +135,7 @@ MODULE_DEVICE_TABLE(i2c, ms5611_id);
 static struct i2c_driver ms5611_driver = {
         .driver = {
                 .name = "ms5611",
+                .of_match_table = of_match_ptr(ms5611_i2c_matches)
         },
         .id_table = ms5611_id,
         .probe = ms5611_i2c_probe,
diff --git a/drivers/iio/pressure/ms5611_spi.c b/drivers/iio/pressure/ms5611_spi.c
index 5cc009e85f0e..932e05001e1a 100644
--- a/drivers/iio/pressure/ms5611_spi.c
+++ b/drivers/iio/pressure/ms5611_spi.c
@@ -12,6 +12,7 @@
 #include <linux/delay.h>
 #include <linux/module.h>
 #include <linux/spi/spi.h>
+#include <linux/of_device.h>
 
 #include "ms5611.h"
 
@@ -55,28 +56,29 @@ static int ms5611_spi_read_adc(struct device *dev, s32 *val)
 static int ms5611_spi_read_adc_temp_and_pressure(struct device *dev,
                                                  s32 *temp, s32 *pressure)
 {
-        u8 cmd;
         int ret;
         struct ms5611_state *st = iio_priv(dev_to_iio_dev(dev));
+        const struct ms5611_osr *osr = st->temp_osr;
 
-        cmd = MS5611_START_TEMP_CONV;
-        ret = spi_write_then_read(st->client, &cmd, 1, NULL, 0);
+        /*
+         * Warning: &osr->cmd MUST be aligned on a word boundary since used as
+         * 2nd argument (void*) of spi_write_then_read.
+         */
+        ret = spi_write_then_read(st->client, &osr->cmd, 1, NULL, 0);
         if (ret < 0)
                 return ret;
 
-        usleep_range(MS5611_CONV_TIME_MIN, MS5611_CONV_TIME_MAX);
-
+        usleep_range(osr->conv_usec, osr->conv_usec + (osr->conv_usec / 10UL));
         ret = ms5611_spi_read_adc(dev, temp);
         if (ret < 0)
                 return ret;
 
-        cmd = MS5611_START_PRESSURE_CONV;
-        ret = spi_write_then_read(st->client, &cmd, 1, NULL, 0);
+        osr = st->pressure_osr;
+        ret = spi_write_then_read(st->client, &osr->cmd, 1, NULL, 0);
         if (ret < 0)
                 return ret;
 
-        usleep_range(MS5611_CONV_TIME_MIN, MS5611_CONV_TIME_MAX);
-
+        usleep_range(osr->conv_usec, osr->conv_usec + (osr->conv_usec / 10UL));
         return ms5611_spi_read_adc(dev, pressure);
 }
 
@@ -106,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)
@@ -114,6 +116,17 @@ static int ms5611_spi_remove(struct spi_device *spi)
         return ms5611_remove(spi_get_drvdata(spi));
 }
 
+#if defined(CONFIG_OF)
+static const struct of_device_id ms5611_spi_matches[] = {
+        { .compatible = "meas,ms5611" },
+        { .compatible = "ms5611" },
+        { .compatible = "meas,ms5607" },
+        { .compatible = "ms5607" },
+        { }
+};
+MODULE_DEVICE_TABLE(of, ms5611_spi_matches);
+#endif
+
 static const struct spi_device_id ms5611_id[] = {
         { "ms5611", MS5611 },
         { "ms5607", MS5607 },
@@ -124,6 +137,7 @@ MODULE_DEVICE_TABLE(spi, ms5611_id);
 static struct spi_driver ms5611_driver = {
         .driver = {
                 .name = "ms5611",
+                .of_match_table = of_match_ptr(ms5611_spi_matches)
         },
         .id_table = ms5611_id,
         .probe = ms5611_spi_probe,
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,