PM / QoS: Add function dev_pm_qos_read_value() (v3)

To read the current PM QoS value for a given device we need to
make sure that the device's power.constraints object won't be
removed while we're doing that.  For this reason, put the
operation under dev->power.lock and acquire the lock
around the initialization and removal of power.constraints.

Moreover, since we're using the value of power.constraints to
determine whether or not the object is present, the
power.constraints_state field isn't necessary any more and may be
removed.  However, dev_pm_qos_add_request() needs to check if the
device is being removed from the system before allocating a new
PM QoS constraints object for it, so make it use the
power.power_state field of struct device for this purpose.

Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>

3 files changed, 102 insertions, 74 deletions

diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 956443f86254..c6291ab725a3 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -22,7 +22,6 @@
 #include <linux/mutex.h>
 #include <linux/pm.h>
 #include <linux/pm_runtime.h>
-#include <linux/pm_qos.h>
 #include <linux/resume-trace.h>
 #include <linux/interrupt.h>
 #include <linux/sched.h>
@@ -66,6 +65,7 @@ void device_pm_init(struct device *dev)
         spin_lock_init(&dev->power.lock);
         pm_runtime_init(dev);
         INIT_LIST_HEAD(&dev->power.entry);
+        dev->power.power_state = PMSG_INVALID;
 }
 
 /**
@@ -97,8 +97,8 @@ void device_pm_add(struct device *dev)
                 dev_warn(dev, "parent %s should not be sleeping\n",
                         dev_name(dev->parent));
         list_add_tail(&dev->power.entry, &dpm_list);
-        mutex_unlock(&dpm_list_mtx);
         dev_pm_qos_constraints_init(dev);
+        mutex_unlock(&dpm_list_mtx);
 }
 
 /**
@@ -109,9 +109,9 @@ void device_pm_remove(struct device *dev)
 {
         pr_debug("PM: Removing info for %s:%s\n",
                  dev->bus ? dev->bus->name : "No Bus", dev_name(dev));
-        dev_pm_qos_constraints_destroy(dev);
         complete_all(&dev->power.completion);
         mutex_lock(&dpm_list_mtx);
+        dev_pm_qos_constraints_destroy(dev);
         list_del_init(&dev->power.entry);
         mutex_unlock(&dpm_list_mtx);
         device_wakeup_disable(dev);
diff --git a/drivers/base/power/power.h b/drivers/base/power/power.h
index f2a25f18fde7..9bf62323aaf3 100644
--- a/drivers/base/power/power.h
+++ b/drivers/base/power/power.h
@@ -1,3 +1,5 @@
+#include <linux/pm_qos.h>
+
 #ifdef CONFIG_PM_RUNTIME
 
 extern void pm_runtime_init(struct device *dev);
@@ -35,15 +37,21 @@ extern void device_pm_move_last(struct device *);
 static inline void device_pm_init(struct device *dev)
 {
         spin_lock_init(&dev->power.lock);
+        dev->power.power_state = PMSG_INVALID;
         pm_runtime_init(dev);
 }
 
+static inline void device_pm_add(struct device *dev)
+{
+        dev_pm_qos_constraints_init(dev);
+}
+
 static inline void device_pm_remove(struct device *dev)
 {
+        dev_pm_qos_constraints_destroy(dev);
         pm_runtime_remove(dev);
 }
 
-static inline void device_pm_add(struct device *dev) {}
 static inline void device_pm_move_before(struct device *deva,
                                          struct device *devb) {}
 static inline void device_pm_move_after(struct device *deva,
diff --git a/drivers/base/power/qos.c b/drivers/base/power/qos.c
index 8d0b81151c14..91e061417382 100644
--- a/drivers/base/power/qos.c
+++ b/drivers/base/power/qos.c
@@ -30,15 +30,6 @@
  * . To minimize the data usage by the per-device constraints, the data struct
  *   is only allocated at the first call to dev_pm_qos_add_request.
  * . The data is later free'd when the device is removed from the system.
- * . The constraints_state variable from dev_pm_info tracks the data struct
- *    allocation state:
- *    DEV_PM_QOS_NO_DEVICE: No device present or device removed, no data
- *     allocated,
- *    DEV_PM_QOS_DEVICE_PRESENT: Device present, data not allocated and will be
- *     allocated at the first call to dev_pm_qos_add_request,
- *    DEV_PM_QOS_ALLOCATED: Device present, data allocated. The per-device
- *     PM QoS constraints framework is operational and constraints can be
- *     added, updated or removed using the dev_pm_qos_* API.
  *  . A global mutex protects the constraints users from the data being
  *     allocated and free'd.
  */
@@ -51,8 +42,30 @@
 
 
 static DEFINE_MUTEX(dev_pm_qos_mtx);
