Commit c8940eca authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/suspend-2.6 

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/suspend-2.6:
  spi / PM: Support dev_pm_ops
  PM: Prototype the pm_generic_ operations
  PM / Runtime: Generic resume shouldn't set RPM_ACTIVE unconditionally
  PM: Use dev_name() in core device suspend and resume routines
  PM: Permit registration of parentless devices during system suspend
  PM: Replace the device power.status field with a bit field
  PM: Remove redundant checks from core device resume routines
  PM: Use a different list of devices for each stage of device suspend
  PM: Avoid compiler warning in pm_noirq_op()
  PM: Use pm_wakeup_pending() in __device_suspend()
  PM / Wakeup: Replace pm_check_wakeup_events() with pm_wakeup_pending()
  PM: Prevent dpm_prepare() from returning errors unnecessarily
  PM: Fix references to basic-pm-debugging.txt in drivers-testing.txt
  PM / Runtime: Add synchronous runtime interface for interrupt handlers (v3)
  PM / Hibernate: When failed, in_suspend should be reset
  PM / Hibernate: hibernation_ops->leave should be checked too
  Freezer: Fix a race during freezing of TASK_STOPPED tasks
  PM: Use proper ccflag flag in kernel/power/Makefile
  PM / Runtime: Fix comments to match runtime callback code
parents 78c92a9f 3ae22e8c

Documentation/power/drivers-testing.txt

+4 −4
Original line number Diff line number Diff line
@@ -23,10 +23,10 @@ Once you have resolved the suspend/resume-related problems with your test system 
without the new driver, you are ready to test it:



a) Build the driver as a module, load it and try the test modes of hibernation

   (see: Documents/power/basic-pm-debugging.txt, 1).

   (see: Documentation/power/basic-pm-debugging.txt, 1).



b) Load the driver and attempt to hibernate in the "reboot", "shutdown" and

   "platform" modes (see: Documents/power/basic-pm-debugging.txt, 1).

   "platform" modes (see: Documentation/power/basic-pm-debugging.txt, 1).



c) Compile the driver directly into the kernel and try the test modes of

   hibernation.
@@ -34,12 +34,12 @@ c) Compile the driver directly into the kernel and try the test modes of 
d) Attempt to hibernate with the driver compiled directly into the kernel

   in the "reboot", "shutdown" and "platform" modes.



e) Try the test modes of suspend (see: Documents/power/basic-pm-debugging.txt,

e) Try the test modes of suspend (see: Documentation/power/basic-pm-debugging.txt,

   2).  [As far as the STR tests are concerned, it should not matter whether or

   not the driver is built as a module.]



f) Attempt to suspend to RAM using the s2ram tool with the driver loaded

   (see: Documents/power/basic-pm-debugging.txt, 2).

   (see: Documentation/power/basic-pm-debugging.txt, 2).



Each of the above tests should be repeated several times and the STD tests

should be mixed with the STR tests.  If any of them fails, the driver cannot be

Documentation/power/runtime_pm.txt

+31 −0
Original line number Diff line number Diff line
@@ -50,6 +50,15 @@ type's callbacks are not defined) of given device. The bus type, device type 
and device class callbacks are referred to as subsystem-level callbacks in what

follows.



By default, the callbacks are always invoked in process context with interrupts

enabled.  However, subsystems can use the pm_runtime_irq_safe() helper function

to tell the PM core that a device's ->runtime_suspend() and ->runtime_resume()

callbacks should be invoked in atomic context with interrupts disabled

(->runtime_idle() is still invoked the default way).  This implies that these

callback routines must not block or sleep, but it also means that the

synchronous helper functions listed at the end of Section 4 can be used within

an interrupt handler or in an atomic context.



The subsystem-level suspend callback is _entirely_ _responsible_ for handling

the suspend of the device as appropriate, which may, but need not include

executing the device driver's own ->runtime_suspend() callback (from the
@@ -237,6 +246,10 @@ defined in include/linux/pm.h: 
      Section 8); it may be modified only by the pm_runtime_no_callbacks()

      helper function



  unsigned int irq_safe;

    - indicates that the ->runtime_suspend() and ->runtime_resume() callbacks

      will be invoked with the spinlock held and interrupts disabled



  unsigned int use_autosuspend;

    - indicates that the device's driver supports delayed autosuspend (see

      Section 9); it may be modified only by the
