2011-07-01 20:12:45 +00:00
|
|
|
/*
|
|
|
|
|
* pm_domain.h - Definitions and headers related to device power domains.
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Renesas Electronics Corp.
|
|
|
|
|
*
|
|
|
|
|
* This file is released under the GPLv2.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef _LINUX_PM_DOMAIN_H
|
|
|
|
|
#define _LINUX_PM_DOMAIN_H
|
|
|
|
|
|
|
|
|
|
#include <linux/device.h>
|
2012-01-30 16:46:54 +00:00
|
|
|
#include <linux/mutex.h>
|
|
|
|
|
#include <linux/pm.h>
|
2011-11-30 23:05:31 +00:00
|
|
|
#include <linux/err.h>
|
2012-01-27 06:22:07 +00:00
|
|
|
#include <linux/of.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-01 19:34:07 +00:00
|
|
|
#include <linux/notifier.h>
|
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-03 17:07:42 +00:00
|
|
|
#include <linux/cpuidle.h>
|
2011-07-01 20:12:45 +00:00
|
|
|
|
2011-07-11 22:39:29 +00:00
|
|
|
enum gpd_status {
|
|
|
|
|
GPD_STATE_ACTIVE = 0, /* PM domain is active */
|
2011-08-08 21:43:50 +00:00
|
|
|
GPD_STATE_WAIT_MASTER, /* PM domain's master is being waited for */
|
2011-07-11 22:39:29 +00:00
|
|
|
GPD_STATE_BUSY, /* Something is happening to the PM domain */
|
PM / Domains: Allow callbacks to execute all runtime PM helpers
A deadlock may occur if one of the PM domains' .start_device() or
.stop_device() callbacks or a device driver's .runtime_suspend() or
.runtime_resume() callback executed by the core generic PM domain
code uses a "wrong" runtime PM helper function. This happens, for
example, if .runtime_resume() from one device's driver calls
pm_runtime_resume() for another device in the same PM domain.
A similar situation may take place if a device's parent is in the
same PM domain, in which case the runtime PM framework may execute
pm_genpd_runtime_resume() automatically for the parent (if it is
suspended at the moment). This, of course, is undesirable, so
the generic PM domains code should be modified to prevent it from
happening.
The runtime PM framework guarantees that pm_genpd_runtime_suspend()
and pm_genpd_runtime_resume() won't be executed in parallel for
the same device, so the generic PM domains code need not worry
about those cases. Still, it needs to prevent the other possible
race conditions between pm_genpd_runtime_suspend(),
pm_genpd_runtime_resume(), pm_genpd_poweron() and pm_genpd_poweroff()
from happening and it needs to avoid deadlocks at the same time.
To this end, modify the generic PM domains code to relax
synchronization rules so that:
* pm_genpd_poweron() doesn't wait for the PM domain status to
change from GPD_STATE_BUSY. If it finds that the status is
not GPD_STATE_POWER_OFF, it returns without powering the domain on
(it may modify the status depending on the circumstances).
* pm_genpd_poweroff() returns as soon as it finds that the PM
domain's status changed from GPD_STATE_BUSY after it's released
the PM domain's lock.
* pm_genpd_runtime_suspend() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing the domain's
.stop_device() callback and executes pm_genpd_poweroff() only
if pm_genpd_runtime_resume() is not executed in parallel.
* pm_genpd_runtime_resume() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing pm_genpd_poweron()
and sets the domain's status to GPD_STATE_BUSY and increments its
counter of resuming devices (introduced by this change) immediately
after acquiring the lock. The counter of resuming devices is then
decremented after executing __pm_genpd_runtime_resume() for the
device and the domain's status is reset to GPD_STATE_ACTIVE (unless
there are more resuming devices in the domain, in which case the
status remains GPD_STATE_BUSY).
This way, for example, if a device driver's .runtime_resume()
callback executes pm_runtime_resume() for another device in the same
PM domain, pm_genpd_poweron() called by pm_genpd_runtime_resume()
invoked by the runtime PM framework will not block and it will see
that there's nothing to do for it. Next, the PM domain's lock will
be acquired without waiting for its status to change from
GPD_STATE_BUSY and the device driver's .runtime_resume() callback
will be executed. In turn, if pm_runtime_suspend() is executed by
one device driver's .runtime_resume() callback for another device in
the same PM domain, pm_genpd_poweroff() executed by
pm_genpd_runtime_suspend() invoked by the runtime PM framework as a
result will notice that one of the devices in the domain is being
resumed, so it will return immediately.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 22:39:36 +00:00
|
|
|
GPD_STATE_REPEAT, /* Power off in progress, to be repeated */
|
2011-07-11 22:39:29 +00:00
|
|
|
GPD_STATE_POWER_OFF, /* PM domain is off */
|
|
|
|
|
};
|
2011-07-01 20:13:19 +00:00
|
|
|
|
2011-07-01 20:12:45 +00:00
|
|
|
struct dev_power_governor {
|
|
|
|
|
bool (*power_down_ok)(struct dev_pm_domain *domain);
|
2011-11-30 23:02:05 +00:00
|
|
|
bool (*stop_ok)(struct device *dev);
|
2011-07-01 20:12:45 +00:00
|
|
|
};
|
|
|
|
|
|
2011-11-27 12:11:36 +00:00
|
|
|
struct gpd_dev_ops {
|
|
|
|
|
int (*start)(struct device *dev);
|
|
|
|
|
int (*stop)(struct device *dev);
|
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 12:11:44 +00:00
|
|
|
int (*save_state)(struct device *dev);
|
|
|
|
|
int (*restore_state)(struct device *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 12:11:51 +00:00
|
|
|
int (*suspend)(struct device *dev);
|
|
|
|
|
int (*suspend_late)(struct device *dev);
|
|
|
|
|
int (*resume_early)(struct device *dev);
|
|
|
|
|
int (*resume)(struct device *dev);
|
|
|
|
|
int (*freeze)(struct device *dev);
|
|
|
|
|
int (*freeze_late)(struct device *dev);
|
|
|
|
|
int (*thaw_early)(struct device *dev);
|
|
|
|
|
int (*thaw)(struct device *dev);
|
2011-11-27 12:11:36 +00:00
|
|
|
bool (*active_wakeup)(struct device *dev);
|
|
|
|
|
};
|
|
|
|
|
|
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-03 17:07:42 +00:00
|
|
|
struct gpd_cpu_data {
|
|
|
|
|
unsigned int saved_exit_latency;
|
|
|
|
|
struct cpuidle_state *idle_state;
|
|
|
|
|
};
|
|
|
|
|
|
2011-07-01 20:12:45 +00:00
|
|
|
struct generic_pm_domain {
|
|
|
|
|
struct dev_pm_domain domain; /* PM domain operations */
|
2011-07-13 10:31:52 +00:00
|
|
|
struct list_head gpd_list_node; /* Node in the global PM domains list */
|
2011-08-08 21:43:40 +00:00
|
|
|
struct list_head master_links; /* Links with PM domain as a master */
|
|
|
|
|
struct list_head slave_links; /* Links with PM domain as a slave */
|
2011-07-01 20:12:45 +00:00
|
|
|
struct list_head dev_list; /* List of devices */
|
|
|
|
|
struct mutex lock;
|
|
|
|
|
struct dev_power_governor *gov;
|
|
|
|
|
struct work_struct power_off_work;
|
2011-12-06 21:19:54 +00:00
|
|
|
char *name;
|
2011-07-01 20:12:45 +00:00
|
|
|
unsigned int in_progress; /* Number of devices being suspended now */
|
2011-08-08 21:43:04 +00:00
|
|
|
atomic_t sd_count; /* Number of subdomains with power "on" */
|
2011-07-11 22:39:29 +00:00
|
|
|
enum gpd_status status; /* Current state of the domain */
|
|
|
|
|
wait_queue_head_t status_wait_queue;
|
PM / Domains: Allow callbacks to execute all runtime PM helpers
A deadlock may occur if one of the PM domains' .start_device() or
.stop_device() callbacks or a device driver's .runtime_suspend() or
.runtime_resume() callback executed by the core generic PM domain
code uses a "wrong" runtime PM helper function. This happens, for
example, if .runtime_resume() from one device's driver calls
pm_runtime_resume() for another device in the same PM domain.
A similar situation may take place if a device's parent is in the
same PM domain, in which case the runtime PM framework may execute
pm_genpd_runtime_resume() automatically for the parent (if it is
suspended at the moment). This, of course, is undesirable, so
the generic PM domains code should be modified to prevent it from
happening.
The runtime PM framework guarantees that pm_genpd_runtime_suspend()
and pm_genpd_runtime_resume() won't be executed in parallel for
the same device, so the generic PM domains code need not worry
about those cases. Still, it needs to prevent the other possible
race conditions between pm_genpd_runtime_suspend(),
pm_genpd_runtime_resume(), pm_genpd_poweron() and pm_genpd_poweroff()
from happening and it needs to avoid deadlocks at the same time.
To this end, modify the generic PM domains code to relax
synchronization rules so that:
* pm_genpd_poweron() doesn't wait for the PM domain status to
change from GPD_STATE_BUSY. If it finds that the status is
not GPD_STATE_POWER_OFF, it returns without powering the domain on
(it may modify the status depending on the circumstances).
* pm_genpd_poweroff() returns as soon as it finds that the PM
domain's status changed from GPD_STATE_BUSY after it's released
the PM domain's lock.
* pm_genpd_runtime_suspend() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing the domain's
.stop_device() callback and executes pm_genpd_poweroff() only
if pm_genpd_runtime_resume() is not executed in parallel.
* pm_genpd_runtime_resume() doesn't wait for the PM domain status
to change from GPD_STATE_BUSY after executing pm_genpd_poweron()
and sets the domain's status to GPD_STATE_BUSY and increments its
counter of resuming devices (introduced by this change) immediately
after acquiring the lock. The counter of resuming devices is then
decremented after executing __pm_genpd_runtime_resume() for the
device and the domain's status is reset to GPD_STATE_ACTIVE (unless
there are more resuming devices in the domain, in which case the
status remains GPD_STATE_BUSY).
This way, for example, if a device driver's .runtime_resume()
callback executes pm_runtime_resume() for another device in the same
PM domain, pm_genpd_poweron() called by pm_genpd_runtime_resume()
invoked by the runtime PM framework will not block and it will see
that there's nothing to do for it. Next, the PM domain's lock will
be acquired without waiting for its status to change from
GPD_STATE_BUSY and the device driver's .runtime_resume() callback
will be executed. In turn, if pm_runtime_suspend() is executed by
one device driver's .runtime_resume() callback for another device in
the same PM domain, pm_genpd_poweroff() executed by
pm_genpd_runtime_suspend() invoked by the runtime PM framework as a
result will notice that one of the devices in the domain is being
resumed, so it will return immediately.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
2011-07-11 22:39:36 +00:00
|
|
|
struct task_struct *poweroff_task; /* Powering off task */
|
|
|
|
|
unsigned int resume_count; /* Number of devices being resumed */
|
2011-07-01 20:13:19 +00:00
|
|
|
unsigned int device_count; /* Number of devices */
|
|
|
|
|
unsigned int suspended_count; /* System suspend device counter */
|
|
|
|
|
unsigned int prepared_count; /* Suspend counter of prepared devices */
|
|
|
|
|
bool suspend_power_off; /* Power status before system suspend */
|
2011-08-25 13:37:04 +00:00
|
|
|
bool dev_irq_safe; /* Device callbacks are IRQ-safe */
|
2011-07-01 20:12:45 +00:00
|
|
|
int (*power_off)(struct generic_pm_domain *domain);
|
2011-11-30 23:02:10 +00:00
|
|
|
s64 power_off_latency_ns;
|
2011-07-01 20:12:45 +00:00
|
|
|
int (*power_on)(struct generic_pm_domain *domain);
|
2011-11-30 23:02:10 +00:00
|
|
|
s64 power_on_latency_ns;
|
2011-11-27 12:11:36 +00:00
|
|
|
struct gpd_dev_ops dev_ops;
|
2011-11-30 23:02:10 +00:00
|
|
|
s64 max_off_time_ns; /* Maximum allowed "suspended" time. */
|
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-01 19:34:07 +00:00
|
|
|
bool max_off_time_changed;
|
|
|
|
|
bool cached_power_down_ok;
|
2012-01-27 06:22:07 +00:00
|
|
|
struct device_node *of_node; /* Node in device tree */
|
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-03 17:07:42 +00:00
|
|
|
struct gpd_cpu_data *cpu_data;
|
2011-07-01 20:12:45 +00:00
|
|
|
};
|
|
|
|
|
|
2011-07-01 20:13:19 +00:00
|
|
|
static inline struct generic_pm_domain *pd_to_genpd(struct dev_pm_domain *pd)
|
|
|
|
|
{
|
|
|
|
|
return container_of(pd, struct generic_pm_domain, domain);
|
|
|
|
|
}
|
|
|
|
|
|
2011-08-08 21:43:40 +00:00
|
|
|
struct gpd_link {
|
|
|
|
|
struct generic_pm_domain *master;
|
|
|
|
|
struct list_head master_node;
|
|
|
|
|
struct generic_pm_domain *slave;
|
|
|
|
|
struct list_head slave_node;
|
|
|
|
|
};
|
|
|
|
|
|
2011-11-30 23:02:05 +00:00
|
|
|
struct gpd_timing_data {
|
|
|
|
|
s64 stop_latency_ns;
|
|
|
|
|
s64 start_latency_ns;
|
2011-11-30 23:02:10 +00:00
|
|
|
s64 save_state_latency_ns;
|
|
|
|
|
s64 restore_state_latency_ns;
|
2012-04-29 20:54:17 +00:00
|
|
|
s64 effective_constraint_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-01 19:34:07 +00:00
|
|
|
bool constraint_changed;
|
|
|
|
|
bool cached_stop_ok;
|
2011-11-30 23:02:05 +00:00
|
|
|
};
|
|
|
|
|
|
2011-09-26 18:22:02 +00:00
|
|
|
struct generic_pm_domain_data {
|
|
|
|
|
struct pm_domain_data base;
|
2011-11-27 12:11:36 +00:00
|
|
|
struct gpd_dev_ops ops;
|
2011-11-30 23:02:05 +00:00
|
|
|
struct gpd_timing_data td;
|
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-01 19:34:07 +00:00
|
|
|
struct notifier_block nb;
|
|
|
|
|
struct mutex lock;
|
2012-07-05 20:12:32 +00:00
|
|
|
unsigned int refcount;
|
2011-09-26 18:22:02 +00:00
|
|
|
bool need_restore;
|
|
|
|
|
};
|
|
|
|
|
|
2012-02-04 21:26:49 +00:00
|
|
|
#ifdef CONFIG_PM_GENERIC_DOMAINS
|
2011-09-26 18:22:02 +00:00
|
|
|
static inline struct generic_pm_domain_data *to_gpd_data(struct pm_domain_data *pdd)
|
|
|
|
|
{
|
|
|
|
|
return container_of(pdd, struct generic_pm_domain_data, base);
|
|
|
|
|
}
|
|
|
|
|
|
2011-11-27 12:11:36 +00:00
|
|
|
static inline struct generic_pm_domain_data *dev_gpd_data(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
return to_gpd_data(dev->power.subsys_data->domain_data);
|
|
|
|
|
}
|
|
|
|
|
|
2011-11-30 23:02:05 +00:00
|
|
|
extern struct dev_power_governor simple_qos_governor;
|
|
|
|
|
|
|
|
|
|
extern struct generic_pm_domain *dev_to_genpd(struct device *dev);
|
|
|
|
|
extern int __pm_genpd_add_device(struct generic_pm_domain *genpd,
|
|
|
|
|
struct device *dev,
|
|
|
|
|
struct gpd_timing_data *td);
|
|
|
|
|
|
2012-01-27 06:22:07 +00:00
|
|
|
extern int __pm_genpd_of_add_device(struct device_node *genpd_node,
|
|
|
|
|
struct device *dev,
|
|
|
|
|
struct gpd_timing_data *td);
|
|
|
|
|
|
2012-08-06 23:06:11 +00:00
|
|
|
extern int __pm_genpd_name_add_device(const char *domain_name,
|
|
|
|
|
struct device *dev,
|
|
|
|
|
struct gpd_timing_data *td);
|
2012-01-27 06:22:07 +00:00
|
|
|
|
2011-07-01 20:12:45 +00:00
|
|
|
extern int pm_genpd_remove_device(struct generic_pm_domain *genpd,
|
|
|
|
|
struct device *dev);
|
2012-05-14 19:45:52 +00:00
|
|
|
extern void pm_genpd_dev_need_restore(struct device *dev, bool val);
|
2011-07-01 20:12:45 +00:00
|
|
|
extern int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
|
|
|
|
|
struct generic_pm_domain *new_subdomain);
|
2012-08-06 23:08:37 +00:00
|
|
|
extern int pm_genpd_add_subdomain_names(const char *master_name,
|
|
|
|
|
const char *subdomain_name);
|
2011-07-01 20:12:45 +00:00
|
|
|
extern int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
|
|
|
|
|
struct generic_pm_domain *target);
|
2011-11-30 23:02:05 +00:00
|
|
|
extern int pm_genpd_add_callbacks(struct device *dev,
|
|
|
|
|
struct gpd_dev_ops *ops,
|
|
|
|
|
struct gpd_timing_data *td);
|
|
|
|
|
extern int __pm_genpd_remove_callbacks(struct device *dev, bool clear_td);
|
2012-08-15 18:32:43 +00:00
|
|
|
extern int pm_genpd_attach_cpuidle(struct generic_pm_domain *genpd, int state);
|
2012-08-15 18:32:59 +00:00
|
|
|
extern int pm_genpd_name_attach_cpuidle(const char *name, int state);
|
2012-08-15 18:32:43 +00:00
|
|
|
extern int pm_genpd_detach_cpuidle(struct generic_pm_domain *genpd);
|
2012-08-15 18:32:59 +00:00
|
|
|
extern int pm_genpd_name_detach_cpuidle(const char *name);
|
2011-07-01 20:12:45 +00:00
|
|
|
extern void pm_genpd_init(struct generic_pm_domain *genpd,
|
|
|
|
|
struct dev_power_governor *gov, bool is_off);
|
2011-11-30 23:02:05 +00:00
|
|
|
|
2011-07-10 08:39:14 +00:00
|
|
|
extern int pm_genpd_poweron(struct generic_pm_domain *genpd);
|
2012-08-06 23:11:14 +00:00
|
|
|
extern int pm_genpd_name_poweron(const char *domain_name);
|
2011-11-30 23:02:05 +00:00
|
|
|
|
|
|
|
|
extern bool default_stop_ok(struct device *dev);
|
|
|
|
|
|
2011-12-08 22:27:28 +00:00
|
|
|
extern struct dev_power_governor pm_domain_always_on_gov;
|
2011-07-01 20:12:45 +00:00
|
|
|
#else
|
2011-11-30 23:02:05 +00:00
|
|
|
|
2012-02-25 21:14:18 +00:00
|
|
|
static inline struct generic_pm_domain_data *dev_gpd_data(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
return ERR_PTR(-ENOSYS);
|
|
|
|
|
}
|
2011-11-30 23:02:05 +00:00
|
|
|
static inline struct generic_pm_domain *dev_to_genpd(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
return ERR_PTR(-ENOSYS);
|
|
|
|
|
}
|
|
|
|
|
static inline int __pm_genpd_add_device(struct generic_pm_domain *genpd,
|
|
|
|
|
struct device *dev,
|
|
|
|
|
struct gpd_timing_data *td)
|
|
|
|
|
{
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
2012-08-06 23:06:11 +00:00
|
|
|
static inline int __pm_genpd_of_add_device(struct device_node *genpd_node,
|
|
|
|
|
struct device *dev,
|
|
|
|
|
struct gpd_timing_data *td)
|
|
|
|
|
{
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
|
|
|
|
static inline int __pm_genpd_name_add_device(const char *domain_name,
|
|
|
|
|
struct device *dev,
|
|
|
|
|
struct gpd_timing_data *td)
|
2011-07-01 20:12:45 +00:00
|
|
|
{
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
|
|
|
|
static inline int pm_genpd_remove_device(struct generic_pm_domain *genpd,
|
|
|
|
|
struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
2012-05-14 19:45:52 +00:00
|
|
|
static inline void pm_genpd_dev_need_restore(struct device *dev, bool val) {}
|
2011-07-01 20:12:45 +00:00
|
|
|
static inline int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
|
|
|
|
|
struct generic_pm_domain *new_sd)
|
|
|
|
|
{
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
2012-08-06 23:08:37 +00:00
|
|
|
static inline int pm_genpd_add_subdomain_names(const char *master_name,
|
|
|
|
|
const char *subdomain_name)
|
|
|
|
|
{
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
2011-07-01 20:12:45 +00:00
|
|
|
static inline int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
|
|
|
|
|
struct generic_pm_domain *target)
|
|
|
|
|
{
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
2011-11-27 12:11:36 +00:00
|
|
|
static inline int pm_genpd_add_callbacks(struct device *dev,
|
2011-11-30 23:02:05 +00:00
|
|
|
struct gpd_dev_ops *ops,
|
|
|
|
|
struct gpd_timing_data *td)
|
2011-11-27 12:11:36 +00:00
|
|
|
{
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
2011-11-30 23:02:05 +00:00
|
|
|
static inline int __pm_genpd_remove_callbacks(struct device *dev, bool clear_td)
|
2011-11-27 12:11:36 +00:00
|
|
|
{
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
2012-08-15 18:32:43 +00:00
|
|
|
static inline int pm_genpd_attach_cpuidle(struct generic_pm_domain *genpd, int st)
|
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-03 17:07:42 +00:00
|
|
|
{
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
2012-08-15 18:32:59 +00:00
|
|
|
static inline int pm_genpd_name_attach_cpuidle(const char *name, int state)
|
|
|
|
|
{
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
2012-08-15 18:32:43 +00:00
|
|
|
static inline 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-03 17:07:42 +00:00
|
|
|
{
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
2012-08-15 18:32:59 +00:00
|
|
|
static inline int pm_genpd_name_detach_cpuidle(const char *name)
|
|
|
|
|
{
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
2012-02-25 21:14:18 +00:00
|
|
|
static inline void pm_genpd_init(struct generic_pm_domain *genpd,
|
|
|
|
|
struct dev_power_governor *gov, bool is_off)
|
2011-11-30 23:02:05 +00:00
|
|
|
{
|
|
|
|
|
}
|
2011-07-10 08:39:14 +00:00
|
|
|
static inline int pm_genpd_poweron(struct generic_pm_domain *genpd)
|
|
|
|
|
{
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
2012-08-06 23:11:14 +00:00
|
|
|
static inline int pm_genpd_name_poweron(const char *domain_name)
|
|
|
|
|
{
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
2011-11-30 23:02:05 +00:00
|
|
|
static inline bool default_stop_ok(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2012-02-25 21:14:18 +00:00
|
|
|
#define simple_qos_governor NULL
|
2011-12-08 22:27:28 +00:00
|
|
|
#define pm_domain_always_on_gov NULL
|
2011-08-14 11:34:31 +00:00
|
|
|
#endif
|
|
|
|
|
|
2012-08-06 23:06:11 +00:00
|
|
|
static inline int pm_genpd_add_device(struct generic_pm_domain *genpd,
|
|
|
|
|
struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
return __pm_genpd_add_device(genpd, dev, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int pm_genpd_of_add_device(struct device_node *genpd_node,
|
|
|
|
|
struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
return __pm_genpd_of_add_device(genpd_node, dev, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int pm_genpd_name_add_device(const char *domain_name,
|
|
|
|
|
struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
return __pm_genpd_name_add_device(domain_name, dev, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
2011-11-30 23:02:05 +00:00
|
|
|
static inline int pm_genpd_remove_callbacks(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
return __pm_genpd_remove_callbacks(dev, true);
|
|
|
|
|
}
|
|
|
|
|
|
2011-08-14 11:34:31 +00:00
|
|
|
#ifdef CONFIG_PM_GENERIC_DOMAINS_RUNTIME
|
|
|
|
|
extern void genpd_queue_power_off_work(struct generic_pm_domain *genpd);
|
|
|
|
|
extern void pm_genpd_poweroff_unused(void);
|
|
|
|
|
#else
|
2011-07-14 18:59:07 +00:00
|
|
|
static inline void genpd_queue_power_off_work(struct generic_pm_domain *gpd) {}
|
2011-08-14 11:34:31 +00:00
|
|
|
static inline void pm_genpd_poweroff_unused(void) {}
|
2011-07-01 20:12:45 +00:00
|
|
|
#endif
|
|
|
|
|
|
2012-08-05 23:39:57 +00:00
|
|
|
#ifdef CONFIG_PM_GENERIC_DOMAINS_SLEEP
|
|
|
|
|
extern void pm_genpd_syscore_switch(struct device *dev, bool suspend);
|
|
|
|
|
#else
|
|
|
|
|
static inline void pm_genpd_syscore_switch(struct device *dev, bool suspend) {}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
static inline void pm_genpd_syscore_poweroff(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
pm_genpd_syscore_switch(dev, true);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void pm_genpd_syscore_poweron(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
pm_genpd_syscore_switch(dev, false);
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-01 20:12:45 +00:00
|
|
|
#endif /* _LINUX_PM_DOMAIN_H */
|