+
 static BLOCKING_NOTIFIER_HEAD(dev_pm_notifiers);
 
+/**
+ * dev_pm_qos_read_value - Get PM QoS constraint for a given device.
+ * @dev: Device to get the PM QoS constraint value for.
+ */
+s32 dev_pm_qos_read_value(struct device *dev)
+{
+        struct pm_qos_constraints *c;
+        unsigned long flags;
+        s32 ret = 0;
+
+        spin_lock_irqsave(&dev->power.lock, flags);
+
+        c = dev->power.constraints;
+        if (c)
+                ret = pm_qos_read_value(c);
+
+        spin_unlock_irqrestore(&dev->power.lock, flags);
+
+        return ret;
+}
+
 /*
  * apply_constraint
  * @req: constraint request to apply
@@ -105,27 +118,31 @@ static int dev_pm_qos_constraints_allocate(struct device *dev)
         }
         BLOCKING_INIT_NOTIFIER_HEAD(n);
 
+        plist_head_init(&c->list);
+        c->target_value = PM_QOS_DEV_LAT_DEFAULT_VALUE;
+        c->default_value = PM_QOS_DEV_LAT_DEFAULT_VALUE;
+        c->type = PM_QOS_MIN;
+        c->notifiers = n;
+
+        spin_lock_irq(&dev->power.lock);
         dev->power.constraints = c;
-        plist_head_init(&dev->power.constraints->list);
-        dev->power.constraints->target_value = PM_QOS_DEV_LAT_DEFAULT_VALUE;
-        dev->power.constraints->default_value = PM_QOS_DEV_LAT_DEFAULT_VALUE;
-        dev->power.constraints->type = PM_QOS_MIN;
-        dev->power.constraints->notifiers = n;
-        dev->power.constraints_state = DEV_PM_QOS_ALLOCATED;
+        spin_unlock_irq(&dev->power.lock);
 
         return 0;
 }
 
 /**
- * dev_pm_qos_constraints_init
+ * dev_pm_qos_constraints_init - Initalize device's PM QoS constraints pointer.
  * @dev: target device
  *
- * Called from the device PM subsystem at device insertion
+ * Called from the device PM subsystem during device insertion under
+ * device_pm_lock().
  */
 void dev_pm_qos_constraints_init(struct device *dev)
 {
         mutex_lock(&dev_pm_qos_mtx);
-        dev->power.constraints_state = DEV_PM_QOS_DEVICE_PRESENT;
+        dev->power.constraints = NULL;
+        dev->power.power_state = PMSG_ON;
         mutex_unlock(&dev_pm_qos_mtx);
 }
 
@@ -133,34 +150,38 @@ void dev_pm_qos_constraints_init(struct device *dev)
  * dev_pm_qos_constraints_destroy
  * @dev: target device
  *
