PM / Sleep: Make pm_op() and pm_noirq_op() return callback pointers

Make the pm_op() and pm_noirq_op() functions return pointers to
appropriate callbacks instead of executing those callbacks and
returning their results.

This change is required for a subsequent modification that will
execute the corresponding driver callback if the subsystem
callback returned by either pm_op(), or pm_noirq_op() is NULL.

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

1 files changed, 95 insertions, 102 deletions

diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index b570189d4f2d..b5cef7e7de23 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -32,6 +32,8 @@
 #include "../base.h"
 #include "power.h"
 
+typedef int (*pm_callback_t)(struct device *);
+
 /*
  * The entries in the dpm_list list are in a depth first order, simply
  * because children are guaranteed to be discovered after parents, and
@@ -211,113 +213,70 @@ static void dpm_wait_for_children(struct device *dev, bool async)
        device_for_each_child(dev, &async, dpm_wait_fn);
 }
 
-static int dpm_run_callback(struct device *dev, int (*cb)(struct device *))
-{
-        ktime_t calltime;
-        int error;
-
-        if (!cb)
-                return 0;
-
-        calltime = initcall_debug_start(dev);
-
-        error = cb(dev);
-        suspend_report_result(cb, error);
-
-        initcall_debug_report(dev, calltime, error);
-
-        return error;
-}
-
 /**
- * pm_op - Execute the PM operation appropriate for given PM event.
- * @dev: Device to handle.
+ * pm_op - Return the PM operation appropriate for given PM event.
  * @ops: PM operations to choose from.
  * @state: PM transition of the system being carried out.
  */
-static int pm_op(struct device *dev,
-                 const struct dev_pm_ops *ops,
-                 pm_message_t state)
+static pm_callback_t pm_op(const struct dev_pm_ops *ops, pm_message_t state)
 {
-        int error = 0;
-
         switch (state.event) {
 #ifdef CONFIG_SUSPEND
         case PM_EVENT_SUSPEND:
-                error = dpm_run_callback(dev, ops->suspend);
-                break;
+                return ops->suspend;
         case PM_EVENT_RESUME:
-                error = dpm_run_callback(dev, ops->resume);
-                break;
+                return ops->resume;
 #endif /* CONFIG_SUSPEND */
 #ifdef CONFIG_HIBERNATE_CALLBACKS
         case PM_EVENT_FREEZE:
         case PM_EVENT_QUIESCE:
-                error = dpm_run_callback(dev, ops->freeze);
-                break;
+                return ops->freeze;
         case PM_EVENT_HIBERNATE:
-                error = dpm_run_callback(dev, ops->poweroff);
-                break;
+                return ops->poweroff;
         case PM_EVENT_THAW:
         case PM_EVENT_RECOVER:
-                error = dpm_run_callback(dev, ops->thaw);
+                return ops->thaw;
                 break;
         case PM_EVENT_RESTORE:
-                error = dpm_run_callback(dev, ops->restore);
-                break;
+                return ops->restore;
 #endif /* CONFIG_HIBERNATE_CALLBACKS */
-        default:
-                error = -EINVAL;
         }
 
-        return error;
+        return NULL;
 }
 
 /**
- * pm_noirq_op - Execute the PM operation appropriate for given PM event.
- * @dev: Device to handle.
+ * pm_noirq_op - Return the PM operation appropriate for given PM event.
  * @ops: PM operations to choose from.
  * @state: PM transition of the system being carried out.
  *
  * The driver of @dev will not receive interrupts while this function is being
  * executed.
  */
-static int pm_noirq_op(struct device *dev,
-                        const struct dev_pm_ops *ops,
-                        pm_message_t state)
+static pm_callback_t pm_noirq_op(const struct dev_pm_ops *ops, pm_message_t state)
 {
-        int error = 0;
-
         switch (state.event) {
 #ifdef CONFIG_SUSPEND
         case PM_EVENT_SUSPEND:
-                error = dpm_run_callback(dev, ops->suspend_noirq);
-                break;
+                return ops->suspend_noirq;
         case PM_EVENT_RESUME:
-                error = dpm_run_callback(dev, ops->resume_noirq);
-                break;
+                return ops->resume_noirq;
 #endif /* CONFIG_SUSPEND */
 #ifdef CONFIG_HIBERNATE_CALLBACKS
         case PM_EVENT_FREEZE:
         case PM_EVENT_QUIESCE:
-                error = dpm_run_callback(dev, ops->freeze_noirq);
-                break;
+                return ops->freeze_noirq;
         case PM_EVENT_HIBERNATE:
-                error = dpm_run_callback(dev, ops->poweroff_noirq);
-                break;
+                return ops->poweroff_noirq;
         case PM_EVENT_THAW:
         case PM_EVENT_RECOVER:
-                error = dpm_run_callback(dev, ops->thaw_noirq);
-                break;
+                return ops->thaw_noirq;
         case PM_EVENT_RESTORE:
-                error = dpm_run_callback(dev, ops->restore_noirq);
-                break;
+                return ops->restore_noirq;
 #endif /* CONFIG_HIBERNATE_CALLBACKS */
-        default:
-                error = -EINVAL;
         }
 
-        return error;
+        return NULL;
 }
 
 static char *pm_verb(int event)
