Merge tag 'pm+acpi-3.9-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm

Pull ACPI and power management fixes from Rafael J Wysocki:

 - Two fixes for the new intel_pstate driver from Dirk Brandewie.

 - Fix for incorrect usage of the .find_bridge() callback from struct
   acpi_bus_type in the USB core and subsequent removal of that callback
   from Rafael J Wysocki.

 - ACPI processor driver cleanups from Chen Gang and Syam Sidhardhan.

 - ACPI initialization and error messages fix from Joe Perches.

 - Operating Performance Points documentation improvement from Nishanth
   Menon.

 - Fixes for memory leaks and potential concurrency issues and sysfs
  attributes leaks during device removal in the core device PM QoS code
  from Rafael J Wysocki.

 - Calxeda Highbank cpufreq driver simplification from Emilio López.

 - cpufreq comment cleanup from Namhyung Kim.

 - Fix for a section mismatch in Calxeda Highbank interprocessor
   communication code from Mark Langsdorf (this is not a PM fix strictly
   speaking, but the code in question went in through the PM tree).

* tag 'pm+acpi-3.9-rc2' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm:
  cpufreq / intel_pstate: Do not load on VM that does not report max P state.
  cpufreq / intel_pstate: Fix intel_pstate_init() error path
  ACPI / glue: Drop .find_bridge() callback from struct acpi_bus_type
  ACPI / glue: Add .match() callback to struct acpi_bus_type
  ACPI / porocessor: Beautify code, pr->id is u32 which is never < 0
  ACPI / processor: Remove redundant NULL check before kfree
  ACPI / Sleep: Avoid interleaved message on errors
  PM / QoS: Remove device PM QoS sysfs attributes at the right place
  PM / QoS: Fix concurrency issues and memory leaks in device PM QoS
  cpufreq: highbank: do not initialize array with a loop
  PM / OPP: improve introductory documentation
  cpufreq: Fix a typo in comment
  mailbox, pl320-ipc: remove __init from probe function

4 files changed, 126 insertions, 102 deletions

diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 2b7f77d3fcb0..15beb500a4e4 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -99,7 +99,6 @@ 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);
-        dev_pm_qos_constraints_init(dev);
         mutex_unlock(&dpm_list_mtx);
 }
 
