UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

PM / Domains: Do not execute device callbacks under locks 

Currently, the .start_device() and .stop_device() callbacks from
struct generic_pm_domain() as well as the device drivers' runtime PM
callbacks used by the generic PM domains code are executed under
the generic PM domain lock.  This, unfortunately, is prone to
deadlocks, for example if a device and its parent are boths members
of the same PM domain.  For this reason, it would be better if the
PM domains code didn't execute device callbacks under the lock.

Rework the locking in the generic PM domains code so that the lock
is dropped for the execution of device callbacks.  To this end,
introduce PM domains states reflecting the current status of a PM
domain and such that the PM domain lock cannot be acquired if the
status is GPD_STATE_BUSY.  Make threads attempting to acquire a PM
domain's lock wait until the status changes to either
GPD_STATE_ACTIVE or GPD_STATE_POWER_OFF.

This change by itself doesn't fix the deadlock problem mentioned
above, but the mechanism introduced by it will be used for for this
purpose by a subsequent patch.

Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
This commit is contained in:
Rafael J. Wysocki 2011-07-12 00:39:29 +02:00
parent b6c10c8466
commit 17b75eca76
2 changed files with 185 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

249
drivers/base/power/domain.c
View File

@ -13,6 +13,8 @@
#include <linux/pm_domain.h> #include <linux/pm_domain.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/err.h> #include <linux/err.h>
#include <linux/sched.h>
#include <linux/suspend.h>
#ifdef CONFIG_PM #ifdef CONFIG_PM
@ -30,6 +32,34 @@ static void genpd_sd_counter_dec(struct generic_pm_domain *genpd)
genpd->sd_count--; genpd->sd_count--;
} }
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);
if (genpd->status != GPD_STATE_BUSY)
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_genpd_poweron - Restore power to a given PM domain and its parents. * pm_genpd_poweron - Restore power to a given PM domain and its parents.
* @genpd: PM domain to power up. * @genpd: PM domain to power up.
@ -39,22 +69,50 @@ static void genpd_sd_counter_dec(struct generic_pm_domain *genpd)
*/ */
int pm_genpd_poweron(struct generic_pm_domain *genpd) int pm_genpd_poweron(struct generic_pm_domain *genpd)
{ {
struct generic_pm_domain *parent = genpd->parent;
DEFINE_WAIT(wait);
int ret = 0; int ret = 0;
start: start:
if (genpd->parent) if (parent) {
mutex_lock(&genpd->parent->lock); mutex_lock(&parent->lock);
mutex_lock_nested(&genpd->lock, SINGLE_DEPTH_NESTING); mutex_lock_nested(&genpd->lock, SINGLE_DEPTH_NESTING);
} else {
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);
if (genpd->status != GPD_STATE_BUSY)
break;
mutex_unlock(&genpd->lock);
if (parent)
mutex_unlock(&parent->lock);
if (!genpd->power_is_off schedule();
if (parent) {
mutex_lock(&parent->lock);
mutex_lock_nested(&genpd->lock, SINGLE_DEPTH_NESTING);
} else {
mutex_lock(&genpd->lock);
}
}
finish_wait(&genpd->status_wait_queue, &wait);
if (genpd->status == GPD_STATE_ACTIVE
|| (genpd->prepared_count > 0 && genpd->suspend_power_off)) || (genpd->prepared_count > 0 && genpd->suspend_power_off))
goto out; goto out;
if (genpd->parent && genpd->parent->power_is_off) { if (parent && parent->status != GPD_STATE_ACTIVE) {
mutex_unlock(&genpd->lock); mutex_unlock(&genpd->lock);
mutex_unlock(&genpd->parent->lock); mutex_unlock(&parent->lock);
ret = pm_genpd_poweron(genpd->parent); ret = pm_genpd_poweron(parent);
if (ret) if (ret)
return ret; return ret;
@ -67,14 +125,14 @@ int pm_genpd_poweron(struct generic_pm_domain *genpd)
goto out; goto out;
} }
genpd->power_is_off = false; genpd->status = GPD_STATE_ACTIVE;
if (genpd->parent) if (parent)
genpd->parent->sd_count++; parent->sd_count++;
out: out:
mutex_unlock(&genpd->lock); mutex_unlock(&genpd->lock);
if (genpd->parent) if (parent)
mutex_unlock(&genpd->parent->lock); mutex_unlock(&parent->lock);
return ret; return ret;
} }
@ -90,6 +148,7 @@ int pm_genpd_poweron(struct generic_pm_domain *genpd)
*/ */
static int __pm_genpd_save_device(struct dev_list_entry *dle, static int __pm_genpd_save_device(struct dev_list_entry *dle,
struct generic_pm_domain *genpd) struct generic_pm_domain *genpd)
__releases(&genpd->lock) __acquires(&genpd->lock)
{ {
struct device *dev = dle->dev; struct device *dev = dle->dev;
struct device_driver *drv = dev->driver; struct device_driver *drv = dev->driver;
@ -98,6 +157,8 @@ static int __pm_genpd_save_device(struct dev_list_entry *dle,
if (dle->need_restore) if (dle->need_restore)
return 0; return 0;
mutex_unlock(&genpd->lock);
if (drv && drv->pm && drv->pm->runtime_suspend) { if (drv && drv->pm && drv->pm->runtime_suspend) {
if (genpd->start_device) if (genpd->start_device)
genpd->start_device(dev); genpd->start_device(dev);
@ -108,6 +169,8 @@ static int __pm_genpd_save_device(struct dev_list_entry *dle,
genpd->stop_device(dev); genpd->stop_device(dev);
} }
mutex_lock(&genpd->lock);
if (!ret) if (!ret)
dle->need_restore = true; dle->need_restore = true;
@ -121,6 +184,7 @@ static int __pm_genpd_save_device(struct dev_list_entry *dle,
*/ */
static void __pm_genpd_restore_device(struct dev_list_entry *dle, static void __pm_genpd_restore_device(struct dev_list_entry *dle,
struct generic_pm_domain *genpd) struct generic_pm_domain *genpd)
__releases(&genpd->lock) __acquires(&genpd->lock)
{ {
struct device *dev = dle->dev; struct device *dev = dle->dev;
struct device_driver *drv = dev->driver; struct device_driver *drv = dev->driver;
@ -128,6 +192,8 @@ static void __pm_genpd_restore_device(struct dev_list_entry *dle,
if (!dle->need_restore) if (!dle->need_restore)
return; return;
mutex_unlock(&genpd->lock);
if (drv && drv->pm && drv->pm->runtime_resume) { if (drv && drv->pm && drv->pm->runtime_resume) {
if (genpd->start_device) if (genpd->start_device)
genpd->start_device(dev); genpd->start_device(dev);
@ -138,6 +204,8 @@ static void __pm_genpd_restore_device(struct dev_list_entry *dle,
genpd->stop_device(dev); genpd->stop_device(dev);
} }
mutex_lock(&genpd->lock);
dle->need_restore = false; dle->need_restore = false;
} }
@ -150,13 +218,14 @@ static void __pm_genpd_restore_device(struct dev_list_entry *dle,
* the @genpd's devices' drivers and remove power from @genpd. * the @genpd's devices' drivers and remove power from @genpd.
*/ */
static int pm_genpd_poweroff(struct generic_pm_domain *genpd) static int pm_genpd_poweroff(struct generic_pm_domain *genpd)
__releases(&genpd->lock) __acquires(&genpd->lock)
{ {
struct generic_pm_domain *parent; struct generic_pm_domain *parent;
struct dev_list_entry *dle; struct dev_list_entry *dle;
unsigned int not_suspended; unsigned int not_suspended;
int ret; int ret;
if (genpd->power_is_off || genpd->prepared_count > 0) if (genpd->status == GPD_STATE_POWER_OFF || genpd->prepared_count > 0)
return 0; return 0;
if (genpd->sd_count > 0) if (genpd->sd_count > 0)
@ -175,22 +244,36 @@ static int pm_genpd_poweroff(struct generic_pm_domain *genpd)
return -EAGAIN; return -EAGAIN;
} }
genpd->status = GPD_STATE_BUSY;
list_for_each_entry_reverse(dle, &genpd->dev_list, node) { list_for_each_entry_reverse(dle, &genpd->dev_list, node) {
ret = __pm_genpd_save_device(dle, genpd); ret = __pm_genpd_save_device(dle, genpd);
if (ret) if (ret)
goto err_dev; goto err_dev;
} }
mutex_unlock(&genpd->lock);
parent = genpd->parent;
if (parent) {
genpd_acquire_lock(parent);
mutex_lock_nested(&genpd->lock, SINGLE_DEPTH_NESTING);
} else {
mutex_lock(&genpd->lock);
}
if (genpd->power_off) if (genpd->power_off)
genpd->power_off(genpd); genpd->power_off(genpd);
genpd->power_is_off = true; genpd->status = GPD_STATE_POWER_OFF;
wake_up_all(&genpd->status_wait_queue);
parent = genpd->parent;
if (parent) { if (parent) {
genpd_sd_counter_dec(parent); genpd_sd_counter_dec(parent);
if (parent->sd_count == 0) if (parent->sd_count == 0)
queue_work(pm_wq, &parent->power_off_work); queue_work(pm_wq, &parent->power_off_work);
genpd_release_lock(parent);
} }
return 0; return 0;
@ -199,6 +282,9 @@ static int pm_genpd_poweroff(struct generic_pm_domain *genpd)
list_for_each_entry_continue(dle, &genpd->dev_list, node) list_for_each_entry_continue(dle, &genpd->dev_list, node)
__pm_genpd_restore_device(dle, genpd); __pm_genpd_restore_device(dle, genpd);
genpd->status = GPD_STATE_ACTIVE;
wake_up_all(&genpd->status_wait_queue);
return ret; return ret;
} }
@ -212,13 +298,9 @@ static void genpd_power_off_work_fn(struct work_struct *work)
genpd = container_of(work, struct generic_pm_domain, power_off_work); genpd = container_of(work, struct generic_pm_domain, power_off_work);
if (genpd->parent) genpd_acquire_lock(genpd);
mutex_lock(&genpd->parent->lock);
mutex_lock_nested(&genpd->lock, SINGLE_DEPTH_NESTING);
pm_genpd_poweroff(genpd); pm_genpd_poweroff(genpd);
mutex_unlock(&genpd->lock); genpd_release_lock(genpd);
if (genpd->parent)
mutex_unlock(&genpd->parent->lock);
} }
/** /**
@ -239,23 +321,17 @@ static int pm_genpd_runtime_suspend(struct device *dev)
if (IS_ERR(genpd)) if (IS_ERR(genpd))
return -EINVAL; return -EINVAL;
if (genpd->parent)
mutex_lock(&genpd->parent->lock);
mutex_lock_nested(&genpd->lock, SINGLE_DEPTH_NESTING);
if (genpd->stop_device) { if (genpd->stop_device) {
int ret = genpd->stop_device(dev); int ret = genpd->stop_device(dev);
if (ret) if (ret)
goto out; return ret;
} }
genpd_acquire_lock(genpd);
genpd->in_progress++; genpd->in_progress++;
pm_genpd_poweroff(genpd); pm_genpd_poweroff(genpd);
genpd->in_progress--; genpd->in_progress--;
genpd_release_lock(genpd);
out:
mutex_unlock(&genpd->lock);
if (genpd->parent)
mutex_unlock(&genpd->parent->lock);
return 0; return 0;
} }
@ -276,9 +352,6 @@ static void __pm_genpd_runtime_resume(struct device *dev,
break; break;
} }
} }
if (genpd->start_device)
genpd->start_device(dev);
} }
/** /**
@ -304,9 +377,15 @@ static int pm_genpd_runtime_resume(struct device *dev)
if (ret) if (ret)
return ret; return ret;
mutex_lock(&genpd->lock); genpd_acquire_lock(genpd);
genpd->status = GPD_STATE_BUSY;
__pm_genpd_runtime_resume(dev, genpd); __pm_genpd_runtime_resume(dev, genpd);
mutex_unlock(&genpd->lock); genpd->status = GPD_STATE_ACTIVE;
wake_up_all(&genpd->status_wait_queue);
genpd_release_lock(genpd);
if (genpd->start_device)
genpd->start_device(dev);
return 0; return 0;
} }
@ -339,7 +418,7 @@ static void pm_genpd_sync_poweroff(struct generic_pm_domain *genpd)
{ {
struct generic_pm_domain *parent = genpd->parent; struct generic_pm_domain *parent = genpd->parent;
if (genpd->power_is_off) if (genpd->status == GPD_STATE_POWER_OFF)
return; return;
if (genpd->suspended_count != genpd->device_count || genpd->sd_count > 0) if (genpd->suspended_count != genpd->device_count || genpd->sd_count > 0)
@ -348,7 +427,7 @@ static void pm_genpd_sync_poweroff(struct generic_pm_domain *genpd)
if (genpd->power_off) if (genpd->power_off)
genpd->power_off(genpd); genpd->power_off(genpd);
genpd->power_is_off = true; genpd->status = GPD_STATE_POWER_OFF;
if (parent) { if (parent) {
genpd_sd_counter_dec(parent); genpd_sd_counter_dec(parent);
pm_genpd_sync_poweroff(parent); pm_genpd_sync_poweroff(parent);
@ -375,32 +454,41 @@ static int pm_genpd_prepare(struct device *dev)
if (IS_ERR(genpd)) if (IS_ERR(genpd))
return -EINVAL; return -EINVAL;
mutex_lock(&genpd->lock); /*
* 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;
}
genpd_acquire_lock(genpd);
if (genpd->prepared_count++ == 0) if (genpd->prepared_count++ == 0)
genpd->suspend_power_off = genpd->power_is_off; genpd->suspend_power_off = genpd->status == GPD_STATE_POWER_OFF;
genpd_release_lock(genpd);
if (genpd->suspend_power_off) { if (genpd->suspend_power_off) {
mutex_unlock(&genpd->lock); pm_runtime_put_noidle(dev);
return 0; return 0;
} }
/* /*
* If the device is in the (runtime) "suspended" state, call * The PM domain must be in the GPD_STATE_ACTIVE state at this point,
* .start_device() for it, if defined. * so pm_genpd_poweron() will return immediately, but if the device
*/ * is suspended (e.g. it's been stopped by .stop_device()), we need
if (pm_runtime_suspended(dev)) * to make it operational.
__pm_genpd_runtime_resume(dev, genpd);
/*
* Do not check if runtime resume is pending at this point, because it
* has been taken care of already and if pm_genpd_poweron() ran at this
* point as a result of the check, it would deadlock.
*/ */
pm_runtime_resume(dev);
__pm_runtime_disable(dev, false); __pm_runtime_disable(dev, false);
mutex_unlock(&genpd->lock);
ret = pm_generic_prepare(dev); ret = pm_generic_prepare(dev);
if (ret) { if (ret) {
mutex_lock(&genpd->lock); mutex_lock(&genpd->lock);
@ -409,7 +497,10 @@ static int pm_genpd_prepare(struct device *dev)
genpd->suspend_power_off = false; genpd->suspend_power_off = false;
mutex_unlock(&genpd->lock); mutex_unlock(&genpd->lock);
pm_runtime_enable(dev);
} }
pm_runtime_put_sync(dev);
return ret; return ret;
} }
@ -726,7 +817,7 @@ static int pm_genpd_restore_noirq(struct device *dev)
* guaranteed that this function will never run twice in parallel for * guaranteed that this function will never run twice in parallel for
* the same PM domain, so it is not necessary to use locking here. * the same PM domain, so it is not necessary to use locking here.
*/ */
genpd->power_is_off = true; genpd->status = GPD_STATE_POWER_OFF;
if (genpd->suspend_power_off) { if (genpd->suspend_power_off) {
/* /*
* The boot kernel might put the domain into the power on state, * The boot kernel might put the domain into the power on state,
@ -836,9 +927,9 @@ int pm_genpd_add_device(struct generic_pm_domain *genpd, struct device *dev)
if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev)) if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev))
return -EINVAL; return -EINVAL;
mutex_lock(&genpd->lock); genpd_acquire_lock(genpd);
if (genpd->power_is_off) { if (genpd->status == GPD_STATE_POWER_OFF) {
ret = -EINVAL; ret = -EINVAL;
goto out; goto out;
} }
@ -870,7 +961,7 @@ int pm_genpd_add_device(struct generic_pm_domain *genpd, struct device *dev)
spin_unlock_irq(&dev->power.lock); spin_unlock_irq(&dev->power.lock);
out: out:
mutex_unlock(&genpd->lock); genpd_release_lock(genpd);
return ret; return ret;
} }
@ -891,7 +982,7 @@ int pm_genpd_remove_device(struct generic_pm_domain *genpd,
if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev)) if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(dev))
return -EINVAL; return -EINVAL;
mutex_lock(&genpd->lock); genpd_acquire_lock(genpd);
if (genpd->prepared_count > 0) { if (genpd->prepared_count > 0) {
ret = -EAGAIN; ret = -EAGAIN;
@ -915,7 +1006,7 @@ int pm_genpd_remove_device(struct generic_pm_domain *genpd,
} }
out: out:
mutex_unlock(&genpd->lock); genpd_release_lock(genpd);
return ret; return ret;
} }
@ -934,9 +1025,19 @@ int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(new_subdomain)) if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(new_subdomain))
return -EINVAL; return -EINVAL;
mutex_lock(&genpd->lock); start:
genpd_acquire_lock(genpd);
mutex_lock_nested(&new_subdomain->lock, SINGLE_DEPTH_NESTING);
if (genpd->power_is_off && !new_subdomain->power_is_off) { if (new_subdomain->status != GPD_STATE_POWER_OFF
&& new_subdomain->status != GPD_STATE_ACTIVE) {
mutex_unlock(&new_subdomain->lock);
genpd_release_lock(genpd);
goto start;
}
if (genpd->status == GPD_STATE_POWER_OFF
&& new_subdomain->status != GPD_STATE_POWER_OFF) {
ret = -EINVAL; ret = -EINVAL;
goto out; goto out;
} }
@ -948,17 +1049,14 @@ int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
} }
} }
mutex_lock_nested(&new_subdomain->lock, SINGLE_DEPTH_NESTING);
list_add_tail(&new_subdomain->sd_node, &genpd->sd_list); list_add_tail(&new_subdomain->sd_node, &genpd->sd_list);
new_subdomain->parent = genpd; new_subdomain->parent = genpd;
if (!subdomain->power_is_off) if (subdomain->status != GPD_STATE_POWER_OFF)
genpd->sd_count++; genpd->sd_count++;
mutex_unlock(&new_subdomain->lock);
out: out:
mutex_unlock(&genpd->lock); mutex_unlock(&new_subdomain->lock);
genpd_release_lock(genpd);
return ret; return ret;
} }
@ -977,7 +1075,8 @@ int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(target)) if (IS_ERR_OR_NULL(genpd) || IS_ERR_OR_NULL(target))
return -EINVAL; return -EINVAL;
mutex_lock(&genpd->lock); start:
genpd_acquire_lock(genpd);
list_for_each_entry(subdomain, &genpd->sd_list, sd_node) { list_for_each_entry(subdomain, &genpd->sd_list, sd_node) {
if (subdomain != target) if (subdomain != target)
@ -985,9 +1084,16 @@ int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
mutex_lock_nested(&subdomain->lock, SINGLE_DEPTH_NESTING); mutex_lock_nested(&subdomain->lock, SINGLE_DEPTH_NESTING);
if (subdomain->status != GPD_STATE_POWER_OFF
&& subdomain->status != GPD_STATE_ACTIVE) {
mutex_unlock(&subdomain->lock);
genpd_release_lock(genpd);
goto start;
}
list_del(&subdomain->sd_node); list_del(&subdomain->sd_node);
subdomain->parent = NULL; subdomain->parent = NULL;
if (!subdomain->power_is_off) if (subdomain->status != GPD_STATE_POWER_OFF)
genpd_sd_counter_dec(genpd); genpd_sd_counter_dec(genpd);
mutex_unlock(&subdomain->lock); mutex_unlock(&subdomain->lock);
@ -996,7 +1102,7 @@ int pm_genpd_remove_subdomain(struct generic_pm_domain *genpd,
break; break;
} }
mutex_unlock(&genpd->lock); genpd_release_lock(genpd);
return ret; return ret;
} }
@ -1022,7 +1128,8 @@ void pm_genpd_init(struct generic_pm_domain *genpd,
INIT_WORK(&genpd->power_off_work, genpd_power_off_work_fn); INIT_WORK(&genpd->power_off_work, genpd_power_off_work_fn);
genpd->in_progress = 0; genpd->in_progress = 0;
genpd->sd_count = 0; genpd->sd_count = 0;
genpd->power_is_off = is_off; genpd->status = is_off ? GPD_STATE_POWER_OFF : GPD_STATE_ACTIVE;
init_waitqueue_head(&genpd->status_wait_queue);
genpd->device_count = 0; genpd->device_count = 0;
genpd->suspended_count = 0; genpd->suspended_count = 0;
genpd->domain.ops.runtime_suspend = pm_genpd_runtime_suspend; genpd->domain.ops.runtime_suspend = pm_genpd_runtime_suspend;

10
include/linux/pm_domain.h
View File

@ -11,8 +11,11 @@
#include <linux/device.h> #include <linux/device.h>
#define GPD_IN_SUSPEND 1 enum gpd_status {
#define GPD_POWER_OFF 2 GPD_STATE_ACTIVE = 0, /* PM domain is active */
GPD_STATE_BUSY, /* Something is happening to the PM domain */
GPD_STATE_POWER_OFF, /* PM domain is off */
};
struct dev_power_governor { struct dev_power_governor {
bool (*power_down_ok)(struct dev_pm_domain *domain); bool (*power_down_ok)(struct dev_pm_domain *domain);
@ -29,7 +32,8 @@ struct generic_pm_domain {
struct work_struct power_off_work; struct work_struct power_off_work;
unsigned int in_progress; /* Number of devices being suspended now */ unsigned int in_progress; /* Number of devices being suspended now */
unsigned int sd_count; /* Number of subdomains with power "on" */ unsigned int sd_count; /* Number of subdomains with power "on" */
bool power_is_off; /* Whether or not power has been removed */ enum gpd_status status; /* Current state of the domain */
wait_queue_head_t status_wait_queue;
unsigned int device_count; /* Number of devices */ unsigned int device_count; /* Number of devices */
unsigned int suspended_count; /* System suspend device counter */ unsigned int suspended_count; /* System suspend device counter */
unsigned int prepared_count; /* Suspend counter of prepared devices */ unsigned int prepared_count; /* Suspend counter of prepared devices */