@@ -344,6 +357,10 @@ drivers/base/power/runtime.c and include/linux/pm_runtime.h: 
    - decrement the device's usage counter; if the result is 0 then run

      pm_runtime_idle(dev) and return its result



  int pm_runtime_put_sync_suspend(struct device *dev);

    - decrement the device's usage counter; if the result is 0 then run

      pm_runtime_suspend(dev) and return its result



  int pm_runtime_put_sync_autosuspend(struct device *dev);

    - decrement the device's usage counter; if the result is 0 then run

      pm_runtime_autosuspend(dev) and return its result
@@ -397,6 +414,11 @@ drivers/base/power/runtime.c and include/linux/pm_runtime.h: 
      PM attributes from /sys/devices/.../power (or prevent them from being

      added when the device is registered)



  void pm_runtime_irq_safe(struct device *dev);

    - set the power.irq_safe flag for the device, causing the runtime-PM

      suspend and resume callbacks (but not the idle callback) to be invoked

      with interrupts disabled



  void pm_runtime_mark_last_busy(struct device *dev);

    - set the power.last_busy field to the current time
@@ -438,6 +460,15 @@ pm_runtime_suspended() 
pm_runtime_mark_last_busy()

pm_runtime_autosuspend_expiration()



If pm_runtime_irq_safe() has been called for a device then the following helper

functions may also be used in interrupt context:



pm_runtime_suspend()

pm_runtime_autosuspend()

pm_runtime_resume()

pm_runtime_get_sync()

pm_runtime_put_sync_suspend()



5. Run-time PM Initialization, Device Probing and Removal



Initially, the run-time PM is disabled for all devices, which means that the

drivers/base/power/generic_ops.c

+3 −3
Original line number Diff line number Diff line
@@ -39,7 +39,7 @@ EXPORT_SYMBOL_GPL(pm_generic_runtime_idle); 
 *

 * If PM operations are defined for the @dev's driver and they include

 * ->runtime_suspend(), execute it and return its error code.  Otherwise,

 * return -EINVAL.

 * return 0.

 */

int pm_generic_runtime_suspend(struct device *dev)

