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

Jonathan writes:

First set of new features, drivers and cleanups for IIO in the 3.14 cycle.
This mostly consists of patches that didn't quite make the last cycle. Lots
of interesting things under review currently.

Core:
- Add devm_iio_device_register/unregister.  I took some convincing on whether
  there would be many devices that really were simple enough to need no
  explicit actions on removal.  Turns out there are some.
- Move some stray docs to above the relevant implemenation.
- Drop a redundant repeated check on the fact the trigger has actually changed
  when there is a userspace attempt change it.

Drivers:
New drivers
- Freescale MPL3115A2 Pressure / temperature sensor

New functionality
- hid_sensors: add sensitivity support.

DT bindings
- tsl2563
- hmc5843

Cleanups
- Drop unused scan_type from viperboard adc driver.
- devm_iio_device_register used in viperboard, ad5421, ad5755, adis16130,
  adxrs450, vcnl4000, adis16220, ad7816, lpc32xx, adt7316, adis16060, isl29018
  and ad2s1200.  Note that this was proposed in a number of other drivers
  and this revealed a number of missorderings in remove functions.  Also for
  now I have blocked this on any device that any hardware suspend suport on
  the basis that we probably want to power down devices if they have no driver
  support loaded.

18 files changed, 534 insertions, 78 deletions

diff --git a/drivers/iio/accel/hid-sensor-accel-3d.c b/drivers/iio/accel/hid-sensor-accel-3d.c
index dcda17395c4e..6b8735ce8345 100644
--- a/drivers/iio/accel/hid-sensor-accel-3d.c
+++ b/drivers/iio/accel/hid-sensor-accel-3d.c
@@ -262,6 +262,18 @@ static int accel_3d_parse_report(struct platform_device *pdev,
                         st->accel[1].index, st->accel[1].report_id,
                         st->accel[2].index, st->accel[2].report_id);
 
+        /* Set Sensitivity field ids, when there is no individual modifier */
+        if (st->common_attributes.sensitivity.index < 0) {
+                sensor_hub_input_get_attribute_info(hsdev,
+                        HID_FEATURE_REPORT, usage_id,
+                        HID_USAGE_SENSOR_DATA_MOD_CHANGE_SENSITIVITY_ABS |
+                        HID_USAGE_SENSOR_DATA_ACCELERATION,
+                        &st->common_attributes.sensitivity);
+                dev_dbg(&pdev->dev, "Sensitivity index:report %d:%d\n",
+                        st->common_attributes.sensitivity.index,
+                        st->common_attributes.sensitivity.report_id);
+        }
+
         return ret;
 }
 
diff --git a/drivers/iio/adc/mcp3422.c b/drivers/iio/adc/mcp3422.c
index 12948325431c..dbdbd77f69ea 100644
--- a/drivers/iio/adc/mcp3422.c
+++ b/drivers/iio/adc/mcp3422.c
@@ -362,7 +362,7 @@ static int mcp3422_probe(struct i2c_client *client,
                 | MCP3422_SAMPLE_RATE_VALUE(MCP3422_SRATE_240));
         mcp3422_update_config(adc, config);
 
-        err = iio_device_register(indio_dev);
+        err = devm_iio_device_register(&client->dev, indio_dev);
         if (err < 0)
                 return err;
 
@@ -371,12 +371,6 @@ static int mcp3422_probe(struct i2c_client *client,
         return 0;
 }
 
-static int mcp3422_remove(struct i2c_client *client)
-{
-        iio_device_unregister(i2c_get_clientdata(client));
-        return 0;
-}
-
 static const struct i2c_device_id mcp3422_id[] = {
         { "mcp3422", 2 },
         { "mcp3423", 3 },
@@ -400,7 +394,6 @@ static struct i2c_driver mcp3422_driver = {
                 .of_match_table = of_match_ptr(mcp3422_of_match),
         },
         .probe = mcp3422_probe,
-        .remove = mcp3422_remove,
         .id_table = mcp3422_id,
 };
 module_i2c_driver(mcp3422_driver);
diff --git a/drivers/iio/adc/viperboard_adc.c b/drivers/iio/adc/viperboard_adc.c
index 09727a71e9fa..d0add8f9416b 100644
--- a/drivers/iio/adc/viperboard_adc.c
+++ b/drivers/iio/adc/viperboard_adc.c
@@ -42,12 +42,6 @@ struct vprbrd_adc {
         .indexed = 1,                                   \
         .channel = _index,                              \
         .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),   \
-        .scan_index = _index,                           \
-        .scan_type = {                                  \
-                .sign = 'u',                            \
-                .realbits = 8,                          \
-                .storagebits = 8,                       \
-        },                                              \
 }
 
 static struct iio_chan_spec const vprbrd_adc_iio_channels[] = {
@@ -73,7 +67,7 @@ static int vprbrd_iio_read_raw(struct iio_dev *iio_dev,
                 mutex_lock(&vb->lock);
 
                 admsg->cmd = VPRBRD_ADC_CMD_GET;
-                admsg->chan = chan->scan_index;
+                admsg->chan = chan->channel;
                 admsg->val = 0x00;
 
                 ret = usb_control_msg(vb->usb_dev,
@@ -139,7 +133,7 @@ static int vprbrd_adc_probe(struct platform_device *pdev)
         indio_dev->channels = vprbrd_adc_iio_channels;
         indio_dev->num_channels = ARRAY_SIZE(vprbrd_adc_iio_channels);
 
-        ret = iio_device_register(indio_dev);
+        ret = devm_iio_device_register(&pdev->dev, indio_dev);
         if (ret) {
                 dev_err(&pdev->dev, "could not register iio (adc)");
                 return ret;
@@ -150,22 +144,12 @@ static int vprbrd_adc_probe(struct platform_device *pdev)
         return 0;
 }
 
-static int vprbrd_adc_remove(struct platform_device *pdev)
-{
-        struct iio_dev *indio_dev = platform_get_drvdata(pdev);
-
-        iio_device_unregister(indio_dev);
-
-        return 0;
-}
-
 static struct platform_driver vprbrd_adc_driver = {
         .driver = {
                 .name   = "viperboard-adc",
                 .owner  = THIS_MODULE,
         },
         .probe          = vprbrd_adc_probe,
-        .remove         = vprbrd_adc_remove,
 };
 
 module_platform_driver(vprbrd_adc_driver);
diff --git a/drivers/iio/dac/ad5421.c b/drivers/iio/dac/ad5421.c
index 3eeaa82075f7..7d1e90811c71 100644
--- a/drivers/iio/dac/ad5421.c
+++ b/drivers/iio/dac/ad5421.c
@@ -514,16 +514,7 @@ static int ad5421_probe(struct spi_device *spi)
                         return ret;
         }
 
-        return iio_device_register(indio_dev);
-}
-
-static int ad5421_remove(struct spi_device *spi)
-{
-        struct iio_dev *indio_dev = spi_get_drvdata(spi);
-
-        iio_device_unregister(indio_dev);
-
-        return 0;
+        return devm_iio_device_register(&spi->dev, indio_dev);
 }
 
 static struct spi_driver ad5421_driver = {
@@ -532,7 +523,6 @@ static struct spi_driver ad5421_driver = {
                    .owner = THIS_MODULE,
         },
         .probe = ad5421_probe,
-        .remove = ad5421_remove,
 };
 module_spi_driver(ad5421_driver);
 
diff --git a/drivers/iio/dac/ad5755.c b/drivers/iio/dac/ad5755.c
index 9a78d5abb2f6..ee1e95a3a0c3 100644
--- a/drivers/iio/dac/ad5755.c
+++ b/drivers/iio/dac/ad5755.c
@@ -589,16 +589,7 @@ static int ad5755_probe(struct spi_device *spi)
         if (ret)
                 return ret;
 
-        return iio_device_register(indio_dev);
-}
-
-static int ad5755_remove(struct spi_device *spi)
-{
-        struct iio_dev *indio_dev = spi_get_drvdata(spi);
-
-        iio_device_unregister(indio_dev);
-
-        return 0;
+        return devm_iio_device_register(&spi->dev, indio_dev);
 }
 
 static const struct spi_device_id ad5755_id[] = {
@@ -617,7 +608,6 @@ static struct spi_driver ad5755_driver = {
                 .owner = THIS_MODULE,
         },
         .probe = ad5755_probe,
-        .remove = ad5755_remove,
         .id_table = ad5755_id,
 };
 module_spi_driver(ad5755_driver);
diff --git a/drivers/iio/gyro/adis16130.c b/drivers/iio/gyro/adis16130.c
index 445c2aecfadd..8d08c7ed1ea6 100644
--- a/drivers/iio/gyro/adis16130.c
+++ b/drivers/iio/gyro/adis16130.c
@@ -161,13 +161,7 @@ static int adis16130_probe(struct spi_device *spi)
         indio_dev->info = &adis16130_info;
         indio_dev->modes = INDIO_DIRECT_MODE;
 
-        return iio_device_register(indio_dev);
-}
-
-static int adis16130_remove(struct spi_device *spi)
-{
-        iio_device_unregister(spi_get_drvdata(spi));
-        return 0;
+        return devm_iio_device_register(&spi->dev, indio_dev);
 }
 
 static struct spi_driver adis16130_driver = {
@@ -176,7 +170,6 @@ static struct spi_driver adis16130_driver = {
                 .owner = THIS_MODULE,
         },
         .probe = adis16130_probe,
-        .remove = adis16130_remove,
 };
 module_spi_driver(adis16130_driver);
 
