7 files changed, 527 insertions, 63 deletions

diff --git a/drivers/base/power/Makefile b/drivers/base/power/Makefile
index 118c1b92a511..3647e114d0e7 100644
--- a/drivers/base/power/Makefile
+++ b/drivers/base/power/Makefile
@@ -3,6 +3,6 @@ obj-$(CONFIG_PM_SLEEP)	+= main.o wakeup.o
 obj-$(CONFIG_PM_RUNTIME)        += runtime.o
 obj-$(CONFIG_PM_TRACE_RTC)      += trace.o
 obj-$(CONFIG_PM_OPP)    += opp.o
+obj-$(CONFIG_HAVE_CLK)  += clock_ops.o
 
-ccflags-$(CONFIG_DEBUG_DRIVER) := -DDEBUG
-ccflags-$(CONFIG_PM_VERBOSE)   += -DDEBUG
+ccflags-$(CONFIG_DEBUG_DRIVER) := -DDEBUG
\ No newline at end of file
diff --git a/drivers/base/power/clock_ops.c b/drivers/base/power/clock_ops.c
new file mode 100644
index 000000000000..c0dd09df7be8
--- /dev/null
+++ b/drivers/base/power/clock_ops.c
@@ -0,0 +1,431 @@
+/*
+ * drivers/base/power/clock_ops.c - Generic clock manipulation PM callbacks
+ *
+ * Copyright (c) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Renesas Electronics Corp.
+ *
+ * This file is released under the GPLv2.
+ */
+
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/io.h>
+#include <linux/pm.h>
+#include <linux/pm_runtime.h>
+#include <linux/clk.h>
+#include <linux/slab.h>
+#include <linux/err.h>
+
+#ifdef CONFIG_PM_RUNTIME
+
+struct pm_runtime_clk_data {
+        struct list_head clock_list;
+        struct mutex lock;
+};
+
+enum pce_status {
+        PCE_STATUS_NONE = 0,
+        PCE_STATUS_ACQUIRED,
+        PCE_STATUS_ENABLED,
+        PCE_STATUS_ERROR,
+};
+
+struct pm_clock_entry {
+        struct list_head node;
+        char *con_id;
+        struct clk *clk;
+        enum pce_status status;
+};
+
+static struct pm_runtime_clk_data *__to_prd(struct device *dev)
+{
+        return dev ? dev->power.subsys_data : NULL;
+}
+
+/**
+ * pm_runtime_clk_add - Start using a device clock for runtime PM.
+ * @dev: Device whose clock is going to be used for runtime PM.
+ * @con_id: Connection ID of the clock.
+ *
+ * Add the clock represented by @con_id to the list of clocks used for
+ * the runtime PM of @dev.
+ */
+int pm_runtime_clk_add(struct device *dev, const char *con_id)
+{
+        struct pm_runtime_clk_data *prd = __to_prd(dev);
+        struct pm_clock_entry *ce;
+
+        if (!prd)
+                return -EINVAL;
+
+        ce = kzalloc(sizeof(*ce), GFP_KERNEL);
+        if (!ce) {
+                dev_err(dev, "Not enough memory for clock entry.\n");
+                return -ENOMEM;
+        }
+
+        if (con_id) {
+                ce->con_id = kstrdup(con_id, GFP_KERNEL);
+                if (!ce->con_id) {
+                        dev_err(dev,
+                                "Not enough memory for clock connection ID.\n");
+                        kfree(ce);
+                        return -ENOMEM;
+                }
+        }
+
+        mutex_lock(&prd->lock);
+        list_add_tail(&ce->node, &prd->clock_list);
+        mutex_unlock(&prd->lock);
+        return 0;
+}
+
+/**
+ * __pm_runtime_clk_remove - Destroy runtime PM clock entry.
+ * @ce: Runtime PM clock entry to destroy.
+ *
+ * This routine must be called under the mutex protecting the runtime PM list
+ * of clocks corresponding the the @ce's device.
+ */
+static void __pm_runtime_clk_remove(struct pm_clock_entry *ce)
+{
+        if (!ce)
+                return;
+
+        list_del(&ce->node);
+
+        if (ce->status < PCE_STATUS_ERROR) {
+                if (ce->status == PCE_STATUS_ENABLED)
+                        clk_disable(ce->clk);
+
+                if (ce->status >= PCE_STATUS_ACQUIRED)
+                        clk_put(ce->clk);
+        }
+
+        if (ce->con_id)
+                kfree(ce->con_id);
+
+        kfree(ce);
+}
+
+/**
+ * pm_runtime_clk_remove - Stop using a device clock for runtime PM.
+ * @dev: Device whose clock should not be used for runtime PM any more.
+ * @con_id: Connection ID of the clock.
+ *
+ * Remove the clock represented by @con_id from the list of clocks used for
+ * the runtime PM of @dev.
+ */
+void pm_runtime_clk_remove(struct device *dev, const char *con_id)
+{
+        struct pm_runtime_clk_data *prd = __to_prd(dev);
+        struct pm_clock_entry *ce;
+
+        if (!prd)
+                return;
+
+        mutex_lock(&prd->lock);
+
+        list_for_each_entry(ce, &prd->clock_list, node) {
+                if (!con_id && !ce->con_id) {
+                        __pm_runtime_clk_remove(ce);
+                        break;
+                } else if (!con_id || !ce->con_id) {
+                        continue;
+                } else if (!strcmp(con_id, ce->con_id)) {
+                        __pm_runtime_clk_remove(ce);
+                        break;
+                }
+        }
+
+        mutex_unlock(&prd->lock);
+}
+
+/**
+ * pm_runtime_clk_init - Initialize a device's list of runtime PM clocks.
+ * @dev: Device to initialize the list of runtime PM clocks for.
+ *
+ * Allocate a struct pm_runtime_clk_data object, initialize its lock member and
+ * make the @dev's power.subsys_data field point to it.
+ */
+int pm_runtime_clk_init(struct device *dev)
+{
+        struct pm_runtime_clk_data *prd;
+
+        prd = kzalloc(sizeof(*prd), GFP_KERNEL);
+        if (!prd) {
+                dev_err(dev, "Not enough memory fo runtime PM data.\n");
+                return -ENOMEM;
+        }
+
+        INIT_LIST_HEAD(&prd->clock_list);
+        mutex_init(&prd->lock);
+        dev->power.subsys_data = prd;
+        return 0;
+}
+
+/**
+ * pm_runtime_clk_destroy - Destroy a device's list of runtime PM clocks.
+ * @dev: Device to destroy the list of runtime PM clocks for.
+ *
+ * Clear the @dev's power.subsys_data field, remove the list of clock entries
+ * from the struct pm_runtime_clk_data object pointed to by it before and free
+ * that object.
+ */
+void pm_runtime_clk_destroy(struct device *dev)
+{
+        struct pm_runtime_clk_data *prd = __to_prd(dev);
+        struct pm_clock_entry *ce, *c;
+
+        if (!prd)
+                return;
+
+        dev->power.subsys_data = NULL;
+
+        mutex_lock(&prd->lock);
+
+        list_for_each_entry_safe_reverse(ce, c, &prd->clock_list, node)
+                __pm_runtime_clk_remove(ce);
+
+        mutex_unlock(&prd->lock);
+
+        kfree(prd);
+}
+
+/**
+ * pm_runtime_clk_acquire - Acquire a device clock.
+ * @dev: Device whose clock is to be acquired.
+ * @con_id: Connection ID of the clock.
+ */
+static void pm_runtime_clk_acquire(struct device *dev,
+                                    struct pm_clock_entry *ce)
+{
+        ce->clk = clk_get(dev, ce->con_id);
+        if (IS_ERR(ce->clk)) {
+                ce->status = PCE_STATUS_ERROR;
+        } else {
+                ce->status = PCE_STATUS_ACQUIRED;
+                dev_dbg(dev, "Clock %s managed by runtime PM.\n", ce->con_id);
+        }
+}
+
+/**
+ * pm_runtime_clk_suspend - Disable clocks in a device's runtime PM clock list.
+ * @dev: Device to disable the clocks for.
+ */
+int pm_runtime_clk_suspend(struct device *dev)
+{
+        struct pm_runtime_clk_data *prd = __to_prd(dev);
+        struct pm_clock_entry *ce;
+
+        dev_dbg(dev, "%s()\n", __func__);
+
+        if (!prd)
+                return 0;
+
+        mutex_lock(&prd->lock);
+
+        list_for_each_entry_reverse(ce, &prd->clock_list, node) {
+                if (ce->status == PCE_STATUS_NONE)
+                        pm_runtime_clk_acquire(dev, ce);
+
+                if (ce->status < PCE_STATUS_ERROR) {
+                        clk_disable(ce->clk);
+                        ce->status = PCE_STATUS_ACQUIRED;
+                }
+        }
+
+        mutex_unlock(&prd->lock);
+
+        return 0;
+}
+
+/**
+ * pm_runtime_clk_resume - Enable clocks in a device's runtime PM clock list.
+ * @dev: Device to enable the clocks for.
+ */
+int pm_runtime_clk_resume(struct device *dev)
+{
+        struct pm_runtime_clk_data *prd = __to_prd(dev);
+        struct pm_clock_entry *ce;
+
+        dev_dbg(dev, "%s()\n", __func__);
+
+        if (!prd)
+                return 0;
+
+        mutex_lock(&prd->lock);
+
+        list_for_each_entry(ce, &prd->clock_list, node) {
+                if (ce->status == PCE_STATUS_NONE)
+                        pm_runtime_clk_acquire(dev, ce);
+
+                if (ce->status < PCE_STATUS_ERROR) {
+                        clk_enable(ce->clk);
+                        ce->status = PCE_STATUS_ENABLED;
+                }
+        }
+
+        mutex_unlock(&prd->lock);
+
+        return 0;
+}
+
+/**
+ * pm_runtime_clk_notify - Notify routine for device addition and removal.
+ * @nb: Notifier block object this function is a member of.
+ * @action: Operation being carried out by the caller.
+ * @data: Device the routine is being run for.
+ *
+ * For this function to work, @nb must be a member of an object of type
+ * struct pm_clk_notifier_block containing all of the requisite data.
+ * Specifically, the pwr_domain member of that object is copied to the device's
+ * pwr_domain field and its con_ids member is used to populate the device's list
+ * of runtime PM clocks, depending on @action.
+ *
+ * If the device's pwr_domain field is already populated with a value different
+ * from the one stored in the struct pm_clk_notifier_block object, the function
+ * does nothing.
+ */
+static int pm_runtime_clk_notify(struct notifier_block *nb,
+                                 unsigned long action, void *data)
+{
+        struct pm_clk_notifier_block *clknb;
+        struct device *dev = data;
+        char *con_id;
+        int error;
+
+        dev_dbg(dev, "%s() %ld\n", __func__, action);
+
+        clknb = container_of(nb, struct pm_clk_notifier_block, nb);
+
+        switch (action) {
+        case BUS_NOTIFY_ADD_DEVICE:
+                if (dev->pwr_domain)
+                        break;
+
+                error = pm_runtime_clk_init(dev);
+                if (error)
+                        break;
+
+                dev->pwr_domain = clknb->pwr_domain;
+                if (clknb->con_ids[0]) {
+                        for (con_id = clknb->con_ids[0]; *con_id; con_id++)
+                                pm_runtime_clk_add(dev, con_id);
+                } else {
+                        pm_runtime_clk_add(dev, NULL);
+                }
+
+                break;
+        case BUS_NOTIFY_DEL_DEVICE:
+                if (dev->pwr_domain != clknb->pwr_domain)
+                        break;
+
+                dev->pwr_domain = NULL;
+                pm_runtime_clk_destroy(dev);
+                break;
+        }
+
+        return 0;
+}
+
+#else /* !CONFIG_PM_RUNTIME */
+
+/**
+ * enable_clock - Enable a device clock.
+ * @dev: Device whose clock is to be enabled.
+ * @con_id: Connection ID of the clock.
+ */
+static void enable_clock(struct device *dev, const char *con_id)
+{
+        struct clk *clk;
+
+        clk = clk_get(dev, con_id);
+        if (!IS_ERR(clk)) {
+                clk_enable(clk);
+                clk_put(clk);
+                dev_info(dev, "Runtime PM disabled, clock forced on.\n");
+        }
+}
+
+/**
+ * disable_clock - Disable a device clock.
+ * @dev: Device whose clock is to be disabled.
+ * @con_id: Connection ID of the clock.
+ */
+static void disable_clock(struct device *dev, const char *con_id)
+{
+        struct clk *clk;
+
+        clk = clk_get(dev, con_id);
+        if (!IS_ERR(clk)) {
+                clk_disable(clk);
+                clk_put(clk);
+                dev_info(dev, "Runtime PM disabled, clock forced off.\n");
+        }
+}
+
+/**
+ * pm_runtime_clk_notify - Notify routine for device addition and removal.
+ * @nb: Notifier block object this function is a member of.
+ * @action: Operation being carried out by the caller.
+ * @data: Device the routine is being run for.
+ *
+ * For this function to work, @nb must be a member of an object of type
+ * struct pm_clk_notifier_block containing all of the requisite data.
+ * Specifically, the con_ids member of that object is used to enable or disable
+ * the device's clocks, depending on @action.
+ */
+static int pm_runtime_clk_notify(struct notifier_block *nb,
+                                 unsigned long action, void *data)
+{
+        struct pm_clk_notifier_block *clknb;
+        struct device *dev = data;
+        char *con_id;
+
+        dev_dbg(dev, "%s() %ld\n", __func__, action);
+
+        clknb = container_of(nb, struct pm_clk_notifier_block, nb);
+
+        switch (action) {
+        case BUS_NOTIFY_ADD_DEVICE:
+                if (clknb->con_ids[0]) {
+                        for (con_id = clknb->con_ids[0]; *con_id; con_id++)
+                                enable_clock(dev, con_id);
+                } else {
+                        enable_clock(dev, NULL);
+                }
+                break;
+        case BUS_NOTIFY_DEL_DEVICE:
+                if (clknb->con_ids[0]) {
+                        for (con_id = clknb->con_ids[0]; *con_id; con_id++)
+                                disable_clock(dev, con_id);
+                } else {
+                        disable_clock(dev, NULL);
+                }
+                break;
+        }
+
+        return 0;
+}
+
+#endif /* !CONFIG_PM_RUNTIME */
+
+/**
+ * pm_runtime_clk_add_notifier - Add bus type notifier for runtime PM clocks.
+ * @bus: Bus type to add the notifier to.
+ * @clknb: Notifier to be added to the given bus type.
+ *
+ * The nb member of @clknb is not expected to be initialized and its
+ * notifier_call member will be replaced with pm_runtime_clk_notify().  However,
+ * the remaining members of @clknb should be populated prior to calling this
+ * routine.
+ */
+void pm_runtime_clk_add_notifier(struct bus_type *bus,
+                                 struct pm_clk_notifier_block *clknb)
+{
+        if (!bus || !clknb)
+                return;
+
+        clknb->nb.notifier_call = pm_runtime_clk_notify;
+        bus_register_notifier(bus, &clknb->nb);
+}
diff --git a/drivers/base/power/generic_ops.c b/drivers/base/power/generic_ops.c
index 42f97f925629..cb3bb368681c 100644
--- a/drivers/base/power/generic_ops.c
+++ b/drivers/base/power/generic_ops.c
@@ -74,6 +74,23 @@ EXPORT_SYMBOL_GPL(pm_generic_runtime_resume);
 
 #ifdef CONFIG_PM_SLEEP
 /**
+ * pm_generic_prepare - Generic routine preparing a device for power transition.
+ * @dev: Device to prepare.
+ *
+ * Prepare a device for a system-wide power transition.
+ */
+int pm_generic_prepare(struct device *dev)
+{
+        struct device_driver *drv = dev->driver;
+        int ret = 0;
+
+        if (drv && drv->pm && drv->pm->prepare)
+                ret = drv->pm->prepare(dev);
+
+        return ret;
+}
+
+/**
  * __pm_generic_call - Generic suspend/freeze/poweroff/thaw subsystem callback.
  * @dev: Device to handle.
  * @event: PM transition of the system under way.
@@ -213,16 +230,38 @@ int pm_generic_restore(struct device *dev)
         return __pm_generic_resume(dev, PM_EVENT_RESTORE);
 }
 EXPORT_SYMBOL_GPL(pm_generic_restore);
+
+/**
+ * pm_generic_complete - Generic routine competing a device power transition.
+ * @dev: Device to handle.
+ *
+ * Complete a device power transition during a system-wide power transition.
+ */
+void pm_generic_complete(struct device *dev)
+{
+        struct device_driver *drv = dev->driver;
+
+        if (drv && drv->pm && drv->pm->complete)
+                drv->pm->complete(dev);
+
+        /*
+         * Let runtime PM try to suspend devices that haven't been in use before
+         * going into the system-wide sleep state we're resuming from.
+         */
+        pm_runtime_idle(dev);
+}
 #endif /* CONFIG_PM_SLEEP */
 
 struct dev_pm_ops generic_subsys_pm_ops = {
 #ifdef CONFIG_PM_SLEEP
+        .prepare = pm_generic_prepare,
         .suspend = pm_generic_suspend,
         .resume = pm_generic_resume,
         .freeze = pm_generic_freeze,
         .thaw = pm_generic_thaw,
         .poweroff = pm_generic_poweroff,
         .restore = pm_generic_restore,
+        .complete = pm_generic_complete,
 #endif
 #ifdef CONFIG_PM_RUNTIME
         .runtime_suspend = pm_generic_runtime_suspend,
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index abe3ab709e87..aa6320207745 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -426,10 +426,8 @@ static int device_resume_noirq(struct device *dev, pm_message_t state)
 
         if (dev->pwr_domain) {
                 pm_dev_dbg(dev, state, "EARLY power domain ");
-                pm_noirq_op(dev, &dev->pwr_domain->ops, state);
-        }
-
-        if (dev->type && dev->type->pm) {
+                error = pm_noirq_op(dev, &dev->pwr_domain->ops, state);
+        } else if (dev->type && dev->type->pm) {
                 pm_dev_dbg(dev, state, "EARLY type ");
                 error = pm_noirq_op(dev, dev->type->pm, state);
         } else if (dev->class && dev->class->pm) {
@@ -517,7 +515,8 @@ static int device_resume(struct device *dev, pm_message_t state, bool async)
 
         if (dev->pwr_domain) {
                 pm_dev_dbg(dev, state, "power domain ");
-                pm_op(dev, &dev->pwr_domain->ops, state);
+                error = pm_op(dev, &dev->pwr_domain->ops, state);
+                goto End;
         }
 
         if (dev->type && dev->type->pm) {
@@ -580,11 +579,13 @@ static bool is_async(struct device *dev)
  * Execute the appropriate "resume" callback for all devices whose status
  * indicates that they are suspended.
  */
-static void dpm_resume(pm_message_t state)
+void dpm_resume(pm_message_t state)
 {
         struct device *dev;
         ktime_t starttime = ktime_get();
 
+        might_sleep();
+
         mutex_lock(&dpm_list_mtx);
         pm_transition = state;
         async_error = 0;
@@ -629,12 +630,11 @@ static void device_complete(struct device *dev, pm_message_t state)
 {
         device_lock(dev);
 
-        if (dev->pwr_domain && dev->pwr_domain->ops.complete) {
+        if (dev->pwr_domain) {
                 pm_dev_dbg(dev, state, "completing power domain ");
-                dev->pwr_domain->ops.complete(dev);
-        }
-
-        if (dev->type && dev->type->pm) {
+                if (dev->pwr_domain->ops.complete)
+                        dev->pwr_domain->ops.complete(dev);
+        } else if (dev->type && dev->type->pm) {
                 pm_dev_dbg(dev, state, "completing type ");
                 if (dev->type->pm->complete)
                         dev->type->pm->complete(dev);
@@ -658,10 +658,12 @@ static void device_complete(struct device *dev, pm_message_t state)
  * Execute the ->complete() callbacks for all devices whose PM status is not
  * DPM_ON (this allows new devices to be registered).
  */
-static void dpm_complete(pm_message_t state)
+void dpm_complete(pm_message_t state)
 {
         struct list_head list;
 
+        might_sleep();
+
         INIT_LIST_HEAD(&list);
         mutex_lock(&dpm_list_mtx);
         while (!list_empty(&dpm_prepared_list)) {
@@ -690,7 +692,6 @@ static void dpm_complete(pm_message_t state)
  */
 void dpm_resume_end(pm_message_t state)
 {
-        might_sleep();
         dpm_resume(state);
         dpm_complete(state);
 }
@@ -732,7 +733,12 @@ static int device_suspend_noirq(struct device *dev, pm_message_t state)
 {
         int error;
 
-        if (dev->type && dev->type->pm) {
+        if (dev->pwr_domain) {
+                pm_dev_dbg(dev, state, "LATE power domain ");
+                error = pm_noirq_op(dev, &dev->pwr_domain->ops, state);
+                if (error)
+                        return error;
+        } else if (dev->type && dev->type->pm) {
                 pm_dev_dbg(dev, state, "LATE type ");
                 error = pm_noirq_op(dev, dev->type->pm, state);
                 if (error)
@@ -749,11 +755,6 @@ static int device_suspend_noirq(struct device *dev, pm_message_t state)
                         return error;
         }
 
-        if (dev->pwr_domain) {
-                pm_dev_dbg(dev, state, "LATE power domain ");
-                pm_noirq_op(dev, &dev->pwr_domain->ops, state);
-        }
-
         return 0;
 }
 
@@ -841,21 +842,27 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async)
                 goto End;
         }
 
+        if (dev->pwr_domain) {
+                pm_dev_dbg(dev, state, "power domain ");
+                error = pm_op(dev, &dev->pwr_domain->ops, state);
+                goto End;
+        }
+
         if (dev->type && dev->type->pm) {
                 pm_dev_dbg(dev, state, "type ");
                 error = pm_op(dev, dev->type->pm, state);
-                goto Domain;
+                goto End;
         }
 
         if (dev->class) {
                 if (dev->class->pm) {
                         pm_dev_dbg(dev, state, "class ");
                         error = pm_op(dev, dev->class->pm, state);
-                        goto Domain;
+                        goto End;
                 } else if (dev->class->suspend) {
                         pm_dev_dbg(dev, state, "legacy class ");
                         error = legacy_suspend(dev, state, dev->class->suspend);
-                        goto Domain;
+                        goto End;
                 }
         }
 
@@ -869,12 +876,6 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async)
                 }
         }
 
- Domain:
-        if (!error && dev->pwr_domain) {
-                pm_dev_dbg(dev, state, "power domain ");
-                pm_op(dev, &dev->pwr_domain->ops, state);
-        }
-
  End:
         device_unlock(dev);
         complete_all(&dev->power.completion);
@@ -914,11 +915,13 @@ static int device_suspend(struct device *dev)
  * dpm_suspend - Execute "suspend" callbacks for all non-sysdev devices.
  * @state: PM transition of the system being carried out.
  */
-static int dpm_suspend(pm_message_t state)
+int dpm_suspend(pm_message_t state)
 {
         ktime_t starttime = ktime_get();
         int error = 0;
 
+        might_sleep();
+
         mutex_lock(&dpm_list_mtx);
         pm_transition = state;
         async_error = 0;
@@ -965,7 +968,14 @@ static int device_prepare(struct device *dev, pm_message_t state)
 
         device_lock(dev);
 
-        if (dev->type && dev->type->pm) {
+        if (dev->pwr_domain) {
+                pm_dev_dbg(dev, state, "preparing power domain ");
+                if (dev->pwr_domain->ops.prepare)
+                        error = dev->pwr_domain->ops.prepare(dev);
+                suspend_report_result(dev->pwr_domain->ops.prepare, error);
+                if (error)
+                        goto End;
+        } else if (dev->type && dev->type->pm) {
                 pm_dev_dbg(dev, state, "preparing type ");
                 if (dev->type->pm->prepare)
                         error = dev->type->pm->prepare(dev);
@@ -984,13 +994,6 @@ static int device_prepare(struct device *dev, pm_message_t state)
                 if (dev->bus->pm->prepare)
                         error = dev->bus->pm->prepare(dev);
                 suspend_report_result(dev->bus->pm->prepare, error);
-                if (error)
-                        goto End;
-        }
-
-        if (dev->pwr_domain && dev->pwr_domain->ops.prepare) {
-                pm_dev_dbg(dev, state, "preparing power domain ");
-                dev->pwr_domain->ops.prepare(dev);
         }
 
  End:
@@ -1005,10 +1008,12 @@ static int device_prepare(struct device *dev, pm_message_t state)
  *
  * Execute the ->prepare() callback(s) for all devices.
  */
-static int dpm_prepare(pm_message_t state)
+int dpm_prepare(pm_message_t state)
 {
         int error = 0;
 
+        might_sleep();
+
         mutex_lock(&dpm_list_mtx);
         while (!list_empty(&dpm_list)) {
                 struct device *dev = to_device(dpm_list.next);
@@ -1057,7 +1062,6 @@ int dpm_suspend_start(pm_message_t state)
 {
         int error;
 
-        might_sleep();
         error = dpm_prepare(state);
         if (!error)
                 error = dpm_suspend(state);
diff --git a/drivers/base/power/runtime.c b/drivers/base/power/runtime.c
index 3172c60d23a9..0d4587b15c55 100644
--- a/drivers/base/power/runtime.c
+++ b/drivers/base/power/runtime.c
@@ -168,7 +168,6 @@ static int rpm_check_suspend_allowed(struct device *dev)
 static int rpm_idle(struct device *dev, int rpmflags)
 {
         int (*callback)(struct device *);
-        int (*domain_callback)(struct device *);
         int retval;
 
         retval = rpm_check_suspend_allowed(dev);
@@ -214,7 +213,9 @@ static int rpm_idle(struct device *dev, int rpmflags)
 
         dev->power.idle_notification = true;
 
-        if (dev->type && dev->type->pm)
+        if (dev->pwr_domain)
+                callback = dev->pwr_domain->ops.runtime_idle;
+        else if (dev->type && dev->type->pm)
                 callback = dev->type->pm->runtime_idle;
         else if (dev->class && dev->class->pm)
                 callback = dev->class->pm->runtime_idle;
@@ -223,19 +224,10 @@ static int rpm_idle(struct device *dev, int rpmflags)
         else
                 callback = NULL;
 
-        if (dev->pwr_domain)
-                domain_callback = dev->pwr_domain->ops.runtime_idle;
-        else
-                domain_callback = NULL;
-
-        if (callback || domain_callback) {
+        if (callback) {
                 spin_unlock_irq(&dev->power.lock);
 
-                if (domain_callback)
-                        retval = domain_callback(dev);
-
-                if (!retval && callback)
-                        callback(dev);
+                callback(dev);
 
                 spin_lock_irq(&dev->power.lock);
         }
@@ -382,7 +374,9 @@ static int rpm_suspend(struct device *dev, int rpmflags)
 
         __update_runtime_status(dev, RPM_SUSPENDING);
 
-        if (dev->type && dev->type->pm)
+        if (dev->pwr_domain)
+                callback = dev->pwr_domain->ops.runtime_suspend;
+        else if (dev->type && dev->type->pm)
                 callback = dev->type->pm->runtime_suspend;
         else if (dev->class && dev->class->pm)
                 callback = dev->class->pm->runtime_suspend;
@@ -400,8 +394,6 @@ static int rpm_suspend(struct device *dev, int rpmflags)
                 else
                         pm_runtime_cancel_pending(dev);
         } else {
-                if (dev->pwr_domain)
-                        rpm_callback(dev->pwr_domain->ops.runtime_suspend, dev);
  no_callback:
                 __update_runtime_status(dev, RPM_SUSPENDED);
                 pm_runtime_deactivate_timer(dev);
@@ -582,9 +574,8 @@ static int rpm_resume(struct device *dev, int rpmflags)
         __update_runtime_status(dev, RPM_RESUMING);
 
         if (dev->pwr_domain)
-                rpm_callback(dev->pwr_domain->ops.runtime_resume, dev);
-
-        if (dev->type && dev->type->pm)
+                callback = dev->pwr_domain->ops.runtime_resume;
+        else if (dev->type && dev->type->pm)
                 callback = dev->type->pm->runtime_resume;
         else if (dev->class && dev->class->pm)
                 callback = dev->class->pm->runtime_resume;
diff --git a/drivers/base/power/sysfs.c b/drivers/base/power/sysfs.c
index fff49bee781d..a9f5b8979611 100644
--- a/drivers/base/power/sysfs.c
+++ b/drivers/base/power/sysfs.c
@@ -212,8 +212,9 @@ static ssize_t autosuspend_delay_ms_store(struct device *dev,
 static DEVICE_ATTR(autosuspend_delay_ms, 0644, autosuspend_delay_ms_show,
                 autosuspend_delay_ms_store);
 
-#endif
+#endif /* CONFIG_PM_RUNTIME */
 
+#ifdef CONFIG_PM_SLEEP
 static ssize_t
 wake_show(struct device * dev, struct device_attribute *attr, char * buf)
 {
@@ -248,7 +249,6 @@ wake_store(struct device * dev, struct device_attribute *attr,
 
 static DEVICE_ATTR(wakeup, 0644, wake_show, wake_store);
 
-#ifdef CONFIG_PM_SLEEP
 static ssize_t wakeup_count_show(struct device *dev,
                                 struct device_attribute *attr, char *buf)
 {
diff --git a/drivers/base/power/wakeup.c b/drivers/base/power/wakeup.c
index abbbd33e8d8a..84f7c7d5a098 100644
--- a/drivers/base/power/wakeup.c
+++ b/drivers/base/power/wakeup.c
@@ -110,7 +110,6 @@ void wakeup_source_add(struct wakeup_source *ws)
         spin_lock_irq(&events_lock);
         list_add_rcu(&ws->entry, &wakeup_sources);
         spin_unlock_irq(&events_lock);
-        synchronize_rcu();
 }
 EXPORT_SYMBOL_GPL(wakeup_source_add);