@@ -375,6 +334,26 @@ static void dpm_show_time(ktime_t starttime, pm_message_t state, char *info)
                 usecs / USEC_PER_MSEC, usecs % USEC_PER_MSEC);
 }
 
+static int dpm_run_callback(pm_callback_t cb, struct device *dev,
+                            pm_message_t state, char *info)
+{
+        ktime_t calltime;
+        int error;
+
+        if (!cb)
+                return 0;
+
+        calltime = initcall_debug_start(dev);
+
+        pm_dev_dbg(dev, state, info);
+        error = cb(dev);
+        suspend_report_result(cb, error);
+
+        initcall_debug_report(dev, calltime, error);
+
+        return error;
+}
+
 /*------------------------- Resume routines -------------------------*/
 
 /**
@@ -387,25 +366,29 @@ static void dpm_show_time(ktime_t starttime, pm_message_t state, char *info)
  */
 static int device_resume_noirq(struct device *dev, pm_message_t state)
 {
+        pm_callback_t callback = NULL;
+        char *info = NULL;
         int error = 0;
 
         TRACE_DEVICE(dev);
         TRACE_RESUME(0);
 
         if (dev->pm_domain) {
-                pm_dev_dbg(dev, state, "EARLY power domain ");
-                error = pm_noirq_op(dev, &dev->pm_domain->ops, state);
+                info = "EARLY power domain ";
+                callback = pm_noirq_op(&dev->pm_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);
+                info = "EARLY type ";
+                callback = pm_noirq_op(dev->type->pm, state);
         } else if (dev->class && dev->class->pm) {
-                pm_dev_dbg(dev, state, "EARLY class ");
-                error = pm_noirq_op(dev, dev->class->pm, state);
+                info = "EARLY class ";
+                callback = pm_noirq_op(dev->class->pm, state);
         } else if (dev->bus && dev->bus->pm) {
-                pm_dev_dbg(dev, state, "EARLY ");
-                error = pm_noirq_op(dev, dev->bus->pm, state);
+                info = "EARLY ";
+                callback = pm_noirq_op(dev->bus->pm, state);
         }
 
+        error = dpm_run_callback(callback, dev, state, info);
+
         TRACE_RESUME(error);
         return error;
 }