{
@@ -58,7 +58,7 @@ EXPORT_SYMBOL_GPL(pm_generic_runtime_suspend); 
 *

 * If PM operations are defined for the @dev's driver and they include

 * ->runtime_resume(), execute it and return its error code.  Otherwise,

 * return -EINVAL.

 * return 0.

 */

int pm_generic_runtime_resume(struct device *dev)

{
@@ -185,7 +185,7 @@ static int __pm_generic_resume(struct device *dev, int event) 
		return 0;



	ret = callback(dev);

	if (!ret) {

	if (!ret && pm_runtime_enabled(dev)) {

		pm_runtime_disable(dev);

		pm_runtime_set_active(dev);

		pm_runtime_enable(dev);

drivers/base/power/main.c

+62 −112
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@ 
#include <linux/interrupt.h>

#include <linux/sched.h>

#include <linux/async.h>

#include <linux/suspend.h>



#include "../base.h"

#include "power.h"
@@ -41,16 +42,13 @@ 
 */



LIST_HEAD(dpm_list);

LIST_HEAD(dpm_prepared_list);

LIST_HEAD(dpm_suspended_list);

LIST_HEAD(dpm_noirq_list);



static DEFINE_MUTEX(dpm_list_mtx);

static pm_message_t pm_transition;



/*

 * Set once the preparation of devices for a PM transition has started, reset

 * before starting to resume devices.  Protected by dpm_list_mtx.

 */

static bool transition_started;



static int async_error;



/**
@@ -59,7 +57,7 @@ static int async_error; 
 */

void device_pm_init(struct device *dev)

{

	dev->power.status = DPM_ON;

	dev->power.in_suspend = false;

	init_completion(&dev->power.completion);

	complete_all(&dev->power.completion);

	dev->power.wakeup = NULL;
@@ -90,22 +88,11 @@ void device_pm_unlock(void) 
void device_pm_add(struct device *dev)

{

	pr_debug("PM: Adding info for %s:%s\n",

		 dev->bus ? dev->bus->name : "No Bus",

		 kobject_name(&dev->kobj));

		 dev->bus ? dev->bus->name : "No Bus", dev_name(dev));

	mutex_lock(&dpm_list_mtx);

	if (dev->parent) {

		if (dev->parent->power.status >= DPM_SUSPENDING)

	if (dev->parent && dev->parent->power.in_suspend)

		dev_warn(dev, "parent %s should not be sleeping\n",

			dev_name(dev->parent));

	} else if (transition_started) {

		/*

		 * We refuse to register parentless devices while a PM

		 * transition is in progress in order to avoid leaving them

		 * unhandled down the road

		 */

		dev_WARN(dev, "Parentless device registered during a PM transaction\n");

	}



	list_add_tail(&dev->power.entry, &dpm_list);

	mutex_unlock(&dpm_list_mtx);

}
@@ -117,8 +104,7 @@ void device_pm_add(struct device *dev) 
void device_pm_remove(struct device *dev)

{

	pr_debug("PM: Removing info for %s:%s\n",

		 dev->bus ? dev->bus->name : "No Bus",

		 kobject_name(&dev->kobj));

		 dev->bus ? dev->bus->name : "No Bus", dev_name(dev));

	complete_all(&dev->power.completion);

	mutex_lock(&dpm_list_mtx);

	list_del_init(&dev->power.entry);
@@ -135,10 +121,8 @@ void device_pm_remove(struct device *dev) 
void device_pm_move_before(struct device *deva, struct device *devb)

{

	pr_debug("PM: Moving %s:%s before %s:%s\n",

		 deva->bus ? deva->bus->name : "No Bus",

		 kobject_name(&deva->kobj),

		 devb->bus ? devb->bus->name : "No Bus",

		 kobject_name(&devb->kobj));

		 deva->bus ? deva->bus->name : "No Bus", dev_name(deva),

		 devb->bus ? devb->bus->name : "No Bus", dev_name(devb));

	/* Delete deva from dpm_list and reinsert before devb. */

	list_move_tail(&deva->power.entry, &devb->power.entry);

}
@@ -151,10 +135,8 @@ void device_pm_move_before(struct device *deva, struct device *devb) 
void device_pm_move_after(struct device *deva, struct device *devb)

{

	pr_debug("PM: Moving %s:%s after %s:%s\n",

		 deva->bus ? deva->bus->name : "No Bus",

		 kobject_name(&deva->kobj),

		 devb->bus ? devb->bus->name : "No Bus",

		 kobject_name(&devb->kobj));

		 deva->bus ? deva->bus->name : "No Bus", dev_name(deva),

		 devb->bus ? devb->bus->name : "No Bus", dev_name(devb));

	/* Delete deva from dpm_list and reinsert after devb. */

	list_move(&deva->power.entry, &devb->power.entry);

}
@@ -166,8 +148,7 @@ void device_pm_move_after(struct device *deva, struct device *devb) 
void device_pm_move_last(struct device *dev)

{

	pr_debug("PM: Moving %s:%s to end of list\n",

		 dev->bus ? dev->bus->name : "No Bus",

		 kobject_name(&dev->kobj));

		 dev->bus ? dev->bus->name : "No Bus", dev_name(dev));

	list_move_tail(&dev->power.entry, &dpm_list);

}
@@ -303,7 +284,7 @@ static int pm_noirq_op(struct device *dev, 
			pm_message_t state)

{

	int error = 0;

	ktime_t calltime, delta, rettime;

	ktime_t calltime = ktime_set(0, 0), delta, rettime;



	if (initcall_debug) {

		pr_info("calling  %s+ @ %i, parent: %s\n",
@@ -405,7 +386,7 @@ static void pm_dev_err(struct device *dev, pm_message_t state, char *info, 
			int error)

{

	printk(KERN_ERR "PM: Device %s failed to %s%s: error %d\n",

		kobject_name(&dev->kobj), pm_verb(state.event), info, error);

		dev_name(dev), pm_verb(state.event), info, error);

}



static void dpm_show_time(ktime_t starttime, pm_message_t state, char *info)
@@ -475,33 +456,24 @@ End: 
 */

void dpm_resume_noirq(pm_message_t state)

{

	struct list_head list;

	ktime_t starttime = ktime_get();



	INIT_LIST_HEAD(&list);

	mutex_lock(&dpm_list_mtx);

	transition_started = false;

	while (!list_empty(&dpm_list)) {

		struct device *dev = to_device(dpm_list.next);



		get_device(dev);

		if (dev->power.status > DPM_OFF) {

	while (!list_empty(&dpm_noirq_list)) {

		struct device *dev = to_device(dpm_noirq_list.next);

		int error;



			dev->power.status = DPM_OFF;

		get_device(dev);

		list_move_tail(&dev->power.entry, &dpm_suspended_list);

		mutex_unlock(&dpm_list_mtx);



		error = device_resume_noirq(dev, state);



			mutex_lock(&dpm_list_mtx);

		if (error)

			pm_dev_err(dev, state, " early", error);

		}

		if (!list_empty(&dev->power.entry))

			list_move_tail(&dev->power.entry, &list);



		mutex_lock(&dpm_list_mtx);

		put_device(dev);

	}

	list_splice(&list, &dpm_list);

	mutex_unlock(&dpm_list_mtx);

	dpm_show_time(starttime, state, "early");

	resume_device_irqs();
@@ -544,7 +516,7 @@ static int device_resume(struct device *dev, pm_message_t state, bool async) 
	dpm_wait(dev->parent, async);

	device_lock(dev);



	dev->power.status = DPM_RESUMING;

	dev->power.in_suspend = false;



	if (dev->bus) {

		if (dev->bus->pm) {
@@ -610,19 +582,14 @@ static bool is_async(struct device *dev) 
 */

static void dpm_resume(pm_message_t state)

{

	struct list_head list;

	struct device *dev;

	ktime_t starttime = ktime_get();



	INIT_LIST_HEAD(&list);

	mutex_lock(&dpm_list_mtx);

	pm_transition = state;

	async_error = 0;



	list_for_each_entry(dev, &dpm_list, power.entry) {

		if (dev->power.status < DPM_OFF)

			continue;



	list_for_each_entry(dev, &dpm_suspended_list, power.entry) {

		INIT_COMPLETION(dev->power.completion);

		if (is_async(dev)) {

			get_device(dev);
@@ -630,28 +597,24 @@ static void dpm_resume(pm_message_t state) 
		}

	}



	while (!list_empty(&dpm_list)) {

		dev = to_device(dpm_list.next);

	while (!list_empty(&dpm_suspended_list)) {

		dev = to_device(dpm_suspended_list.next);

		get_device(dev);

		if (dev->power.status >= DPM_OFF && !is_async(dev)) {

		if (!is_async(dev)) {

			int error;



			mutex_unlock(&dpm_list_mtx);



			error = device_resume(dev, state, false);



			mutex_lock(&dpm_list_mtx);

			if (error)

				pm_dev_err(dev, state, "", error);

		} else if (dev->power.status == DPM_SUSPENDING) {

			/* Allow new children of the device to be registered */

			dev->power.status = DPM_RESUMING;



			mutex_lock(&dpm_list_mtx);

		}

		if (!list_empty(&dev->power.entry))

			list_move_tail(&dev->power.entry, &list);

			list_move_tail(&dev->power.entry, &dpm_prepared_list);

		put_device(dev);

	}

	list_splice(&list, &dpm_list);

	mutex_unlock(&dpm_list_mtx);

	async_synchronize_full();

	dpm_show_time(starttime, state, NULL);
@@ -697,22 +660,18 @@ static void dpm_complete(pm_message_t state) 


	INIT_LIST_HEAD(&list);

	mutex_lock(&dpm_list_mtx);

	transition_started = false;

	while (!list_empty(&dpm_list)) {

		struct device *dev = to_device(dpm_list.prev);

	while (!list_empty(&dpm_prepared_list)) {

		struct device *dev = to_device(dpm_prepared_list.prev);



		get_device(dev);

		if (dev->power.status > DPM_ON) {

			dev->power.status = DPM_ON;

		dev->power.in_suspend = false;

		list_move(&dev->power.entry, &list);

		mutex_unlock(&dpm_list_mtx);



		device_complete(dev, state);

		pm_runtime_put_sync(dev);



		mutex_lock(&dpm_list_mtx);

		}

		if (!list_empty(&dev->power.entry))

			list_move(&dev->power.entry, &list);

		put_device(dev);

	}

	list_splice(&list, &dpm_list);
@@ -802,15 +761,13 @@ End: 
 */

int dpm_suspend_noirq(pm_message_t state)

{

	struct list_head list;

	ktime_t starttime = ktime_get();

	int error = 0;



	INIT_LIST_HEAD(&list);

	suspend_device_irqs();

	mutex_lock(&dpm_list_mtx);

	while (!list_empty(&dpm_list)) {

		struct device *dev = to_device(dpm_list.prev);

	while (!list_empty(&dpm_suspended_list)) {

		struct device *dev = to_device(dpm_suspended_list.prev);



		get_device(dev);

		mutex_unlock(&dpm_list_mtx);
@@ -823,12 +780,10 @@ int dpm_suspend_noirq(pm_message_t state) 
			put_device(dev);

			break;

		}

		dev->power.status = DPM_OFF_IRQ;

		if (!list_empty(&dev->power.entry))

			list_move(&dev->power.entry, &list);

			list_move(&dev->power.entry, &dpm_noirq_list);

		put_device(dev);

	}

	list_splice_tail(&list, &dpm_list);

	mutex_unlock(&dpm_list_mtx);

	if (error)

		dpm_resume_noirq(resume_event(state));
@@ -876,6 +831,11 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async) 
	if (async_error)

		goto End;



	if (pm_wakeup_pending()) {

		async_error = -EBUSY;

		goto End;

	}



	if (dev->class) {

		if (dev->class->pm) {

			pm_dev_dbg(dev, state, "class ");
@@ -907,9 +867,6 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async) 
		}

	}



	if (!error)

		dev->power.status = DPM_OFF;



 End:

	device_unlock(dev);

	complete_all(&dev->power.completion);
@@ -951,16 +908,14 @@ static int device_suspend(struct device *dev) 
 */

static int dpm_suspend(pm_message_t state)

{

	struct list_head list;

	ktime_t starttime = ktime_get();

	int error = 0;



	INIT_LIST_HEAD(&list);

	mutex_lock(&dpm_list_mtx);

	pm_transition = state;

	async_error = 0;

	while (!list_empty(&dpm_list)) {

		struct device *dev = to_device(dpm_list.prev);

	while (!list_empty(&dpm_prepared_list)) {

		struct device *dev = to_device(dpm_prepared_list.prev);



		get_device(dev);

		mutex_unlock(&dpm_list_mtx);
@@ -974,12 +929,11 @@ static int dpm_suspend(pm_message_t state) 
			break;

		}

		if (!list_empty(&dev->power.entry))

			list_move(&dev->power.entry, &list);

			list_move(&dev->power.entry, &dpm_suspended_list);

		put_device(dev);

		if (async_error)

			break;

	}

	list_splice(&list, dpm_list.prev);

	mutex_unlock(&dpm_list_mtx);

	async_synchronize_full();

	if (!error)
@@ -1038,22 +992,20 @@ static int device_prepare(struct device *dev, pm_message_t state) 
 */

static int dpm_prepare(pm_message_t state)

{

	struct list_head list;

	int error = 0;



	INIT_LIST_HEAD(&list);

	mutex_lock(&dpm_list_mtx);

	transition_started = true;

	while (!list_empty(&dpm_list)) {

		struct device *dev = to_device(dpm_list.next);



		get_device(dev);

		dev->power.status = DPM_PREPARING;

		mutex_unlock(&dpm_list_mtx);



		pm_runtime_get_noresume(dev);

		if (pm_runtime_barrier(dev) && device_may_wakeup(dev)) {

			/* Wake-up requested during system sleep transition. */

		if (pm_runtime_barrier(dev) && device_may_wakeup(dev))

			pm_wakeup_event(dev, 0);



		if (pm_wakeup_pending()) {

			pm_runtime_put_sync(dev);

			error = -EBUSY;

		} else {
@@ -1062,24 +1014,22 @@ static int dpm_prepare(pm_message_t state) 


		mutex_lock(&dpm_list_mtx);

		if (error) {

			dev->power.status = DPM_ON;

			if (error == -EAGAIN) {

				put_device(dev);

				error = 0;

				continue;

			}

			printk(KERN_ERR "PM: Failed to prepare device %s "

				"for power transition: error %d\n",

				kobject_name(&dev->kobj), error);

			printk(KERN_INFO "PM: Device %s not prepared "

				"for power transition: code %d\n",

				dev_name(dev), error);

			put_device(dev);

			break;

		}

		dev->power.status = DPM_SUSPENDING;

		dev->power.in_suspend = true;

		if (!list_empty(&dev->power.entry))

			list_move_tail(&dev->power.entry, &list);

			list_move_tail(&dev->power.entry, &dpm_prepared_list);

		put_device(dev);

	}

	list_splice(&list, &dpm_list);

	mutex_unlock(&dpm_list_mtx);

	return error;

}

drivers/base/power/runtime.c

+38 −9
Original line number Diff line number Diff line
@@ -250,13 +250,16 @@ static int rpm_callback(int (*cb)(struct device *), struct device *dev) 
	if (!cb)

		return -ENOSYS;



	if (dev->power.irq_safe) {

		retval = cb(dev);

	} else {

		spin_unlock_irq(&dev->power.lock);



		retval = cb(dev);



		spin_lock_irq(&dev->power.lock);

	}

	dev->power.runtime_error = retval;



	return retval;

}
@@ -404,7 +407,7 @@ static int rpm_suspend(struct device *dev, int rpmflags) 
		goto out;

	}



	if (parent && !parent->power.ignore_children) {

	if (parent && !parent->power.ignore_children && !dev->power.irq_safe) {

		spin_unlock_irq(&dev->power.lock);



		pm_request_idle(parent);
@@ -527,10 +530,13 @@ static int rpm_resume(struct device *dev, int rpmflags) 


	if (!parent && dev->parent) {

		/*

		 * Increment the parent's resume counter and resume it if

		 * necessary.

		 * Increment the parent's usage counter and resume it if

		 * necessary.  Not needed if dev is irq-safe; then the

		 * parent is permanently resumed.

		 */

		parent = dev->parent;

		if (dev->power.irq_safe)

			goto skip_parent;

		spin_unlock(&dev->power.lock);



		pm_runtime_get_noresume(parent);
@@ -553,6 +559,7 @@ static int rpm_resume(struct device *dev, int rpmflags) 
			goto out;

		goto repeat;

	}

 skip_parent:



	if (dev->power.no_callbacks)

		goto no_callback;	/* Assume success. */
@@ -584,7 +591,7 @@ static int rpm_resume(struct device *dev, int rpmflags) 
		rpm_idle(dev, RPM_ASYNC);



 out:

	if (parent) {

	if (parent && !dev->power.irq_safe) {

		spin_unlock_irq(&dev->power.lock);



		pm_runtime_put(parent);
@@ -1065,7 +1072,6 @@ EXPORT_SYMBOL_GPL(pm_runtime_allow); 
 * Set the power.no_callbacks flag, which tells the PM core that this

 * device is power-managed through its parent and has no run-time PM

 * callbacks of its own.  The run-time sysfs attributes will be removed.

 *

 */

void pm_runtime_no_callbacks(struct device *dev)

{
@@ -1077,6 +1083,27 @@ void pm_runtime_no_callbacks(struct device *dev) 
}

EXPORT_SYMBOL_GPL(pm_runtime_no_callbacks);



/**

 * 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);



/**

 * update_autosuspend - Handle a change to a device's autosuspend settings.

 * @dev: Device to handle.
@@ -1199,4 +1226,6 @@ void pm_runtime_remove(struct device *dev) 
	/* Change the status back to 'suspended' to match the initial status. */

	if (dev->power.runtime_status == RPM_ACTIVE)

		pm_runtime_set_suspended(dev);

	if (dev->power.irq_safe && dev->parent)

		pm_runtime_put_sync(dev->parent);

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE