2011-07-02 04:12:45 +08: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>
|
PM / Domains: Cache device stop and domain power off governor results, v3
The results of the default device stop and domain power off governor
functions for generic PM domains, default_stop_ok() and
default_power_down_ok(), depend only on the timing data of devices,
which are static, and on their PM QoS constraints. Thus, in theory,
these functions only need to carry out their computations, which may
be time consuming in general, when it is known that the PM QoS
constraint of at least one of the devices in question has changed.
Use the PM QoS notifiers of devices to implement that. First,
introduce new fields, constraint_changed and max_off_time_changed,
into struct gpd_timing_data and struct generic_pm_domain,
respectively, and register a PM QoS notifier function when adding
a device into a domain that will set those fields to 'true' whenever
the device's PM QoS constraint is modified. Second, make
default_stop_ok() and default_power_down_ok() use those fields to
decide whether or not to carry out their computations from scratch.
The device and PM domain hierarchies are taken into account in that
and the expense is that the changes of PM QoS constraints of
suspended devices will not be taken into account immediately, which
isn't guaranteed anyway in general.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-05-02 03:34:07 +08:00
|
|
|
#include <linux/pm_qos.h>
|
2011-07-02 04:12:45 +08:00
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/err.h>
|
2011-07-12 06:39:29 +08:00
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/suspend.h>
|
2011-11-27 20:11:36 +08:00
|
|
|
#include <linux/export.h>
|
|
|
|
|
|
|
|
#define GENPD_DEV_CALLBACK(genpd, type, callback, dev) \
|
|
|
|
({ \
|
|
|
|
type (*__routine)(struct device *__d); \
|
|
|
|
type __ret = (type)0; \
|
|
|
|
\
|
|
|
|
__routine = genpd->dev_ops.callback; \
|
|
|
|
if (__routine) { \
|
|
|
|
__ret = __routine(dev); \
|
|
|
|
} else { \
|
|
|
|
__routine = dev_gpd_data(dev)->ops.callback; \
|
|
|
|
if (__routine) \
|
|
|
|
__ret = __routine(dev); \
|
|
|
|
} \
|
|
|
|
__ret; \
|
|
|
|
})
|
2011-07-02 04:12:45 +08:00
|
|
|
|
2011-12-01 07:02:17 +08:00
|
|
|
#define GENPD_DEV_TIMED_CALLBACK(genpd, type, callback, dev, field, name) \
|
|
|
|
({ \
|
|
|
|
ktime_t __start = ktime_get(); \
|
|
|
|
type __retval = GENPD_DEV_CALLBACK(genpd, type, callback, dev); \
|
|
|
|
s64 __elapsed = ktime_to_ns(ktime_sub(ktime_get(), __start)); \
|
PM / Domains: Cache device stop and domain power off governor results, v3
The results of the default device stop and domain power off governor
functions for generic PM domains, default_stop_ok() and
default_power_down_ok(), depend only on the timing data of devices,
which are static, and on their PM QoS constraints. Thus, in theory,
these functions only need to carry out their computations, which may
be time consuming in general, when it is known that the PM QoS
constraint of at least one of the devices in question has changed.
Use the PM QoS notifiers of devices to implement that. First,
introduce new fields, constraint_changed and max_off_time_changed,
into struct gpd_timing_data and struct generic_pm_domain,
respectively, and register a PM QoS notifier function when adding
a device into a domain that will set those fields to 'true' whenever
the device's PM QoS constraint is modified. Second, make
default_stop_ok() and default_power_down_ok() use those fields to
decide whether or not to carry out their computations from scratch.
The device and PM domain hierarchies are taken into account in that
and the expense is that the changes of PM QoS constraints of
suspended devices will not be taken into account immediately, which
isn't guaranteed anyway in general.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-05-02 03:34:07 +08:00
|
|
|
struct gpd_timing_data *__td = &dev_gpd_data(dev)->td; \
|
|
|
|
if (!__retval && __elapsed > __td->field) { \
|
|
|
|
__td->field = __elapsed; \
|
2011-12-01 07:02:17 +08:00
|
|
|
dev_warn(dev, name " latency exceeded, new value %lld ns\n", \
|
|
|
|
__elapsed); \
|
PM / Domains: Cache device stop and domain power off governor results, v3
The results of the default device stop and domain power off governor
functions for generic PM domains, default_stop_ok() and
default_power_down_ok(), depend only on the timing data of devices,
which are static, and on their PM QoS constraints. Thus, in theory,
these functions only need to carry out their computations, which may
be time consuming in general, when it is known that the PM QoS
constraint of at least one of the devices in question has changed.
Use the PM QoS notifiers of devices to implement that. First,
introduce new fields, constraint_changed and max_off_time_changed,
into struct gpd_timing_data and struct generic_pm_domain,
respectively, and register a PM QoS notifier function when adding
a device into a domain that will set those fields to 'true' whenever
the device's PM QoS constraint is modified. Second, make
default_stop_ok() and default_power_down_ok() use those fields to
decide whether or not to carry out their computations from scratch.
The device and PM domain hierarchies are taken into account in that
and the expense is that the changes of PM QoS constraints of
suspended devices will not be taken into account immediately, which
isn't guaranteed anyway in general.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-05-02 03:34:07 +08:00
|
|
|
genpd->max_off_time_changed = true; \
|
|
|
|
__td->constraint_changed = true; \
|
2011-12-01 07:02:17 +08:00
|
|
|
} \
|
|
|
|
__retval; \
|
|
|
|
})
|
|
|
|
|
2011-07-13 18:31:52 +08:00
|
|
|
static LIST_HEAD(gpd_list);
|
|
|
|
static DEFINE_MUTEX(gpd_list_lock);
|
|
|
|
|
2012-08-07 07:11:14 +08:00
|
|
|
static struct generic_pm_domain *pm_genpd_lookup_name(const char *domain_name)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain *genpd = NULL, *gpd;
|
|
|
|
|
|
|
|
if (IS_ERR_OR_NULL(domain_name))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
mutex_lock(&gpd_list_lock);
|
|
|
|
list_for_each_entry(gpd, &gpd_list, gpd_list_node) {
|
|
|
|
if (!strcmp(gpd->name, domain_name)) {
|
|
|
|
genpd = gpd;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&gpd_list_lock);
|
|
|
|
return genpd;
|
|
|
|
}
|
|
|
|
|
2011-07-02 04:13:10 +08:00
|
|
|
#ifdef CONFIG_PM
|
|
|
|
|
2011-12-01 07:02:05 +08:00
|
|
|
struct generic_pm_domain *dev_to_genpd(struct device *dev)
|
2011-07-02 04:13:10 +08:00
|
|
|
{
|
|
|
|
if (IS_ERR_OR_NULL(dev->pm_domain))
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
2011-07-02 04:13:19 +08:00
|
|
|
return pd_to_genpd(dev->pm_domain);
|
2011-07-02 04:13:10 +08:00
|
|
|
}
|
2011-07-02 04:12:45 +08:00
|
|
|
|
2011-11-27 20:11:36 +08:00
|
|
|
static int genpd_stop_dev(struct generic_pm_domain *genpd, struct device *dev)
|
|
|
|
{
|
2011-12-01 07:02:17 +08:00
|
|
|
return GENPD_DEV_TIMED_CALLBACK(genpd, int, stop, dev,
|
|
|
|
stop_latency_ns, "stop");
|
2011-11-27 20:11:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int genpd_start_dev(struct generic_pm_domain *genpd, struct device *dev)
|
|
|
|
{
|
2011-12-01 07:02:17 +08:00
|
|
|
return GENPD_DEV_TIMED_CALLBACK(genpd, int, start, dev,
|
|
|
|
start_latency_ns, "start");
|
2011-11-27 20:11:36 +08:00
|
|
|
}
|
|
|
|
|
2011-08-09 05:43:04 +08:00
|
|
|
static bool genpd_sd_counter_dec(struct generic_pm_domain *genpd)
|
2011-07-02 04:12:45 +08:00
|
|
|
{
|
2011-08-09 05:43:04 +08: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-02 04:12:45 +08:00
|
|
|
}
|
|
|
|
|
2011-07-12 06:39:29 +08: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-12 06:39:36 +08:00
|
|
|
if (genpd->status == GPD_STATE_ACTIVE
|
|
|
|
|| genpd->status == GPD_STATE_POWER_OFF)
|
2011-07-12 06:39:29 +08: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-12 06:39:36 +08:00
|
|
|
static void genpd_set_active(struct generic_pm_domain *genpd)
|
|
|
|
{
|
|
|
|
if (genpd->resume_count == 0)
|
|
|
|
genpd->status = GPD_STATE_ACTIVE;
|
|
|
|
}
|
|
|
|
|
PM / Domains: Add preliminary support for cpuidle, v2
On some systems there are CPU cores located in the same power
domains as I/O devices. Then, power can only be removed from the
domain if all I/O devices in it are not in use and the CPU core
is idle. Add preliminary support for that to the generic PM domains
framework.
First, the platform is expected to provide a cpuidle driver with one
extra state designated for use with the generic PM domains code.
This state should be initially disabled and its exit_latency value
should be set to whatever time is needed to bring up the CPU core
itself after restoring power to it, not including the domain's
power on latency. Its .enter() callback should point to a procedure
that will remove power from the domain containing the CPU core at
the end of the CPU power transition.
The remaining characteristics of the extra cpuidle state, referred to
as the "domain" cpuidle state below, (e.g. power usage, target
residency) should be populated in accordance with the properties of
the hardware.
Next, the platform should execute genpd_attach_cpuidle() on the PM
domain containing the CPU core. That will cause the generic PM
domains framework to treat that domain in a special way such that:
* When all devices in the domain have been suspended and it is about
to be turned off, the states of the devices will be saved, but
power will not be removed from the domain. Instead, the "domain"
cpuidle state will be enabled so that power can be removed from
the domain when the CPU core is idle and the state has been chosen
as the target by the cpuidle governor.
* When the first I/O device in the domain is resumed and
__pm_genpd_poweron(() is called for the first time after
power has been removed from the domain, the "domain" cpuidle
state will be disabled to avoid subsequent surprise power removals
via cpuidle.
The effective exit_latency value of the "domain" cpuidle state
depends on the time needed to bring up the CPU core itself after
restoring power to it as well as on the power on latency of the
domain containing the CPU core. Thus the "domain" cpuidle state's
exit_latency has to be recomputed every time the domain's power on
latency is updated, which may happen every time power is restored
to the domain, if the measured power on latency is greater than
the latency stored in the corresponding generic_pm_domain structure.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Reviewed-by: Kevin Hilman <khilman@ti.com>
2012-07-04 01:07:42 +08:00
|
|
|
static void genpd_recalc_cpu_exit_latency(struct generic_pm_domain *genpd)
|
|
|
|
{
|
|
|
|
s64 usecs64;
|
|
|
|
|
|
|
|
if (!genpd->cpu_data)
|
|
|
|
return;
|
|
|
|
|
|
|
|
usecs64 = genpd->power_on_latency_ns;
|
|
|
|
do_div(usecs64, NSEC_PER_USEC);
|
|
|
|
usecs64 += genpd->cpu_data->saved_exit_latency;
|
|
|
|
genpd->cpu_data->idle_state->exit_latency = usecs64;
|
|
|
|
}
|
|
|
|
|
2011-07-02 04:13:10 +08:00
|
|
|
/**
|
2011-08-09 05:43:40 +08:00
|
|
|
* __pm_genpd_poweron - Restore power to a given PM domain and its masters.
|
2011-07-02 04:13:10 +08:00
|
|
|
* @genpd: PM domain to power up.
|
|
|
|
*
|
2011-08-09 05:43:40 +08:00
|
|
|
* Restore power to @genpd and all of its masters so that it is possible to
|
2011-07-02 04:13:10 +08:00
|
|
|
* resume a device belonging to it.
|
|
|
|
*/
|
2012-07-11 03:47:07 +08:00
|
|
|
static int __pm_genpd_poweron(struct generic_pm_domain *genpd)
|
2011-08-09 05:43:29 +08:00
|
|
|
__releases(&genpd->lock) __acquires(&genpd->lock)
|
2011-07-02 04:13:10 +08:00
|
|
|
{
|
2011-08-09 05:43:40 +08:00
|
|
|
struct gpd_link *link;
|
2011-08-09 05:43:29 +08:00
|
|
|
DEFINE_WAIT(wait);
|
2011-07-02 04:13:10 +08:00
|
|
|
int ret = 0;
|
|
|
|
|
2011-08-09 05:43:40 +08:00
|
|
|
/* If the domain's master is being waited for, we have to wait too. */
|
2011-08-09 05:43:29 +08:00
|
|
|
for (;;) {
|
|
|
|
prepare_to_wait(&genpd->status_wait_queue, &wait,
|
|
|
|
TASK_UNINTERRUPTIBLE);
|
2011-08-09 05:43:50 +08:00
|
|
|
if (genpd->status != GPD_STATE_WAIT_MASTER)
|
2011-08-09 05:43:29 +08:00
|
|
|
break;
|
|
|
|
mutex_unlock(&genpd->lock);
|
2011-07-12 06:39:29 +08:00
|
|
|
|
2011-08-09 05:43:29 +08:00
|
|
|
schedule();
|
|
|
|
|
|
|
|
mutex_lock(&genpd->lock);
|
|
|
|
}
|
|
|
|
finish_wait(&genpd->status_wait_queue, &wait);
|
2011-08-09 05:43:22 +08:00
|
|
|
|
2011-07-12 06:39:29 +08:00
|
|
|
if (genpd->status == GPD_STATE_ACTIVE
|
2011-07-02 04:13:19 +08:00
|
|
|
|| (genpd->prepared_count > 0 && genpd->suspend_power_off))
|
2011-08-09 05:43:29 +08:00
|
|
|
return 0;
|
2011-07-02 04:13:10 +08: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-12 06:39:36 +08:00
|
|
|
if (genpd->status != GPD_STATE_POWER_OFF) {
|
|
|
|
genpd_set_active(genpd);
|
2011-08-09 05:43:29 +08: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-12 06:39:36 +08:00
|
|
|
}
|
|
|
|
|
PM / Domains: Add preliminary support for cpuidle, v2
On some systems there are CPU cores located in the same power
domains as I/O devices. Then, power can only be removed from the
domain if all I/O devices in it are not in use and the CPU core
is idle. Add preliminary support for that to the generic PM domains
framework.
First, the platform is expected to provide a cpuidle driver with one
extra state designated for use with the generic PM domains code.
This state should be initially disabled and its exit_latency value
should be set to whatever time is needed to bring up the CPU core
itself after restoring power to it, not including the domain's
power on latency. Its .enter() callback should point to a procedure
that will remove power from the domain containing the CPU core at
the end of the CPU power transition.
The remaining characteristics of the extra cpuidle state, referred to
as the "domain" cpuidle state below, (e.g. power usage, target
residency) should be populated in accordance with the properties of
the hardware.
Next, the platform should execute genpd_attach_cpuidle() on the PM
domain containing the CPU core. That will cause the generic PM
domains framework to treat that domain in a special way such that:
* When all devices in the domain have been suspended and it is about
to be turned off, the states of the devices will be saved, but
power will not be removed from the domain. Instead, the "domain"
cpuidle state will be enabled so that power can be removed from
the domain when the CPU core is idle and the state has been chosen
as the target by the cpuidle governor.
* When the first I/O device in the domain is resumed and
__pm_genpd_poweron(() is called for the first time after
power has been removed from the domain, the "domain" cpuidle
state will be disabled to avoid subsequent surprise power removals
via cpuidle.
The effective exit_latency value of the "domain" cpuidle state
depends on the time needed to bring up the CPU core itself after
restoring power to it as well as on the power on latency of the
domain containing the CPU core. Thus the "domain" cpuidle state's
exit_latency has to be recomputed every time the domain's power on
latency is updated, which may happen every time power is restored
to the domain, if the measured power on latency is greater than
the latency stored in the corresponding generic_pm_domain structure.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Reviewed-by: Kevin Hilman <khilman@ti.com>
2012-07-04 01:07:42 +08:00
|
|
|
if (genpd->cpu_data) {
|
|
|
|
cpuidle_pause_and_lock();
|
|
|
|
genpd->cpu_data->idle_state->disabled = true;
|
|
|
|
cpuidle_resume_and_unlock();
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-08-09 05:43:40 +08: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-09 05:43:50 +08:00
|
|
|
genpd->status = GPD_STATE_WAIT_MASTER;
|
2011-08-09 05:43:14 +08:00
|
|
|
|
2011-07-02 04:13:10 +08:00
|
|
|
mutex_unlock(&genpd->lock);
|
|
|
|
|
2011-08-09 05:43:40 +08:00
|
|
|
ret = pm_genpd_poweron(link->master);
|
2011-08-09 05:43:22 +08:00
|
|
|
|
|
|
|
mutex_lock(&genpd->lock);
|
|
|
|
|
2011-08-09 05:43:29 +08:00
|
|
|
/*
|
|
|
|
* The "wait for parent" status is guaranteed not to change
|
2011-08-09 05:43:40 +08:00
|
|
|
* while the master is powering on.
|
2011-08-09 05:43:29 +08:00
|
|
|
*/
|
|
|
|
genpd->status = GPD_STATE_POWER_OFF;
|
|
|
|
wake_up_all(&genpd->status_wait_queue);
|
2011-08-09 05:43:40 +08:00
|
|
|
if (ret) {
|
|
|
|
genpd_sd_counter_dec(link->master);
|
2011-08-09 05:43:22 +08:00
|
|
|
goto err;
|
2011-08-09 05:43:40 +08:00
|
|
|
}
|
2011-07-02 04:13:10 +08:00
|
|
|
}
|
|
|
|
|
2011-08-09 05:43:22 +08:00
|
|
|
if (genpd->power_on) {
|
2011-12-01 07:02:17 +08:00
|
|
|
ktime_t time_start = ktime_get();
|
|
|
|
s64 elapsed_ns;
|
|
|
|
|
2011-08-06 03:45:11 +08:00
|
|
|
ret = genpd->power_on(genpd);
|
2011-08-09 05:43:22 +08:00
|
|
|
if (ret)
|
|
|
|
goto err;
|
2011-12-01 07:02:17 +08:00
|
|
|
|
|
|
|
elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start));
|
2011-12-07 05:19:54 +08:00
|
|
|
if (elapsed_ns > genpd->power_on_latency_ns) {
|
2011-12-01 07:02:17 +08:00
|
|
|
genpd->power_on_latency_ns = elapsed_ns;
|
PM / Domains: Cache device stop and domain power off governor results, v3
The results of the default device stop and domain power off governor
functions for generic PM domains, default_stop_ok() and
default_power_down_ok(), depend only on the timing data of devices,
which are static, and on their PM QoS constraints. Thus, in theory,
these functions only need to carry out their computations, which may
be time consuming in general, when it is known that the PM QoS
constraint of at least one of the devices in question has changed.
Use the PM QoS notifiers of devices to implement that. First,
introduce new fields, constraint_changed and max_off_time_changed,
into struct gpd_timing_data and struct generic_pm_domain,
respectively, and register a PM QoS notifier function when adding
a device into a domain that will set those fields to 'true' whenever
the device's PM QoS constraint is modified. Second, make
default_stop_ok() and default_power_down_ok() use those fields to
decide whether or not to carry out their computations from scratch.
The device and PM domain hierarchies are taken into account in that
and the expense is that the changes of PM QoS constraints of
suspended devices will not be taken into account immediately, which
isn't guaranteed anyway in general.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-05-02 03:34:07 +08:00
|
|
|
genpd->max_off_time_changed = true;
|
PM / Domains: Add preliminary support for cpuidle, v2
On some systems there are CPU cores located in the same power
domains as I/O devices. Then, power can only be removed from the
domain if all I/O devices in it are not in use and the CPU core
is idle. Add preliminary support for that to the generic PM domains
framework.
First, the platform is expected to provide a cpuidle driver with one
extra state designated for use with the generic PM domains code.
This state should be initially disabled and its exit_latency value
should be set to whatever time is needed to bring up the CPU core
itself after restoring power to it, not including the domain's
power on latency. Its .enter() callback should point to a procedure
that will remove power from the domain containing the CPU core at
the end of the CPU power transition.
The remaining characteristics of the extra cpuidle state, referred to
as the "domain" cpuidle state below, (e.g. power usage, target
residency) should be populated in accordance with the properties of
the hardware.
Next, the platform should execute genpd_attach_cpuidle() on the PM
domain containing the CPU core. That will cause the generic PM
domains framework to treat that domain in a special way such that:
* When all devices in the domain have been suspended and it is about
to be turned off, the states of the devices will be saved, but
power will not be removed from the domain. Instead, the "domain"
cpuidle state will be enabled so that power can be removed from
the domain when the CPU core is idle and the state has been chosen
as the target by the cpuidle governor.
* When the first I/O device in the domain is resumed and
__pm_genpd_poweron(() is called for the first time after
power has been removed from the domain, the "domain" cpuidle
state will be disabled to avoid subsequent surprise power removals
via cpuidle.
The effective exit_latency value of the "domain" cpuidle state
depends on the time needed to bring up the CPU core itself after
restoring power to it as well as on the power on latency of the
domain containing the CPU core. Thus the "domain" cpuidle state's
exit_latency has to be recomputed every time the domain's power on
latency is updated, which may happen every time power is restored
to the domain, if the measured power on latency is greater than
the latency stored in the corresponding generic_pm_domain structure.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Reviewed-by: Kevin Hilman <khilman@ti.com>
2012-07-04 01:07:42 +08:00
|
|
|
genpd_recalc_cpu_exit_latency(genpd);
|
2011-12-07 05:19:54 +08:00
|
|
|
if (genpd->name)
|
|
|
|
pr_warning("%s: Power-on latency exceeded, "
|
|
|
|
"new value %lld ns\n", genpd->name,
|
|
|
|
elapsed_ns);
|
|
|
|
}
|
2011-08-09 05:43:14 +08:00
|
|
|
}
|
2011-07-02 04:13:10 +08:00
|
|
|
|
PM / Domains: Add preliminary support for cpuidle, v2
On some systems there are CPU cores located in the same power
domains as I/O devices. Then, power can only be removed from the
domain if all I/O devices in it are not in use and the CPU core
is idle. Add preliminary support for that to the generic PM domains
framework.
First, the platform is expected to provide a cpuidle driver with one
extra state designated for use with the generic PM domains code.
This state should be initially disabled and its exit_latency value
should be set to whatever time is needed to bring up the CPU core
itself after restoring power to it, not including the domain's
power on latency. Its .enter() callback should point to a procedure
that will remove power from the domain containing the CPU core at
the end of the CPU power transition.
The remaining characteristics of the extra cpuidle state, referred to
as the "domain" cpuidle state below, (e.g. power usage, target
residency) should be populated in accordance with the properties of
the hardware.
Next, the platform should execute genpd_attach_cpuidle() on the PM
domain containing the CPU core. That will cause the generic PM
domains framework to treat that domain in a special way such that:
* When all devices in the domain have been suspended and it is about
to be turned off, the states of the devices will be saved, but
power will not be removed from the domain. Instead, the "domain"
cpuidle state will be enabled so that power can be removed from
the domain when the CPU core is idle and the state has been chosen
as the target by the cpuidle governor.
* When the first I/O device in the domain is resumed and
__pm_genpd_poweron(() is called for the first time after
power has been removed from the domain, the "domain" cpuidle
state will be disabled to avoid subsequent surprise power removals
via cpuidle.
The effective exit_latency value of the "domain" cpuidle state
depends on the time needed to bring up the CPU core itself after
restoring power to it as well as on the power on latency of the
domain containing the CPU core. Thus the "domain" cpuidle state's
exit_latency has to be recomputed every time the domain's power on
latency is updated, which may happen every time power is restored
to the domain, if the measured power on latency is greater than
the latency stored in the corresponding generic_pm_domain structure.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Reviewed-by: Kevin Hilman <khilman@ti.com>
2012-07-04 01:07:42 +08:00
|
|
|
out:
|
2011-08-09 05:43:22 +08:00
|
|
|
genpd_set_active(genpd);
|
|
|
|
|
2011-08-09 05:43:29 +08:00
|
|
|
return 0;
|
2011-08-09 05:43:22 +08:00
|
|
|
|
|
|
|
err:
|
2011-08-09 05:43:40 +08:00
|
|
|
list_for_each_entry_continue_reverse(link, &genpd->slave_links, slave_node)
|
|
|
|
genpd_sd_counter_dec(link->master);
|
2011-08-09 05:43:22 +08:00
|
|
|
|
2011-08-09 05:43:29 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-08-09 05:43:40 +08:00
|
|
|
* pm_genpd_poweron - Restore power to a given PM domain and its masters.
|
2011-08-09 05:43:29 +08: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-02 04:13:10 +08:00
|
|
|
}
|
|
|
|
|
2012-08-07 07:11:14 +08:00
|
|
|
/**
|
|
|
|
* pm_genpd_name_poweron - Restore power to a given PM domain and its masters.
|
|
|
|
* @domain_name: Name of the PM domain to power up.
|
|
|
|
*/
|
|
|
|
int pm_genpd_name_poweron(const char *domain_name)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain *genpd;
|
|
|
|
|
|
|
|
genpd = pm_genpd_lookup_name(domain_name);
|
|
|
|
return genpd ? pm_genpd_poweron(genpd) : -EINVAL;
|
|
|
|
}
|
|
|
|
|
2011-07-02 04:13:10 +08:00
|
|
|
#endif /* CONFIG_PM */
|
|
|
|
|
|
|
|
#ifdef CONFIG_PM_RUNTIME
|
|
|
|
|
2012-09-06 16:18:57 +08:00
|
|
|
static int genpd_start_dev_no_timing(struct generic_pm_domain *genpd,
|
|
|
|
struct device *dev)
|
|
|
|
{
|
|
|
|
return GENPD_DEV_CALLBACK(genpd, int, start, dev);
|
|
|
|
}
|
|
|
|
|
2012-07-12 04:42:52 +08:00
|
|
|
static int genpd_save_dev(struct generic_pm_domain *genpd, struct device *dev)
|
|
|
|
{
|
|
|
|
return GENPD_DEV_TIMED_CALLBACK(genpd, int, save_state, dev,
|
|
|
|
save_state_latency_ns, "state save");
|
|
|
|
}
|
|
|
|
|
|
|
|
static int genpd_restore_dev(struct generic_pm_domain *genpd, struct device *dev)
|
|
|
|
{
|
|
|
|
return GENPD_DEV_TIMED_CALLBACK(genpd, int, restore_state, dev,
|
|
|
|
restore_state_latency_ns,
|
|
|
|
"state restore");
|
|
|
|
}
|
|
|
|
|
PM / Domains: Cache device stop and domain power off governor results, v3
The results of the default device stop and domain power off governor
functions for generic PM domains, default_stop_ok() and
default_power_down_ok(), depend only on the timing data of devices,
which are static, and on their PM QoS constraints. Thus, in theory,
these functions only need to carry out their computations, which may
be time consuming in general, when it is known that the PM QoS
constraint of at least one of the devices in question has changed.
Use the PM QoS notifiers of devices to implement that. First,
introduce new fields, constraint_changed and max_off_time_changed,
into struct gpd_timing_data and struct generic_pm_domain,
respectively, and register a PM QoS notifier function when adding
a device into a domain that will set those fields to 'true' whenever
the device's PM QoS constraint is modified. Second, make
default_stop_ok() and default_power_down_ok() use those fields to
decide whether or not to carry out their computations from scratch.
The device and PM domain hierarchies are taken into account in that
and the expense is that the changes of PM QoS constraints of
suspended devices will not be taken into account immediately, which
isn't guaranteed anyway in general.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-05-02 03:34:07 +08:00
|
|
|
static int genpd_dev_pm_qos_notifier(struct notifier_block *nb,
|
|
|
|
unsigned long val, void *ptr)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain_data *gpd_data;
|
|
|
|
struct device *dev;
|
|
|
|
|
|
|
|
gpd_data = container_of(nb, struct generic_pm_domain_data, nb);
|
|
|
|
|
|
|
|
mutex_lock(&gpd_data->lock);
|
|
|
|
dev = gpd_data->base.dev;
|
|
|
|
if (!dev) {
|
|
|
|
mutex_unlock(&gpd_data->lock);
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
}
|
|
|
|
mutex_unlock(&gpd_data->lock);
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
struct generic_pm_domain *genpd;
|
|
|
|
struct pm_domain_data *pdd;
|
|
|
|
|
|
|
|
spin_lock_irq(&dev->power.lock);
|
|
|
|
|
|
|
|
pdd = dev->power.subsys_data ?
|
|
|
|
dev->power.subsys_data->domain_data : NULL;
|
2012-07-06 04:12:32 +08:00
|
|
|
if (pdd && pdd->dev) {
|
PM / Domains: Cache device stop and domain power off governor results, v3
The results of the default device stop and domain power off governor
functions for generic PM domains, default_stop_ok() and
default_power_down_ok(), depend only on the timing data of devices,
which are static, and on their PM QoS constraints. Thus, in theory,
these functions only need to carry out their computations, which may
be time consuming in general, when it is known that the PM QoS
constraint of at least one of the devices in question has changed.
Use the PM QoS notifiers of devices to implement that. First,
introduce new fields, constraint_changed and max_off_time_changed,
into struct gpd_timing_data and struct generic_pm_domain,
respectively, and register a PM QoS notifier function when adding
a device into a domain that will set those fields to 'true' whenever
the device's PM QoS constraint is modified. Second, make
default_stop_ok() and default_power_down_ok() use those fields to
decide whether or not to carry out their computations from scratch.
The device and PM domain hierarchies are taken into account in that
and the expense is that the changes of PM QoS constraints of
suspended devices will not be taken into account immediately, which
isn't guaranteed anyway in general.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-05-02 03:34:07 +08:00
|
|
|
to_gpd_data(pdd)->td.constraint_changed = true;
|
|
|
|
genpd = dev_to_genpd(dev);
|
|
|
|
} else {
|
|
|
|
genpd = ERR_PTR(-ENODATA);
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
|
|
|
|
if (!IS_ERR(genpd)) {
|
|
|
|
mutex_lock(&genpd->lock);
|
|
|
|
genpd->max_off_time_changed = true;
|
|
|
|
mutex_unlock(&genpd->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
dev = dev->parent;
|
|
|
|
if (!dev || dev->power.ignore_children)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
}
|
|
|
|
|
2011-07-02 04:12:45 +08:00
|
|
|
/**
|
|
|
|
* __pm_genpd_save_device - Save the pre-suspend state of a device.
|
2011-08-25 21:34:12 +08:00
|
|
|
* @pdd: Domain data of the device to save the state of.
|
2011-07-02 04:12:45 +08:00
|
|
|
* @genpd: PM domain the device belongs to.
|
|
|
|
*/
|
2011-08-25 21:34:12 +08:00
|
|
|
static int __pm_genpd_save_device(struct pm_domain_data *pdd,
|
2011-07-02 04:12:45 +08:00
|
|
|
struct generic_pm_domain *genpd)
|
2011-07-12 06:39:29 +08:00
|
|
|
__releases(&genpd->lock) __acquires(&genpd->lock)
|
2011-07-02 04:12:45 +08:00
|
|
|
{
|
2011-09-27 02:22:02 +08:00
|
|
|
struct generic_pm_domain_data *gpd_data = to_gpd_data(pdd);
|
2011-08-25 21:34:12 +08:00
|
|
|
struct device *dev = pdd->dev;
|
2011-07-02 04:12:45 +08:00
|
|
|
int ret = 0;
|
|
|
|
|
2011-09-27 02:22:02 +08:00
|
|
|
if (gpd_data->need_restore)
|
2011-07-02 04:12:45 +08:00
|
|
|
return 0;
|
|
|
|
|
2011-07-12 06:39:29 +08:00
|
|
|
mutex_unlock(&genpd->lock);
|
|
|
|
|
PM / Domains: Introduce "save/restore state" device callbacks
The current PM domains code uses device drivers' .runtime_suspend()
and .runtime_resume() callbacks as the "save device state" and
"restore device state" operations, which may not be appropriate in
general, because it forces drivers to assume that they always will
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM
domain, in which case it would be necessary to add "fake" PM
domains to satisfy the above assumption. It also may be located in
a PM domain that's not handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, introduce new device callbacks,
.save_state() and .restore_state(), that can be supplied by the
drivers in addition to their "standard" runtime PM callbacks. This
will allow the drivers to be designed to work with generic PM domains
as well as without them.
For backwards compatibility, introduce default .save_state() and
.restore_state() callback routines for PM domains that will execute
a device driver's .runtime_suspend() and .runtime_resume() callbacks,
respectively, for the given device if the driver doesn't provide its
own implementations of .save_state() and .restore_state().
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:44 +08:00
|
|
|
genpd_start_dev(genpd, dev);
|
|
|
|
ret = genpd_save_dev(genpd, dev);
|
|
|
|
genpd_stop_dev(genpd, dev);
|
2011-07-02 04:12:45 +08:00
|
|
|
|
2011-07-12 06:39:29 +08:00
|
|
|
mutex_lock(&genpd->lock);
|
|
|
|
|
2011-07-02 04:12:45 +08:00
|
|
|
if (!ret)
|
2011-09-27 02:22:02 +08:00
|
|
|
gpd_data->need_restore = true;
|
2011-07-02 04:12:45 +08:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __pm_genpd_restore_device - Restore the pre-suspend state of a device.
|
2011-08-25 21:34:12 +08:00
|
|
|
* @pdd: Domain data of the device to restore the state of.
|
2011-07-02 04:12:45 +08:00
|
|
|
* @genpd: PM domain the device belongs to.
|
|
|
|
*/
|
2011-08-25 21:34:12 +08:00
|
|
|
static void __pm_genpd_restore_device(struct pm_domain_data *pdd,
|
2011-07-02 04:12:45 +08:00
|
|
|
struct generic_pm_domain *genpd)
|
2011-07-12 06:39:29 +08:00
|
|
|
__releases(&genpd->lock) __acquires(&genpd->lock)
|
2011-07-02 04:12:45 +08:00
|
|
|
{
|
2011-09-27 02:22:02 +08:00
|
|
|
struct generic_pm_domain_data *gpd_data = to_gpd_data(pdd);
|
2011-08-25 21:34:12 +08:00
|
|
|
struct device *dev = pdd->dev;
|
PM / Domains: Do not stop devices after restoring their states
While resuming a device belonging to a PM domain,
pm_genpd_runtime_resume() calls __pm_genpd_restore_device() to
restore its state, if necessary. The latter starts the device,
using genpd_start_dev(), restores its state, using
genpd_restore_dev(), and then stops it, using genpd_stop_dev().
However, this last operation is not necessary, because the
device is supposed to be operational after pm_genpd_runtime_resume()
has returned and because of it pm_genpd_runtime_resume() has to
call genpd_start_dev() once again for the "restored" device, which
is inefficient.
To make things more efficient, remove the call to genpd_stop_dev()
from __pm_genpd_restore_device() and the direct call to
genpd_start_dev() from pm_genpd_runtime_resume(). [Of course,
genpd_start_dev() still has to be called by it for devices with the
power.irq_safe flag set, because __pm_genpd_restore_device() is not
executed for them.]
This change has been tested on the SH7372 Mackerel board.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-06-16 06:02:34 +08:00
|
|
|
bool need_restore = gpd_data->need_restore;
|
2011-07-02 04:12:45 +08:00
|
|
|
|
PM / Domains: Do not stop devices after restoring their states
While resuming a device belonging to a PM domain,
pm_genpd_runtime_resume() calls __pm_genpd_restore_device() to
restore its state, if necessary. The latter starts the device,
using genpd_start_dev(), restores its state, using
genpd_restore_dev(), and then stops it, using genpd_stop_dev().
However, this last operation is not necessary, because the
device is supposed to be operational after pm_genpd_runtime_resume()
has returned and because of it pm_genpd_runtime_resume() has to
call genpd_start_dev() once again for the "restored" device, which
is inefficient.
To make things more efficient, remove the call to genpd_stop_dev()
from __pm_genpd_restore_device() and the direct call to
genpd_start_dev() from pm_genpd_runtime_resume(). [Of course,
genpd_start_dev() still has to be called by it for devices with the
power.irq_safe flag set, because __pm_genpd_restore_device() is not
executed for them.]
This change has been tested on the SH7372 Mackerel board.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-06-16 06:02:34 +08:00
|
|
|
gpd_data->need_restore = false;
|
2011-07-12 06:39:29 +08:00
|
|
|
mutex_unlock(&genpd->lock);
|
|
|
|
|
PM / Domains: Introduce "save/restore state" device callbacks
The current PM domains code uses device drivers' .runtime_suspend()
and .runtime_resume() callbacks as the "save device state" and
"restore device state" operations, which may not be appropriate in
general, because it forces drivers to assume that they always will
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM
domain, in which case it would be necessary to add "fake" PM
domains to satisfy the above assumption. It also may be located in
a PM domain that's not handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, introduce new device callbacks,
.save_state() and .restore_state(), that can be supplied by the
drivers in addition to their "standard" runtime PM callbacks. This
will allow the drivers to be designed to work with generic PM domains
as well as without them.
For backwards compatibility, introduce default .save_state() and
.restore_state() callback routines for PM domains that will execute
a device driver's .runtime_suspend() and .runtime_resume() callbacks,
respectively, for the given device if the driver doesn't provide its
own implementations of .save_state() and .restore_state().
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:44 +08:00
|
|
|
genpd_start_dev(genpd, dev);
|
PM / Domains: Do not stop devices after restoring their states
While resuming a device belonging to a PM domain,
pm_genpd_runtime_resume() calls __pm_genpd_restore_device() to
restore its state, if necessary. The latter starts the device,
using genpd_start_dev(), restores its state, using
genpd_restore_dev(), and then stops it, using genpd_stop_dev().
However, this last operation is not necessary, because the
device is supposed to be operational after pm_genpd_runtime_resume()
has returned and because of it pm_genpd_runtime_resume() has to
call genpd_start_dev() once again for the "restored" device, which
is inefficient.
To make things more efficient, remove the call to genpd_stop_dev()
from __pm_genpd_restore_device() and the direct call to
genpd_start_dev() from pm_genpd_runtime_resume(). [Of course,
genpd_start_dev() still has to be called by it for devices with the
power.irq_safe flag set, because __pm_genpd_restore_device() is not
executed for them.]
This change has been tested on the SH7372 Mackerel board.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-06-16 06:02:34 +08:00
|
|
|
if (need_restore)
|
|
|
|
genpd_restore_dev(genpd, dev);
|
2011-07-02 04:12:45 +08:00
|
|
|
|
2011-07-12 06:39:29 +08:00
|
|
|
mutex_lock(&genpd->lock);
|
2011-07-02 04:12:45 +08: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-12 06:39:36 +08: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-09 05:43:50 +08:00
|
|
|
return genpd->status == GPD_STATE_WAIT_MASTER
|
2011-08-09 05:43:29 +08:00
|
|
|
|| 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-12 06:39:36 +08:00
|
|
|
}
|
|
|
|
|
2011-07-12 06:40:03 +08: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-15 02:59:07 +08:00
|
|
|
void genpd_queue_power_off_work(struct generic_pm_domain *genpd)
|
2011-07-12 06:40:03 +08:00
|
|
|
{
|
|
|
|
if (!work_pending(&genpd->power_off_work))
|
|
|
|
queue_work(pm_wq, &genpd->power_off_work);
|
|
|
|
}
|
|
|
|
|
2011-07-02 04:12:45 +08: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-12 06:39:29 +08:00
|
|
|
__releases(&genpd->lock) __acquires(&genpd->lock)
|
2011-07-02 04:12:45 +08:00
|
|
|
{
|
2011-08-25 21:34:12 +08:00
|
|
|
struct pm_domain_data *pdd;
|
2011-08-09 05:43:40 +08:00
|
|
|
struct gpd_link *link;
|
2011-07-02 04:12:45 +08: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-12 06:39:36 +08:00
|
|
|
int ret = 0;
|
2011-07-02 04:12:45 +08: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-12 06:39:36 +08: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-09 05:43:40 +08: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-12 06:39:36 +08:00
|
|
|
* (3) One of the domain's devices is being resumed right now.
|
2011-08-09 05:43:29 +08: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-12 06:39:36 +08:00
|
|
|
*/
|
2011-08-09 05:43:29 +08:00
|
|
|
if (genpd->status == GPD_STATE_POWER_OFF
|
2011-08-09 05:43:50 +08:00
|
|
|
|| genpd->status == GPD_STATE_WAIT_MASTER
|
2011-08-09 05:43:29 +08:00
|
|
|
|| genpd->resume_count > 0 || genpd->prepared_count > 0)
|
2011-07-02 04:12:45 +08:00
|
|
|
return 0;
|
|
|
|
|
2011-08-09 05:43:04 +08:00
|
|
|
if (atomic_read(&genpd->sd_count) > 0)
|
2011-07-02 04:12:45 +08:00
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
not_suspended = 0;
|
2011-08-25 21:34:12 +08:00
|
|
|
list_for_each_entry(pdd, &genpd->dev_list, list_node)
|
2011-08-25 21:37:04 +08:00
|
|
|
if (pdd->dev->driver && (!pm_runtime_suspended(pdd->dev)
|
2012-08-13 20:00:25 +08:00
|
|
|
|| pdd->dev->power.irq_safe))
|
2011-07-02 04:12:45 +08:00
|
|
|
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-12 06:39:36 +08: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-02 04:12:45 +08:00
|
|
|
if (genpd->gov && genpd->gov->power_down_ok) {
|
|
|
|
if (!genpd->gov->power_down_ok(&genpd->domain))
|
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
|
2011-07-12 06:39:29 +08: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-12 06:39:36 +08:00
|
|
|
genpd->poweroff_task = current;
|
2011-07-12 06:39:29 +08:00
|
|
|
|
2011-08-25 21:34:12 +08:00
|
|
|
list_for_each_entry_reverse(pdd, &genpd->dev_list, list_node) {
|
2011-08-09 05:43:14 +08:00
|
|
|
ret = atomic_read(&genpd->sd_count) == 0 ?
|
2011-08-25 21:34:12 +08:00
|
|
|
__pm_genpd_save_device(pdd, genpd) : -EBUSY;
|
2011-08-09 05:43:29 +08:00
|
|
|
|
|
|
|
if (genpd_abort_poweroff(genpd))
|
|
|
|
goto out;
|
|
|
|
|
2011-07-12 06:39:48 +08:00
|
|
|
if (ret) {
|
|
|
|
genpd_set_active(genpd);
|
|
|
|
goto out;
|
|
|
|
}
|
2011-07-02 04:12:45 +08: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-12 06:39:36 +08:00
|
|
|
if (genpd->status == GPD_STATE_REPEAT) {
|
|
|
|
genpd->poweroff_task = NULL;
|
|
|
|
goto start;
|
|
|
|
}
|
|
|
|
}
|
2011-07-12 06:39:29 +08:00
|
|
|
|
PM / Domains: Add preliminary support for cpuidle, v2
On some systems there are CPU cores located in the same power
domains as I/O devices. Then, power can only be removed from the
domain if all I/O devices in it are not in use and the CPU core
is idle. Add preliminary support for that to the generic PM domains
framework.
First, the platform is expected to provide a cpuidle driver with one
extra state designated for use with the generic PM domains code.
This state should be initially disabled and its exit_latency value
should be set to whatever time is needed to bring up the CPU core
itself after restoring power to it, not including the domain's
power on latency. Its .enter() callback should point to a procedure
that will remove power from the domain containing the CPU core at
the end of the CPU power transition.
The remaining characteristics of the extra cpuidle state, referred to
as the "domain" cpuidle state below, (e.g. power usage, target
residency) should be populated in accordance with the properties of
the hardware.
Next, the platform should execute genpd_attach_cpuidle() on the PM
domain containing the CPU core. That will cause the generic PM
domains framework to treat that domain in a special way such that:
* When all devices in the domain have been suspended and it is about
to be turned off, the states of the devices will be saved, but
power will not be removed from the domain. Instead, the "domain"
cpuidle state will be enabled so that power can be removed from
the domain when the CPU core is idle and the state has been chosen
as the target by the cpuidle governor.
* When the first I/O device in the domain is resumed and
__pm_genpd_poweron(() is called for the first time after
power has been removed from the domain, the "domain" cpuidle
state will be disabled to avoid subsequent surprise power removals
via cpuidle.
The effective exit_latency value of the "domain" cpuidle state
depends on the time needed to bring up the CPU core itself after
restoring power to it as well as on the power on latency of the
domain containing the CPU core. Thus the "domain" cpuidle state's
exit_latency has to be recomputed every time the domain's power on
latency is updated, which may happen every time power is restored
to the domain, if the measured power on latency is greater than
the latency stored in the corresponding generic_pm_domain structure.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Reviewed-by: Kevin Hilman <khilman@ti.com>
2012-07-04 01:07:42 +08:00
|
|
|
if (genpd->cpu_data) {
|
|
|
|
/*
|
|
|
|
* If cpu_data is set, cpuidle should turn the domain off when
|
|
|
|
* the CPU in it is idle. In that case we don't decrement the
|
|
|
|
* subdomain counts of the master domains, so that power is not
|
|
|
|
* removed from the current domain prematurely as a result of
|
|
|
|
* cutting off the masters' power.
|
|
|
|
*/
|
|
|
|
genpd->status = GPD_STATE_POWER_OFF;
|
|
|
|
cpuidle_pause_and_lock();
|
|
|
|
genpd->cpu_data->idle_state->disabled = false;
|
|
|
|
cpuidle_resume_and_unlock();
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-08-09 05:43:14 +08:00
|
|
|
if (genpd->power_off) {
|
2011-12-01 07:02:17 +08:00
|
|
|
ktime_t time_start;
|
|
|
|
s64 elapsed_ns;
|
|
|
|
|
2011-08-09 05:43:14 +08:00
|
|
|
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-12 06:39:36 +08:00
|
|
|
goto out;
|
|
|
|
}
|
2011-07-12 06:39:29 +08:00
|
|
|
|
2011-12-01 07:02:17 +08:00
|
|
|
time_start = ktime_get();
|
|
|
|
|
2011-08-09 05:43:14 +08:00
|
|
|
/*
|
2011-08-09 05:43:40 +08: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-09 05:43:14 +08: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-15 02:59:20 +08:00
|
|
|
ret = genpd->power_off(genpd);
|
|
|
|
if (ret == -EBUSY) {
|
|
|
|
genpd_set_active(genpd);
|
|
|
|
goto out;
|
|
|
|
}
|
2011-12-01 07:02:17 +08:00
|
|
|
|
|
|
|
elapsed_ns = ktime_to_ns(ktime_sub(ktime_get(), time_start));
|
2011-12-07 05:19:54 +08:00
|
|
|
if (elapsed_ns > genpd->power_off_latency_ns) {
|
2011-12-01 07:02:17 +08:00
|
|
|
genpd->power_off_latency_ns = elapsed_ns;
|
PM / Domains: Cache device stop and domain power off governor results, v3
The results of the default device stop and domain power off governor
functions for generic PM domains, default_stop_ok() and
default_power_down_ok(), depend only on the timing data of devices,
which are static, and on their PM QoS constraints. Thus, in theory,
these functions only need to carry out their computations, which may
be time consuming in general, when it is known that the PM QoS
constraint of at least one of the devices in question has changed.
Use the PM QoS notifiers of devices to implement that. First,
introduce new fields, constraint_changed and max_off_time_changed,
into struct gpd_timing_data and struct generic_pm_domain,
respectively, and register a PM QoS notifier function when adding
a device into a domain that will set those fields to 'true' whenever
the device's PM QoS constraint is modified. Second, make
default_stop_ok() and default_power_down_ok() use those fields to
decide whether or not to carry out their computations from scratch.
The device and PM domain hierarchies are taken into account in that
and the expense is that the changes of PM QoS constraints of
suspended devices will not be taken into account immediately, which
isn't guaranteed anyway in general.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-05-02 03:34:07 +08:00
|
|
|
genpd->max_off_time_changed = true;
|
2011-12-07 05:19:54 +08:00
|
|
|
if (genpd->name)
|
|
|
|
pr_warning("%s: Power-off latency exceeded, "
|
|
|
|
"new value %lld ns\n", genpd->name,
|
|
|
|
elapsed_ns);
|
|
|
|
}
|
2011-07-15 02:59:20 +08:00
|
|
|
}
|
2011-07-02 04:12:45 +08:00
|
|
|
|
2011-07-12 06:39:29 +08:00
|
|
|
genpd->status = GPD_STATE_POWER_OFF;
|
2011-12-01 07:02:10 +08:00
|
|
|
|
2011-08-09 05:43:40 +08: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-02 04:12:45 +08: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-12 06:39:36 +08:00
|
|
|
out:
|
|
|
|
genpd->poweroff_task = NULL;
|
|
|
|
wake_up_all(&genpd->status_wait_queue);
|
|
|
|
return ret;
|
2011-07-02 04:12:45 +08: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-12 06:39:29 +08:00
|
|
|
genpd_acquire_lock(genpd);
|
2011-07-02 04:12:45 +08:00
|
|
|
pm_genpd_poweroff(genpd);
|
2011-07-12 06:39:29 +08:00
|
|
|
genpd_release_lock(genpd);
|
2011-07-02 04:12:45 +08: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;
|
2011-12-01 07:02:05 +08:00
|
|
|
bool (*stop_ok)(struct device *__dev);
|
2011-11-27 20:11:36 +08:00
|
|
|
int ret;
|
2011-07-02 04:12:45 +08:00
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
2011-07-02 04:13:10 +08:00
|
|
|
genpd = dev_to_genpd(dev);
|
|
|
|
if (IS_ERR(genpd))
|
2011-07-02 04:12:45 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2011-08-25 21:37:04 +08:00
|
|
|
might_sleep_if(!genpd->dev_irq_safe);
|
|
|
|
|
2011-12-01 07:02:05 +08:00
|
|
|
stop_ok = genpd->gov ? genpd->gov->stop_ok : NULL;
|
|
|
|
if (stop_ok && !stop_ok(dev))
|
|
|
|
return -EBUSY;
|
|
|
|
|
2011-11-27 20:11:36 +08:00
|
|
|
ret = genpd_stop_dev(genpd, dev);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2011-07-12 06:39:29 +08:00
|
|
|
|
2011-08-25 21:37:04 +08:00
|
|
|
/*
|
|
|
|
* If power.irq_safe is set, this routine will be run with interrupts
|
|
|
|
* off, so it can't use mutexes.
|
|
|
|
*/
|
|
|
|
if (dev->power.irq_safe)
|
|
|
|
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-12 06:39:36 +08:00
|
|
|
mutex_lock(&genpd->lock);
|
2011-07-02 04:12:45 +08: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-12 06:39:36 +08:00
|
|
|
mutex_unlock(&genpd->lock);
|
2011-07-02 04:12:45 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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-12 06:39:36 +08:00
|
|
|
DEFINE_WAIT(wait);
|
2011-07-02 04:12:45 +08:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
2011-07-02 04:13:10 +08:00
|
|
|
genpd = dev_to_genpd(dev);
|
|
|
|
if (IS_ERR(genpd))
|
2011-07-02 04:12:45 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2011-08-25 21:37:04 +08:00
|
|
|
might_sleep_if(!genpd->dev_irq_safe);
|
|
|
|
|
|
|
|
/* If power.irq_safe, the PM domain is never powered off. */
|
|
|
|
if (dev->power.irq_safe)
|
2012-08-06 07:47:29 +08:00
|
|
|
return genpd_start_dev_no_timing(genpd, dev);
|
2011-08-25 21:37:04 +08: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-12 06:39:36 +08:00
|
|
|
mutex_lock(&genpd->lock);
|
2011-08-09 05:43:29 +08:00
|
|
|
ret = __pm_genpd_poweron(genpd);
|
|
|
|
if (ret) {
|
|
|
|
mutex_unlock(&genpd->lock);
|
|
|
|
return ret;
|
|
|
|
}
|
2011-07-12 06:39:29 +08: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-12 06:39:36 +08: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-09-27 02:22:02 +08:00
|
|
|
__pm_genpd_restore_device(dev->power.subsys_data->domain_data, 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-12 06:39:36 +08:00
|
|
|
genpd->resume_count--;
|
|
|
|
genpd_set_active(genpd);
|
2011-07-12 06:39:29 +08: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-12 06:39:36 +08:00
|
|
|
mutex_unlock(&genpd->lock);
|
2011-07-12 06:39:29 +08:00
|
|
|
|
2011-07-02 04:12:45 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-08-14 19:34:31 +08: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-02 04:12:45 +08:00
|
|
|
#else
|
|
|
|
|
PM / Domains: Cache device stop and domain power off governor results, v3
The results of the default device stop and domain power off governor
functions for generic PM domains, default_stop_ok() and
default_power_down_ok(), depend only on the timing data of devices,
which are static, and on their PM QoS constraints. Thus, in theory,
these functions only need to carry out their computations, which may
be time consuming in general, when it is known that the PM QoS
constraint of at least one of the devices in question has changed.
Use the PM QoS notifiers of devices to implement that. First,
introduce new fields, constraint_changed and max_off_time_changed,
into struct gpd_timing_data and struct generic_pm_domain,
respectively, and register a PM QoS notifier function when adding
a device into a domain that will set those fields to 'true' whenever
the device's PM QoS constraint is modified. Second, make
default_stop_ok() and default_power_down_ok() use those fields to
decide whether or not to carry out their computations from scratch.
The device and PM domain hierarchies are taken into account in that
and the expense is that the changes of PM QoS constraints of
suspended devices will not be taken into account immediately, which
isn't guaranteed anyway in general.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-05-02 03:34:07 +08:00
|
|
|
static inline int genpd_dev_pm_qos_notifier(struct notifier_block *nb,
|
|
|
|
unsigned long val, void *ptr)
|
|
|
|
{
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
}
|
|
|
|
|
2011-07-02 04:12:45 +08:00
|
|
|
static inline void genpd_power_off_work_fn(struct work_struct *work) {}
|
|
|
|
|
|
|
|
#define pm_genpd_runtime_suspend NULL
|
|
|
|
#define pm_genpd_runtime_resume NULL
|
|
|
|
|
|
|
|
#endif /* CONFIG_PM_RUNTIME */
|
|
|
|
|
2011-07-02 04:13:19 +08:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
|
|
|
2012-08-06 07:39:57 +08:00
|
|
|
/**
|
|
|
|
* pm_genpd_present - Check if the given PM domain has been initialized.
|
|
|
|
* @genpd: PM domain to check.
|
|
|
|
*/
|
|
|
|
static bool pm_genpd_present(struct generic_pm_domain *genpd)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain *gpd;
|
|
|
|
|
|
|
|
if (IS_ERR_OR_NULL(genpd))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
list_for_each_entry(gpd, &gpd_list, gpd_list_node)
|
|
|
|
if (gpd == genpd)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-11-27 20:11:36 +08:00
|
|
|
static bool genpd_dev_active_wakeup(struct generic_pm_domain *genpd,
|
|
|
|
struct device *dev)
|
|
|
|
{
|
|
|
|
return GENPD_DEV_CALLBACK(genpd, bool, active_wakeup, dev);
|
|
|
|
}
|
|
|
|
|
PM / Domains: Rework system suspend callback routines (v2)
The current generic PM domains code attempts to use the generic
system suspend operations along with the domains' device stop/start
routines, which requires device drivers to assume that their
system suspend/resume (and hibernation/restore) callbacks will always
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM domain,
in which case it would be necessary to add "fake" PM domains to
satisfy the above assumption. Also, the domain the hardware belongs
to may not be handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, add new device callbacks,
.suspend(), .suspend_late(), .resume_early(), .resume(), .freeze(),
.freeze_late(), .thaw_early(), and .thaw(), that can be supplied by
the drivers in addition to their "standard" system suspend and
hibernation callbacks. These new callbacks, if defined, will be used
by the generic PM domains code for the handling of system suspend and
hibernation instead of the "standard" ones. This will allow drivers
to be designed to work with generic PM domains as well as without
them.
For backwards compatibility, introduce default implementations of the
new callbacks for PM domains that will execute pm_generic_suspend(),
pm_generic_suspend_noirq(), pm_generic_resume_noirq(),
pm_generic_resume(), pm_generic_freeze(), pm_generic_freeze_noirq(),
pm_generic_thaw_noirq(), and pm_generic_thaw(), respectively, for the
given device if its driver doesn't define those callbacks.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:51 +08:00
|
|
|
static int genpd_suspend_dev(struct generic_pm_domain *genpd, struct device *dev)
|
|
|
|
{
|
|
|
|
return GENPD_DEV_CALLBACK(genpd, int, suspend, dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int genpd_suspend_late(struct generic_pm_domain *genpd, struct device *dev)
|
|
|
|
{
|
|
|
|
return GENPD_DEV_CALLBACK(genpd, int, suspend_late, dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int genpd_resume_early(struct generic_pm_domain *genpd, struct device *dev)
|
|
|
|
{
|
|
|
|
return GENPD_DEV_CALLBACK(genpd, int, resume_early, dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int genpd_resume_dev(struct generic_pm_domain *genpd, struct device *dev)
|
|
|
|
{
|
|
|
|
return GENPD_DEV_CALLBACK(genpd, int, resume, dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int genpd_freeze_dev(struct generic_pm_domain *genpd, struct device *dev)
|
|
|
|
{
|
|
|
|
return GENPD_DEV_CALLBACK(genpd, int, freeze, dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int genpd_freeze_late(struct generic_pm_domain *genpd, struct device *dev)
|
|
|
|
{
|
|
|
|
return GENPD_DEV_CALLBACK(genpd, int, freeze_late, dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int genpd_thaw_early(struct generic_pm_domain *genpd, struct device *dev)
|
|
|
|
{
|
|
|
|
return GENPD_DEV_CALLBACK(genpd, int, thaw_early, dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int genpd_thaw_dev(struct generic_pm_domain *genpd, struct device *dev)
|
|
|
|
{
|
|
|
|
return GENPD_DEV_CALLBACK(genpd, int, thaw, dev);
|
|
|
|
}
|
|
|
|
|
2011-07-02 04:13:19 +08:00
|
|
|
/**
|
2011-08-09 05:43:40 +08:00
|
|
|
* pm_genpd_sync_poweroff - Synchronously power off a PM domain and its masters.
|
2011-07-02 04:13:19 +08: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-09 05:43:40 +08:00
|
|
|
* hibernation) and do that if so. Also, in that case propagate to its masters.
|
2011-07-02 04:13:19 +08:00
|
|
|
*
|
2012-08-06 07:39:57 +08:00
|
|
|
* This function is only called in "noirq" and "syscore" 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).
|
2011-07-02 04:13:19 +08:00
|
|
|
*/
|
|
|
|
static void pm_genpd_sync_poweroff(struct generic_pm_domain *genpd)
|
|
|
|
{
|
2011-08-09 05:43:40 +08:00
|
|
|
struct gpd_link *link;
|
2011-07-02 04:13:19 +08:00
|
|
|
|
2011-07-12 06:39:29 +08:00
|
|
|
if (genpd->status == GPD_STATE_POWER_OFF)
|
2011-07-02 04:13:19 +08:00
|
|
|
return;
|
|
|
|
|
2011-08-09 05:43:04 +08:00
|
|
|
if (genpd->suspended_count != genpd->device_count
|
|
|
|
|| atomic_read(&genpd->sd_count) > 0)
|
2011-07-02 04:13:19 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
if (genpd->power_off)
|
|
|
|
genpd->power_off(genpd);
|
|
|
|
|
2011-07-12 06:39:29 +08:00
|
|
|
genpd->status = GPD_STATE_POWER_OFF;
|
2011-08-09 05:43:40 +08: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-02 04:13:19 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-06 07:39:16 +08:00
|
|
|
/**
|
|
|
|
* pm_genpd_sync_poweron - Synchronously power on a PM domain and its masters.
|
|
|
|
* @genpd: PM domain to power on.
|
|
|
|
*
|
2012-08-06 07:39:57 +08:00
|
|
|
* This function is only called in "noirq" and "syscore" 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).
|
2012-08-06 07:39:16 +08:00
|
|
|
*/
|
|
|
|
static void pm_genpd_sync_poweron(struct generic_pm_domain *genpd)
|
|
|
|
{
|
|
|
|
struct gpd_link *link;
|
|
|
|
|
|
|
|
if (genpd->status != GPD_STATE_POWER_OFF)
|
|
|
|
return;
|
|
|
|
|
|
|
|
list_for_each_entry(link, &genpd->slave_links, slave_node) {
|
|
|
|
pm_genpd_sync_poweron(link->master);
|
|
|
|
genpd_sd_counter_inc(link->master);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (genpd->power_on)
|
|
|
|
genpd->power_on(genpd);
|
|
|
|
|
|
|
|
genpd->status = GPD_STATE_ACTIVE;
|
|
|
|
}
|
|
|
|
|
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-12 06:39:57 +08: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;
|
|
|
|
|
2011-11-27 20:11:36 +08:00
|
|
|
active_wakeup = genpd_dev_active_wakeup(genpd, dev);
|
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-12 06:39:57 +08:00
|
|
|
return device_may_wakeup(dev) ? active_wakeup : !active_wakeup;
|
|
|
|
}
|
|
|
|
|
2011-07-02 04:13:19 +08: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-12 06:39:21 +08:00
|
|
|
int ret;
|
2011-07-02 04:13:19 +08:00
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
|
|
|
genpd = dev_to_genpd(dev);
|
|
|
|
if (IS_ERR(genpd))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-07-12 06:39:29 +08: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-12 06:39:57 +08:00
|
|
|
if (resume_needed(dev, genpd))
|
|
|
|
pm_runtime_resume(dev);
|
|
|
|
|
2011-07-12 06:39:29 +08:00
|
|
|
genpd_acquire_lock(genpd);
|
2011-07-02 04:13:19 +08:00
|
|
|
|
2012-03-14 05:39:37 +08:00
|
|
|
if (genpd->prepared_count++ == 0) {
|
|
|
|
genpd->suspended_count = 0;
|
2011-07-12 06:39:29 +08:00
|
|
|
genpd->suspend_power_off = genpd->status == GPD_STATE_POWER_OFF;
|
2012-03-14 05:39:37 +08:00
|
|
|
}
|
2011-07-12 06:39:29 +08:00
|
|
|
|
|
|
|
genpd_release_lock(genpd);
|
2011-07-02 04:13:19 +08:00
|
|
|
|
|
|
|
if (genpd->suspend_power_off) {
|
2011-07-12 06:39:29 +08:00
|
|
|
pm_runtime_put_noidle(dev);
|
2011-07-02 04:13:19 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2011-07-12 06:39:29 +08: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
|
2011-11-27 20:11:36 +08:00
|
|
|
* is suspended (e.g. it's been stopped by genpd_stop_dev()), we need
|
2011-07-12 06:39:29 +08:00
|
|
|
* to make it operational.
|
2011-07-02 04:13:19 +08:00
|
|
|
*/
|
2011-07-12 06:39:29 +08:00
|
|
|
pm_runtime_resume(dev);
|
2011-07-02 04:13:19 +08:00
|
|
|
__pm_runtime_disable(dev, false);
|
|
|
|
|
2011-07-12 06:39:21 +08: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-12 06:39:29 +08:00
|
|
|
pm_runtime_enable(dev);
|
2011-07-12 06:39:21 +08:00
|
|
|
}
|
2011-07-12 06:39:29 +08:00
|
|
|
|
|
|
|
pm_runtime_put_sync(dev);
|
2011-07-12 06:39:21 +08:00
|
|
|
return ret;
|
2011-07-02 04:13:19 +08: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;
|
|
|
|
|
PM / Domains: Rework system suspend callback routines (v2)
The current generic PM domains code attempts to use the generic
system suspend operations along with the domains' device stop/start
routines, which requires device drivers to assume that their
system suspend/resume (and hibernation/restore) callbacks will always
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM domain,
in which case it would be necessary to add "fake" PM domains to
satisfy the above assumption. Also, the domain the hardware belongs
to may not be handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, add new device callbacks,
.suspend(), .suspend_late(), .resume_early(), .resume(), .freeze(),
.freeze_late(), .thaw_early(), and .thaw(), that can be supplied by
the drivers in addition to their "standard" system suspend and
hibernation callbacks. These new callbacks, if defined, will be used
by the generic PM domains code for the handling of system suspend and
hibernation instead of the "standard" ones. This will allow drivers
to be designed to work with generic PM domains as well as without
them.
For backwards compatibility, introduce default implementations of the
new callbacks for PM domains that will execute pm_generic_suspend(),
pm_generic_suspend_noirq(), pm_generic_resume_noirq(),
pm_generic_resume(), pm_generic_freeze(), pm_generic_freeze_noirq(),
pm_generic_thaw_noirq(), and pm_generic_thaw(), respectively, for the
given device if its driver doesn't define those callbacks.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:51 +08:00
|
|
|
return genpd->suspend_power_off ? 0 : genpd_suspend_dev(genpd, dev);
|
2011-07-02 04:13:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2012-01-30 03:39:02 +08:00
|
|
|
* pm_genpd_suspend_late - Late suspend of a device from an I/O PM domain.
|
2011-07-02 04:13:19 +08:00
|
|
|
* @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.
|
|
|
|
*/
|
2012-01-30 03:39:02 +08:00
|
|
|
static int pm_genpd_suspend_late(struct device *dev)
|
2011-07-02 04:13:19 +08:00
|
|
|
{
|
|
|
|
struct generic_pm_domain *genpd;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
|
|
|
genpd = dev_to_genpd(dev);
|
|
|
|
if (IS_ERR(genpd))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-01-30 03:39:02 +08:00
|
|
|
return genpd->suspend_power_off ? 0 : genpd_suspend_late(genpd, dev);
|
|
|
|
}
|
2011-07-02 04:13:19 +08:00
|
|
|
|
2012-01-30 03:39:02 +08:00
|
|
|
/**
|
|
|
|
* pm_genpd_suspend_noirq - Completion of suspend of device in an I/O PM domain.
|
|
|
|
* @dev: Device to suspend.
|
|
|
|
*
|
|
|
|
* Stop the device and remove power from the domain if all devices in it have
|
|
|
|
* been stopped.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_suspend_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;
|
2011-07-02 04:13:19 +08:00
|
|
|
|
2012-08-06 07:46:39 +08:00
|
|
|
if (genpd->suspend_power_off
|
2012-01-30 03:39:02 +08:00
|
|
|
|| (dev->power.wakeup_path && genpd_dev_active_wakeup(genpd, dev)))
|
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-02 04:13:29 +08:00
|
|
|
return 0;
|
|
|
|
|
2011-11-27 20:11:36 +08:00
|
|
|
genpd_stop_dev(genpd, dev);
|
2011-07-02 04:13:19 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2012-01-30 03:39:02 +08:00
|
|
|
* pm_genpd_resume_noirq - Start of resume of device in an I/O PM domain.
|
2011-07-02 04:13:19 +08:00
|
|
|
* @dev: Device to resume.
|
|
|
|
*
|
2012-01-30 03:39:02 +08:00
|
|
|
* Restore power to the device's PM domain, if necessary, and start the device.
|
2011-07-02 04:13:19 +08:00
|
|
|
*/
|
|
|
|
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;
|
|
|
|
|
2012-08-06 07:46:39 +08:00
|
|
|
if (genpd->suspend_power_off
|
2012-03-14 05:39:31 +08:00
|
|
|
|| (dev->power.wakeup_path && genpd_dev_active_wakeup(genpd, dev)))
|
2011-07-02 04:13:19 +08:00
|
|
|
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.
|
|
|
|
*/
|
2012-08-06 07:39:16 +08:00
|
|
|
pm_genpd_sync_poweron(genpd);
|
2011-07-02 04:13:19 +08:00
|
|
|
genpd->suspended_count--;
|
|
|
|
|
2012-01-30 03:39:02 +08:00
|
|
|
return genpd_start_dev(genpd, dev);
|
2011-07-02 04:13:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2012-01-30 03:39:02 +08:00
|
|
|
* pm_genpd_resume_early - Early resume of a device in an I/O PM 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_early(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 : genpd_resume_early(genpd, dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_resume - Resume of device in an I/O PM domain.
|
2011-07-02 04:13:19 +08:00
|
|
|
* @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;
|
|
|
|
|
PM / Domains: Rework system suspend callback routines (v2)
The current generic PM domains code attempts to use the generic
system suspend operations along with the domains' device stop/start
routines, which requires device drivers to assume that their
system suspend/resume (and hibernation/restore) callbacks will always
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM domain,
in which case it would be necessary to add "fake" PM domains to
satisfy the above assumption. Also, the domain the hardware belongs
to may not be handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, add new device callbacks,
.suspend(), .suspend_late(), .resume_early(), .resume(), .freeze(),
.freeze_late(), .thaw_early(), and .thaw(), that can be supplied by
the drivers in addition to their "standard" system suspend and
hibernation callbacks. These new callbacks, if defined, will be used
by the generic PM domains code for the handling of system suspend and
hibernation instead of the "standard" ones. This will allow drivers
to be designed to work with generic PM domains as well as without
them.
For backwards compatibility, introduce default implementations of the
new callbacks for PM domains that will execute pm_generic_suspend(),
pm_generic_suspend_noirq(), pm_generic_resume_noirq(),
pm_generic_resume(), pm_generic_freeze(), pm_generic_freeze_noirq(),
pm_generic_thaw_noirq(), and pm_generic_thaw(), respectively, for the
given device if its driver doesn't define those callbacks.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:51 +08:00
|
|
|
return genpd->suspend_power_off ? 0 : genpd_resume_dev(genpd, dev);
|
2011-07-02 04:13:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2012-01-30 03:39:02 +08:00
|
|
|
* pm_genpd_freeze - Freezing a device in an I/O PM domain.
|
2011-07-02 04:13:19 +08:00
|
|
|
* @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;
|
|
|
|
|
PM / Domains: Rework system suspend callback routines (v2)
The current generic PM domains code attempts to use the generic
system suspend operations along with the domains' device stop/start
routines, which requires device drivers to assume that their
system suspend/resume (and hibernation/restore) callbacks will always
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM domain,
in which case it would be necessary to add "fake" PM domains to
satisfy the above assumption. Also, the domain the hardware belongs
to may not be handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, add new device callbacks,
.suspend(), .suspend_late(), .resume_early(), .resume(), .freeze(),
.freeze_late(), .thaw_early(), and .thaw(), that can be supplied by
the drivers in addition to their "standard" system suspend and
hibernation callbacks. These new callbacks, if defined, will be used
by the generic PM domains code for the handling of system suspend and
hibernation instead of the "standard" ones. This will allow drivers
to be designed to work with generic PM domains as well as without
them.
For backwards compatibility, introduce default implementations of the
new callbacks for PM domains that will execute pm_generic_suspend(),
pm_generic_suspend_noirq(), pm_generic_resume_noirq(),
pm_generic_resume(), pm_generic_freeze(), pm_generic_freeze_noirq(),
pm_generic_thaw_noirq(), and pm_generic_thaw(), respectively, for the
given device if its driver doesn't define those callbacks.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:51 +08:00
|
|
|
return genpd->suspend_power_off ? 0 : genpd_freeze_dev(genpd, dev);
|
2011-07-02 04:13:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2012-01-30 03:39:02 +08:00
|
|
|
* pm_genpd_freeze_late - Late freeze of a device in an I/O PM 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_late(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 : genpd_freeze_late(genpd, dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_freeze_noirq - Completion of freezing a device in an I/O PM domain.
|
2011-07-02 04:13:19 +08:00
|
|
|
* @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;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
|
|
|
genpd = dev_to_genpd(dev);
|
|
|
|
if (IS_ERR(genpd))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-08-06 07:46:39 +08:00
|
|
|
return genpd->suspend_power_off ? 0 : genpd_stop_dev(genpd, dev);
|
2012-01-30 03:39:02 +08:00
|
|
|
}
|
2011-07-02 04:13:19 +08:00
|
|
|
|
2012-01-30 03:39:02 +08:00
|
|
|
/**
|
|
|
|
* pm_genpd_thaw_noirq - Early thaw of device in an I/O PM domain.
|
|
|
|
* @dev: Device to thaw.
|
|
|
|
*
|
|
|
|
* Start the device, unless power has been removed from the domain already
|
|
|
|
* before the system transition.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_thaw_noirq(struct device *dev)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain *genpd;
|
2011-07-02 04:13:19 +08:00
|
|
|
|
2012-01-30 03:39:02 +08:00
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
2011-07-02 04:13:19 +08:00
|
|
|
|
2012-01-30 03:39:02 +08:00
|
|
|
genpd = dev_to_genpd(dev);
|
|
|
|
if (IS_ERR(genpd))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-08-06 07:46:39 +08:00
|
|
|
return genpd->suspend_power_off ? 0 : genpd_start_dev(genpd, dev);
|
2011-07-02 04:13:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2012-01-30 03:39:02 +08:00
|
|
|
* pm_genpd_thaw_early - Early thaw of device in an I/O PM domain.
|
2011-07-02 04:13:19 +08:00
|
|
|
* @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.
|
|
|
|
*/
|
2012-01-30 03:39:02 +08:00
|
|
|
static int pm_genpd_thaw_early(struct device *dev)
|
2011-07-02 04:13:19 +08:00
|
|
|
{
|
|
|
|
struct generic_pm_domain *genpd;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
|
|
|
genpd = dev_to_genpd(dev);
|
|
|
|
if (IS_ERR(genpd))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-01-30 03:39:02 +08:00
|
|
|
return genpd->suspend_power_off ? 0 : genpd_thaw_early(genpd, dev);
|
2011-07-02 04:13:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
|
PM / Domains: Rework system suspend callback routines (v2)
The current generic PM domains code attempts to use the generic
system suspend operations along with the domains' device stop/start
routines, which requires device drivers to assume that their
system suspend/resume (and hibernation/restore) callbacks will always
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM domain,
in which case it would be necessary to add "fake" PM domains to
satisfy the above assumption. Also, the domain the hardware belongs
to may not be handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, add new device callbacks,
.suspend(), .suspend_late(), .resume_early(), .resume(), .freeze(),
.freeze_late(), .thaw_early(), and .thaw(), that can be supplied by
the drivers in addition to their "standard" system suspend and
hibernation callbacks. These new callbacks, if defined, will be used
by the generic PM domains code for the handling of system suspend and
hibernation instead of the "standard" ones. This will allow drivers
to be designed to work with generic PM domains as well as without
them.
For backwards compatibility, introduce default implementations of the
new callbacks for PM domains that will execute pm_generic_suspend(),
pm_generic_suspend_noirq(), pm_generic_resume_noirq(),
pm_generic_resume(), pm_generic_freeze(), pm_generic_freeze_noirq(),
pm_generic_thaw_noirq(), and pm_generic_thaw(), respectively, for the
given device if its driver doesn't define those callbacks.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:51 +08:00
|
|
|
return genpd->suspend_power_off ? 0 : genpd_thaw_dev(genpd, dev);
|
2011-07-02 04:13:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2012-01-30 03:39:02 +08:00
|
|
|
* pm_genpd_restore_noirq - Start of restore of device in an I/O PM domain.
|
2011-07-02 04:13:19 +08:00
|
|
|
* @dev: Device to resume.
|
|
|
|
*
|
2012-01-30 03:39:02 +08:00
|
|
|
* Make sure the domain will be in the same power state as before the
|
|
|
|
* hibernation the system is resuming from and start the device if necessary.
|
2011-07-02 04:13:19 +08:00
|
|
|
*/
|
|
|
|
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.
|
2012-03-14 05:39:37 +08:00
|
|
|
*
|
|
|
|
* At this point suspended_count == 0 means we are being run for the
|
|
|
|
* first time for the given domain in the present cycle.
|
2011-07-02 04:13:19 +08:00
|
|
|
*/
|
2012-03-14 05:39:37 +08:00
|
|
|
if (genpd->suspended_count++ == 0) {
|
2011-07-02 04:13:19 +08:00
|
|
|
/*
|
2012-03-14 05:39:37 +08:00
|
|
|
* The boot kernel might put the domain into arbitrary state,
|
2012-08-06 07:39:16 +08:00
|
|
|
* so make it appear as powered off to pm_genpd_sync_poweron(),
|
|
|
|
* so that it tries to power it on in case it was really off.
|
2011-07-02 04:13:19 +08:00
|
|
|
*/
|
2012-03-14 05:39:37 +08:00
|
|
|
genpd->status = GPD_STATE_POWER_OFF;
|
|
|
|
if (genpd->suspend_power_off) {
|
|
|
|
/*
|
|
|
|
* If the domain was off before the hibernation, make
|
|
|
|
* sure it will be off going forward.
|
|
|
|
*/
|
|
|
|
if (genpd->power_off)
|
|
|
|
genpd->power_off(genpd);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2011-07-02 04:13:19 +08:00
|
|
|
}
|
|
|
|
|
2012-03-19 17:38:14 +08:00
|
|
|
if (genpd->suspend_power_off)
|
|
|
|
return 0;
|
|
|
|
|
2012-08-06 07:39:16 +08:00
|
|
|
pm_genpd_sync_poweron(genpd);
|
2011-07-02 04:13:19 +08:00
|
|
|
|
2012-08-06 07:46:39 +08:00
|
|
|
return genpd_start_dev(genpd, dev);
|
2011-07-02 04:13:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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-12 06:39:10 +08:00
|
|
|
pm_runtime_set_active(dev);
|
2011-07-02 04:13:19 +08:00
|
|
|
pm_runtime_enable(dev);
|
2011-07-12 06:39:10 +08:00
|
|
|
pm_runtime_idle(dev);
|
2011-07-02 04:13:19 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-06 07:39:57 +08:00
|
|
|
/**
|
|
|
|
* pm_genpd_syscore_switch - Switch power during system core suspend or resume.
|
|
|
|
* @dev: Device that normally is marked as "always on" to switch power for.
|
|
|
|
*
|
|
|
|
* This routine may only be called during the system core (syscore) suspend or
|
|
|
|
* resume phase for devices whose "always on" flags are set.
|
|
|
|
*/
|
|
|
|
void pm_genpd_syscore_switch(struct device *dev, bool suspend)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain *genpd;
|
|
|
|
|
|
|
|
genpd = dev_to_genpd(dev);
|
|
|
|
if (!pm_genpd_present(genpd))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (suspend) {
|
|
|
|
genpd->suspended_count++;
|
|
|
|
pm_genpd_sync_poweroff(genpd);
|
|
|
|
} else {
|
|
|
|
pm_genpd_sync_poweron(genpd);
|
|
|
|
genpd->suspended_count--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(pm_genpd_syscore_switch);
|
|
|
|
|
2011-07-02 04:13:19 +08:00
|
|
|
#else
|
|
|
|
|
|
|
|
#define pm_genpd_prepare NULL
|
|
|
|
#define pm_genpd_suspend NULL
|
2012-01-30 03:39:02 +08:00
|
|
|
#define pm_genpd_suspend_late NULL
|
2011-07-02 04:13:19 +08:00
|
|
|
#define pm_genpd_suspend_noirq NULL
|
2012-01-30 03:39:02 +08:00
|
|
|
#define pm_genpd_resume_early NULL
|
2011-07-02 04:13:19 +08:00
|
|
|
#define pm_genpd_resume_noirq NULL
|
|
|
|
#define pm_genpd_resume NULL
|
|
|
|
#define pm_genpd_freeze NULL
|
2012-01-30 03:39:02 +08:00
|
|
|
#define pm_genpd_freeze_late NULL
|
2011-07-02 04:13:19 +08:00
|
|
|
#define pm_genpd_freeze_noirq NULL
|
2012-01-30 03:39:02 +08:00
|
|
|
#define pm_genpd_thaw_early NULL
|
2011-07-02 04:13:19 +08:00
|
|
|
#define pm_genpd_thaw_noirq NULL
|
|
|
|
#define pm_genpd_thaw NULL
|
|
|
|
#define pm_genpd_restore_noirq NULL
|
|
|
|
#define pm_genpd_complete NULL
|
|
|
|
|
|
|
|
#endif /* CONFIG_PM_SLEEP */
|
|
|
|
|
2012-07-06 04:12:32 +08:00
|
|
|
static struct generic_pm_domain_data *__pm_genpd_alloc_dev_data(struct device *dev)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain_data *gpd_data;
|
|
|
|
|
|
|
|
gpd_data = kzalloc(sizeof(*gpd_data), GFP_KERNEL);
|
|
|
|
if (!gpd_data)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
mutex_init(&gpd_data->lock);
|
|
|
|
gpd_data->nb.notifier_call = genpd_dev_pm_qos_notifier;
|
|
|
|
dev_pm_qos_add_notifier(dev, &gpd_data->nb);
|
|
|
|
return gpd_data;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __pm_genpd_free_dev_data(struct device *dev,
|
|
|
|
struct generic_pm_domain_data *gpd_data)
|
|
|
|
{
|
|
|
|
dev_pm_qos_remove_notifier(dev, &gpd_data->nb);
|
|
|
|
kfree(gpd_data);
|
|
|
|
}
|
|
|
|
|
2011-07-02 04:12:45 +08:00
|
|
|
/**
|
2011-12-01 07:02:05 +08:00
|
|
|
* __pm_genpd_add_device - Add a device to an I/O PM domain.
|
2011-07-02 04:12:45 +08:00
|
|
|
* @genpd: PM domain to add the device to.
|
|
|
|
* @dev: Device to be added.
|
2011-12-01 07:02:05 +08:00
|
|
|
* @td: Set of PM QoS timing parameters to attach to the device.
|
2011-07-02 04:12:45 +08:00
|
|
|
*/
|
2011-12-01 07:02:05 +08:00
|
|
|
int __pm_genpd_add_device(struct generic_pm_domain *genpd, struct device *dev,
|
|
|
|
struct gpd_timing_data *td)
|
2011-07-02 04:12:45 +08:00
|
|
|
{
|
2012-07-06 04:12:32 +08:00
|
|
|
struct generic_pm_domain_data *gpd_data_new, *gpd_data = NULL;
|
2011-08-25 21:34:12 +08:00
|
|
|
struct pm_domain_data *pdd;
|
2011-07-02 04:12:45 +08:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
|
|
|
if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-07-06 04:12:32 +08:00
|
|
|
gpd_data_new = __pm_genpd_alloc_dev_data(dev);
|
|
|
|
if (!gpd_data_new)
|
PM / Domains: Cache device stop and domain power off governor results, v3
The results of the default device stop and domain power off governor
functions for generic PM domains, default_stop_ok() and
default_power_down_ok(), depend only on the timing data of devices,
which are static, and on their PM QoS constraints. Thus, in theory,
these functions only need to carry out their computations, which may
be time consuming in general, when it is known that the PM QoS
constraint of at least one of the devices in question has changed.
Use the PM QoS notifiers of devices to implement that. First,
introduce new fields, constraint_changed and max_off_time_changed,
into struct gpd_timing_data and struct generic_pm_domain,
respectively, and register a PM QoS notifier function when adding
a device into a domain that will set those fields to 'true' whenever
the device's PM QoS constraint is modified. Second, make
default_stop_ok() and default_power_down_ok() use those fields to
decide whether or not to carry out their computations from scratch.
The device and PM domain hierarchies are taken into account in that
and the expense is that the changes of PM QoS constraints of
suspended devices will not be taken into account immediately, which
isn't guaranteed anyway in general.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-05-02 03:34:07 +08:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2011-07-12 06:39:29 +08:00
|
|
|
genpd_acquire_lock(genpd);
|
2011-07-02 04:12:45 +08:00
|
|
|
|
2011-07-02 04:13:19 +08:00
|
|
|
if (genpd->prepared_count > 0) {
|
|
|
|
ret = -EAGAIN;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-08-25 21:34:12 +08:00
|
|
|
list_for_each_entry(pdd, &genpd->dev_list, list_node)
|
|
|
|
if (pdd->dev == dev) {
|
2011-07-02 04:12:45 +08:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2012-07-06 04:12:32 +08:00
|
|
|
ret = dev_pm_get_subsys_data(dev);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
2011-07-02 04:13:19 +08:00
|
|
|
genpd->device_count++;
|
PM / Domains: Cache device stop and domain power off governor results, v3
The results of the default device stop and domain power off governor
functions for generic PM domains, default_stop_ok() and
default_power_down_ok(), depend only on the timing data of devices,
which are static, and on their PM QoS constraints. Thus, in theory,
these functions only need to carry out their computations, which may
be time consuming in general, when it is known that the PM QoS
constraint of at least one of the devices in question has changed.
Use the PM QoS notifiers of devices to implement that. First,
introduce new fields, constraint_changed and max_off_time_changed,
into struct gpd_timing_data and struct generic_pm_domain,
respectively, and register a PM QoS notifier function when adding
a device into a domain that will set those fields to 'true' whenever
the device's PM QoS constraint is modified. Second, make
default_stop_ok() and default_power_down_ok() use those fields to
decide whether or not to carry out their computations from scratch.
The device and PM domain hierarchies are taken into account in that
and the expense is that the changes of PM QoS constraints of
suspended devices will not be taken into account immediately, which
isn't guaranteed anyway in general.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-05-02 03:34:07 +08:00
|
|
|
genpd->max_off_time_changed = true;
|
2011-07-02 04:12:45 +08:00
|
|
|
|
PM / Domains: Cache device stop and domain power off governor results, v3
The results of the default device stop and domain power off governor
functions for generic PM domains, default_stop_ok() and
default_power_down_ok(), depend only on the timing data of devices,
which are static, and on their PM QoS constraints. Thus, in theory,
these functions only need to carry out their computations, which may
be time consuming in general, when it is known that the PM QoS
constraint of at least one of the devices in question has changed.
Use the PM QoS notifiers of devices to implement that. First,
introduce new fields, constraint_changed and max_off_time_changed,
into struct gpd_timing_data and struct generic_pm_domain,
respectively, and register a PM QoS notifier function when adding
a device into a domain that will set those fields to 'true' whenever
the device's PM QoS constraint is modified. Second, make
default_stop_ok() and default_power_down_ok() use those fields to
decide whether or not to carry out their computations from scratch.
The device and PM domain hierarchies are taken into account in that
and the expense is that the changes of PM QoS constraints of
suspended devices will not be taken into account immediately, which
isn't guaranteed anyway in general.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-05-02 03:34:07 +08:00
|
|
|
spin_lock_irq(&dev->power.lock);
|
2012-07-06 04:12:32 +08:00
|
|
|
|
PM / Domains: Cache device stop and domain power off governor results, v3
The results of the default device stop and domain power off governor
functions for generic PM domains, default_stop_ok() and
default_power_down_ok(), depend only on the timing data of devices,
which are static, and on their PM QoS constraints. Thus, in theory,
these functions only need to carry out their computations, which may
be time consuming in general, when it is known that the PM QoS
constraint of at least one of the devices in question has changed.
Use the PM QoS notifiers of devices to implement that. First,
introduce new fields, constraint_changed and max_off_time_changed,
into struct gpd_timing_data and struct generic_pm_domain,
respectively, and register a PM QoS notifier function when adding
a device into a domain that will set those fields to 'true' whenever
the device's PM QoS constraint is modified. Second, make
default_stop_ok() and default_power_down_ok() use those fields to
decide whether or not to carry out their computations from scratch.
The device and PM domain hierarchies are taken into account in that
and the expense is that the changes of PM QoS constraints of
suspended devices will not be taken into account immediately, which
isn't guaranteed anyway in general.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-05-02 03:34:07 +08:00
|
|
|
dev->pm_domain = &genpd->domain;
|
2012-07-06 04:12:32 +08:00
|
|
|
if (dev->power.subsys_data->domain_data) {
|
|
|
|
gpd_data = to_gpd_data(dev->power.subsys_data->domain_data);
|
|
|
|
} else {
|
|
|
|
gpd_data = gpd_data_new;
|
|
|
|
dev->power.subsys_data->domain_data = &gpd_data->base;
|
|
|
|
}
|
|
|
|
gpd_data->refcount++;
|
2011-12-01 07:02:05 +08:00
|
|
|
if (td)
|
|
|
|
gpd_data->td = *td;
|
2011-07-02 04:12:45 +08:00
|
|
|
|
2012-07-06 04:12:32 +08:00
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
|
|
|
|
mutex_lock(&gpd_data->lock);
|
|
|
|
gpd_data->base.dev = dev;
|
|
|
|
list_add_tail(&gpd_data->base.list_node, &genpd->dev_list);
|
|
|
|
gpd_data->need_restore = genpd->status == GPD_STATE_POWER_OFF;
|
PM / Domains: Cache device stop and domain power off governor results, v3
The results of the default device stop and domain power off governor
functions for generic PM domains, default_stop_ok() and
default_power_down_ok(), depend only on the timing data of devices,
which are static, and on their PM QoS constraints. Thus, in theory,
these functions only need to carry out their computations, which may
be time consuming in general, when it is known that the PM QoS
constraint of at least one of the devices in question has changed.
Use the PM QoS notifiers of devices to implement that. First,
introduce new fields, constraint_changed and max_off_time_changed,
into struct gpd_timing_data and struct generic_pm_domain,
respectively, and register a PM QoS notifier function when adding
a device into a domain that will set those fields to 'true' whenever
the device's PM QoS constraint is modified. Second, make
default_stop_ok() and default_power_down_ok() use those fields to
decide whether or not to carry out their computations from scratch.
The device and PM domain hierarchies are taken into account in that
and the expense is that the changes of PM QoS constraints of
suspended devices will not be taken into account immediately, which
isn't guaranteed anyway in general.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-05-02 03:34:07 +08:00
|
|
|
gpd_data->td.constraint_changed = true;
|
|
|
|
gpd_data->td.effective_constraint_ns = -1;
|
|
|
|
mutex_unlock(&gpd_data->lock);
|
|
|
|
|
2011-07-02 04:12:45 +08:00
|
|
|
out:
|
2011-07-12 06:39:29 +08:00
|
|
|
genpd_release_lock(genpd);
|
2011-07-02 04:12:45 +08:00
|
|
|
|
2012-07-06 04:12:32 +08:00
|
|
|
if (gpd_data != gpd_data_new)
|
|
|
|
__pm_genpd_free_dev_data(dev, gpd_data_new);
|
|
|
|
|
2011-07-02 04:12:45 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-01-27 14:22:07 +08:00
|
|
|
/**
|
|
|
|
* __pm_genpd_of_add_device - Add a device to an I/O PM domain.
|
|
|
|
* @genpd_node: Device tree node pointer representing a PM domain to which the
|
|
|
|
* the device is added to.
|
|
|
|
* @dev: Device to be added.
|
|
|
|
* @td: Set of PM QoS timing parameters to attach to the device.
|
|
|
|
*/
|
|
|
|
int __pm_genpd_of_add_device(struct device_node *genpd_node, struct device *dev,
|
|
|
|
struct gpd_timing_data *td)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain *genpd = NULL, *gpd;
|
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
|
|
|
if (IS_ERR_OR_NULL(genpd_node) || IS_ERR_OR_NULL(dev))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
mutex_lock(&gpd_list_lock);
|
|
|
|
list_for_each_entry(gpd, &gpd_list, gpd_list_node) {
|
|
|
|
if (gpd->of_node == genpd_node) {
|
|
|
|
genpd = gpd;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mutex_unlock(&gpd_list_lock);
|
|
|
|
|
|
|
|
if (!genpd)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return __pm_genpd_add_device(genpd, dev, td);
|
|
|
|
}
|
|
|
|
|
2012-08-07 07:06:11 +08:00
|
|
|
|
|
|
|
/**
|
|
|
|
* __pm_genpd_name_add_device - Find I/O PM domain and add a device to it.
|
|
|
|
* @domain_name: Name of the PM domain to add the device to.
|
|
|
|
* @dev: Device to be added.
|
|
|
|
* @td: Set of PM QoS timing parameters to attach to the device.
|
|
|
|
*/
|
|
|
|
int __pm_genpd_name_add_device(const char *domain_name, struct device *dev,
|
|
|
|
struct gpd_timing_data *td)
|
|
|
|
{
|
2012-08-07 07:11:14 +08:00
|
|
|
return __pm_genpd_add_device(pm_genpd_lookup_name(domain_name), dev, td);
|
2012-08-07 07:06:11 +08:00
|
|
|
}
|
|
|
|
|
2011-07-02 04:12:45 +08:00
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
PM / Domains: Cache device stop and domain power off governor results, v3
The results of the default device stop and domain power off governor
functions for generic PM domains, default_stop_ok() and
default_power_down_ok(), depend only on the timing data of devices,
which are static, and on their PM QoS constraints. Thus, in theory,
these functions only need to carry out their computations, which may
be time consuming in general, when it is known that the PM QoS
constraint of at least one of the devices in question has changed.
Use the PM QoS notifiers of devices to implement that. First,
introduce new fields, constraint_changed and max_off_time_changed,
into struct gpd_timing_data and struct generic_pm_domain,
respectively, and register a PM QoS notifier function when adding
a device into a domain that will set those fields to 'true' whenever
the device's PM QoS constraint is modified. Second, make
default_stop_ok() and default_power_down_ok() use those fields to
decide whether or not to carry out their computations from scratch.
The device and PM domain hierarchies are taken into account in that
and the expense is that the changes of PM QoS constraints of
suspended devices will not be taken into account immediately, which
isn't guaranteed anyway in general.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-05-02 03:34:07 +08:00
|
|
|
struct generic_pm_domain_data *gpd_data;
|
2011-08-25 21:34:12 +08:00
|
|
|
struct pm_domain_data *pdd;
|
2012-07-06 04:12:32 +08:00
|
|
|
bool remove = false;
|
2012-05-02 03:33:53 +08:00
|
|
|
int ret = 0;
|
2011-07-02 04:12:45 +08:00
|
|
|
|
|
|
|
dev_dbg(dev, "%s()\n", __func__);
|
|
|
|
|
2012-05-02 03:33:53 +08:00
|
|
|
if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev)
|
|
|
|
|| IS_ERR_OR_NULL(dev->pm_domain)
|
|
|
|
|| pd_to_genpd(dev->pm_domain) != genpd)
|
2011-07-02 04:12:45 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2011-07-12 06:39:29 +08:00
|
|
|
genpd_acquire_lock(genpd);
|
2011-07-02 04:12:45 +08:00
|
|
|
|
2011-07-02 04:13:19 +08:00
|
|
|
if (genpd->prepared_count > 0) {
|
|
|
|
ret = -EAGAIN;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
PM / Domains: Cache device stop and domain power off governor results, v3
The results of the default device stop and domain power off governor
functions for generic PM domains, default_stop_ok() and
default_power_down_ok(), depend only on the timing data of devices,
which are static, and on their PM QoS constraints. Thus, in theory,
these functions only need to carry out their computations, which may
be time consuming in general, when it is known that the PM QoS
constraint of at least one of the devices in question has changed.
Use the PM QoS notifiers of devices to implement that. First,
introduce new fields, constraint_changed and max_off_time_changed,
into struct gpd_timing_data and struct generic_pm_domain,
respectively, and register a PM QoS notifier function when adding
a device into a domain that will set those fields to 'true' whenever
the device's PM QoS constraint is modified. Second, make
default_stop_ok() and default_power_down_ok() use those fields to
decide whether or not to carry out their computations from scratch.
The device and PM domain hierarchies are taken into account in that
and the expense is that the changes of PM QoS constraints of
suspended devices will not be taken into account immediately, which
isn't guaranteed anyway in general.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-05-02 03:34:07 +08:00
|
|
|
genpd->device_count--;
|
|
|
|
genpd->max_off_time_changed = true;
|
|
|
|
|
|
|
|
spin_lock_irq(&dev->power.lock);
|
2012-07-06 04:12:32 +08:00
|
|
|
|
2012-05-02 03:33:53 +08:00
|
|
|
dev->pm_domain = NULL;
|
|
|
|
pdd = dev->power.subsys_data->domain_data;
|
|
|
|
list_del_init(&pdd->list_node);
|
2012-07-06 04:12:32 +08:00
|
|
|
gpd_data = to_gpd_data(pdd);
|
|
|
|
if (--gpd_data->refcount == 0) {
|
|
|
|
dev->power.subsys_data->domain_data = NULL;
|
|
|
|
remove = true;
|
|
|
|
}
|
|
|
|
|
PM / Domains: Cache device stop and domain power off governor results, v3
The results of the default device stop and domain power off governor
functions for generic PM domains, default_stop_ok() and
default_power_down_ok(), depend only on the timing data of devices,
which are static, and on their PM QoS constraints. Thus, in theory,
these functions only need to carry out their computations, which may
be time consuming in general, when it is known that the PM QoS
constraint of at least one of the devices in question has changed.
Use the PM QoS notifiers of devices to implement that. First,
introduce new fields, constraint_changed and max_off_time_changed,
into struct gpd_timing_data and struct generic_pm_domain,
respectively, and register a PM QoS notifier function when adding
a device into a domain that will set those fields to 'true' whenever
the device's PM QoS constraint is modified. Second, make
default_stop_ok() and default_power_down_ok() use those fields to
decide whether or not to carry out their computations from scratch.
The device and PM domain hierarchies are taken into account in that
and the expense is that the changes of PM QoS constraints of
suspended devices will not be taken into account immediately, which
isn't guaranteed anyway in general.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-05-02 03:34:07 +08:00
|
|
|
spin_unlock_irq(&dev->power.lock);
|
2011-07-02 04:12:45 +08:00
|
|
|
|
PM / Domains: Cache device stop and domain power off governor results, v3
The results of the default device stop and domain power off governor
functions for generic PM domains, default_stop_ok() and
default_power_down_ok(), depend only on the timing data of devices,
which are static, and on their PM QoS constraints. Thus, in theory,
these functions only need to carry out their computations, which may
be time consuming in general, when it is known that the PM QoS
constraint of at least one of the devices in question has changed.
Use the PM QoS notifiers of devices to implement that. First,
introduce new fields, constraint_changed and max_off_time_changed,
into struct gpd_timing_data and struct generic_pm_domain,
respectively, and register a PM QoS notifier function when adding
a device into a domain that will set those fields to 'true' whenever
the device's PM QoS constraint is modified. Second, make
default_stop_ok() and default_power_down_ok() use those fields to
decide whether or not to carry out their computations from scratch.
The device and PM domain hierarchies are taken into account in that
and the expense is that the changes of PM QoS constraints of
suspended devices will not be taken into account immediately, which
isn't guaranteed anyway in general.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-05-02 03:34:07 +08:00
|
|
|
mutex_lock(&gpd_data->lock);
|
|
|
|
pdd->dev = NULL;
|
|
|
|
mutex_unlock(&gpd_data->lock);
|
|
|
|
|
|
|
|
genpd_release_lock(genpd);
|
|
|
|
|
|
|
|
dev_pm_put_subsys_data(dev);
|
2012-07-06 04:12:32 +08:00
|
|
|
if (remove)
|
|
|
|
__pm_genpd_free_dev_data(dev, gpd_data);
|
|
|
|
|
PM / Domains: Cache device stop and domain power off governor results, v3
The results of the default device stop and domain power off governor
functions for generic PM domains, default_stop_ok() and
default_power_down_ok(), depend only on the timing data of devices,
which are static, and on their PM QoS constraints. Thus, in theory,
these functions only need to carry out their computations, which may
be time consuming in general, when it is known that the PM QoS
constraint of at least one of the devices in question has changed.
Use the PM QoS notifiers of devices to implement that. First,
introduce new fields, constraint_changed and max_off_time_changed,
into struct gpd_timing_data and struct generic_pm_domain,
respectively, and register a PM QoS notifier function when adding
a device into a domain that will set those fields to 'true' whenever
the device's PM QoS constraint is modified. Second, make
default_stop_ok() and default_power_down_ok() use those fields to
decide whether or not to carry out their computations from scratch.
The device and PM domain hierarchies are taken into account in that
and the expense is that the changes of PM QoS constraints of
suspended devices will not be taken into account immediately, which
isn't guaranteed anyway in general.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-05-02 03:34:07 +08:00
|
|
|
return 0;
|
2011-07-02 04:12:45 +08:00
|
|
|
|
2011-07-02 04:13:19 +08:00
|
|
|
out:
|
2011-07-12 06:39:29 +08:00
|
|
|
genpd_release_lock(genpd);
|
2011-07-02 04:12:45 +08:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-05-15 03:45:52 +08:00
|
|
|
/**
|
|
|
|
* pm_genpd_dev_need_restore - Set/unset the device's "need restore" flag.
|
|
|
|
* @dev: Device to set/unset the flag for.
|
|
|
|
* @val: The new value of the device's "need restore" flag.
|
|
|
|
*/
|
|
|
|
void pm_genpd_dev_need_restore(struct device *dev, bool val)
|
|
|
|
{
|
|
|
|
struct pm_subsys_data *psd;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&dev->power.lock, flags);
|
|
|
|
|
|
|
|
psd = dev_to_psd(dev);
|
|
|
|
if (psd && psd->domain_data)
|
|
|
|
to_gpd_data(psd->domain_data)->need_restore = val;
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&dev->power.lock, flags);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(pm_genpd_dev_need_restore);
|
|
|
|
|
2011-07-02 04:12:45 +08:00
|
|
|
/**
|
|
|
|
* pm_genpd_add_subdomain - Add a subdomain to an I/O PM domain.
|
|
|
|
* @genpd: Master PM domain to add the subdomain to.
|
2011-08-09 05:43:59 +08:00
|
|
|
* @subdomain: Subdomain to be added.
|
2011-07-02 04:12:45 +08:00
|
|
|
*/
|
|
|
|
int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
|
2011-08-09 05:43:59 +08:00
|
|
|
struct generic_pm_domain *subdomain)
|
2011-07-02 04:12:45 +08:00
|
|
|
{
|
2011-08-09 05:43:40 +08:00
|
|
|
struct gpd_link *link;
|
2011-07-02 04:12:45 +08:00
|
|
|
int ret = 0;
|
|
|
|
|
2012-08-07 07:08:37 +08:00
|
|
|
if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(subdomain)
|
|
|
|
|| genpd == subdomain)
|
2011-07-02 04:12:45 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2011-07-12 06:39:29 +08:00
|
|
|
start:
|
|
|
|
genpd_acquire_lock(genpd);
|
2011-08-09 05:43:59 +08:00
|
|
|
mutex_lock_nested(&subdomain->lock, SINGLE_DEPTH_NESTING);
|
2011-07-02 04:12:45 +08:00
|
|
|
|
2011-08-09 05:43:59 +08:00
|
|
|
if (subdomain->status != GPD_STATE_POWER_OFF
|
|
|
|
&& subdomain->status != GPD_STATE_ACTIVE) {
|
|
|
|
mutex_unlock(&subdomain->lock);
|
2011-07-12 06:39:29 +08:00
|
|
|
genpd_release_lock(genpd);
|
|
|
|
goto start;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (genpd->status == GPD_STATE_POWER_OFF
|
2011-08-09 05:43:59 +08:00
|
|
|
&& subdomain->status != GPD_STATE_POWER_OFF) {
|
2011-07-02 04:12:45 +08:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2012-05-08 03:35:45 +08:00
|
|
|
list_for_each_entry(link, &genpd->master_links, master_node) {
|
2011-08-09 05:43:59 +08:00
|
|
|
if (link->slave == subdomain && link->master == genpd) {
|
2011-07-02 04:12:45 +08:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-08-09 05:43:40 +08: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);
|
2011-08-09 05:43:59 +08:00
|
|
|
link->slave = subdomain;
|
|
|
|
list_add_tail(&link->slave_node, &subdomain->slave_links);
|
|
|
|
if (subdomain->status != GPD_STATE_POWER_OFF)
|
2011-08-09 05:43:04 +08:00
|
|
|
genpd_sd_counter_inc(genpd);
|
2011-07-02 04:12:45 +08:00
|
|
|
|
|
|
|
out:
|
2011-08-09 05:43:59 +08:00
|
|
|
mutex_unlock(&subdomain->lock);
|
2011-07-12 06:39:29 +08:00
|
|
|
genpd_release_lock(genpd);
|
2011-07-02 04:12:45 +08:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-08-07 07:08:37 +08:00
|
|
|
/**
|
|
|
|
* pm_genpd_add_subdomain_names - Add a subdomain to an I/O PM domain.
|
|
|
|
* @master_name: Name of the master PM domain to add the subdomain to.
|
|
|
|
* @subdomain_name: Name of the subdomain to be added.
|
|
|
|
*/
|
|
|
|
int pm_genpd_add_subdomain_names(const char *master_name,
|
|
|
|
const char *subdomain_name)
|
|
|
|
{
|
|
|
|
struct generic_pm_domain *master = NULL, *subdomain = NULL, *gpd;
|
|
|
|
|
|
|
|
if (IS_ERR_OR_NULL(master_name) || IS_ERR_OR_NULL(subdomain_name))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
mutex_lock(&gpd_list_lock);
|
|
|
|
list_for_each_entry(gpd, &gpd_list, gpd_list_node) {
|
|
|
|
if (!master && !strcmp(gpd->name, master_name))
|
|
|
|
master = gpd;
|
|
|
|
|
|
|
|
if (!subdomain && !strcmp(gpd->name, subdomain_name))
|
|
|
|
subdomain = gpd;
|
|
|
|
|
|
|
|
if (master && subdomain)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
mutex_unlock(&gpd_list_lock);
|
|
|
|
|
|
|
|
return pm_genpd_add_subdomain(master, subdomain);
|
|
|
|
}
|
|
|
|
|
2011-07-02 04:12:45 +08:00
|
|
|
/**
|
|
|
|
* pm_genpd_remove_subdomain - Remove a subdomain from an I/O PM domain.
|
|
|
|
* @genpd: Master PM domain to remove the subdomain from.
|
2011-08-09 05:43:40 +08:00
|
|
|
* @subdomain: Subdomain to be removed.
|
2011-07-02 04:12:45 +08:00
|
|
|
*/
|
|
|
|
int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
|
2011-08-09 05:43:40 +08:00
|
|
|
struct generic_pm_domain *subdomain)
|
2011-07-02 04:12:45 +08:00
|
|
|
{
|
2011-08-09 05:43:40 +08:00
|
|
|
struct gpd_link *link;
|
2011-07-02 04:12:45 +08:00
|
|
|
int ret = -EINVAL;
|
|
|
|
|
2011-08-09 05:43:40 +08:00
|
|
|
if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(subdomain))
|
2011-07-02 04:12:45 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2011-07-12 06:39:29 +08:00
|
|
|
start:
|
|
|
|
genpd_acquire_lock(genpd);
|
2011-07-02 04:12:45 +08:00
|
|
|
|
2011-08-09 05:43:40 +08:00
|
|
|
list_for_each_entry(link, &genpd->master_links, master_node) {
|
|
|
|
if (link->slave != subdomain)
|
2011-07-02 04:12:45 +08:00
|
|
|
continue;
|
|
|
|
|
|
|
|
mutex_lock_nested(&subdomain->lock, SINGLE_DEPTH_NESTING);
|
|
|
|
|
2011-07-12 06:39:29 +08: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-09 05:43:40 +08:00
|
|
|
list_del(&link->master_node);
|
|
|
|
list_del(&link->slave_node);
|
|
|
|
kfree(link);
|
2011-07-12 06:39:29 +08:00
|
|
|
if (subdomain->status != GPD_STATE_POWER_OFF)
|
2011-07-02 04:12:45 +08:00
|
|
|
genpd_sd_counter_dec(genpd);
|
|
|
|
|
|
|
|
mutex_unlock(&subdomain->lock);
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-07-12 06:39:29 +08:00
|
|
|
genpd_release_lock(genpd);
|
2011-07-02 04:12:45 +08:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-11-27 20:11:36 +08:00
|
|
|
/**
|
|
|
|
* pm_genpd_add_callbacks - Add PM domain callbacks to a given device.
|
|
|
|
* @dev: Device to add the callbacks to.
|
|
|
|
* @ops: Set of callbacks to add.
|
2011-12-01 07:02:05 +08:00
|
|
|
* @td: Timing data to add to the device along with the callbacks (optional).
|
2012-07-06 04:12:54 +08:00
|
|
|
*
|
|
|
|
* Every call to this routine should be balanced with a call to
|
|
|
|
* __pm_genpd_remove_callbacks() and they must not be nested.
|
2011-11-27 20:11:36 +08:00
|
|
|
*/
|
2011-12-01 07:02:05 +08:00
|
|
|
int pm_genpd_add_callbacks(struct device *dev, struct gpd_dev_ops *ops,
|
|
|
|
struct gpd_timing_data *td)
|
2011-11-27 20:11:36 +08:00
|
|
|
{
|
2012-07-06 04:12:54 +08:00
|
|
|
struct generic_pm_domain_data *gpd_data_new, *gpd_data = NULL;
|
2011-11-27 20:11:36 +08:00
|
|
|
int ret = 0;
|
|
|
|
|
2012-07-06 04:12:54 +08:00
|
|
|
if (!(dev && ops))
|
2011-11-27 20:11:36 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2012-07-06 04:12:54 +08:00
|
|
|
gpd_data_new = __pm_genpd_alloc_dev_data(dev);
|
|
|
|
if (!gpd_data_new)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2011-11-27 20:11:36 +08:00
|
|
|
pm_runtime_disable(dev);
|
|
|
|
device_pm_lock();
|
|
|
|
|
2012-07-06 04:12:54 +08:00
|
|
|
ret = dev_pm_get_subsys_data(dev);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
spin_lock_irq(&dev->power.lock);
|
2011-11-27 20:11:36 +08:00
|
|
|
|
2012-07-06 04:12:54 +08:00
|
|
|
if (dev->power.subsys_data->domain_data) {
|
|
|
|
gpd_data = to_gpd_data(dev->power.subsys_data->domain_data);
|
2011-11-27 20:11:36 +08:00
|
|
|
} else {
|
2012-07-06 04:12:54 +08:00
|
|
|
gpd_data = gpd_data_new;
|
|
|
|
dev->power.subsys_data->domain_data = &gpd_data->base;
|
2011-11-27 20:11:36 +08:00
|
|
|
}
|
2012-07-06 04:12:54 +08:00
|
|
|
gpd_data->refcount++;
|
|
|
|
gpd_data->ops = *ops;
|
|
|
|
if (td)
|
|
|
|
gpd_data->td = *td;
|
2011-11-27 20:11:36 +08:00
|
|
|
|
2012-07-06 04:12:54 +08:00
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
|
|
|
|
out:
|
2011-11-27 20:11:36 +08:00
|
|
|
device_pm_unlock();
|
|
|
|
pm_runtime_enable(dev);
|
|
|
|
|
2012-07-06 04:12:54 +08:00
|
|
|
if (gpd_data != gpd_data_new)
|
|
|
|
__pm_genpd_free_dev_data(dev, gpd_data_new);
|
|
|
|
|
2011-11-27 20:11:36 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(pm_genpd_add_callbacks);
|
|
|
|
|
|
|
|
/**
|
2011-12-01 07:02:05 +08:00
|
|
|
* __pm_genpd_remove_callbacks - Remove PM domain callbacks from a given device.
|
2011-11-27 20:11:36 +08:00
|
|
|
* @dev: Device to remove the callbacks from.
|
2011-12-01 07:02:05 +08:00
|
|
|
* @clear_td: If set, clear the device's timing data too.
|
2012-07-06 04:12:54 +08:00
|
|
|
*
|
|
|
|
* This routine can only be called after pm_genpd_add_callbacks().
|
2011-11-27 20:11:36 +08:00
|
|
|
*/
|
2011-12-01 07:02:05 +08:00
|
|
|
int __pm_genpd_remove_callbacks(struct device *dev, bool clear_td)
|
2011-11-27 20:11:36 +08:00
|
|
|
{
|
2012-07-06 04:12:54 +08:00
|
|
|
struct generic_pm_domain_data *gpd_data = NULL;
|
|
|
|
bool remove = false;
|
2011-11-27 20:11:36 +08:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (!(dev && dev->power.subsys_data))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
pm_runtime_disable(dev);
|
|
|
|
device_pm_lock();
|
|
|
|
|
2012-07-06 04:12:54 +08:00
|
|
|
spin_lock_irq(&dev->power.lock);
|
2011-11-27 20:11:36 +08:00
|
|
|
|
2012-07-06 04:12:54 +08:00
|
|
|
if (dev->power.subsys_data->domain_data) {
|
|
|
|
gpd_data = to_gpd_data(dev->power.subsys_data->domain_data);
|
2012-07-11 18:25:49 +08:00
|
|
|
gpd_data->ops = (struct gpd_dev_ops){ NULL };
|
2011-12-01 07:02:05 +08:00
|
|
|
if (clear_td)
|
|
|
|
gpd_data->td = (struct gpd_timing_data){ 0 };
|
2012-07-06 04:12:54 +08:00
|
|
|
|
|
|
|
if (--gpd_data->refcount == 0) {
|
|
|
|
dev->power.subsys_data->domain_data = NULL;
|
|
|
|
remove = true;
|
|
|
|
}
|
2011-11-27 20:11:36 +08:00
|
|
|
} else {
|
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
|
|
|
|
2012-07-06 04:12:54 +08:00
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
|
2011-11-27 20:11:36 +08:00
|
|
|
device_pm_unlock();
|
|
|
|
pm_runtime_enable(dev);
|
|
|
|
|
2012-07-06 04:12:54 +08:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
dev_pm_put_subsys_data(dev);
|
|
|
|
if (remove)
|
|
|
|
__pm_genpd_free_dev_data(dev, gpd_data);
|
|
|
|
|
|
|
|
return 0;
|
2011-11-27 20:11:36 +08:00
|
|
|
}
|
2011-12-01 07:02:05 +08:00
|
|
|
EXPORT_SYMBOL_GPL(__pm_genpd_remove_callbacks);
|
2011-11-27 20:11:36 +08:00
|
|
|
|
2012-08-16 02:32:43 +08:00
|
|
|
/**
|
|
|
|
* pm_genpd_attach_cpuidle - Connect the given PM domain with cpuidle.
|
|
|
|
* @genpd: PM domain to be connected with cpuidle.
|
|
|
|
* @state: cpuidle state this domain can disable/enable.
|
|
|
|
*
|
|
|
|
* Make a PM domain behave as though it contained a CPU core, that is, instead
|
|
|
|
* of calling its power down routine it will enable the given cpuidle state so
|
|
|
|
* that the cpuidle subsystem can power it down (if possible and desirable).
|
|
|
|
*/
|
|
|
|
int pm_genpd_attach_cpuidle(struct generic_pm_domain *genpd, int state)
|
PM / Domains: Add preliminary support for cpuidle, v2
On some systems there are CPU cores located in the same power
domains as I/O devices. Then, power can only be removed from the
domain if all I/O devices in it are not in use and the CPU core
is idle. Add preliminary support for that to the generic PM domains
framework.
First, the platform is expected to provide a cpuidle driver with one
extra state designated for use with the generic PM domains code.
This state should be initially disabled and its exit_latency value
should be set to whatever time is needed to bring up the CPU core
itself after restoring power to it, not including the domain's
power on latency. Its .enter() callback should point to a procedure
that will remove power from the domain containing the CPU core at
the end of the CPU power transition.
The remaining characteristics of the extra cpuidle state, referred to
as the "domain" cpuidle state below, (e.g. power usage, target
residency) should be populated in accordance with the properties of
the hardware.
Next, the platform should execute genpd_attach_cpuidle() on the PM
domain containing the CPU core. That will cause the generic PM
domains framework to treat that domain in a special way such that:
* When all devices in the domain have been suspended and it is about
to be turned off, the states of the devices will be saved, but
power will not be removed from the domain. Instead, the "domain"
cpuidle state will be enabled so that power can be removed from
the domain when the CPU core is idle and the state has been chosen
as the target by the cpuidle governor.
* When the first I/O device in the domain is resumed and
__pm_genpd_poweron(() is called for the first time after
power has been removed from the domain, the "domain" cpuidle
state will be disabled to avoid subsequent surprise power removals
via cpuidle.
The effective exit_latency value of the "domain" cpuidle state
depends on the time needed to bring up the CPU core itself after
restoring power to it as well as on the power on latency of the
domain containing the CPU core. Thus the "domain" cpuidle state's
exit_latency has to be recomputed every time the domain's power on
latency is updated, which may happen every time power is restored
to the domain, if the measured power on latency is greater than
the latency stored in the corresponding generic_pm_domain structure.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Reviewed-by: Kevin Hilman <khilman@ti.com>
2012-07-04 01:07:42 +08:00
|
|
|
{
|
|
|
|
struct cpuidle_driver *cpuidle_drv;
|
|
|
|
struct gpd_cpu_data *cpu_data;
|
|
|
|
struct cpuidle_state *idle_state;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (IS_ERR_OR_NULL(genpd) || state < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
genpd_acquire_lock(genpd);
|
|
|
|
|
|
|
|
if (genpd->cpu_data) {
|
|
|
|
ret = -EEXIST;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
cpu_data = kzalloc(sizeof(*cpu_data), GFP_KERNEL);
|
|
|
|
if (!cpu_data) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
cpuidle_drv = cpuidle_driver_ref();
|
|
|
|
if (!cpuidle_drv) {
|
|
|
|
ret = -ENODEV;
|
2012-10-23 06:54:38 +08:00
|
|
|
goto err_drv;
|
PM / Domains: Add preliminary support for cpuidle, v2
On some systems there are CPU cores located in the same power
domains as I/O devices. Then, power can only be removed from the
domain if all I/O devices in it are not in use and the CPU core
is idle. Add preliminary support for that to the generic PM domains
framework.
First, the platform is expected to provide a cpuidle driver with one
extra state designated for use with the generic PM domains code.
This state should be initially disabled and its exit_latency value
should be set to whatever time is needed to bring up the CPU core
itself after restoring power to it, not including the domain's
power on latency. Its .enter() callback should point to a procedure
that will remove power from the domain containing the CPU core at
the end of the CPU power transition.
The remaining characteristics of the extra cpuidle state, referred to
as the "domain" cpuidle state below, (e.g. power usage, target
residency) should be populated in accordance with the properties of
the hardware.
Next, the platform should execute genpd_attach_cpuidle() on the PM
domain containing the CPU core. That will cause the generic PM
domains framework to treat that domain in a special way such that:
* When all devices in the domain have been suspended and it is about
to be turned off, the states of the devices will be saved, but
power will not be removed from the domain. Instead, the "domain"
cpuidle state will be enabled so that power can be removed from
the domain when the CPU core is idle and the state has been chosen
as the target by the cpuidle governor.
* When the first I/O device in the domain is resumed and
__pm_genpd_poweron(() is called for the first time after
power has been removed from the domain, the "domain" cpuidle
state will be disabled to avoid subsequent surprise power removals
via cpuidle.
The effective exit_latency value of the "domain" cpuidle state
depends on the time needed to bring up the CPU core itself after
restoring power to it as well as on the power on latency of the
domain containing the CPU core. Thus the "domain" cpuidle state's
exit_latency has to be recomputed every time the domain's power on
latency is updated, which may happen every time power is restored
to the domain, if the measured power on latency is greater than
the latency stored in the corresponding generic_pm_domain structure.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Reviewed-by: Kevin Hilman <khilman@ti.com>
2012-07-04 01:07:42 +08:00
|
|
|
}
|
|
|
|
if (cpuidle_drv->state_count <= state) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
idle_state = &cpuidle_drv->states[state];
|
|
|
|
if (!idle_state->disabled) {
|
|
|
|
ret = -EAGAIN;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
cpu_data->idle_state = idle_state;
|
|
|
|
cpu_data->saved_exit_latency = idle_state->exit_latency;
|
|
|
|
genpd->cpu_data = cpu_data;
|
|
|
|
genpd_recalc_cpu_exit_latency(genpd);
|
|
|
|
|
|
|
|
out:
|
|
|
|
genpd_release_lock(genpd);
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
err:
|
|
|
|
cpuidle_driver_unref();
|
2012-10-23 06:54:38 +08:00
|
|
|
|
|
|
|
err_drv:
|
|
|
|
kfree(cpu_data);
|
PM / Domains: Add preliminary support for cpuidle, v2
On some systems there are CPU cores located in the same power
domains as I/O devices. Then, power can only be removed from the
domain if all I/O devices in it are not in use and the CPU core
is idle. Add preliminary support for that to the generic PM domains
framework.
First, the platform is expected to provide a cpuidle driver with one
extra state designated for use with the generic PM domains code.
This state should be initially disabled and its exit_latency value
should be set to whatever time is needed to bring up the CPU core
itself after restoring power to it, not including the domain's
power on latency. Its .enter() callback should point to a procedure
that will remove power from the domain containing the CPU core at
the end of the CPU power transition.
The remaining characteristics of the extra cpuidle state, referred to
as the "domain" cpuidle state below, (e.g. power usage, target
residency) should be populated in accordance with the properties of
the hardware.
Next, the platform should execute genpd_attach_cpuidle() on the PM
domain containing the CPU core. That will cause the generic PM
domains framework to treat that domain in a special way such that:
* When all devices in the domain have been suspended and it is about
to be turned off, the states of the devices will be saved, but
power will not be removed from the domain. Instead, the "domain"
cpuidle state will be enabled so that power can be removed from
the domain when the CPU core is idle and the state has been chosen
as the target by the cpuidle governor.
* When the first I/O device in the domain is resumed and
__pm_genpd_poweron(() is called for the first time after
power has been removed from the domain, the "domain" cpuidle
state will be disabled to avoid subsequent surprise power removals
via cpuidle.
The effective exit_latency value of the "domain" cpuidle state
depends on the time needed to bring up the CPU core itself after
restoring power to it as well as on the power on latency of the
domain containing the CPU core. Thus the "domain" cpuidle state's
exit_latency has to be recomputed every time the domain's power on
latency is updated, which may happen every time power is restored
to the domain, if the measured power on latency is greater than
the latency stored in the corresponding generic_pm_domain structure.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Reviewed-by: Kevin Hilman <khilman@ti.com>
2012-07-04 01:07:42 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2012-08-16 02:32:59 +08:00
|
|
|
/**
|
|
|
|
* pm_genpd_name_attach_cpuidle - Find PM domain and connect cpuidle to it.
|
|
|
|
* @name: Name of the domain to connect to cpuidle.
|
|
|
|
* @state: cpuidle state this domain can manipulate.
|
|
|
|
*/
|
|
|
|
int pm_genpd_name_attach_cpuidle(const char *name, int state)
|
|
|
|
{
|
|
|
|
return pm_genpd_attach_cpuidle(pm_genpd_lookup_name(name), state);
|
|
|
|
}
|
|
|
|
|
2012-08-16 02:32:43 +08:00
|
|
|
/**
|
|
|
|
* pm_genpd_detach_cpuidle - Remove the cpuidle connection from a PM domain.
|
|
|
|
* @genpd: PM domain to remove the cpuidle connection from.
|
|
|
|
*
|
|
|
|
* Remove the cpuidle connection set up by pm_genpd_attach_cpuidle() from the
|
|
|
|
* given PM domain.
|
|
|
|
*/
|
|
|
|
int pm_genpd_detach_cpuidle(struct generic_pm_domain *genpd)
|
PM / Domains: Add preliminary support for cpuidle, v2
On some systems there are CPU cores located in the same power
domains as I/O devices. Then, power can only be removed from the
domain if all I/O devices in it are not in use and the CPU core
is idle. Add preliminary support for that to the generic PM domains
framework.
First, the platform is expected to provide a cpuidle driver with one
extra state designated for use with the generic PM domains code.
This state should be initially disabled and its exit_latency value
should be set to whatever time is needed to bring up the CPU core
itself after restoring power to it, not including the domain's
power on latency. Its .enter() callback should point to a procedure
that will remove power from the domain containing the CPU core at
the end of the CPU power transition.
The remaining characteristics of the extra cpuidle state, referred to
as the "domain" cpuidle state below, (e.g. power usage, target
residency) should be populated in accordance with the properties of
the hardware.
Next, the platform should execute genpd_attach_cpuidle() on the PM
domain containing the CPU core. That will cause the generic PM
domains framework to treat that domain in a special way such that:
* When all devices in the domain have been suspended and it is about
to be turned off, the states of the devices will be saved, but
power will not be removed from the domain. Instead, the "domain"
cpuidle state will be enabled so that power can be removed from
the domain when the CPU core is idle and the state has been chosen
as the target by the cpuidle governor.
* When the first I/O device in the domain is resumed and
__pm_genpd_poweron(() is called for the first time after
power has been removed from the domain, the "domain" cpuidle
state will be disabled to avoid subsequent surprise power removals
via cpuidle.
The effective exit_latency value of the "domain" cpuidle state
depends on the time needed to bring up the CPU core itself after
restoring power to it as well as on the power on latency of the
domain containing the CPU core. Thus the "domain" cpuidle state's
exit_latency has to be recomputed every time the domain's power on
latency is updated, which may happen every time power is restored
to the domain, if the measured power on latency is greater than
the latency stored in the corresponding generic_pm_domain structure.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Reviewed-by: Kevin Hilman <khilman@ti.com>
2012-07-04 01:07:42 +08:00
|
|
|
{
|
|
|
|
struct gpd_cpu_data *cpu_data;
|
|
|
|
struct cpuidle_state *idle_state;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (IS_ERR_OR_NULL(genpd))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
genpd_acquire_lock(genpd);
|
|
|
|
|
|
|
|
cpu_data = genpd->cpu_data;
|
|
|
|
if (!cpu_data) {
|
|
|
|
ret = -ENODEV;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
idle_state = cpu_data->idle_state;
|
|
|
|
if (!idle_state->disabled) {
|
|
|
|
ret = -EAGAIN;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
idle_state->exit_latency = cpu_data->saved_exit_latency;
|
|
|
|
cpuidle_driver_unref();
|
|
|
|
genpd->cpu_data = NULL;
|
|
|
|
kfree(cpu_data);
|
|
|
|
|
|
|
|
out:
|
|
|
|
genpd_release_lock(genpd);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-08-16 02:32:59 +08:00
|
|
|
/**
|
|
|
|
* pm_genpd_name_detach_cpuidle - Find PM domain and disconnect cpuidle from it.
|
|
|
|
* @name: Name of the domain to disconnect cpuidle from.
|
|
|
|
*/
|
|
|
|
int pm_genpd_name_detach_cpuidle(const char *name)
|
|
|
|
{
|
|
|
|
return pm_genpd_detach_cpuidle(pm_genpd_lookup_name(name));
|
|
|
|
}
|
|
|
|
|
PM / Domains: Rework system suspend callback routines (v2)
The current generic PM domains code attempts to use the generic
system suspend operations along with the domains' device stop/start
routines, which requires device drivers to assume that their
system suspend/resume (and hibernation/restore) callbacks will always
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM domain,
in which case it would be necessary to add "fake" PM domains to
satisfy the above assumption. Also, the domain the hardware belongs
to may not be handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, add new device callbacks,
.suspend(), .suspend_late(), .resume_early(), .resume(), .freeze(),
.freeze_late(), .thaw_early(), and .thaw(), that can be supplied by
the drivers in addition to their "standard" system suspend and
hibernation callbacks. These new callbacks, if defined, will be used
by the generic PM domains code for the handling of system suspend and
hibernation instead of the "standard" ones. This will allow drivers
to be designed to work with generic PM domains as well as without
them.
For backwards compatibility, introduce default implementations of the
new callbacks for PM domains that will execute pm_generic_suspend(),
pm_generic_suspend_noirq(), pm_generic_resume_noirq(),
pm_generic_resume(), pm_generic_freeze(), pm_generic_freeze_noirq(),
pm_generic_thaw_noirq(), and pm_generic_thaw(), respectively, for the
given device if its driver doesn't define those callbacks.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:51 +08:00
|
|
|
/* Default device callbacks for generic PM domains. */
|
|
|
|
|
PM / Domains: Introduce "save/restore state" device callbacks
The current PM domains code uses device drivers' .runtime_suspend()
and .runtime_resume() callbacks as the "save device state" and
"restore device state" operations, which may not be appropriate in
general, because it forces drivers to assume that they always will
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM
domain, in which case it would be necessary to add "fake" PM
domains to satisfy the above assumption. It also may be located in
a PM domain that's not handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, introduce new device callbacks,
.save_state() and .restore_state(), that can be supplied by the
drivers in addition to their "standard" runtime PM callbacks. This
will allow the drivers to be designed to work with generic PM domains
as well as without them.
For backwards compatibility, introduce default .save_state() and
.restore_state() callback routines for PM domains that will execute
a device driver's .runtime_suspend() and .runtime_resume() callbacks,
respectively, for the given device if the driver doesn't provide its
own implementations of .save_state() and .restore_state().
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:44 +08:00
|
|
|
/**
|
|
|
|
* pm_genpd_default_save_state - Default "save device state" for PM domians.
|
|
|
|
* @dev: Device to handle.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_default_save_state(struct device *dev)
|
|
|
|
{
|
|
|
|
int (*cb)(struct device *__dev);
|
|
|
|
|
|
|
|
cb = dev_gpd_data(dev)->ops.save_state;
|
|
|
|
if (cb)
|
|
|
|
return cb(dev);
|
|
|
|
|
PM / Domains: Use subsystem runtime suspend/resume callbacks by default
Currently, the default "save state" and "restore state" routines
for generic PM domains, pm_genpd_default_save_state() and
pm_genpd_default_restore_state(), respectively, only use runtime PM
callbacks provided by device drivers, but in general those callbacks
need not provide the entire necessary functionality. Namely, in
general it may be necessary to execute subsystem (i.e. device type,
device class or bus type) callbacks that will carry out all of the
necessary operations.
For this reason, modify pm_genpd_default_save_state() and
pm_genpd_default_restore_state() to execute subsystem callbacks,
if they are provided, and fall back to driver callbacks otherwise.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-06-16 06:02:22 +08:00
|
|
|
if (dev->type && dev->type->pm)
|
|
|
|
cb = dev->type->pm->runtime_suspend;
|
|
|
|
else if (dev->class && dev->class->pm)
|
|
|
|
cb = dev->class->pm->runtime_suspend;
|
|
|
|
else if (dev->bus && dev->bus->pm)
|
|
|
|
cb = dev->bus->pm->runtime_suspend;
|
|
|
|
else
|
|
|
|
cb = NULL;
|
PM / Domains: Introduce "save/restore state" device callbacks
The current PM domains code uses device drivers' .runtime_suspend()
and .runtime_resume() callbacks as the "save device state" and
"restore device state" operations, which may not be appropriate in
general, because it forces drivers to assume that they always will
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM
domain, in which case it would be necessary to add "fake" PM
domains to satisfy the above assumption. It also may be located in
a PM domain that's not handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, introduce new device callbacks,
.save_state() and .restore_state(), that can be supplied by the
drivers in addition to their "standard" runtime PM callbacks. This
will allow the drivers to be designed to work with generic PM domains
as well as without them.
For backwards compatibility, introduce default .save_state() and
.restore_state() callback routines for PM domains that will execute
a device driver's .runtime_suspend() and .runtime_resume() callbacks,
respectively, for the given device if the driver doesn't provide its
own implementations of .save_state() and .restore_state().
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:44 +08:00
|
|
|
|
PM / Domains: Use subsystem runtime suspend/resume callbacks by default
Currently, the default "save state" and "restore state" routines
for generic PM domains, pm_genpd_default_save_state() and
pm_genpd_default_restore_state(), respectively, only use runtime PM
callbacks provided by device drivers, but in general those callbacks
need not provide the entire necessary functionality. Namely, in
general it may be necessary to execute subsystem (i.e. device type,
device class or bus type) callbacks that will carry out all of the
necessary operations.
For this reason, modify pm_genpd_default_save_state() and
pm_genpd_default_restore_state() to execute subsystem callbacks,
if they are provided, and fall back to driver callbacks otherwise.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-06-16 06:02:22 +08:00
|
|
|
if (!cb && dev->driver && dev->driver->pm)
|
|
|
|
cb = dev->driver->pm->runtime_suspend;
|
|
|
|
|
|
|
|
return cb ? cb(dev) : 0;
|
PM / Domains: Introduce "save/restore state" device callbacks
The current PM domains code uses device drivers' .runtime_suspend()
and .runtime_resume() callbacks as the "save device state" and
"restore device state" operations, which may not be appropriate in
general, because it forces drivers to assume that they always will
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM
domain, in which case it would be necessary to add "fake" PM
domains to satisfy the above assumption. It also may be located in
a PM domain that's not handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, introduce new device callbacks,
.save_state() and .restore_state(), that can be supplied by the
drivers in addition to their "standard" runtime PM callbacks. This
will allow the drivers to be designed to work with generic PM domains
as well as without them.
For backwards compatibility, introduce default .save_state() and
.restore_state() callback routines for PM domains that will execute
a device driver's .runtime_suspend() and .runtime_resume() callbacks,
respectively, for the given device if the driver doesn't provide its
own implementations of .save_state() and .restore_state().
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:44 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_default_restore_state - Default PM domians "restore device state".
|
|
|
|
* @dev: Device to handle.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_default_restore_state(struct device *dev)
|
|
|
|
{
|
|
|
|
int (*cb)(struct device *__dev);
|
|
|
|
|
|
|
|
cb = dev_gpd_data(dev)->ops.restore_state;
|
|
|
|
if (cb)
|
|
|
|
return cb(dev);
|
|
|
|
|
PM / Domains: Use subsystem runtime suspend/resume callbacks by default
Currently, the default "save state" and "restore state" routines
for generic PM domains, pm_genpd_default_save_state() and
pm_genpd_default_restore_state(), respectively, only use runtime PM
callbacks provided by device drivers, but in general those callbacks
need not provide the entire necessary functionality. Namely, in
general it may be necessary to execute subsystem (i.e. device type,
device class or bus type) callbacks that will carry out all of the
necessary operations.
For this reason, modify pm_genpd_default_save_state() and
pm_genpd_default_restore_state() to execute subsystem callbacks,
if they are provided, and fall back to driver callbacks otherwise.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-06-16 06:02:22 +08:00
|
|
|
if (dev->type && dev->type->pm)
|
|
|
|
cb = dev->type->pm->runtime_resume;
|
|
|
|
else if (dev->class && dev->class->pm)
|
|
|
|
cb = dev->class->pm->runtime_resume;
|
|
|
|
else if (dev->bus && dev->bus->pm)
|
|
|
|
cb = dev->bus->pm->runtime_resume;
|
|
|
|
else
|
|
|
|
cb = NULL;
|
PM / Domains: Introduce "save/restore state" device callbacks
The current PM domains code uses device drivers' .runtime_suspend()
and .runtime_resume() callbacks as the "save device state" and
"restore device state" operations, which may not be appropriate in
general, because it forces drivers to assume that they always will
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM
domain, in which case it would be necessary to add "fake" PM
domains to satisfy the above assumption. It also may be located in
a PM domain that's not handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, introduce new device callbacks,
.save_state() and .restore_state(), that can be supplied by the
drivers in addition to their "standard" runtime PM callbacks. This
will allow the drivers to be designed to work with generic PM domains
as well as without them.
For backwards compatibility, introduce default .save_state() and
.restore_state() callback routines for PM domains that will execute
a device driver's .runtime_suspend() and .runtime_resume() callbacks,
respectively, for the given device if the driver doesn't provide its
own implementations of .save_state() and .restore_state().
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:44 +08:00
|
|
|
|
PM / Domains: Use subsystem runtime suspend/resume callbacks by default
Currently, the default "save state" and "restore state" routines
for generic PM domains, pm_genpd_default_save_state() and
pm_genpd_default_restore_state(), respectively, only use runtime PM
callbacks provided by device drivers, but in general those callbacks
need not provide the entire necessary functionality. Namely, in
general it may be necessary to execute subsystem (i.e. device type,
device class or bus type) callbacks that will carry out all of the
necessary operations.
For this reason, modify pm_genpd_default_save_state() and
pm_genpd_default_restore_state() to execute subsystem callbacks,
if they are provided, and fall back to driver callbacks otherwise.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-06-16 06:02:22 +08:00
|
|
|
if (!cb && dev->driver && dev->driver->pm)
|
|
|
|
cb = dev->driver->pm->runtime_resume;
|
|
|
|
|
|
|
|
return cb ? cb(dev) : 0;
|
PM / Domains: Introduce "save/restore state" device callbacks
The current PM domains code uses device drivers' .runtime_suspend()
and .runtime_resume() callbacks as the "save device state" and
"restore device state" operations, which may not be appropriate in
general, because it forces drivers to assume that they always will
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM
domain, in which case it would be necessary to add "fake" PM
domains to satisfy the above assumption. It also may be located in
a PM domain that's not handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, introduce new device callbacks,
.save_state() and .restore_state(), that can be supplied by the
drivers in addition to their "standard" runtime PM callbacks. This
will allow the drivers to be designed to work with generic PM domains
as well as without them.
For backwards compatibility, introduce default .save_state() and
.restore_state() callback routines for PM domains that will execute
a device driver's .runtime_suspend() and .runtime_resume() callbacks,
respectively, for the given device if the driver doesn't provide its
own implementations of .save_state() and .restore_state().
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:44 +08:00
|
|
|
}
|
|
|
|
|
2012-01-14 07:39:25 +08:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
|
|
|
|
PM / Domains: Rework system suspend callback routines (v2)
The current generic PM domains code attempts to use the generic
system suspend operations along with the domains' device stop/start
routines, which requires device drivers to assume that their
system suspend/resume (and hibernation/restore) callbacks will always
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM domain,
in which case it would be necessary to add "fake" PM domains to
satisfy the above assumption. Also, the domain the hardware belongs
to may not be handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, add new device callbacks,
.suspend(), .suspend_late(), .resume_early(), .resume(), .freeze(),
.freeze_late(), .thaw_early(), and .thaw(), that can be supplied by
the drivers in addition to their "standard" system suspend and
hibernation callbacks. These new callbacks, if defined, will be used
by the generic PM domains code for the handling of system suspend and
hibernation instead of the "standard" ones. This will allow drivers
to be designed to work with generic PM domains as well as without
them.
For backwards compatibility, introduce default implementations of the
new callbacks for PM domains that will execute pm_generic_suspend(),
pm_generic_suspend_noirq(), pm_generic_resume_noirq(),
pm_generic_resume(), pm_generic_freeze(), pm_generic_freeze_noirq(),
pm_generic_thaw_noirq(), and pm_generic_thaw(), respectively, for the
given device if its driver doesn't define those callbacks.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:51 +08:00
|
|
|
/**
|
|
|
|
* pm_genpd_default_suspend - Default "device suspend" for PM domians.
|
|
|
|
* @dev: Device to handle.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_default_suspend(struct device *dev)
|
|
|
|
{
|
2011-12-07 06:16:47 +08:00
|
|
|
int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.suspend;
|
PM / Domains: Rework system suspend callback routines (v2)
The current generic PM domains code attempts to use the generic
system suspend operations along with the domains' device stop/start
routines, which requires device drivers to assume that their
system suspend/resume (and hibernation/restore) callbacks will always
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM domain,
in which case it would be necessary to add "fake" PM domains to
satisfy the above assumption. Also, the domain the hardware belongs
to may not be handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, add new device callbacks,
.suspend(), .suspend_late(), .resume_early(), .resume(), .freeze(),
.freeze_late(), .thaw_early(), and .thaw(), that can be supplied by
the drivers in addition to their "standard" system suspend and
hibernation callbacks. These new callbacks, if defined, will be used
by the generic PM domains code for the handling of system suspend and
hibernation instead of the "standard" ones. This will allow drivers
to be designed to work with generic PM domains as well as without
them.
For backwards compatibility, introduce default implementations of the
new callbacks for PM domains that will execute pm_generic_suspend(),
pm_generic_suspend_noirq(), pm_generic_resume_noirq(),
pm_generic_resume(), pm_generic_freeze(), pm_generic_freeze_noirq(),
pm_generic_thaw_noirq(), and pm_generic_thaw(), respectively, for the
given device if its driver doesn't define those callbacks.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:51 +08:00
|
|
|
|
|
|
|
return cb ? cb(dev) : pm_generic_suspend(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_default_suspend_late - Default "late device suspend" for PM domians.
|
|
|
|
* @dev: Device to handle.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_default_suspend_late(struct device *dev)
|
|
|
|
{
|
2011-12-07 06:16:47 +08:00
|
|
|
int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.suspend_late;
|
PM / Domains: Rework system suspend callback routines (v2)
The current generic PM domains code attempts to use the generic
system suspend operations along with the domains' device stop/start
routines, which requires device drivers to assume that their
system suspend/resume (and hibernation/restore) callbacks will always
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM domain,
in which case it would be necessary to add "fake" PM domains to
satisfy the above assumption. Also, the domain the hardware belongs
to may not be handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, add new device callbacks,
.suspend(), .suspend_late(), .resume_early(), .resume(), .freeze(),
.freeze_late(), .thaw_early(), and .thaw(), that can be supplied by
the drivers in addition to their "standard" system suspend and
hibernation callbacks. These new callbacks, if defined, will be used
by the generic PM domains code for the handling of system suspend and
hibernation instead of the "standard" ones. This will allow drivers
to be designed to work with generic PM domains as well as without
them.
For backwards compatibility, introduce default implementations of the
new callbacks for PM domains that will execute pm_generic_suspend(),
pm_generic_suspend_noirq(), pm_generic_resume_noirq(),
pm_generic_resume(), pm_generic_freeze(), pm_generic_freeze_noirq(),
pm_generic_thaw_noirq(), and pm_generic_thaw(), respectively, for the
given device if its driver doesn't define those callbacks.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:51 +08:00
|
|
|
|
2012-01-30 03:39:02 +08:00
|
|
|
return cb ? cb(dev) : pm_generic_suspend_late(dev);
|
PM / Domains: Rework system suspend callback routines (v2)
The current generic PM domains code attempts to use the generic
system suspend operations along with the domains' device stop/start
routines, which requires device drivers to assume that their
system suspend/resume (and hibernation/restore) callbacks will always
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM domain,
in which case it would be necessary to add "fake" PM domains to
satisfy the above assumption. Also, the domain the hardware belongs
to may not be handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, add new device callbacks,
.suspend(), .suspend_late(), .resume_early(), .resume(), .freeze(),
.freeze_late(), .thaw_early(), and .thaw(), that can be supplied by
the drivers in addition to their "standard" system suspend and
hibernation callbacks. These new callbacks, if defined, will be used
by the generic PM domains code for the handling of system suspend and
hibernation instead of the "standard" ones. This will allow drivers
to be designed to work with generic PM domains as well as without
them.
For backwards compatibility, introduce default implementations of the
new callbacks for PM domains that will execute pm_generic_suspend(),
pm_generic_suspend_noirq(), pm_generic_resume_noirq(),
pm_generic_resume(), pm_generic_freeze(), pm_generic_freeze_noirq(),
pm_generic_thaw_noirq(), and pm_generic_thaw(), respectively, for the
given device if its driver doesn't define those callbacks.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:51 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_default_resume_early - Default "early device resume" for PM domians.
|
|
|
|
* @dev: Device to handle.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_default_resume_early(struct device *dev)
|
|
|
|
{
|
2011-12-07 06:16:47 +08:00
|
|
|
int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.resume_early;
|
PM / Domains: Rework system suspend callback routines (v2)
The current generic PM domains code attempts to use the generic
system suspend operations along with the domains' device stop/start
routines, which requires device drivers to assume that their
system suspend/resume (and hibernation/restore) callbacks will always
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM domain,
in which case it would be necessary to add "fake" PM domains to
satisfy the above assumption. Also, the domain the hardware belongs
to may not be handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, add new device callbacks,
.suspend(), .suspend_late(), .resume_early(), .resume(), .freeze(),
.freeze_late(), .thaw_early(), and .thaw(), that can be supplied by
the drivers in addition to their "standard" system suspend and
hibernation callbacks. These new callbacks, if defined, will be used
by the generic PM domains code for the handling of system suspend and
hibernation instead of the "standard" ones. This will allow drivers
to be designed to work with generic PM domains as well as without
them.
For backwards compatibility, introduce default implementations of the
new callbacks for PM domains that will execute pm_generic_suspend(),
pm_generic_suspend_noirq(), pm_generic_resume_noirq(),
pm_generic_resume(), pm_generic_freeze(), pm_generic_freeze_noirq(),
pm_generic_thaw_noirq(), and pm_generic_thaw(), respectively, for the
given device if its driver doesn't define those callbacks.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:51 +08:00
|
|
|
|
2012-01-30 03:39:02 +08:00
|
|
|
return cb ? cb(dev) : pm_generic_resume_early(dev);
|
PM / Domains: Rework system suspend callback routines (v2)
The current generic PM domains code attempts to use the generic
system suspend operations along with the domains' device stop/start
routines, which requires device drivers to assume that their
system suspend/resume (and hibernation/restore) callbacks will always
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM domain,
in which case it would be necessary to add "fake" PM domains to
satisfy the above assumption. Also, the domain the hardware belongs
to may not be handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, add new device callbacks,
.suspend(), .suspend_late(), .resume_early(), .resume(), .freeze(),
.freeze_late(), .thaw_early(), and .thaw(), that can be supplied by
the drivers in addition to their "standard" system suspend and
hibernation callbacks. These new callbacks, if defined, will be used
by the generic PM domains code for the handling of system suspend and
hibernation instead of the "standard" ones. This will allow drivers
to be designed to work with generic PM domains as well as without
them.
For backwards compatibility, introduce default implementations of the
new callbacks for PM domains that will execute pm_generic_suspend(),
pm_generic_suspend_noirq(), pm_generic_resume_noirq(),
pm_generic_resume(), pm_generic_freeze(), pm_generic_freeze_noirq(),
pm_generic_thaw_noirq(), and pm_generic_thaw(), respectively, for the
given device if its driver doesn't define those callbacks.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:51 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_default_resume - Default "device resume" for PM domians.
|
|
|
|
* @dev: Device to handle.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_default_resume(struct device *dev)
|
|
|
|
{
|
2011-12-07 06:16:47 +08:00
|
|
|
int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.resume;
|
PM / Domains: Rework system suspend callback routines (v2)
The current generic PM domains code attempts to use the generic
system suspend operations along with the domains' device stop/start
routines, which requires device drivers to assume that their
system suspend/resume (and hibernation/restore) callbacks will always
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM domain,
in which case it would be necessary to add "fake" PM domains to
satisfy the above assumption. Also, the domain the hardware belongs
to may not be handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, add new device callbacks,
.suspend(), .suspend_late(), .resume_early(), .resume(), .freeze(),
.freeze_late(), .thaw_early(), and .thaw(), that can be supplied by
the drivers in addition to their "standard" system suspend and
hibernation callbacks. These new callbacks, if defined, will be used
by the generic PM domains code for the handling of system suspend and
hibernation instead of the "standard" ones. This will allow drivers
to be designed to work with generic PM domains as well as without
them.
For backwards compatibility, introduce default implementations of the
new callbacks for PM domains that will execute pm_generic_suspend(),
pm_generic_suspend_noirq(), pm_generic_resume_noirq(),
pm_generic_resume(), pm_generic_freeze(), pm_generic_freeze_noirq(),
pm_generic_thaw_noirq(), and pm_generic_thaw(), respectively, for the
given device if its driver doesn't define those callbacks.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:51 +08:00
|
|
|
|
|
|
|
return cb ? cb(dev) : pm_generic_resume(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_default_freeze - Default "device freeze" for PM domians.
|
|
|
|
* @dev: Device to handle.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_default_freeze(struct device *dev)
|
|
|
|
{
|
|
|
|
int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.freeze;
|
|
|
|
|
|
|
|
return cb ? cb(dev) : pm_generic_freeze(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_default_freeze_late - Default "late device freeze" for PM domians.
|
|
|
|
* @dev: Device to handle.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_default_freeze_late(struct device *dev)
|
|
|
|
{
|
|
|
|
int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.freeze_late;
|
|
|
|
|
2012-01-30 03:39:02 +08:00
|
|
|
return cb ? cb(dev) : pm_generic_freeze_late(dev);
|
PM / Domains: Rework system suspend callback routines (v2)
The current generic PM domains code attempts to use the generic
system suspend operations along with the domains' device stop/start
routines, which requires device drivers to assume that their
system suspend/resume (and hibernation/restore) callbacks will always
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM domain,
in which case it would be necessary to add "fake" PM domains to
satisfy the above assumption. Also, the domain the hardware belongs
to may not be handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, add new device callbacks,
.suspend(), .suspend_late(), .resume_early(), .resume(), .freeze(),
.freeze_late(), .thaw_early(), and .thaw(), that can be supplied by
the drivers in addition to their "standard" system suspend and
hibernation callbacks. These new callbacks, if defined, will be used
by the generic PM domains code for the handling of system suspend and
hibernation instead of the "standard" ones. This will allow drivers
to be designed to work with generic PM domains as well as without
them.
For backwards compatibility, introduce default implementations of the
new callbacks for PM domains that will execute pm_generic_suspend(),
pm_generic_suspend_noirq(), pm_generic_resume_noirq(),
pm_generic_resume(), pm_generic_freeze(), pm_generic_freeze_noirq(),
pm_generic_thaw_noirq(), and pm_generic_thaw(), respectively, for the
given device if its driver doesn't define those callbacks.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:51 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_default_thaw_early - Default "early device thaw" for PM domians.
|
|
|
|
* @dev: Device to handle.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_default_thaw_early(struct device *dev)
|
|
|
|
{
|
|
|
|
int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.thaw_early;
|
|
|
|
|
2012-01-30 03:39:02 +08:00
|
|
|
return cb ? cb(dev) : pm_generic_thaw_early(dev);
|
PM / Domains: Rework system suspend callback routines (v2)
The current generic PM domains code attempts to use the generic
system suspend operations along with the domains' device stop/start
routines, which requires device drivers to assume that their
system suspend/resume (and hibernation/restore) callbacks will always
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM domain,
in which case it would be necessary to add "fake" PM domains to
satisfy the above assumption. Also, the domain the hardware belongs
to may not be handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, add new device callbacks,
.suspend(), .suspend_late(), .resume_early(), .resume(), .freeze(),
.freeze_late(), .thaw_early(), and .thaw(), that can be supplied by
the drivers in addition to their "standard" system suspend and
hibernation callbacks. These new callbacks, if defined, will be used
by the generic PM domains code for the handling of system suspend and
hibernation instead of the "standard" ones. This will allow drivers
to be designed to work with generic PM domains as well as without
them.
For backwards compatibility, introduce default implementations of the
new callbacks for PM domains that will execute pm_generic_suspend(),
pm_generic_suspend_noirq(), pm_generic_resume_noirq(),
pm_generic_resume(), pm_generic_freeze(), pm_generic_freeze_noirq(),
pm_generic_thaw_noirq(), and pm_generic_thaw(), respectively, for the
given device if its driver doesn't define those callbacks.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:51 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_genpd_default_thaw - Default "device thaw" for PM domians.
|
|
|
|
* @dev: Device to handle.
|
|
|
|
*/
|
|
|
|
static int pm_genpd_default_thaw(struct device *dev)
|
|
|
|
{
|
|
|
|
int (*cb)(struct device *__dev) = dev_gpd_data(dev)->ops.thaw;
|
|
|
|
|
|
|
|
return cb ? cb(dev) : pm_generic_thaw(dev);
|
|
|
|
}
|
|
|
|
|
2012-01-14 07:39:25 +08:00
|
|
|
#else /* !CONFIG_PM_SLEEP */
|
|
|
|
|
|
|
|
#define pm_genpd_default_suspend NULL
|
|
|
|
#define pm_genpd_default_suspend_late NULL
|
|
|
|
#define pm_genpd_default_resume_early NULL
|
|
|
|
#define pm_genpd_default_resume NULL
|
|
|
|
#define pm_genpd_default_freeze NULL
|
|
|
|
#define pm_genpd_default_freeze_late NULL
|
|
|
|
#define pm_genpd_default_thaw_early NULL
|
|
|
|
#define pm_genpd_default_thaw NULL
|
|
|
|
|
|
|
|
#endif /* !CONFIG_PM_SLEEP */
|
|
|
|
|
2011-07-02 04:12:45 +08:00
|
|
|
/**
|
|
|
|
* 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-09 05:43:40 +08:00
|
|
|
INIT_LIST_HEAD(&genpd->master_links);
|
|
|
|
INIT_LIST_HEAD(&genpd->slave_links);
|
2011-07-02 04:12:45 +08: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-09 05:43:04 +08:00
|
|
|
atomic_set(&genpd->sd_count, 0);
|
2011-07-12 06:39:29 +08: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-12 06:39:36 +08:00
|
|
|
genpd->poweroff_task = NULL;
|
|
|
|
genpd->resume_count = 0;
|
2011-07-02 04:13:19 +08:00
|
|
|
genpd->device_count = 0;
|
2011-12-01 07:02:10 +08:00
|
|
|
genpd->max_off_time_ns = -1;
|
PM / Domains: Cache device stop and domain power off governor results, v3
The results of the default device stop and domain power off governor
functions for generic PM domains, default_stop_ok() and
default_power_down_ok(), depend only on the timing data of devices,
which are static, and on their PM QoS constraints. Thus, in theory,
these functions only need to carry out their computations, which may
be time consuming in general, when it is known that the PM QoS
constraint of at least one of the devices in question has changed.
Use the PM QoS notifiers of devices to implement that. First,
introduce new fields, constraint_changed and max_off_time_changed,
into struct gpd_timing_data and struct generic_pm_domain,
respectively, and register a PM QoS notifier function when adding
a device into a domain that will set those fields to 'true' whenever
the device's PM QoS constraint is modified. Second, make
default_stop_ok() and default_power_down_ok() use those fields to
decide whether or not to carry out their computations from scratch.
The device and PM domain hierarchies are taken into account in that
and the expense is that the changes of PM QoS constraints of
suspended devices will not be taken into account immediately, which
isn't guaranteed anyway in general.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2012-05-02 03:34:07 +08:00
|
|
|
genpd->max_off_time_changed = true;
|
2011-07-02 04:12:45 +08: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-02 04:13:19 +08:00
|
|
|
genpd->domain.ops.prepare = pm_genpd_prepare;
|
|
|
|
genpd->domain.ops.suspend = pm_genpd_suspend;
|
2012-01-30 03:39:02 +08:00
|
|
|
genpd->domain.ops.suspend_late = pm_genpd_suspend_late;
|
2011-07-02 04:13:19 +08:00
|
|
|
genpd->domain.ops.suspend_noirq = pm_genpd_suspend_noirq;
|
|
|
|
genpd->domain.ops.resume_noirq = pm_genpd_resume_noirq;
|
2012-01-30 03:39:02 +08:00
|
|
|
genpd->domain.ops.resume_early = pm_genpd_resume_early;
|
2011-07-02 04:13:19 +08:00
|
|
|
genpd->domain.ops.resume = pm_genpd_resume;
|
|
|
|
genpd->domain.ops.freeze = pm_genpd_freeze;
|
2012-01-30 03:39:02 +08:00
|
|
|
genpd->domain.ops.freeze_late = pm_genpd_freeze_late;
|
2011-07-02 04:13:19 +08:00
|
|
|
genpd->domain.ops.freeze_noirq = pm_genpd_freeze_noirq;
|
|
|
|
genpd->domain.ops.thaw_noirq = pm_genpd_thaw_noirq;
|
2012-01-30 03:39:02 +08:00
|
|
|
genpd->domain.ops.thaw_early = pm_genpd_thaw_early;
|
2011-07-02 04:13:19 +08:00
|
|
|
genpd->domain.ops.thaw = pm_genpd_thaw;
|
PM / Domains: Rework system suspend callback routines (v2)
The current generic PM domains code attempts to use the generic
system suspend operations along with the domains' device stop/start
routines, which requires device drivers to assume that their
system suspend/resume (and hibernation/restore) callbacks will always
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM domain,
in which case it would be necessary to add "fake" PM domains to
satisfy the above assumption. Also, the domain the hardware belongs
to may not be handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, add new device callbacks,
.suspend(), .suspend_late(), .resume_early(), .resume(), .freeze(),
.freeze_late(), .thaw_early(), and .thaw(), that can be supplied by
the drivers in addition to their "standard" system suspend and
hibernation callbacks. These new callbacks, if defined, will be used
by the generic PM domains code for the handling of system suspend and
hibernation instead of the "standard" ones. This will allow drivers
to be designed to work with generic PM domains as well as without
them.
For backwards compatibility, introduce default implementations of the
new callbacks for PM domains that will execute pm_generic_suspend(),
pm_generic_suspend_noirq(), pm_generic_resume_noirq(),
pm_generic_resume(), pm_generic_freeze(), pm_generic_freeze_noirq(),
pm_generic_thaw_noirq(), and pm_generic_thaw(), respectively, for the
given device if its driver doesn't define those callbacks.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:51 +08:00
|
|
|
genpd->domain.ops.poweroff = pm_genpd_suspend;
|
2012-01-30 03:39:02 +08:00
|
|
|
genpd->domain.ops.poweroff_late = pm_genpd_suspend_late;
|
PM / Domains: Rework system suspend callback routines (v2)
The current generic PM domains code attempts to use the generic
system suspend operations along with the domains' device stop/start
routines, which requires device drivers to assume that their
system suspend/resume (and hibernation/restore) callbacks will always
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM domain,
in which case it would be necessary to add "fake" PM domains to
satisfy the above assumption. Also, the domain the hardware belongs
to may not be handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, add new device callbacks,
.suspend(), .suspend_late(), .resume_early(), .resume(), .freeze(),
.freeze_late(), .thaw_early(), and .thaw(), that can be supplied by
the drivers in addition to their "standard" system suspend and
hibernation callbacks. These new callbacks, if defined, will be used
by the generic PM domains code for the handling of system suspend and
hibernation instead of the "standard" ones. This will allow drivers
to be designed to work with generic PM domains as well as without
them.
For backwards compatibility, introduce default implementations of the
new callbacks for PM domains that will execute pm_generic_suspend(),
pm_generic_suspend_noirq(), pm_generic_resume_noirq(),
pm_generic_resume(), pm_generic_freeze(), pm_generic_freeze_noirq(),
pm_generic_thaw_noirq(), and pm_generic_thaw(), respectively, for the
given device if its driver doesn't define those callbacks.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:51 +08:00
|
|
|
genpd->domain.ops.poweroff_noirq = pm_genpd_suspend_noirq;
|
2011-07-02 04:13:19 +08:00
|
|
|
genpd->domain.ops.restore_noirq = pm_genpd_restore_noirq;
|
2012-01-30 03:39:02 +08:00
|
|
|
genpd->domain.ops.restore_early = pm_genpd_resume_early;
|
PM / Domains: Rework system suspend callback routines (v2)
The current generic PM domains code attempts to use the generic
system suspend operations along with the domains' device stop/start
routines, which requires device drivers to assume that their
system suspend/resume (and hibernation/restore) callbacks will always
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM domain,
in which case it would be necessary to add "fake" PM domains to
satisfy the above assumption. Also, the domain the hardware belongs
to may not be handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, add new device callbacks,
.suspend(), .suspend_late(), .resume_early(), .resume(), .freeze(),
.freeze_late(), .thaw_early(), and .thaw(), that can be supplied by
the drivers in addition to their "standard" system suspend and
hibernation callbacks. These new callbacks, if defined, will be used
by the generic PM domains code for the handling of system suspend and
hibernation instead of the "standard" ones. This will allow drivers
to be designed to work with generic PM domains as well as without
them.
For backwards compatibility, introduce default implementations of the
new callbacks for PM domains that will execute pm_generic_suspend(),
pm_generic_suspend_noirq(), pm_generic_resume_noirq(),
pm_generic_resume(), pm_generic_freeze(), pm_generic_freeze_noirq(),
pm_generic_thaw_noirq(), and pm_generic_thaw(), respectively, for the
given device if its driver doesn't define those callbacks.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:51 +08:00
|
|
|
genpd->domain.ops.restore = pm_genpd_resume;
|
2011-07-02 04:13:19 +08:00
|
|
|
genpd->domain.ops.complete = pm_genpd_complete;
|
PM / Domains: Introduce "save/restore state" device callbacks
The current PM domains code uses device drivers' .runtime_suspend()
and .runtime_resume() callbacks as the "save device state" and
"restore device state" operations, which may not be appropriate in
general, because it forces drivers to assume that they always will
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM
domain, in which case it would be necessary to add "fake" PM
domains to satisfy the above assumption. It also may be located in
a PM domain that's not handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, introduce new device callbacks,
.save_state() and .restore_state(), that can be supplied by the
drivers in addition to their "standard" runtime PM callbacks. This
will allow the drivers to be designed to work with generic PM domains
as well as without them.
For backwards compatibility, introduce default .save_state() and
.restore_state() callback routines for PM domains that will execute
a device driver's .runtime_suspend() and .runtime_resume() callbacks,
respectively, for the given device if the driver doesn't provide its
own implementations of .save_state() and .restore_state().
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:44 +08:00
|
|
|
genpd->dev_ops.save_state = pm_genpd_default_save_state;
|
|
|
|
genpd->dev_ops.restore_state = pm_genpd_default_restore_state;
|
2011-12-07 06:16:47 +08:00
|
|
|
genpd->dev_ops.suspend = pm_genpd_default_suspend;
|
|
|
|
genpd->dev_ops.suspend_late = pm_genpd_default_suspend_late;
|
|
|
|
genpd->dev_ops.resume_early = pm_genpd_default_resume_early;
|
|
|
|
genpd->dev_ops.resume = pm_genpd_default_resume;
|
PM / Domains: Rework system suspend callback routines (v2)
The current generic PM domains code attempts to use the generic
system suspend operations along with the domains' device stop/start
routines, which requires device drivers to assume that their
system suspend/resume (and hibernation/restore) callbacks will always
be used with generic PM domains. However, in theory, the same
hardware may be used in devices that don't belong to any PM domain,
in which case it would be necessary to add "fake" PM domains to
satisfy the above assumption. Also, the domain the hardware belongs
to may not be handled with the help of the generic code.
To allow device drivers that may be used along with the generic PM
domains code of more flexibility, add new device callbacks,
.suspend(), .suspend_late(), .resume_early(), .resume(), .freeze(),
.freeze_late(), .thaw_early(), and .thaw(), that can be supplied by
the drivers in addition to their "standard" system suspend and
hibernation callbacks. These new callbacks, if defined, will be used
by the generic PM domains code for the handling of system suspend and
hibernation instead of the "standard" ones. This will allow drivers
to be designed to work with generic PM domains as well as without
them.
For backwards compatibility, introduce default implementations of the
new callbacks for PM domains that will execute pm_generic_suspend(),
pm_generic_suspend_noirq(), pm_generic_resume_noirq(),
pm_generic_resume(), pm_generic_freeze(), pm_generic_freeze_noirq(),
pm_generic_thaw_noirq(), and pm_generic_thaw(), respectively, for the
given device if its driver doesn't define those callbacks.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-11-27 20:11:51 +08:00
|
|
|
genpd->dev_ops.freeze = pm_genpd_default_freeze;
|
|
|
|
genpd->dev_ops.freeze_late = pm_genpd_default_freeze_late;
|
|
|
|
genpd->dev_ops.thaw_early = pm_genpd_default_thaw_early;
|
|
|
|
genpd->dev_ops.thaw = pm_genpd_default_thaw;
|
2011-07-13 18:31:52 +08:00
|
|
|
mutex_lock(&gpd_list_lock);
|
|
|
|
list_add(&genpd->gpd_list_node, &gpd_list);
|
|
|
|
mutex_unlock(&gpd_list_lock);
|
|
|
|
}
|