Merge tag 'iio-for-3.19a' of git://git.kernel.org/pub/scm/linux/kernel/git/jic23/iio into staging-next

Jonathan writes:

First round of new drivers, features and cleanups for IIO in the 3.19 cycle.

New drivers / supported parts
* rockchip - rk3066-tsadc variant
* si7020 humidity and temperature sensor
* mcp320x - add mcp3001, mcp3002, mcp3004, mcp3008, mcp3201, mcp3202
* bmp280 pressure and temperature sensor
* Qualcomm SPMI PMIC current ADC driver
* Exynos_adc - support exynos7

New features
* vf610-adc - add temperature sensor support
* Documentation of current attributes, scaled pressure, offset and
  scaled humidity, RGBC intensity gain factor and scale applied to
  differential voltage channels.
* Bring iio_event_monitor up to date with newer modifiers.
* Add of_xlate function to allow for complex channel mappings from the
  device tree.
* Add -g parameter to generic_buffer example to allow for devices with
  directly fed (no trigger) buffers.
* Move exynos driver over to syscon for PMU register access.

Cleanups, fixes for new drivers
* lis3l02dq drop an unneeded else.
* st sensors - renam st_sensors to st_sensor_settings (for clarity)
* st sensors - drop an unused parameter from all the probe utility
  functions.
* vf610 better error handling and tidy up.
* si7020 - cleanups following merge
* as3935 - drop some unnecessary semicolons.
* bmp280 - fix the pressure calculation.

3 files changed, 70 insertions, 58 deletions

diff --git a/drivers/iio/common/st_sensors/st_sensors_core.c b/drivers/iio/common/st_sensors/st_sensors_core.c
index 24cfe4e044f9..edd13d2b4121 100644
--- a/drivers/iio/common/st_sensors/st_sensors_core.c
+++ b/drivers/iio/common/st_sensors/st_sensors_core.c
@@ -44,18 +44,18 @@ st_sensors_write_data_with_mask_error:
         return err;
 }
 
-static int st_sensors_match_odr(struct st_sensors *sensor,
+static int st_sensors_match_odr(struct st_sensor_settings *sensor_settings,
                         unsigned int odr, struct st_sensor_odr_avl *odr_out)
 {
         int i, ret = -EINVAL;
 
         for (i = 0; i < ST_SENSORS_ODR_LIST_MAX; i++) {
-                if (sensor->odr.odr_avl[i].hz == 0)
+                if (sensor_settings->odr.odr_avl[i].hz == 0)
                         goto st_sensors_match_odr_error;
 
-                if (sensor->odr.odr_avl[i].hz == odr) {
-                        odr_out->hz = sensor->odr.odr_avl[i].hz;
-                        odr_out->value = sensor->odr.odr_avl[i].value;
+                if (sensor_settings->odr.odr_avl[i].hz == odr) {
+                        odr_out->hz = sensor_settings->odr.odr_avl[i].hz;
+                        odr_out->value = sensor_settings->odr.odr_avl[i].value;
                         ret = 0;
                         break;
                 }
@@ -71,23 +71,26 @@ int st_sensors_set_odr(struct iio_dev *indio_dev, unsigned int odr)
         struct st_sensor_odr_avl odr_out = {0, 0};
         struct st_sensor_data *sdata = iio_priv(indio_dev);
 
-        err = st_sensors_match_odr(sdata->sensor, odr, &odr_out);
+        err = st_sensors_match_odr(sdata->sensor_settings, odr, &odr_out);
         if (err < 0)
                 goto st_sensors_match_odr_error;
 
-        if ((sdata->sensor->odr.addr == sdata->sensor->pw.addr) &&
-                        (sdata->sensor->odr.mask == sdata->sensor->pw.mask)) {
+        if ((sdata->sensor_settings->odr.addr ==
+                                        sdata->sensor_settings->pw.addr) &&
+                                (sdata->sensor_settings->odr.mask ==
+                                        sdata->sensor_settings->pw.mask)) {
                 if (sdata->enabled == true) {
                         err = st_sensors_write_data_with_mask(indio_dev,
-                                sdata->sensor->odr.addr,
-                                sdata->sensor->odr.mask,
+                                sdata->sensor_settings->odr.addr,
+                                sdata->sensor_settings->odr.mask,
                                 odr_out.value);
                 } else {
                         err = 0;
                 }
         } else {
                 err = st_sensors_write_data_with_mask(indio_dev,
-                        sdata->sensor->odr.addr, sdata->sensor->odr.mask,
+                        sdata->sensor_settings->odr.addr,
+                        sdata->sensor_settings->odr.mask,
                         odr_out.value);
         }
         if (err >= 0)
@@ -98,16 +101,16 @@ st_sensors_match_odr_error:
 }
 EXPORT_SYMBOL(st_sensors_set_odr);
 
-static int st_sensors_match_fs(struct st_sensors *sensor,
+static int st_sensors_match_fs(struct st_sensor_settings *sensor_settings,
                                         unsigned int fs, int *index_fs_avl)
 {
         int i, ret = -EINVAL;
 
         for (i = 0; i < ST_SENSORS_FULLSCALE_AVL_MAX; i++) {
-                if (sensor->fs.fs_avl[i].num == 0)
+                if (sensor_settings->fs.fs_avl[i].num == 0)
                         goto st_sensors_match_odr_error;
 
-                if (sensor->fs.fs_avl[i].num == fs) {
+                if (sensor_settings->fs.fs_avl[i].num == fs) {
                         *index_fs_avl = i;
                         ret = 0;
                         break;
@@ -118,25 +121,24 @@ st_sensors_match_odr_error:
         return ret;
 }
 
-static int st_sensors_set_fullscale(struct iio_dev *indio_dev,
-                                                                unsigned int fs)
+static int st_sensors_set_fullscale(struct iio_dev *indio_dev, unsigned int fs)
 {
         int err, i = 0;
         struct st_sensor_data *sdata = iio_priv(indio_dev);
 
-        err = st_sensors_match_fs(sdata->sensor, fs, &i);
+        err = st_sensors_match_fs(sdata->sensor_settings, fs, &i);
         if (err < 0)
                 goto st_accel_set_fullscale_error;
 
         err = st_sensors_write_data_with_mask(indio_dev,
-                                sdata->sensor->fs.addr,
-                                sdata->sensor->fs.mask,
-                                sdata->sensor->fs.fs_avl[i].value);
+                                sdata->sensor_settings->fs.addr,
+                                sdata->sensor_settings->fs.mask,
+                                sdata->sensor_settings->fs.fs_avl[i].value);
         if (err < 0)
                 goto st_accel_set_fullscale_error;
 
         sdata->current_fullscale = (struct st_sensor_fullscale_avl *)
-                                                &sdata->sensor->fs.fs_avl[i];
+                                        &sdata->sensor_settings->fs.fs_avl[i];
         return err;
 
 st_accel_set_fullscale_error:
@@ -153,10 +155,12 @@ int st_sensors_set_enable(struct iio_dev *indio_dev, bool enable)
         struct st_sensor_data *sdata = iio_priv(indio_dev);
 
         if (enable) {
-                tmp_value = sdata->sensor->pw.value_on;
-                if ((sdata->sensor->odr.addr == sdata->sensor->pw.addr) &&
-                        (sdata->sensor->odr.mask == sdata->sensor->pw.mask)) {
-                        err = st_sensors_match_odr(sdata->sensor,
+                tmp_value = sdata->sensor_settings->pw.value_on;
+                if ((sdata->sensor_settings->odr.addr ==
+                                        sdata->sensor_settings->pw.addr) &&
+                                (sdata->sensor_settings->odr.mask ==
+                                        sdata->sensor_settings->pw.mask)) {
+                        err = st_sensors_match_odr(sdata->sensor_settings,
                                                         sdata->odr, &odr_out);
                         if (err < 0)
                                 goto set_enable_error;
@@ -164,8 +168,8 @@ int st_sensors_set_enable(struct iio_dev *indio_dev, bool enable)
                         found = true;
                 }
                 err = st_sensors_write_data_with_mask(indio_dev,
-                                sdata->sensor->pw.addr,
-                                sdata->sensor->pw.mask, tmp_value);
+                                sdata->sensor_settings->pw.addr,
+                                sdata->sensor_settings->pw.mask, tmp_value);
                 if (err < 0)
                         goto set_enable_error;
 
@@ -175,9 +179,9 @@ int st_sensors_set_enable(struct iio_dev *indio_dev, bool enable)
                         sdata->odr = odr_out.hz;
         } else {
                 err = st_sensors_write_data_with_mask(indio_dev,
-                                sdata->sensor->pw.addr,
-                                sdata->sensor->pw.mask,
-                                sdata->sensor->pw.value_off);
+                                sdata->sensor_settings->pw.addr,
+                                sdata->sensor_settings->pw.mask,
+                                sdata->sensor_settings->pw.value_off);
                 if (err < 0)
                         goto set_enable_error;
 
@@ -194,8 +198,9 @@ int st_sensors_set_axis_enable(struct iio_dev *indio_dev, u8 axis_enable)
         struct st_sensor_data *sdata = iio_priv(indio_dev);
 
         return st_sensors_write_data_with_mask(indio_dev,
-                                sdata->sensor->enable_axis.addr,
-                                sdata->sensor->enable_axis.mask, axis_enable);
+                                sdata->sensor_settings->enable_axis.addr,
+                                sdata->sensor_settings->enable_axis.mask,
+                                axis_enable);
 }
 EXPORT_SYMBOL(st_sensors_set_axis_enable);
 
@@ -236,13 +241,13 @@ void st_sensors_power_disable(struct iio_dev *indio_dev)
 EXPORT_SYMBOL(st_sensors_power_disable);
 
 static int st_sensors_set_drdy_int_pin(struct iio_dev *indio_dev,
-                                       struct st_sensors_platform_data *pdata)
+                                        struct st_sensors_platform_data *pdata)
 {
         struct st_sensor_data *sdata = iio_priv(indio_dev);
 
         switch (pdata->drdy_int_pin) {
         case 1:
-                if (sdata->sensor->drdy_irq.mask_int1 == 0) {
+                if (sdata->sensor_settings->drdy_irq.mask_int1 == 0) {
                         dev_err(&indio_dev->dev,
                                         "DRDY on INT1 not available.\n");
                         return -EINVAL;
@@ -250,7 +255,7 @@ static int st_sensors_set_drdy_int_pin(struct iio_dev *indio_dev,
                 sdata->drdy_int_pin = 1;
                 break;
         case 2:
-                if (sdata->sensor->drdy_irq.mask_int2 == 0) {
+                if (sdata->sensor_settings->drdy_irq.mask_int2 == 0) {
                         dev_err(&indio_dev->dev,
                                         "DRDY on INT2 not available.\n");
                         return -EINVAL;
@@ -318,7 +323,7 @@ int st_sensors_init_sensor(struct iio_dev *indio_dev,
 
         if (sdata->current_fullscale) {
                 err = st_sensors_set_fullscale(indio_dev,
-                                               sdata->current_fullscale->num);
+                                                sdata->current_fullscale->num);
                 if (err < 0)
                         return err;
         } else
@@ -330,7 +335,8 @@ int st_sensors_init_sensor(struct iio_dev *indio_dev,
 
         /* set BDU */
         err = st_sensors_write_data_with_mask(indio_dev,
-                        sdata->sensor->bdu.addr, sdata->sensor->bdu.mask, true);
+                                        sdata->sensor_settings->bdu.addr,
+                                        sdata->sensor_settings->bdu.mask, true);
         if (err < 0)
                 return err;
 
@@ -346,26 +352,28 @@ int st_sensors_set_dataready_irq(struct iio_dev *indio_dev, bool enable)
         u8 drdy_mask;
         struct st_sensor_data *sdata = iio_priv(indio_dev);
 
-        if (!sdata->sensor->drdy_irq.addr)
+        if (!sdata->sensor_settings->drdy_irq.addr)
                 return 0;
 
         /* Enable/Disable the interrupt generator 1. */
-        if (sdata->sensor->drdy_irq.ig1.en_addr > 0) {
+        if (sdata->sensor_settings->drdy_irq.ig1.en_addr > 0) {
                 err = st_sensors_write_data_with_mask(indio_dev,
-                        sdata->sensor->drdy_irq.ig1.en_addr,
-                        sdata->sensor->drdy_irq.ig1.en_mask, (int)enable);
+                                sdata->sensor_settings->drdy_irq.ig1.en_addr,
+                                sdata->sensor_settings->drdy_irq.ig1.en_mask,
+                                (int)enable);
                 if (err < 0)
                         goto st_accel_set_dataready_irq_error;
         }
 
         if (sdata->drdy_int_pin == 1)
-                drdy_mask = sdata->sensor->drdy_irq.mask_int1;
+                drdy_mask = sdata->sensor_settings->drdy_irq.mask_int1;
         else
-                drdy_mask = sdata->sensor->drdy_irq.mask_int2;
+                drdy_mask = sdata->sensor_settings->drdy_irq.mask_int2;
 
         /* Enable/Disable the interrupt generator for data ready. */
         err = st_sensors_write_data_with_mask(indio_dev,
-                        sdata->sensor->drdy_irq.addr, drdy_mask, (int)enable);
+                                        sdata->sensor_settings->drdy_irq.addr,
+                                        drdy_mask, (int)enable);
 
 st_accel_set_dataready_irq_error:
         return err;
@@ -378,8 +386,8 @@ int st_sensors_set_fullscale_by_gain(struct iio_dev *indio_dev, int scale)
         struct st_sensor_data *sdata = iio_priv(indio_dev);
 
         for (i = 0; i < ST_SENSORS_FULLSCALE_AVL_MAX; i++) {
-                if ((sdata->sensor->fs.fs_avl[i].gain == scale) &&
-                                (sdata->sensor->fs.fs_avl[i].gain != 0)) {
+                if ((sdata->sensor_settings->fs.fs_avl[i].gain == scale) &&
+                                (sdata->sensor_settings->fs.fs_avl[i].gain != 0)) {
                         err = 0;
                         break;
                 }
@@ -388,7 +396,7 @@ int st_sensors_set_fullscale_by_gain(struct iio_dev *indio_dev, int scale)
                 goto st_sensors_match_scale_error;
 
         err = st_sensors_set_fullscale(indio_dev,
-                                        sdata->sensor->fs.fs_avl[i].num);
+                                sdata->sensor_settings->fs.fs_avl[i].num);
 
 st_sensors_match_scale_error:
         return err;
@@ -439,7 +447,7 @@ int st_sensors_read_info_raw(struct iio_dev *indio_dev,
                 if (err < 0)
                         goto out;
 
-                msleep((sdata->sensor->bootime * 1000) / sdata->odr);
+                msleep((sdata->sensor_settings->bootime * 1000) / sdata->odr);
                 err = st_sensors_read_axis_data(indio_dev, ch, val);
                 if (err < 0)
                         goto out;
@@ -456,7 +464,8 @@ out:
 EXPORT_SYMBOL(st_sensors_read_info_raw);
 
 int st_sensors_check_device_support(struct iio_dev *indio_dev,
-                        int num_sensors_list, const struct st_sensors *sensors)
+                        int num_sensors_list,
+                        const struct st_sensor_settings *sensor_settings)
 {
         u8 wai;
         int i, n, err;
@@ -470,23 +479,24 @@ int st_sensors_check_device_support(struct iio_dev *indio_dev,
         }
 
         for (i = 0; i < num_sensors_list; i++) {
-                if (sensors[i].wai == wai)
+                if (sensor_settings[i].wai == wai)
                         break;
         }
         if (i == num_sensors_list)
                 goto device_not_supported;
 
-        for (n = 0; n < ARRAY_SIZE(sensors[i].sensors_supported); n++) {
+        for (n = 0; n < ARRAY_SIZE(sensor_settings[i].sensors_supported); n++) {
                 if (strcmp(indio_dev->name,
-                                &sensors[i].sensors_supported[n][0]) == 0)
+                                &sensor_settings[i].sensors_supported[n][0]) == 0)
                         break;
         }
-        if (n == ARRAY_SIZE(sensors[i].sensors_supported)) {
+        if (n == ARRAY_SIZE(sensor_settings[i].sensors_supported)) {
                 dev_err(&indio_dev->dev, "device name and WhoAmI mismatch.\n");
                 goto sensor_name_mismatch;
         }
 
-        sdata->sensor = (struct st_sensors *)&sensors[i];
+        sdata->sensor_settings =
+                        (struct st_sensor_settings *)&sensor_settings[i];
 
         return i;
 
@@ -508,11 +518,11 @@ ssize_t st_sensors_sysfs_sampling_frequency_avail(struct device *dev,
 
         mutex_lock(&indio_dev->mlock);
         for (i = 0; i < ST_SENSORS_ODR_LIST_MAX; i++) {
-                if (sdata->sensor->odr.odr_avl[i].hz == 0)
+                if (sdata->sensor_settings->odr.odr_avl[i].hz == 0)
                         break;
 
                 len += scnprintf(buf + len, PAGE_SIZE - len, "%d ",
-                                        sdata->sensor->odr.odr_avl[i].hz);
+                                sdata->sensor_settings->odr.odr_avl[i].hz);
         }
         mutex_unlock(&indio_dev->mlock);
         buf[len - 1] = '\n';
@@ -530,11 +540,11 @@ ssize_t st_sensors_sysfs_scale_avail(struct device *dev,
 
         mutex_lock(&indio_dev->mlock);
         for (i = 0; i < ST_SENSORS_FULLSCALE_AVL_MAX; i++) {
-                if (sdata->sensor->fs.fs_avl[i].num == 0)
+                if (sdata->sensor_settings->fs.fs_avl[i].num == 0)
                         break;
 
                 len += scnprintf(buf + len, PAGE_SIZE - len, "0.%06u ",
-                                        sdata->sensor->fs.fs_avl[i].gain);
+                                sdata->sensor_settings->fs.fs_avl[i].gain);
         }
         mutex_unlock(&indio_dev->mlock);
         buf[len - 1] = '\n';
diff --git a/drivers/iio/common/st_sensors/st_sensors_i2c.c b/drivers/iio/common/st_sensors/st_sensors_i2c.c
index bb6f3085f57b..98cfee296d46 100644
--- a/drivers/iio/common/st_sensors/st_sensors_i2c.c
+++ b/drivers/iio/common/st_sensors/st_sensors_i2c.c
@@ -72,6 +72,7 @@ void st_sensors_i2c_configure(struct iio_dev *indio_dev,
         indio_dev->dev.parent = &client->dev;
         indio_dev->name = client->name;
 
+        sdata->dev = &client->dev;
         sdata->tf = &st_sensors_tf_i2c;
         sdata->get_irq_data_ready = st_sensors_i2c_get_irq;
 }
diff --git a/drivers/iio/common/st_sensors/st_sensors_spi.c b/drivers/iio/common/st_sensors/st_sensors_spi.c
index 251baf6abc25..78a6a1ab3ece 100644
--- a/drivers/iio/common/st_sensors/st_sensors_spi.c
+++ b/drivers/iio/common/st_sensors/st_sensors_spi.c
@@ -111,6 +111,7 @@ void st_sensors_spi_configure(struct iio_dev *indio_dev,
         indio_dev->dev.parent = &spi->dev;
         indio_dev->name = spi->modalias;
 
+        sdata->dev = &spi->dev;
         sdata->tf = &st_sensors_tf_spi;
         sdata->get_irq_data_ready = st_sensors_spi_get_irq;
 }