@@ -113,7 +112,6 @@ void device_pm_remove(struct device *dev)
                  dev->bus ? dev->bus->name : "No Bus", dev_name(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 b16686a0a5a2..cfc3226ec492 100644
--- a/drivers/base/power/power.h
+++ b/drivers/base/power/power.h
@@ -4,7 +4,7 @@ static inline void device_pm_init_common(struct device *dev)
 {
         if (!dev->power.early_init) {
                 spin_lock_init(&dev->power.lock);
-                dev->power.power_state = PMSG_INVALID;
+                dev->power.qos = NULL;
                 dev->power.early_init = true;
         }
 }
@@ -56,14 +56,10 @@ extern void device_pm_move_last(struct device *);
 
 static inline void device_pm_sleep_init(struct device *dev) {}
 
-static inline void device_pm_add(struct device *dev)
-{
-        dev_pm_qos_constraints_init(dev);
-}
+static inline void device_pm_add(struct device *dev) {}
 
 static inline void device_pm_remove(struct device *dev)
 {
-        dev_pm_qos_constraints_destroy(dev);
         pm_runtime_remove(dev);
 }
 
diff --git a/drivers/base/power/qos.c b/drivers/base/power/qos.c
index 3d4d1f8aac5c..5f74587ef258 100644
--- a/drivers/base/power/qos.c
+++ b/drivers/base/power/qos.c
@@ -41,6 +41,7 @@
 #include <linux/mutex.h>
 #include <linux/export.h>
 #include <linux/pm_runtime.h>
+#include <linux/err.h>
 
 #include "power.h"
 
@@ -61,7 +62,7 @@ enum pm_qos_flags_status __dev_pm_qos_flags(struct device *dev, s32 mask)
         struct pm_qos_flags *pqf;
         s32 val;
 
-        if (!qos)
+        if (IS_ERR_OR_NULL(qos))
                 return PM_QOS_FLAGS_UNDEFINED;
 
         pqf = &qos->flags;
@@ -101,7 +102,8 @@ EXPORT_SYMBOL_GPL(dev_pm_qos_flags);
  */
 s32 __dev_pm_qos_read_value(struct device *dev)
 {
-        return dev->power.qos ? pm_qos_read_value(&dev->power.qos->latency) : 0;
+        return IS_ERR_OR_NULL(dev->power.qos) ?
+                0 : pm_qos_read_value(&dev->power.qos->latency);
 }
 
 /**
@@ -198,20 +200,8 @@ static int dev_pm_qos_constraints_allocate(struct device *dev)
         return 0;
 }
 
-/**
- * dev_pm_qos_constraints_init - Initalize device's PM QoS constraints pointer.
- * @dev: target device
- *
- * 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.qos = NULL;
-        dev->power.power_state = PMSG_ON;
-        mutex_unlock(&dev_pm_qos_mtx);
-}
+static void __dev_pm_qos_hide_latency_limit(struct device *dev);
+static void __dev_pm_qos_hide_flags(struct device *dev);
 
 /**
  * dev_pm_qos_constraints_destroy
@@ -226,16 +216,15 @@ void dev_pm_qos_constraints_destroy(struct device *dev)
         struct pm_qos_constraints *c;
         struct pm_qos_flags *f;
 
+        mutex_lock(&dev_pm_qos_mtx);
+
         /*
          * If the device's PM QoS resume latency limit or PM QoS flags have been
          * exposed to user space, they have to be hidden at this point.
          */
-        dev_pm_qos_hide_latency_limit(dev);
-        dev_pm_qos_hide_flags(dev);
+        __dev_pm_qos_hide_latency_limit(dev);
+        __dev_pm_qos_hide_flags(dev);
 
-        mutex_lock(&dev_pm_qos_mtx);
-
-        dev->power.power_state = PMSG_INVALID;
         qos = dev->power.qos;
         if (!qos)
                 goto out;
@@ -257,7 +246,7 @@ void dev_pm_qos_constraints_destroy(struct device *dev)
         }
 
         spin_lock_irq(&dev->power.lock);
-        dev->power.qos = NULL;
+        dev->power.qos = ERR_PTR(-ENODEV);
         spin_unlock_irq(&dev->power.lock);
 
         kfree(c->notifiers);
@@ -301,32 +290,19 @@ int dev_pm_qos_add_request(struct device *dev, struct dev_pm_qos_request *req,
                  "%s() called for already added request\n", __func__))
                 return -EINVAL;
 
-        req->dev = dev;
-
         mutex_lock(&dev_pm_qos_mtx);
 
