Skip to content

Commit

Permalink
PM / Sleep: Make pm_op() and pm_noirq_op() return callback pointers
Browse files Browse the repository at this point in the history 
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>
  • Loading branch information
Rafael J. Wysocki committed Dec 21, 2011
1 parent b00f4dc commit 9cf519d
Showing 1 changed file with 95 additions and 102 deletions.
197 changes: 95 additions & 102 deletions drivers/base/power/main.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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
Expand Down Expand Up @@ -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)
Expand Down Expand Up @@ -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 -------------------------*/

/**
Expand All @@ -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;
}
Expand Down Expand Up @@ -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;

Expand All @@ -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:
Expand Down Expand Up @@ -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);
}

/**
Expand Down Expand Up @@ -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);
Expand All @@ -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);
Expand All @@ -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;
Expand Down

0 comments on commit 9cf519d

Please sign in to comment.