diff --git a/drivers/iio/gyro/adxrs450.c b/drivers/iio/gyro/adxrs450.c
index 1e546ba7ba45..eb0e08ec9e20 100644
--- a/drivers/iio/gyro/adxrs450.c
+++ b/drivers/iio/gyro/adxrs450.c
@@ -434,23 +434,14 @@ static int adxrs450_probe(struct spi_device *spi)
         indio_dev->num_channels = ARRAY_SIZE(adxrs450_channels);
         indio_dev->name = spi->dev.driver->name;
 
-        ret = iio_device_register(indio_dev);
+        ret = devm_iio_device_register(&spi->dev, indio_dev);
         if (ret)
                 return ret;
 
         /* Get the device into a sane initial state */
         ret = adxrs450_initial_setup(indio_dev);
         if (ret)
-                goto error_initial;
-        return 0;
-error_initial:
-        iio_device_unregister(indio_dev);
-        return ret;
-}
-
-static int adxrs450_remove(struct spi_device *spi)
-{
-        iio_device_unregister(spi_get_drvdata(spi));
+                return ret;
 
         return 0;
 }
@@ -468,7 +459,6 @@ static struct spi_driver adxrs450_driver = {
                 .owner = THIS_MODULE,
         },
         .probe = adxrs450_probe,
-        .remove = adxrs450_remove,
         .id_table       = adxrs450_id,
 };
 module_spi_driver(adxrs450_driver);
diff --git a/drivers/iio/gyro/hid-sensor-gyro-3d.c b/drivers/iio/gyro/hid-sensor-gyro-3d.c
index ea01c6bcfb56..97797dbaad34 100644
--- a/drivers/iio/gyro/hid-sensor-gyro-3d.c
+++ b/drivers/iio/gyro/hid-sensor-gyro-3d.c
@@ -262,6 +262,17 @@ static int gyro_3d_parse_report(struct platform_device *pdev,
                         st->gyro[1].index, st->gyro[1].report_id,
                         st->gyro[2].index, st->gyro[2].report_id);
 
+        /* Set Sensitivity field ids, when there is no individual modifier */
+        if (st->common_attributes.sensitivity.index < 0) {
+                sensor_hub_input_get_attribute_info(hsdev,
+                        HID_FEATURE_REPORT, usage_id,
+                        HID_USAGE_SENSOR_DATA_MOD_CHANGE_SENSITIVITY_ABS |
+                        HID_USAGE_SENSOR_DATA_ANGL_VELOCITY,
+                        &st->common_attributes.sensitivity);
+                dev_dbg(&pdev->dev, "Sensitivity index:report %d:%d\n",
+                        st->common_attributes.sensitivity.index,
+                        st->common_attributes.sensitivity.report_id);
+        }
         return ret;
 }
 
diff --git a/drivers/iio/industrialio-core.c b/drivers/iio/industrialio-core.c
index 18f72e3d0ed6..2fe88c189f74 100644
--- a/drivers/iio/industrialio-core.c
+++ b/drivers/iio/industrialio-core.c
@@ -107,6 +107,11 @@ static const char * const iio_chan_info_postfix[] = {
         [IIO_CHAN_INFO_INT_TIME] = "integration_time",
 };
 
