iio: light: ltr390: Implement runtime PM support

Implement runtime power management for the LTR390 sensor. The device
autosuspends after 1s of idle time, reducing current consumption from
100 µA in active mode to 1 µA in standby mode as per the datasheet.

Ensure that interrupts continue to be delivered with runtime PM.
Since the LTR390 cannot be used as a wakeup source during runtime
suspend, therefore increment the runtime PM refcount when enabling
events and decrement it when disabling events or powering down.
This prevents event loss while still allowing power savings when IRQs
are unused.

Signed-off-by: Akshay Jindal <akshayaj.lkd@gmail.com>
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>

diff --git a/drivers/iio/light/ltr390.c b/drivers/iio/light/ltr390.c
index 2e1cf62e82012004fb70a1c3cd068e07c2421935..a2b804e9089aa092c1007cbff7be867007a312f4 100644 (file)
--- a/drivers/iio/light/ltr390.c
+++ b/drivers/iio/light/ltr390.c
@@ -26,6 +26,7 @@
 #include <linux/math.h>
 #include <linux/module.h>
 #include <linux/mutex.h>
+#include <linux/pm_runtime.h>
 #include <linux/regmap.h>
 
 #include <linux/iio/iio.h>
@@ -105,6 +106,7 @@ struct ltr390_data {
        enum ltr390_mode mode;
        int gain;
        int int_time_us;
+       bool irq_enabled;
 };
 
 static const struct regmap_range ltr390_readable_reg_ranges[] = {
@@ -215,9 +217,10 @@ static int ltr390_get_samp_freq_or_period(struct ltr390_data *data,
        return ltr390_samp_freq_table[value][option];
 }
 
-static int ltr390_read_raw(struct iio_dev *iio_device,
-                          struct iio_chan_spec const *chan, int *val,
-                          int *val2, long mask)
+
+static int ltr390_do_read_raw(struct iio_dev *iio_device,
+                             struct iio_chan_spec const *chan, int *val,
+                             int *val2, long mask)
 {
        int ret;
        struct ltr390_data *data = iio_priv(iio_device);
@@ -280,6 +283,27 @@ static int ltr390_read_raw(struct iio_dev *iio_device,
        }
 }
 
+static int ltr390_read_raw(struct iio_dev *iio_device,
+                          struct iio_chan_spec const *chan,
+                          int *val, int *val2, long mask)
+{
+       int ret;
+       struct ltr390_data *data = iio_priv(iio_device);
+       struct device *dev = &data->client->dev;
+
+       ret = pm_runtime_resume_and_get(dev);
+       if (ret < 0) {
+               dev_err(dev, "runtime PM failed to resume: %d\n", ret);
+               return ret;
+       }
+
+       ret = ltr390_do_read_raw(iio_device, chan, val, val2, mask);
+
+       pm_runtime_put_autosuspend(dev);
+
+       return ret;
+}
+
 /* integration time in us */
 static const int ltr390_int_time_map_us[] = { 400000, 200000, 100000, 50000, 25000, 12500 };
 static const int ltr390_gain_map[] = { 1, 3, 6, 9, 18 };
@@ -586,11 +610,11 @@ static int ltr390_read_event_config(struct iio_dev *indio_dev,
        return FIELD_GET(LTR390_LS_INT_EN, status);
 }
 
-static int ltr390_write_event_config(struct iio_dev *indio_dev,
-                               const struct iio_chan_spec *chan,
-                               enum iio_event_type type,
-                               enum iio_event_direction dir,
-                               bool state)
+static int ltr390_do_event_config(struct iio_dev *indio_dev,
+                                 const struct iio_chan_spec *chan,
+                                 enum iio_event_type type,
+                                 enum iio_event_direction dir,
+                                 bool state)
 {
        struct ltr390_data *data = iio_priv(indio_dev);
        int ret;
@@ -598,7 +622,6 @@ static int ltr390_write_event_config(struct iio_dev *indio_dev,
        if (!state)
                return regmap_clear_bits(data->regmap, LTR390_INT_CFG, LTR390_LS_INT_EN);
 
-       guard(mutex)(&data->lock);
        ret = regmap_set_bits(data->regmap, LTR390_INT_CFG, LTR390_LS_INT_EN);
        if (ret < 0)
                return ret;
@@ -623,6 +646,37 @@ static int ltr390_write_event_config(struct iio_dev *indio_dev,
        }
 }
 
+static int ltr390_write_event_config(struct iio_dev *indio_dev,
+                                    const struct iio_chan_spec *chan,
+                                    enum iio_event_type type,
+                                    enum iio_event_direction dir,
+                                    bool state)
+{
+       int ret;
+       struct ltr390_data *data = iio_priv(indio_dev);
+       struct device *dev = &data->client->dev;
+
+       guard(mutex)(&data->lock);
+
+       if (state && !data->irq_enabled) {
+               ret = pm_runtime_resume_and_get(dev);
+               if (ret < 0) {
+                       dev_err(dev, "runtime PM failed to resume: %d\n", ret);
+                       return ret;
+               }
+               data->irq_enabled = true;
+       }
+
+       ret = ltr390_do_event_config(indio_dev, chan, type, dir, state);
+
+       if (!state && data->irq_enabled) {
+               data->irq_enabled = false;
+               pm_runtime_put_autosuspend(dev);
+       }
+
+       return ret;
+}
+
 static int ltr390_debugfs_reg_access(struct iio_dev *indio_dev,
                                                unsigned int reg, unsigned int writeval,
                                                unsigned int *readval)
@@ -683,17 +737,38 @@ static irqreturn_t ltr390_interrupt_handler(int irq, void *private)
 static void ltr390_powerdown(void *priv)
 {
        struct ltr390_data *data = priv;
+       struct device *dev = &data->client->dev;
+       int ret;
 
        guard(mutex)(&data->lock);
 
        /* Ensure that power off and interrupts are disabled */
-       if (regmap_clear_bits(data->regmap, LTR390_INT_CFG,
-                               LTR390_LS_INT_EN) < 0)
-               dev_err(&data->client->dev, "failed to disable interrupts\n");
+       if (data->irq_enabled) {
+               ret = regmap_clear_bits(data->regmap, LTR390_INT_CFG, LTR390_LS_INT_EN);
+               if (ret < 0)
+                       dev_err(dev, "failed to disable interrupts\n");
+
+               data->irq_enabled = false;
+               pm_runtime_put_autosuspend(dev);
+       }
+
+       ret = regmap_clear_bits(data->regmap, LTR390_MAIN_CTRL, LTR390_SENSOR_ENABLE);
+       if (ret < 0)
+               dev_err(dev, "failed to disable sensor\n");
+}
+
+static int ltr390_pm_init(struct ltr390_data *data)
+{
+       int ret;
+       struct device *dev = &data->client->dev;
+
+       ret = devm_pm_runtime_set_active_enabled(dev);
+       if (ret)
+               return dev_err_probe(dev, ret, "failed to enable runtime PM\n");
 
-       if (regmap_clear_bits(data->regmap, LTR390_MAIN_CTRL,
-                       LTR390_SENSOR_ENABLE) < 0)
-               dev_err(&data->client->dev, "failed to disable sensor\n");
+       pm_runtime_set_autosuspend_delay(dev, 1000);
+       pm_runtime_use_autosuspend(dev);
+       return 0;
 }
 
 static int ltr390_probe(struct i2c_client *client)
@@ -708,6 +783,8 @@ static int ltr390_probe(struct i2c_client *client)
        if (!indio_dev)
                return -ENOMEM;
 
+       i2c_set_clientdata(client, indio_dev);
+
        data = iio_priv(indio_dev);
        data->regmap = devm_regmap_init_i2c(client, &ltr390_regmap_config);
        if (IS_ERR(data->regmap))
@@ -721,6 +798,8 @@ static int ltr390_probe(struct i2c_client *client)
        data->gain = 3;
        /* default mode for ltr390 is ALS mode */
        data->mode = LTR390_SET_ALS_MODE;
+       /* default value of irq_enabled is false */
+       data->irq_enabled = false;
 
        mutex_init(&data->lock);
 
@@ -763,6 +842,10 @@ static int ltr390_probe(struct i2c_client *client)
                                             "request irq (%d) failed\n", client->irq);
        }
 