-        if (!dev->power.qos) {
-                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 (IS_ERR(dev->power.qos))
+                ret = -ENODEV;
+        else if (!dev->power.qos)
+                ret = dev_pm_qos_constraints_allocate(dev);
 
         if (!ret) {
+                req->dev = dev;
                 req->type = type;
                 ret = apply_constraint(req, PM_QOS_ADD_REQ, value);
         }
 
- out:
         mutex_unlock(&dev_pm_qos_mtx);
 
         return ret;
@@ -344,7 +320,14 @@ static int __dev_pm_qos_update_request(struct dev_pm_qos_request *req,
         s32 curr_value;
         int ret = 0;
 
-        if (!req->dev->power.qos)
+        if (!req) /*guard against callers passing in null */
+                return -EINVAL;
+
+        if (WARN(!dev_pm_qos_request_active(req),
+                 "%s() called for unknown object\n", __func__))
+                return -EINVAL;
+
+        if (IS_ERR_OR_NULL(req->dev->power.qos))
                 return -ENODEV;
 
         switch(req->type) {
@@ -386,6 +369,17 @@ int dev_pm_qos_update_request(struct dev_pm_qos_request *req, s32 new_value)
 {
         int ret;
 
+        mutex_lock(&dev_pm_qos_mtx);
+        ret = __dev_pm_qos_update_request(req, new_value);
+        mutex_unlock(&dev_pm_qos_mtx);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(dev_pm_qos_update_request);
+
+static int __dev_pm_qos_remove_request(struct dev_pm_qos_request *req)
+{
+        int ret;
+
         if (!req) /*guard against callers passing in null */
                 return -EINVAL;
 
@@ -393,13 +387,13 @@ int dev_pm_qos_update_request(struct dev_pm_qos_request *req, s32 new_value)
                  "%s() called for unknown object\n", __func__))
                 return -EINVAL;
 
-        mutex_lock(&dev_pm_qos_mtx);
-        ret = __dev_pm_qos_update_request(req, new_value);
-        mutex_unlock(&dev_pm_qos_mtx);
+        if (IS_ERR_OR_NULL(req->dev->power.qos))
+                return -ENODEV;
 
+        ret = apply_constraint(req, PM_QOS_REMOVE_REQ, PM_QOS_DEFAULT_VALUE);
+        memset(req, 0, sizeof(*req));
         return ret;
 }
-EXPORT_SYMBOL_GPL(dev_pm_qos_update_request);
 
 /**
  * dev_pm_qos_remove_request - modifies an existing qos request
@@ -418,26 +412,10 @@ EXPORT_SYMBOL_GPL(dev_pm_qos_update_request);
  */
 int dev_pm_qos_remove_request(struct dev_pm_qos_request *req)
 {
-        int ret = 0;
-
-        if (!req) /*guard against callers passing in null */
-                return -EINVAL;
-
-        if (WARN(!dev_pm_qos_request_active(req),
-                 "%s() called for unknown object\n", __func__))
-                return -EINVAL;
+        int ret;
 
         mutex_lock(&dev_pm_qos_mtx);
-
-        if (req->dev->power.qos) {
-                ret = apply_constraint(req, PM_QOS_REMOVE_REQ,
-                                       PM_QOS_DEFAULT_VALUE);
-                memset(req, 0, sizeof(*req));
-        } else {
-                /* Return if the device has been removed */
-                ret = -ENODEV;
-        }
-
+        ret = __dev_pm_qos_remove_request(req);
         mutex_unlock(&dev_pm_qos_mtx);
         return ret;
 }
@@ -462,9 +440,10 @@ int dev_pm_qos_add_notifier(struct device *dev, struct notifier_block *notifier)
 
         mutex_lock(&dev_pm_qos_mtx);
 
-        if (!dev->power.qos)
-                ret = dev->power.power_state.event != PM_EVENT_INVALID ?
-                        dev_pm_qos_constraints_allocate(dev) : -ENODEV;
+        if (IS_ERR(dev->power.qos))
+                ret = -ENODEV;
+        else if (!dev->power.qos)
+                ret = dev_pm_qos_constraints_allocate(dev);
 
         if (!ret)
                 ret = blocking_notifier_chain_register(
@@ -493,7 +472,7 @@ int dev_pm_qos_remove_notifier(struct device *dev,
         mutex_lock(&dev_pm_qos_mtx);
 
         /* Silently return if the constraints object is not present. */
-        if (dev->power.qos)
+        if (!IS_ERR_OR_NULL(dev->power.qos))
                 retval = blocking_notifier_chain_unregister(
                                 dev->power.qos->latency.notifiers,
                                 notifier);
@@ -563,16 +542,20 @@ EXPORT_SYMBOL_GPL(dev_pm_qos_add_ancestor_request);
 static void __dev_pm_qos_drop_user_request(struct device *dev,
                                            enum dev_pm_qos_req_type type)
 {
+        struct dev_pm_qos_request *req = NULL;
+
         switch(type) {
         case DEV_PM_QOS_LATENCY:
-                dev_pm_qos_remove_request(dev->power.qos->latency_req);
+                req = dev->power.qos->latency_req;
                 dev->power.qos->latency_req = NULL;
                 break;
         case DEV_PM_QOS_FLAGS:
-                dev_pm_qos_remove_request(dev->power.qos->flags_req);
+                req = dev->power.qos->flags_req;
                 dev->power.qos->flags_req = NULL;
                 break;
         }
+        __dev_pm_qos_remove_request(req);
+        kfree(req);
 }
 
 /**
@@ -588,36 +571,57 @@ int dev_pm_qos_expose_latency_limit(struct device *dev, s32 value)
         if (!device_is_registered(dev) || value < 0)
                 return -EINVAL;
 
-        if (dev->power.qos && dev->power.qos->latency_req)
-                return -EEXIST;
-
         req = kzalloc(sizeof(*req), GFP_KERNEL);
         if (!req)
                 return -ENOMEM;
 
         ret = dev_pm_qos_add_request(dev, req, DEV_PM_QOS_LATENCY, value);
-        if (ret < 0)
+        if (ret < 0) {
+                kfree(req);
                 return ret;
+        }
+
+        mutex_lock(&dev_pm_qos_mtx);
+
+        if (IS_ERR_OR_NULL(dev->power.qos))
+                ret = -ENODEV;
+        else if (dev->power.qos->latency_req)
+                ret = -EEXIST;
+
+        if (ret < 0) {
+                __dev_pm_qos_remove_request(req);
+                kfree(req);
+                goto out;
+        }
 
         dev->power.qos->latency_req = req;
         ret = pm_qos_sysfs_add_latency(dev);
         if (ret)
                 __dev_pm_qos_drop_user_request(dev, DEV_PM_QOS_LATENCY);
 
+ out:
+        mutex_unlock(&dev_pm_qos_mtx);
         return ret;
 }
 EXPORT_SYMBOL_GPL(dev_pm_qos_expose_latency_limit);
 
+static void __dev_pm_qos_hide_latency_limit(struct device *dev)
+{
+        if (!IS_ERR_OR_NULL(dev->power.qos) && dev->power.qos->latency_req) {
+                pm_qos_sysfs_remove_latency(dev);
+                __dev_pm_qos_drop_user_request(dev, DEV_PM_QOS_LATENCY);
+        }
+}
+
 /**
  * dev_pm_qos_hide_latency_limit - Hide PM QoS latency limit from user space.
  * @dev: Device whose PM QoS latency limit is to be hidden from user space.
  */
 void dev_pm_qos_hide_latency_limit(struct device *dev)
 {
-        if (dev->power.qos && dev->power.qos->latency_req) {
-                pm_qos_sysfs_remove_latency(dev);
-                __dev_pm_qos_drop_user_request(dev, DEV_PM_QOS_LATENCY);
-        }
+        mutex_lock(&dev_pm_qos_mtx);
+        __dev_pm_qos_hide_latency_limit(dev);
+        mutex_unlock(&dev_pm_qos_mtx);
 }
 EXPORT_SYMBOL_GPL(dev_pm_qos_hide_latency_limit);
 
@@ -634,41 +638,61 @@ int dev_pm_qos_expose_flags(struct device *dev, s32 val)
         if (!device_is_registered(dev))
                 return -EINVAL;
 
-        if (dev->power.qos && dev->power.qos->flags_req)
-                return -EEXIST;
-
         req = kzalloc(sizeof(*req), GFP_KERNEL);
         if (!req)
                 return -ENOMEM;
 
-        pm_runtime_get_sync(dev);
         ret = dev_pm_qos_add_request(dev, req, DEV_PM_QOS_FLAGS, val);
-        if (ret < 0)
-                goto fail;
+        if (ret < 0) {
+                kfree(req);
+                return ret;
+        }
+
+        pm_runtime_get_sync(dev);
+        mutex_lock(&dev_pm_qos_mtx);
+
+        if (IS_ERR_OR_NULL(dev->power.qos))
+                ret = -ENODEV;
+        else if (dev->power.qos->flags_req)
+                ret = -EEXIST;
+
+        if (ret < 0) {
+                __dev_pm_qos_remove_request(req);
+                kfree(req);
+                goto out;
+        }
 
         dev->power.qos->flags_req = req;
         ret = pm_qos_sysfs_add_flags(dev);
         if (ret)
                 __dev_pm_qos_drop_user_request(dev, DEV_PM_QOS_FLAGS);
 
-fail:
+ out:
+        mutex_unlock(&dev_pm_qos_mtx);
         pm_runtime_put(dev);
         return ret;
 }
 EXPORT_SYMBOL_GPL(dev_pm_qos_expose_flags);
 
+static void __dev_pm_qos_hide_flags(struct device *dev)
+{
+        if (!IS_ERR_OR_NULL(dev->power.qos) && dev->power.qos->flags_req) {
+                pm_qos_sysfs_remove_flags(dev);
+                __dev_pm_qos_drop_user_request(dev, DEV_PM_QOS_FLAGS);
+        }
+}
+
 /**
  * dev_pm_qos_hide_flags - Hide PM QoS flags of a device from user space.
  * @dev: Device whose PM QoS flags are to be hidden from user space.
  */
 void dev_pm_qos_hide_flags(struct device *dev)
 {
-        if (dev->power.qos && dev->power.qos->flags_req) {
-                pm_qos_sysfs_remove_flags(dev);
-                pm_runtime_get_sync(dev);
-                __dev_pm_qos_drop_user_request(dev, DEV_PM_QOS_FLAGS);
-                pm_runtime_put(dev);
-        }
+        pm_runtime_get_sync(dev);
+        mutex_lock(&dev_pm_qos_mtx);
+        __dev_pm_qos_hide_flags(dev);
+        mutex_unlock(&dev_pm_qos_mtx);
+        pm_runtime_put(dev);
 }
 EXPORT_SYMBOL_GPL(dev_pm_qos_hide_flags);
 
@@ -683,12 +707,14 @@ int dev_pm_qos_update_flags(struct device *dev, s32 mask, bool set)
         s32 value;
         int ret;
 
-        if (!dev->power.qos || !dev->power.qos->flags_req)
-                return -EINVAL;
-
         pm_runtime_get_sync(dev);
         mutex_lock(&dev_pm_qos_mtx);
 
+        if (IS_ERR_OR_NULL(dev->power.qos) || !dev->power.qos->flags_req) {
+                ret = -EINVAL;
+                goto out;
+        }
+
         value = dev_pm_qos_requested_flags(dev);
         if (set)
                 value |= mask;
@@ -697,9 +723,12 @@ int dev_pm_qos_update_flags(struct device *dev, s32 mask, bool set)
 
         ret = __dev_pm_qos_update_request(dev->power.qos->flags_req, value);
 
+ out:
         mutex_unlock(&dev_pm_qos_mtx);
         pm_runtime_put(dev);
-
         return ret;
 }
+#else /* !CONFIG_PM_RUNTIME */
+static void __dev_pm_qos_hide_latency_limit(struct device *dev) {}
+static void __dev_pm_qos_hide_flags(struct device *dev) {}
 #endif /* CONFIG_PM_RUNTIME */
diff --git a/drivers/base/power/sysfs.c b/drivers/base/power/sysfs.c
index 50d16e3cb0a9..a53ebd265701 100644
--- a/drivers/base/power/sysfs.c
+++ b/drivers/base/power/sysfs.c
@@ -708,6 +708,7 @@ void rpm_sysfs_remove(struct device *dev)
 
 void dpm_sysfs_remove(struct device *dev)
 {
+        dev_pm_qos_constraints_destroy(dev);
         rpm_sysfs_remove(dev);
         sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
         sysfs_remove_group(&dev->kobj, &pm_attr_group);