2019-04-02 21:32:01 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2009-08-19 05:38:32 +08:00
|
|
|
/*
|
2011-07-06 16:52:13 +08:00
|
|
|
* drivers/base/power/runtime.c - Helper functions for device runtime PM
|
2009-08-19 05:38:32 +08:00
|
|
|
*
|
|
|
|
* Copyright (c) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
|
2010-09-26 05:35:00 +08:00
|
|
|
* Copyright (C) 2010 Alan Stern <stern@rowland.harvard.edu>
|
2009-08-19 05:38:32 +08:00
|
|
|
*/
|
2017-02-03 03:43:54 +08:00
|
|
|
#include <linux/sched/mm.h>
|
2018-12-14 22:22:25 +08:00
|
|
|
#include <linux/ktime.h>
|
|
|
|
#include <linux/hrtimer.h>
|
2011-05-27 19:12:15 +08:00
|
|
|
#include <linux/export.h>
|
2009-08-19 05:38:32 +08:00
|
|
|
#include <linux/pm_runtime.h>
|
PM / Wakeirq: Add automated device wake IRQ handling
Turns out we can automate the handling for the device_may_wakeup()
quite a bit by using the kernel wakeup source list as suggested
by Rafael J. Wysocki <rjw@rjwysocki.net>.
And as some hardware has separate dedicated wake-up interrupt
in addition to the IO interrupt, we can automate the handling by
adding a generic threaded interrupt handler that just calls the
device PM runtime to wake up the device.
This allows dropping code from device drivers as we currently
are doing it in multiple ways, and often wrong.
For most drivers, we should be able to drop the following
boilerplate code from runtime_suspend and runtime_resume
functions:
...
device_init_wakeup(dev, true);
...
if (device_may_wakeup(dev))
enable_irq_wake(irq);
...
if (device_may_wakeup(dev))
disable_irq_wake(irq);
...
device_init_wakeup(dev, false);
...
We can replace it with just the following init and exit
time code:
...
device_init_wakeup(dev, true);
dev_pm_set_wake_irq(dev, irq);
...
dev_pm_clear_wake_irq(dev);
device_init_wakeup(dev, false);
...
And for hardware with dedicated wake-up interrupts:
...
device_init_wakeup(dev, true);
dev_pm_set_dedicated_wake_irq(dev, irq);
...
dev_pm_clear_wake_irq(dev);
device_init_wakeup(dev, false);
...
Signed-off-by: Tony Lindgren <tony@atomide.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2015-05-19 06:40:29 +08:00
|
|
|
#include <linux/pm_wakeirq.h>
|
2011-09-28 04:54:41 +08:00
|
|
|
#include <trace/events/rpm.h>
|
2016-10-31 00:32:31 +08:00
|
|
|
|
|
|
|
#include "../base.h"
|
2010-09-26 05:35:15 +08:00
|
|
|
#include "power.h"
|
2009-08-19 05:38:32 +08:00
|
|
|
|
2014-10-17 18:58:02 +08:00
|
|
|
typedef int (*pm_callback_t)(struct device *);
|
2014-03-01 18:56:04 +08:00
|
|
|
|
2014-10-17 18:58:02 +08:00
|
|
|
static pm_callback_t __rpm_get_callback(struct device *dev, size_t cb_offset)
|
2014-03-01 18:56:04 +08:00
|
|
|
{
|
2014-10-17 18:58:02 +08:00
|
|
|
pm_callback_t cb;
|
|
|
|
const struct dev_pm_ops *ops;
|
|
|
|
|
|
|
|
if (dev->pm_domain)
|
|
|
|
ops = &dev->pm_domain->ops;
|
|
|
|
else if (dev->type && dev->type->pm)
|
|
|
|
ops = dev->type->pm;
|
|
|
|
else if (dev->class && dev->class->pm)
|
|
|
|
ops = dev->class->pm;
|
|
|
|
else if (dev->bus && dev->bus->pm)
|
|
|
|
ops = dev->bus->pm;
|
|
|
|
else
|
|
|
|
ops = NULL;
|
|
|
|
|
|
|
|
if (ops)
|
|
|
|
cb = *(pm_callback_t *)((void *)ops + cb_offset);
|
|
|
|
else
|
|
|
|
cb = NULL;
|
|
|
|
|
|
|
|
if (!cb && dev->driver && dev->driver->pm)
|
|
|
|
cb = *(pm_callback_t *)((void *)dev->driver->pm + cb_offset);
|
|
|
|
|
|
|
|
return cb;
|
2014-03-01 18:56:04 +08:00
|
|
|
}
|
|
|
|
|
2014-10-17 18:58:02 +08:00
|
|
|
#define RPM_GET_CALLBACK(dev, callback) \
|
|
|
|
__rpm_get_callback(dev, offsetof(struct dev_pm_ops, callback))
|
|
|
|
|
2010-09-26 05:35:07 +08:00
|
|
|
static int rpm_resume(struct device *dev, int rpmflags);
|
2010-09-26 05:35:15 +08:00
|
|
|
static int rpm_suspend(struct device *dev, int rpmflags);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
2010-09-26 05:34:46 +08:00
|
|
|
/**
|
|
|
|
* update_pm_runtime_accounting - Update the time accounting of power states
|
|
|
|
* @dev: Device to update the accounting for
|
|
|
|
*
|
|
|
|
* In order to be able to have time accounting of the various power states
|
|
|
|
* (as used by programs such as PowerTOP to show the effectiveness of runtime
|
|
|
|
* PM), we need to track the time spent in each state.
|
|
|
|
* update_pm_runtime_accounting must be called each time before the
|
|
|
|
* runtime_status field is updated, to account the time in the old state
|
|
|
|
* correctly.
|
|
|
|
*/
|
2019-03-05 20:55:35 +08:00
|
|
|
static void update_pm_runtime_accounting(struct device *dev)
|
2010-09-26 05:34:46 +08:00
|
|
|
{
|
2019-02-05 00:25:53 +08:00
|
|
|
u64 now, last, delta;
|
2010-09-26 05:34:46 +08:00
|
|
|
|
2019-02-05 00:25:53 +08:00
|
|
|
if (dev->power.disable_depth > 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
last = dev->power.accounting_timestamp;
|
2010-09-26 05:34:46 +08:00
|
|
|
|
2019-02-05 00:25:53 +08:00
|
|
|
now = ktime_get_mono_fast_ns();
|
2010-09-26 05:34:46 +08:00
|
|
|
dev->power.accounting_timestamp = now;
|
|
|
|
|
2019-02-05 00:25:52 +08:00
|
|
|
/*
|
|
|
|
* Because ktime_get_mono_fast_ns() is not monotonic during
|
|
|
|
* timekeeping updates, ensure that 'now' is after the last saved
|
|
|
|
* timesptamp.
|
|
|
|
*/
|
|
|
|
if (now < last)
|
2010-09-26 05:34:46 +08:00
|
|
|
return;
|
|
|
|
|
2019-02-05 00:25:52 +08:00
|
|
|
delta = now - last;
|
|
|
|
|
2010-09-26 05:34:46 +08:00
|
|
|
if (dev->power.runtime_status == RPM_SUSPENDED)
|
2019-01-23 15:50:14 +08:00
|
|
|
dev->power.suspended_time += delta;
|
2010-09-26 05:34:46 +08:00
|
|
|
else
|
2019-01-23 15:50:14 +08:00
|
|
|
dev->power.active_time += delta;
|
2010-09-26 05:34:46 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __update_runtime_status(struct device *dev, enum rpm_status status)
|
|
|
|
{
|
|
|
|
update_pm_runtime_accounting(dev);
|
|
|
|
dev->power.runtime_status = status;
|
|
|
|
}
|
|
|
|
|
2019-03-05 20:55:26 +08:00
|
|
|
static u64 rpm_get_accounted_time(struct device *dev, bool suspended)
|
2018-12-21 18:33:54 +08:00
|
|
|
{
|
2019-01-23 15:50:14 +08:00
|
|
|
u64 time;
|
|
|
|
unsigned long flags;
|
2018-12-21 18:33:54 +08:00
|
|
|
|
|
|
|
spin_lock_irqsave(&dev->power.lock, flags);
|
|
|
|
|
|
|
|
update_pm_runtime_accounting(dev);
|
2019-03-05 20:55:26 +08:00
|
|
|
time = suspended ? dev->power.suspended_time : dev->power.active_time;
|
2018-12-21 18:33:54 +08:00
|
|
|
|
|
|
|
spin_unlock_irqrestore(&dev->power.lock, flags);
|
|
|
|
|
2019-01-23 15:50:14 +08:00
|
|
|
return time;
|
2018-12-21 18:33:54 +08:00
|
|
|
}
|
2019-03-05 20:55:26 +08:00
|
|
|
|
|
|
|
u64 pm_runtime_active_time(struct device *dev)
|
|
|
|
{
|
|
|
|
return rpm_get_accounted_time(dev, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
u64 pm_runtime_suspended_time(struct device *dev)
|
|
|
|
{
|
|
|
|
return rpm_get_accounted_time(dev, true);
|
|
|
|
}
|
2018-12-21 18:33:54 +08:00
|
|
|
EXPORT_SYMBOL_GPL(pm_runtime_suspended_time);
|
|
|
|
|
2009-08-19 05:38:32 +08:00
|
|
|
/**
|
|
|
|
* pm_runtime_deactivate_timer - Deactivate given device's suspend timer.
|
|
|
|
* @dev: Device to handle.
|
|
|
|
*/
|
|
|
|
static void pm_runtime_deactivate_timer(struct device *dev)
|
|
|
|
{
|
|
|
|
if (dev->power.timer_expires > 0) {
|
2019-02-21 15:59:02 +08:00
|
|
|
hrtimer_try_to_cancel(&dev->power.suspend_timer);
|
2009-08-19 05:38:32 +08:00
|
|
|
dev->power.timer_expires = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_runtime_cancel_pending - Deactivate suspend timer and cancel requests.
|
|
|
|
* @dev: Device to handle.
|
|
|
|
*/
|
|
|
|
static void pm_runtime_cancel_pending(struct device *dev)
|
|
|
|
{
|
|
|
|
pm_runtime_deactivate_timer(dev);
|
|
|
|
/*
|
|
|
|
* In case there's a request pending, make sure its work function will
|
|
|
|
* return without doing anything.
|
|
|
|
*/
|
|
|
|
dev->power.request = RPM_REQ_NONE;
|
|
|
|
}
|
|
|
|
|
2010-09-26 05:35:21 +08:00
|
|
|
/*
|
|
|
|
* pm_runtime_autosuspend_expiration - Get a device's autosuspend-delay expiration time.
|
|
|
|
* @dev: Device to handle.
|
|
|
|
*
|
|
|
|
* Compute the autosuspend-delay expiration time based on the device's
|
|
|
|
* power.last_busy time. If the delay has already expired or is disabled
|
|
|
|
* (negative) or the power.use_autosuspend flag isn't set, return 0.
|
2019-01-10 07:19:44 +08:00
|
|
|
* Otherwise return the expiration time in nanoseconds (adjusted to be nonzero).
|
2010-09-26 05:35:21 +08:00
|
|
|
*
|
|
|
|
* This function may be called either with or without dev->power.lock held.
|
|
|
|
* Either way it can be racy, since power.last_busy may be updated at any time.
|
|
|
|
*/
|
2018-12-14 22:22:25 +08:00
|
|
|
u64 pm_runtime_autosuspend_expiration(struct device *dev)
|
2010-09-26 05:35:21 +08:00
|
|
|
{
|
|
|
|
int autosuspend_delay;
|
2019-01-31 05:40:17 +08:00
|
|
|
u64 expires;
|
2010-09-26 05:35:21 +08:00
|
|
|
|
|
|
|
if (!dev->power.use_autosuspend)
|
2019-01-31 05:40:17 +08:00
|
|
|
return 0;
|
2010-09-26 05:35:21 +08:00
|
|
|
|
locking/atomics: COCCINELLE/treewide: Convert trivial ACCESS_ONCE() patterns to READ_ONCE()/WRITE_ONCE()
Please do not apply this to mainline directly, instead please re-run the
coccinelle script shown below and apply its output.
For several reasons, it is desirable to use {READ,WRITE}_ONCE() in
preference to ACCESS_ONCE(), and new code is expected to use one of the
former. So far, there's been no reason to change most existing uses of
ACCESS_ONCE(), as these aren't harmful, and changing them results in
churn.
However, for some features, the read/write distinction is critical to
correct operation. To distinguish these cases, separate read/write
accessors must be used. This patch migrates (most) remaining
ACCESS_ONCE() instances to {READ,WRITE}_ONCE(), using the following
coccinelle script:
----
// Convert trivial ACCESS_ONCE() uses to equivalent READ_ONCE() and
// WRITE_ONCE()
// $ make coccicheck COCCI=/home/mark/once.cocci SPFLAGS="--include-headers" MODE=patch
virtual patch
@ depends on patch @
expression E1, E2;
@@
- ACCESS_ONCE(E1) = E2
+ WRITE_ONCE(E1, E2)
@ depends on patch @
expression E;
@@
- ACCESS_ONCE(E)
+ READ_ONCE(E)
----
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: davem@davemloft.net
Cc: linux-arch@vger.kernel.org
Cc: mpe@ellerman.id.au
Cc: shuah@kernel.org
Cc: snitzer@redhat.com
Cc: thor.thayer@linux.intel.com
Cc: tj@kernel.org
Cc: viro@zeniv.linux.org.uk
Cc: will.deacon@arm.com
Link: http://lkml.kernel.org/r/1508792849-3115-19-git-send-email-paulmck@linux.vnet.ibm.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2017-10-24 05:07:29 +08:00
|
|
|
autosuspend_delay = READ_ONCE(dev->power.autosuspend_delay);
|
2010-09-26 05:35:21 +08:00
|
|
|
if (autosuspend_delay < 0)
|
2019-01-31 05:40:17 +08:00
|
|
|
return 0;
|
2010-09-26 05:35:21 +08:00
|
|
|
|
2019-01-31 05:40:17 +08:00
|
|
|
expires = READ_ONCE(dev->power.last_busy);
|
|
|
|
expires += (u64)autosuspend_delay * NSEC_PER_MSEC;
|
|
|
|
if (expires > ktime_get_mono_fast_ns())
|
|
|
|
return expires; /* Expires in the future */
|
2010-09-26 05:35:21 +08:00
|
|
|
|
2019-01-31 05:40:17 +08:00
|
|
|
return 0;
|
2010-09-26 05:35:21 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(pm_runtime_autosuspend_expiration);
|
|
|
|
|
2013-02-23 08:34:11 +08:00
|
|
|
static int dev_memalloc_noio(struct device *dev, void *data)
|
|
|
|
{
|
|
|
|
return dev->power.memalloc_noio;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* pm_runtime_set_memalloc_noio - Set a device's memalloc_noio flag.
|
|
|
|
* @dev: Device to handle.
|
|
|
|
* @enable: True for setting the flag and False for clearing the flag.
|
|
|
|
*
|
|
|
|
* Set the flag for all devices in the path from the device to the
|
|
|
|
* root device in the device tree if @enable is true, otherwise clear
|
|
|
|
* the flag for devices in the path whose siblings don't set the flag.
|
|
|
|
*
|
|
|
|
* The function should only be called by block device, or network
|
|
|
|
* device driver for solving the deadlock problem during runtime
|
|
|
|
* resume/suspend:
|
|
|
|
*
|
|
|
|
* If memory allocation with GFP_KERNEL is called inside runtime
|
|
|
|
* resume/suspend callback of any one of its ancestors(or the
|
|
|
|
* block device itself), the deadlock may be triggered inside the
|
|
|
|
* memory allocation since it might not complete until the block
|
|
|
|
* device becomes active and the involed page I/O finishes. The
|
|
|
|
* situation is pointed out first by Alan Stern. Network device
|
|
|
|
* are involved in iSCSI kind of situation.
|
|
|
|
*
|
|
|
|
* The lock of dev_hotplug_mutex is held in the function for handling
|
|
|
|
* hotplug race because pm_runtime_set_memalloc_noio() may be called
|
|
|
|
* in async probe().
|
|
|
|
*
|
|
|
|
* The function should be called between device_add() and device_del()
|
|
|
|
* on the affected device(block/network device).
|
|
|
|
*/
|
|
|
|
void pm_runtime_set_memalloc_noio(struct device *dev, bool enable)
|
|
|
|
{
|
|
|
|
static DEFINE_MUTEX(dev_hotplug_mutex);
|
|
|
|
|
|
|
|
mutex_lock(&dev_hotplug_mutex);
|
|
|
|
for (;;) {
|
|
|
|
bool enabled;
|
|
|
|
|
|
|
|
/* hold power lock since bitfield is not SMP-safe. */
|
|
|
|
spin_lock_irq(&dev->power.lock);
|
|
|
|
enabled = dev->power.memalloc_noio;
|
|
|
|
dev->power.memalloc_noio = enable;
|
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* not need to enable ancestors any more if the device
|
|
|
|
* has been enabled.
|
|
|
|
*/
|
|
|
|
if (enabled && enable)
|
|
|
|
break;
|
|
|
|
|
|
|
|
dev = dev->parent;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* clear flag of the parent device only if all the
|
|
|
|
* children don't set the flag because ancestor's
|
|
|
|
* flag was set by any one of the descendants.
|
|
|
|
*/
|
|
|
|
if (!dev || (!enable &&
|
|
|
|
device_for_each_child(dev, NULL,
|
|
|
|
dev_memalloc_noio)))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
mutex_unlock(&dev_hotplug_mutex);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(pm_runtime_set_memalloc_noio);
|
|
|
|
|
2009-08-19 05:38:32 +08:00
|
|
|
/**
|
2010-09-26 05:35:00 +08:00
|
|
|
* rpm_check_suspend_allowed - Test whether a device may be suspended.
|
|
|
|
* @dev: Device to test.
|
2009-08-19 05:38:32 +08:00
|
|
|
*/
|
2010-09-26 05:35:00 +08:00
|
|
|
static int rpm_check_suspend_allowed(struct device *dev)
|
2009-08-19 05:38:32 +08:00
|
|
|
{
|
|
|
|
int retval = 0;
|
|
|
|
|
|
|
|
if (dev->power.runtime_error)
|
|
|
|
retval = -EINVAL;
|
2011-07-02 04:29:15 +08:00
|
|
|
else if (dev->power.disable_depth > 0)
|
|
|
|
retval = -EACCES;
|
|
|
|
else if (atomic_read(&dev->power.usage_count) > 0)
|
2009-08-19 05:38:32 +08:00
|
|
|
retval = -EAGAIN;
|
2016-10-18 02:16:58 +08:00
|
|
|
else if (!dev->power.ignore_children &&
|
|
|
|
atomic_read(&dev->power.child_count))
|
2009-08-19 05:38:32 +08:00
|
|
|
retval = -EBUSY;
|
2010-09-26 05:35:00 +08:00
|
|
|
|
|
|
|
/* Pending resume requests take precedence over suspends. */
|
|
|
|
else if ((dev->power.deferred_resume
|
2010-10-29 21:29:55 +08:00
|
|
|
&& dev->power.runtime_status == RPM_SUSPENDING)
|
2010-09-26 05:35:00 +08:00
|
|
|
|| (dev->power.request_pending
|
|
|
|
&& dev->power.request == RPM_REQ_RESUME))
|
|
|
|
retval = -EAGAIN;
|
2019-07-04 15:36:18 +08:00
|
|
|
else if (__dev_pm_qos_resume_latency(dev) == 0)
|
2012-08-16 03:32:04 +08:00
|
|
|
retval = -EPERM;
|
2010-09-26 05:35:00 +08:00
|
|
|
else if (dev->power.runtime_status == RPM_SUSPENDED)
|
|
|
|
retval = 1;
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2016-10-31 00:32:31 +08:00
|
|
|
static int rpm_get_suppliers(struct device *dev)
|
|
|
|
{
|
|
|
|
struct device_link *link;
|
|
|
|
|
2019-07-17 06:12:25 +08:00
|
|
|
list_for_each_entry_rcu(link, &dev->links.suppliers, c_node,
|
|
|
|
device_links_read_lock_held()) {
|
2016-10-31 00:32:31 +08:00
|
|
|
int retval;
|
|
|
|
|
PM: runtime: Remove link state checks in rpm_get/put_supplier()
To support runtime PM for hisi SAS driver (the driver is in directory
drivers/scsi/hisi_sas), we add device link between scsi_device->sdev_gendev
(consumer device) and hisi_hba->dev(supplier device) with flags
DL_FLAG_PM_RUNTIME | DL_FLAG_RPM_ACTIVE.
After runtime suspended consumers and supplier, unload the dirver which
causes a hung.
We found that it called function device_release_driver_internal() to
release the supplier device (hisi_hba->dev), as the device link was
busy, it set the device link state to DL_STATE_SUPPLIER_UNBIND, and
then it called device_release_driver_internal() to release the consumer
device (scsi_device->sdev_gendev).
Then it would try to call pm_runtime_get_sync() to resume the consumer
device, but because consumer-supplier relation existed, it would try
to resume the supplier first, but as the link state was already
DL_STATE_SUPPLIER_UNBIND, so it skipped resuming the supplier and only
resumed the consumer which hanged (it sends IOs to resume scsi_device
while the SAS controller is suspended).
Simple flow is as follows:
device_release_driver_internal -> (supplier device)
if device_links_busy ->
device_links_unbind_consumers ->
...
WRITE_ONCE(link->status, DL_STATE_SUPPLIER_UNBIND)
device_release_driver_internal (consumer device)
pm_runtime_get_sync -> (consumer device)
...
__rpm_callback ->
rpm_get_suppliers ->
if link->state == DL_STATE_SUPPLIER_UNBIND -> skip the action of resuming the supplier
...
pm_runtime_clean_up_links
...
Correct suspend/resume ordering between a supplier device and its consumer
devices (resume the supplier device before resuming consumer devices, and
suspend consumer devices before suspending the supplier device) should be
guaranteed by runtime PM, but the state checks in rpm_get_supplier() and
rpm_put_supplier() break this rule, so remove them.
Signed-off-by: Xiang Chen <chenxiang66@hisilicon.com>
[ rjw: Subject and changelog edits ]
Cc: All applicable <stable@vger.kernel.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2020-09-22 21:11:06 +08:00
|
|
|
if (!(link->flags & DL_FLAG_PM_RUNTIME))
|
2016-10-31 00:32:31 +08:00
|
|
|
continue;
|
|
|
|
|
|
|
|
retval = pm_runtime_get_sync(link->supplier);
|
2017-12-01 21:58:34 +08:00
|
|
|
/* Ignore suppliers with disabled runtime PM. */
|
|
|
|
if (retval < 0 && retval != -EACCES) {
|
2016-10-31 00:32:31 +08:00
|
|
|
pm_runtime_put_noidle(link->supplier);
|
|
|
|
return retval;
|
|
|
|
}
|
driver core: Fix handling of runtime PM flags in device_link_add()
After commit ead18c23c263 ("driver core: Introduce device links
reference counting"), if there is a link between the given supplier
and the given consumer already, device_link_add() will refcount it
and return it unconditionally without updating its flags. It is
possible, however, that the second (or any subsequent) caller of
device_link_add() for the same consumer-supplier pair will pass
DL_FLAG_PM_RUNTIME, possibly along with DL_FLAG_RPM_ACTIVE, in flags
to it and the existing link may not behave as expected then.
First, if DL_FLAG_PM_RUNTIME is not set in the existing link's flags
at all, it needs to be set like during the original initialization of
the link.
Second, if DL_FLAG_RPM_ACTIVE is passed to device_link_add() in flags
(in addition to DL_FLAG_PM_RUNTIME), the existing link should to be
updated to reflect the "active" runtime PM configuration of the
consumer-supplier pair and extra care must be taken here to avoid
possible destructive races with runtime PM of the consumer.
To that end, redefine the rpm_active field in struct device_link
as a refcount, initialize it to 1 and make rpm_resume() (for the
consumer) and device_link_add() increment it whenever they acquire
a runtime PM reference on the supplier device. Accordingly, make
rpm_suspend() (for the consumer) and pm_runtime_clean_up_links()
decrement it and drop runtime PM references to the supplier
device in a loop until rpm_active becones 1 again.
Fixes: ead18c23c263 ("driver core: Introduce device links reference counting")
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2019-02-01 08:49:14 +08:00
|
|
|
refcount_inc(&link->rpm_active);
|
2016-10-31 00:32:31 +08:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2021-12-11 00:10:13 +08:00
|
|
|
/**
|
|
|
|
* pm_runtime_release_supplier - Drop references to device link's supplier.
|
|
|
|
* @link: Target device link.
|
|
|
|
* @check_idle: Whether or not to check if the supplier device is idle.
|
|
|
|
*
|
|
|
|
* Drop all runtime PM references associated with @link to its supplier device
|
|
|
|
* and if @check_idle is set, check if that device is idle (and so it can be
|
|
|
|
* suspended).
|
|
|
|
*/
|
|
|
|
void pm_runtime_release_supplier(struct device_link *link, bool check_idle)
|
|
|
|
{
|
|
|
|
struct device *supplier = link->supplier;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The additional power.usage_count check is a safety net in case
|
|
|
|
* the rpm_active refcount becomes saturated, in which case
|
|
|
|
* refcount_dec_not_one() would return true forever, but it is not
|
|
|
|
* strictly necessary.
|
|
|
|
*/
|
|
|
|
while (refcount_dec_not_one(&link->rpm_active) &&
|
|
|
|
atomic_read(&supplier->power.usage_count) > 0)
|
|
|
|
pm_runtime_put_noidle(supplier);
|
|
|
|
|
|
|
|
if (check_idle)
|
|
|
|
pm_request_idle(supplier);
|
|
|
|
}
|
|
|
|
|
2021-03-19 22:47:31 +08:00
|
|
|
static void __rpm_put_suppliers(struct device *dev, bool try_to_suspend)
|
2016-10-31 00:32:31 +08:00
|
|
|
{
|
|
|
|
struct device_link *link;
|
|
|
|
|
2019-07-17 06:12:25 +08:00
|
|
|
list_for_each_entry_rcu(link, &dev->links.suppliers, c_node,
|
2021-12-11 00:10:13 +08:00
|
|
|
device_links_read_lock_held())
|
|
|
|
pm_runtime_release_supplier(link, try_to_suspend);
|
2016-10-31 00:32:31 +08:00
|
|
|
}
|
|
|
|
|
2021-03-19 22:47:31 +08:00
|
|
|
static void rpm_put_suppliers(struct device *dev)
|
|
|
|
{
|
|
|
|
__rpm_put_suppliers(dev, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rpm_suspend_suppliers(struct device *dev)
|
|
|
|
{
|
|
|
|
struct device_link *link;
|
|
|
|
int idx = device_links_read_lock();
|
|
|
|
|
|
|
|
list_for_each_entry_rcu(link, &dev->links.suppliers, c_node,
|
|
|
|
device_links_read_lock_held())
|
|
|
|
pm_request_idle(link->supplier);
|
|
|
|
|
|
|
|
device_links_read_unlock(idx);
|
|
|
|
}
|
|
|
|
|
2011-09-28 03:54:52 +08:00
|
|
|
/**
|
|
|
|
* __rpm_callback - Run a given runtime PM callback for a given device.
|
|
|
|
* @cb: Runtime PM callback to run.
|
|
|
|
* @dev: Device to run the callback for.
|
|
|
|
*/
|
|
|
|
static int __rpm_callback(int (*cb)(struct device *), struct device *dev)
|
|
|
|
__releases(&dev->power.lock) __acquires(&dev->power.lock)
|
|
|
|
{
|
2021-06-08 17:02:49 +08:00
|
|
|
int retval = 0, idx;
|
2021-03-19 22:47:25 +08:00
|
|
|
bool use_links = dev->power.links_count > 0;
|
2011-09-28 03:54:52 +08:00
|
|
|
|
2016-10-31 00:32:31 +08:00
|
|
|
if (dev->power.irq_safe) {
|
2011-09-28 03:54:52 +08:00
|
|
|
spin_unlock(&dev->power.lock);
|
2016-10-31 00:32:31 +08:00
|
|
|
} else {
|
2011-09-28 03:54:52 +08:00
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
|
2021-03-19 22:47:25 +08:00
|
|
|
/*
|
|
|
|
* Resume suppliers if necessary.
|
|
|
|
*
|
|
|
|
* The device's runtime PM status cannot change until this
|
|
|
|
* routine returns, so it is safe to read the status outside of
|
|
|
|
* the lock.
|
|
|
|
*/
|
|
|
|
if (use_links && dev->power.runtime_status == RPM_RESUMING) {
|
2016-10-31 00:32:31 +08:00
|
|
|
idx = device_links_read_lock();
|
|
|
|
|
|
|
|
retval = rpm_get_suppliers(dev);
|
2021-03-19 22:47:31 +08:00
|
|
|
if (retval) {
|
|
|
|
rpm_put_suppliers(dev);
|
2016-10-31 00:32:31 +08:00
|
|
|
goto fail;
|
2021-03-19 22:47:31 +08:00
|
|
|
}
|
2016-10-31 00:32:31 +08:00
|
|
|
|
|
|
|
device_links_read_unlock(idx);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-06-08 17:02:49 +08:00
|
|
|
if (cb)
|
|
|
|
retval = cb(dev);
|
2011-09-28 03:54:52 +08:00
|
|
|
|
2016-10-31 00:32:31 +08:00
|
|
|
if (dev->power.irq_safe) {
|
2011-09-28 03:54:52 +08:00
|
|
|
spin_lock(&dev->power.lock);
|
2021-03-19 22:47:25 +08:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* If the device is suspending and the callback has returned
|
|
|
|
* success, drop the usage counters of the suppliers that have
|
|
|
|
* been reference counted on its resume.
|
|
|
|
*
|
|
|
|
* Do that if resume fails too.
|
|
|
|
*/
|
|
|
|
if (use_links
|
|
|
|
&& ((dev->power.runtime_status == RPM_SUSPENDING && !retval)
|
|
|
|
|| (dev->power.runtime_status == RPM_RESUMING && retval))) {
|
|
|
|
idx = device_links_read_lock();
|
2021-02-26 02:23:27 +08:00
|
|
|
|
2021-03-19 22:47:31 +08:00
|
|
|
__rpm_put_suppliers(dev, false);
|
2021-02-26 02:23:27 +08:00
|
|
|
|
2021-03-19 22:47:31 +08:00
|
|
|
fail:
|
2021-03-19 22:47:25 +08:00
|
|
|
device_links_read_unlock(idx);
|
|
|
|
}
|
2016-10-31 00:32:31 +08:00
|
|
|
|
2011-09-28 03:54:52 +08:00
|
|
|
spin_lock_irq(&dev->power.lock);
|
2016-10-31 00:32:31 +08:00
|
|
|
}
|
2011-09-28 03:54:52 +08:00
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2010-09-26 05:35:00 +08:00
|
|
|
/**
|
2010-09-26 05:35:07 +08:00
|
|
|
* rpm_idle - Notify device bus type if the device can be suspended.
|
2010-09-26 05:35:00 +08:00
|
|
|
* @dev: Device to notify the bus type about.
|
|
|
|
* @rpmflags: Flag bits.
|
|
|
|
*
|
2011-07-06 16:52:13 +08:00
|
|
|
* Check if the device's runtime PM status allows it to be suspended. If
|
2010-09-26 05:35:00 +08:00
|
|
|
* another idle notification has been started earlier, return immediately. If
|
|
|
|
* the RPM_ASYNC flag is set then queue an idle-notification request; otherwise
|
2013-10-16 04:25:08 +08:00
|
|
|
* run the ->runtime_idle() callback directly. If the ->runtime_idle callback
|
|
|
|
* doesn't exist or if it returns 0, call rpm_suspend with the RPM_AUTO flag.
|
2010-09-26 05:35:00 +08:00
|
|
|
*
|
|
|
|
* This function must be called under dev->power.lock with interrupts disabled.
|
|
|
|
*/
|
2010-09-26 05:35:07 +08:00
|
|
|
static int rpm_idle(struct device *dev, int rpmflags)
|
2010-09-26 05:35:00 +08:00
|
|
|
{
|
2010-10-05 04:08:01 +08:00
|
|
|
int (*callback)(struct device *);
|
2010-09-26 05:35:00 +08:00
|
|
|
int retval;
|
|
|
|
|
2016-04-27 04:03:51 +08:00
|
|
|
trace_rpm_idle_rcuidle(dev, rpmflags);
|
2010-09-26 05:35:00 +08:00
|
|
|
retval = rpm_check_suspend_allowed(dev);
|
|
|
|
if (retval < 0)
|
|
|
|
; /* Conditions are wrong. */
|
|
|
|
|
|
|
|
/* Idle notifications are allowed only in the RPM_ACTIVE state. */
|
|
|
|
else if (dev->power.runtime_status != RPM_ACTIVE)
|
|
|
|
retval = -EAGAIN;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Any pending request other than an idle notification takes
|
|
|
|
* precedence over us, except that the timer may be running.
|
|
|
|
*/
|
|
|
|
else if (dev->power.request_pending &&
|
|
|
|
dev->power.request > RPM_REQ_IDLE)
|
|
|
|
retval = -EAGAIN;
|
|
|
|
|
|
|
|
/* Act as though RPM_NOWAIT is always set. */
|
|
|
|
else if (dev->power.idle_notification)
|
|
|
|
retval = -EINPROGRESS;
|
2009-08-19 05:38:32 +08:00
|
|
|
if (retval)
|
|
|
|
goto out;
|
|
|
|
|
2010-09-26 05:35:00 +08:00
|
|
|
/* Pending requests need to be canceled. */
|
|
|
|
dev->power.request = RPM_REQ_NONE;
|
|
|
|
|
2021-06-08 17:02:48 +08:00
|
|
|
callback = RPM_GET_CALLBACK(dev, runtime_idle);
|
|
|
|
|
|
|
|
/* If no callback assume success. */
|
|
|
|
if (!callback || dev->power.no_callbacks)
|
2010-09-26 05:35:15 +08:00
|
|
|
goto out;
|
|
|
|
|
2010-09-26 05:35:00 +08:00
|
|
|
/* Carry out an asynchronous or a synchronous idle notification. */
|
|
|
|
if (rpmflags & RPM_ASYNC) {
|
|
|
|
dev->power.request = RPM_REQ_IDLE;
|
|
|
|
if (!dev->power.request_pending) {
|
|
|
|
dev->power.request_pending = true;
|
|
|
|
queue_work(pm_wq, &dev->power.work);
|
2009-08-19 05:38:32 +08:00
|
|
|
}
|
2016-04-27 04:03:51 +08:00
|
|
|
trace_rpm_return_int_rcuidle(dev, _THIS_IP_, 0);
|
PM / Runtime: Rework the "runtime idle" helper routine
The "runtime idle" helper routine, rpm_idle(), currently ignores
return values from .runtime_idle() callbacks executed by it.
However, it turns out that many subsystems use
pm_generic_runtime_idle() which checks the return value of the
driver's callback and executes pm_runtime_suspend() for the device
unless that value is not 0. If that logic is moved to rpm_idle()
instead, pm_generic_runtime_idle() can be dropped and its users
will not need any .runtime_idle() callbacks any more.
Moreover, the PCI, SCSI, and SATA subsystems' .runtime_idle()
routines, pci_pm_runtime_idle(), scsi_runtime_idle(), and
ata_port_runtime_idle(), respectively, as well as a few drivers'
ones may be simplified if rpm_idle() calls rpm_suspend() after 0 has
been returned by the .runtime_idle() callback executed by it.
To reduce overall code bloat, make the changes described above.
Tested-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Tested-by: Kevin Hilman <khilman@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Acked-by: Kevin Hilman <khilman@linaro.org>
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
Acked-by: Alan Stern <stern@rowland.harvard.edu>
2013-06-04 03:49:52 +08:00
|
|
|
return 0;
|
2009-08-19 05:38:32 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
dev->power.idle_notification = true;
|
|
|
|
|
2021-06-08 17:02:48 +08:00
|
|
|
retval = __rpm_callback(callback, dev);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
|
|
|
dev->power.idle_notification = false;
|
|
|
|
wake_up_all(&dev->power.wait_queue);
|
|
|
|
|
|
|
|
out:
|
2016-04-27 04:03:51 +08:00
|
|
|
trace_rpm_return_int_rcuidle(dev, _THIS_IP_, retval);
|
2013-10-16 04:25:08 +08:00
|
|
|
return retval ? retval : rpm_suspend(dev, rpmflags | RPM_AUTO);
|
2009-08-19 05:38:32 +08:00
|
|
|
}
|
|
|
|
|
2010-10-05 04:08:01 +08:00
|
|
|
/**
|
|
|
|
* rpm_callback - Run a given runtime PM callback for a given device.
|
|
|
|
* @cb: Runtime PM callback to run.
|
|
|
|
* @dev: Device to run the callback for.
|
|
|
|
*/
|
|
|
|
static int rpm_callback(int (*cb)(struct device *), struct device *dev)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
|
2013-02-23 08:34:19 +08:00
|
|
|
if (dev->power.memalloc_noio) {
|
|
|
|
unsigned int noio_flag;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Deadlock might be caused if memory allocation with
|
|
|
|
* GFP_KERNEL happens inside runtime_suspend and
|
|
|
|
* runtime_resume callbacks of one block device's
|
|
|
|
* ancestor or the block device itself. Network
|
|
|
|
* device might be thought as part of iSCSI block
|
|
|
|
* device, so network device and its ancestor should
|
|
|
|
* be marked as memalloc_noio too.
|
|
|
|
*/
|
|
|
|
noio_flag = memalloc_noio_save();
|
|
|
|
retval = __rpm_callback(cb, dev);
|
|
|
|
memalloc_noio_restore(noio_flag);
|
|
|
|
} else {
|
|
|
|
retval = __rpm_callback(cb, dev);
|
|
|
|
}
|
2010-10-05 04:08:01 +08:00
|
|
|
|
|
|
|
dev->power.runtime_error = retval;
|
2011-07-02 04:29:15 +08:00
|
|
|
return retval != -EACCES ? retval : -EIO;
|
2010-10-05 04:08:01 +08:00
|
|
|
}
|
|
|
|
|
2009-08-19 05:38:32 +08:00
|
|
|
/**
|
2011-07-06 16:52:13 +08:00
|
|
|
* rpm_suspend - Carry out runtime suspend of given device.
|
2009-08-19 05:38:32 +08:00
|
|
|
* @dev: Device to suspend.
|
2010-09-26 05:34:54 +08:00
|
|
|
* @rpmflags: Flag bits.
|
2009-08-19 05:38:32 +08:00
|
|
|
*
|
2011-10-12 11:53:32 +08:00
|
|
|
* Check if the device's runtime PM status allows it to be suspended.
|
|
|
|
* Cancel a pending idle notification, autosuspend or suspend. If
|
|
|
|
* another suspend has been started earlier, either return immediately
|
|
|
|
* or wait for it to finish, depending on the RPM_NOWAIT and RPM_ASYNC
|
|
|
|
* flags. If the RPM_ASYNC flag is set then queue a suspend request;
|
2011-10-13 04:59:33 +08:00
|
|
|
* otherwise run the ->runtime_suspend() callback directly. When
|
|
|
|
* ->runtime_suspend succeeded, if a deferred resume was requested while
|
|
|
|
* the callback was running then carry it out, otherwise send an idle
|
|
|
|
* notification for its parent (if the suspend succeeded and both
|
|
|
|
* ignore_children of parent->power and irq_safe of dev->power are not set).
|
2011-11-04 06:39:18 +08:00
|
|
|
* If ->runtime_suspend failed with -EAGAIN or -EBUSY, and if the RPM_AUTO
|
|
|
|
* flag is set and the next autosuspend-delay expiration time is in the
|
|
|
|
* future, schedule another autosuspend attempt.
|
2009-08-19 05:38:32 +08:00
|
|
|
*
|
|
|
|
* This function must be called under dev->power.lock with interrupts disabled.
|
|
|
|
*/
|
2010-09-26 05:35:07 +08:00
|
|
|
static int rpm_suspend(struct device *dev, int rpmflags)
|
2009-08-19 05:38:32 +08:00
|
|
|
__releases(&dev->power.lock) __acquires(&dev->power.lock)
|
|
|
|
{
|
2010-10-05 04:08:01 +08:00
|
|
|
int (*callback)(struct device *);
|
2009-08-19 05:38:32 +08:00
|
|
|
struct device *parent = NULL;
|
2010-09-26 05:35:00 +08:00
|
|
|
int retval;
|
2009-08-19 05:38:32 +08:00
|
|
|
|
2016-04-27 01:42:25 +08:00
|
|
|
trace_rpm_suspend_rcuidle(dev, rpmflags);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
|
|
|
repeat:
|
2010-09-26 05:35:00 +08:00
|
|
|
retval = rpm_check_suspend_allowed(dev);
|
|
|
|
if (retval < 0)
|
2020-05-22 23:09:55 +08:00
|
|
|
goto out; /* Conditions are wrong. */
|
2010-09-26 05:35:00 +08:00
|
|
|
|
|
|
|
/* Synchronous suspends are not allowed in the RPM_RESUMING state. */
|
2020-05-22 23:09:55 +08:00
|
|
|
if (dev->power.runtime_status == RPM_RESUMING && !(rpmflags & RPM_ASYNC))
|
2009-08-19 05:38:32 +08:00
|
|
|
retval = -EAGAIN;
|
2010-09-26 05:35:00 +08:00
|
|
|
if (retval)
|
2009-08-19 05:38:32 +08:00
|
|
|
goto out;
|
|
|
|
|
2010-09-26 05:35:21 +08:00
|
|
|
/* If the autosuspend_delay time hasn't expired yet, reschedule. */
|
|
|
|
if ((rpmflags & RPM_AUTO)
|
|
|
|
&& dev->power.runtime_status != RPM_SUSPENDING) {
|
2018-12-14 22:22:25 +08:00
|
|
|
u64 expires = pm_runtime_autosuspend_expiration(dev);
|
2010-09-26 05:35:21 +08:00
|
|
|
|
|
|
|
if (expires != 0) {
|
|
|
|
/* Pending requests need to be canceled. */
|
|
|
|
dev->power.request = RPM_REQ_NONE;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Optimization: If the timer is already running and is
|
|
|
|
* set to expire at or before the autosuspend delay,
|
|
|
|
* avoid the overhead of resetting it. Just let it
|
|
|
|
* expire; pm_suspend_timer_fn() will take care of the
|
|
|
|
* rest.
|
|
|
|
*/
|
2018-12-14 22:22:25 +08:00
|
|
|
if (!(dev->power.timer_expires &&
|
|
|
|
dev->power.timer_expires <= expires)) {
|
|
|
|
/*
|
|
|
|
* We add a slack of 25% to gather wakeups
|
|
|
|
* without sacrificing the granularity.
|
|
|
|
*/
|
2019-01-10 17:00:40 +08:00
|
|
|
u64 slack = (u64)READ_ONCE(dev->power.autosuspend_delay) *
|
2018-12-14 22:22:25 +08:00
|
|
|
(NSEC_PER_MSEC >> 2);
|
|
|
|
|
2010-09-26 05:35:21 +08:00
|
|
|
dev->power.timer_expires = expires;
|
2018-12-14 22:22:25 +08:00
|
|
|
hrtimer_start_range_ns(&dev->power.suspend_timer,
|
|
|
|
ns_to_ktime(expires),
|
|
|
|
slack,
|
|
|
|
HRTIMER_MODE_ABS);
|
2010-09-26 05:35:21 +08:00
|
|
|
}
|
|
|
|
dev->power.timer_autosuspends = 1;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-19 05:38:32 +08:00
|
|
|
/* Other scheduled or pending requests need to be canceled. */
|
|
|
|
pm_runtime_cancel_pending(dev);
|
|
|
|
|
|
|
|
if (dev->power.runtime_status == RPM_SUSPENDING) {
|
|
|
|
DEFINE_WAIT(wait);
|
|
|
|
|
2010-09-26 05:35:00 +08:00
|
|
|
if (rpmflags & (RPM_ASYNC | RPM_NOWAIT)) {
|
2009-08-19 05:38:32 +08:00
|
|
|
retval = -EINPROGRESS;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-09-28 03:54:52 +08:00
|
|
|
if (dev->power.irq_safe) {
|
|
|
|
spin_unlock(&dev->power.lock);
|
|
|
|
|
|
|
|
cpu_relax();
|
|
|
|
|
|
|
|
spin_lock(&dev->power.lock);
|
|
|
|
goto repeat;
|
|
|
|
}
|
|
|
|
|
2009-08-19 05:38:32 +08:00
|
|
|
/* Wait for the other suspend running in parallel with us. */
|
|
|
|
for (;;) {
|
|
|
|
prepare_to_wait(&dev->power.wait_queue, &wait,
|
|
|
|
TASK_UNINTERRUPTIBLE);
|
|
|
|
if (dev->power.runtime_status != RPM_SUSPENDING)
|
|
|
|
break;
|
|
|
|
|
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
|
|
|
|
schedule();
|
|
|
|
|
|
|
|
spin_lock_irq(&dev->power.lock);
|
|
|
|
}
|
|
|
|
finish_wait(&dev->power.wait_queue, &wait);
|
|
|
|
goto repeat;
|
|
|
|
}
|
|
|
|
|
2010-09-26 05:35:15 +08:00
|
|
|
if (dev->power.no_callbacks)
|
|
|
|
goto no_callback; /* Assume success. */
|
|
|
|
|
2010-09-26 05:35:00 +08:00
|
|
|
/* Carry out an asynchronous or a synchronous suspend. */
|
|
|
|
if (rpmflags & RPM_ASYNC) {
|
2010-09-26 05:35:21 +08:00
|
|
|
dev->power.request = (rpmflags & RPM_AUTO) ?
|
|
|
|
RPM_REQ_AUTOSUSPEND : RPM_REQ_SUSPEND;
|
2010-09-26 05:35:00 +08:00
|
|
|
if (!dev->power.request_pending) {
|
|
|
|
dev->power.request_pending = true;
|
|
|
|
queue_work(pm_wq, &dev->power.work);
|
|
|
|
}
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2010-07-19 08:01:06 +08:00
|
|
|
__update_runtime_status(dev, RPM_SUSPENDING);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
2014-10-17 18:58:02 +08:00
|
|
|
callback = RPM_GET_CALLBACK(dev, runtime_suspend);
|
2011-12-18 07:34:13 +08:00
|
|
|
|
2016-12-06 08:38:16 +08:00
|
|
|
dev_pm_enable_wake_irq_check(dev, true);
|
2010-10-05 04:08:01 +08:00
|
|
|
retval = rpm_callback(callback, dev);
|
2011-12-01 07:01:31 +08:00
|
|
|
if (retval)
|
|
|
|
goto fail;
|
2011-11-04 06:39:18 +08:00
|
|
|
|
PM / wakeirq: support enabling wake-up irq after runtime_suspend called
When the dedicated wake IRQ is level trigger, and it uses the
device's low-power status as the wakeup source, that means if the
device is not in low-power state, the wake IRQ will be triggered
if enabled; For this case, need enable the wake IRQ after running
the device's ->runtime_suspend() which make it enter low-power state.
e.g.
Assume the wake IRQ is a low level trigger type, and the wakeup
signal comes from the low-power status of the device.
The wakeup signal is low level at running time (0), and becomes
high level when the device enters low-power state (runtime_suspend
(1) is called), a wakeup event at (2) make the device exit low-power
state, then the wakeup signal also becomes low level.
------------------
| ^ ^|
---------------- | | --------------
|<---(0)--->|<--(1)--| (3) (2) (4)
if enable the wake IRQ before running runtime_suspend during (0),
a wake IRQ will arise, it causes resume immediately;
it works if enable wake IRQ ( e.g. at (3) or (4)) after running
->runtime_suspend().
This patch introduces a new status WAKE_IRQ_DEDICATED_REVERSE to
optionally support enabling wake IRQ after running ->runtime_suspend().
Suggested-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Signed-off-by: Chunfeng Yun <chunfeng.yun@mediatek.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2021-10-25 15:01:53 +08:00
|
|
|
dev_pm_enable_wake_irq_complete(dev);
|
|
|
|
|
2010-09-26 05:35:15 +08:00
|
|
|
no_callback:
|
2011-10-13 04:59:33 +08:00
|
|
|
__update_runtime_status(dev, RPM_SUSPENDED);
|
|
|
|
pm_runtime_deactivate_timer(dev);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
2011-10-13 04:59:33 +08:00
|
|
|
if (dev->parent) {
|
|
|
|
parent = dev->parent;
|
|
|
|
atomic_add_unless(&parent->power.child_count, -1, 0);
|
2009-08-19 05:38:32 +08:00
|
|
|
}
|
|
|
|
wake_up_all(&dev->power.wait_queue);
|
|
|
|
|
|
|
|
if (dev->power.deferred_resume) {
|
2012-08-16 03:31:55 +08:00
|
|
|
dev->power.deferred_resume = false;
|
2010-09-26 05:35:07 +08:00
|
|
|
rpm_resume(dev, 0);
|
2009-08-19 05:38:32 +08:00
|
|
|
retval = -EAGAIN;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2021-03-19 22:47:31 +08:00
|
|
|
if (dev->power.irq_safe)
|
|
|
|
goto out;
|
|
|
|
|
2011-01-26 03:50:07 +08:00
|
|
|
/* Maybe the parent is now able to suspend. */
|
2021-03-19 22:47:31 +08:00
|
|
|
if (parent && !parent->power.ignore_children) {
|
2011-01-26 03:50:07 +08:00
|
|
|
spin_unlock(&dev->power.lock);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
2011-01-26 03:50:07 +08:00
|
|
|
spin_lock(&parent->power.lock);
|
|
|
|
rpm_idle(parent, RPM_ASYNC);
|
|
|
|
spin_unlock(&parent->power.lock);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
2011-01-26 03:50:07 +08:00
|
|
|
spin_lock(&dev->power.lock);
|
2009-08-19 05:38:32 +08:00
|
|
|
}
|
2021-03-19 22:47:31 +08:00
|
|
|
/* Maybe the suppliers are now able to suspend. */
|
|
|
|
if (dev->power.links_count > 0) {
|
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
|
|
|
|
rpm_suspend_suppliers(dev);
|
|
|
|
|
|
|
|
spin_lock_irq(&dev->power.lock);
|
|
|
|
}
|
2009-08-19 05:38:32 +08:00
|
|
|
|
|
|
|
out:
|
2016-04-27 01:42:25 +08:00
|
|
|
trace_rpm_return_int_rcuidle(dev, _THIS_IP_, retval);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
|
|
|
return retval;
|
2011-12-01 07:01:31 +08:00
|
|
|
|
|
|
|
fail:
|
PM / wakeirq: support enabling wake-up irq after runtime_suspend called
When the dedicated wake IRQ is level trigger, and it uses the
device's low-power status as the wakeup source, that means if the
device is not in low-power state, the wake IRQ will be triggered
if enabled; For this case, need enable the wake IRQ after running
the device's ->runtime_suspend() which make it enter low-power state.
e.g.
Assume the wake IRQ is a low level trigger type, and the wakeup
signal comes from the low-power status of the device.
The wakeup signal is low level at running time (0), and becomes
high level when the device enters low-power state (runtime_suspend
(1) is called), a wakeup event at (2) make the device exit low-power
state, then the wakeup signal also becomes low level.
------------------
| ^ ^|
---------------- | | --------------
|<---(0)--->|<--(1)--| (3) (2) (4)
if enable the wake IRQ before running runtime_suspend during (0),
a wake IRQ will arise, it causes resume immediately;
it works if enable wake IRQ ( e.g. at (3) or (4)) after running
->runtime_suspend().
This patch introduces a new status WAKE_IRQ_DEDICATED_REVERSE to
optionally support enabling wake IRQ after running ->runtime_suspend().
Suggested-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Signed-off-by: Chunfeng Yun <chunfeng.yun@mediatek.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2021-10-25 15:01:53 +08:00
|
|
|
dev_pm_disable_wake_irq_check(dev, true);
|
2011-12-01 07:01:31 +08:00
|
|
|
__update_runtime_status(dev, RPM_ACTIVE);
|
|
|
|
dev->power.deferred_resume = false;
|
2012-03-27 04:46:52 +08:00
|
|
|
wake_up_all(&dev->power.wait_queue);
|
|
|
|
|
2011-12-01 07:01:31 +08:00
|
|
|
if (retval == -EAGAIN || retval == -EBUSY) {
|
|
|
|
dev->power.runtime_error = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the callback routine failed an autosuspend, and
|
|
|
|
* if the last_busy time has been updated so that there
|
|
|
|
* is a new autosuspend expiration time, automatically
|
|
|
|
* reschedule another autosuspend.
|
|
|
|
*/
|
|
|
|
if ((rpmflags & RPM_AUTO) &&
|
|
|
|
pm_runtime_autosuspend_expiration(dev) != 0)
|
|
|
|
goto repeat;
|
|
|
|
} else {
|
|
|
|
pm_runtime_cancel_pending(dev);
|
|
|
|
}
|
|
|
|
goto out;
|
2009-08-19 05:38:32 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-07-06 16:52:13 +08:00
|
|
|
* rpm_resume - Carry out runtime resume of given device.
|
2009-08-19 05:38:32 +08:00
|
|
|
* @dev: Device to resume.
|
2010-09-26 05:34:54 +08:00
|
|
|
* @rpmflags: Flag bits.
|
2009-08-19 05:38:32 +08:00
|
|
|
*
|
2011-07-06 16:52:13 +08:00
|
|
|
* Check if the device's runtime PM status allows it to be resumed. Cancel
|
2010-09-26 05:35:00 +08:00
|
|
|
* any scheduled or pending requests. If another resume has been started
|
2011-03-31 09:57:33 +08:00
|
|
|
* earlier, either return immediately or wait for it to finish, depending on the
|
2010-09-26 05:35:00 +08:00
|
|
|
* RPM_NOWAIT and RPM_ASYNC flags. Similarly, if there's a suspend running in
|
|
|
|
* parallel with this function, either tell the other process to resume after
|
|
|
|
* suspending (deferred_resume) or wait for it to finish. If the RPM_ASYNC
|
|
|
|
* flag is set then queue a resume request; otherwise run the
|
|
|
|
* ->runtime_resume() callback directly. Queue an idle notification for the
|
|
|
|
* device if the resume succeeded.
|
2009-08-19 05:38:32 +08:00
|
|
|
*
|
|
|
|
* This function must be called under dev->power.lock with interrupts disabled.
|
|
|
|
*/
|
2010-09-26 05:35:07 +08:00
|
|
|
static int rpm_resume(struct device *dev, int rpmflags)
|
2009-08-19 05:38:32 +08:00
|
|
|
__releases(&dev->power.lock) __acquires(&dev->power.lock)
|
|
|
|
{
|
2010-10-05 04:08:01 +08:00
|
|
|
int (*callback)(struct device *);
|
2009-08-19 05:38:32 +08:00
|
|
|
struct device *parent = NULL;
|
|
|
|
int retval = 0;
|
|
|
|
|
2016-04-27 04:38:55 +08:00
|
|
|
trace_rpm_resume_rcuidle(dev, rpmflags);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
|
|
|
repeat:
|
PM: runtime: Capture device status before disabling runtime PM
In some cases (for example, during system-wide suspend and resume of
devices) it is useful to know whether or not runtime PM has ever been
enabled for a given device and, if so, what the runtime PM status of
it had been right before runtime PM was disabled for it last time.
For this reason, introduce a new struct dev_pm_info field called
last_status that will be used for capturing the runtime PM status of
the device when its power.disable_depth counter changes from 0 to 1.
The new field will be set to RPM_INVALID to start with and whenever
power.disable_depth changes from 1 to 0, so it will be valid only
when runtime PM of the device is currently disabled, but it has been
enabled at least once.
Immediately use power.last_status in rpm_resume() to make it handle
the case when PM runtime is disabled for the device, but its runtime
PM status is RPM_ACTIVE more consistently. Namely, make it return 1
if power.last_status is also equal to RPM_ACTIVE in that case (the
idea being that if the status was RPM_ACTIVE last time when
power.disable_depth was changing from 0 to 1 and it is still
RPM_ACTIVE, it can be assumed to reflect what happened to the device
last time when it was using runtime PM) and -EACCES otherwise.
Update the documentation to provide a description of last_status and
change the description of pm_runtime_resume() in it to reflect the
new behavior of rpm_active().
While at it, rearrange the code in pm_runtime_enable() to be more
straightforward and replace the WARN() macro in it with a pr_warn()
invocation which is less disruptive.
Link: https://lore.kernel.org/linux-pm/20211026222626.39222-1-ulf.hansson@linaro.org/t/#u
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2021-12-08 02:54:32 +08:00
|
|
|
if (dev->power.runtime_error) {
|
2009-08-19 05:38:32 +08:00
|
|
|
retval = -EINVAL;
|
PM: runtime: Capture device status before disabling runtime PM
In some cases (for example, during system-wide suspend and resume of
devices) it is useful to know whether or not runtime PM has ever been
enabled for a given device and, if so, what the runtime PM status of
it had been right before runtime PM was disabled for it last time.
For this reason, introduce a new struct dev_pm_info field called
last_status that will be used for capturing the runtime PM status of
the device when its power.disable_depth counter changes from 0 to 1.
The new field will be set to RPM_INVALID to start with and whenever
power.disable_depth changes from 1 to 0, so it will be valid only
when runtime PM of the device is currently disabled, but it has been
enabled at least once.
Immediately use power.last_status in rpm_resume() to make it handle
the case when PM runtime is disabled for the device, but its runtime
PM status is RPM_ACTIVE more consistently. Namely, make it return 1
if power.last_status is also equal to RPM_ACTIVE in that case (the
idea being that if the status was RPM_ACTIVE last time when
power.disable_depth was changing from 0 to 1 and it is still
RPM_ACTIVE, it can be assumed to reflect what happened to the device
last time when it was using runtime PM) and -EACCES otherwise.
Update the documentation to provide a description of last_status and
change the description of pm_runtime_resume() in it to reflect the
new behavior of rpm_active().
While at it, rearrange the code in pm_runtime_enable() to be more
straightforward and replace the WARN() macro in it with a pr_warn()
invocation which is less disruptive.
Link: https://lore.kernel.org/linux-pm/20211026222626.39222-1-ulf.hansson@linaro.org/t/#u
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2021-12-08 02:54:32 +08:00
|
|
|
} else if (dev->power.disable_depth > 0) {
|
|
|
|
if (dev->power.runtime_status == RPM_ACTIVE &&
|
|
|
|
dev->power.last_status == RPM_ACTIVE)
|
|
|
|
retval = 1;
|
|
|
|
else
|
|
|
|
retval = -EACCES;
|
|
|
|
}
|
2010-09-26 05:35:00 +08:00
|
|
|
if (retval)
|
2009-08-19 05:38:32 +08:00
|
|
|
goto out;
|
|
|
|
|
2010-09-26 05:35:21 +08:00
|
|
|
/*
|
|
|
|
* Other scheduled or pending requests need to be canceled. Small
|
|
|
|
* optimization: If an autosuspend timer is running, leave it running
|
|
|
|
* rather than cancelling it now only to restart it again in the near
|
|
|
|
* future.
|
|
|
|
*/
|
|
|
|
dev->power.request = RPM_REQ_NONE;
|
|
|
|
if (!dev->power.timer_autosuspends)
|
|
|
|
pm_runtime_deactivate_timer(dev);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
2010-09-26 05:35:00 +08:00
|
|
|
if (dev->power.runtime_status == RPM_ACTIVE) {
|
2009-08-19 05:38:32 +08:00
|
|
|
retval = 1;
|
|
|
|
goto out;
|
2010-09-26 05:35:00 +08:00
|
|
|
}
|
2009-08-19 05:38:32 +08:00
|
|
|
|
|
|
|
if (dev->power.runtime_status == RPM_RESUMING
|
|
|
|
|| dev->power.runtime_status == RPM_SUSPENDING) {
|
|
|
|
DEFINE_WAIT(wait);
|
|
|
|
|
2010-09-26 05:35:00 +08:00
|
|
|
if (rpmflags & (RPM_ASYNC | RPM_NOWAIT)) {
|
2009-08-19 05:38:32 +08:00
|
|
|
if (dev->power.runtime_status == RPM_SUSPENDING)
|
|
|
|
dev->power.deferred_resume = true;
|
2010-09-26 05:35:00 +08:00
|
|
|
else
|
|
|
|
retval = -EINPROGRESS;
|
2009-08-19 05:38:32 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2011-09-28 03:54:52 +08:00
|
|
|
if (dev->power.irq_safe) {
|
|
|
|
spin_unlock(&dev->power.lock);
|
|
|
|
|
|
|
|
cpu_relax();
|
|
|
|
|
|
|
|
spin_lock(&dev->power.lock);
|
|
|
|
goto repeat;
|
|
|
|
}
|
|
|
|
|
2009-08-19 05:38:32 +08:00
|
|
|
/* Wait for the operation carried out in parallel with us. */
|
|
|
|
for (;;) {
|
|
|
|
prepare_to_wait(&dev->power.wait_queue, &wait,
|
|
|
|
TASK_UNINTERRUPTIBLE);
|
|
|
|
if (dev->power.runtime_status != RPM_RESUMING
|
|
|
|
&& dev->power.runtime_status != RPM_SUSPENDING)
|
|
|
|
break;
|
|
|
|
|
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
|
|
|
|
schedule();
|
|
|
|
|
|
|
|
spin_lock_irq(&dev->power.lock);
|
|
|
|
}
|
|
|
|
finish_wait(&dev->power.wait_queue, &wait);
|
|
|
|
goto repeat;
|
|
|
|
}
|
|
|
|
|
2010-09-26 05:35:15 +08:00
|
|
|
/*
|
|
|
|
* See if we can skip waking up the parent. This is safe only if
|
|
|
|
* power.no_callbacks is set, because otherwise we don't know whether
|
|
|
|
* the resume will actually succeed.
|
|
|
|
*/
|
|
|
|
if (dev->power.no_callbacks && !parent && dev->parent) {
|
2010-10-23 05:48:14 +08:00
|
|
|
spin_lock_nested(&dev->parent->power.lock, SINGLE_DEPTH_NESTING);
|
2010-09-26 05:35:15 +08:00
|
|
|
if (dev->parent->power.disable_depth > 0
|
|
|
|
|| dev->parent->power.ignore_children
|
|
|
|
|| dev->parent->power.runtime_status == RPM_ACTIVE) {
|
|
|
|
atomic_inc(&dev->parent->power.child_count);
|
|
|
|
spin_unlock(&dev->parent->power.lock);
|
2012-08-16 03:31:45 +08:00
|
|
|
retval = 1;
|
2010-09-26 05:35:15 +08:00
|
|
|
goto no_callback; /* Assume success. */
|
|
|
|
}
|
|
|
|
spin_unlock(&dev->parent->power.lock);
|
|
|
|
}
|
|
|
|
|
2010-09-26 05:35:00 +08:00
|
|
|
/* Carry out an asynchronous or a synchronous resume. */
|
|
|
|
if (rpmflags & RPM_ASYNC) {
|
|
|
|
dev->power.request = RPM_REQ_RESUME;
|
|
|
|
if (!dev->power.request_pending) {
|
|
|
|
dev->power.request_pending = true;
|
|
|
|
queue_work(pm_wq, &dev->power.work);
|
|
|
|
}
|
|
|
|
retval = 0;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2009-08-19 05:38:32 +08:00
|
|
|
if (!parent && dev->parent) {
|
|
|
|
/*
|
2010-12-01 07:14:42 +08:00
|
|
|
* Increment the parent's usage counter and resume it if
|
|
|
|
* necessary. Not needed if dev is irq-safe; then the
|
|
|
|
* parent is permanently resumed.
|
2009-08-19 05:38:32 +08:00
|
|
|
*/
|
|
|
|
parent = dev->parent;
|
2010-12-01 07:14:42 +08:00
|
|
|
if (dev->power.irq_safe)
|
|
|
|
goto skip_parent;
|
2009-11-25 08:06:37 +08:00
|
|
|
spin_unlock(&dev->power.lock);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
|
|
|
pm_runtime_get_noresume(parent);
|
|
|
|
|
2009-11-25 08:06:37 +08:00
|
|
|
spin_lock(&parent->power.lock);
|
2009-08-19 05:38:32 +08:00
|
|
|
/*
|
2016-10-18 02:16:59 +08:00
|
|
|
* Resume the parent if it has runtime PM enabled and not been
|
|
|
|
* set to ignore its children.
|
2009-08-19 05:38:32 +08:00
|
|
|
*/
|
|
|
|
if (!parent->power.disable_depth
|
|
|
|
&& !parent->power.ignore_children) {
|
2010-09-26 05:35:07 +08:00
|
|
|
rpm_resume(parent, 0);
|
2009-08-19 05:38:32 +08:00
|
|
|
if (parent->power.runtime_status != RPM_ACTIVE)
|
|
|
|
retval = -EBUSY;
|
|
|
|
}
|
2009-11-25 08:06:37 +08:00
|
|
|
spin_unlock(&parent->power.lock);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
2009-11-25 08:06:37 +08:00
|
|
|
spin_lock(&dev->power.lock);
|
2009-08-19 05:38:32 +08:00
|
|
|
if (retval)
|
|
|
|
goto out;
|
|
|
|
goto repeat;
|
|
|
|
}
|
2010-12-01 07:14:42 +08:00
|
|
|
skip_parent:
|
2009-08-19 05:38:32 +08:00
|
|
|
|
2010-09-26 05:35:15 +08:00
|
|
|
if (dev->power.no_callbacks)
|
|
|
|
goto no_callback; /* Assume success. */
|
|
|
|
|
2010-07-19 08:01:06 +08:00
|
|
|
__update_runtime_status(dev, RPM_RESUMING);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
2014-10-17 18:58:02 +08:00
|
|
|
callback = RPM_GET_CALLBACK(dev, runtime_resume);
|
2011-12-18 07:34:13 +08:00
|
|
|
|
PM / wakeirq: support enabling wake-up irq after runtime_suspend called
When the dedicated wake IRQ is level trigger, and it uses the
device's low-power status as the wakeup source, that means if the
device is not in low-power state, the wake IRQ will be triggered
if enabled; For this case, need enable the wake IRQ after running
the device's ->runtime_suspend() which make it enter low-power state.
e.g.
Assume the wake IRQ is a low level trigger type, and the wakeup
signal comes from the low-power status of the device.
The wakeup signal is low level at running time (0), and becomes
high level when the device enters low-power state (runtime_suspend
(1) is called), a wakeup event at (2) make the device exit low-power
state, then the wakeup signal also becomes low level.
------------------
| ^ ^|
---------------- | | --------------
|<---(0)--->|<--(1)--| (3) (2) (4)
if enable the wake IRQ before running runtime_suspend during (0),
a wake IRQ will arise, it causes resume immediately;
it works if enable wake IRQ ( e.g. at (3) or (4)) after running
->runtime_suspend().
This patch introduces a new status WAKE_IRQ_DEDICATED_REVERSE to
optionally support enabling wake IRQ after running ->runtime_suspend().
Suggested-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Signed-off-by: Chunfeng Yun <chunfeng.yun@mediatek.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2021-10-25 15:01:53 +08:00
|
|
|
dev_pm_disable_wake_irq_check(dev, false);
|
2010-10-05 04:08:01 +08:00
|
|
|
retval = rpm_callback(callback, dev);
|
2009-08-19 05:38:32 +08:00
|
|
|
if (retval) {
|
2010-07-19 08:01:06 +08:00
|
|
|
__update_runtime_status(dev, RPM_SUSPENDED);
|
2009-08-19 05:38:32 +08:00
|
|
|
pm_runtime_cancel_pending(dev);
|
2016-12-06 08:38:16 +08:00
|
|
|
dev_pm_enable_wake_irq_check(dev, false);
|
2009-08-19 05:38:32 +08:00
|
|
|
} else {
|
2010-09-26 05:35:15 +08:00
|
|
|
no_callback:
|
2010-07-19 08:01:06 +08:00
|
|
|
__update_runtime_status(dev, RPM_ACTIVE);
|
2015-05-14 07:36:32 +08:00
|
|
|
pm_runtime_mark_last_busy(dev);
|
2009-08-19 05:38:32 +08:00
|
|
|
if (parent)
|
|
|
|
atomic_inc(&parent->power.child_count);
|
|
|
|
}
|
|
|
|
wake_up_all(&dev->power.wait_queue);
|
|
|
|
|
2012-08-16 03:31:45 +08:00
|
|
|
if (retval >= 0)
|
2010-09-26 05:35:07 +08:00
|
|
|
rpm_idle(dev, RPM_ASYNC);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
|
|
|
out:
|
2010-12-01 07:14:42 +08:00
|
|
|
if (parent && !dev->power.irq_safe) {
|
2009-08-19 05:38:32 +08:00
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
|
|
|
|
pm_runtime_put(parent);
|
|
|
|
|
|
|
|
spin_lock_irq(&dev->power.lock);
|
|
|
|
}
|
|
|
|
|
2016-04-27 04:38:55 +08:00
|
|
|
trace_rpm_return_int_rcuidle(dev, _THIS_IP_, retval);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-07-06 16:52:13 +08:00
|
|
|
* pm_runtime_work - Universal runtime PM work function.
|
2009-08-19 05:38:32 +08:00
|
|
|
* @work: Work structure used for scheduling the execution of this function.
|
|
|
|
*
|
|
|
|
* Use @work to get the device object the work is to be done for, determine what
|
2011-07-06 16:52:13 +08:00
|
|
|
* is to be done and execute the appropriate runtime PM function.
|
2009-08-19 05:38:32 +08:00
|
|
|
*/
|
|
|
|
static void pm_runtime_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct device *dev = container_of(work, struct device, power.work);
|
|
|
|
enum rpm_request req;
|
|
|
|
|
|
|
|
spin_lock_irq(&dev->power.lock);
|
|
|
|
|
|
|
|
if (!dev->power.request_pending)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
req = dev->power.request;
|
|
|
|
dev->power.request = RPM_REQ_NONE;
|
|
|
|
dev->power.request_pending = false;
|
|
|
|
|
|
|
|
switch (req) {
|
|
|
|
case RPM_REQ_NONE:
|
|
|
|
break;
|
|
|
|
case RPM_REQ_IDLE:
|
2010-09-26 05:35:07 +08:00
|
|
|
rpm_idle(dev, RPM_NOWAIT);
|
2009-08-19 05:38:32 +08:00
|
|
|
break;
|
|
|
|
case RPM_REQ_SUSPEND:
|
2010-09-26 05:35:07 +08:00
|
|
|
rpm_suspend(dev, RPM_NOWAIT);
|
2009-08-19 05:38:32 +08:00
|
|
|
break;
|
2010-09-26 05:35:21 +08:00
|
|
|
case RPM_REQ_AUTOSUSPEND:
|
|
|
|
rpm_suspend(dev, RPM_NOWAIT | RPM_AUTO);
|
|
|
|
break;
|
2009-08-19 05:38:32 +08:00
|
|
|
case RPM_REQ_RESUME:
|
2010-09-26 05:35:07 +08:00
|
|
|
rpm_resume(dev, RPM_NOWAIT);
|
2009-08-19 05:38:32 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_suspend_timer_fn - Timer function for pm_schedule_suspend().
|
2021-04-01 07:26:10 +08:00
|
|
|
* @timer: hrtimer used by pm_schedule_suspend().
|
2009-08-19 05:38:32 +08:00
|
|
|
*
|
2010-09-26 05:35:00 +08:00
|
|
|
* Check if the time is right and queue a suspend request.
|
2009-08-19 05:38:32 +08:00
|
|
|
*/
|
2018-12-14 22:22:25 +08:00
|
|
|
static enum hrtimer_restart pm_suspend_timer_fn(struct hrtimer *timer)
|
2009-08-19 05:38:32 +08:00
|
|
|
{
|
2018-12-14 22:22:25 +08:00
|
|
|
struct device *dev = container_of(timer, struct device, power.suspend_timer);
|
2009-08-19 05:38:32 +08:00
|
|
|
unsigned long flags;
|
2018-12-14 22:22:25 +08:00
|
|
|
u64 expires;
|
2009-08-19 05:38:32 +08:00
|
|
|
|
|
|
|
spin_lock_irqsave(&dev->power.lock, flags);
|
|
|
|
|
|
|
|
expires = dev->power.timer_expires;
|
2019-01-10 07:19:44 +08:00
|
|
|
/*
|
|
|
|
* If 'expires' is after the current time, we've been called
|
|
|
|
* too early.
|
|
|
|
*/
|
2019-01-31 01:26:02 +08:00
|
|
|
if (expires > 0 && expires < ktime_get_mono_fast_ns()) {
|
2009-08-19 05:38:32 +08:00
|
|
|
dev->power.timer_expires = 0;
|
2010-09-26 05:35:21 +08:00
|
|
|
rpm_suspend(dev, dev->power.timer_autosuspends ?
|
|
|
|
(RPM_ASYNC | RPM_AUTO) : RPM_ASYNC);
|
2009-08-19 05:38:32 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&dev->power.lock, flags);
|
2018-12-14 22:22:25 +08:00
|
|
|
|
|
|
|
return HRTIMER_NORESTART;
|
2009-08-19 05:38:32 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_schedule_suspend - Set up a timer to submit a suspend request in future.
|
|
|
|
* @dev: Device to suspend.
|
|
|
|
* @delay: Time to wait before submitting a suspend request, in milliseconds.
|
|
|
|
*/
|
|
|
|
int pm_schedule_suspend(struct device *dev, unsigned int delay)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
2019-01-31 01:26:02 +08:00
|
|
|
u64 expires;
|
2010-09-26 05:35:00 +08:00
|
|
|
int retval;
|
2009-08-19 05:38:32 +08:00
|
|
|
|
|
|
|
spin_lock_irqsave(&dev->power.lock, flags);
|
|
|
|
|
|
|
|
if (!delay) {
|
2010-09-26 05:35:07 +08:00
|
|
|
retval = rpm_suspend(dev, RPM_ASYNC);
|
2009-08-19 05:38:32 +08:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2010-09-26 05:35:00 +08:00
|
|
|
retval = rpm_check_suspend_allowed(dev);
|
2009-08-19 05:38:32 +08:00
|
|
|
if (retval)
|
|
|
|
goto out;
|
|
|
|
|
2010-09-26 05:35:00 +08:00
|
|
|
/* Other scheduled or pending requests need to be canceled. */
|
|
|
|
pm_runtime_cancel_pending(dev);
|
|
|
|
|
2019-01-31 01:26:02 +08:00
|
|
|
expires = ktime_get_mono_fast_ns() + (u64)delay * NSEC_PER_MSEC;
|
|
|
|
dev->power.timer_expires = expires;
|
2010-09-26 05:35:21 +08:00
|
|
|
dev->power.timer_autosuspends = 0;
|
2018-12-14 22:22:25 +08:00
|
|
|
hrtimer_start(&dev->power.suspend_timer, expires, HRTIMER_MODE_ABS);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
|
|
|
out:
|
|
|
|
spin_unlock_irqrestore(&dev->power.lock, flags);
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(pm_schedule_suspend);
|
|
|
|
|
|
|
|
/**
|
2011-07-06 16:52:13 +08:00
|
|
|
* __pm_runtime_idle - Entry point for runtime idle operations.
|
2010-09-26 05:35:07 +08:00
|
|
|
* @dev: Device to send idle notification for.
|
|
|
|
* @rpmflags: Flag bits.
|
|
|
|
*
|
|
|
|
* If the RPM_GET_PUT flag is set, decrement the device's usage count and
|
|
|
|
* return immediately if it is larger than zero. Then carry out an idle
|
|
|
|
* notification, either synchronous or asynchronous.
|
|
|
|
*
|
2011-08-09 05:39:36 +08:00
|
|
|
* This routine may be called in atomic context if the RPM_ASYNC flag is set,
|
|
|
|
* or if pm_runtime_irq_safe() has been called.
|
2009-08-19 05:38:32 +08:00
|
|
|
*/
|
2010-09-26 05:35:07 +08:00
|
|
|
int __pm_runtime_idle(struct device *dev, int rpmflags)
|
2009-08-19 05:38:32 +08:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
int retval;
|
|
|
|
|
2010-09-26 05:35:07 +08:00
|
|
|
if (rpmflags & RPM_GET_PUT) {
|
2020-01-05 00:27:57 +08:00
|
|
|
if (!atomic_dec_and_test(&dev->power.usage_count)) {
|
|
|
|
trace_rpm_usage_rcuidle(dev, rpmflags);
|
2010-09-26 05:35:07 +08:00
|
|
|
return 0;
|
2020-01-05 00:27:57 +08:00
|
|
|
}
|
2010-09-26 05:35:07 +08:00
|
|
|
}
|
|
|
|
|
PM / runtime: Avoid false-positive warnings from might_sleep_if()
The might_sleep_if() assertions in __pm_runtime_idle(),
__pm_runtime_suspend() and __pm_runtime_resume() may generate
false-positive warnings in some situations. For example, that
happens if a nested pm_runtime_get_sync()/pm_runtime_put() pair
is executed with disabled interrupts within an outer
pm_runtime_get_sync()/pm_runtime_put() section for the same device.
[Generally, pm_runtime_get_sync() may sleep, so it should not be
called with disabled interrupts, but in this particular case the
previous pm_runtime_get_sync() guarantees that the device will not
be suspended, so the inner pm_runtime_get_sync() will return
immediately after incrementing the device's usage counter.]
That started to happen in the i915 driver in 4.10-rc, leading to
the following splat:
BUG: sleeping function called from invalid context at drivers/base/power/runtime.c:1032
in_atomic(): 1, irqs_disabled(): 0, pid: 1500, name: Xorg
1 lock held by Xorg/1500:
#0: (&dev->struct_mutex){+.+.+.}, at:
[<ffffffffa0680c13>] i915_mutex_lock_interruptible+0x43/0x140 [i915]
CPU: 0 PID: 1500 Comm: Xorg Not tainted
Call Trace:
dump_stack+0x85/0xc2
___might_sleep+0x196/0x260
__might_sleep+0x53/0xb0
__pm_runtime_resume+0x7a/0x90
intel_runtime_pm_get+0x25/0x90 [i915]
aliasing_gtt_bind_vma+0xaa/0xf0 [i915]
i915_vma_bind+0xaf/0x1e0 [i915]
i915_gem_execbuffer_relocate_entry+0x513/0x6f0 [i915]
i915_gem_execbuffer_relocate_vma.isra.34+0x188/0x250 [i915]
? trace_hardirqs_on+0xd/0x10
? i915_gem_execbuffer_reserve_vma.isra.31+0x152/0x1f0 [i915]
? i915_gem_execbuffer_reserve.isra.32+0x372/0x3a0 [i915]
i915_gem_do_execbuffer.isra.38+0xa70/0x1a40 [i915]
? __might_fault+0x4e/0xb0
i915_gem_execbuffer2+0xc5/0x260 [i915]
? __might_fault+0x4e/0xb0
drm_ioctl+0x206/0x450 [drm]
? i915_gem_execbuffer+0x340/0x340 [i915]
? __fget+0x5/0x200
do_vfs_ioctl+0x91/0x6f0
? __fget+0x111/0x200
? __fget+0x5/0x200
SyS_ioctl+0x79/0x90
entry_SYSCALL_64_fastpath+0x23/0xc6
even though the code triggering it is correct.
Unfortunately, the might_sleep_if() assertions in question are
too coarse-grained to cover such cases correctly, so make them
a bit less sensitive in order to avoid the false-positives.
Reported-and-tested-by: Sedat Dilek <sedat.dilek@gmail.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2017-02-04 07:44:36 +08:00
|
|
|
might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe);
|
|
|
|
|
2009-08-19 05:38:32 +08:00
|
|
|
spin_lock_irqsave(&dev->power.lock, flags);
|
2010-09-26 05:35:07 +08:00
|
|
|
retval = rpm_idle(dev, rpmflags);
|
2009-08-19 05:38:32 +08:00
|
|
|
spin_unlock_irqrestore(&dev->power.lock, flags);
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
2010-09-26 05:35:07 +08:00
|
|
|
EXPORT_SYMBOL_GPL(__pm_runtime_idle);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
|
|
|
/**
|
2011-07-06 16:52:13 +08:00
|
|
|
* __pm_runtime_suspend - Entry point for runtime put/suspend operations.
|
2010-09-26 05:35:07 +08:00
|
|
|
* @dev: Device to suspend.
|
2010-09-26 05:34:54 +08:00
|
|
|
* @rpmflags: Flag bits.
|
2009-08-19 05:38:32 +08:00
|
|
|
*
|
2010-09-26 05:35:21 +08:00
|
|
|
* If the RPM_GET_PUT flag is set, decrement the device's usage count and
|
|
|
|
* return immediately if it is larger than zero. Then carry out a suspend,
|
|
|
|
* either synchronous or asynchronous.
|
2010-09-26 05:35:07 +08:00
|
|
|
*
|
2011-08-09 05:39:36 +08:00
|
|
|
* This routine may be called in atomic context if the RPM_ASYNC flag is set,
|
|
|
|
* or if pm_runtime_irq_safe() has been called.
|
2009-08-19 05:38:32 +08:00
|
|
|
*/
|
2010-09-26 05:35:07 +08:00
|
|
|
int __pm_runtime_suspend(struct device *dev, int rpmflags)
|
2009-08-19 05:38:32 +08:00
|
|
|
{
|
2010-09-26 05:35:07 +08:00
|
|
|
unsigned long flags;
|
2009-12-14 03:28:30 +08:00
|
|
|
int retval;
|
2009-08-19 05:38:32 +08:00
|
|
|
|
2010-09-26 05:35:21 +08:00
|
|
|
if (rpmflags & RPM_GET_PUT) {
|
2020-01-05 00:27:57 +08:00
|
|
|
if (!atomic_dec_and_test(&dev->power.usage_count)) {
|
|
|
|
trace_rpm_usage_rcuidle(dev, rpmflags);
|
2010-09-26 05:35:21 +08:00
|
|
|
return 0;
|
2020-01-05 00:27:57 +08:00
|
|
|
}
|
2010-09-26 05:35:21 +08:00
|
|
|
}
|
|
|
|
|
PM / runtime: Avoid false-positive warnings from might_sleep_if()
The might_sleep_if() assertions in __pm_runtime_idle(),
__pm_runtime_suspend() and __pm_runtime_resume() may generate
false-positive warnings in some situations. For example, that
happens if a nested pm_runtime_get_sync()/pm_runtime_put() pair
is executed with disabled interrupts within an outer
pm_runtime_get_sync()/pm_runtime_put() section for the same device.
[Generally, pm_runtime_get_sync() may sleep, so it should not be
called with disabled interrupts, but in this particular case the
previous pm_runtime_get_sync() guarantees that the device will not
be suspended, so the inner pm_runtime_get_sync() will return
immediately after incrementing the device's usage counter.]
That started to happen in the i915 driver in 4.10-rc, leading to
the following splat:
BUG: sleeping function called from invalid context at drivers/base/power/runtime.c:1032
in_atomic(): 1, irqs_disabled(): 0, pid: 1500, name: Xorg
1 lock held by Xorg/1500:
#0: (&dev->struct_mutex){+.+.+.}, at:
[<ffffffffa0680c13>] i915_mutex_lock_interruptible+0x43/0x140 [i915]
CPU: 0 PID: 1500 Comm: Xorg Not tainted
Call Trace:
dump_stack+0x85/0xc2
___might_sleep+0x196/0x260
__might_sleep+0x53/0xb0
__pm_runtime_resume+0x7a/0x90
intel_runtime_pm_get+0x25/0x90 [i915]
aliasing_gtt_bind_vma+0xaa/0xf0 [i915]
i915_vma_bind+0xaf/0x1e0 [i915]
i915_gem_execbuffer_relocate_entry+0x513/0x6f0 [i915]
i915_gem_execbuffer_relocate_vma.isra.34+0x188/0x250 [i915]
? trace_hardirqs_on+0xd/0x10
? i915_gem_execbuffer_reserve_vma.isra.31+0x152/0x1f0 [i915]
? i915_gem_execbuffer_reserve.isra.32+0x372/0x3a0 [i915]
i915_gem_do_execbuffer.isra.38+0xa70/0x1a40 [i915]
? __might_fault+0x4e/0xb0
i915_gem_execbuffer2+0xc5/0x260 [i915]
? __might_fault+0x4e/0xb0
drm_ioctl+0x206/0x450 [drm]
? i915_gem_execbuffer+0x340/0x340 [i915]
? __fget+0x5/0x200
do_vfs_ioctl+0x91/0x6f0
? __fget+0x111/0x200
? __fget+0x5/0x200
SyS_ioctl+0x79/0x90
entry_SYSCALL_64_fastpath+0x23/0xc6
even though the code triggering it is correct.
Unfortunately, the might_sleep_if() assertions in question are
too coarse-grained to cover such cases correctly, so make them
a bit less sensitive in order to avoid the false-positives.
Reported-and-tested-by: Sedat Dilek <sedat.dilek@gmail.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2017-02-04 07:44:36 +08:00
|
|
|
might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe);
|
|
|
|
|
2010-09-26 05:35:07 +08:00
|
|
|
spin_lock_irqsave(&dev->power.lock, flags);
|
|
|
|
retval = rpm_suspend(dev, rpmflags);
|
|
|
|
spin_unlock_irqrestore(&dev->power.lock, flags);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
2010-09-26 05:35:07 +08:00
|
|
|
EXPORT_SYMBOL_GPL(__pm_runtime_suspend);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
|
|
|
/**
|
2011-07-06 16:52:13 +08:00
|
|
|
* __pm_runtime_resume - Entry point for runtime resume operations.
|
2010-09-26 05:35:07 +08:00
|
|
|
* @dev: Device to resume.
|
2010-09-26 05:34:54 +08:00
|
|
|
* @rpmflags: Flag bits.
|
2009-08-19 05:38:32 +08:00
|
|
|
*
|
2010-09-26 05:35:07 +08:00
|
|
|
* If the RPM_GET_PUT flag is set, increment the device's usage count. Then
|
|
|
|
* carry out a resume, either synchronous or asynchronous.
|
|
|
|
*
|
2011-08-09 05:39:36 +08:00
|
|
|
* This routine may be called in atomic context if the RPM_ASYNC flag is set,
|
|
|
|
* or if pm_runtime_irq_safe() has been called.
|
2009-08-19 05:38:32 +08:00
|
|
|
*/
|
2010-09-26 05:35:07 +08:00
|
|
|
int __pm_runtime_resume(struct device *dev, int rpmflags)
|
2009-08-19 05:38:32 +08:00
|
|
|
{
|
2010-09-26 05:35:07 +08:00
|
|
|
unsigned long flags;
|
|
|
|
int retval;
|
2009-08-19 05:38:32 +08:00
|
|
|
|
PM / runtime: Avoid false-positive warnings from might_sleep_if()
The might_sleep_if() assertions in __pm_runtime_idle(),
__pm_runtime_suspend() and __pm_runtime_resume() may generate
false-positive warnings in some situations. For example, that
happens if a nested pm_runtime_get_sync()/pm_runtime_put() pair
is executed with disabled interrupts within an outer
pm_runtime_get_sync()/pm_runtime_put() section for the same device.
[Generally, pm_runtime_get_sync() may sleep, so it should not be
called with disabled interrupts, but in this particular case the
previous pm_runtime_get_sync() guarantees that the device will not
be suspended, so the inner pm_runtime_get_sync() will return
immediately after incrementing the device's usage counter.]
That started to happen in the i915 driver in 4.10-rc, leading to
the following splat:
BUG: sleeping function called from invalid context at drivers/base/power/runtime.c:1032
in_atomic(): 1, irqs_disabled(): 0, pid: 1500, name: Xorg
1 lock held by Xorg/1500:
#0: (&dev->struct_mutex){+.+.+.}, at:
[<ffffffffa0680c13>] i915_mutex_lock_interruptible+0x43/0x140 [i915]
CPU: 0 PID: 1500 Comm: Xorg Not tainted
Call Trace:
dump_stack+0x85/0xc2
___might_sleep+0x196/0x260
__might_sleep+0x53/0xb0
__pm_runtime_resume+0x7a/0x90
intel_runtime_pm_get+0x25/0x90 [i915]
aliasing_gtt_bind_vma+0xaa/0xf0 [i915]
i915_vma_bind+0xaf/0x1e0 [i915]
i915_gem_execbuffer_relocate_entry+0x513/0x6f0 [i915]
i915_gem_execbuffer_relocate_vma.isra.34+0x188/0x250 [i915]
? trace_hardirqs_on+0xd/0x10
? i915_gem_execbuffer_reserve_vma.isra.31+0x152/0x1f0 [i915]
? i915_gem_execbuffer_reserve.isra.32+0x372/0x3a0 [i915]
i915_gem_do_execbuffer.isra.38+0xa70/0x1a40 [i915]
? __might_fault+0x4e/0xb0
i915_gem_execbuffer2+0xc5/0x260 [i915]
? __might_fault+0x4e/0xb0
drm_ioctl+0x206/0x450 [drm]
? i915_gem_execbuffer+0x340/0x340 [i915]
? __fget+0x5/0x200
do_vfs_ioctl+0x91/0x6f0
? __fget+0x111/0x200
? __fget+0x5/0x200
SyS_ioctl+0x79/0x90
entry_SYSCALL_64_fastpath+0x23/0xc6
even though the code triggering it is correct.
Unfortunately, the might_sleep_if() assertions in question are
too coarse-grained to cover such cases correctly, so make them
a bit less sensitive in order to avoid the false-positives.
Reported-and-tested-by: Sedat Dilek <sedat.dilek@gmail.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2017-02-04 07:44:36 +08:00
|
|
|
might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe &&
|
|
|
|
dev->power.runtime_status != RPM_ACTIVE);
|
2011-08-09 05:39:36 +08:00
|
|
|
|
2010-09-26 05:35:07 +08:00
|
|
|
if (rpmflags & RPM_GET_PUT)
|
|
|
|
atomic_inc(&dev->power.usage_count);
|
|
|
|
|
|
|
|
spin_lock_irqsave(&dev->power.lock, flags);
|
|
|
|
retval = rpm_resume(dev, rpmflags);
|
|
|
|
spin_unlock_irqrestore(&dev->power.lock, flags);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
2010-09-26 05:35:07 +08:00
|
|
|
EXPORT_SYMBOL_GPL(__pm_runtime_resume);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
2015-12-17 09:54:26 +08:00
|
|
|
/**
|
2020-08-01 01:04:11 +08:00
|
|
|
* pm_runtime_get_if_active - Conditionally bump up device usage counter.
|
2015-12-17 09:54:26 +08:00
|
|
|
* @dev: Device to handle.
|
2020-08-01 01:04:11 +08:00
|
|
|
* @ign_usage_count: Whether or not to look at the current usage counter value.
|
2015-12-17 09:54:26 +08:00
|
|
|
*
|
2020-08-01 01:04:11 +08:00
|
|
|
* Return -EINVAL if runtime PM is disabled for @dev.
|
2015-12-17 09:54:26 +08:00
|
|
|
*
|
2020-08-01 01:04:11 +08:00
|
|
|
* Otherwise, if the runtime PM status of @dev is %RPM_ACTIVE and either
|
|
|
|
* @ign_usage_count is %true or the runtime PM usage counter of @dev is not
|
|
|
|
* zero, increment the usage counter of @dev and return 1. Otherwise, return 0
|
|
|
|
* without changing the usage counter.
|
2020-02-25 17:31:02 +08:00
|
|
|
*
|
2020-08-01 01:04:11 +08:00
|
|
|
* If @ign_usage_count is %true, this function can be used to prevent suspending
|
|
|
|
* the device when its runtime PM status is %RPM_ACTIVE.
|
2020-02-25 17:31:02 +08:00
|
|
|
*
|
2020-08-01 01:04:11 +08:00
|
|
|
* If @ign_usage_count is %false, this function can be used to prevent
|
|
|
|
* suspending the device when both its runtime PM status is %RPM_ACTIVE and its
|
|
|
|
* runtime PM usage counter is not zero.
|
2020-02-25 17:31:02 +08:00
|
|
|
*
|
2021-01-20 22:33:12 +08:00
|
|
|
* The caller is responsible for decrementing the runtime PM usage counter of
|
2020-08-01 01:04:11 +08:00
|
|
|
* @dev after this function has returned a positive value for it.
|
2015-12-17 09:54:26 +08:00
|
|
|
*/
|
2020-02-25 17:31:02 +08:00
|
|
|
int pm_runtime_get_if_active(struct device *dev, bool ign_usage_count)
|
2015-12-17 09:54:26 +08:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&dev->power.lock, flags);
|
2020-02-25 17:31:02 +08:00
|
|
|
if (dev->power.disable_depth > 0) {
|
|
|
|
retval = -EINVAL;
|
|
|
|
} else if (dev->power.runtime_status != RPM_ACTIVE) {
|
|
|
|
retval = 0;
|
|
|
|
} else if (ign_usage_count) {
|
|
|
|
retval = 1;
|
|
|
|
atomic_inc(&dev->power.usage_count);
|
|
|
|
} else {
|
|
|
|
retval = atomic_inc_not_zero(&dev->power.usage_count);
|
|
|
|
}
|
2020-01-05 00:27:57 +08:00
|
|
|
trace_rpm_usage_rcuidle(dev, 0);
|
2015-12-17 09:54:26 +08:00
|
|
|
spin_unlock_irqrestore(&dev->power.lock, flags);
|
2020-02-25 17:31:02 +08:00
|
|
|
|
2015-12-17 09:54:26 +08:00
|
|
|
return retval;
|
|
|
|
}
|
2020-02-25 17:31:02 +08:00
|
|
|
EXPORT_SYMBOL_GPL(pm_runtime_get_if_active);
|
2015-12-17 09:54:26 +08:00
|
|
|
|
2009-08-19 05:38:32 +08:00
|
|
|
/**
|
2011-07-06 16:52:13 +08:00
|
|
|
* __pm_runtime_set_status - Set runtime PM status of a device.
|
2009-08-19 05:38:32 +08:00
|
|
|
* @dev: Device to handle.
|
2011-07-06 16:52:13 +08:00
|
|
|
* @status: New runtime PM status of the device.
|
2009-08-19 05:38:32 +08:00
|
|
|
*
|
2011-07-06 16:52:13 +08:00
|
|
|
* If runtime PM of the device is disabled or its power.runtime_error field is
|
2009-08-19 05:38:32 +08:00
|
|
|
* different from zero, the status may be changed either to RPM_ACTIVE, or to
|
|
|
|
* RPM_SUSPENDED, as long as that reflects the actual state of the device.
|
|
|
|
* However, if the device has a parent and the parent is not active, and the
|
|
|
|
* parent's power.ignore_children flag is unset, the device's status cannot be
|
|
|
|
* set to RPM_ACTIVE, so -EBUSY is returned in that case.
|
|
|
|
*
|
|
|
|
* If successful, __pm_runtime_set_status() clears the power.runtime_error field
|
|
|
|
* and the device parent's counter of unsuspended children is modified to
|
|
|
|
* reflect the new status. If the new status is RPM_SUSPENDED, an idle
|
|
|
|
* notification request for the parent is submitted.
|
2019-02-08 02:38:56 +08:00
|
|
|
*
|
|
|
|
* If @dev has any suppliers (as reflected by device links to them), and @status
|
|
|
|
* is RPM_ACTIVE, they will be activated upfront and if the activation of one
|
|
|
|
* of them fails, the status of @dev will be changed to RPM_SUSPENDED (instead
|
|
|
|
* of the @status value) and the suppliers will be deacticated on exit. The
|
|
|
|
* error returned by the failing supplier activation will be returned in that
|
|
|
|
* case.
|
2009-08-19 05:38:32 +08:00
|
|
|
*/
|
|
|
|
int __pm_runtime_set_status(struct device *dev, unsigned int status)
|
|
|
|
{
|
|
|
|
struct device *parent = dev->parent;
|
|
|
|
bool notify_parent = false;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
if (status != RPM_ACTIVE && status != RPM_SUSPENDED)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2019-02-12 20:04:12 +08:00
|
|
|
spin_lock_irq(&dev->power.lock);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
2019-02-12 20:04:12 +08:00
|
|
|
/*
|
|
|
|
* Prevent PM-runtime from being enabled for the device or return an
|
|
|
|
* error if it is enabled already and working.
|
|
|
|
*/
|
|
|
|
if (dev->power.runtime_error || dev->power.disable_depth)
|
|
|
|
dev->power.disable_depth++;
|
|
|
|
else
|
2009-08-19 05:38:32 +08:00
|
|
|
error = -EAGAIN;
|
2019-02-12 20:04:12 +08:00
|
|
|
|
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2019-02-08 02:38:56 +08:00
|
|
|
/*
|
|
|
|
* If the new status is RPM_ACTIVE, the suppliers can be activated
|
|
|
|
* upfront regardless of the current status, because next time
|
|
|
|
* rpm_put_suppliers() runs, the rpm_active refcounts of the links
|
|
|
|
* involved will be dropped down to one anyway.
|
|
|
|
*/
|
|
|
|
if (status == RPM_ACTIVE) {
|
|
|
|
int idx = device_links_read_lock();
|
|
|
|
|
|
|
|
error = rpm_get_suppliers(dev);
|
|
|
|
if (error)
|
|
|
|
status = RPM_SUSPENDED;
|
|
|
|
|
|
|
|
device_links_read_unlock(idx);
|
2009-08-19 05:38:32 +08:00
|
|
|
}
|
|
|
|
|
2019-02-08 02:38:56 +08:00
|
|
|
spin_lock_irq(&dev->power.lock);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
2017-11-17 05:51:22 +08:00
|
|
|
if (dev->power.runtime_status == status || !parent)
|
2009-08-19 05:38:32 +08:00
|
|
|
goto out_set;
|
|
|
|
|
|
|
|
if (status == RPM_SUSPENDED) {
|
2017-11-17 05:51:22 +08:00
|
|
|
atomic_add_unless(&parent->power.child_count, -1, 0);
|
|
|
|
notify_parent = !parent->power.ignore_children;
|
|
|
|
} else {
|
2009-12-04 03:21:21 +08:00
|
|
|
spin_lock_nested(&parent->power.lock, SINGLE_DEPTH_NESTING);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* It is invalid to put an active child under a parent that is
|
2011-07-06 16:52:13 +08:00
|
|
|
* not active, has runtime PM enabled and the
|
2009-08-19 05:38:32 +08:00
|
|
|
* 'power.ignore_children' flag unset.
|
|
|
|
*/
|
|
|
|
if (!parent->power.disable_depth
|
|
|
|
&& !parent->power.ignore_children
|
2016-06-20 17:14:26 +08:00
|
|
|
&& parent->power.runtime_status != RPM_ACTIVE) {
|
|
|
|
dev_err(dev, "runtime PM trying to activate child device %s but parent (%s) is not active\n",
|
|
|
|
dev_name(dev),
|
|
|
|
dev_name(parent));
|
2009-08-19 05:38:32 +08:00
|
|
|
error = -EBUSY;
|
2016-06-20 17:14:26 +08:00
|
|
|
} else if (dev->power.runtime_status == RPM_SUSPENDED) {
|
2009-12-04 04:04:41 +08:00
|
|
|
atomic_inc(&parent->power.child_count);
|
2016-06-20 17:14:26 +08:00
|
|
|
}
|
2009-08-19 05:38:32 +08:00
|
|
|
|
2009-11-25 08:06:37 +08:00
|
|
|
spin_unlock(&parent->power.lock);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
2019-02-08 02:38:56 +08:00
|
|
|
if (error) {
|
|
|
|
status = RPM_SUSPENDED;
|
2009-08-19 05:38:32 +08:00
|
|
|
goto out;
|
2019-02-08 02:38:56 +08:00
|
|
|
}
|
2009-08-19 05:38:32 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
out_set:
|
2010-07-19 08:01:06 +08:00
|
|
|
__update_runtime_status(dev, status);
|
2019-02-08 02:38:56 +08:00
|
|
|
if (!error)
|
|
|
|
dev->power.runtime_error = 0;
|
|
|
|
|
2009-08-19 05:38:32 +08:00
|
|
|
out:
|
2019-02-08 02:38:56 +08:00
|
|
|
spin_unlock_irq(&dev->power.lock);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
|
|
|
if (notify_parent)
|
|
|
|
pm_request_idle(parent);
|
|
|
|
|
2019-02-08 02:38:56 +08:00
|
|
|
if (status == RPM_SUSPENDED) {
|
|
|
|
int idx = device_links_read_lock();
|
|
|
|
|
|
|
|
rpm_put_suppliers(dev);
|
|
|
|
|
|
|
|
device_links_read_unlock(idx);
|
|
|
|
}
|
|
|
|
|
2019-02-12 20:04:12 +08:00
|
|
|
pm_runtime_enable(dev);
|
|
|
|
|
2009-08-19 05:38:32 +08:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(__pm_runtime_set_status);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __pm_runtime_barrier - Cancel pending requests and wait for completions.
|
|
|
|
* @dev: Device to handle.
|
|
|
|
*
|
|
|
|
* Flush all pending requests for the device from pm_wq and wait for all
|
2011-07-06 16:52:13 +08:00
|
|
|
* runtime PM operations involving the device in progress to complete.
|
2009-08-19 05:38:32 +08:00
|
|
|
*
|
|
|
|
* Should be called under dev->power.lock with interrupts disabled.
|
|
|
|
*/
|
|
|
|
static void __pm_runtime_barrier(struct device *dev)
|
|
|
|
{
|
|
|
|
pm_runtime_deactivate_timer(dev);
|
|
|
|
|
|
|
|
if (dev->power.request_pending) {
|
|
|
|
dev->power.request = RPM_REQ_NONE;
|
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
|
|
|
|
cancel_work_sync(&dev->power.work);
|
|
|
|
|
|
|
|
spin_lock_irq(&dev->power.lock);
|
|
|
|
dev->power.request_pending = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dev->power.runtime_status == RPM_SUSPENDING
|
|
|
|
|| dev->power.runtime_status == RPM_RESUMING
|
|
|
|
|| dev->power.idle_notification) {
|
|
|
|
DEFINE_WAIT(wait);
|
|
|
|
|
|
|
|
/* Suspend, wake-up or idle notification in progress. */
|
|
|
|
for (;;) {
|
|
|
|
prepare_to_wait(&dev->power.wait_queue, &wait,
|
|
|
|
TASK_UNINTERRUPTIBLE);
|
|
|
|
if (dev->power.runtime_status != RPM_SUSPENDING
|
|
|
|
&& dev->power.runtime_status != RPM_RESUMING
|
|
|
|
&& !dev->power.idle_notification)
|
|
|
|
break;
|
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
|
|
|
|
schedule();
|
|
|
|
|
|
|
|
spin_lock_irq(&dev->power.lock);
|
|
|
|
}
|
|
|
|
finish_wait(&dev->power.wait_queue, &wait);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_runtime_barrier - Flush pending requests and wait for completions.
|
|
|
|
* @dev: Device to handle.
|
|
|
|
*
|
|
|
|
* Prevent the device from being suspended by incrementing its usage counter and
|
|
|
|
* if there's a pending resume request for the device, wake the device up.
|
|
|
|
* Next, make sure that all pending requests for the device have been flushed
|
2011-07-06 16:52:13 +08:00
|
|
|
* from pm_wq and wait for all runtime PM operations involving the device in
|
2009-08-19 05:38:32 +08:00
|
|
|
* progress to complete.
|
|
|
|
*
|
|
|
|
* Return value:
|
|
|
|
* 1, if there was a resume request pending and the device had to be woken up,
|
|
|
|
* 0, otherwise
|
|
|
|
*/
|
|
|
|
int pm_runtime_barrier(struct device *dev)
|
|
|
|
{
|
|
|
|
int retval = 0;
|
|
|
|
|
|
|
|
pm_runtime_get_noresume(dev);
|
|
|
|
spin_lock_irq(&dev->power.lock);
|
|
|
|
|
|
|
|
if (dev->power.request_pending
|
|
|
|
&& dev->power.request == RPM_REQ_RESUME) {
|
2010-09-26 05:35:07 +08:00
|
|
|
rpm_resume(dev, 0);
|
2009-08-19 05:38:32 +08:00
|
|
|
retval = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
__pm_runtime_barrier(dev);
|
|
|
|
|
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
pm_runtime_put_noidle(dev);
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(pm_runtime_barrier);
|
|
|
|
|
|
|
|
/**
|
2011-07-06 16:52:13 +08:00
|
|
|
* __pm_runtime_disable - Disable runtime PM of a device.
|
2009-08-19 05:38:32 +08:00
|
|
|
* @dev: Device to handle.
|
|
|
|
* @check_resume: If set, check if there's a resume request for the device.
|
|
|
|
*
|
2014-03-11 18:23:40 +08:00
|
|
|
* Increment power.disable_depth for the device and if it was zero previously,
|
2011-07-06 16:52:13 +08:00
|
|
|
* cancel all pending runtime PM requests for the device and wait for all
|
2009-08-19 05:38:32 +08:00
|
|
|
* operations in progress to complete. The device can be either active or
|
2011-07-06 16:52:13 +08:00
|
|
|
* suspended after its runtime PM has been disabled.
|
2009-08-19 05:38:32 +08:00
|
|
|
*
|
|
|
|
* If @check_resume is set and there's a resume request pending when
|
|
|
|
* __pm_runtime_disable() is called and power.disable_depth is zero, the
|
2011-07-06 16:52:13 +08:00
|
|
|
* function will wake up the device before disabling its runtime PM.
|
2009-08-19 05:38:32 +08:00
|
|
|
*/
|
|
|
|
void __pm_runtime_disable(struct device *dev, bool check_resume)
|
|
|
|
{
|
|
|
|
spin_lock_irq(&dev->power.lock);
|
|
|
|
|
|
|
|
if (dev->power.disable_depth > 0) {
|
|
|
|
dev->power.disable_depth++;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wake up the device if there's a resume request pending, because that
|
2011-07-06 16:52:13 +08:00
|
|
|
* means there probably is some I/O to process and disabling runtime PM
|
2009-08-19 05:38:32 +08:00
|
|
|
* shouldn't prevent the device from processing the I/O.
|
|
|
|
*/
|
|
|
|
if (check_resume && dev->power.request_pending
|
|
|
|
&& dev->power.request == RPM_REQ_RESUME) {
|
|
|
|
/*
|
|
|
|
* Prevent suspends and idle notifications from being carried
|
|
|
|
* out after we have woken up the device.
|
|
|
|
*/
|
|
|
|
pm_runtime_get_noresume(dev);
|
|
|
|
|
2010-09-26 05:35:07 +08:00
|
|
|
rpm_resume(dev, 0);
|
2009-08-19 05:38:32 +08:00
|
|
|
|
|
|
|
pm_runtime_put_noidle(dev);
|
|
|
|
}
|
|
|
|
|
2019-02-05 00:25:53 +08:00
|
|
|
/* Update time accounting before disabling PM-runtime. */
|
|
|
|
update_pm_runtime_accounting(dev);
|
|
|
|
|
PM: runtime: Capture device status before disabling runtime PM
In some cases (for example, during system-wide suspend and resume of
devices) it is useful to know whether or not runtime PM has ever been
enabled for a given device and, if so, what the runtime PM status of
it had been right before runtime PM was disabled for it last time.
For this reason, introduce a new struct dev_pm_info field called
last_status that will be used for capturing the runtime PM status of
the device when its power.disable_depth counter changes from 0 to 1.
The new field will be set to RPM_INVALID to start with and whenever
power.disable_depth changes from 1 to 0, so it will be valid only
when runtime PM of the device is currently disabled, but it has been
enabled at least once.
Immediately use power.last_status in rpm_resume() to make it handle
the case when PM runtime is disabled for the device, but its runtime
PM status is RPM_ACTIVE more consistently. Namely, make it return 1
if power.last_status is also equal to RPM_ACTIVE in that case (the
idea being that if the status was RPM_ACTIVE last time when
power.disable_depth was changing from 0 to 1 and it is still
RPM_ACTIVE, it can be assumed to reflect what happened to the device
last time when it was using runtime PM) and -EACCES otherwise.
Update the documentation to provide a description of last_status and
change the description of pm_runtime_resume() in it to reflect the
new behavior of rpm_active().
While at it, rearrange the code in pm_runtime_enable() to be more
straightforward and replace the WARN() macro in it with a pr_warn()
invocation which is less disruptive.
Link: https://lore.kernel.org/linux-pm/20211026222626.39222-1-ulf.hansson@linaro.org/t/#u
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2021-12-08 02:54:32 +08:00
|
|
|
if (!dev->power.disable_depth++) {
|
2009-08-19 05:38:32 +08:00
|
|
|
__pm_runtime_barrier(dev);
|
PM: runtime: Capture device status before disabling runtime PM
In some cases (for example, during system-wide suspend and resume of
devices) it is useful to know whether or not runtime PM has ever been
enabled for a given device and, if so, what the runtime PM status of
it had been right before runtime PM was disabled for it last time.
For this reason, introduce a new struct dev_pm_info field called
last_status that will be used for capturing the runtime PM status of
the device when its power.disable_depth counter changes from 0 to 1.
The new field will be set to RPM_INVALID to start with and whenever
power.disable_depth changes from 1 to 0, so it will be valid only
when runtime PM of the device is currently disabled, but it has been
enabled at least once.
Immediately use power.last_status in rpm_resume() to make it handle
the case when PM runtime is disabled for the device, but its runtime
PM status is RPM_ACTIVE more consistently. Namely, make it return 1
if power.last_status is also equal to RPM_ACTIVE in that case (the
idea being that if the status was RPM_ACTIVE last time when
power.disable_depth was changing from 0 to 1 and it is still
RPM_ACTIVE, it can be assumed to reflect what happened to the device
last time when it was using runtime PM) and -EACCES otherwise.
Update the documentation to provide a description of last_status and
change the description of pm_runtime_resume() in it to reflect the
new behavior of rpm_active().
While at it, rearrange the code in pm_runtime_enable() to be more
straightforward and replace the WARN() macro in it with a pr_warn()
invocation which is less disruptive.
Link: https://lore.kernel.org/linux-pm/20211026222626.39222-1-ulf.hansson@linaro.org/t/#u
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2021-12-08 02:54:32 +08:00
|
|
|
dev->power.last_status = dev->power.runtime_status;
|
|
|
|
}
|
2009-08-19 05:38:32 +08:00
|
|
|
|
|
|
|
out:
|
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(__pm_runtime_disable);
|
|
|
|
|
|
|
|
/**
|
2011-07-06 16:52:13 +08:00
|
|
|
* pm_runtime_enable - Enable runtime PM of a device.
|
2009-08-19 05:38:32 +08:00
|
|
|
* @dev: Device to handle.
|
|
|
|
*/
|
|
|
|
void pm_runtime_enable(struct device *dev)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&dev->power.lock, flags);
|
|
|
|
|
PM: runtime: Capture device status before disabling runtime PM
In some cases (for example, during system-wide suspend and resume of
devices) it is useful to know whether or not runtime PM has ever been
enabled for a given device and, if so, what the runtime PM status of
it had been right before runtime PM was disabled for it last time.
For this reason, introduce a new struct dev_pm_info field called
last_status that will be used for capturing the runtime PM status of
the device when its power.disable_depth counter changes from 0 to 1.
The new field will be set to RPM_INVALID to start with and whenever
power.disable_depth changes from 1 to 0, so it will be valid only
when runtime PM of the device is currently disabled, but it has been
enabled at least once.
Immediately use power.last_status in rpm_resume() to make it handle
the case when PM runtime is disabled for the device, but its runtime
PM status is RPM_ACTIVE more consistently. Namely, make it return 1
if power.last_status is also equal to RPM_ACTIVE in that case (the
idea being that if the status was RPM_ACTIVE last time when
power.disable_depth was changing from 0 to 1 and it is still
RPM_ACTIVE, it can be assumed to reflect what happened to the device
last time when it was using runtime PM) and -EACCES otherwise.
Update the documentation to provide a description of last_status and
change the description of pm_runtime_resume() in it to reflect the
new behavior of rpm_active().
While at it, rearrange the code in pm_runtime_enable() to be more
straightforward and replace the WARN() macro in it with a pr_warn()
invocation which is less disruptive.
Link: https://lore.kernel.org/linux-pm/20211026222626.39222-1-ulf.hansson@linaro.org/t/#u
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2021-12-08 02:54:32 +08:00
|
|
|
if (!dev->power.disable_depth) {
|
2009-08-19 05:38:32 +08:00
|
|
|
dev_warn(dev, "Unbalanced %s!\n", __func__);
|
PM: runtime: Capture device status before disabling runtime PM
In some cases (for example, during system-wide suspend and resume of
devices) it is useful to know whether or not runtime PM has ever been
enabled for a given device and, if so, what the runtime PM status of
it had been right before runtime PM was disabled for it last time.
For this reason, introduce a new struct dev_pm_info field called
last_status that will be used for capturing the runtime PM status of
the device when its power.disable_depth counter changes from 0 to 1.
The new field will be set to RPM_INVALID to start with and whenever
power.disable_depth changes from 1 to 0, so it will be valid only
when runtime PM of the device is currently disabled, but it has been
enabled at least once.
Immediately use power.last_status in rpm_resume() to make it handle
the case when PM runtime is disabled for the device, but its runtime
PM status is RPM_ACTIVE more consistently. Namely, make it return 1
if power.last_status is also equal to RPM_ACTIVE in that case (the
idea being that if the status was RPM_ACTIVE last time when
power.disable_depth was changing from 0 to 1 and it is still
RPM_ACTIVE, it can be assumed to reflect what happened to the device
last time when it was using runtime PM) and -EACCES otherwise.
Update the documentation to provide a description of last_status and
change the description of pm_runtime_resume() in it to reflect the
new behavior of rpm_active().
While at it, rearrange the code in pm_runtime_enable() to be more
straightforward and replace the WARN() macro in it with a pr_warn()
invocation which is less disruptive.
Link: https://lore.kernel.org/linux-pm/20211026222626.39222-1-ulf.hansson@linaro.org/t/#u
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2021-12-08 02:54:32 +08:00
|
|
|
goto out;
|
2019-01-23 15:50:13 +08:00
|
|
|
}
|
2009-08-19 05:38:32 +08:00
|
|
|
|
PM: runtime: Capture device status before disabling runtime PM
In some cases (for example, during system-wide suspend and resume of
devices) it is useful to know whether or not runtime PM has ever been
enabled for a given device and, if so, what the runtime PM status of
it had been right before runtime PM was disabled for it last time.
For this reason, introduce a new struct dev_pm_info field called
last_status that will be used for capturing the runtime PM status of
the device when its power.disable_depth counter changes from 0 to 1.
The new field will be set to RPM_INVALID to start with and whenever
power.disable_depth changes from 1 to 0, so it will be valid only
when runtime PM of the device is currently disabled, but it has been
enabled at least once.
Immediately use power.last_status in rpm_resume() to make it handle
the case when PM runtime is disabled for the device, but its runtime
PM status is RPM_ACTIVE more consistently. Namely, make it return 1
if power.last_status is also equal to RPM_ACTIVE in that case (the
idea being that if the status was RPM_ACTIVE last time when
power.disable_depth was changing from 0 to 1 and it is still
RPM_ACTIVE, it can be assumed to reflect what happened to the device
last time when it was using runtime PM) and -EACCES otherwise.
Update the documentation to provide a description of last_status and
change the description of pm_runtime_resume() in it to reflect the
new behavior of rpm_active().
While at it, rearrange the code in pm_runtime_enable() to be more
straightforward and replace the WARN() macro in it with a pr_warn()
invocation which is less disruptive.
Link: https://lore.kernel.org/linux-pm/20211026222626.39222-1-ulf.hansson@linaro.org/t/#u
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2021-12-08 02:54:32 +08:00
|
|
|
if (--dev->power.disable_depth > 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
dev->power.last_status = RPM_INVALID;
|
|
|
|
dev->power.accounting_timestamp = ktime_get_mono_fast_ns();
|
|
|
|
|
|
|
|
if (dev->power.runtime_status == RPM_SUSPENDED &&
|
|
|
|
!dev->power.ignore_children &&
|
|
|
|
atomic_read(&dev->power.child_count) > 0)
|
|
|
|
dev_warn(dev, "Enabling runtime PM for inactive device with active children\n");
|
2017-11-17 05:51:22 +08:00
|
|
|
|
PM: runtime: Capture device status before disabling runtime PM
In some cases (for example, during system-wide suspend and resume of
devices) it is useful to know whether or not runtime PM has ever been
enabled for a given device and, if so, what the runtime PM status of
it had been right before runtime PM was disabled for it last time.
For this reason, introduce a new struct dev_pm_info field called
last_status that will be used for capturing the runtime PM status of
the device when its power.disable_depth counter changes from 0 to 1.
The new field will be set to RPM_INVALID to start with and whenever
power.disable_depth changes from 1 to 0, so it will be valid only
when runtime PM of the device is currently disabled, but it has been
enabled at least once.
Immediately use power.last_status in rpm_resume() to make it handle
the case when PM runtime is disabled for the device, but its runtime
PM status is RPM_ACTIVE more consistently. Namely, make it return 1
if power.last_status is also equal to RPM_ACTIVE in that case (the
idea being that if the status was RPM_ACTIVE last time when
power.disable_depth was changing from 0 to 1 and it is still
RPM_ACTIVE, it can be assumed to reflect what happened to the device
last time when it was using runtime PM) and -EACCES otherwise.
Update the documentation to provide a description of last_status and
change the description of pm_runtime_resume() in it to reflect the
new behavior of rpm_active().
While at it, rearrange the code in pm_runtime_enable() to be more
straightforward and replace the WARN() macro in it with a pr_warn()
invocation which is less disruptive.
Link: https://lore.kernel.org/linux-pm/20211026222626.39222-1-ulf.hansson@linaro.org/t/#u
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2021-12-08 02:54:32 +08:00
|
|
|
out:
|
2009-08-19 05:38:32 +08:00
|
|
|
spin_unlock_irqrestore(&dev->power.lock, flags);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(pm_runtime_enable);
|
|
|
|
|
2021-08-01 03:50:32 +08:00
|
|
|
static void pm_runtime_disable_action(void *data)
|
|
|
|
{
|
2022-02-24 00:34:48 +08:00
|
|
|
pm_runtime_dont_use_autosuspend(data);
|
2021-08-01 03:50:32 +08:00
|
|
|
pm_runtime_disable(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* devm_pm_runtime_enable - devres-enabled version of pm_runtime_enable.
|
2022-02-24 00:34:48 +08:00
|
|
|
*
|
|
|
|
* NOTE: this will also handle calling pm_runtime_dont_use_autosuspend() for
|
|
|
|
* you at driver exit time if needed.
|
|
|
|
*
|
2021-08-01 03:50:32 +08:00
|
|
|
* @dev: Device to handle.
|
|
|
|
*/
|
|
|
|
int devm_pm_runtime_enable(struct device *dev)
|
|
|
|
{
|
|
|
|
pm_runtime_enable(dev);
|
|
|
|
|
|
|
|
return devm_add_action_or_reset(dev, pm_runtime_disable_action, dev);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(devm_pm_runtime_enable);
|
|
|
|
|
2010-01-24 05:02:51 +08:00
|
|
|
/**
|
2011-07-06 16:52:13 +08:00
|
|
|
* pm_runtime_forbid - Block runtime PM of a device.
|
2010-01-24 05:02:51 +08:00
|
|
|
* @dev: Device to handle.
|
|
|
|
*
|
|
|
|
* Increase the device's usage count and clear its power.runtime_auto flag,
|
|
|
|
* so that it cannot be suspended at run time until pm_runtime_allow() is called
|
|
|
|
* for it.
|
|
|
|
*/
|
|
|
|
void pm_runtime_forbid(struct device *dev)
|
|
|
|
{
|
|
|
|
spin_lock_irq(&dev->power.lock);
|
|
|
|
if (!dev->power.runtime_auto)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
dev->power.runtime_auto = false;
|
|
|
|
atomic_inc(&dev->power.usage_count);
|
2010-09-26 05:35:07 +08:00
|
|
|
rpm_resume(dev, 0);
|
2010-01-24 05:02:51 +08:00
|
|
|
|
|
|
|
out:
|
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(pm_runtime_forbid);
|
|
|
|
|
|
|
|
/**
|
2011-07-06 16:52:13 +08:00
|
|
|
* pm_runtime_allow - Unblock runtime PM of a device.
|
2010-01-24 05:02:51 +08:00
|
|
|
* @dev: Device to handle.
|
|
|
|
*
|
|
|
|
* Decrease the device's usage count and set its power.runtime_auto flag.
|
|
|
|
*/
|
|
|
|
void pm_runtime_allow(struct device *dev)
|
|
|
|
{
|
|
|
|
spin_lock_irq(&dev->power.lock);
|
|
|
|
if (dev->power.runtime_auto)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
dev->power.runtime_auto = true;
|
|
|
|
if (atomic_dec_and_test(&dev->power.usage_count))
|
2016-06-29 08:53:48 +08:00
|
|
|
rpm_idle(dev, RPM_AUTO | RPM_ASYNC);
|
2020-01-05 00:27:57 +08:00
|
|
|
else
|
|
|
|
trace_rpm_usage_rcuidle(dev, RPM_AUTO | RPM_ASYNC);
|
2010-01-24 05:02:51 +08:00
|
|
|
|
|
|
|
out:
|
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(pm_runtime_allow);
|
|
|
|
|
2010-09-26 05:35:15 +08:00
|
|
|
/**
|
2011-07-06 16:52:13 +08:00
|
|
|
* pm_runtime_no_callbacks - Ignore runtime PM callbacks for a device.
|
2010-09-26 05:35:15 +08:00
|
|
|
* @dev: Device to handle.
|
|
|
|
*
|
|
|
|
* Set the power.no_callbacks flag, which tells the PM core that this
|
2011-07-06 16:52:13 +08:00
|
|
|
* device is power-managed through its parent and has no runtime PM
|
|
|
|
* callbacks of its own. The runtime sysfs attributes will be removed.
|
2010-09-26 05:35:15 +08:00
|
|
|
*/
|
|
|
|
void pm_runtime_no_callbacks(struct device *dev)
|
|
|
|
{
|
|
|
|
spin_lock_irq(&dev->power.lock);
|
|
|
|
dev->power.no_callbacks = 1;
|
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
if (device_is_registered(dev))
|
|
|
|
rpm_sysfs_remove(dev);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(pm_runtime_no_callbacks);
|
|
|
|
|
2010-12-01 07:14:42 +08:00
|
|
|
/**
|
|
|
|
* pm_runtime_irq_safe - Leave interrupts disabled during callbacks.
|
|
|
|
* @dev: Device to handle
|
|
|
|
*
|
|
|
|
* Set the power.irq_safe flag, which tells the PM core that the
|
|
|
|
* ->runtime_suspend() and ->runtime_resume() callbacks for this device should
|
|
|
|
* always be invoked with the spinlock held and interrupts disabled. It also
|
|
|
|
* causes the parent's usage counter to be permanently incremented, preventing
|
|
|
|
* the parent from runtime suspending -- otherwise an irq-safe child might have
|
|
|
|
* to wait for a non-irq-safe parent.
|
|
|
|
*/
|
|
|
|
void pm_runtime_irq_safe(struct device *dev)
|
|
|
|
{
|
|
|
|
if (dev->parent)
|
|
|
|
pm_runtime_get_sync(dev->parent);
|
|
|
|
spin_lock_irq(&dev->power.lock);
|
|
|
|
dev->power.irq_safe = 1;
|
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(pm_runtime_irq_safe);
|
|
|
|
|
2010-09-26 05:35:21 +08:00
|
|
|
/**
|
|
|
|
* update_autosuspend - Handle a change to a device's autosuspend settings.
|
|
|
|
* @dev: Device to handle.
|
|
|
|
* @old_delay: The former autosuspend_delay value.
|
|
|
|
* @old_use: The former use_autosuspend value.
|
|
|
|
*
|
|
|
|
* Prevent runtime suspend if the new delay is negative and use_autosuspend is
|
|
|
|
* set; otherwise allow it. Send an idle notification if suspends are allowed.
|
|
|
|
*
|
|
|
|
* This function must be called under dev->power.lock with interrupts disabled.
|
|
|
|
*/
|
|
|
|
static void update_autosuspend(struct device *dev, int old_delay, int old_use)
|
|
|
|
{
|
|
|
|
int delay = dev->power.autosuspend_delay;
|
|
|
|
|
|
|
|
/* Should runtime suspend be prevented now? */
|
|
|
|
if (dev->power.use_autosuspend && delay < 0) {
|
|
|
|
|
|
|
|
/* If it used to be allowed then prevent it. */
|
|
|
|
if (!old_use || old_delay >= 0) {
|
|
|
|
atomic_inc(&dev->power.usage_count);
|
|
|
|
rpm_resume(dev, 0);
|
2020-01-05 00:27:57 +08:00
|
|
|
} else {
|
|
|
|
trace_rpm_usage_rcuidle(dev, 0);
|
2010-09-26 05:35:21 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Runtime suspend should be allowed now. */
|
|
|
|
else {
|
|
|
|
|
|
|
|
/* If it used to be prevented then allow it. */
|
|
|
|
if (old_use && old_delay < 0)
|
|
|
|
atomic_dec(&dev->power.usage_count);
|
|
|
|
|
|
|
|
/* Maybe we can autosuspend now. */
|
|
|
|
rpm_idle(dev, RPM_AUTO);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_runtime_set_autosuspend_delay - Set a device's autosuspend_delay value.
|
|
|
|
* @dev: Device to handle.
|
|
|
|
* @delay: Value of the new delay in milliseconds.
|
|
|
|
*
|
|
|
|
* Set the device's power.autosuspend_delay value. If it changes to negative
|
2011-07-06 16:52:13 +08:00
|
|
|
* and the power.use_autosuspend flag is set, prevent runtime suspends. If it
|
|
|
|
* changes the other way, allow runtime suspends.
|
2010-09-26 05:35:21 +08:00
|
|
|
*/
|
|
|
|
void pm_runtime_set_autosuspend_delay(struct device *dev, int delay)
|
|
|
|
{
|
|
|
|
int old_delay, old_use;
|
|
|
|
|
|
|
|
spin_lock_irq(&dev->power.lock);
|
|
|
|
old_delay = dev->power.autosuspend_delay;
|
|
|
|
old_use = dev->power.use_autosuspend;
|
|
|
|
dev->power.autosuspend_delay = delay;
|
|
|
|
update_autosuspend(dev, old_delay, old_use);
|
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(pm_runtime_set_autosuspend_delay);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* __pm_runtime_use_autosuspend - Set a device's use_autosuspend flag.
|
|
|
|
* @dev: Device to handle.
|
|
|
|
* @use: New value for use_autosuspend.
|
|
|
|
*
|
2011-07-06 16:52:13 +08:00
|
|
|
* Set the device's power.use_autosuspend flag, and allow or prevent runtime
|
2010-09-26 05:35:21 +08:00
|
|
|
* suspends as needed.
|
|
|
|
*/
|
|
|
|
void __pm_runtime_use_autosuspend(struct device *dev, bool use)
|
|
|
|
{
|
|
|
|
int old_delay, old_use;
|
|
|
|
|
|
|
|
spin_lock_irq(&dev->power.lock);
|
|
|
|
old_delay = dev->power.autosuspend_delay;
|
|
|
|
old_use = dev->power.use_autosuspend;
|
|
|
|
dev->power.use_autosuspend = use;
|
|
|
|
update_autosuspend(dev, old_delay, old_use);
|
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(__pm_runtime_use_autosuspend);
|
|
|
|
|
2009-08-19 05:38:32 +08:00
|
|
|
/**
|
2011-07-06 16:52:13 +08:00
|
|
|
* pm_runtime_init - Initialize runtime PM fields in given device object.
|
2009-08-19 05:38:32 +08:00
|
|
|
* @dev: Device object to initialize.
|
|
|
|
*/
|
|
|
|
void pm_runtime_init(struct device *dev)
|
|
|
|
{
|
|
|
|
dev->power.runtime_status = RPM_SUSPENDED;
|
PM: runtime: Capture device status before disabling runtime PM
In some cases (for example, during system-wide suspend and resume of
devices) it is useful to know whether or not runtime PM has ever been
enabled for a given device and, if so, what the runtime PM status of
it had been right before runtime PM was disabled for it last time.
For this reason, introduce a new struct dev_pm_info field called
last_status that will be used for capturing the runtime PM status of
the device when its power.disable_depth counter changes from 0 to 1.
The new field will be set to RPM_INVALID to start with and whenever
power.disable_depth changes from 1 to 0, so it will be valid only
when runtime PM of the device is currently disabled, but it has been
enabled at least once.
Immediately use power.last_status in rpm_resume() to make it handle
the case when PM runtime is disabled for the device, but its runtime
PM status is RPM_ACTIVE more consistently. Namely, make it return 1
if power.last_status is also equal to RPM_ACTIVE in that case (the
idea being that if the status was RPM_ACTIVE last time when
power.disable_depth was changing from 0 to 1 and it is still
RPM_ACTIVE, it can be assumed to reflect what happened to the device
last time when it was using runtime PM) and -EACCES otherwise.
Update the documentation to provide a description of last_status and
change the description of pm_runtime_resume() in it to reflect the
new behavior of rpm_active().
While at it, rearrange the code in pm_runtime_enable() to be more
straightforward and replace the WARN() macro in it with a pr_warn()
invocation which is less disruptive.
Link: https://lore.kernel.org/linux-pm/20211026222626.39222-1-ulf.hansson@linaro.org/t/#u
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2021-12-08 02:54:32 +08:00
|
|
|
dev->power.last_status = RPM_INVALID;
|
2009-08-19 05:38:32 +08:00
|
|
|
dev->power.idle_notification = false;
|
|
|
|
|
|
|
|
dev->power.disable_depth = 1;
|
|
|
|
atomic_set(&dev->power.usage_count, 0);
|
|
|
|
|
|
|
|
dev->power.runtime_error = 0;
|
|
|
|
|
|
|
|
atomic_set(&dev->power.child_count, 0);
|
|
|
|
pm_suspend_ignore_children(dev, false);
|
2010-01-24 05:02:51 +08:00
|
|
|
dev->power.runtime_auto = true;
|
2009-08-19 05:38:32 +08:00
|
|
|
|
|
|
|
dev->power.request_pending = false;
|
|
|
|
dev->power.request = RPM_REQ_NONE;
|
|
|
|
dev->power.deferred_resume = false;
|
2021-05-05 19:09:15 +08:00
|
|
|
dev->power.needs_force_resume = 0;
|
2009-08-19 05:38:32 +08:00
|
|
|
INIT_WORK(&dev->power.work, pm_runtime_work);
|
|
|
|
|
|
|
|
dev->power.timer_expires = 0;
|
2018-12-14 22:22:25 +08:00
|
|
|
hrtimer_init(&dev->power.suspend_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
|
|
|
|
dev->power.suspend_timer.function = pm_suspend_timer_fn;
|
2009-08-19 05:38:32 +08:00
|
|
|
|
|
|
|
init_waitqueue_head(&dev->power.wait_queue);
|
|
|
|
}
|
|
|
|
|
PM / runtime: Re-init runtime PM states at probe error and driver unbind
There are two common expectations among several subsystems/drivers that
deploys runtime PM support, but which isn't met by the driver core.
Expectation 1)
At ->probe() the subsystem/driver expects the runtime PM status of the
device to be RPM_SUSPENDED, which is the initial status being assigned at
device registration.
This expectation is especially common among some of those subsystems/
drivers that manages devices with an attached PM domain, as those requires
the ->runtime_resume() callback at the PM domain level to be invoked
during ->probe().
Moreover these subsystems/drivers entirely relies on runtime PM resources
being managed at the PM domain level, thus don't implement their own set
of runtime PM callbacks.
These are two scenarios that suffers from this unmet expectation.
i) A failed ->probe() sequence requests probe deferral:
->probe()
...
pm_runtime_enable()
pm_runtime_get_sync()
...
err:
pm_runtime_put()
pm_runtime_disable()
...
As there are no guarantees that such sequence turns the runtime PM status
of the device into RPM_SUSPENDED, the re-trying ->probe() may start with
the status in RPM_ACTIVE.
In such case the runtime PM core won't invoke the ->runtime_resume()
callback because of a pm_runtime_get_sync(), as it considers the device to
be already runtime resumed.
ii) A driver re-bind sequence:
At driver unbind, the subsystem/driver's >remove() callback invokes a
sequence of runtime PM APIs, to undo actions during ->probe() and to put
the device into low power state.
->remove()
...
pm_runtime_put()
pm_runtime_disable()
...
Similar as in the failing ->probe() case, this sequence don't guarantee
the runtime PM status of the device to turn into RPM_SUSPENDED.
Trying to re-bind the driver thus causes the same issue as when re-trying
->probe(), in the probe deferral scenario.
Expectation 2)
Drivers that invokes the pm_runtime_irq_safe() API during ->probe(),
triggers the runtime PM core to increase the usage count for the device's
parent and permanently make it runtime resumed.
The usage count is only dropped at device removal, which also allows it to
be runtime suspended again.
A re-trying ->probe() repeats the call to pm_runtime_irq_safe() and thus
once more triggers the usage count of the device's parent to be increased.
This leads to not only an imbalance issue of the usage count of the
device's parent, but also to keep it runtime resumed permanently even if
->probe() fails.
To address these issues, let's change the policy of the driver core to
meet these expectations. More precisely, at ->probe() failures and driver
unbind, restore the initial states of runtime PM.
Although to still allow subsystem's to control PM for devices that doesn't
->probe() successfully, don't restore the initial states unless runtime PM
is disabled.
Signed-off-by: Ulf Hansson <ulf.hansson@linaro.org>
Reviewed-by: Kevin Hilman <khilman@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2015-11-18 18:48:39 +08:00
|
|
|
/**
|
|
|
|
* pm_runtime_reinit - Re-initialize runtime PM fields in given device object.
|
|
|
|
* @dev: Device object to re-initialize.
|
|
|
|
*/
|
|
|
|
void pm_runtime_reinit(struct device *dev)
|
|
|
|
{
|
|
|
|
if (!pm_runtime_enabled(dev)) {
|
|
|
|
if (dev->power.runtime_status == RPM_ACTIVE)
|
|
|
|
pm_runtime_set_suspended(dev);
|
|
|
|
if (dev->power.irq_safe) {
|
|
|
|
spin_lock_irq(&dev->power.lock);
|
|
|
|
dev->power.irq_safe = 0;
|
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
if (dev->parent)
|
|
|
|
pm_runtime_put(dev->parent);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-19 05:38:32 +08:00
|
|
|
/**
|
|
|
|
* pm_runtime_remove - Prepare for removing a device from device hierarchy.
|
|
|
|
* @dev: Device object being removed from device hierarchy.
|
|
|
|
*/
|
|
|
|
void pm_runtime_remove(struct device *dev)
|
|
|
|
{
|
|
|
|
__pm_runtime_disable(dev, false);
|
PM / runtime: Re-init runtime PM states at probe error and driver unbind
There are two common expectations among several subsystems/drivers that
deploys runtime PM support, but which isn't met by the driver core.
Expectation 1)
At ->probe() the subsystem/driver expects the runtime PM status of the
device to be RPM_SUSPENDED, which is the initial status being assigned at
device registration.
This expectation is especially common among some of those subsystems/
drivers that manages devices with an attached PM domain, as those requires
the ->runtime_resume() callback at the PM domain level to be invoked
during ->probe().
Moreover these subsystems/drivers entirely relies on runtime PM resources
being managed at the PM domain level, thus don't implement their own set
of runtime PM callbacks.
These are two scenarios that suffers from this unmet expectation.
i) A failed ->probe() sequence requests probe deferral:
->probe()
...
pm_runtime_enable()
pm_runtime_get_sync()
...
err:
pm_runtime_put()
pm_runtime_disable()
...
As there are no guarantees that such sequence turns the runtime PM status
of the device into RPM_SUSPENDED, the re-trying ->probe() may start with
the status in RPM_ACTIVE.
In such case the runtime PM core won't invoke the ->runtime_resume()
callback because of a pm_runtime_get_sync(), as it considers the device to
be already runtime resumed.
ii) A driver re-bind sequence:
At driver unbind, the subsystem/driver's >remove() callback invokes a
sequence of runtime PM APIs, to undo actions during ->probe() and to put
the device into low power state.
->remove()
...
pm_runtime_put()
pm_runtime_disable()
...
Similar as in the failing ->probe() case, this sequence don't guarantee
the runtime PM status of the device to turn into RPM_SUSPENDED.
Trying to re-bind the driver thus causes the same issue as when re-trying
->probe(), in the probe deferral scenario.
Expectation 2)
Drivers that invokes the pm_runtime_irq_safe() API during ->probe(),
triggers the runtime PM core to increase the usage count for the device's
parent and permanently make it runtime resumed.
The usage count is only dropped at device removal, which also allows it to
be runtime suspended again.
A re-trying ->probe() repeats the call to pm_runtime_irq_safe() and thus
once more triggers the usage count of the device's parent to be increased.
This leads to not only an imbalance issue of the usage count of the
device's parent, but also to keep it runtime resumed permanently even if
->probe() fails.
To address these issues, let's change the policy of the driver core to
meet these expectations. More precisely, at ->probe() failures and driver
unbind, restore the initial states of runtime PM.
Although to still allow subsystem's to control PM for devices that doesn't
->probe() successfully, don't restore the initial states unless runtime PM
is disabled.
Signed-off-by: Ulf Hansson <ulf.hansson@linaro.org>
Reviewed-by: Kevin Hilman <khilman@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2015-11-18 18:48:39 +08:00
|
|
|
pm_runtime_reinit(dev);
|
2009-08-19 05:38:32 +08:00
|
|
|
}
|
2014-03-01 18:56:05 +08:00
|
|
|
|
2016-10-31 00:32:31 +08:00
|
|
|
/**
|
2018-06-12 16:24:13 +08:00
|
|
|
* pm_runtime_get_suppliers - Resume and reference-count supplier devices.
|
2016-10-31 00:32:31 +08:00
|
|
|
* @dev: Consumer device.
|
|
|
|
*/
|
2018-06-12 16:24:13 +08:00
|
|
|
void pm_runtime_get_suppliers(struct device *dev)
|
2016-10-31 00:32:31 +08:00
|
|
|
{
|
2018-06-12 16:24:13 +08:00
|
|
|
struct device_link *link;
|
2016-10-31 00:32:31 +08:00
|
|
|
int idx;
|
|
|
|
|
|
|
|
idx = device_links_read_lock();
|
|
|
|
|
2019-07-17 06:12:25 +08:00
|
|
|
list_for_each_entry_rcu(link, &dev->links.suppliers, c_node,
|
|
|
|
device_links_read_lock_held())
|
driver core: Fix possible supplier PM-usage counter imbalance
If a stateless device link to a certain supplier with
DL_FLAG_PM_RUNTIME set in the flags is added and then removed by the
consumer driver's probe callback, the supplier's PM-runtime usage
counter will be nonzero after that which effectively causes the
supplier to remain "always on" going forward.
Namely, device_link_add() called to add the link invokes
device_link_rpm_prepare() which notices that the consumer driver is
probing, so it increments the supplier's PM-runtime usage counter
with the assumption that the link will stay around until
pm_runtime_put_suppliers() is called by driver_probe_device(),
but if the link goes away before that point, the supplier's
PM-runtime usage counter will remain nonzero.
To prevent that from happening, first rework pm_runtime_get_suppliers()
and pm_runtime_put_suppliers() to use the rpm_active refounts of device
links and make the latter only drop rpm_active and the supplier's
PM-runtime usage counter for each link by one, unless rpm_active is
one already for it. Next, modify device_link_add() to bump up the
new link's rpm_active refcount and the suppliers PM-runtime usage
counter by two, to prevent pm_runtime_put_suppliers(), if it is
called subsequently, from suspending the supplier prematurely (in
case its PM-runtime usage counter goes down to 0 in there).
Due to the way rpm_put_suppliers() works, this change does not
affect runtime suspend of the consumer ends of new device links (or,
generally, device links for which DL_FLAG_PM_RUNTIME has just been
set).
Fixes: e2f3cd831a28 ("driver core: Fix handling of runtime PM flags in device_link_add()")
Reported-by: Ulf Hansson <ulf.hansson@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
Tested-by: Ulf Hansson <ulf.hansson@linaro.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2019-02-12 20:08:10 +08:00
|
|
|
if (link->flags & DL_FLAG_PM_RUNTIME) {
|
2019-02-20 00:53:26 +08:00
|
|
|
link->supplier_preactivated = true;
|
2018-06-12 16:24:13 +08:00
|
|
|
pm_runtime_get_sync(link->supplier);
|
2021-03-26 18:56:18 +08:00
|
|
|
refcount_inc(&link->rpm_active);
|
driver core: Fix possible supplier PM-usage counter imbalance
If a stateless device link to a certain supplier with
DL_FLAG_PM_RUNTIME set in the flags is added and then removed by the
consumer driver's probe callback, the supplier's PM-runtime usage
counter will be nonzero after that which effectively causes the
supplier to remain "always on" going forward.
Namely, device_link_add() called to add the link invokes
device_link_rpm_prepare() which notices that the consumer driver is
probing, so it increments the supplier's PM-runtime usage counter
with the assumption that the link will stay around until
pm_runtime_put_suppliers() is called by driver_probe_device(),
but if the link goes away before that point, the supplier's
PM-runtime usage counter will remain nonzero.
To prevent that from happening, first rework pm_runtime_get_suppliers()
and pm_runtime_put_suppliers() to use the rpm_active refounts of device
links and make the latter only drop rpm_active and the supplier's
PM-runtime usage counter for each link by one, unless rpm_active is
one already for it. Next, modify device_link_add() to bump up the
new link's rpm_active refcount and the suppliers PM-runtime usage
counter by two, to prevent pm_runtime_put_suppliers(), if it is
called subsequently, from suspending the supplier prematurely (in
case its PM-runtime usage counter goes down to 0 in there).
Due to the way rpm_put_suppliers() works, this change does not
affect runtime suspend of the consumer ends of new device links (or,
generally, device links for which DL_FLAG_PM_RUNTIME has just been
set).
Fixes: e2f3cd831a28 ("driver core: Fix handling of runtime PM flags in device_link_add()")
Reported-by: Ulf Hansson <ulf.hansson@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
Tested-by: Ulf Hansson <ulf.hansson@linaro.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2019-02-12 20:08:10 +08:00
|
|
|
}
|
2018-06-12 16:24:13 +08:00
|
|
|
|
|
|
|
device_links_read_unlock(idx);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_runtime_put_suppliers - Drop references to supplier devices.
|
|
|
|
* @dev: Consumer device.
|
|
|
|
*/
|
|
|
|
void pm_runtime_put_suppliers(struct device *dev)
|
|
|
|
{
|
|
|
|
struct device_link *link;
|
|
|
|
int idx;
|
|
|
|
|
|
|
|
idx = device_links_read_lock();
|
|
|
|
|
2019-07-17 06:12:25 +08:00
|
|
|
list_for_each_entry_rcu(link, &dev->links.suppliers, c_node,
|
|
|
|
device_links_read_lock_held())
|
2019-02-20 00:53:26 +08:00
|
|
|
if (link->supplier_preactivated) {
|
2021-12-18 03:16:02 +08:00
|
|
|
bool put;
|
|
|
|
|
2019-02-20 00:53:26 +08:00
|
|
|
link->supplier_preactivated = false;
|
2021-12-18 03:16:02 +08:00
|
|
|
|
|
|
|
spin_lock_irq(&dev->power.lock);
|
|
|
|
|
PM: runtime: Fix race getting/putting suppliers at probe
pm_runtime_put_suppliers() must not decrement rpm_active unless the
consumer is suspended. That is because, otherwise, it could suspend
suppliers for an active consumer.
That can happen as follows:
static int driver_probe_device(struct device_driver *drv, struct device *dev)
{
int ret = 0;
if (!device_is_registered(dev))
return -ENODEV;
dev->can_match = true;
pr_debug("bus: '%s': %s: matched device %s with driver %s\n",
drv->bus->name, __func__, dev_name(dev), drv->name);
pm_runtime_get_suppliers(dev);
if (dev->parent)
pm_runtime_get_sync(dev->parent);
At this point, dev can runtime suspend so rpm_put_suppliers() can run,
rpm_active becomes 1 (the lowest value).
pm_runtime_barrier(dev);
if (initcall_debug)
ret = really_probe_debug(dev, drv);
else
ret = really_probe(dev, drv);
Probe callback can have runtime resumed dev, and then runtime put
so dev is awaiting autosuspend, but rpm_active is 2.
pm_request_idle(dev);
if (dev->parent)
pm_runtime_put(dev->parent);
pm_runtime_put_suppliers(dev);
Now pm_runtime_put_suppliers() will put the supplier
i.e. rpm_active 2 -> 1, but consumer can still be active.
return ret;
}
Fix by checking the runtime status. For any status other than
RPM_SUSPENDED, rpm_active can be considered to be "owned" by
rpm_[get/put]_suppliers() and pm_runtime_put_suppliers() need do nothing.
Reported-by: Asutosh Das <asutoshd@codeaurora.org>
Fixes: 4c06c4e6cf63 ("driver core: Fix possible supplier PM-usage counter imbalance")
Signed-off-by: Adrian Hunter <adrian.hunter@intel.com>
Cc: 5.1+ <stable@vger.kernel.org> # 5.1+
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2021-03-26 18:56:19 +08:00
|
|
|
put = pm_runtime_status_suspended(dev) &&
|
|
|
|
refcount_dec_not_one(&link->rpm_active);
|
2021-12-18 03:16:02 +08:00
|
|
|
|
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
|
PM: runtime: Fix race getting/putting suppliers at probe
pm_runtime_put_suppliers() must not decrement rpm_active unless the
consumer is suspended. That is because, otherwise, it could suspend
suppliers for an active consumer.
That can happen as follows:
static int driver_probe_device(struct device_driver *drv, struct device *dev)
{
int ret = 0;
if (!device_is_registered(dev))
return -ENODEV;
dev->can_match = true;
pr_debug("bus: '%s': %s: matched device %s with driver %s\n",
drv->bus->name, __func__, dev_name(dev), drv->name);
pm_runtime_get_suppliers(dev);
if (dev->parent)
pm_runtime_get_sync(dev->parent);
At this point, dev can runtime suspend so rpm_put_suppliers() can run,
rpm_active becomes 1 (the lowest value).
pm_runtime_barrier(dev);
if (initcall_debug)
ret = really_probe_debug(dev, drv);
else
ret = really_probe(dev, drv);
Probe callback can have runtime resumed dev, and then runtime put
so dev is awaiting autosuspend, but rpm_active is 2.
pm_request_idle(dev);
if (dev->parent)
pm_runtime_put(dev->parent);
pm_runtime_put_suppliers(dev);
Now pm_runtime_put_suppliers() will put the supplier
i.e. rpm_active 2 -> 1, but consumer can still be active.
return ret;
}
Fix by checking the runtime status. For any status other than
RPM_SUSPENDED, rpm_active can be considered to be "owned" by
rpm_[get/put]_suppliers() and pm_runtime_put_suppliers() need do nothing.
Reported-by: Asutosh Das <asutoshd@codeaurora.org>
Fixes: 4c06c4e6cf63 ("driver core: Fix possible supplier PM-usage counter imbalance")
Signed-off-by: Adrian Hunter <adrian.hunter@intel.com>
Cc: 5.1+ <stable@vger.kernel.org> # 5.1+
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2021-03-26 18:56:19 +08:00
|
|
|
if (put)
|
2019-02-20 00:53:26 +08:00
|
|
|
pm_runtime_put(link->supplier);
|
|
|
|
}
|
2016-10-31 00:32:31 +08:00
|
|
|
|
|
|
|
device_links_read_unlock(idx);
|
|
|
|
}
|
|
|
|
|
2016-10-31 00:32:43 +08:00
|
|
|
void pm_runtime_new_link(struct device *dev)
|
|
|
|
{
|
|
|
|
spin_lock_irq(&dev->power.lock);
|
|
|
|
dev->power.links_count++;
|
|
|
|
spin_unlock_irq(&dev->power.lock);
|
|
|
|
}
|
|
|
|
|
2020-10-22 03:12:15 +08:00
|
|
|
static void pm_runtime_drop_link_count(struct device *dev)
|
2016-10-31 00:32:43 +08:00
|
|
|
{
|
|
|
|
spin_lock_irq(&dev->power.lock);
|
|
|
|
WARN_ON(dev->power.links_count == 0);
|
|
|
|
dev->power.links_count--;
|
|
|
|
spin_unlock_irq(&dev->power.lock);
|
2020-10-22 03:12:15 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pm_runtime_drop_link - Prepare for device link removal.
|
|
|
|
* @link: Device link going away.
|
|
|
|
*
|
|
|
|
* Drop the link count of the consumer end of @link and decrement the supplier
|
|
|
|
* device's runtime PM usage counter as many times as needed to drop all of the
|
|
|
|
* PM runtime reference to it from the consumer.
|
|
|
|
*/
|
|
|
|
void pm_runtime_drop_link(struct device_link *link)
|
|
|
|
{
|
|
|
|
if (!(link->flags & DL_FLAG_PM_RUNTIME))
|
|
|
|
return;
|
|
|
|
|
|
|
|
pm_runtime_drop_link_count(link->consumer);
|
2021-12-11 00:10:13 +08:00
|
|
|
pm_runtime_release_supplier(link, true);
|
2016-10-31 00:32:43 +08:00
|
|
|
}
|
|
|
|
|
PM / runtime: Rework pm_runtime_force_suspend/resume()
One of the limitations of pm_runtime_force_suspend/resume() is that
if a parent driver wants to use these functions, all of its child
drivers generally have to do that too because of the parent usage
counter manipulations necessary to get the correct state of the parent
during system-wide transitions to the working state (system resume).
However, that limitation turns out to be artificial, so remove it.
Namely, pm_runtime_force_suspend() only needs to update the children
counter of its parent (if there's is a parent) when the device can
stay in suspend after the subsequent system resume transition, as
that counter is correct already otherwise. Now, if the parent's
children counter is not updated, it is not necessary to increment
the parent's usage counter in that case any more, as long as the
children counters of devices are checked along with their usage
counters in order to decide whether or not the devices may be left
in suspend after the subsequent system resume transition.
Accordingly, modify pm_runtime_force_suspend() to only call
pm_runtime_set_suspended() for devices whose usage and children
counters are at the "no references" level (the runtime PM status
of the device needs to be updated to "suspended" anyway in case
this function is called once again for the same device during the
transition under way), drop the parent usage counter incrementation
from it and update pm_runtime_force_resume() to compensate for these
changes.
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
2018-01-12 21:12:05 +08:00
|
|
|
static bool pm_runtime_need_not_resume(struct device *dev)
|
|
|
|
{
|
|
|
|
return atomic_read(&dev->power.usage_count) <= 1 &&
|
2018-01-15 08:46:25 +08:00
|
|
|
(atomic_read(&dev->power.child_count) == 0 ||
|
|
|
|
dev->power.ignore_children);
|
PM / runtime: Rework pm_runtime_force_suspend/resume()
One of the limitations of pm_runtime_force_suspend/resume() is that
if a parent driver wants to use these functions, all of its child
drivers generally have to do that too because of the parent usage
counter manipulations necessary to get the correct state of the parent
during system-wide transitions to the working state (system resume).
However, that limitation turns out to be artificial, so remove it.
Namely, pm_runtime_force_suspend() only needs to update the children
counter of its parent (if there's is a parent) when the device can
stay in suspend after the subsequent system resume transition, as
that counter is correct already otherwise. Now, if the parent's
children counter is not updated, it is not necessary to increment
the parent's usage counter in that case any more, as long as the
children counters of devices are checked along with their usage
counters in order to decide whether or not the devices may be left
in suspend after the subsequent system resume transition.
Accordingly, modify pm_runtime_force_suspend() to only call
pm_runtime_set_suspended() for devices whose usage and children
counters are at the "no references" level (the runtime PM status
of the device needs to be updated to "suspended" anyway in case
this function is called once again for the same device during the
transition under way), drop the parent usage counter incrementation
from it and update pm_runtime_force_resume() to compensate for these
changes.
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
2018-01-12 21:12:05 +08:00
|
|
|
}
|
|
|
|
|
2014-03-01 18:56:05 +08:00
|
|
|
/**
|
|
|
|
* pm_runtime_force_suspend - Force a device into suspend state if needed.
|
|
|
|
* @dev: Device to suspend.
|
|
|
|
*
|
|
|
|
* Disable runtime PM so we safely can check the device's runtime PM status and
|
PM / runtime: Rework pm_runtime_force_suspend/resume()
One of the limitations of pm_runtime_force_suspend/resume() is that
if a parent driver wants to use these functions, all of its child
drivers generally have to do that too because of the parent usage
counter manipulations necessary to get the correct state of the parent
during system-wide transitions to the working state (system resume).
However, that limitation turns out to be artificial, so remove it.
Namely, pm_runtime_force_suspend() only needs to update the children
counter of its parent (if there's is a parent) when the device can
stay in suspend after the subsequent system resume transition, as
that counter is correct already otherwise. Now, if the parent's
children counter is not updated, it is not necessary to increment
the parent's usage counter in that case any more, as long as the
children counters of devices are checked along with their usage
counters in order to decide whether or not the devices may be left
in suspend after the subsequent system resume transition.
Accordingly, modify pm_runtime_force_suspend() to only call
pm_runtime_set_suspended() for devices whose usage and children
counters are at the "no references" level (the runtime PM status
of the device needs to be updated to "suspended" anyway in case
this function is called once again for the same device during the
transition under way), drop the parent usage counter incrementation
from it and update pm_runtime_force_resume() to compensate for these
changes.
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
2018-01-12 21:12:05 +08:00
|
|
|
* if it is active, invoke its ->runtime_suspend callback to suspend it and
|
|
|
|
* change its runtime PM status field to RPM_SUSPENDED. Also, if the device's
|
|
|
|
* usage and children counters don't indicate that the device was in use before
|
|
|
|
* the system-wide transition under way, decrement its parent's children counter
|
|
|
|
* (if there is a parent). Keep runtime PM disabled to preserve the state
|
|
|
|
* unless we encounter errors.
|
2014-03-01 18:56:05 +08:00
|
|
|
*
|
|
|
|
* Typically this function may be invoked from a system suspend callback to make
|
PM / runtime: Rework pm_runtime_force_suspend/resume()
One of the limitations of pm_runtime_force_suspend/resume() is that
if a parent driver wants to use these functions, all of its child
drivers generally have to do that too because of the parent usage
counter manipulations necessary to get the correct state of the parent
during system-wide transitions to the working state (system resume).
However, that limitation turns out to be artificial, so remove it.
Namely, pm_runtime_force_suspend() only needs to update the children
counter of its parent (if there's is a parent) when the device can
stay in suspend after the subsequent system resume transition, as
that counter is correct already otherwise. Now, if the parent's
children counter is not updated, it is not necessary to increment
the parent's usage counter in that case any more, as long as the
children counters of devices are checked along with their usage
counters in order to decide whether or not the devices may be left
in suspend after the subsequent system resume transition.
Accordingly, modify pm_runtime_force_suspend() to only call
pm_runtime_set_suspended() for devices whose usage and children
counters are at the "no references" level (the runtime PM status
of the device needs to be updated to "suspended" anyway in case
this function is called once again for the same device during the
transition under way), drop the parent usage counter incrementation
from it and update pm_runtime_force_resume() to compensate for these
changes.
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
2018-01-12 21:12:05 +08:00
|
|
|
* sure the device is put into low power state and it should only be used during
|
|
|
|
* system-wide PM transitions to sleep states. It assumes that the analogous
|
|
|
|
* pm_runtime_force_resume() will be used to resume the device.
|
2014-03-01 18:56:05 +08:00
|
|
|
*/
|
|
|
|
int pm_runtime_force_suspend(struct device *dev)
|
|
|
|
{
|
|
|
|
int (*callback)(struct device *);
|
2018-01-16 16:01:27 +08:00
|
|
|
int ret;
|
2014-03-01 18:56:05 +08:00
|
|
|
|
|
|
|
pm_runtime_disable(dev);
|
|
|
|
if (pm_runtime_status_suspended(dev))
|
|
|
|
return 0;
|
|
|
|
|
2014-10-17 18:58:02 +08:00
|
|
|
callback = RPM_GET_CALLBACK(dev, runtime_suspend);
|
2014-03-01 18:56:05 +08:00
|
|
|
|
2018-01-16 16:01:27 +08:00
|
|
|
ret = callback ? callback(dev) : 0;
|
2014-03-01 18:56:05 +08:00
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
|
2016-10-13 22:58:54 +08:00
|
|
|
/*
|
PM / runtime: Rework pm_runtime_force_suspend/resume()
One of the limitations of pm_runtime_force_suspend/resume() is that
if a parent driver wants to use these functions, all of its child
drivers generally have to do that too because of the parent usage
counter manipulations necessary to get the correct state of the parent
during system-wide transitions to the working state (system resume).
However, that limitation turns out to be artificial, so remove it.
Namely, pm_runtime_force_suspend() only needs to update the children
counter of its parent (if there's is a parent) when the device can
stay in suspend after the subsequent system resume transition, as
that counter is correct already otherwise. Now, if the parent's
children counter is not updated, it is not necessary to increment
the parent's usage counter in that case any more, as long as the
children counters of devices are checked along with their usage
counters in order to decide whether or not the devices may be left
in suspend after the subsequent system resume transition.
Accordingly, modify pm_runtime_force_suspend() to only call
pm_runtime_set_suspended() for devices whose usage and children
counters are at the "no references" level (the runtime PM status
of the device needs to be updated to "suspended" anyway in case
this function is called once again for the same device during the
transition under way), drop the parent usage counter incrementation
from it and update pm_runtime_force_resume() to compensate for these
changes.
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
2018-01-12 21:12:05 +08:00
|
|
|
* If the device can stay in suspend after the system-wide transition
|
|
|
|
* to the working state that will follow, drop the children counter of
|
|
|
|
* its parent, but set its status to RPM_SUSPENDED anyway in case this
|
|
|
|
* function will be called again for it in the meantime.
|
2016-10-13 22:58:54 +08:00
|
|
|
*/
|
2021-05-05 19:09:15 +08:00
|
|
|
if (pm_runtime_need_not_resume(dev)) {
|
PM / runtime: Rework pm_runtime_force_suspend/resume()
One of the limitations of pm_runtime_force_suspend/resume() is that
if a parent driver wants to use these functions, all of its child
drivers generally have to do that too because of the parent usage
counter manipulations necessary to get the correct state of the parent
during system-wide transitions to the working state (system resume).
However, that limitation turns out to be artificial, so remove it.
Namely, pm_runtime_force_suspend() only needs to update the children
counter of its parent (if there's is a parent) when the device can
stay in suspend after the subsequent system resume transition, as
that counter is correct already otherwise. Now, if the parent's
children counter is not updated, it is not necessary to increment
the parent's usage counter in that case any more, as long as the
children counters of devices are checked along with their usage
counters in order to decide whether or not the devices may be left
in suspend after the subsequent system resume transition.
Accordingly, modify pm_runtime_force_suspend() to only call
pm_runtime_set_suspended() for devices whose usage and children
counters are at the "no references" level (the runtime PM status
of the device needs to be updated to "suspended" anyway in case
this function is called once again for the same device during the
transition under way), drop the parent usage counter incrementation
from it and update pm_runtime_force_resume() to compensate for these
changes.
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
2018-01-12 21:12:05 +08:00
|
|
|
pm_runtime_set_suspended(dev);
|
2021-05-05 19:09:15 +08:00
|
|
|
} else {
|
PM / runtime: Rework pm_runtime_force_suspend/resume()
One of the limitations of pm_runtime_force_suspend/resume() is that
if a parent driver wants to use these functions, all of its child
drivers generally have to do that too because of the parent usage
counter manipulations necessary to get the correct state of the parent
during system-wide transitions to the working state (system resume).
However, that limitation turns out to be artificial, so remove it.
Namely, pm_runtime_force_suspend() only needs to update the children
counter of its parent (if there's is a parent) when the device can
stay in suspend after the subsequent system resume transition, as
that counter is correct already otherwise. Now, if the parent's
children counter is not updated, it is not necessary to increment
the parent's usage counter in that case any more, as long as the
children counters of devices are checked along with their usage
counters in order to decide whether or not the devices may be left
in suspend after the subsequent system resume transition.
Accordingly, modify pm_runtime_force_suspend() to only call
pm_runtime_set_suspended() for devices whose usage and children
counters are at the "no references" level (the runtime PM status
of the device needs to be updated to "suspended" anyway in case
this function is called once again for the same device during the
transition under way), drop the parent usage counter incrementation
from it and update pm_runtime_force_resume() to compensate for these
changes.
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
2018-01-12 21:12:05 +08:00
|
|
|
__update_runtime_status(dev, RPM_SUSPENDED);
|
2021-05-05 19:09:15 +08:00
|
|
|
dev->power.needs_force_resume = 1;
|
|
|
|
}
|
2016-10-13 22:58:54 +08:00
|
|
|
|
2014-03-01 18:56:05 +08:00
|
|
|
return 0;
|
PM / runtime: Rework pm_runtime_force_suspend/resume()
One of the limitations of pm_runtime_force_suspend/resume() is that
if a parent driver wants to use these functions, all of its child
drivers generally have to do that too because of the parent usage
counter manipulations necessary to get the correct state of the parent
during system-wide transitions to the working state (system resume).
However, that limitation turns out to be artificial, so remove it.
Namely, pm_runtime_force_suspend() only needs to update the children
counter of its parent (if there's is a parent) when the device can
stay in suspend after the subsequent system resume transition, as
that counter is correct already otherwise. Now, if the parent's
children counter is not updated, it is not necessary to increment
the parent's usage counter in that case any more, as long as the
children counters of devices are checked along with their usage
counters in order to decide whether or not the devices may be left
in suspend after the subsequent system resume transition.
Accordingly, modify pm_runtime_force_suspend() to only call
pm_runtime_set_suspended() for devices whose usage and children
counters are at the "no references" level (the runtime PM status
of the device needs to be updated to "suspended" anyway in case
this function is called once again for the same device during the
transition under way), drop the parent usage counter incrementation
from it and update pm_runtime_force_resume() to compensate for these
changes.
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
2018-01-12 21:12:05 +08:00
|
|
|
|
2014-03-01 18:56:05 +08:00
|
|
|
err:
|
|
|
|
pm_runtime_enable(dev);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(pm_runtime_force_suspend);
|
|
|
|
|
|
|
|
/**
|
2016-10-13 22:58:54 +08:00
|
|
|
* pm_runtime_force_resume - Force a device into resume state if needed.
|
2014-03-01 18:56:05 +08:00
|
|
|
* @dev: Device to resume.
|
|
|
|
*
|
|
|
|
* Prior invoking this function we expect the user to have brought the device
|
|
|
|
* into low power state by a call to pm_runtime_force_suspend(). Here we reverse
|
PM / runtime: Rework pm_runtime_force_suspend/resume()
One of the limitations of pm_runtime_force_suspend/resume() is that
if a parent driver wants to use these functions, all of its child
drivers generally have to do that too because of the parent usage
counter manipulations necessary to get the correct state of the parent
during system-wide transitions to the working state (system resume).
However, that limitation turns out to be artificial, so remove it.
Namely, pm_runtime_force_suspend() only needs to update the children
counter of its parent (if there's is a parent) when the device can
stay in suspend after the subsequent system resume transition, as
that counter is correct already otherwise. Now, if the parent's
children counter is not updated, it is not necessary to increment
the parent's usage counter in that case any more, as long as the
children counters of devices are checked along with their usage
counters in order to decide whether or not the devices may be left
in suspend after the subsequent system resume transition.
Accordingly, modify pm_runtime_force_suspend() to only call
pm_runtime_set_suspended() for devices whose usage and children
counters are at the "no references" level (the runtime PM status
of the device needs to be updated to "suspended" anyway in case
this function is called once again for the same device during the
transition under way), drop the parent usage counter incrementation
from it and update pm_runtime_force_resume() to compensate for these
changes.
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
2018-01-12 21:12:05 +08:00
|
|
|
* those actions and bring the device into full power, if it is expected to be
|
|
|
|
* used on system resume. In the other case, we defer the resume to be managed
|
|
|
|
* via runtime PM.
|
2014-03-01 18:56:05 +08:00
|
|
|
*
|
2016-10-13 22:58:54 +08:00
|
|
|
* Typically this function may be invoked from a system resume callback.
|
2014-03-01 18:56:05 +08:00
|
|
|
*/
|
|
|
|
int pm_runtime_force_resume(struct device *dev)
|
|
|
|
{
|
|
|
|
int (*callback)(struct device *);
|
|
|
|
int ret = 0;
|
|
|
|
|
2021-05-05 19:09:15 +08:00
|
|
|
if (!pm_runtime_status_suspended(dev) || !dev->power.needs_force_resume)
|
2016-05-30 17:33:12 +08:00
|
|
|
goto out;
|
|
|
|
|
2016-10-13 22:58:54 +08:00
|
|
|
/*
|
PM / runtime: Rework pm_runtime_force_suspend/resume()
One of the limitations of pm_runtime_force_suspend/resume() is that
if a parent driver wants to use these functions, all of its child
drivers generally have to do that too because of the parent usage
counter manipulations necessary to get the correct state of the parent
during system-wide transitions to the working state (system resume).
However, that limitation turns out to be artificial, so remove it.
Namely, pm_runtime_force_suspend() only needs to update the children
counter of its parent (if there's is a parent) when the device can
stay in suspend after the subsequent system resume transition, as
that counter is correct already otherwise. Now, if the parent's
children counter is not updated, it is not necessary to increment
the parent's usage counter in that case any more, as long as the
children counters of devices are checked along with their usage
counters in order to decide whether or not the devices may be left
in suspend after the subsequent system resume transition.
Accordingly, modify pm_runtime_force_suspend() to only call
pm_runtime_set_suspended() for devices whose usage and children
counters are at the "no references" level (the runtime PM status
of the device needs to be updated to "suspended" anyway in case
this function is called once again for the same device during the
transition under way), drop the parent usage counter incrementation
from it and update pm_runtime_force_resume() to compensate for these
changes.
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
2018-01-12 21:12:05 +08:00
|
|
|
* The value of the parent's children counter is correct already, so
|
|
|
|
* just update the status of the device.
|
|
|
|
*/
|
|
|
|
__update_runtime_status(dev, RPM_ACTIVE);
|
2016-10-13 22:58:54 +08:00
|
|
|
|
PM / runtime: Rework pm_runtime_force_suspend/resume()
One of the limitations of pm_runtime_force_suspend/resume() is that
if a parent driver wants to use these functions, all of its child
drivers generally have to do that too because of the parent usage
counter manipulations necessary to get the correct state of the parent
during system-wide transitions to the working state (system resume).
However, that limitation turns out to be artificial, so remove it.
Namely, pm_runtime_force_suspend() only needs to update the children
counter of its parent (if there's is a parent) when the device can
stay in suspend after the subsequent system resume transition, as
that counter is correct already otherwise. Now, if the parent's
children counter is not updated, it is not necessary to increment
the parent's usage counter in that case any more, as long as the
children counters of devices are checked along with their usage
counters in order to decide whether or not the devices may be left
in suspend after the subsequent system resume transition.
Accordingly, modify pm_runtime_force_suspend() to only call
pm_runtime_set_suspended() for devices whose usage and children
counters are at the "no references" level (the runtime PM status
of the device needs to be updated to "suspended" anyway in case
this function is called once again for the same device during the
transition under way), drop the parent usage counter incrementation
from it and update pm_runtime_force_resume() to compensate for these
changes.
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Reviewed-by: Ulf Hansson <ulf.hansson@linaro.org>
2018-01-12 21:12:05 +08:00
|
|
|
callback = RPM_GET_CALLBACK(dev, runtime_resume);
|
2014-03-01 18:56:05 +08:00
|
|
|
|
2018-01-16 16:01:27 +08:00
|
|
|
ret = callback ? callback(dev) : 0;
|
2016-04-08 19:10:23 +08:00
|
|
|
if (ret) {
|
|
|
|
pm_runtime_set_suspended(dev);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-03-01 18:56:05 +08:00
|
|
|
pm_runtime_mark_last_busy(dev);
|
|
|
|
out:
|
2021-05-05 19:09:15 +08:00
|
|
|
dev->power.needs_force_resume = 0;
|
2014-03-01 18:56:05 +08:00
|
|
|
pm_runtime_enable(dev);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(pm_runtime_force_resume);
|