+/**
+ * iio_find_channel_from_si() - get channel from its scan index
+ * @indio_dev:          device
+ * @si:                 scan index to match
+ */
 const struct iio_chan_spec
 *iio_find_channel_from_si(struct iio_dev *indio_dev, int si)
 {
@@ -922,6 +927,10 @@ struct device_type iio_device_type = {
         .release = iio_dev_release,
 };
 
+/**
+ * iio_device_alloc() - allocate an iio_dev from a driver
+ * @sizeof_priv:        Space to allocate for private structure.
+ **/
 struct iio_dev *iio_device_alloc(int sizeof_priv)
 {
         struct iio_dev *dev;
@@ -962,6 +971,10 @@ struct iio_dev *iio_device_alloc(int sizeof_priv)
 }
 EXPORT_SYMBOL(iio_device_alloc);
 
+/**
+ * iio_device_free() - free an iio_dev from a driver
+ * @dev:                the iio_dev associated with the device
+ **/
 void iio_device_free(struct iio_dev *dev)
 {
         if (dev)
@@ -984,6 +997,20 @@ static int devm_iio_device_match(struct device *dev, void *res, void *data)
         return *r == data;
 }
 
+/**
+ * devm_iio_device_alloc - Resource-managed iio_device_alloc()
+ * @dev:                Device to allocate iio_dev for
+ * @sizeof_priv:        Space to allocate for private structure.
+ *
+ * Managed iio_device_alloc. iio_dev allocated with this function is
+ * automatically freed on driver detach.
+ *
+ * If an iio_dev allocated with this function needs to be freed separately,
+ * devm_iio_device_free() must be used.
+ *
+ * RETURNS:
+ * Pointer to allocated iio_dev on success, NULL on failure.
+ */
 struct iio_dev *devm_iio_device_alloc(struct device *dev, int sizeof_priv)
 {
         struct iio_dev **ptr, *iio_dev;
@@ -1006,6 +1033,13 @@ struct iio_dev *devm_iio_device_alloc(struct device *dev, int sizeof_priv)
 }
 EXPORT_SYMBOL_GPL(devm_iio_device_alloc);
 
+/**
+ * devm_iio_device_free - Resource-managed iio_device_free()
+ * @dev:                Device this iio_dev belongs to
+ * @iio_dev:            the iio_dev associated with the device
+ *
+ * Free iio_dev allocated with devm_iio_device_alloc().
+ */
 void devm_iio_device_free(struct device *dev, struct iio_dev *iio_dev)
 {
         int rc;
@@ -1080,6 +1114,10 @@ static const struct file_operations iio_buffer_fileops = {
 
 static const struct iio_buffer_setup_ops noop_ring_setup_ops;
 
+/**
+ * iio_device_register() - register a device with the IIO subsystem
+ * @indio_dev:          Device structure filled by the device driver
+ **/
 int iio_device_register(struct iio_dev *indio_dev)
 {
         int ret;
@@ -1141,6 +1179,10 @@ error_ret:
 }
 EXPORT_SYMBOL(iio_device_register);
 
+/**
+ * iio_device_unregister() - unregister a device from the IIO subsystem
+ * @indio_dev:          Device structure representing the device.
+ **/
 void iio_device_unregister(struct iio_dev *indio_dev)
 {
         mutex_lock(&indio_dev->info_exist_lock);
@@ -1161,6 +1203,65 @@ void iio_device_unregister(struct iio_dev *indio_dev)
         mutex_unlock(&indio_dev->info_exist_lock);
 }
 EXPORT_SYMBOL(iio_device_unregister);
+
+static void devm_iio_device_unreg(struct device *dev, void *res)
+{
+        iio_device_unregister(*(struct iio_dev **)res);
+}
+
+/**
+ * devm_iio_device_register - Resource-managed iio_device_register()
+ * @dev:        Device to allocate iio_dev for
+ * @indio_dev:  Device structure filled by the device driver
+ *
+ * Managed iio_device_register.  The IIO device registered with this
+ * function is automatically unregistered on driver detach. This function
+ * calls iio_device_register() internally. Refer to that function for more
+ * information.
+ *
+ * If an iio_dev registered with this function needs to be unregistered
+ * separately, devm_iio_device_unregister() must be used.
+ *
+ * RETURNS:
+ * 0 on success, negative error number on failure.
+ */
+int devm_iio_device_register(struct device *dev, struct iio_dev *indio_dev)
+{
+        struct iio_dev **ptr;
+        int ret;
+
+        ptr = devres_alloc(devm_iio_device_unreg, sizeof(*ptr), GFP_KERNEL);
+        if (!ptr)
+                return -ENOMEM;
+
+        *ptr = indio_dev;
+        ret = iio_device_register(indio_dev);
+        if (!ret)
+                devres_add(dev, ptr);
+        else
+                devres_free(ptr);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(devm_iio_device_register);
+
+/**
+ * devm_iio_device_unregister - Resource-managed iio_device_unregister()
+ * @dev:        Device this iio_dev belongs to
+ * @indio_dev:  the iio_dev associated with the device
+ *
+ * Unregister iio_dev registered with devm_iio_device_register().
+ */
+void devm_iio_device_unregister(struct device *dev, struct iio_dev *indio_dev)
+{
+        int rc;
+
+        rc = devres_release(dev, devm_iio_device_unreg,
+                            devm_iio_device_match, indio_dev);
+        WARN_ON(rc);
+}
+EXPORT_SYMBOL_GPL(devm_iio_device_unregister);
+
 subsys_initcall(iio_init);
 module_exit(iio_exit);
 
diff --git a/drivers/iio/industrialio-event.c b/drivers/iio/industrialio-event.c
index c10eab64bc05..bc043fab4cd1 100644
--- a/drivers/iio/industrialio-event.c
+++ b/drivers/iio/industrialio-event.c
@@ -42,6 +42,12 @@ struct iio_event_interface {
         struct attribute_group  group;
 };
 
+/**
+ * iio_push_event() - try to add event to the list for userspace reading
+ * @indio_dev:          IIO device structure
+ * @ev_code:            What event
+ * @timestamp:          When the event occurred
+ **/
 int iio_push_event(struct iio_dev *indio_dev, u64 ev_code, s64 timestamp)
 {
         struct iio_event_interface *ev_int = indio_dev->event_interface;
diff --git a/drivers/iio/industrialio-trigger.c b/drivers/iio/industrialio-trigger.c
index bf5e70a32d3f..7ba2f002ffca 100644
--- a/drivers/iio/industrialio-trigger.c
+++ b/drivers/iio/industrialio-trigger.c
@@ -318,7 +318,7 @@ static ssize_t iio_trigger_read_current(struct device *dev,
  * iio_trigger_write_current() - trigger consumer sysfs set current trigger
  *
  * For trigger consumers the current_trigger interface allows the trigger
- * used for this device to be specified at run time based on the triggers
+ * used for this device to be specified at run time based on the trigger's
  * name.
  **/
 static ssize_t iio_trigger_write_current(struct device *dev,
@@ -356,7 +356,7 @@ static ssize_t iio_trigger_write_current(struct device *dev,
 
         indio_dev->trig = trig;
 
-        if (oldtrig && indio_dev->trig != oldtrig)
+        if (oldtrig)
                 iio_trigger_put(oldtrig);
         if (indio_dev->trig)
                 iio_trigger_get(indio_dev->trig);
@@ -506,6 +506,23 @@ static int devm_iio_trigger_match(struct device *dev, void *res, void *data)
         return *r == data;
 }
 
+/**
+ * devm_iio_trigger_alloc - Resource-managed iio_trigger_alloc()
+ * @dev:                Device to allocate iio_trigger for
+ * @fmt:                trigger name format. If it includes format
+ *                      specifiers, the additional arguments following
+ *                      format are formatted and inserted in the resulting
+ *                      string replacing their respective specifiers.
+ *
+ * Managed iio_trigger_alloc.  iio_trigger allocated with this function is
+ * automatically freed on driver detach.
+ *
+ * If an iio_trigger allocated with this function needs to be freed separately,
+ * devm_iio_trigger_free() must be used.
+ *
+ * RETURNS:
+ * Pointer to allocated iio_trigger on success, NULL on failure.
+ */
 struct iio_trigger *devm_iio_trigger_alloc(struct device *dev,
                                                 const char *fmt, ...)
 {
@@ -532,6 +549,13 @@ struct iio_trigger *devm_iio_trigger_alloc(struct device *dev,
 }
 EXPORT_SYMBOL_GPL(devm_iio_trigger_alloc);
 
+/**
+ * devm_iio_trigger_free - Resource-managed iio_trigger_free()
+ * @dev:                Device this iio_dev belongs to
+ * @iio_trig:           the iio_trigger associated with the device
+ *
+ * Free iio_trigger allocated with devm_iio_trigger_alloc().
+ */
 void devm_iio_trigger_free(struct device *dev, struct iio_trigger *iio_trig)
 {
         int rc;
diff --git a/drivers/iio/light/hid-sensor-als.c b/drivers/iio/light/hid-sensor-als.c
index fa6ae8cf89ea..0c7f115ee3b3 100644
--- a/drivers/iio/light/hid-sensor-als.c
+++ b/drivers/iio/light/hid-sensor-als.c
@@ -229,6 +229,17 @@ static int als_parse_report(struct platform_device *pdev,
         dev_dbg(&pdev->dev, "als %x:%x\n", st->als_illum.index,
                         st->als_illum.report_id);
 
+        /* Set Sensitivity field ids, when there is no individual modifier */
+        if (st->common_attributes.sensitivity.index < 0) {
+                sensor_hub_input_get_attribute_info(hsdev,
+                        HID_FEATURE_REPORT, usage_id,
+                        HID_USAGE_SENSOR_DATA_MOD_CHANGE_SENSITIVITY_ABS |
+                        HID_USAGE_SENSOR_DATA_LIGHT,
+                        &st->common_attributes.sensitivity);
+                dev_dbg(&pdev->dev, "Sensitivity index:report %d:%d\n",
+                        st->common_attributes.sensitivity.index,
+                        st->common_attributes.sensitivity.report_id);
+        }
         return ret;
 }
 
diff --git a/drivers/iio/light/tsl2563.c b/drivers/iio/light/tsl2563.c
index 5e5d9dea22c5..0c6e459c86b1 100644
--- a/drivers/iio/light/tsl2563.c
+++ b/drivers/iio/light/tsl2563.c
@@ -714,6 +714,7 @@ static int tsl2563_probe(struct i2c_client *client,
         struct iio_dev *indio_dev;
         struct tsl2563_chip *chip;
         struct tsl2563_platform_data *pdata = client->dev.platform_data;
+        struct device_node *np = client->dev.of_node;
         int err = 0;
         u8 id = 0;
 
@@ -750,6 +751,9 @@ static int tsl2563_probe(struct i2c_client *client,
 
         if (pdata)
                 chip->cover_comp_gain = pdata->cover_comp_gain;
+        else if (np)
+                of_property_read_u32(np, "amstaos,cover-comp-gain",
+                                     &chip->cover_comp_gain);
         else
                 chip->cover_comp_gain = 1;
 
diff --git a/drivers/iio/light/vcnl4000.c b/drivers/iio/light/vcnl4000.c
index ecb3341ef9c0..384ac23f576f 100644
--- a/drivers/iio/light/vcnl4000.c
+++ b/drivers/iio/light/vcnl4000.c
@@ -179,13 +179,7 @@ static int vcnl4000_probe(struct i2c_client *client,
         indio_dev->name = VCNL4000_DRV_NAME;
         indio_dev->modes = INDIO_DIRECT_MODE;
 
-        return iio_device_register(indio_dev);
-}
-
-static int vcnl4000_remove(struct i2c_client *client)
-{
-        iio_device_unregister(i2c_get_clientdata(client));
-        return 0;
+        return devm_iio_device_register(&client->dev, indio_dev);
 }
 
 static struct i2c_driver vcnl4000_driver = {
@@ -194,7 +188,6 @@ static struct i2c_driver vcnl4000_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe  = vcnl4000_probe,
-        .remove = vcnl4000_remove,
         .id_table = vcnl4000_id,
 };
 
diff --git a/drivers/iio/magnetometer/hid-sensor-magn-3d.c b/drivers/iio/magnetometer/hid-sensor-magn-3d.c
index 2634920562fb..67fce1916d21 100644
--- a/drivers/iio/magnetometer/hid-sensor-magn-3d.c
+++ b/drivers/iio/magnetometer/hid-sensor-magn-3d.c
@@ -263,6 +263,18 @@ static int magn_3d_parse_report(struct platform_device *pdev,
                         st->magn[1].index, st->magn[1].report_id,
                         st->magn[2].index, st->magn[2].report_id);
 
+        /* Set Sensitivity field ids, when there is no individual modifier */
+        if (st->common_attributes.sensitivity.index < 0) {
+                sensor_hub_input_get_attribute_info(hsdev,
+                        HID_FEATURE_REPORT, usage_id,
+                        HID_USAGE_SENSOR_DATA_MOD_CHANGE_SENSITIVITY_ABS |
+                        HID_USAGE_SENSOR_DATA_ORIENTATION,
+                        &st->common_attributes.sensitivity);
+                dev_dbg(&pdev->dev, "Sensitivity index:report %d:%d\n",
+                        st->common_attributes.sensitivity.index,
+                        st->common_attributes.sensitivity.report_id);
+        }
+
         return ret;
 }
 
diff --git a/drivers/iio/pressure/Kconfig b/drivers/iio/pressure/Kconfig
index 4f2e0f9bad8c..a8b9cae5c173 100644
--- a/drivers/iio/pressure/Kconfig
+++ b/drivers/iio/pressure/Kconfig
@@ -5,6 +5,18 @@
 
 menu "Pressure sensors"
 
+config MPL3115
+        tristate "Freescale MPL3115A2 pressure sensor driver"
+        depends on I2C
+        select IIO_BUFFER
+        select IIO_TRIGGERED_BUFFER
+        help
+          Say yes here to build support for the Freescale MPL3115A2
+          pressure sensor / altimeter.
+
+          To compile this driver as a module, choose M here: the module
+          will be called mpl3115.
+
 config IIO_ST_PRESS
         tristate "STMicroelectronics pressure sensor Driver"
         depends on (I2C || SPI_MASTER) && SYSFS
diff --git a/drivers/iio/pressure/Makefile b/drivers/iio/pressure/Makefile
index be71464c2752..42bb9fcf5436 100644
--- a/drivers/iio/pressure/Makefile
+++ b/drivers/iio/pressure/Makefile
@@ -3,6 +3,7 @@
 #
 
 # When adding new entries keep the list in alphabetical order
+obj-$(CONFIG_MPL3115) += mpl3115.o
 obj-$(CONFIG_IIO_ST_PRESS) += st_pressure.o
 st_pressure-y := st_pressure_core.o
 st_pressure-$(CONFIG_IIO_BUFFER) += st_pressure_buffer.o
diff --git a/drivers/iio/pressure/mpl3115.c b/drivers/iio/pressure/mpl3115.c
new file mode 100644
index 000000000000..ac8c8ab723e5
--- /dev/null
+++ b/drivers/iio/pressure/mpl3115.c
@@ -0,0 +1,329 @@
+/*
+ * mpl3115.c - Support for Freescale MPL3115A2 pressure/temperature sensor
+ *
+ * Copyright (c) 2013 Peter Meerwald <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.
+ *
+ * (7-bit I2C slave address 0x60)
+ *
+ * TODO: FIFO buffer, altimeter mode, oversampling, continuous mode,
+ * interrupts, user offset correction, raw mode
+ */
+
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/iio/iio.h>
+#include <linux/iio/sysfs.h>
+#include <linux/iio/trigger_consumer.h>
+#include <linux/iio/buffer.h>
+#include <linux/iio/triggered_buffer.h>
+#include <linux/delay.h>
+
+#define MPL3115_STATUS 0x00
+#define MPL3115_OUT_PRESS 0x01 /* MSB first, 20 bit */
+#define MPL3115_OUT_TEMP 0x04 /* MSB first, 12 bit */
+#define MPL3115_WHO_AM_I 0x0c
+#define MPL3115_CTRL_REG1 0x26
+
+#define MPL3115_DEVICE_ID 0xc4
+
+#define MPL3115_STATUS_PRESS_RDY BIT(2)
+#define MPL3115_STATUS_TEMP_RDY BIT(1)
+
+#define MPL3115_CTRL_RESET BIT(2) /* software reset */
+#define MPL3115_CTRL_OST BIT(1) /* initiate measurement */
+#define MPL3115_CTRL_ACTIVE BIT(0) /* continuous measurement */
+#define MPL3115_CTRL_OS_258MS (BIT(5) | BIT(4)) /* 64x oversampling */
+
+struct mpl3115_data {
+        struct i2c_client *client;
+        struct mutex lock;
+        u8 ctrl_reg1;
+};
+
+static int mpl3115_request(struct mpl3115_data *data)
+{
+        int ret, tries = 15;
+
+        /* trigger measurement */
+        ret = i2c_smbus_write_byte_data(data->client, MPL3115_CTRL_REG1,
+                data->ctrl_reg1 | MPL3115_CTRL_OST);
+        if (ret < 0)
+                return ret;
+
+        while (tries-- > 0) {
+                ret = i2c_smbus_read_byte_data(data->client, MPL3115_CTRL_REG1);
+                if (ret < 0)
+                        return ret;
+                /* wait for data ready, i.e. OST cleared */
+                if (!(ret & MPL3115_CTRL_OST))
+                        break;
+                msleep(20);
+        }
+
+        if (tries < 0) {
+                dev_err(&data->client->dev, "data not ready\n");
+                return -EIO;
+        }
+
+        return 0;
+}
+
+static int mpl3115_read_raw(struct iio_dev *indio_dev,
+                            struct iio_chan_spec const *chan,
+                            int *val, int *val2, long mask)
+{
+        struct mpl3115_data *data = iio_priv(indio_dev);
+        s32 tmp = 0;
+        int ret;
+
+        switch (mask) {
+        case IIO_CHAN_INFO_RAW:
+                if (iio_buffer_enabled(indio_dev))
+                        return -EBUSY;
+
+                switch (chan->type) {
+                case IIO_PRESSURE: /* in 0.25 pascal / LSB */
+                        mutex_lock(&data->lock);
+                        ret = mpl3115_request(data);
+                        if (ret < 0) {
+                                mutex_unlock(&data->lock);
+                                return ret;
+                        }
+                        ret = i2c_smbus_read_i2c_block_data(data->client,
+                                MPL3115_OUT_PRESS, 3, (u8 *) &tmp);
+                        mutex_unlock(&data->lock);
+                        if (ret < 0)
+                                return ret;
+                        *val = sign_extend32(be32_to_cpu(tmp) >> 12, 23);
+                        return IIO_VAL_INT;
+                case IIO_TEMP: /* in 0.0625 celsius / LSB */
+                        mutex_lock(&data->lock);
+                        ret = mpl3115_request(data);
+                        if (ret < 0) {
+                                mutex_unlock(&data->lock);
+                                return ret;
+                        }
+                        ret = i2c_smbus_read_i2c_block_data(data->client,
+                                MPL3115_OUT_TEMP, 2, (u8 *) &tmp);
+                        mutex_unlock(&data->lock);
+                        if (ret < 0)
+                                return ret;
+                        *val = sign_extend32(be32_to_cpu(tmp) >> 20, 15);
+                        return IIO_VAL_INT;
+                default:
+                        return -EINVAL;
+                }
+        case IIO_CHAN_INFO_SCALE:
+                switch (chan->type) {
+                case IIO_PRESSURE:
+                        *val = 0;
+                        *val2 = 250; /* want kilopascal */
+                        return IIO_VAL_INT_PLUS_MICRO;
+                case IIO_TEMP:
+                        *val = 0;
+                        *val2 = 62500;
+                        return IIO_VAL_INT_PLUS_MICRO;
+                default:
+                        return -EINVAL;
+                }
+        }
+        return -EINVAL;
+}
+
+static irqreturn_t mpl3115_trigger_handler(int irq, void *p)
+{
+        struct iio_poll_func *pf = p;
+        struct iio_dev *indio_dev = pf->indio_dev;
+        struct mpl3115_data *data = iio_priv(indio_dev);
+        u8 buffer[16]; /* 32-bit channel + 16-bit channel + padding + ts */
+        int ret, pos = 0;
+
+        mutex_lock(&data->lock);
+        ret = mpl3115_request(data);
+        if (ret < 0) {
+                mutex_unlock(&data->lock);
+                goto done;
+        }
+
+        memset(buffer, 0, sizeof(buffer));
+        if (test_bit(0, indio_dev->active_scan_mask)) {
+                ret = i2c_smbus_read_i2c_block_data(data->client,
+                        MPL3115_OUT_PRESS, 3, &buffer[pos]);
+                if (ret < 0) {
+                        mutex_unlock(&data->lock);
+                        goto done;
+                }
+                pos += 4;
+        }
+
+        if (test_bit(1, indio_dev->active_scan_mask)) {
+                ret = i2c_smbus_read_i2c_block_data(data->client,
+                        MPL3115_OUT_TEMP, 2, &buffer[pos]);
+                if (ret < 0) {
+                        mutex_unlock(&data->lock);
+                        goto done;
+                }
+        }
+        mutex_unlock(&data->lock);
+
+        iio_push_to_buffers_with_timestamp(indio_dev, buffer,
+                iio_get_time_ns());
+
+done:
+        iio_trigger_notify_done(indio_dev->trig);
+        return IRQ_HANDLED;
+}
+
+static const struct iio_chan_spec mpl3115_channels[] = {
+        {
+                .type = IIO_PRESSURE,
+                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
+                        BIT(IIO_CHAN_INFO_SCALE),
+                .scan_index = 0,
+                .scan_type = {
+                        .sign = 's',
+                        .realbits = 20,
+                        .storagebits = 32,
+                        .shift = 12,
+                        .endianness = IIO_BE,
+                }
+        },
+        {
+                .type = IIO_TEMP,
+                .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
+                        BIT(IIO_CHAN_INFO_SCALE),
+                .scan_index = 1,
+                .scan_type = {
+                        .sign = 's',
+                        .realbits = 12,
+                        .storagebits = 16,
+                        .shift = 4,
+                        .endianness = IIO_BE,
+                }
+        },
+        IIO_CHAN_SOFT_TIMESTAMP(2),
+};
+
+static const struct iio_info mpl3115_info = {
+        .read_raw = &mpl3115_read_raw,
+        .driver_module = THIS_MODULE,
+};
+
+static int mpl3115_probe(struct i2c_client *client,
+                         const struct i2c_device_id *id)
+{
+        struct mpl3115_data *data;
+        struct iio_dev *indio_dev;
+        int ret;
+
+        ret = i2c_smbus_read_byte_data(client, MPL3115_WHO_AM_I);
+        if (ret < 0)
+                return ret;
+        if (ret != MPL3115_DEVICE_ID)
+                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->lock);
+
+        i2c_set_clientdata(client, indio_dev);
+        indio_dev->info = &mpl3115_info;
+        indio_dev->name = id->name;
+        indio_dev->dev.parent = &client->dev;
+        indio_dev->modes = INDIO_DIRECT_MODE;
+        indio_dev->channels = mpl3115_channels;
+        indio_dev->num_channels = ARRAY_SIZE(mpl3115_channels);
+
+        /* software reset, I2C transfer is aborted (fails) */
+        i2c_smbus_write_byte_data(client, MPL3115_CTRL_REG1,
+                MPL3115_CTRL_RESET);
+        msleep(50);
+
+        data->ctrl_reg1 = MPL3115_CTRL_OS_258MS;
+        ret = i2c_smbus_write_byte_data(client, MPL3115_CTRL_REG1,
+                data->ctrl_reg1);
+        if (ret < 0)
+                return ret;
+
+        ret = iio_triggered_buffer_setup(indio_dev, NULL,
+                mpl3115_trigger_handler, NULL);
+        if (ret < 0)
+                return ret;
+
+        ret = iio_device_register(indio_dev);
+        if (ret < 0)
+                goto buffer_cleanup;
+        return 0;
+
+buffer_cleanup:
+        iio_triggered_buffer_cleanup(indio_dev);
+        return ret;
+}
+
+static int mpl3115_standby(struct mpl3115_data *data)
+{
+        return i2c_smbus_write_byte_data(data->client, MPL3115_CTRL_REG1,
+                data->ctrl_reg1 & ~MPL3115_CTRL_ACTIVE);
+}
+
+static int mpl3115_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);
+        mpl3115_standby(iio_priv(indio_dev));
+
+        return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int mpl3115_suspend(struct device *dev)
+{
+        return mpl3115_standby(iio_priv(i2c_get_clientdata(
+                to_i2c_client(dev))));
+}
+
+static int mpl3115_resume(struct device *dev)
+{
+        struct mpl3115_data *data = iio_priv(i2c_get_clientdata(
+                to_i2c_client(dev)));
+
+        return i2c_smbus_write_byte_data(data->client, MPL3115_CTRL_REG1,
+                data->ctrl_reg1);
+}
+
+static SIMPLE_DEV_PM_OPS(mpl3115_pm_ops, mpl3115_suspend, mpl3115_resume);
+#define MPL3115_PM_OPS (&mpl3115_pm_ops)
+#else
+#define MPL3115_PM_OPS NULL
+#endif
+
+static const struct i2c_device_id mpl3115_id[] = {
+        { "mpl3115", 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, mpl3115_id);
+
+static struct i2c_driver mpl3115_driver = {
+        .driver = {
+                .name   = "mpl3115",
+                .pm     = MPL3115_PM_OPS,
+        },
+        .probe = mpl3115_probe,
+        .remove = mpl3115_remove,
+        .id_table = mpl3115_id,
+};
+module_i2c_driver(mpl3115_driver);
+
+MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>");
+MODULE_DESCRIPTION("Freescale MPL3115 pressure/temperature driver");
+MODULE_LICENSE("GPL");