@@ -455,6 +438,8 @@ EXPORT_SYMBOL_GPL(dpm_resume_noirq);
  */
 static int device_resume(struct device *dev, pm_message_t state, bool async)
 {
+        pm_callback_t callback = NULL;
+        char *info = NULL;
         int error = 0;
         bool put = false;
 
@@ -477,40 +462,41 @@ static int device_resume(struct device *dev, pm_message_t state, bool async)
         put = true;
 
         if (dev->pm_domain) {
-                pm_dev_dbg(dev, state, "power domain ");
-                error = pm_op(dev, &dev->pm_domain->ops, state);
+                info = "power domain ";
+                callback = pm_op(&dev->pm_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);
+                info = "type ";
+                callback = pm_op(dev->type->pm, state);
                 goto End;
         }
 
         if (dev->class) {
                 if (dev->class->pm) {
-                        pm_dev_dbg(dev, state, "class ");
-                        error = pm_op(dev, dev->class->pm, state);
+                        info = "class ";
+                        callback = pm_op(dev->class->pm, state);
                         goto End;
                 } else if (dev->class->resume) {
-                        pm_dev_dbg(dev, state, "legacy class ");
-                        error = dpm_run_callback(dev, dev->class->resume);
+                        info = "legacy class ";
+                        callback = dev->class->resume;
                         goto End;
                 }
         }
 
         if (dev->bus) {
                 if (dev->bus->pm) {
-                        pm_dev_dbg(dev, state, "");
-                        error = pm_op(dev, dev->bus->pm, state);
+                        info = "";
+                        callback = pm_op(dev->bus->pm, state);
                 } else if (dev->bus->resume) {
-                        pm_dev_dbg(dev, state, "legacy ");
-                        error = dpm_run_callback(dev, dev->bus->resume);
+                        info = "legacy ";
+                        callback = dev->bus->resume;
                 }
         }
 
  End:
+        error = dpm_run_callback(callback, dev, state, info);
         dev->power.is_suspended = false;
 
  Unlock:
@@ -705,23 +691,24 @@ static pm_message_t resume_event(pm_message_t sleep_state)
  */
 static int device_suspend_noirq(struct device *dev, pm_message_t state)
 {
-        int error = 0;
+        pm_callback_t callback = NULL;
+        char *info = NULL;
 
         if (dev->pm_domain) {
-                pm_dev_dbg(dev, state, "LATE power domain ");
-                error = pm_noirq_op(dev, &dev->pm_domain->ops, state);
+                info = "LATE power domain ";
+                callback = pm_noirq_op(&dev->pm_domain->ops, state);
         } else if (dev->type && dev->type->pm) {
-                pm_dev_dbg(dev, state, "LATE type ");
-                error = pm_noirq_op(dev, dev->type->pm, state);
+                info = "LATE type ";
+                callback = pm_noirq_op(dev->type->pm, state);
         } else if (dev->class && dev->class->pm) {
-                pm_dev_dbg(dev, state, "LATE class ");
-                error = pm_noirq_op(dev, dev->class->pm, state);
+                info = "LATE class ";
+                callback = pm_noirq_op(dev->class->pm, state);
         } else if (dev->bus && dev->bus->pm) {
-                pm_dev_dbg(dev, state, "LATE ");
-                error = pm_noirq_op(dev, dev->bus->pm, state);
+                info = "LATE ";
+                callback = pm_noirq_op(dev->bus->pm, state);
         }
 
-        return error;
+        return dpm_run_callback(callback, dev, state, info);
 }
 
 /**
@@ -798,6 +785,8 @@ static int legacy_suspend(struct device *dev, pm_message_t state,
  */
 static int __device_suspend(struct device *dev, pm_message_t state, bool async)
 {
+        pm_callback_t callback = NULL;
+        char *info = NULL;
         int error = 0;
 
         dpm_wait_for_children(dev, async);
@@ -818,22 +807,22 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async)
         device_lock(dev);
 
         if (dev->pm_domain) {
-                pm_dev_dbg(dev, state, "power domain ");
-                error = pm_op(dev, &dev->pm_domain->ops, state);
-                goto End;
+                info = "power domain ";
+                callback = pm_op(&dev->pm_domain->ops, state);
+                goto Run;
         }
 
         if (dev->type && dev->type->pm) {
-                pm_dev_dbg(dev, state, "type ");
-                error = pm_op(dev, dev->type->pm, state);
-                goto End;
+                info = "type ";
+                callback = pm_op(dev->type->pm, state);
+                goto Run;
         }
 
         if (dev->class) {
                 if (dev->class->pm) {
-                        pm_dev_dbg(dev, state, "class ");
-                        error = pm_op(dev, dev->class->pm, state);
-                        goto End;
+                        info = "class ";
+                        callback = pm_op(dev->class->pm, state);
+                        goto Run;
                 } else if (dev->class->suspend) {
                         pm_dev_dbg(dev, state, "legacy class ");
                         error = legacy_suspend(dev, state, dev->class->suspend);
@@ -843,14 +832,18 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async)
 
         if (dev->bus) {
                 if (dev->bus->pm) {
-                        pm_dev_dbg(dev, state, "");
-                        error = pm_op(dev, dev->bus->pm, state);
+                        info = "";
+                        callback = pm_op(dev->bus->pm, state);
                 } else if (dev->bus->suspend) {
                         pm_dev_dbg(dev, state, "legacy ");
                         error = legacy_suspend(dev, state, dev->bus->suspend);
+                        goto End;
                 }
         }
 
+ Run:
+        error = dpm_run_callback(callback, dev, state, info);
+
  End:
         if (!error) {
                 dev->power.is_suspended = true;