- * Called from the device PM subsystem at device removal
+ * Called from the device PM subsystem on device removal under device_pm_lock().
  */
 void dev_pm_qos_constraints_destroy(struct device *dev)
 {
         struct dev_pm_qos_request *req, *tmp;
+        struct pm_qos_constraints *c;
 
         mutex_lock(&dev_pm_qos_mtx);
 
-        if (dev->power.constraints_state == DEV_PM_QOS_ALLOCATED) {
-                /* Flush the constraints list for the device */
-                plist_for_each_entry_safe(req, tmp,
-                                          &dev->power.constraints->list,
-                                          node) {
-                        /*
-                         * Update constraints list and call the notification
-                         * callbacks if needed
-                         */
-                        apply_constraint(req, PM_QOS_REMOVE_REQ,
-                                         PM_QOS_DEFAULT_VALUE);
-                        memset(req, 0, sizeof(*req));
-                }
+        dev->power.power_state = PMSG_INVALID;
+        c = dev->power.constraints;
+        if (!c)
+                goto out;
 
-                kfree(dev->power.constraints->notifiers);
-                kfree(dev->power.constraints);
-                dev->power.constraints = NULL;
+        /* Flush the constraints list for the device */
+        plist_for_each_entry_safe(req, tmp, &c->list, node) {
+                /*
+                 * Update constraints list and call the notification
+                 * callbacks if needed
+                 */
+                apply_constraint(req, PM_QOS_REMOVE_REQ, PM_QOS_DEFAULT_VALUE);
+                memset(req, 0, sizeof(*req));
         }
-        dev->power.constraints_state = DEV_PM_QOS_NO_DEVICE;
 
+        spin_lock_irq(&dev->power.lock);
+        dev->power.constraints = NULL;
+        spin_unlock_irq(&dev->power.lock);
+
+        kfree(c->notifiers);
+        kfree(c);
+
+ out:
         mutex_unlock(&dev_pm_qos_mtx);
 }
 
@@ -178,8 +199,9 @@ void dev_pm_qos_constraints_destroy(struct device *dev)
  *
  * Returns 1 if the aggregated constraint value has changed,
  * 0 if the aggregated constraint value has not changed,
- * -EINVAL in case of wrong parameters, -ENODEV if the device has been
- * removed from the system
+ * -EINVAL in case of wrong parameters, -ENOMEM if there's not enough memory
+ * to allocate for data structures, -ENODEV if the device has just been removed
+ * from the system.
  */
 int dev_pm_qos_add_request(struct device *dev, struct dev_pm_qos_request *req,
                            s32 value)
@@ -195,28 +217,32 @@ int dev_pm_qos_add_request(struct device *dev, struct dev_pm_qos_request *req,
                 return -EINVAL;
         }
 
-        mutex_lock(&dev_pm_qos_mtx);
         req->dev = dev;
 
-        /* Return if the device has been removed */
-        if (req->dev->power.constraints_state == DEV_PM_QOS_NO_DEVICE) {
-                ret = -ENODEV;
-                goto out;
-        }
+        mutex_lock(&dev_pm_qos_mtx);
 
-        /*
-         * Allocate the constraints data on the first call to add_request,
-         * i.e. only if the data is not already allocated and if the device has
-         * not been removed
-         */
-        if (dev->power.constraints_state == DEV_PM_QOS_DEVICE_PRESENT)
-                ret = dev_pm_qos_constraints_allocate(dev);
+        if (!dev->power.constraints) {
+                if (dev->power.power_state.event == PM_EVENT_INVALID) {
+                        /* The device has been removed from the system. */
+                        req->dev = NULL;
+                        ret = -ENODEV;
+                        goto out;
+                } else {
+                        /*
+                         * Allocate the constraints data on the first call to
+                         * add_request, i.e. only if the data is not already
+                         * allocated and if the device has not been removed.
+                         */
+                        ret = dev_pm_qos_constraints_allocate(dev);
+                }
+        }
 
         if (!ret)
                 ret = apply_constraint(req, PM_QOS_ADD_REQ, value);
 
-out:
+ out:
         mutex_unlock(&dev_pm_qos_mtx);
+
         return ret;
 }
 EXPORT_SYMBOL_GPL(dev_pm_qos_add_request);
@@ -252,7 +278,7 @@ int dev_pm_qos_update_request(struct dev_pm_qos_request *req,
 
         mutex_lock(&dev_pm_qos_mtx);
 
-        if (req->dev->power.constraints_state == DEV_PM_QOS_ALLOCATED) {
+        if (req->dev->power.constraints) {
                 if (new_value != req->node.prio)
                         ret = apply_constraint(req, PM_QOS_UPDATE_REQ,
                                                new_value);
@@ -293,7 +319,7 @@ int dev_pm_qos_remove_request(struct dev_pm_qos_request *req)
 
         mutex_lock(&dev_pm_qos_mtx);
 
-        if (req->dev->power.constraints_state == DEV_PM_QOS_ALLOCATED) {
+        if (req->dev->power.constraints) {
                 ret = apply_constraint(req, PM_QOS_REMOVE_REQ,
                                        PM_QOS_DEFAULT_VALUE);
                 memset(req, 0, sizeof(*req));
@@ -323,15 +349,12 @@ int dev_pm_qos_add_notifier(struct device *dev, struct notifier_block *notifier)
 
         mutex_lock(&dev_pm_qos_mtx);
 
-        /* Silently return if the device has been removed */
-        if (dev->power.constraints_state != DEV_PM_QOS_ALLOCATED)
-                goto out;
-
-        retval = blocking_notifier_chain_register(
-                        dev->power.constraints->notifiers,
-                        notifier);
+        /* Silently return if the constraints object is not present. */
+        if (dev->power.constraints)
+                retval = blocking_notifier_chain_register(
+                                dev->power.constraints->notifiers,
+                                notifier);
 
-out:
         mutex_unlock(&dev_pm_qos_mtx);
         return retval;
 }
@@ -354,15 +377,12 @@ int dev_pm_qos_remove_notifier(struct device *dev,
 
         mutex_lock(&dev_pm_qos_mtx);
 
-        /* Silently return if the device has been removed */
-        if (dev->power.constraints_state != DEV_PM_QOS_ALLOCATED)
-                goto out;
-
-        retval = blocking_notifier_chain_unregister(
-                        dev->power.constraints->notifiers,
-                        notifier);
+        /* Silently return if the constraints object is not present. */
+        if (dev->power.constraints)
+                retval = blocking_notifier_chain_unregister(
+                                dev->power.constraints->notifiers,
+                                notifier);
 
-out:
         mutex_unlock(&dev_pm_qos_mtx);
         return retval;
 }