+       ret = ltr390_pm_init(data);
+       if (ret)
+               return dev_err_probe(dev, ret, "failed to initialize runtime PM\n");
+
        return devm_iio_device_register(dev, indio_dev);
 }
 
@@ -784,7 +867,26 @@ static int ltr390_resume(struct device *dev)
                                LTR390_SENSOR_ENABLE);
 }
 
-static DEFINE_SIMPLE_DEV_PM_OPS(ltr390_pm_ops, ltr390_suspend, ltr390_resume);
+static int ltr390_runtime_suspend(struct device *dev)
+{
+       struct iio_dev *indio_dev = dev_get_drvdata(dev);
+       struct ltr390_data *data = iio_priv(indio_dev);
+
+       return regmap_clear_bits(data->regmap, LTR390_MAIN_CTRL, LTR390_SENSOR_ENABLE);
+}
+
+static int ltr390_runtime_resume(struct device *dev)
+{
+       struct iio_dev *indio_dev = dev_get_drvdata(dev);
+       struct ltr390_data *data = iio_priv(indio_dev);
+
+       return regmap_set_bits(data->regmap, LTR390_MAIN_CTRL, LTR390_SENSOR_ENABLE);
+}
+
+static const struct dev_pm_ops ltr390_pm_ops = {
+       SYSTEM_SLEEP_PM_OPS(ltr390_suspend, ltr390_resume)
+       RUNTIME_PM_OPS(ltr390_runtime_suspend, ltr390_runtime_resume, NULL)
+};
 
 static const struct i2c_device_id ltr390_id[] = {
        { "ltr390" },
@@ -802,7 +904,7 @@ static struct i2c_driver ltr390_driver = {
        .driver = {
                .name = "ltr390",
                .of_match_table = ltr390_of_table,
-               .pm = pm_sleep_ptr(&ltr390_pm_ops),
+               .pm = pm_ptr(&ltr390_pm_ops),
        },
        .probe = ltr390_probe,
        .id_table = ltr390_id,