2011-07-01 14:12:45 -06:00
|
|
|
/*
|
|
|
|
* drivers/base/power/domain.c - Common code related to device power domains.
|
|
|
|
*
|
|
|
|
* 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_runtime.h>
|
|
|
|
#include <linux/pm_domain.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/err.h>
|
2011-07-11 16:39:29 -06:00
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/suspend.h>
|
2011-07-01 14:12:45 -06:00
|
|
|
|
2011-07-13 04:31:52 -06:00
|
|
|
static LIST_HEAD(gpd_list);
|
|
|
|
static DEFINE_MUTEX(gpd_list_lock);
|
|
|
|
|
2011-07-01 14:13:10 -06:00
|
|
|
#ifdef CONFIG_PM
|
|
|
|
|
|
|
|
static struct generic_pm_domain *dev_to_genpd(struct device *dev)
|
|
|
|
{
|
|
|
|
if (IS_ERR_OR_NULL(dev->pm_domain))
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
2011-07-01 14:13:19 -06:00
|
|
|
return pd_to_genpd(dev->pm_domain);
|
2011-07-01 14:13:10 -06:00
|
|
|
}
|
2011-07-01 14:12:45 -06:00
|
|
|
|
2011-08-08 15:43:04 -06:00
|
|
|
static bool genpd_sd_counter_dec(struct generic_pm_domain *genpd)
|
2011-07-01 14:12:45 -06:00
|
|
|
{
|
2011-08-08 15:43:04 -06:00
|
|
|
bool ret = false;
|
|
|
|
|
|
|
|
if (!WARN_ON(atomic_read(&genpd->sd_count) == 0))
|
|
|
|
ret = !!atomic_dec_and_test(&genpd->sd_count);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void genpd_sd_counter_inc(struct generic_pm_domain *genpd)
|
|
|
|
{
|
|
|
|
atomic_inc(&genpd->sd_count);
|
|
|
|
smp_mb__after_atomic_inc();
|
2011-07-01 14:12:45 -06:00
|
|
|
}
|
|
|
|
|
2011-07-11 16:39:29 -06:00
|
|
|
static void genpd_acquire_lock(struct generic_pm_domain *genpd)
|
|
|
|
{
|
|
|
|
DEFINE_WAIT(wait);
|
|
|
|
|
|
|
|
mutex_lock(&genpd->lock);
|
|
|
|
/*
|
|
|
|
* Wait for the domain to transition into either the active,
|
|
|
|
* or the power off state.
|
|
|
|
*/
|
|
|
|
for (;;) {
|
|
|
|
prepare_to_wait(&genpd->status_wait_queue, &wait,
|
|
|
|
TASK_UNINTERRUPTIBLE);
|
PM / Domains: Allow callbacks to execute all runtime PM helpers
A deadlock may occur if one of the PM domains' .start_device() or
.stop_device() callbacks or a device driver's .runtime_suspend() or
.runtime_resume() callback executed by the core generic PM domain
code uses a "wrong" runtime PM helper function. This happens, for
example, if .runtime_resume() from one device's driver calls
pm_runtime_resume() for another device in the same PM domain.
A similar situation may take place if a device's parent is in the
same PM domain, in which case the runtime PM framework may execute
pm_genpd_runtime_resume() automatically for the parent (if it is
suspended at the moment). This, of course, is undesirable, so
the generic PM domains code should be modified to prevent it from
happening.
The runtime PM framework guarantees that pm_genpd_runtime_suspend()
and pm_genpd_runtime_resume() won't be executed in parallel for
the same device, so the generic PM domains code need not worry
about those cases. Still, it needs to prevent the other possible
race conditions between pm_genpd_runtime_suspend(),
pm_genpd_runtime_resume(), pm_genpd_poweron() and pm_genpd_poweroff()
from happening and it needs to avoid deadlocks at the same time.
To this end, modify the generic PM domains code to relax
synchronization rules so that:
* pm_genpd_poweron() doesn't wait for the PM domain status to
change from GPD_STATE_BUSY. If it finds that the status is
not GPD_STATE_POWER_OFF, it returns without powering the domain on
(it may modify the status depending on the circumstances).
* pm_genpd_poweroff() returns as soon as it finds that the PM
domain's status changed from GPD_STATE_BUSY after it's released
the PM domain's lock.
* pm_genpd_runtime_suspend() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing the domain's
.stop_device() callback and executes pm_genpd_poweroff() only
if pm_genpd_runtime_resume() is not executed in parallel.
* pm_genpd_runtime_resume() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing pm_genpd_poweron()
and sets the domain's status to GPD_STATE_BUSY and increments its
counter of resuming devices (introduced by this change) immediately
after acquiring the lock. The counter of resuming devices is then
decremented after executing __pm_genpd_runtime_resume() for the
device and the domain's status is reset to GPD_STATE_ACTIVE (unless
there are more resuming devices in the domain, in which case the
status remains GPD_STATE_BUSY).
This way, for example, if a device driver's .runtime_resume()
callback executes pm_runtime_resume() for another device in the same
PM domain, pm_genpd_poweron() called by pm_genpd_runtime_resume()
invoked by the runtime PM framework will not block and it will see
that there's nothing to do for it. Next, the PM domain's lock will
be acquired without waiting for its status to change from
GPD_STATE_BUSY and the device driver's .runtime_resume() callback
will be executed. In turn, if pm_runtime_suspend() is executed by
one device driver's .runtime_resume() callback for another device in
the same PM domain, pm_genpd_poweroff() executed by
pm_genpd_runtime_suspend() invoked by the runtime PM framework as a
result will notice that one of the devices in the domain is being
resumed, so it will return immediately.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 16:39:36 -06:00
|
|
|
if (genpd->status == GPD_STATE_ACTIVE
|
|
|
|
|| genpd->status == GPD_STATE_POWER_OFF)
|
2011-07-11 16:39:29 -06:00
|
|
|
break;
|
|
|
|
mutex_unlock(&genpd->lock);
|
|
|
|
|
|
|
|
schedule();
|
|
|
|
|
|
|
|
mutex_lock(&genpd->lock);
|
|
|
|
}
|
|
|
|
finish_wait(&genpd->status_wait_queue, &wait);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void genpd_release_lock(struct generic_pm_domain *genpd)
|
|
|
|
{
|
|
|
|
mutex_unlock(&genpd->lock);
|
|
|
|
}
|
|
|
|
|
PM / Domains: Allow callbacks to execute all runtime PM helpers
A deadlock may occur if one of the PM domains' .start_device() or
.stop_device() callbacks or a device driver's .runtime_suspend() or
.runtime_resume() callback executed by the core generic PM domain
code uses a "wrong" runtime PM helper function. This happens, for
example, if .runtime_resume() from one device's driver calls
pm_runtime_resume() for another device in the same PM domain.
A similar situation may take place if a device's parent is in the
same PM domain, in which case the runtime PM framework may execute
pm_genpd_runtime_resume() automatically for the parent (if it is
suspended at the moment). This, of course, is undesirable, so
the generic PM domains code should be modified to prevent it from
happening.
The runtime PM framework guarantees that pm_genpd_runtime_suspend()
and pm_genpd_runtime_resume() won't be executed in parallel for
the same device, so the generic PM domains code need not worry
about those cases. Still, it needs to prevent the other possible
race conditions between pm_genpd_runtime_suspend(),
pm_genpd_runtime_resume(), pm_genpd_poweron() and pm_genpd_poweroff()
from happening and it needs to avoid deadlocks at the same time.
To this end, modify the generic PM domains code to relax
synchronization rules so that:
* pm_genpd_poweron() doesn't wait for the PM domain status to
change from GPD_STATE_BUSY. If it finds that the status is
not GPD_STATE_POWER_OFF, it returns without powering the domain on
(it may modify the status depending on the circumstances).
* pm_genpd_poweroff() returns as soon as it finds that the PM
domain's status changed from GPD_STATE_BUSY after it's released
the PM domain's lock.
* pm_genpd_runtime_suspend() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing the domain's
.stop_device() callback and executes pm_genpd_poweroff() only
if pm_genpd_runtime_resume() is not executed in parallel.
* pm_genpd_runtime_resume() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing pm_genpd_poweron()
and sets the domain's status to GPD_STATE_BUSY and increments its
counter of resuming devices (introduced by this change) immediately
after acquiring the lock. The counter of resuming devices is then
decremented after executing __pm_genpd_runtime_resume() for the
device and the domain's status is reset to GPD_STATE_ACTIVE (unless
there are more resuming devices in the domain, in which case the
status remains GPD_STATE_BUSY).
This way, for example, if a device driver's .runtime_resume()
callback executes pm_runtime_resume() for another device in the same
PM domain, pm_genpd_poweron() called by pm_genpd_runtime_resume()
invoked by the runtime PM framework will not block and it will see
that there's nothing to do for it. Next, the PM domain's lock will
be acquired without waiting for its status to change from
GPD_STATE_BUSY and the device driver's .runtime_resume() callback
will be executed. In turn, if pm_runtime_suspend() is executed by
one device driver's .runtime_resume() callback for another device in
the same PM domain, pm_genpd_poweroff() executed by
pm_genpd_runtime_suspend() invoked by the runtime PM framework as a
result will notice that one of the devices in the domain is being
resumed, so it will return immediately.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 16:39:36 -06:00
|
|
|
static void genpd_set_active(struct generic_pm_domain *genpd)
|
|
|
|
{
|
|
|
|
if (genpd->resume_count == 0)
|
|
|
|
genpd->status = GPD_STATE_ACTIVE;
|
|
|
|
}
|
|
|
|
|
2011-07-01 14:13:10 -06:00
|
|
|
/**
|
2011-08-08 15:43:40 -06:00
|
|
|
* __pm_genpd_poweron - Restore power to a given PM domain and its masters.
|
2011-07-01 14:13:10 -06:00
|
|
|
* @genpd: PM domain to power up.
|
|
|
|
*
|
2011-08-08 15:43:40 -06:00
|
|
|
* Restore power to @genpd and all of its masters so that it is possible to
|
2011-07-01 14:13:10 -06:00
|
|
|
* resume a device belonging to it.
|
|
|
|
*/
|
2011-08-08 15:43:29 -06:00
|
|
|
int __pm_genpd_poweron(struct generic_pm_domain *genpd)
|
|
|
|
__releases(&genpd->lock) __acquires(&genpd->lock)
|
2011-07-01 14:13:10 -06:00
|
|
|
{
|
2011-08-08 15:43:40 -06:00
|
|
|
struct gpd_link *link;
|
2011-08-08 15:43:29 -06:00
|
|
|
DEFINE_WAIT(wait);
|
2011-07-01 14:13:10 -06:00
|
|
|
int ret = 0;
|
|
|
|
|
2011-08-08 15:43:40 -06:00
|
|
|
/* If the domain's master is being waited for, we have to wait too. */
|
2011-08-08 15:43:29 -06:00
|
|
|
for (;;) {
|
|
|
|
prepare_to_wait(&genpd->status_wait_queue, &wait,
|
|
|
|
TASK_UNINTERRUPTIBLE);
|
|
|
|
if (genpd->status != GPD_STATE_WAIT_PARENT)
|
|
|
|
break;
|
|
|
|
mutex_unlock(&genpd->lock);
|
2011-07-11 16:39:29 -06:00
|
|
|
|
2011-08-08 15:43:29 -06:00
|
|
|
schedule();
|
|
|
|
|
|
|
|
mutex_lock(&genpd->lock);
|
|
|
|
}
|
|
|
|
finish_wait(&genpd->status_wait_queue, &wait);
|
2011-08-08 15:43:22 -06:00
|
|
|
|
2011-07-11 16:39:29 -06:00
|
|
|
if (genpd->status == GPD_STATE_ACTIVE
|
2011-07-01 14:13:19 -06:00
|
|
|
|| (genpd->prepared_count > 0 && genpd->suspend_power_off))
|
2011-08-08 15:43:29 -06:00
|
|
|
return 0;
|
2011-07-01 14:13:10 -06:00
|
|
|
|
PM / Domains: Allow callbacks to execute all runtime PM helpers
A deadlock may occur if one of the PM domains' .start_device() or
.stop_device() callbacks or a device driver's .runtime_suspend() or
.runtime_resume() callback executed by the core generic PM domain
code uses a "wrong" runtime PM helper function. This happens, for
example, if .runtime_resume() from one device's driver calls
pm_runtime_resume() for another device in the same PM domain.
A similar situation may take place if a device's parent is in the
same PM domain, in which case the runtime PM framework may execute
pm_genpd_runtime_resume() automatically for the parent (if it is
suspended at the moment). This, of course, is undesirable, so
the generic PM domains code should be modified to prevent it from
happening.
The runtime PM framework guarantees that pm_genpd_runtime_suspend()
and pm_genpd_runtime_resume() won't be executed in parallel for
the same device, so the generic PM domains code need not worry
about those cases. Still, it needs to prevent the other possible
race conditions between pm_genpd_runtime_suspend(),
pm_genpd_runtime_resume(), pm_genpd_poweron() and pm_genpd_poweroff()
from happening and it needs to avoid deadlocks at the same time.
To this end, modify the generic PM domains code to relax
synchronization rules so that:
* pm_genpd_poweron() doesn't wait for the PM domain status to
change from GPD_STATE_BUSY. If it finds that the status is
not GPD_STATE_POWER_OFF, it returns without powering the domain on
(it may modify the status depending on the circumstances).
* pm_genpd_poweroff() returns as soon as it finds that the PM
domain's status changed from GPD_STATE_BUSY after it's released
the PM domain's lock.
* pm_genpd_runtime_suspend() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing the domain's
.stop_device() callback and executes pm_genpd_poweroff() only
if pm_genpd_runtime_resume() is not executed in parallel.
* pm_genpd_runtime_resume() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing pm_genpd_poweron()
and sets the domain's status to GPD_STATE_BUSY and increments its
counter of resuming devices (introduced by this change) immediately
after acquiring the lock. The counter of resuming devices is then
decremented after executing __pm_genpd_runtime_resume() for the
device and the domain's status is reset to GPD_STATE_ACTIVE (unless
there are more resuming devices in the domain, in which case the
status remains GPD_STATE_BUSY).
This way, for example, if a device driver's .runtime_resume()
callback executes pm_runtime_resume() for another device in the same
PM domain, pm_genpd_poweron() called by pm_genpd_runtime_resume()
invoked by the runtime PM framework will not block and it will see
that there's nothing to do for it. Next, the PM domain's lock will
be acquired without waiting for its status to change from
GPD_STATE_BUSY and the device driver's .runtime_resume() callback
will be executed. In turn, if pm_runtime_suspend() is executed by
one device driver's .runtime_resume() callback for another device in
the same PM domain, pm_genpd_poweroff() executed by
pm_genpd_runtime_suspend() invoked by the runtime PM framework as a
result will notice that one of the devices in the domain is being
resumed, so it will return immediately.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 16:39:36 -06:00
|
|
|
if (genpd->status != GPD_STATE_POWER_OFF) {
|
|
|
|
genpd_set_active(genpd);
|
2011-08-08 15:43:29 -06:00
|
|
|
return 0;
|
PM / Domains: Allow callbacks to execute all runtime PM helpers
A deadlock may occur if one of the PM domains' .start_device() or
.stop_device() callbacks or a device driver's .runtime_suspend() or
.runtime_resume() callback executed by the core generic PM domain
code uses a "wrong" runtime PM helper function. This happens, for
example, if .runtime_resume() from one device's driver calls
pm_runtime_resume() for another device in the same PM domain.
A similar situation may take place if a device's parent is in the
same PM domain, in which case the runtime PM framework may execute
pm_genpd_runtime_resume() automatically for the parent (if it is
suspended at the moment). This, of course, is undesirable, so
the generic PM domains code should be modified to prevent it from
happening.
The runtime PM framework guarantees that pm_genpd_runtime_suspend()
and pm_genpd_runtime_resume() won't be executed in parallel for
the same device, so the generic PM domains code need not worry
about those cases. Still, it needs to prevent the other possible
race conditions between pm_genpd_runtime_suspend(),
pm_genpd_runtime_resume(), pm_genpd_poweron() and pm_genpd_poweroff()
from happening and it needs to avoid deadlocks at the same time.
To this end, modify the generic PM domains code to relax
synchronization rules so that:
* pm_genpd_poweron() doesn't wait for the PM domain status to
change from GPD_STATE_BUSY. If it finds that the status is
not GPD_STATE_POWER_OFF, it returns without powering the domain on
(it may modify the status depending on the circumstances).
* pm_genpd_poweroff() returns as soon as it finds that the PM
domain's status changed from GPD_STATE_BUSY after it's released
the PM domain's lock.
* pm_genpd_runtime_suspend() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing the domain's
.stop_device() callback and executes pm_genpd_poweroff() only
if pm_genpd_runtime_resume() is not executed in parallel.
* pm_genpd_runtime_resume() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing pm_genpd_poweron()
and sets the domain's status to GPD_STATE_BUSY and increments its
counter of resuming devices (introduced by this change) immediately
after acquiring the lock. The counter of resuming devices is then
decremented after executing __pm_genpd_runtime_resume() for the
device and the domain's status is reset to GPD_STATE_ACTIVE (unless
there are more resuming devices in the domain, in which case the
status remains GPD_STATE_BUSY).
This way, for example, if a device driver's .runtime_resume()
callback executes pm_runtime_resume() for another device in the same
PM domain, pm_genpd_poweron() called by pm_genpd_runtime_resume()
invoked by the runtime PM framework will not block and it will see
that there's nothing to do for it. Next, the PM domain's lock will
be acquired without waiting for its status to change from
GPD_STATE_BUSY and the device driver's .runtime_resume() callback
will be executed. In turn, if pm_runtime_suspend() is executed by
one device driver's .runtime_resume() callback for another device in
the same PM domain, pm_genpd_poweroff() executed by
pm_genpd_runtime_suspend() invoked by the runtime PM framework as a
result will notice that one of the devices in the domain is being
resumed, so it will return immediately.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 16:39:36 -06:00
|
|
|
}
|
|
|
|
|
2011-08-08 15:43:40 -06:00
|
|
|
/*
|
|
|
|
* The list is guaranteed not to change while the loop below is being
|
|
|
|
* executed, unless one of the masters' .power_on() callbacks fiddles
|
|
|
|
* with it.
|
|
|
|
*/
|
|
|
|
list_for_each_entry(link, &genpd->slave_links, slave_node) {
|
|
|
|
genpd_sd_counter_inc(link->master);
|
2011-08-08 15:43:29 -06:00
|
|
|
genpd->status = GPD_STATE_WAIT_PARENT;
|
2011-08-08 15:43:14 -06:00
|
|
|
|
2011-07-01 14:13:10 -06:00
|
|
|
mutex_unlock(&genpd->lock);
|
|
|
|
|
2011-08-08 15:43:40 -06:00
|
|
|
ret = pm_genpd_poweron(link->master);
|
2011-08-08 15:43:22 -06:00
|
|
|
|
|
|
|
mutex_lock(&genpd->lock);
|
|
|
|
|
2011-08-08 15:43:29 -06:00
|
|
|
/*
|
|
|
|
* The "wait for parent" status is guaranteed not to change
|
2011-08-08 15:43:40 -06:00
|
|
|
* while the master is powering on.
|
2011-08-08 15:43:29 -06:00
|
|
|
*/
|
|
|
|
genpd->status = GPD_STATE_POWER_OFF;
|
|
|
|
wake_up_all(&genpd->status_wait_queue);
|
2011-08-08 15:43:40 -06:00
|
|
|
if (ret) {
|
|
|
|
genpd_sd_counter_dec(link->master);
|
2011-08-08 15:43:22 -06:00
|
|
|
goto err;
|
2011-08-08 15:43:40 -06:00
|
|
|
}
|
2011-07-01 14:13:10 -06:00
|
|
|
}
|
|
|
|
|
2011-08-08 15:43:22 -06:00
|
|
|
if (genpd->power_on) {
|
2011-08-05 13:45:11 -06:00
|
|
|
ret = genpd->power_on(genpd);
|
2011-08-08 15:43:22 -06:00
|
|
|
if (ret)
|
|
|
|
goto err;
|
2011-08-08 15:43:14 -06:00
|
|
|
}
|
2011-07-01 14:13:10 -06:00
|
|
|
|
2011-08-08 15:43:22 -06:00
|
|
|
genpd_set_active(genpd);
|
|
|
|
|
2011-08-08 15:43:29 -06:00
|
|
|
return 0;
|
2011-08-08 15:43:22 -06:00
|
|
|
|
|
|
|
err:
|
2011-08-08 15:43:40 -06:00
|
|
|
list_for_each_entry_continue_reverse(link, &genpd->slave_links, slave_node)
|
|
|
|
genpd_sd_counter_dec(link->master);
|
2011-08-08 15:43:22 -06:00
|
|
|
|
2011-08-08 15:43:29 -06:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-08-08 15:43:40 -06:00
|
|
|
* pm_genpd_poweron - Restore power to a given PM domain and its masters.
|
2011-08-08 15:43:29 -06:00
|
|
|
* @genpd: PM domain to power up.
|
|
|
|
*/
|
|
|
|
int pm_genpd_poweron(struct generic_pm_domain *genpd)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
mutex_lock(&genpd->lock);
|
|
|
|
ret = __pm_genpd_poweron(genpd);
|
|
|
|
mutex_unlock(&genpd->lock);
|
|
|
|
return ret;
|
2011-07-01 14:13:10 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* CONFIG_PM */
|
|
|
|
|
|
|
|
#ifdef CONFIG_PM_RUNTIME
|
|
|
|
|
2011-07-01 14:12:45 -06:00
|
|
|
/**
|
|
|
|
* __pm_genpd_save_device - Save the pre-suspend state of a device.
|
|
|
|
* @dle: Device list entry of the device to save the state of.
|
|
|
|
* @genpd: PM domain the device belongs to.
|
|
|
|
*/
|
|
|
|
static int __pm_genpd_save_device(struct dev_list_entry *dle,
|
|
|
|
struct generic_pm_domain *genpd)
|
2011-07-11 16:39:29 -06:00
|
|
|
__releases(&genpd->lock) __acquires(&genpd->lock)
|
2011-07-01 14:12:45 -06:00
|
|
|
{
|
|
|
|
struct device *dev = dle->dev;
|
|
|
|
struct device_driver *drv = dev->driver;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (dle->need_restore)
|
|
|
|
return 0;
|
|
|
|
|
2011-07-11 16:39:29 -06:00
|
|
|
mutex_unlock(&genpd->lock);
|
|
|
|
|
2011-07-01 14:12:45 -06:00
|
|
|
if (drv && drv->pm && drv->pm->runtime_suspend) {
|
|
|
|
if (genpd->start_device)
|
|
|
|
genpd->start_device(dev);
|
|
|
|
|
|
|
|
ret = drv->pm->runtime_suspend(dev);
|
|
|
|
|
|
|
|
if (genpd->stop_device)
|
|
|
|
genpd->stop_device(dev);
|
|
|
|
}
|
|
|
|
|
2011-07-11 16:39:29 -06:00
|
|
|
mutex_lock(&genpd->lock);
|
|
|
|
|
2011-07-01 14:12:45 -06:00
|
|
|
if (!ret)
|
|
|
|
dle->need_restore = true;
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __pm_genpd_restore_device - Restore the pre-suspend state of a device.
|
|
|
|
* @dle: Device list entry of the device to restore the state of.
|
|
|
|
* @genpd: PM domain the device belongs to.
|
|
|
|
*/
|
|
|
|
static void __pm_genpd_restore_device(struct dev_list_entry *dle,
|
|
|
|
struct generic_pm_domain *genpd)
|
2011-07-11 16:39:29 -06:00
|
|
|
__releases(&genpd->lock) __acquires(&genpd->lock)
|
2011-07-01 14:12:45 -06:00
|
|
|
{
|
|
|
|
struct device *dev = dle->dev;
|
|
|
|
struct device_driver *drv = dev->driver;
|
|
|
|
|
|
|
|
if (!dle->need_restore)
|
|
|
|
return;
|
|
|
|
|
2011-07-11 16:39:29 -06:00
|
|
|
mutex_unlock(&genpd->lock);
|
|
|
|
|
2011-07-01 14:12:45 -06:00
|
|
|
if (drv && drv->pm && drv->pm->runtime_resume) {
|
|
|
|
if (genpd->start_device)
|
|
|
|
genpd->start_device(dev);
|
|
|
|
|
|
|
|
drv->pm->runtime_resume(dev);
|
|
|
|
|
|
|
|
if (genpd->stop_device)
|
|
|
|
genpd->stop_device(dev);
|
|
|
|
}
|
|
|
|
|
2011-07-11 16:39:29 -06:00
|
|
|
mutex_lock(&genpd->lock);
|
|
|
|
|
2011-07-01 14:12:45 -06:00
|
|
|
dle->need_restore = false;
|
|
|
|
}
|
|
|
|
|
PM / Domains: Allow callbacks to execute all runtime PM helpers
A deadlock may occur if one of the PM domains' .start_device() or
.stop_device() callbacks or a device driver's .runtime_suspend() or
.runtime_resume() callback executed by the core generic PM domain
code uses a "wrong" runtime PM helper function. This happens, for
example, if .runtime_resume() from one device's driver calls
pm_runtime_resume() for another device in the same PM domain.
A similar situation may take place if a device's parent is in the
same PM domain, in which case the runtime PM framework may execute
pm_genpd_runtime_resume() automatically for the parent (if it is
suspended at the moment). This, of course, is undesirable, so
the generic PM domains code should be modified to prevent it from
happening.
The runtime PM framework guarantees that pm_genpd_runtime_suspend()
and pm_genpd_runtime_resume() won't be executed in parallel for
the same device, so the generic PM domains code need not worry
about those cases. Still, it needs to prevent the other possible
race conditions between pm_genpd_runtime_suspend(),
pm_genpd_runtime_resume(), pm_genpd_poweron() and pm_genpd_poweroff()
from happening and it needs to avoid deadlocks at the same time.
To this end, modify the generic PM domains code to relax
synchronization rules so that:
* pm_genpd_poweron() doesn't wait for the PM domain status to
change from GPD_STATE_BUSY. If it finds that the status is
not GPD_STATE_POWER_OFF, it returns without powering the domain on
(it may modify the status depending on the circumstances).
* pm_genpd_poweroff() returns as soon as it finds that the PM
domain's status changed from GPD_STATE_BUSY after it's released
the PM domain's lock.
* pm_genpd_runtime_suspend() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing the domain's
.stop_device() callback and executes pm_genpd_poweroff() only
if pm_genpd_runtime_resume() is not executed in parallel.
* pm_genpd_runtime_resume() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing pm_genpd_poweron()
and sets the domain's status to GPD_STATE_BUSY and increments its
counter of resuming devices (introduced by this change) immediately
after acquiring the lock. The counter of resuming devices is then
decremented after executing __pm_genpd_runtime_resume() for the
device and the domain's status is reset to GPD_STATE_ACTIVE (unless
there are more resuming devices in the domain, in which case the
status remains GPD_STATE_BUSY).
This way, for example, if a device driver's .runtime_resume()
callback executes pm_runtime_resume() for another device in the same
PM domain, pm_genpd_poweron() called by pm_genpd_runtime_resume()
invoked by the runtime PM framework will not block and it will see
that there's nothing to do for it. Next, the PM domain's lock will
be acquired without waiting for its status to change from
GPD_STATE_BUSY and the device driver's .runtime_resume() callback
will be executed. In turn, if pm_runtime_suspend() is executed by
one device driver's .runtime_resume() callback for another device in
the same PM domain, pm_genpd_poweroff() executed by
pm_genpd_runtime_suspend() invoked by the runtime PM framework as a
result will notice that one of the devices in the domain is being
resumed, so it will return immediately.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 16:39:36 -06:00
|
|
|
/**
|
|
|
|
* genpd_abort_poweroff - Check if a PM domain power off should be aborted.
|
|
|
|
* @genpd: PM domain to check.
|
|
|
|
*
|
|
|
|
* Return true if a PM domain's status changed to GPD_STATE_ACTIVE during
|
|
|
|
* a "power off" operation, which means that a "power on" has occured in the
|
|
|
|
* meantime, or if its resume_count field is different from zero, which means
|
|
|
|
* that one of its devices has been resumed in the meantime.
|
|
|
|
*/
|
|
|
|
static bool genpd_abort_poweroff(struct generic_pm_domain *genpd)
|
|
|
|
{
|
2011-08-08 15:43:29 -06:00
|
|
|
return genpd->status == GPD_STATE_WAIT_PARENT
|
|
|
|
|| genpd->status == GPD_STATE_ACTIVE || genpd->resume_count > 0;
|
PM / Domains: Allow callbacks to execute all runtime PM helpers
A deadlock may occur if one of the PM domains' .start_device() or
.stop_device() callbacks or a device driver's .runtime_suspend() or
.runtime_resume() callback executed by the core generic PM domain
code uses a "wrong" runtime PM helper function. This happens, for
example, if .runtime_resume() from one device's driver calls
pm_runtime_resume() for another device in the same PM domain.
A similar situation may take place if a device's parent is in the
same PM domain, in which case the runtime PM framework may execute
pm_genpd_runtime_resume() automatically for the parent (if it is
suspended at the moment). This, of course, is undesirable, so
the generic PM domains code should be modified to prevent it from
happening.
The runtime PM framework guarantees that pm_genpd_runtime_suspend()
and pm_genpd_runtime_resume() won't be executed in parallel for
the same device, so the generic PM domains code need not worry
about those cases. Still, it needs to prevent the other possible
race conditions between pm_genpd_runtime_suspend(),
pm_genpd_runtime_resume(), pm_genpd_poweron() and pm_genpd_poweroff()
from happening and it needs to avoid deadlocks at the same time.
To this end, modify the generic PM domains code to relax
synchronization rules so that:
* pm_genpd_poweron() doesn't wait for the PM domain status to
change from GPD_STATE_BUSY. If it finds that the status is
not GPD_STATE_POWER_OFF, it returns without powering the domain on
(it may modify the status depending on the circumstances).
* pm_genpd_poweroff() returns as soon as it finds that the PM
domain's status changed from GPD_STATE_BUSY after it's released
the PM domain's lock.
* pm_genpd_runtime_suspend() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing the domain's
.stop_device() callback and executes pm_genpd_poweroff() only
if pm_genpd_runtime_resume() is not executed in parallel.
* pm_genpd_runtime_resume() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing pm_genpd_poweron()
and sets the domain's status to GPD_STATE_BUSY and increments its
counter of resuming devices (introduced by this change) immediately
after acquiring the lock. The counter of resuming devices is then
decremented after executing __pm_genpd_runtime_resume() for the
device and the domain's status is reset to GPD_STATE_ACTIVE (unless
there are more resuming devices in the domain, in which case the
status remains GPD_STATE_BUSY).
This way, for example, if a device driver's .runtime_resume()
callback executes pm_runtime_resume() for another device in the same
PM domain, pm_genpd_poweron() called by pm_genpd_runtime_resume()
invoked by the runtime PM framework will not block and it will see
that there's nothing to do for it. Next, the PM domain's lock will
be acquired without waiting for its status to change from
GPD_STATE_BUSY and the device driver's .runtime_resume() callback
will be executed. In turn, if pm_runtime_suspend() is executed by
one device driver's .runtime_resume() callback for another device in
the same PM domain, pm_genpd_poweroff() executed by
pm_genpd_runtime_suspend() invoked by the runtime PM framework as a
result will notice that one of the devices in the domain is being
resumed, so it will return immediately.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 16:39:36 -06:00
|
|
|
}
|
|
|
|
|
2011-07-11 16:40:03 -06:00
|
|
|
/**
|
|
|
|
* genpd_queue_power_off_work - Queue up the execution of pm_genpd_poweroff().
|
|
|
|
* @genpd: PM domait to power off.
|
|
|
|
*
|
|
|
|
* Queue up the execution of pm_genpd_poweroff() unless it's already been done
|
|
|
|
* before.
|
|
|
|
*/
|
2011-07-14 12:59:07 -06:00
|
|
|
void genpd_queue_power_off_work(struct generic_pm_domain *genpd)
|
2011-07-11 16:40:03 -06:00
|
|
|
{
|
|
|
|
if (!work_pending(&genpd->power_off_work))
|
|
|
|
queue_work(pm_wq, &genpd->power_off_work);
|
|
|
|
}
|
|
|
|
|
2011-07-01 14:12:45 -06:00
|
|
|
/**
|
|
|
|
* pm_genpd_poweroff - Remove power from a given PM domain.
|
|
|
|
* @genpd: PM domain to power down.
|
|
|
|
*
|
|
|
|
* If all of the @genpd's devices have been suspended and all of its subdomains
|
|
|
|
* have been powered down, run the runtime suspend callbacks provided by all of
|
|
|
|
* the @genpd's devices' drivers and remove power from @genpd.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_poweroff(struct generic_pm_domain *genpd)
|
2011-07-11 16:39:29 -06:00
|
|
|
__releases(&genpd->lock) __acquires(&genpd->lock)
|
2011-07-01 14:12:45 -06:00
|
|
|
{
|
|
|
|
struct dev_list_entry *dle;
|
2011-08-08 15:43:40 -06:00
|
|
|
struct gpd_link *link;
|
2011-07-01 14:12:45 -06:00
|
|
|
unsigned int not_suspended;
|
PM / Domains: Allow callbacks to execute all runtime PM helpers
A deadlock may occur if one of the PM domains' .start_device() or
.stop_device() callbacks or a device driver's .runtime_suspend() or
.runtime_resume() callback executed by the core generic PM domain
code uses a "wrong" runtime PM helper function. This happens, for
example, if .runtime_resume() from one device's driver calls
pm_runtime_resume() for another device in the same PM domain.
A similar situation may take place if a device's parent is in the
same PM domain, in which case the runtime PM framework may execute
pm_genpd_runtime_resume() automatically for the parent (if it is
suspended at the moment). This, of course, is undesirable, so
the generic PM domains code should be modified to prevent it from
happening.
The runtime PM framework guarantees that pm_genpd_runtime_suspend()
and pm_genpd_runtime_resume() won't be executed in parallel for
the same device, so the generic PM domains code need not worry
about those cases. Still, it needs to prevent the other possible
race conditions between pm_genpd_runtime_suspend(),
pm_genpd_runtime_resume(), pm_genpd_poweron() and pm_genpd_poweroff()
from happening and it needs to avoid deadlocks at the same time.
To this end, modify the generic PM domains code to relax
synchronization rules so that:
* pm_genpd_poweron() doesn't wait for the PM domain status to
change from GPD_STATE_BUSY. If it finds that the status is
not GPD_STATE_POWER_OFF, it returns without powering the domain on
(it may modify the status depending on the circumstances).
* pm_genpd_poweroff() returns as soon as it finds that the PM
domain's status changed from GPD_STATE_BUSY after it's released
the PM domain's lock.
* pm_genpd_runtime_suspend() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing the domain's
.stop_device() callback and executes pm_genpd_poweroff() only
if pm_genpd_runtime_resume() is not executed in parallel.
* pm_genpd_runtime_resume() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing pm_genpd_poweron()
and sets the domain's status to GPD_STATE_BUSY and increments its
counter of resuming devices (introduced by this change) immediately
after acquiring the lock. The counter of resuming devices is then
decremented after executing __pm_genpd_runtime_resume() for the
device and the domain's status is reset to GPD_STATE_ACTIVE (unless
there are more resuming devices in the domain, in which case the
status remains GPD_STATE_BUSY).
This way, for example, if a device driver's .runtime_resume()
callback executes pm_runtime_resume() for another device in the same
PM domain, pm_genpd_poweron() called by pm_genpd_runtime_resume()
invoked by the runtime PM framework will not block and it will see
that there's nothing to do for it. Next, the PM domain's lock will
be acquired without waiting for its status to change from
GPD_STATE_BUSY and the device driver's .runtime_resume() callback
will be executed. In turn, if pm_runtime_suspend() is executed by
one device driver's .runtime_resume() callback for another device in
the same PM domain, pm_genpd_poweroff() executed by
pm_genpd_runtime_suspend() invoked by the runtime PM framework as a
result will notice that one of the devices in the domain is being
resumed, so it will return immediately.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 16:39:36 -06:00
|
|
|
int ret = 0;
|
2011-07-01 14:12:45 -06:00
|
|
|
|
PM / Domains: Allow callbacks to execute all runtime PM helpers
A deadlock may occur if one of the PM domains' .start_device() or
.stop_device() callbacks or a device driver's .runtime_suspend() or
.runtime_resume() callback executed by the core generic PM domain
code uses a "wrong" runtime PM helper function. This happens, for
example, if .runtime_resume() from one device's driver calls
pm_runtime_resume() for another device in the same PM domain.
A similar situation may take place if a device's parent is in the
same PM domain, in which case the runtime PM framework may execute
pm_genpd_runtime_resume() automatically for the parent (if it is
suspended at the moment). This, of course, is undesirable, so
the generic PM domains code should be modified to prevent it from
happening.
The runtime PM framework guarantees that pm_genpd_runtime_suspend()
and pm_genpd_runtime_resume() won't be executed in parallel for
the same device, so the generic PM domains code need not worry
about those cases. Still, it needs to prevent the other possible
race conditions between pm_genpd_runtime_suspend(),
pm_genpd_runtime_resume(), pm_genpd_poweron() and pm_genpd_poweroff()
from happening and it needs to avoid deadlocks at the same time.
To this end, modify the generic PM domains code to relax
synchronization rules so that:
* pm_genpd_poweron() doesn't wait for the PM domain status to
change from GPD_STATE_BUSY. If it finds that the status is
not GPD_STATE_POWER_OFF, it returns without powering the domain on
(it may modify the status depending on the circumstances).
* pm_genpd_poweroff() returns as soon as it finds that the PM
domain's status changed from GPD_STATE_BUSY after it's released
the PM domain's lock.
* pm_genpd_runtime_suspend() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing the domain's
.stop_device() callback and executes pm_genpd_poweroff() only
if pm_genpd_runtime_resume() is not executed in parallel.
* pm_genpd_runtime_resume() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing pm_genpd_poweron()
and sets the domain's status to GPD_STATE_BUSY and increments its
counter of resuming devices (introduced by this change) immediately
after acquiring the lock. The counter of resuming devices is then
decremented after executing __pm_genpd_runtime_resume() for the
device and the domain's status is reset to GPD_STATE_ACTIVE (unless
there are more resuming devices in the domain, in which case the
status remains GPD_STATE_BUSY).
This way, for example, if a device driver's .runtime_resume()
callback executes pm_runtime_resume() for another device in the same
PM domain, pm_genpd_poweron() called by pm_genpd_runtime_resume()
invoked by the runtime PM framework will not block and it will see
that there's nothing to do for it. Next, the PM domain's lock will
be acquired without waiting for its status to change from
GPD_STATE_BUSY and the device driver's .runtime_resume() callback
will be executed. In turn, if pm_runtime_suspend() is executed by
one device driver's .runtime_resume() callback for another device in
the same PM domain, pm_genpd_poweroff() executed by
pm_genpd_runtime_suspend() invoked by the runtime PM framework as a
result will notice that one of the devices in the domain is being
resumed, so it will return immediately.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 16:39:36 -06:00
|
|
|
start:
|
|
|
|
/*
|
|
|
|
* Do not try to power off the domain in the following situations:
|
|
|
|
* (1) The domain is already in the "power off" state.
|
2011-08-08 15:43:40 -06:00
|
|
|
* (2) The domain is waiting for its master to power up.
|
PM / Domains: Allow callbacks to execute all runtime PM helpers
A deadlock may occur if one of the PM domains' .start_device() or
.stop_device() callbacks or a device driver's .runtime_suspend() or
.runtime_resume() callback executed by the core generic PM domain
code uses a "wrong" runtime PM helper function. This happens, for
example, if .runtime_resume() from one device's driver calls
pm_runtime_resume() for another device in the same PM domain.
A similar situation may take place if a device's parent is in the
same PM domain, in which case the runtime PM framework may execute
pm_genpd_runtime_resume() automatically for the parent (if it is
suspended at the moment). This, of course, is undesirable, so
the generic PM domains code should be modified to prevent it from
happening.
The runtime PM framework guarantees that pm_genpd_runtime_suspend()
and pm_genpd_runtime_resume() won't be executed in parallel for
the same device, so the generic PM domains code need not worry
about those cases. Still, it needs to prevent the other possible
race conditions between pm_genpd_runtime_suspend(),
pm_genpd_runtime_resume(), pm_genpd_poweron() and pm_genpd_poweroff()
from happening and it needs to avoid deadlocks at the same time.
To this end, modify the generic PM domains code to relax
synchronization rules so that:
* pm_genpd_poweron() doesn't wait for the PM domain status to
change from GPD_STATE_BUSY. If it finds that the status is
not GPD_STATE_POWER_OFF, it returns without powering the domain on
(it may modify the status depending on the circumstances).
* pm_genpd_poweroff() returns as soon as it finds that the PM
domain's status changed from GPD_STATE_BUSY after it's released
the PM domain's lock.
* pm_genpd_runtime_suspend() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing the domain's
.stop_device() callback and executes pm_genpd_poweroff() only
if pm_genpd_runtime_resume() is not executed in parallel.
* pm_genpd_runtime_resume() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing pm_genpd_poweron()
and sets the domain's status to GPD_STATE_BUSY and increments its
counter of resuming devices (introduced by this change) immediately
after acquiring the lock. The counter of resuming devices is then
decremented after executing __pm_genpd_runtime_resume() for the
device and the domain's status is reset to GPD_STATE_ACTIVE (unless
there are more resuming devices in the domain, in which case the
status remains GPD_STATE_BUSY).
This way, for example, if a device driver's .runtime_resume()
callback executes pm_runtime_resume() for another device in the same
PM domain, pm_genpd_poweron() called by pm_genpd_runtime_resume()
invoked by the runtime PM framework will not block and it will see
that there's nothing to do for it. Next, the PM domain's lock will
be acquired without waiting for its status to change from
GPD_STATE_BUSY and the device driver's .runtime_resume() callback
will be executed. In turn, if pm_runtime_suspend() is executed by
one device driver's .runtime_resume() callback for another device in
the same PM domain, pm_genpd_poweroff() executed by
pm_genpd_runtime_suspend() invoked by the runtime PM framework as a
result will notice that one of the devices in the domain is being
resumed, so it will return immediately.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 16:39:36 -06:00
|
|
|
* (3) One of the domain's devices is being resumed right now.
|
2011-08-08 15:43:29 -06:00
|
|
|
* (4) System suspend is in progress.
|
PM / Domains: Allow callbacks to execute all runtime PM helpers
A deadlock may occur if one of the PM domains' .start_device() or
.stop_device() callbacks or a device driver's .runtime_suspend() or
.runtime_resume() callback executed by the core generic PM domain
code uses a "wrong" runtime PM helper function. This happens, for
example, if .runtime_resume() from one device's driver calls
pm_runtime_resume() for another device in the same PM domain.
A similar situation may take place if a device's parent is in the
same PM domain, in which case the runtime PM framework may execute
pm_genpd_runtime_resume() automatically for the parent (if it is
suspended at the moment). This, of course, is undesirable, so
the generic PM domains code should be modified to prevent it from
happening.
The runtime PM framework guarantees that pm_genpd_runtime_suspend()
and pm_genpd_runtime_resume() won't be executed in parallel for
the same device, so the generic PM domains code need not worry
about those cases. Still, it needs to prevent the other possible
race conditions between pm_genpd_runtime_suspend(),
pm_genpd_runtime_resume(), pm_genpd_poweron() and pm_genpd_poweroff()
from happening and it needs to avoid deadlocks at the same time.
To this end, modify the generic PM domains code to relax
synchronization rules so that:
* pm_genpd_poweron() doesn't wait for the PM domain status to
change from GPD_STATE_BUSY. If it finds that the status is
not GPD_STATE_POWER_OFF, it returns without powering the domain on
(it may modify the status depending on the circumstances).
* pm_genpd_poweroff() returns as soon as it finds that the PM
domain's status changed from GPD_STATE_BUSY after it's released
the PM domain's lock.
* pm_genpd_runtime_suspend() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing the domain's
.stop_device() callback and executes pm_genpd_poweroff() only
if pm_genpd_runtime_resume() is not executed in parallel.
* pm_genpd_runtime_resume() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing pm_genpd_poweron()
and sets the domain's status to GPD_STATE_BUSY and increments its
counter of resuming devices (introduced by this change) immediately
after acquiring the lock. The counter of resuming devices is then
decremented after executing __pm_genpd_runtime_resume() for the
device and the domain's status is reset to GPD_STATE_ACTIVE (unless
there are more resuming devices in the domain, in which case the
status remains GPD_STATE_BUSY).
This way, for example, if a device driver's .runtime_resume()
callback executes pm_runtime_resume() for another device in the same
PM domain, pm_genpd_poweron() called by pm_genpd_runtime_resume()
invoked by the runtime PM framework will not block and it will see
that there's nothing to do for it. Next, the PM domain's lock will
be acquired without waiting for its status to change from
GPD_STATE_BUSY and the device driver's .runtime_resume() callback
will be executed. In turn, if pm_runtime_suspend() is executed by
one device driver's .runtime_resume() callback for another device in
the same PM domain, pm_genpd_poweroff() executed by
pm_genpd_runtime_suspend() invoked by the runtime PM framework as a
result will notice that one of the devices in the domain is being
resumed, so it will return immediately.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 16:39:36 -06:00
|
|
|
*/
|
2011-08-08 15:43:29 -06:00
|
|
|
if (genpd->status == GPD_STATE_POWER_OFF
|
|
|
|
|| genpd->status == GPD_STATE_WAIT_PARENT
|
|
|
|
|| genpd->resume_count > 0 || genpd->prepared_count > 0)
|
2011-07-01 14:12:45 -06:00
|
|
|
return 0;
|
|
|
|
|
2011-08-08 15:43:04 -06:00
|
|
|
if (atomic_read(&genpd->sd_count) > 0)
|
2011-07-01 14:12:45 -06:00
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
not_suspended = 0;
|
|
|
|
list_for_each_entry(dle, &genpd->dev_list, node)
|
|
|
|
if (dle->dev->driver && !pm_runtime_suspended(dle->dev))
|
|
|
|
not_suspended++;
|
|
|
|
|
|
|
|
if (not_suspended > genpd->in_progress)
|
|
|
|
return -EBUSY;
|
|
|
|
|
PM / Domains: Allow callbacks to execute all runtime PM helpers
A deadlock may occur if one of the PM domains' .start_device() or
.stop_device() callbacks or a device driver's .runtime_suspend() or
.runtime_resume() callback executed by the core generic PM domain
code uses a "wrong" runtime PM helper function. This happens, for
example, if .runtime_resume() from one device's driver calls
pm_runtime_resume() for another device in the same PM domain.
A similar situation may take place if a device's parent is in the
same PM domain, in which case the runtime PM framework may execute
pm_genpd_runtime_resume() automatically for the parent (if it is
suspended at the moment). This, of course, is undesirable, so
the generic PM domains code should be modified to prevent it from
happening.
The runtime PM framework guarantees that pm_genpd_runtime_suspend()
and pm_genpd_runtime_resume() won't be executed in parallel for
the same device, so the generic PM domains code need not worry
about those cases. Still, it needs to prevent the other possible
race conditions between pm_genpd_runtime_suspend(),
pm_genpd_runtime_resume(), pm_genpd_poweron() and pm_genpd_poweroff()
from happening and it needs to avoid deadlocks at the same time.
To this end, modify the generic PM domains code to relax
synchronization rules so that:
* pm_genpd_poweron() doesn't wait for the PM domain status to
change from GPD_STATE_BUSY. If it finds that the status is
not GPD_STATE_POWER_OFF, it returns without powering the domain on
(it may modify the status depending on the circumstances).
* pm_genpd_poweroff() returns as soon as it finds that the PM
domain's status changed from GPD_STATE_BUSY after it's released
the PM domain's lock.
* pm_genpd_runtime_suspend() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing the domain's
.stop_device() callback and executes pm_genpd_poweroff() only
if pm_genpd_runtime_resume() is not executed in parallel.
* pm_genpd_runtime_resume() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing pm_genpd_poweron()
and sets the domain's status to GPD_STATE_BUSY and increments its
counter of resuming devices (introduced by this change) immediately
after acquiring the lock. The counter of resuming devices is then
decremented after executing __pm_genpd_runtime_resume() for the
device and the domain's status is reset to GPD_STATE_ACTIVE (unless
there are more resuming devices in the domain, in which case the
status remains GPD_STATE_BUSY).
This way, for example, if a device driver's .runtime_resume()
callback executes pm_runtime_resume() for another device in the same
PM domain, pm_genpd_poweron() called by pm_genpd_runtime_resume()
invoked by the runtime PM framework will not block and it will see
that there's nothing to do for it. Next, the PM domain's lock will
be acquired without waiting for its status to change from
GPD_STATE_BUSY and the device driver's .runtime_resume() callback
will be executed. In turn, if pm_runtime_suspend() is executed by
one device driver's .runtime_resume() callback for another device in
the same PM domain, pm_genpd_poweroff() executed by
pm_genpd_runtime_suspend() invoked by the runtime PM framework as a
result will notice that one of the devices in the domain is being
resumed, so it will return immediately.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 16:39:36 -06:00
|
|
|
if (genpd->poweroff_task) {
|
|
|
|
/*
|
|
|
|
* Another instance of pm_genpd_poweroff() is executing
|
|
|
|
* callbacks, so tell it to start over and return.
|
|
|
|
*/
|
|
|
|
genpd->status = GPD_STATE_REPEAT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-07-01 14:12:45 -06:00
|
|
|
if (genpd->gov && genpd->gov->power_down_ok) {
|
|
|
|
if (!genpd->gov->power_down_ok(&genpd->domain))
|
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
|
2011-07-11 16:39:29 -06:00
|
|
|
genpd->status = GPD_STATE_BUSY;
|
PM / Domains: Allow callbacks to execute all runtime PM helpers
A deadlock may occur if one of the PM domains' .start_device() or
.stop_device() callbacks or a device driver's .runtime_suspend() or
.runtime_resume() callback executed by the core generic PM domain
code uses a "wrong" runtime PM helper function. This happens, for
example, if .runtime_resume() from one device's driver calls
pm_runtime_resume() for another device in the same PM domain.
A similar situation may take place if a device's parent is in the
same PM domain, in which case the runtime PM framework may execute
pm_genpd_runtime_resume() automatically for the parent (if it is
suspended at the moment). This, of course, is undesirable, so
the generic PM domains code should be modified to prevent it from
happening.
The runtime PM framework guarantees that pm_genpd_runtime_suspend()
and pm_genpd_runtime_resume() won't be executed in parallel for
the same device, so the generic PM domains code need not worry
about those cases. Still, it needs to prevent the other possible
race conditions between pm_genpd_runtime_suspend(),
pm_genpd_runtime_resume(), pm_genpd_poweron() and pm_genpd_poweroff()
from happening and it needs to avoid deadlocks at the same time.
To this end, modify the generic PM domains code to relax
synchronization rules so that:
* pm_genpd_poweron() doesn't wait for the PM domain status to
change from GPD_STATE_BUSY. If it finds that the status is
not GPD_STATE_POWER_OFF, it returns without powering the domain on
(it may modify the status depending on the circumstances).
* pm_genpd_poweroff() returns as soon as it finds that the PM
domain's status changed from GPD_STATE_BUSY after it's released
the PM domain's lock.
* pm_genpd_runtime_suspend() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing the domain's
.stop_device() callback and executes pm_genpd_poweroff() only
if pm_genpd_runtime_resume() is not executed in parallel.
* pm_genpd_runtime_resume() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing pm_genpd_poweron()
and sets the domain's status to GPD_STATE_BUSY and increments its
counter of resuming devices (introduced by this change) immediately
after acquiring the lock. The counter of resuming devices is then
decremented after executing __pm_genpd_runtime_resume() for the
device and the domain's status is reset to GPD_STATE_ACTIVE (unless
there are more resuming devices in the domain, in which case the
status remains GPD_STATE_BUSY).
This way, for example, if a device driver's .runtime_resume()
callback executes pm_runtime_resume() for another device in the same
PM domain, pm_genpd_poweron() called by pm_genpd_runtime_resume()
invoked by the runtime PM framework will not block and it will see
that there's nothing to do for it. Next, the PM domain's lock will
be acquired without waiting for its status to change from
GPD_STATE_BUSY and the device driver's .runtime_resume() callback
will be executed. In turn, if pm_runtime_suspend() is executed by
one device driver's .runtime_resume() callback for another device in
the same PM domain, pm_genpd_poweroff() executed by
pm_genpd_runtime_suspend() invoked by the runtime PM framework as a
result will notice that one of the devices in the domain is being
resumed, so it will return immediately.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 16:39:36 -06:00
|
|
|
genpd->poweroff_task = current;
|
2011-07-11 16:39:29 -06:00
|
|
|
|
2011-07-01 14:12:45 -06:00
|
|
|
list_for_each_entry_reverse(dle, &genpd->dev_list, node) {
|
2011-08-08 15:43:14 -06:00
|
|
|
ret = atomic_read(&genpd->sd_count) == 0 ?
|
|
|
|
__pm_genpd_save_device(dle, genpd) : -EBUSY;
|
2011-08-08 15:43:29 -06:00
|
|
|
|
|
|
|
if (genpd_abort_poweroff(genpd))
|
|
|
|
goto out;
|
|
|
|
|
2011-07-11 16:39:48 -06:00
|
|
|
if (ret) {
|
|
|
|
genpd_set_active(genpd);
|
|
|
|
goto out;
|
|
|
|
}
|
2011-07-01 14:12:45 -06:00
|
|
|
|
PM / Domains: Allow callbacks to execute all runtime PM helpers
A deadlock may occur if one of the PM domains' .start_device() or
.stop_device() callbacks or a device driver's .runtime_suspend() or
.runtime_resume() callback executed by the core generic PM domain
code uses a "wrong" runtime PM helper function. This happens, for
example, if .runtime_resume() from one device's driver calls
pm_runtime_resume() for another device in the same PM domain.
A similar situation may take place if a device's parent is in the
same PM domain, in which case the runtime PM framework may execute
pm_genpd_runtime_resume() automatically for the parent (if it is
suspended at the moment). This, of course, is undesirable, so
the generic PM domains code should be modified to prevent it from
happening.
The runtime PM framework guarantees that pm_genpd_runtime_suspend()
and pm_genpd_runtime_resume() won't be executed in parallel for
the same device, so the generic PM domains code need not worry
about those cases. Still, it needs to prevent the other possible
race conditions between pm_genpd_runtime_suspend(),
pm_genpd_runtime_resume(), pm_genpd_poweron() and pm_genpd_poweroff()
from happening and it needs to avoid deadlocks at the same time.
To this end, modify the generic PM domains code to relax
synchronization rules so that:
* pm_genpd_poweron() doesn't wait for the PM domain status to
change from GPD_STATE_BUSY. If it finds that the status is
not GPD_STATE_POWER_OFF, it returns without powering the domain on
(it may modify the status depending on the circumstances).
* pm_genpd_poweroff() returns as soon as it finds that the PM
domain's status changed from GPD_STATE_BUSY after it's released
the PM domain's lock.
* pm_genpd_runtime_suspend() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing the domain's
.stop_device() callback and executes pm_genpd_poweroff() only
if pm_genpd_runtime_resume() is not executed in parallel.
* pm_genpd_runtime_resume() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing pm_genpd_poweron()
and sets the domain's status to GPD_STATE_BUSY and increments its
counter of resuming devices (introduced by this change) immediately
after acquiring the lock. The counter of resuming devices is then
decremented after executing __pm_genpd_runtime_resume() for the
device and the domain's status is reset to GPD_STATE_ACTIVE (unless
there are more resuming devices in the domain, in which case the
status remains GPD_STATE_BUSY).
This way, for example, if a device driver's .runtime_resume()
callback executes pm_runtime_resume() for another device in the same
PM domain, pm_genpd_poweron() called by pm_genpd_runtime_resume()
invoked by the runtime PM framework will not block and it will see
that there's nothing to do for it. Next, the PM domain's lock will
be acquired without waiting for its status to change from
GPD_STATE_BUSY and the device driver's .runtime_resume() callback
will be executed. In turn, if pm_runtime_suspend() is executed by
one device driver's .runtime_resume() callback for another device in
the same PM domain, pm_genpd_poweroff() executed by
pm_genpd_runtime_suspend() invoked by the runtime PM framework as a
result will notice that one of the devices in the domain is being
resumed, so it will return immediately.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 16:39:36 -06:00
|
|
|
if (genpd->status == GPD_STATE_REPEAT) {
|
|
|
|
genpd->poweroff_task = NULL;
|
|
|
|
goto start;
|
|
|
|
}
|
|
|
|
}
|
2011-07-11 16:39:29 -06:00
|
|
|
|
2011-08-08 15:43:14 -06:00
|
|
|
if (genpd->power_off) {
|
|
|
|
if (atomic_read(&genpd->sd_count) > 0) {
|
|
|
|
ret = -EBUSY;
|
PM / Domains: Allow callbacks to execute all runtime PM helpers
A deadlock may occur if one of the PM domains' .start_device() or
.stop_device() callbacks or a device driver's .runtime_suspend() or
.runtime_resume() callback executed by the core generic PM domain
code uses a "wrong" runtime PM helper function. This happens, for
example, if .runtime_resume() from one device's driver calls
pm_runtime_resume() for another device in the same PM domain.
A similar situation may take place if a device's parent is in the
same PM domain, in which case the runtime PM framework may execute
pm_genpd_runtime_resume() automatically for the parent (if it is
suspended at the moment). This, of course, is undesirable, so
the generic PM domains code should be modified to prevent it from
happening.
The runtime PM framework guarantees that pm_genpd_runtime_suspend()
and pm_genpd_runtime_resume() won't be executed in parallel for
the same device, so the generic PM domains code need not worry
about those cases. Still, it needs to prevent the other possible
race conditions between pm_genpd_runtime_suspend(),
pm_genpd_runtime_resume(), pm_genpd_poweron() and pm_genpd_poweroff()
from happening and it needs to avoid deadlocks at the same time.
To this end, modify the generic PM domains code to relax
synchronization rules so that:
* pm_genpd_poweron() doesn't wait for the PM domain status to
change from GPD_STATE_BUSY. If it finds that the status is
not GPD_STATE_POWER_OFF, it returns without powering the domain on
(it may modify the status depending on the circumstances).
* pm_genpd_poweroff() returns as soon as it finds that the PM
domain's status changed from GPD_STATE_BUSY after it's released
the PM domain's lock.
* pm_genpd_runtime_suspend() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing the domain's
.stop_device() callback and executes pm_genpd_poweroff() only
if pm_genpd_runtime_resume() is not executed in parallel.
* pm_genpd_runtime_resume() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing pm_genpd_poweron()
and sets the domain's status to GPD_STATE_BUSY and increments its
counter of resuming devices (introduced by this change) immediately
after acquiring the lock. The counter of resuming devices is then
decremented after executing __pm_genpd_runtime_resume() for the
device and the domain's status is reset to GPD_STATE_ACTIVE (unless
there are more resuming devices in the domain, in which case the
status remains GPD_STATE_BUSY).
This way, for example, if a device driver's .runtime_resume()
callback executes pm_runtime_resume() for another device in the same
PM domain, pm_genpd_poweron() called by pm_genpd_runtime_resume()
invoked by the runtime PM framework will not block and it will see
that there's nothing to do for it. Next, the PM domain's lock will
be acquired without waiting for its status to change from
GPD_STATE_BUSY and the device driver's .runtime_resume() callback
will be executed. In turn, if pm_runtime_suspend() is executed by
one device driver's .runtime_resume() callback for another device in
the same PM domain, pm_genpd_poweroff() executed by
pm_genpd_runtime_suspend() invoked by the runtime PM framework as a
result will notice that one of the devices in the domain is being
resumed, so it will return immediately.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 16:39:36 -06:00
|
|
|
goto out;
|
|
|
|
}
|
2011-07-11 16:39:29 -06:00
|
|
|
|
2011-08-08 15:43:14 -06:00
|
|
|
/*
|
2011-08-08 15:43:40 -06:00
|
|
|
* If sd_count > 0 at this point, one of the subdomains hasn't
|
|
|
|
* managed to call pm_genpd_poweron() for the master yet after
|
2011-08-08 15:43:14 -06:00
|
|
|
* incrementing it. In that case pm_genpd_poweron() will wait
|
|
|
|
* for us to drop the lock, so we can call .power_off() and let
|
|
|
|
* the pm_genpd_poweron() restore power for us (this shouldn't
|
|
|
|
* happen very often).
|
|
|
|
*/
|
2011-07-14 12:59:20 -06:00
|
|
|
ret = genpd->power_off(genpd);
|
|
|
|
if (ret == -EBUSY) {
|
|
|
|
genpd_set_active(genpd);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
2011-07-01 14:12:45 -06:00
|
|
|
|
2011-07-11 16:39:29 -06:00
|
|
|
genpd->status = GPD_STATE_POWER_OFF;
|
2011-07-01 14:12:45 -06:00
|
|
|
|
2011-08-08 15:43:40 -06:00
|
|
|
list_for_each_entry(link, &genpd->slave_links, slave_node) {
|
|
|
|
genpd_sd_counter_dec(link->master);
|
|
|
|
genpd_queue_power_off_work(link->master);
|
|
|
|
}
|
2011-07-01 14:12:45 -06:00
|
|
|
|
PM / Domains: Allow callbacks to execute all runtime PM helpers
A deadlock may occur if one of the PM domains' .start_device() or
.stop_device() callbacks or a device driver's .runtime_suspend() or
.runtime_resume() callback executed by the core generic PM domain
code uses a "wrong" runtime PM helper function. This happens, for
example, if .runtime_resume() from one device's driver calls
pm_runtime_resume() for another device in the same PM domain.
A similar situation may take place if a device's parent is in the
same PM domain, in which case the runtime PM framework may execute
pm_genpd_runtime_resume() automatically for the parent (if it is
suspended at the moment). This, of course, is undesirable, so
the generic PM domains code should be modified to prevent it from
happening.
The runtime PM framework guarantees that pm_genpd_runtime_suspend()
and pm_genpd_runtime_resume() won't be executed in parallel for
the same device, so the generic PM domains code need not worry
about those cases. Still, it needs to prevent the other possible
race conditions between pm_genpd_runtime_suspend(),
pm_genpd_runtime_resume(), pm_genpd_poweron() and pm_genpd_poweroff()
from happening and it needs to avoid deadlocks at the same time.
To this end, modify the generic PM domains code to relax
synchronization rules so that:
* pm_genpd_poweron() doesn't wait for the PM domain status to
change from GPD_STATE_BUSY. If it finds that the status is
not GPD_STATE_POWER_OFF, it returns without powering the domain on
(it may modify the status depending on the circumstances).
* pm_genpd_poweroff() returns as soon as it finds that the PM
domain's status changed from GPD_STATE_BUSY after it's released
the PM domain's lock.
* pm_genpd_runtime_suspend() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing the domain's
.stop_device() callback and executes pm_genpd_poweroff() only
if pm_genpd_runtime_resume() is not executed in parallel.
* pm_genpd_runtime_resume() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing pm_genpd_poweron()
and sets the domain's status to GPD_STATE_BUSY and increments its
counter of resuming devices (introduced by this change) immediately
after acquiring the lock. The counter of resuming devices is then
decremented after executing __pm_genpd_runtime_resume() for the
device and the domain's status is reset to GPD_STATE_ACTIVE (unless
there are more resuming devices in the domain, in which case the
status remains GPD_STATE_BUSY).
This way, for example, if a device driver's .runtime_resume()
callback executes pm_runtime_resume() for another device in the same
PM domain, pm_genpd_poweron() called by pm_genpd_runtime_resume()
invoked by the runtime PM framework will not block and it will see
that there's nothing to do for it. Next, the PM domain's lock will
be acquired without waiting for its status to change from
GPD_STATE_BUSY and the device driver's .runtime_resume() callback
will be executed. In turn, if pm_runtime_suspend() is executed by
one device driver's .runtime_resume() callback for another device in
the same PM domain, pm_genpd_poweroff() executed by
pm_genpd_runtime_suspend() invoked by the runtime PM framework as a
result will notice that one of the devices in the domain is being
resumed, so it will return immediately.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 16:39:36 -06:00
|
|
|
out:
|
|
|
|
genpd->poweroff_task = NULL;
|
|
|
|
wake_up_all(&genpd->status_wait_queue);
|
|
|
|
return ret;
|
2011-07-01 14:12:45 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* genpd_power_off_work_fn - Power off PM domain whose subdomain count is 0.
|
|
|
|
* @work: Work structure used for scheduling the execution of this function.
|
|
|
|
*/
|
|
|
|
static void genpd_power_off_work_fn(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain *genpd;
|
|
|
|
|
|
|
|
genpd = container_of(work, struct generic_pm_domain, power_off_work);
|
|
|
|
|
2011-07-11 16:39:29 -06:00
|
|
|
genpd_acquire_lock(genpd);
|
2011-07-01 14:12:45 -06:00
|
|
|
pm_genpd_poweroff(genpd);
|
2011-07-11 16:39:29 -06:00
|
|
|
genpd_release_lock(genpd);
|
2011-07-01 14:12:45 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_runtime_suspend - Suspend a device belonging to I/O PM domain.
|
|
|
|
* @dev: Device to suspend.
|
|
|
|
*
|
|
|
|
* Carry out a runtime suspend of a device under the assumption that its
|
|
|
|
* pm_domain field points to the domain member of an object of type
|
|
|
|
* struct generic_pm_domain representing a PM domain consisting of I/O devices.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_runtime_suspend(struct device *dev)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain *genpd;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
2011-07-01 14:13:10 -06:00
|
|
|
genpd = dev_to_genpd(dev);
|
|
|
|
if (IS_ERR(genpd))
|
2011-07-01 14:12:45 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (genpd->stop_device) {
|
|
|
|
int ret = genpd->stop_device(dev);
|
|
|
|
if (ret)
|
2011-07-11 16:39:29 -06:00
|
|
|
return ret;
|
2011-07-01 14:12:45 -06:00
|
|
|
}
|
2011-07-11 16:39:29 -06:00
|
|
|
|
PM / Domains: Allow callbacks to execute all runtime PM helpers
A deadlock may occur if one of the PM domains' .start_device() or
.stop_device() callbacks or a device driver's .runtime_suspend() or
.runtime_resume() callback executed by the core generic PM domain
code uses a "wrong" runtime PM helper function. This happens, for
example, if .runtime_resume() from one device's driver calls
pm_runtime_resume() for another device in the same PM domain.
A similar situation may take place if a device's parent is in the
same PM domain, in which case the runtime PM framework may execute
pm_genpd_runtime_resume() automatically for the parent (if it is
suspended at the moment). This, of course, is undesirable, so
the generic PM domains code should be modified to prevent it from
happening.
The runtime PM framework guarantees that pm_genpd_runtime_suspend()
and pm_genpd_runtime_resume() won't be executed in parallel for
the same device, so the generic PM domains code need not worry
about those cases. Still, it needs to prevent the other possible
race conditions between pm_genpd_runtime_suspend(),
pm_genpd_runtime_resume(), pm_genpd_poweron() and pm_genpd_poweroff()
from happening and it needs to avoid deadlocks at the same time.
To this end, modify the generic PM domains code to relax
synchronization rules so that:
* pm_genpd_poweron() doesn't wait for the PM domain status to
change from GPD_STATE_BUSY. If it finds that the status is
not GPD_STATE_POWER_OFF, it returns without powering the domain on
(it may modify the status depending on the circumstances).
* pm_genpd_poweroff() returns as soon as it finds that the PM
domain's status changed from GPD_STATE_BUSY after it's released
the PM domain's lock.
* pm_genpd_runtime_suspend() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing the domain's
.stop_device() callback and executes pm_genpd_poweroff() only
if pm_genpd_runtime_resume() is not executed in parallel.
* pm_genpd_runtime_resume() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing pm_genpd_poweron()
and sets the domain's status to GPD_STATE_BUSY and increments its
counter of resuming devices (introduced by this change) immediately
after acquiring the lock. The counter of resuming devices is then
decremented after executing __pm_genpd_runtime_resume() for the
device and the domain's status is reset to GPD_STATE_ACTIVE (unless
there are more resuming devices in the domain, in which case the
status remains GPD_STATE_BUSY).
This way, for example, if a device driver's .runtime_resume()
callback executes pm_runtime_resume() for another device in the same
PM domain, pm_genpd_poweron() called by pm_genpd_runtime_resume()
invoked by the runtime PM framework will not block and it will see
that there's nothing to do for it. Next, the PM domain's lock will
be acquired without waiting for its status to change from
GPD_STATE_BUSY and the device driver's .runtime_resume() callback
will be executed. In turn, if pm_runtime_suspend() is executed by
one device driver's .runtime_resume() callback for another device in
the same PM domain, pm_genpd_poweroff() executed by
pm_genpd_runtime_suspend() invoked by the runtime PM framework as a
result will notice that one of the devices in the domain is being
resumed, so it will return immediately.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 16:39:36 -06:00
|
|
|
mutex_lock(&genpd->lock);
|
2011-07-01 14:12:45 -06:00
|
|
|
genpd->in_progress++;
|
|
|
|
pm_genpd_poweroff(genpd);
|
|
|
|
genpd->in_progress--;
|
PM / Domains: Allow callbacks to execute all runtime PM helpers
A deadlock may occur if one of the PM domains' .start_device() or
.stop_device() callbacks or a device driver's .runtime_suspend() or
.runtime_resume() callback executed by the core generic PM domain
code uses a "wrong" runtime PM helper function. This happens, for
example, if .runtime_resume() from one device's driver calls
pm_runtime_resume() for another device in the same PM domain.
A similar situation may take place if a device's parent is in the
same PM domain, in which case the runtime PM framework may execute
pm_genpd_runtime_resume() automatically for the parent (if it is
suspended at the moment). This, of course, is undesirable, so
the generic PM domains code should be modified to prevent it from
happening.
The runtime PM framework guarantees that pm_genpd_runtime_suspend()
and pm_genpd_runtime_resume() won't be executed in parallel for
the same device, so the generic PM domains code need not worry
about those cases. Still, it needs to prevent the other possible
race conditions between pm_genpd_runtime_suspend(),
pm_genpd_runtime_resume(), pm_genpd_poweron() and pm_genpd_poweroff()
from happening and it needs to avoid deadlocks at the same time.
To this end, modify the generic PM domains code to relax
synchronization rules so that:
* pm_genpd_poweron() doesn't wait for the PM domain status to
change from GPD_STATE_BUSY. If it finds that the status is
not GPD_STATE_POWER_OFF, it returns without powering the domain on
(it may modify the status depending on the circumstances).
* pm_genpd_poweroff() returns as soon as it finds that the PM
domain's status changed from GPD_STATE_BUSY after it's released
the PM domain's lock.
* pm_genpd_runtime_suspend() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing the domain's
.stop_device() callback and executes pm_genpd_poweroff() only
if pm_genpd_runtime_resume() is not executed in parallel.
* pm_genpd_runtime_resume() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing pm_genpd_poweron()
and sets the domain's status to GPD_STATE_BUSY and increments its
counter of resuming devices (introduced by this change) immediately
after acquiring the lock. The counter of resuming devices is then
decremented after executing __pm_genpd_runtime_resume() for the
device and the domain's status is reset to GPD_STATE_ACTIVE (unless
there are more resuming devices in the domain, in which case the
status remains GPD_STATE_BUSY).
This way, for example, if a device driver's .runtime_resume()
callback executes pm_runtime_resume() for another device in the same
PM domain, pm_genpd_poweron() called by pm_genpd_runtime_resume()
invoked by the runtime PM framework will not block and it will see
that there's nothing to do for it. Next, the PM domain's lock will
be acquired without waiting for its status to change from
GPD_STATE_BUSY and the device driver's .runtime_resume() callback
will be executed. In turn, if pm_runtime_suspend() is executed by
one device driver's .runtime_resume() callback for another device in
the same PM domain, pm_genpd_poweroff() executed by
pm_genpd_runtime_suspend() invoked by the runtime PM framework as a
result will notice that one of the devices in the domain is being
resumed, so it will return immediately.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 16:39:36 -06:00
|
|
|
mutex_unlock(&genpd->lock);
|
2011-07-01 14:12:45 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-07-01 14:13:19 -06:00
|
|
|
/**
|
|
|
|
* __pm_genpd_runtime_resume - Resume a device belonging to I/O PM domain.
|
|
|
|
* @dev: Device to resume.
|
|
|
|
* @genpd: PM domain the device belongs to.
|
|
|
|
*/
|
|
|
|
static void __pm_genpd_runtime_resume(struct device *dev,
|
|
|
|
struct generic_pm_domain *genpd)
|
|
|
|
{
|
|
|
|
struct dev_list_entry *dle;
|
|
|
|
|
|
|
|
list_for_each_entry(dle, &genpd->dev_list, node) {
|
|
|
|
if (dle->dev == dev) {
|
|
|
|
__pm_genpd_restore_device(dle, genpd);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-01 14:12:45 -06:00
|
|
|
/**
|
|
|
|
* pm_genpd_runtime_resume - Resume a device belonging to I/O PM domain.
|
|
|
|
* @dev: Device to resume.
|
|
|
|
*
|
|
|
|
* Carry out a runtime resume of a device under the assumption that its
|
|
|
|
* pm_domain field points to the domain member of an object of type
|
|
|
|
* struct generic_pm_domain representing a PM domain consisting of I/O devices.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_runtime_resume(struct device *dev)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain *genpd;
|
PM / Domains: Allow callbacks to execute all runtime PM helpers
A deadlock may occur if one of the PM domains' .start_device() or
.stop_device() callbacks or a device driver's .runtime_suspend() or
.runtime_resume() callback executed by the core generic PM domain
code uses a "wrong" runtime PM helper function. This happens, for
example, if .runtime_resume() from one device's driver calls
pm_runtime_resume() for another device in the same PM domain.
A similar situation may take place if a device's parent is in the
same PM domain, in which case the runtime PM framework may execute
pm_genpd_runtime_resume() automatically for the parent (if it is
suspended at the moment). This, of course, is undesirable, so
the generic PM domains code should be modified to prevent it from
happening.
The runtime PM framework guarantees that pm_genpd_runtime_suspend()
and pm_genpd_runtime_resume() won't be executed in parallel for
the same device, so the generic PM domains code need not worry
about those cases. Still, it needs to prevent the other possible
race conditions between pm_genpd_runtime_suspend(),
pm_genpd_runtime_resume(), pm_genpd_poweron() and pm_genpd_poweroff()
from happening and it needs to avoid deadlocks at the same time.
To this end, modify the generic PM domains code to relax
synchronization rules so that:
* pm_genpd_poweron() doesn't wait for the PM domain status to
change from GPD_STATE_BUSY. If it finds that the status is
not GPD_STATE_POWER_OFF, it returns without powering the domain on
(it may modify the status depending on the circumstances).
* pm_genpd_poweroff() returns as soon as it finds that the PM
domain's status changed from GPD_STATE_BUSY after it's released
the PM domain's lock.
* pm_genpd_runtime_suspend() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing the domain's
.stop_device() callback and executes pm_genpd_poweroff() only
if pm_genpd_runtime_resume() is not executed in parallel.
* pm_genpd_runtime_resume() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing pm_genpd_poweron()
and sets the domain's status to GPD_STATE_BUSY and increments its
counter of resuming devices (introduced by this change) immediately
after acquiring the lock. The counter of resuming devices is then
decremented after executing __pm_genpd_runtime_resume() for the
device and the domain's status is reset to GPD_STATE_ACTIVE (unless
there are more resuming devices in the domain, in which case the
status remains GPD_STATE_BUSY).
This way, for example, if a device driver's .runtime_resume()
callback executes pm_runtime_resume() for another device in the same
PM domain, pm_genpd_poweron() called by pm_genpd_runtime_resume()
invoked by the runtime PM framework will not block and it will see
that there's nothing to do for it. Next, the PM domain's lock will
be acquired without waiting for its status to change from
GPD_STATE_BUSY and the device driver's .runtime_resume() callback
will be executed. In turn, if pm_runtime_suspend() is executed by
one device driver's .runtime_resume() callback for another device in
the same PM domain, pm_genpd_poweroff() executed by
pm_genpd_runtime_suspend() invoked by the runtime PM framework as a
result will notice that one of the devices in the domain is being
resumed, so it will return immediately.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 16:39:36 -06:00
|
|
|
DEFINE_WAIT(wait);
|
2011-07-01 14:12:45 -06:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
2011-07-01 14:13:10 -06:00
|
|
|
genpd = dev_to_genpd(dev);
|
|
|
|
if (IS_ERR(genpd))
|
2011-07-01 14:12:45 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
PM / Domains: Allow callbacks to execute all runtime PM helpers
A deadlock may occur if one of the PM domains' .start_device() or
.stop_device() callbacks or a device driver's .runtime_suspend() or
.runtime_resume() callback executed by the core generic PM domain
code uses a "wrong" runtime PM helper function. This happens, for
example, if .runtime_resume() from one device's driver calls
pm_runtime_resume() for another device in the same PM domain.
A similar situation may take place if a device's parent is in the
same PM domain, in which case the runtime PM framework may execute
pm_genpd_runtime_resume() automatically for the parent (if it is
suspended at the moment). This, of course, is undesirable, so
the generic PM domains code should be modified to prevent it from
happening.
The runtime PM framework guarantees that pm_genpd_runtime_suspend()
and pm_genpd_runtime_resume() won't be executed in parallel for
the same device, so the generic PM domains code need not worry
about those cases. Still, it needs to prevent the other possible
race conditions between pm_genpd_runtime_suspend(),
pm_genpd_runtime_resume(), pm_genpd_poweron() and pm_genpd_poweroff()
from happening and it needs to avoid deadlocks at the same time.
To this end, modify the generic PM domains code to relax
synchronization rules so that:
* pm_genpd_poweron() doesn't wait for the PM domain status to
change from GPD_STATE_BUSY. If it finds that the status is
not GPD_STATE_POWER_OFF, it returns without powering the domain on
(it may modify the status depending on the circumstances).
* pm_genpd_poweroff() returns as soon as it finds that the PM
domain's status changed from GPD_STATE_BUSY after it's released
the PM domain's lock.
* pm_genpd_runtime_suspend() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing the domain's
.stop_device() callback and executes pm_genpd_poweroff() only
if pm_genpd_runtime_resume() is not executed in parallel.
* pm_genpd_runtime_resume() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing pm_genpd_poweron()
and sets the domain's status to GPD_STATE_BUSY and increments its
counter of resuming devices (introduced by this change) immediately
after acquiring the lock. The counter of resuming devices is then
decremented after executing __pm_genpd_runtime_resume() for the
device and the domain's status is reset to GPD_STATE_ACTIVE (unless
there are more resuming devices in the domain, in which case the
status remains GPD_STATE_BUSY).
This way, for example, if a device driver's .runtime_resume()
callback executes pm_runtime_resume() for another device in the same
PM domain, pm_genpd_poweron() called by pm_genpd_runtime_resume()
invoked by the runtime PM framework will not block and it will see
that there's nothing to do for it. Next, the PM domain's lock will
be acquired without waiting for its status to change from
GPD_STATE_BUSY and the device driver's .runtime_resume() callback
will be executed. In turn, if pm_runtime_suspend() is executed by
one device driver's .runtime_resume() callback for another device in
the same PM domain, pm_genpd_poweroff() executed by
pm_genpd_runtime_suspend() invoked by the runtime PM framework as a
result will notice that one of the devices in the domain is being
resumed, so it will return immediately.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 16:39:36 -06:00
|
|
|
mutex_lock(&genpd->lock);
|
2011-08-08 15:43:29 -06:00
|
|
|
ret = __pm_genpd_poweron(genpd);
|
|
|
|
if (ret) {
|
|
|
|
mutex_unlock(&genpd->lock);
|
|
|
|
return ret;
|
|
|
|
}
|
2011-07-11 16:39:29 -06:00
|
|
|
genpd->status = GPD_STATE_BUSY;
|
PM / Domains: Allow callbacks to execute all runtime PM helpers
A deadlock may occur if one of the PM domains' .start_device() or
.stop_device() callbacks or a device driver's .runtime_suspend() or
.runtime_resume() callback executed by the core generic PM domain
code uses a "wrong" runtime PM helper function. This happens, for
example, if .runtime_resume() from one device's driver calls
pm_runtime_resume() for another device in the same PM domain.
A similar situation may take place if a device's parent is in the
same PM domain, in which case the runtime PM framework may execute
pm_genpd_runtime_resume() automatically for the parent (if it is
suspended at the moment). This, of course, is undesirable, so
the generic PM domains code should be modified to prevent it from
happening.
The runtime PM framework guarantees that pm_genpd_runtime_suspend()
and pm_genpd_runtime_resume() won't be executed in parallel for
the same device, so the generic PM domains code need not worry
about those cases. Still, it needs to prevent the other possible
race conditions between pm_genpd_runtime_suspend(),
pm_genpd_runtime_resume(), pm_genpd_poweron() and pm_genpd_poweroff()
from happening and it needs to avoid deadlocks at the same time.
To this end, modify the generic PM domains code to relax
synchronization rules so that:
* pm_genpd_poweron() doesn't wait for the PM domain status to
change from GPD_STATE_BUSY. If it finds that the status is
not GPD_STATE_POWER_OFF, it returns without powering the domain on
(it may modify the status depending on the circumstances).
* pm_genpd_poweroff() returns as soon as it finds that the PM
domain's status changed from GPD_STATE_BUSY after it's released
the PM domain's lock.
* pm_genpd_runtime_suspend() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing the domain's
.stop_device() callback and executes pm_genpd_poweroff() only
if pm_genpd_runtime_resume() is not executed in parallel.
* pm_genpd_runtime_resume() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing pm_genpd_poweron()
and sets the domain's status to GPD_STATE_BUSY and increments its
counter of resuming devices (introduced by this change) immediately
after acquiring the lock. The counter of resuming devices is then
decremented after executing __pm_genpd_runtime_resume() for the
device and the domain's status is reset to GPD_STATE_ACTIVE (unless
there are more resuming devices in the domain, in which case the
status remains GPD_STATE_BUSY).
This way, for example, if a device driver's .runtime_resume()
callback executes pm_runtime_resume() for another device in the same
PM domain, pm_genpd_poweron() called by pm_genpd_runtime_resume()
invoked by the runtime PM framework will not block and it will see
that there's nothing to do for it. Next, the PM domain's lock will
be acquired without waiting for its status to change from
GPD_STATE_BUSY and the device driver's .runtime_resume() callback
will be executed. In turn, if pm_runtime_suspend() is executed by
one device driver's .runtime_resume() callback for another device in
the same PM domain, pm_genpd_poweroff() executed by
pm_genpd_runtime_suspend() invoked by the runtime PM framework as a
result will notice that one of the devices in the domain is being
resumed, so it will return immediately.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 16:39:36 -06:00
|
|
|
genpd->resume_count++;
|
|
|
|
for (;;) {
|
|
|
|
prepare_to_wait(&genpd->status_wait_queue, &wait,
|
|
|
|
TASK_UNINTERRUPTIBLE);
|
|
|
|
/*
|
|
|
|
* If current is the powering off task, we have been called
|
|
|
|
* reentrantly from one of the device callbacks, so we should
|
|
|
|
* not wait.
|
|
|
|
*/
|
|
|
|
if (!genpd->poweroff_task || genpd->poweroff_task == current)
|
|
|
|
break;
|
|
|
|
mutex_unlock(&genpd->lock);
|
|
|
|
|
|
|
|
schedule();
|
|
|
|
|
|
|
|
mutex_lock(&genpd->lock);
|
|
|
|
}
|
|
|
|
finish_wait(&genpd->status_wait_queue, &wait);
|
2011-07-01 14:13:19 -06:00
|
|
|
__pm_genpd_runtime_resume(dev, genpd);
|
PM / Domains: Allow callbacks to execute all runtime PM helpers
A deadlock may occur if one of the PM domains' .start_device() or
.stop_device() callbacks or a device driver's .runtime_suspend() or
.runtime_resume() callback executed by the core generic PM domain
code uses a "wrong" runtime PM helper function. This happens, for
example, if .runtime_resume() from one device's driver calls
pm_runtime_resume() for another device in the same PM domain.
A similar situation may take place if a device's parent is in the
same PM domain, in which case the runtime PM framework may execute
pm_genpd_runtime_resume() automatically for the parent (if it is
suspended at the moment). This, of course, is undesirable, so
the generic PM domains code should be modified to prevent it from
happening.
The runtime PM framework guarantees that pm_genpd_runtime_suspend()
and pm_genpd_runtime_resume() won't be executed in parallel for
the same device, so the generic PM domains code need not worry
about those cases. Still, it needs to prevent the other possible
race conditions between pm_genpd_runtime_suspend(),
pm_genpd_runtime_resume(), pm_genpd_poweron() and pm_genpd_poweroff()
from happening and it needs to avoid deadlocks at the same time.
To this end, modify the generic PM domains code to relax
synchronization rules so that:
* pm_genpd_poweron() doesn't wait for the PM domain status to
change from GPD_STATE_BUSY. If it finds that the status is
not GPD_STATE_POWER_OFF, it returns without powering the domain on
(it may modify the status depending on the circumstances).
* pm_genpd_poweroff() returns as soon as it finds that the PM
domain's status changed from GPD_STATE_BUSY after it's released
the PM domain's lock.
* pm_genpd_runtime_suspend() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing the domain's
.stop_device() callback and executes pm_genpd_poweroff() only
if pm_genpd_runtime_resume() is not executed in parallel.
* pm_genpd_runtime_resume() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing pm_genpd_poweron()
and sets the domain's status to GPD_STATE_BUSY and increments its
counter of resuming devices (introduced by this change) immediately
after acquiring the lock. The counter of resuming devices is then
decremented after executing __pm_genpd_runtime_resume() for the
device and the domain's status is reset to GPD_STATE_ACTIVE (unless
there are more resuming devices in the domain, in which case the
status remains GPD_STATE_BUSY).
This way, for example, if a device driver's .runtime_resume()
callback executes pm_runtime_resume() for another device in the same
PM domain, pm_genpd_poweron() called by pm_genpd_runtime_resume()
invoked by the runtime PM framework will not block and it will see
that there's nothing to do for it. Next, the PM domain's lock will
be acquired without waiting for its status to change from
GPD_STATE_BUSY and the device driver's .runtime_resume() callback
will be executed. In turn, if pm_runtime_suspend() is executed by
one device driver's .runtime_resume() callback for another device in
the same PM domain, pm_genpd_poweroff() executed by
pm_genpd_runtime_suspend() invoked by the runtime PM framework as a
result will notice that one of the devices in the domain is being
resumed, so it will return immediately.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 16:39:36 -06:00
|
|
|
genpd->resume_count--;
|
|
|
|
genpd_set_active(genpd);
|
2011-07-11 16:39:29 -06:00
|
|
|
wake_up_all(&genpd->status_wait_queue);
|
PM / Domains: Allow callbacks to execute all runtime PM helpers
A deadlock may occur if one of the PM domains' .start_device() or
.stop_device() callbacks or a device driver's .runtime_suspend() or
.runtime_resume() callback executed by the core generic PM domain
code uses a "wrong" runtime PM helper function. This happens, for
example, if .runtime_resume() from one device's driver calls
pm_runtime_resume() for another device in the same PM domain.
A similar situation may take place if a device's parent is in the
same PM domain, in which case the runtime PM framework may execute
pm_genpd_runtime_resume() automatically for the parent (if it is
suspended at the moment). This, of course, is undesirable, so
the generic PM domains code should be modified to prevent it from
happening.
The runtime PM framework guarantees that pm_genpd_runtime_suspend()
and pm_genpd_runtime_resume() won't be executed in parallel for
the same device, so the generic PM domains code need not worry
about those cases. Still, it needs to prevent the other possible
race conditions between pm_genpd_runtime_suspend(),
pm_genpd_runtime_resume(), pm_genpd_poweron() and pm_genpd_poweroff()
from happening and it needs to avoid deadlocks at the same time.
To this end, modify the generic PM domains code to relax
synchronization rules so that:
* pm_genpd_poweron() doesn't wait for the PM domain status to
change from GPD_STATE_BUSY. If it finds that the status is
not GPD_STATE_POWER_OFF, it returns without powering the domain on
(it may modify the status depending on the circumstances).
* pm_genpd_poweroff() returns as soon as it finds that the PM
domain's status changed from GPD_STATE_BUSY after it's released
the PM domain's lock.
* pm_genpd_runtime_suspend() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing the domain's
.stop_device() callback and executes pm_genpd_poweroff() only
if pm_genpd_runtime_resume() is not executed in parallel.
* pm_genpd_runtime_resume() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing pm_genpd_poweron()
and sets the domain's status to GPD_STATE_BUSY and increments its
counter of resuming devices (introduced by this change) immediately
after acquiring the lock. The counter of resuming devices is then
decremented after executing __pm_genpd_runtime_resume() for the
device and the domain's status is reset to GPD_STATE_ACTIVE (unless
there are more resuming devices in the domain, in which case the
status remains GPD_STATE_BUSY).
This way, for example, if a device driver's .runtime_resume()
callback executes pm_runtime_resume() for another device in the same
PM domain, pm_genpd_poweron() called by pm_genpd_runtime_resume()
invoked by the runtime PM framework will not block and it will see
that there's nothing to do for it. Next, the PM domain's lock will
be acquired without waiting for its status to change from
GPD_STATE_BUSY and the device driver's .runtime_resume() callback
will be executed. In turn, if pm_runtime_suspend() is executed by
one device driver's .runtime_resume() callback for another device in
the same PM domain, pm_genpd_poweroff() executed by
pm_genpd_runtime_suspend() invoked by the runtime PM framework as a
result will notice that one of the devices in the domain is being
resumed, so it will return immediately.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 16:39:36 -06:00
|
|
|
mutex_unlock(&genpd->lock);
|
2011-07-11 16:39:29 -06:00
|
|
|
|
|
|
|
if (genpd->start_device)
|
|
|
|
genpd->start_device(dev);
|
2011-07-01 14:12:45 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-08-14 05:34:31 -06:00
|
|
|
/**
|
|
|
|
* pm_genpd_poweroff_unused - Power off all PM domains with no devices in use.
|
|
|
|
*/
|
|
|
|
void pm_genpd_poweroff_unused(void)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain *genpd;
|
|
|
|
|
|
|
|
mutex_lock(&gpd_list_lock);
|
|
|
|
|
|
|
|
list_for_each_entry(genpd, &gpd_list, gpd_list_node)
|
|
|
|
genpd_queue_power_off_work(genpd);
|
|
|
|
|
|
|
|
mutex_unlock(&gpd_list_lock);
|
|
|
|
}
|
|
|
|
|
2011-07-01 14:12:45 -06:00
|
|
|
#else
|
|
|
|
|
|
|
|
static inline void genpd_power_off_work_fn(struct work_struct *work) {}
|
2011-07-01 14:13:19 -06:00
|
|
|
static inline void __pm_genpd_runtime_resume(struct device *dev,
|
|
|
|
struct generic_pm_domain *genpd) {}
|
2011-07-01 14:12:45 -06:00
|
|
|
|
|
|
|
#define pm_genpd_runtime_suspend NULL
|
|
|
|
#define pm_genpd_runtime_resume NULL
|
|
|
|
|
|
|
|
#endif /* CONFIG_PM_RUNTIME */
|
|
|
|
|
2011-07-01 14:13:19 -06:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
|
|
|
|
|
|
/**
|
2011-08-08 15:43:40 -06:00
|
|
|
* pm_genpd_sync_poweroff - Synchronously power off a PM domain and its masters.
|
2011-07-01 14:13:19 -06:00
|
|
|
* @genpd: PM domain to power off, if possible.
|
|
|
|
*
|
|
|
|
* Check if the given PM domain can be powered off (during system suspend or
|
2011-08-08 15:43:40 -06:00
|
|
|
* hibernation) and do that if so. Also, in that case propagate to its masters.
|
2011-07-01 14:13:19 -06:00
|
|
|
*
|
|
|
|
* This function is only called in "noirq" stages of system power transitions,
|
|
|
|
* so it need not acquire locks (all of the "noirq" callbacks are executed
|
|
|
|
* sequentially, so it is guaranteed that it will never run twice in parallel).
|
|
|
|
*/
|
|
|
|
static void pm_genpd_sync_poweroff(struct generic_pm_domain *genpd)
|
|
|
|
{
|
2011-08-08 15:43:40 -06:00
|
|
|
struct gpd_link *link;
|
2011-07-01 14:13:19 -06:00
|
|
|
|
2011-07-11 16:39:29 -06:00
|
|
|
if (genpd->status == GPD_STATE_POWER_OFF)
|
2011-07-01 14:13:19 -06:00
|
|
|
return;
|
|
|
|
|
2011-08-08 15:43:04 -06:00
|
|
|
if (genpd->suspended_count != genpd->device_count
|
|
|
|
|| atomic_read(&genpd->sd_count) > 0)
|
2011-07-01 14:13:19 -06:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (genpd->power_off)
|
|
|
|
genpd->power_off(genpd);
|
|
|
|
|
2011-07-11 16:39:29 -06:00
|
|
|
genpd->status = GPD_STATE_POWER_OFF;
|
2011-08-08 15:43:40 -06:00
|
|
|
|
|
|
|
list_for_each_entry(link, &genpd->slave_links, slave_node) {
|
|
|
|
genpd_sd_counter_dec(link->master);
|
|
|
|
pm_genpd_sync_poweroff(link->master);
|
2011-07-01 14:13:19 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
PM / Domains: Improve handling of wakeup devices during system suspend
Kevin points out that if there's a device that can wake up the system
from sleep states, but it doesn't generate wakeup signals by itself
(they are generated on its behalf by other parts of the system) and
it currently is not enabled to wake up the system (that is,
device_may_wakeup() returns "false" for it), we may need to change
its wakeup settings during system suspend (for example, the device
might have been configured to signal remote wakeup from the system's
working state, as needed by runtime PM). Therefore the generic PM
domains code should invoke the system suspend callbacks provided by
the device's driver, which it doesn't do if the PM domain is powered
off during the system suspend's "prepare" stage. This is a valid
point. Moreover, this code also should make sure that system wakeup
devices that are enabled to wake up the system from sleep states and
have to remain active for this purpose are not suspended while the
system is in a sleep state.
To avoid the above issues, make the generic PM domains' .prepare()
routine, pm_genpd_prepare(), force runtime resume of devices whose
system wakeup settings may need to be changed during system suspend
or that should remain active while the system is in a sleep state to
be able to wake it up from that state.
Reported-by: Kevin Hilman <khilman@ti.com>
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 16:39:57 -06:00
|
|
|
/**
|
|
|
|
* resume_needed - Check whether to resume a device before system suspend.
|
|
|
|
* @dev: Device to check.
|
|
|
|
* @genpd: PM domain the device belongs to.
|
|
|
|
*
|
|
|
|
* There are two cases in which a device that can wake up the system from sleep
|
|
|
|
* states should be resumed by pm_genpd_prepare(): (1) if the device is enabled
|
|
|
|
* to wake up the system and it has to remain active for this purpose while the
|
|
|
|
* system is in the sleep state and (2) if the device is not enabled to wake up
|
|
|
|
* the system from sleep states and it generally doesn't generate wakeup signals
|
|
|
|
* by itself (those signals are generated on its behalf by other parts of the
|
|
|
|
* system). In the latter case it may be necessary to reconfigure the device's
|
|
|
|
* wakeup settings during system suspend, because it may have been set up to
|
|
|
|
* signal remote wakeup from the system's working state as needed by runtime PM.
|
|
|
|
* Return 'true' in either of the above cases.
|
|
|
|
*/
|
|
|
|
static bool resume_needed(struct device *dev, struct generic_pm_domain *genpd)
|
|
|
|
{
|
|
|
|
bool active_wakeup;
|
|
|
|
|
|
|
|
if (!device_can_wakeup(dev))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
active_wakeup = genpd->active_wakeup && genpd->active_wakeup(dev);
|
|
|
|
return device_may_wakeup(dev) ? active_wakeup : !active_wakeup;
|
|
|
|
}
|
|
|
|
|
2011-07-01 14:13:19 -06:00
|
|
|
/**
|
|
|
|
* pm_genpd_prepare - Start power transition of a device in a PM domain.
|
|
|
|
* @dev: Device to start the transition of.
|
|
|
|
*
|
|
|
|
* Start a power transition of a device (during a system-wide power transition)
|
|
|
|
* under the assumption that its pm_domain field points to the domain member of
|
|
|
|
* an object of type struct generic_pm_domain representing a PM domain
|
|
|
|
* consisting of I/O devices.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_prepare(struct device *dev)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain *genpd;
|
2011-07-11 16:39:21 -06:00
|
|
|
int ret;
|
2011-07-01 14:13:19 -06:00
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
|
|
|
genpd = dev_to_genpd(dev);
|
|
|
|
if (IS_ERR(genpd))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-07-11 16:39:29 -06:00
|
|
|
/*
|
|
|
|
* If a wakeup request is pending for the device, it should be woken up
|
|
|
|
* at this point and a system wakeup event should be reported if it's
|
|
|
|
* set up to wake up the system from sleep states.
|
|
|
|
*/
|
|
|
|
pm_runtime_get_noresume(dev);
|
|
|
|
if (pm_runtime_barrier(dev) && device_may_wakeup(dev))
|
|
|
|
pm_wakeup_event(dev, 0);
|
|
|
|
|
|
|
|
if (pm_wakeup_pending()) {
|
|
|
|
pm_runtime_put_sync(dev);
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
PM / Domains: Improve handling of wakeup devices during system suspend
Kevin points out that if there's a device that can wake up the system
from sleep states, but it doesn't generate wakeup signals by itself
(they are generated on its behalf by other parts of the system) and
it currently is not enabled to wake up the system (that is,
device_may_wakeup() returns "false" for it), we may need to change
its wakeup settings during system suspend (for example, the device
might have been configured to signal remote wakeup from the system's
working state, as needed by runtime PM). Therefore the generic PM
domains code should invoke the system suspend callbacks provided by
the device's driver, which it doesn't do if the PM domain is powered
off during the system suspend's "prepare" stage. This is a valid
point. Moreover, this code also should make sure that system wakeup
devices that are enabled to wake up the system from sleep states and
have to remain active for this purpose are not suspended while the
system is in a sleep state.
To avoid the above issues, make the generic PM domains' .prepare()
routine, pm_genpd_prepare(), force runtime resume of devices whose
system wakeup settings may need to be changed during system suspend
or that should remain active while the system is in a sleep state to
be able to wake it up from that state.
Reported-by: Kevin Hilman <khilman@ti.com>
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 16:39:57 -06:00
|
|
|
if (resume_needed(dev, genpd))
|
|
|
|
pm_runtime_resume(dev);
|
|
|
|
|
2011-07-11 16:39:29 -06:00
|
|
|
genpd_acquire_lock(genpd);
|
2011-07-01 14:13:19 -06:00
|
|
|
|
|
|
|
if (genpd->prepared_count++ == 0)
|
2011-07-11 16:39:29 -06:00
|
|
|
genpd->suspend_power_off = genpd->status == GPD_STATE_POWER_OFF;
|
|
|
|
|
|
|
|
genpd_release_lock(genpd);
|
2011-07-01 14:13:19 -06:00
|
|
|
|
|
|
|
if (genpd->suspend_power_off) {
|
2011-07-11 16:39:29 -06:00
|
|
|
pm_runtime_put_noidle(dev);
|
2011-07-01 14:13:19 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2011-07-11 16:39:29 -06:00
|
|
|
* The PM domain must be in the GPD_STATE_ACTIVE state at this point,
|
|
|
|
* so pm_genpd_poweron() will return immediately, but if the device
|
|
|
|
* is suspended (e.g. it's been stopped by .stop_device()), we need
|
|
|
|
* to make it operational.
|
2011-07-01 14:13:19 -06:00
|
|
|
*/
|
2011-07-11 16:39:29 -06:00
|
|
|
pm_runtime_resume(dev);
|
2011-07-01 14:13:19 -06:00
|
|
|
__pm_runtime_disable(dev, false);
|
|
|
|
|
2011-07-11 16:39:21 -06:00
|
|
|
ret = pm_generic_prepare(dev);
|
|
|
|
if (ret) {
|
|
|
|
mutex_lock(&genpd->lock);
|
|
|
|
|
|
|
|
if (--genpd->prepared_count == 0)
|
|
|
|
genpd->suspend_power_off = false;
|
|
|
|
|
|
|
|
mutex_unlock(&genpd->lock);
|
2011-07-11 16:39:29 -06:00
|
|
|
pm_runtime_enable(dev);
|
2011-07-11 16:39:21 -06:00
|
|
|
}
|
2011-07-11 16:39:29 -06:00
|
|
|
|
|
|
|
pm_runtime_put_sync(dev);
|
2011-07-11 16:39:21 -06:00
|
|
|
return ret;
|
2011-07-01 14:13:19 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_suspend - Suspend a device belonging to an I/O PM domain.
|
|
|
|
* @dev: Device to suspend.
|
|
|
|
*
|
|
|
|
* Suspend a device under the assumption that its pm_domain field points to the
|
|
|
|
* domain member of an object of type struct generic_pm_domain representing
|
|
|
|
* a PM domain consisting of I/O devices.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_suspend(struct device *dev)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain *genpd;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
|
|
|
genpd = dev_to_genpd(dev);
|
|
|
|
if (IS_ERR(genpd))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return genpd->suspend_power_off ? 0 : pm_generic_suspend(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_suspend_noirq - Late suspend of a device from an I/O PM domain.
|
|
|
|
* @dev: Device to suspend.
|
|
|
|
*
|
|
|
|
* Carry out a late suspend of a device under the assumption that its
|
|
|
|
* pm_domain field points to the domain member of an object of type
|
|
|
|
* struct generic_pm_domain representing a PM domain consisting of I/O devices.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_suspend_noirq(struct device *dev)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain *genpd;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
|
|
|
genpd = dev_to_genpd(dev);
|
|
|
|
if (IS_ERR(genpd))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (genpd->suspend_power_off)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ret = pm_generic_suspend_noirq(dev);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
PM / Domains: Wakeup devices support for system sleep transitions
There is the problem how to handle devices set up to wake up the
system from sleep states during system-wide power transitions.
In some cases, those devices can be turned off entirely, because the
wakeup signals will be generated on their behalf anyway. In some
other cases, they will generate wakeup signals if their clocks are
stopped, but only if power is not removed from them. Finally, in
some cases, they can only generate wakeup signals if power is not
removed from them and their clocks are enabled.
To allow platform-specific code to decide whether or not to put
wakeup devices (and their PM domains) into low-power state during
system-wide transitions, such as system suspend, introduce a new
generic PM domain callback, .active_wakeup(), that will be used
during the "noirq" phase of system suspend and hibernation (after
image creation) to decide what to do with wakeup devices.
Specifically, if this callback is present and returns "true", the
generic PM domain code will not execute .stop_device() for the
given wakeup device and its PM domain won't be powered off.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Acked-by: Kevin Hilman <khilman@ti.com>
2011-07-01 14:13:29 -06:00
|
|
|
if (device_may_wakeup(dev)
|
|
|
|
&& genpd->active_wakeup && genpd->active_wakeup(dev))
|
|
|
|
return 0;
|
|
|
|
|
2011-07-01 14:13:19 -06:00
|
|
|
if (genpd->stop_device)
|
|
|
|
genpd->stop_device(dev);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Since all of the "noirq" callbacks are executed sequentially, it is
|
|
|
|
* guaranteed that this function will never run twice in parallel for
|
|
|
|
* the same PM domain, so it is not necessary to use locking here.
|
|
|
|
*/
|
|
|
|
genpd->suspended_count++;
|
|
|
|
pm_genpd_sync_poweroff(genpd);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_resume_noirq - Early resume of a device from an I/O power domain.
|
|
|
|
* @dev: Device to resume.
|
|
|
|
*
|
|
|
|
* Carry out an early resume of a device under the assumption that its
|
|
|
|
* pm_domain field points to the domain member of an object of type
|
|
|
|
* struct generic_pm_domain representing a power domain consisting of I/O
|
|
|
|
* devices.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_resume_noirq(struct device *dev)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain *genpd;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
|
|
|
genpd = dev_to_genpd(dev);
|
|
|
|
if (IS_ERR(genpd))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (genpd->suspend_power_off)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Since all of the "noirq" callbacks are executed sequentially, it is
|
|
|
|
* guaranteed that this function will never run twice in parallel for
|
|
|
|
* the same PM domain, so it is not necessary to use locking here.
|
|
|
|
*/
|
|
|
|
pm_genpd_poweron(genpd);
|
|
|
|
genpd->suspended_count--;
|
|
|
|
if (genpd->start_device)
|
|
|
|
genpd->start_device(dev);
|
|
|
|
|
|
|
|
return pm_generic_resume_noirq(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_resume - Resume a device belonging to an I/O power domain.
|
|
|
|
* @dev: Device to resume.
|
|
|
|
*
|
|
|
|
* Resume a device under the assumption that its pm_domain field points to the
|
|
|
|
* domain member of an object of type struct generic_pm_domain representing
|
|
|
|
* a power domain consisting of I/O devices.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_resume(struct device *dev)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain *genpd;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
|
|
|
genpd = dev_to_genpd(dev);
|
|
|
|
if (IS_ERR(genpd))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return genpd->suspend_power_off ? 0 : pm_generic_resume(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_freeze - Freeze a device belonging to an I/O power domain.
|
|
|
|
* @dev: Device to freeze.
|
|
|
|
*
|
|
|
|
* Freeze a device under the assumption that its pm_domain field points to the
|
|
|
|
* domain member of an object of type struct generic_pm_domain representing
|
|
|
|
* a power domain consisting of I/O devices.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_freeze(struct device *dev)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain *genpd;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
|
|
|
genpd = dev_to_genpd(dev);
|
|
|
|
if (IS_ERR(genpd))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return genpd->suspend_power_off ? 0 : pm_generic_freeze(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_freeze_noirq - Late freeze of a device from an I/O power domain.
|
|
|
|
* @dev: Device to freeze.
|
|
|
|
*
|
|
|
|
* Carry out a late freeze of a device under the assumption that its
|
|
|
|
* pm_domain field points to the domain member of an object of type
|
|
|
|
* struct generic_pm_domain representing a power domain consisting of I/O
|
|
|
|
* devices.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_freeze_noirq(struct device *dev)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain *genpd;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
|
|
|
genpd = dev_to_genpd(dev);
|
|
|
|
if (IS_ERR(genpd))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (genpd->suspend_power_off)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ret = pm_generic_freeze_noirq(dev);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (genpd->stop_device)
|
|
|
|
genpd->stop_device(dev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_thaw_noirq - Early thaw of a device from an I/O power domain.
|
|
|
|
* @dev: Device to thaw.
|
|
|
|
*
|
|
|
|
* Carry out an early thaw of a device under the assumption that its
|
|
|
|
* pm_domain field points to the domain member of an object of type
|
|
|
|
* struct generic_pm_domain representing a power domain consisting of I/O
|
|
|
|
* devices.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_thaw_noirq(struct device *dev)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain *genpd;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
|
|
|
genpd = dev_to_genpd(dev);
|
|
|
|
if (IS_ERR(genpd))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (genpd->suspend_power_off)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (genpd->start_device)
|
|
|
|
genpd->start_device(dev);
|
|
|
|
|
|
|
|
return pm_generic_thaw_noirq(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_thaw - Thaw a device belonging to an I/O power domain.
|
|
|
|
* @dev: Device to thaw.
|
|
|
|
*
|
|
|
|
* Thaw a device under the assumption that its pm_domain field points to the
|
|
|
|
* domain member of an object of type struct generic_pm_domain representing
|
|
|
|
* a power domain consisting of I/O devices.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_thaw(struct device *dev)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain *genpd;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
|
|
|
genpd = dev_to_genpd(dev);
|
|
|
|
if (IS_ERR(genpd))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return genpd->suspend_power_off ? 0 : pm_generic_thaw(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_dev_poweroff - Power off a device belonging to an I/O PM domain.
|
|
|
|
* @dev: Device to suspend.
|
|
|
|
*
|
|
|
|
* Power off a device under the assumption that its pm_domain field points to
|
|
|
|
* the domain member of an object of type struct generic_pm_domain representing
|
|
|
|
* a PM domain consisting of I/O devices.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_dev_poweroff(struct device *dev)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain *genpd;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
|
|
|
genpd = dev_to_genpd(dev);
|
|
|
|
if (IS_ERR(genpd))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return genpd->suspend_power_off ? 0 : pm_generic_poweroff(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_dev_poweroff_noirq - Late power off of a device from a PM domain.
|
|
|
|
* @dev: Device to suspend.
|
|
|
|
*
|
|
|
|
* Carry out a late powering off of a device under the assumption that its
|
|
|
|
* pm_domain field points to the domain member of an object of type
|
|
|
|
* struct generic_pm_domain representing a PM domain consisting of I/O devices.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_dev_poweroff_noirq(struct device *dev)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain *genpd;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
|
|
|
genpd = dev_to_genpd(dev);
|
|
|
|
if (IS_ERR(genpd))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (genpd->suspend_power_off)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ret = pm_generic_poweroff_noirq(dev);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
PM / Domains: Wakeup devices support for system sleep transitions
There is the problem how to handle devices set up to wake up the
system from sleep states during system-wide power transitions.
In some cases, those devices can be turned off entirely, because the
wakeup signals will be generated on their behalf anyway. In some
other cases, they will generate wakeup signals if their clocks are
stopped, but only if power is not removed from them. Finally, in
some cases, they can only generate wakeup signals if power is not
removed from them and their clocks are enabled.
To allow platform-specific code to decide whether or not to put
wakeup devices (and their PM domains) into low-power state during
system-wide transitions, such as system suspend, introduce a new
generic PM domain callback, .active_wakeup(), that will be used
during the "noirq" phase of system suspend and hibernation (after
image creation) to decide what to do with wakeup devices.
Specifically, if this callback is present and returns "true", the
generic PM domain code will not execute .stop_device() for the
given wakeup device and its PM domain won't be powered off.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Acked-by: Kevin Hilman <khilman@ti.com>
2011-07-01 14:13:29 -06:00
|
|
|
if (device_may_wakeup(dev)
|
|
|
|
&& genpd->active_wakeup && genpd->active_wakeup(dev))
|
|
|
|
return 0;
|
|
|
|
|
2011-07-01 14:13:19 -06:00
|
|
|
if (genpd->stop_device)
|
|
|
|
genpd->stop_device(dev);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Since all of the "noirq" callbacks are executed sequentially, it is
|
|
|
|
* guaranteed that this function will never run twice in parallel for
|
|
|
|
* the same PM domain, so it is not necessary to use locking here.
|
|
|
|
*/
|
|
|
|
genpd->suspended_count++;
|
|
|
|
pm_genpd_sync_poweroff(genpd);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_restore_noirq - Early restore of a device from an I/O power domain.
|
|
|
|
* @dev: Device to resume.
|
|
|
|
*
|
|
|
|
* Carry out an early restore of a device under the assumption that its
|
|
|
|
* pm_domain field points to the domain member of an object of type
|
|
|
|
* struct generic_pm_domain representing a power domain consisting of I/O
|
|
|
|
* devices.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_restore_noirq(struct device *dev)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain *genpd;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
|
|
|
genpd = dev_to_genpd(dev);
|
|
|
|
if (IS_ERR(genpd))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Since all of the "noirq" callbacks are executed sequentially, it is
|
|
|
|
* guaranteed that this function will never run twice in parallel for
|
|
|
|
* the same PM domain, so it is not necessary to use locking here.
|
|
|
|
*/
|
2011-07-11 16:39:29 -06:00
|
|
|
genpd->status = GPD_STATE_POWER_OFF;
|
2011-07-01 14:13:19 -06:00
|
|
|
if (genpd->suspend_power_off) {
|
|
|
|
/*
|
|
|
|
* The boot kernel might put the domain into the power on state,
|
|
|
|
* so make sure it really is powered off.
|
|
|
|
*/
|
|
|
|
if (genpd->power_off)
|
|
|
|
genpd->power_off(genpd);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
pm_genpd_poweron(genpd);
|
|
|
|
genpd->suspended_count--;
|
|
|
|
if (genpd->start_device)
|
|
|
|
genpd->start_device(dev);
|
|
|
|
|
|
|
|
return pm_generic_restore_noirq(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_restore - Restore a device belonging to an I/O power domain.
|
|
|
|
* @dev: Device to resume.
|
|
|
|
*
|
|
|
|
* Restore a device under the assumption that its pm_domain field points to the
|
|
|
|
* domain member of an object of type struct generic_pm_domain representing
|
|
|
|
* a power domain consisting of I/O devices.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_restore(struct device *dev)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain *genpd;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
|
|
|
genpd = dev_to_genpd(dev);
|
|
|
|
if (IS_ERR(genpd))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return genpd->suspend_power_off ? 0 : pm_generic_restore(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_complete - Complete power transition of a device in a power domain.
|
|
|
|
* @dev: Device to complete the transition of.
|
|
|
|
*
|
|
|
|
* Complete a power transition of a device (during a system-wide power
|
|
|
|
* transition) under the assumption that its pm_domain field points to the
|
|
|
|
* domain member of an object of type struct generic_pm_domain representing
|
|
|
|
* a power domain consisting of I/O devices.
|
|
|
|
*/
|
|
|
|
static void pm_genpd_complete(struct device *dev)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain *genpd;
|
|
|
|
bool run_complete;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
|
|
|
genpd = dev_to_genpd(dev);
|
|
|
|
if (IS_ERR(genpd))
|
|
|
|
return;
|
|
|
|
|
|
|
|
mutex_lock(&genpd->lock);
|
|
|
|
|
|
|
|
run_complete = !genpd->suspend_power_off;
|
|
|
|
if (--genpd->prepared_count == 0)
|
|
|
|
genpd->suspend_power_off = false;
|
|
|
|
|
|
|
|
mutex_unlock(&genpd->lock);
|
|
|
|
|
|
|
|
if (run_complete) {
|
|
|
|
pm_generic_complete(dev);
|
2011-07-11 16:39:10 -06:00
|
|
|
pm_runtime_set_active(dev);
|
2011-07-01 14:13:19 -06:00
|
|
|
pm_runtime_enable(dev);
|
2011-07-11 16:39:10 -06:00
|
|
|
pm_runtime_idle(dev);
|
2011-07-01 14:13:19 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
#define pm_genpd_prepare NULL
|
|
|
|
#define pm_genpd_suspend NULL
|
|
|
|
#define pm_genpd_suspend_noirq NULL
|
|
|
|
#define pm_genpd_resume_noirq NULL
|
|
|
|
#define pm_genpd_resume NULL
|
|
|
|
#define pm_genpd_freeze NULL
|
|
|
|
#define pm_genpd_freeze_noirq NULL
|
|
|
|
#define pm_genpd_thaw_noirq NULL
|
|
|
|
#define pm_genpd_thaw NULL
|
|
|
|
#define pm_genpd_dev_poweroff_noirq NULL
|
|
|
|
#define pm_genpd_dev_poweroff NULL
|
|
|
|
#define pm_genpd_restore_noirq NULL
|
|
|
|
#define pm_genpd_restore NULL
|
|
|
|
#define pm_genpd_complete NULL
|
|
|
|
|
|
|
|
#endif /* CONFIG_PM_SLEEP */
|
|
|
|
|
2011-07-01 14:12:45 -06:00
|
|
|
/**
|
|
|
|
* pm_genpd_add_device - Add a device to an I/O PM domain.
|
|
|
|
* @genpd: PM domain to add the device to.
|
|
|
|
* @dev: Device to be added.
|
|
|
|
*/
|
|
|
|
int pm_genpd_add_device(struct generic_pm_domain *genpd, struct device *dev)
|
|
|
|
{
|
|
|
|
struct dev_list_entry *dle;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
|
|
|
if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-07-11 16:39:29 -06:00
|
|
|
genpd_acquire_lock(genpd);
|
2011-07-01 14:12:45 -06:00
|
|
|
|
2011-07-11 16:39:29 -06:00
|
|
|
if (genpd->status == GPD_STATE_POWER_OFF) {
|
2011-07-01 14:12:45 -06:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-07-01 14:13:19 -06:00
|
|
|
if (genpd->prepared_count > 0) {
|
|
|
|
ret = -EAGAIN;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-07-01 14:12:45 -06:00
|
|
|
list_for_each_entry(dle, &genpd->dev_list, node)
|
|
|
|
if (dle->dev == dev) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
dle = kzalloc(sizeof(*dle), GFP_KERNEL);
|
|
|
|
if (!dle) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
dle->dev = dev;
|
|
|
|
dle->need_restore = false;
|
|
|
|
list_add_tail(&dle->node, &genpd->dev_list);
|
2011-07-01 14:13:19 -06:00
|
|
|
genpd->device_count++;
|
2011-07-01 14:12:45 -06:00
|
|
|
|
|
|
|
spin_lock_irq(&dev->power.lock);
|
|
|
|
dev->pm_domain = &genpd->domain;
|
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
|
|
|
|
out:
|
2011-07-11 16:39:29 -06:00
|
|
|
genpd_release_lock(genpd);
|
2011-07-01 14:12:45 -06:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_remove_device - Remove a device from an I/O PM domain.
|
|
|
|
* @genpd: PM domain to remove the device from.
|
|
|
|
* @dev: Device to be removed.
|
|
|
|
*/
|
|
|
|
int pm_genpd_remove_device(struct generic_pm_domain *genpd,
|
|
|
|
struct device *dev)
|
|
|
|
{
|
|
|
|
struct dev_list_entry *dle;
|
|
|
|
int ret = -EINVAL;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
|
|
|
if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-07-11 16:39:29 -06:00
|
|
|
genpd_acquire_lock(genpd);
|
2011-07-01 14:12:45 -06:00
|
|
|
|
2011-07-01 14:13:19 -06:00
|
|
|
if (genpd->prepared_count > 0) {
|
|
|
|
ret = -EAGAIN;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-07-01 14:12:45 -06:00
|
|
|
list_for_each_entry(dle, &genpd->dev_list, node) {
|
|
|
|
if (dle->dev != dev)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
spin_lock_irq(&dev->power.lock);
|
|
|
|
dev->pm_domain = NULL;
|
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
|
2011-07-01 14:13:19 -06:00
|
|
|
genpd->device_count--;
|
2011-07-01 14:12:45 -06:00
|
|
|
list_del(&dle->node);
|
|
|
|
kfree(dle);
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-07-01 14:13:19 -06:00
|
|
|
out:
|
2011-07-11 16:39:29 -06:00
|
|
|
genpd_release_lock(genpd);
|
2011-07-01 14:12:45 -06:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_add_subdomain - Add a subdomain to an I/O PM domain.
|
|
|
|
* @genpd: Master PM domain to add the subdomain to.
|
|
|
|
* @new_subdomain: Subdomain to be added.
|
|
|
|
*/
|
|
|
|
int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
|
|
|
|
struct generic_pm_domain *new_subdomain)
|
|
|
|
{
|
2011-08-08 15:43:40 -06:00
|
|
|
struct gpd_link *link;
|
2011-07-01 14:12:45 -06:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(new_subdomain))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-07-11 16:39:29 -06:00
|
|
|
start:
|
|
|
|
genpd_acquire_lock(genpd);
|
|
|
|
mutex_lock_nested(&new_subdomain->lock, SINGLE_DEPTH_NESTING);
|
2011-07-01 14:12:45 -06:00
|
|
|
|
2011-07-11 16:39:29 -06:00
|
|
|
if (new_subdomain->status != GPD_STATE_POWER_OFF
|
|
|
|
&& new_subdomain->status != GPD_STATE_ACTIVE) {
|
|
|
|
mutex_unlock(&new_subdomain->lock);
|
|
|
|
genpd_release_lock(genpd);
|
|
|
|
goto start;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (genpd->status == GPD_STATE_POWER_OFF
|
|
|
|
&& new_subdomain->status != GPD_STATE_POWER_OFF) {
|
2011-07-01 14:12:45 -06:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-08-08 15:43:40 -06:00
|
|
|
list_for_each_entry(link, &genpd->slave_links, slave_node) {
|
|
|
|
if (link->slave == new_subdomain && link->master == genpd) {
|
2011-07-01 14:12:45 -06:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-08-08 15:43:40 -06:00
|
|
|
link = kzalloc(sizeof(*link), GFP_KERNEL);
|
|
|
|
if (!link) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
link->master = genpd;
|
|
|
|
list_add_tail(&link->master_node, &genpd->master_links);
|
|
|
|
link->slave = new_subdomain;
|
|
|
|
list_add_tail(&link->slave_node, &new_subdomain->slave_links);
|
|
|
|
if (new_subdomain->status != GPD_STATE_POWER_OFF)
|
2011-08-08 15:43:04 -06:00
|
|
|
genpd_sd_counter_inc(genpd);
|
2011-07-01 14:12:45 -06:00
|
|
|
|
|
|
|
out:
|
2011-07-11 16:39:29 -06:00
|
|
|
mutex_unlock(&new_subdomain->lock);
|
|
|
|
genpd_release_lock(genpd);
|
2011-07-01 14:12:45 -06:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_remove_subdomain - Remove a subdomain from an I/O PM domain.
|
|
|
|
* @genpd: Master PM domain to remove the subdomain from.
|
2011-08-08 15:43:40 -06:00
|
|
|
* @subdomain: Subdomain to be removed.
|
2011-07-01 14:12:45 -06:00
|
|
|
*/
|
|
|
|
int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
|
2011-08-08 15:43:40 -06:00
|
|
|
struct generic_pm_domain *subdomain)
|
2011-07-01 14:12:45 -06:00
|
|
|
{
|
2011-08-08 15:43:40 -06:00
|
|
|
struct gpd_link *link;
|
2011-07-01 14:12:45 -06:00
|
|
|
int ret = -EINVAL;
|
|
|
|
|
2011-08-08 15:43:40 -06:00
|
|
|
if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(subdomain))
|
2011-07-01 14:12:45 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2011-07-11 16:39:29 -06:00
|
|
|
start:
|
|
|
|
genpd_acquire_lock(genpd);
|
2011-07-01 14:12:45 -06:00
|
|
|
|
2011-08-08 15:43:40 -06:00
|
|
|
list_for_each_entry(link, &genpd->master_links, master_node) {
|
|
|
|
if (link->slave != subdomain)
|
2011-07-01 14:12:45 -06:00
|
|
|
continue;
|
|
|
|
|
|
|
|
mutex_lock_nested(&subdomain->lock, SINGLE_DEPTH_NESTING);
|
|
|
|
|
2011-07-11 16:39:29 -06:00
|
|
|
if (subdomain->status != GPD_STATE_POWER_OFF
|
|
|
|
&& subdomain->status != GPD_STATE_ACTIVE) {
|
|
|
|
mutex_unlock(&subdomain->lock);
|
|
|
|
genpd_release_lock(genpd);
|
|
|
|
goto start;
|
|
|
|
}
|
|
|
|
|
2011-08-08 15:43:40 -06:00
|
|
|
list_del(&link->master_node);
|
|
|
|
list_del(&link->slave_node);
|
|
|
|
kfree(link);
|
2011-07-11 16:39:29 -06:00
|
|
|
if (subdomain->status != GPD_STATE_POWER_OFF)
|
2011-07-01 14:12:45 -06:00
|
|
|
genpd_sd_counter_dec(genpd);
|
|
|
|
|
|
|
|
mutex_unlock(&subdomain->lock);
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-07-11 16:39:29 -06:00
|
|
|
genpd_release_lock(genpd);
|
2011-07-01 14:12:45 -06:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_init - Initialize a generic I/O PM domain object.
|
|
|
|
* @genpd: PM domain object to initialize.
|
|
|
|
* @gov: PM domain governor to associate with the domain (may be NULL).
|
|
|
|
* @is_off: Initial value of the domain's power_is_off field.
|
|
|
|
*/
|
|
|
|
void pm_genpd_init(struct generic_pm_domain *genpd,
|
|
|
|
struct dev_power_governor *gov, bool is_off)
|
|
|
|
{
|
|
|
|
if (IS_ERR_OR_NULL(genpd))
|
|
|
|
return;
|
|
|
|
|
2011-08-08 15:43:40 -06:00
|
|
|
INIT_LIST_HEAD(&genpd->master_links);
|
|
|
|
INIT_LIST_HEAD(&genpd->slave_links);
|
2011-07-01 14:12:45 -06:00
|
|
|
INIT_LIST_HEAD(&genpd->dev_list);
|
|
|
|
mutex_init(&genpd->lock);
|
|
|
|
genpd->gov = gov;
|
|
|
|
INIT_WORK(&genpd->power_off_work, genpd_power_off_work_fn);
|
|
|
|
genpd->in_progress = 0;
|
2011-08-08 15:43:04 -06:00
|
|
|
atomic_set(&genpd->sd_count, 0);
|
2011-07-11 16:39:29 -06:00
|
|
|
genpd->status = is_off ? GPD_STATE_POWER_OFF : GPD_STATE_ACTIVE;
|
|
|
|
init_waitqueue_head(&genpd->status_wait_queue);
|
PM / Domains: Allow callbacks to execute all runtime PM helpers
A deadlock may occur if one of the PM domains' .start_device() or
.stop_device() callbacks or a device driver's .runtime_suspend() or
.runtime_resume() callback executed by the core generic PM domain
code uses a "wrong" runtime PM helper function. This happens, for
example, if .runtime_resume() from one device's driver calls
pm_runtime_resume() for another device in the same PM domain.
A similar situation may take place if a device's parent is in the
same PM domain, in which case the runtime PM framework may execute
pm_genpd_runtime_resume() automatically for the parent (if it is
suspended at the moment). This, of course, is undesirable, so
the generic PM domains code should be modified to prevent it from
happening.
The runtime PM framework guarantees that pm_genpd_runtime_suspend()
and pm_genpd_runtime_resume() won't be executed in parallel for
the same device, so the generic PM domains code need not worry
about those cases. Still, it needs to prevent the other possible
race conditions between pm_genpd_runtime_suspend(),
pm_genpd_runtime_resume(), pm_genpd_poweron() and pm_genpd_poweroff()
from happening and it needs to avoid deadlocks at the same time.
To this end, modify the generic PM domains code to relax
synchronization rules so that:
* pm_genpd_poweron() doesn't wait for the PM domain status to
change from GPD_STATE_BUSY. If it finds that the status is
not GPD_STATE_POWER_OFF, it returns without powering the domain on
(it may modify the status depending on the circumstances).
* pm_genpd_poweroff() returns as soon as it finds that the PM
domain's status changed from GPD_STATE_BUSY after it's released
the PM domain's lock.
* pm_genpd_runtime_suspend() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing the domain's
.stop_device() callback and executes pm_genpd_poweroff() only
if pm_genpd_runtime_resume() is not executed in parallel.
* pm_genpd_runtime_resume() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing pm_genpd_poweron()
and sets the domain's status to GPD_STATE_BUSY and increments its
counter of resuming devices (introduced by this change) immediately
after acquiring the lock. The counter of resuming devices is then
decremented after executing __pm_genpd_runtime_resume() for the
device and the domain's status is reset to GPD_STATE_ACTIVE (unless
there are more resuming devices in the domain, in which case the
status remains GPD_STATE_BUSY).
This way, for example, if a device driver's .runtime_resume()
callback executes pm_runtime_resume() for another device in the same
PM domain, pm_genpd_poweron() called by pm_genpd_runtime_resume()
invoked by the runtime PM framework will not block and it will see
that there's nothing to do for it. Next, the PM domain's lock will
be acquired without waiting for its status to change from
GPD_STATE_BUSY and the device driver's .runtime_resume() callback
will be executed. In turn, if pm_runtime_suspend() is executed by
one device driver's .runtime_resume() callback for another device in
the same PM domain, pm_genpd_poweroff() executed by
pm_genpd_runtime_suspend() invoked by the runtime PM framework as a
result will notice that one of the devices in the domain is being
resumed, so it will return immediately.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 16:39:36 -06:00
|
|
|
genpd->poweroff_task = NULL;
|
|
|
|
genpd->resume_count = 0;
|
2011-07-01 14:13:19 -06:00
|
|
|
genpd->device_count = 0;
|
|
|
|
genpd->suspended_count = 0;
|
2011-07-01 14:12:45 -06:00
|
|
|
genpd->domain.ops.runtime_suspend = pm_genpd_runtime_suspend;
|
|
|
|
genpd->domain.ops.runtime_resume = pm_genpd_runtime_resume;
|
|
|
|
genpd->domain.ops.runtime_idle = pm_generic_runtime_idle;
|
2011-07-01 14:13:19 -06:00
|
|
|
genpd->domain.ops.prepare = pm_genpd_prepare;
|
|
|
|
genpd->domain.ops.suspend = pm_genpd_suspend;
|
|
|
|
genpd->domain.ops.suspend_noirq = pm_genpd_suspend_noirq;
|
|
|
|
genpd->domain.ops.resume_noirq = pm_genpd_resume_noirq;
|
|
|
|
genpd->domain.ops.resume = pm_genpd_resume;
|
|
|
|
genpd->domain.ops.freeze = pm_genpd_freeze;
|
|
|
|
genpd->domain.ops.freeze_noirq = pm_genpd_freeze_noirq;
|
|
|
|
genpd->domain.ops.thaw_noirq = pm_genpd_thaw_noirq;
|
|
|
|
genpd->domain.ops.thaw = pm_genpd_thaw;
|
|
|
|
genpd->domain.ops.poweroff = pm_genpd_dev_poweroff;
|
|
|
|
genpd->domain.ops.poweroff_noirq = pm_genpd_dev_poweroff_noirq;
|
|
|
|
genpd->domain.ops.restore_noirq = pm_genpd_restore_noirq;
|
|
|
|
genpd->domain.ops.restore = pm_genpd_restore;
|
|
|
|
genpd->domain.ops.complete = pm_genpd_complete;
|
2011-07-13 04:31:52 -06:00
|
|
|
mutex_lock(&gpd_list_lock);
|
|
|
|
list_add(&genpd->gpd_list_node, &gpd_list);
|
|
|
|
mutex_unlock(&gpd_list_lock);
|
|
|
|
}
|