2011-07-01 14:12:45 -06: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>
|
2011-11-30 16:05:31 -07:00
|
|
|
#include <linux/err.h>
|
2012-01-26 23:22:07 -07:00
|
|
|
#include <linux/of.h>
|
2011-07-01 14:12:45 -06:00
|
|
|
|
2011-07-11 16:39:29 -06:00
|
|
|
enum gpd_status {
|
|
|
|
|
GPD_STATE_ACTIVE = 0, /* PM domain is active */
|
2011-08-08 15:43:50 -06:00
|
|
|
GPD_STATE_WAIT_MASTER, /* PM domain's master is being waited for */
|
2011-07-11 16:39:29 -06: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 16:39:36 -06:00
|
|
|
GPD_STATE_REPEAT, /* Power off in progress, to be repeated */
|
2011-07-11 16:39:29 -06:00
|
|
|
GPD_STATE_POWER_OFF, /* PM domain is off */
|
|
|
|
|
};
|
2011-07-01 14:13:19 -06:00
|
|
|
|
2011-07-01 14:12:45 -06:00
|
|
|
struct dev_power_governor {
|
|
|
|
|
bool (*power_down_ok)(struct dev_pm_domain *domain);
|
2011-11-30 16:02:05 -07:00
|
|
|
bool (*stop_ok)(struct device *dev);
|
2011-07-01 14:12:45 -06:00
|
|
|
};
|
|
|
|
|
|
2011-11-27 05:11:36 -07: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 05:11:44 -07: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 05:11:51 -07: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 05:11:36 -07:00
|
|
|
bool (*active_wakeup)(struct device *dev);
|
|
|
|
|
};
|
|
|
|
|
|
2011-07-01 14:12:45 -06:00
|
|
|
struct generic_pm_domain {
|
|
|
|
|
struct dev_pm_domain domain; /* PM domain operations */
|
2011-07-13 04:31:52 -06:00
|
|
|
struct list_head gpd_list_node; /* Node in the global PM domains list */
|
2011-08-08 15:43:40 -06: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 14:12:45 -06: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 14:19:54 -07:00
|
|
|
char *name;
|
2011-07-01 14:12:45 -06:00
|
|
|
unsigned int in_progress; /* Number of devices being suspended now */
|
2011-08-08 15:43:04 -06:00
|
|
|
atomic_t sd_count; /* Number of subdomains with power "on" */
|
2011-07-11 16:39:29 -06: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 16:39:36 -06:00
|
|
|
struct task_struct *poweroff_task; /* Powering off task */
|
|
|
|
|
unsigned int resume_count; /* Number of devices being resumed */
|
2011-07-01 14:13:19 -06: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 07:37:04 -06:00
|
|
|
bool dev_irq_safe; /* Device callbacks are IRQ-safe */
|
2011-07-01 14:12:45 -06:00
|
|
|
int (*power_off)(struct generic_pm_domain *domain);
|
2011-11-30 16:02:10 -07:00
|
|
|
s64 power_off_latency_ns;
|
2011-07-01 14:12:45 -06:00
|
|
|
int (*power_on)(struct generic_pm_domain *domain);
|
2011-11-30 16:02:10 -07:00
|
|
|
s64 power_on_latency_ns;
|
2011-11-27 05:11:36 -07:00
|
|
|
struct gpd_dev_ops dev_ops;
|
2011-11-30 16:02:10 -07:00
|
|
|
s64 break_even_ns; /* Power break even for the entire domain. */
|
|
|
|
|
s64 max_off_time_ns; /* Maximum allowed "suspended" time. */
|
|
|
|
|
ktime_t power_off_time;
|
2012-01-26 23:22:07 -07:00
|
|
|
struct device_node *of_node; /* Node in device tree */
|
2011-07-01 14:12:45 -06:00
|
|
|
};
|
|
|
|
|
|
2011-07-01 14:13:19 -06: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 15:43:40 -06: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 16:02:05 -07:00
|
|
|
struct gpd_timing_data {
|
|
|
|
|
s64 stop_latency_ns;
|
|
|
|
|
s64 start_latency_ns;
|
2011-11-30 16:02:10 -07:00
|
|
|
s64 save_state_latency_ns;
|
|
|
|
|
s64 restore_state_latency_ns;
|
2011-11-30 16:02:05 -07:00
|
|
|
s64 break_even_ns;
|
|
|
|
|
};
|
|
|
|
|
|
2011-09-26 12:22:02 -06:00
|
|
|
struct generic_pm_domain_data {
|
|
|
|
|
struct pm_domain_data base;
|
2011-11-27 05:11:36 -07:00
|
|
|
struct gpd_dev_ops ops;
|
2011-11-30 16:02:05 -07:00
|
|
|
struct gpd_timing_data td;
|
2011-09-26 12:22:02 -06:00
|
|
|
bool need_restore;
|
|
|
|
|
};
|
|
|
|
|
|
2012-02-04 14:26:49 -07:00
|
|
|
#ifdef CONFIG_PM_GENERIC_DOMAINS
|
2011-09-26 12:22:02 -06: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 05:11:36 -07: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 16:02:05 -07: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-26 23:22:07 -07:00
|
|
|
extern int __pm_genpd_of_add_device(struct device_node *genpd_node,
|
|
|
|
|
struct device *dev,
|
|
|
|
|
struct gpd_timing_data *td);
|
|
|
|
|
|
2011-11-30 16:02:05 -07:00
|
|
|
static inline int pm_genpd_add_device(struct generic_pm_domain *genpd,
|
|
|
|
|
struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
return __pm_genpd_add_device(genpd, dev, NULL);
|
|
|
|
|
}
|
|
|
|
|
|
2012-01-26 23:22:07 -07:00
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-01 14:12:45 -06:00
|
|
|
extern int pm_genpd_remove_device(struct generic_pm_domain *genpd,
|
|
|
|
|
struct device *dev);
|
|
|
|
|
extern int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
|
|
|
|
|
struct generic_pm_domain *new_subdomain);
|
|
|
|
|
extern int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
|
|
|
|
|
struct generic_pm_domain *target);
|
2011-11-30 16:02:05 -07: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);
|
2011-07-01 14:12:45 -06:00
|
|
|
extern void pm_genpd_init(struct generic_pm_domain *genpd,
|
|
|
|
|
struct dev_power_governor *gov, bool is_off);
|
2011-11-30 16:02:05 -07:00
|
|
|
|
2011-07-10 02:39:14 -06:00
|
|
|
extern int pm_genpd_poweron(struct generic_pm_domain *genpd);
|
2011-11-30 16:02:05 -07:00
|
|
|
|
|
|
|
|
extern bool default_stop_ok(struct device *dev);
|
|
|
|
|
|
2011-12-08 15:27:28 -07:00
|
|
|
extern struct dev_power_governor pm_domain_always_on_gov;
|
2011-07-01 14:12:45 -06:00
|
|
|
#else
|
2011-11-30 16:02:05 -07: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;
|
|
|
|
|
}
|
2011-07-01 14:12:45 -06:00
|
|
|
static inline int pm_genpd_add_device(struct generic_pm_domain *genpd,
|
|
|
|
|
struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
|
|
|
|
static inline int pm_genpd_remove_device(struct generic_pm_domain *genpd,
|
|
|
|
|
struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
|
|
|
|
static inline int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
|
|
|
|
|
struct generic_pm_domain *new_sd)
|
|
|
|
|
{
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
|
|
|
|
static inline int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
|
|
|
|
|
struct generic_pm_domain *target)
|
|
|
|
|
{
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
2011-11-27 05:11:36 -07:00
|
|
|
static inline int pm_genpd_add_callbacks(struct device *dev,
|
2011-11-30 16:02:05 -07:00
|
|
|
struct gpd_dev_ops *ops,
|
|
|
|
|
struct gpd_timing_data *td)
|
2011-11-27 05:11:36 -07:00
|
|
|
{
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
2011-11-30 16:02:05 -07:00
|
|
|
static inline int __pm_genpd_remove_callbacks(struct device *dev, bool clear_td)
|
2011-11-27 05:11:36 -07:00
|
|
|
{
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
2011-11-30 16:02:05 -07:00
|
|
|
static inline void pm_genpd_init(struct generic_pm_domain *genpd, bool is_off)
|
|
|
|
|
{
|
|
|
|
|
}
|
2011-07-10 02:39:14 -06:00
|
|
|
static inline int pm_genpd_poweron(struct generic_pm_domain *genpd)
|
|
|
|
|
{
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
2011-11-30 16:02:05 -07:00
|
|
|
static inline bool default_stop_ok(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2011-12-08 15:27:28 -07:00
|
|
|
#define pm_domain_always_on_gov NULL
|
2012-02-04 14:26:49 -07:00
|
|
|
static inline struct generic_pm_domain_data *dev_gpd_data(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
2011-08-14 05:34:31 -06:00
|
|
|
#endif
|
|
|
|
|
|
2011-11-30 16:02:05 -07:00
|
|
|
static inline int pm_genpd_remove_callbacks(struct device *dev)
|
|
|
|
|
{
|
|
|
|
|
return __pm_genpd_remove_callbacks(dev, true);
|
|
|
|
|
}
|
|
|
|
|
|
2011-08-14 05:34:31 -06: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 12:59:07 -06:00
|
|
|
static inline void genpd_queue_power_off_work(struct generic_pm_domain *gpd) {}
|
2011-08-14 05:34:31 -06:00
|
|
|
static inline void pm_genpd_poweroff_unused(void) {}
|
2011-07-01 14:12:45 -06:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#endif /* _LINUX_PM_DOMAIN_H */
|