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: PM / Hibernate: Fix preallocating of memory PM / Hibernate: Remove swsusp.c finally PM / Hibernate: Remove trailing space in message PM: Allow SCSI devices to suspend/resume asynchronously PM: Allow USB devices to suspend/resume asynchronously USB: implement non-tree resume ordering constraints for PCI host controllers PM: Allow PCI devices to suspend/resume asynchronously PM / Hibernate: Swap, remove useless check from swsusp_read() PM / Hibernate: Really deprecate deprecated user ioctls PM: Allow device drivers to use dpm_wait() PM: Start asynchronous resume threads upfront PM: Add facility for advanced testing of async suspend/resume PM: Add a switch for disabling/enabling asynchronous suspend/resume PM: Asynchronous suspend and resume of devices PM: Add parent information to timing messages PM: Document device power attributes in sysfs PM / Runtime: Add sysfs switch for disabling device run-time PM

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: PM / Hibernate: Fix preallocating of memory PM / Hibernate: Remove swsusp.c finally PM / Hibernate: Remove trailing space in message PM: Allow SCSI devices to suspend/resume asynchronously PM: Allow USB devices to suspend/resume asynchronously USB: implement non-tree resume ordering constraints for PCI host controllers PM: Allow PCI devices to suspend/resume asynchronously PM / Hibernate: Swap, remove useless check from swsusp_read() PM / Hibernate: Really deprecate deprecated user ioctls PM: Allow device drivers to use dpm_wait() PM: Start asynchronous resume threads upfront PM: Add facility for advanced testing of async suspend/resume PM: Add a switch for disabling/enabling asynchronous suspend/resume PM: Asynchronous suspend and resume of devices PM: Add parent information to timing messages PM: Document device power attributes in sysfs PM / Runtime: Add sysfs switch for disabling device run-time PM
Linus Torvalds
2 parents 4912002fff a9c9b4429d
Showing 28 changed files Side-by-side Diff
Documentation/ABI/testing/sysfs-devices-power
Documentation/ABI/testing/sysfs-power
Documentation/feature-removal-schedule.txt
drivers/base/power/main.c
drivers/base/power/power.h
drivers/base/power/runtime.c
drivers/base/power/sysfs.c
drivers/pci/pci.c
drivers/pci/pcie/portdrv_core.c
drivers/pci/probe.c
drivers/scsi/hosts.c
drivers/scsi/scsi_sysfs.c
drivers/usb/core/driver.c
drivers/usb/core/endpoint.c
drivers/usb/core/hcd-pci.c
drivers/usb/core/hub.c
drivers/usb/core/message.c
include/linux/device.h
include/linux/pm.h
include/linux/pm_runtime.h
+What:		/sys/devices/.../power/
+Date:		January 2009
+Contact:	Rafael J. Wysocki <rjw@sisk.pl>
+Description:
+		The /sys/devices/.../power directory contains attributes
+		allowing the user space to check and modify some power
+		management related properties of given device.
+
+What:		/sys/devices/.../power/wakeup
+Date:		January 2009
+Contact:	Rafael J. Wysocki <rjw@sisk.pl>
+Description:
+		The /sys/devices/.../power/wakeup attribute allows the user
+		space to check if the device is enabled to wake up the system
+		from sleep states, such as the memory sleep state (suspend to
+		RAM) and hibernation (suspend to disk), and to enable or disable
+		it to do that as desired.
+
+		Some devices support "wakeup" events, which are hardware signals
+		used to activate the system from a sleep state.  Such devices
+		have one of the following two values for the sysfs power/wakeup
+		file:
+
+		+ "enabled\n" to issue the events;
+		+ "disabled\n" not to do so;
+
+		In that cases the user space can change the setting represented
+		by the contents of this file by writing either "enabled", or
+		"disabled" to it.
+
+		For the devices that are not capable of generating system wakeup
+		events this file contains "\n".  In that cases the user space
+		cannot modify the contents of this file and the device cannot be
+		enabled to wake up the system.
+
+What:		/sys/devices/.../power/control
+Date:		January 2009
+Contact:	Rafael J. Wysocki <rjw@sisk.pl>
+Description:
+		The /sys/devices/.../power/control attribute allows the user
+		space to control the run-time power management of the device.
+
+		All devices have one of the following two values for the
+		power/control file:
+
+		+ "auto\n" to allow the device to be power managed at run time;
+		+ "on\n" to prevent the device from being power managed;
+
+		The default for all devices is "auto", which means that they may
+		be subject to automatic power management, depending on their
+		drivers.  Changing this attribute to "on" prevents the driver
+		from power managing the device at run time.  Doing that while
+		the device is suspended causes it to be woken up.
+
+What:		/sys/devices/.../power/async
+Date:		January 2009
+Contact:	Rafael J. Wysocki <rjw@sisk.pl>
+Description:
+		The /sys/devices/.../async attribute allows the user space to
+		enable or diasble the device's suspend and resume callbacks to
+		be executed asynchronously (ie. in separate threads, in parallel
+		with the main suspend/resume thread) during system-wide power
+		transitions (eg. suspend to RAM, hibernation).
+
+		All devices have one of the following two values for the
+		power/async file:
+
+		+ "enabled\n" to permit the asynchronous suspend/resume;
+		+ "disabled\n" to forbid it;
+
+		The value of this attribute may be changed by writing either
+		"enabled", or "disabled" to it.
+
+		It generally is unsafe to permit the asynchronous suspend/resume
+		of a device unless it is certain that all of the PM dependencies
+		of the device are known to the PM core.  However, for some
+		devices this attribute is set to "enabled" by bus type code or
+		device drivers and in that cases it should be safe to leave the
+		default value.
@@ -101,4 +101,17 @@
  
 		CAUTION: Using it will cause your machine's real-time (CMOS)
 		clock to be set to a random invalid time after a resume.
+
+What:		/sys/power/pm_async
+Date:		January 2009
+Contact:	Rafael J. Wysocki <rjw@sisk.pl>
+Description:
+		The /sys/power/pm_async file controls the switch allowing the
+		user space to enable or disable asynchronous suspend and resume
+		of devices.  If enabled, this feature will cause some device
+		drivers' suspend and resume callbacks to be executed in parallel
+		with each other and with the main suspend thread.  It is enabled
+		if this file contains "1", which is the default.  It may be
+		disabled by writing "0" to this file, in which case all devices
+		will be suspended and resumed synchronously.
@@ -64,6 +64,17 @@
  
 ---------------------------
  
+What:	Deprecated snapshot ioctls
+When:	2.6.36
+
+Why:	The ioctls in kernel/power/user.c were marked as deprecated long time
+	ago. Now they notify users about that so that they need to replace
+	their userspace. After some more time, remove them completely.
+
+Who:	Jiri Slaby <jirislaby@gmail.com>
+
+---------------------------
+
 What:	The ieee80211_regdom module parameter
 When:	March 2010 / desktop catchup
  
@@ -25,6 +25,7 @@
 #include <linux/resume-trace.h>
 #include <linux/interrupt.h>
 #include <linux/sched.h>
+#include <linux/async.h>
  
 #include "../base.h"
 #include "power.h"
@@ -42,6 +43,7 @@
 LIST_HEAD(dpm_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
@@ -56,6 +58,7 @@
 void device_pm_init(struct device *dev)
 {
 	dev->power.status = DPM_ON;
+	init_completion(&dev->power.completion);
 	pm_runtime_init(dev);
 }
  
@@ -111,6 +114,7 @@
 	pr_debug("PM: Removing info for %s:%s\n",
 		 dev->bus ? dev->bus->name : "No Bus",
 		 kobject_name(&dev->kobj));
+	complete_all(&dev->power.completion);
 	mutex_lock(&dpm_list_mtx);
 	list_del_init(&dev->power.entry);
 	mutex_unlock(&dpm_list_mtx);
@@ -188,6 +192,31 @@
 }
  
 /**
+ * dpm_wait - Wait for a PM operation to complete.
+ * @dev: Device to wait for.
+ * @async: If unset, wait only if the device's power.async_suspend flag is set.
+ */
+static void dpm_wait(struct device *dev, bool async)
+{
+	if (!dev)
+		return;
+
+	if (async || (pm_async_enabled && dev->power.async_suspend))
+		wait_for_completion(&dev->power.completion);
+}
+
+static int dpm_wait_fn(struct device *dev, void *async_ptr)
+{
+	dpm_wait(dev, *((bool *)async_ptr));
+	return 0;
+}
+
+static void dpm_wait_for_children(struct device *dev, bool async)
+{
+       device_for_each_child(dev, &async, dpm_wait_fn);
+}
+
+/**
  * pm_op - Execute the PM operation appropriate for given PM event.
  * @dev: Device to handle.
  * @ops: PM operations to choose from.
@@ -271,8 +300,9 @@
 	ktime_t calltime, delta, rettime;
  
 	if (initcall_debug) {
-		pr_info("calling  %s_i+ @ %i\n",
-				dev_name(dev), task_pid_nr(current));
+		pr_info("calling  %s+ @ %i, parent: %s\n",
+				dev_name(dev), task_pid_nr(current),
+				dev->parent ? dev_name(dev->parent) : "none");
 		calltime = ktime_get();
 	}
  
  
  
  
@@ -468,16 +498,20 @@
  * device_resume - Execute "resume" callbacks for given device.
  * @dev: Device to handle.
  * @state: PM transition of the system being carried out.
+ * @async: If true, the device is being resumed asynchronously.
  */
-static int device_resume(struct device *dev, pm_message_t state)
+static int device_resume(struct device *dev, pm_message_t state, bool async)
 {
 	int error = 0;
  
 	TRACE_DEVICE(dev);
 	TRACE_RESUME(0);
  
+	dpm_wait(dev->parent, async);
 	down(&dev->sem);
  
+	dev->power.status = DPM_RESUMING;
+
 	if (dev->bus) {
 		if (dev->bus->pm) {
 			pm_dev_dbg(dev, state, "");
  
@@ -510,11 +544,29 @@
 	}
  End:
 	up(&dev->sem);
+	complete_all(&dev->power.completion);
  
 	TRACE_RESUME(error);
 	return error;
 }
  
+static void async_resume(void *data, async_cookie_t cookie)
+{
+	struct device *dev = (struct device *)data;
+	int error;
+
+	error = device_resume(dev, pm_transition, true);
+	if (error)
+		pm_dev_err(dev, pm_transition, " async", error);
+	put_device(dev);
+}
+
+static bool is_async(struct device *dev)
+{
+	return dev->power.async_suspend && pm_async_enabled
+		&& !pm_trace_is_enabled();
+}
+
 /**
  * dpm_resume - Execute "resume" callbacks for non-sysdev devices.
  * @state: PM transition of the system being carried out.
  
  
  
  
  
@@ -525,21 +577,33 @@
 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);
-	while (!list_empty(&dpm_list)) {
-		struct device *dev = to_device(dpm_list.next);
+	pm_transition = state;
  
+	list_for_each_entry(dev, &dpm_list, power.entry) {
+		if (dev->power.status < DPM_OFF)
+			continue;
+
+		INIT_COMPLETION(dev->power.completion);
+		if (is_async(dev)) {
+			get_device(dev);
+			async_schedule(async_resume, dev);
+		}
+	}
+
+	while (!list_empty(&dpm_list)) {
+		dev = to_device(dpm_list.next);
 		get_device(dev);
-		if (dev->power.status >= DPM_OFF) {
+		if (dev->power.status >= DPM_OFF && !is_async(dev)) {
 			int error;
  
-			dev->power.status = DPM_RESUMING;
 			mutex_unlock(&dpm_list_mtx);
  
-			error = device_resume(dev, state);
+			error = device_resume(dev, state, false);
  
 			mutex_lock(&dpm_list_mtx);
 			if (error)
@@ -554,6 +618,7 @@
 	}
 	list_splice(&list, &dpm_list);
 	mutex_unlock(&dpm_list_mtx);
+	async_synchronize_full();
 	dpm_show_time(starttime, state, NULL);
 }
  
  
  
  
  
@@ -731,17 +796,24 @@
 	return error;
 }
  
+static int async_error;
+
 /**
  * device_suspend - Execute "suspend" callbacks for given device.
  * @dev: Device to handle.
  * @state: PM transition of the system being carried out.
+ * @async: If true, the device is being suspended asynchronously.
  */
-static int device_suspend(struct device *dev, pm_message_t state)
+static int __device_suspend(struct device *dev, pm_message_t state, bool async)
 {
 	int error = 0;
  
+	dpm_wait_for_children(dev, async);
 	down(&dev->sem);
  
+	if (async_error)
+		goto End;
+
 	if (dev->class) {
 		if (dev->class->pm) {
 			pm_dev_dbg(dev, state, "class ");
  
  
@@ -772,12 +844,44 @@
 			error = legacy_suspend(dev, state, dev->bus->suspend);
 		}
 	}
+
+	if (!error)
+		dev->power.status = DPM_OFF;
+
  End:
 	up(&dev->sem);
+	complete_all(&dev->power.completion);
  
 	return error;
 }
  
+static void async_suspend(void *data, async_cookie_t cookie)
+{
+	struct device *dev = (struct device *)data;
+	int error;
+
+	error = __device_suspend(dev, pm_transition, true);
+	if (error) {
+		pm_dev_err(dev, pm_transition, " async", error);
+		async_error = error;
+	}
+
+	put_device(dev);
+}
+
+static int device_suspend(struct device *dev)
+{
+	INIT_COMPLETION(dev->power.completion);
+
+	if (pm_async_enabled && dev->power.async_suspend) {
+		get_device(dev);
+		async_schedule(async_suspend, dev);
+		return 0;
+	}
+
+	return __device_suspend(dev, pm_transition, false);
+}
+
 /**
  * dpm_suspend - Execute "suspend" callbacks for all non-sysdev devices.
  * @state: PM transition of the system being carried out.
  
@@ -790,13 +894,15 @@
  
 	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);
  
 		get_device(dev);
 		mutex_unlock(&dpm_list_mtx);
  
-		error = device_suspend(dev, state);
+		error = device_suspend(dev);
  
 		mutex_lock(&dpm_list_mtx);
 		if (error) {
  
  
  
@@ -804,14 +910,18 @@
 			put_device(dev);
 			break;
 		}
-		dev->power.status = DPM_OFF;
 		if (!list_empty(&dev->power.entry))
 			list_move(&dev->power.entry, &list);
 		put_device(dev);
+		if (async_error)
+			break;
 	}
 	list_splice(&list, dpm_list.prev);
 	mutex_unlock(&dpm_list_mtx);
+	async_synchronize_full();
 	if (!error)
+		error = async_error;
+	if (!error)
 		dpm_show_time(starttime, state, NULL);
 	return error;
 }
@@ -936,4 +1046,15 @@
 		printk(KERN_ERR "%s(): %pF returns %d\n", function, fn, ret);
 }
 EXPORT_SYMBOL_GPL(__suspend_report_result);
+
+/**
+ * device_pm_wait_for_dev - Wait for suspend/resume of a device to complete.
+ * @dev: Device to wait for.
+ * @subordinate: Device that needs to wait for @dev.
+ */
+void device_pm_wait_for_dev(struct device *subordinate, struct device *dev)
+{
+	dpm_wait(dev, subordinate->power.async_suspend);
+}
+EXPORT_SYMBOL_GPL(device_pm_wait_for_dev);
@@ -12,10 +12,10 @@
  
 #ifdef CONFIG_PM_SLEEP
  
-/*
- * main.c
- */
+/* kernel/power/main.c */
+extern int pm_async_enabled;
  
+/* drivers/base/power/main.c */
 extern struct list_head dpm_list;	/* The active device list */
  
 static inline struct device *to_device(struct list_head *entry)
@@ -1011,6 +1011,50 @@
 EXPORT_SYMBOL_GPL(pm_runtime_enable);
  
 /**
+ * pm_runtime_forbid - Block run-time PM of a device.
+ * @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);
+	__pm_runtime_resume(dev, false);
+
+ out:
+	spin_unlock_irq(&dev->power.lock);
+}
+EXPORT_SYMBOL_GPL(pm_runtime_forbid);
+
+/**
+ * pm_runtime_allow - Unblock run-time PM of a device.
+ * @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))
+		__pm_runtime_idle(dev);
+
+ out:
+	spin_unlock_irq(&dev->power.lock);
+}
+EXPORT_SYMBOL_GPL(pm_runtime_allow);
+
+/**
  * pm_runtime_init - Initialize run-time PM fields in given device object.
  * @dev: Device object to initialize.
  */
@@ -1028,6 +1072,7 @@
  
 	atomic_set(&dev->power.child_count, 0);
 	pm_suspend_ignore_children(dev, false);
+	dev->power.runtime_auto = true;
  
 	dev->power.request_pending = false;
 	dev->power.request = RPM_REQ_NONE;
@@ -4,9 +4,25 @@
  
 #include <linux/device.h>
 #include <linux/string.h>
+#include <linux/pm_runtime.h>
 #include "power.h"
  
 /*
+ *	control - Report/change current runtime PM setting of the device
+ *
+ *	Runtime power management of a device can be blocked with the help of
+ *	this attribute.  All devices have one of the following two values for
+ *	the power/control file:
+ *
+ *	 + "auto\n" to allow the device to be power managed at run time;
+ *	 + "on\n" to prevent the device from being power managed at run time;
+ *
+ *	The default for all devices is "auto", which means that devices may be
+ *	subject to automatic power management, depending on their drivers.
+ *	Changing this attribute to "on" prevents the driver from power managing
+ *	the device at run time.  Doing that while the device is suspended causes
+ *	it to be woken up.
+ *
  *	wakeup - Report/change current wakeup option for device
  *
  *	Some devices support "wakeup" events, which are hardware signals
  
@@ -38,11 +54,61 @@
  *	wakeup events internally (unless they are disabled), keeping
  *	their hardware in low power modes whenever they're unused.  This
  *	saves runtime power, without requiring system-wide sleep states.
+ *
+ *	async - Report/change current async suspend setting for the device
+ *
+ *	Asynchronous suspend and resume of the device during system-wide power
+ *	state transitions can be enabled by writing "enabled" to this file.
+ *	Analogously, if "disabled" is written to this file, the device will be
+ *	suspended and resumed synchronously.
+ *
+ *	All devices have one of the following two values for power/async:
+ *
+ *	 + "enabled\n" to permit the asynchronous suspend/resume of the device;
+ *	 + "disabled\n" to forbid it;
+ *
+ *	NOTE: It generally is unsafe to permit the asynchronous suspend/resume
+ *	of a device unless it is certain that all of the PM dependencies of the
+ *	device are known to the PM core.  However, for some devices this
+ *	attribute is set to "enabled" by bus type code or device drivers and in
+ *	that cases it should be safe to leave the default value.
  */
  
 static const char enabled[] = "enabled";
 static const char disabled[] = "disabled";
  
+#ifdef CONFIG_PM_RUNTIME
+static const char ctrl_auto[] = "auto";
+static const char ctrl_on[] = "on";
+
+static ssize_t control_show(struct device *dev, struct device_attribute *attr,
+			    char *buf)
+{
+	return sprintf(buf, "%s\n",
+				dev->power.runtime_auto ? ctrl_auto : ctrl_on);
+}
+
+static ssize_t control_store(struct device * dev, struct device_attribute *attr,
+			     const char * buf, size_t n)
+{
+	char *cp;
+	int len = n;
+
+	cp = memchr(buf, '\n', n);
+	if (cp)
+		len = cp - buf;
+	if (len == sizeof ctrl_auto - 1 && strncmp(buf, ctrl_auto, len) == 0)
+		pm_runtime_allow(dev);
+	else if (len == sizeof ctrl_on - 1 && strncmp(buf, ctrl_on, len) == 0)
+		pm_runtime_forbid(dev);
+	else
+		return -EINVAL;
+	return n;
+}
+
+static DEVICE_ATTR(control, 0644, control_show, control_store);
+#endif
+
 static ssize_t
 wake_show(struct device * dev, struct device_attribute *attr, char * buf)
 {
  
  
  
@@ -77,9 +143,43 @@
  
 static DEVICE_ATTR(wakeup, 0644, wake_show, wake_store);
  
+#ifdef CONFIG_PM_SLEEP_ADVANCED_DEBUG
+static ssize_t async_show(struct device *dev, struct device_attribute *attr,
+			  char *buf)
+{
+	return sprintf(buf, "%s\n",
+			device_async_suspend_enabled(dev) ? enabled : disabled);
+}
  
+static ssize_t async_store(struct device *dev, struct device_attribute *attr,
+			   const char *buf, size_t n)
+{
+	char *cp;
+	int len = n;
+
+	cp = memchr(buf, '\n', n);
+	if (cp)
+		len = cp - buf;
+	if (len == sizeof enabled - 1 && strncmp(buf, enabled, len) == 0)
+		device_enable_async_suspend(dev);
+	else if (len == sizeof disabled - 1 && strncmp(buf, disabled, len) == 0)
+		device_disable_async_suspend(dev);
+	else
+		return -EINVAL;
+	return n;
+}
+
+static DEVICE_ATTR(async, 0644, async_show, async_store);
+#endif /* CONFIG_PM_SLEEP_ADVANCED_DEBUG */
+
 static struct attribute * power_attrs[] = {
+#ifdef CONFIG_PM_RUNTIME
+	&dev_attr_control.attr,
+#endif
 	&dev_attr_wakeup.attr,
+#ifdef CONFIG_PM_SLEEP_ADVANCED_DEBUG
+	&dev_attr_async.attr,
+#endif
 	NULL,
 };
 static struct attribute_group pm_attr_group = {
@@ -1540,6 +1540,7 @@
 	int pm;
 	u16 pmc;
  
+	device_enable_async_suspend(&dev->dev);
 	dev->wakeup_prepared = false;
 	dev->pm_cap = 0;
  
@@ -285,6 +285,7 @@
 		     pci_name(pdev),
 		     get_descriptor_id(pdev->pcie_type, service));
 	device->parent = &pdev->dev;
+	device_enable_async_suspend(device);
  
 	retval = device_register(device);
 	if (retval)
@@ -1436,6 +1436,7 @@
 	if (error)
 		goto dev_reg_err;
 	b->bridge = get_device(dev);
+	device_enable_async_suspend(b->bridge);
  
 	if (!parent)
 		set_dev_node(b->bridge, pcibus_to_node(b));
@@ -215,12 +215,16 @@
 		shost->shost_gendev.parent = dev ? dev : &platform_bus;
 	shost->dma_dev = dma_dev;
  
+	device_enable_async_suspend(&shost->shost_gendev);
+
 	error = device_add(&shost->shost_gendev);
 	if (error)
 		goto out;
  
 	scsi_host_set_state(shost, SHOST_RUNNING);
 	get_device(shost->shost_gendev.parent);
+
+	device_enable_async_suspend(&shost->shost_dev);
  
 	error = device_add(&shost->shost_dev);
 	if (error)
@@ -847,6 +847,8 @@
 	if (starget->state != STARGET_CREATED)
 		return 0;
  
+	device_enable_async_suspend(&starget->dev);
+
 	error = device_add(&starget->dev);
 	if (error) {
 		dev_err(&starget->dev, "target device_add failed, error %d\n", error);
  
@@ -887,11 +889,13 @@
 		return error;
  
 	transport_configure_device(&starget->dev);
+	device_enable_async_suspend(&sdev->sdev_gendev);
 	error = device_add(&sdev->sdev_gendev);
 	if (error) {
 		printk(KERN_INFO "error 1\n");
 		return error;
 	}
+	device_enable_async_suspend(&sdev->sdev_dev);
 	error = device_add(&sdev->sdev_dev);
 	if (error) {
 		printk(KERN_INFO "error 2\n");
@@ -1022,6 +1022,14 @@
 		goto done;
 	}
  
+	/* Non-root devices on a full/low-speed bus must wait for their
+	 * companion high-speed root hub, in case a handoff is needed.
+	 */
+	if (!(msg.event & PM_EVENT_AUTO) && udev->parent &&
+			udev->bus->hs_companion)
+		device_pm_wait_for_dev(&udev->dev,
+				&udev->bus->hs_companion->root_hub->dev);
+
 	if (udev->quirks & USB_QUIRK_RESET_RESUME)
 		udev->reset_resume = 1;
  
@@ -186,6 +186,7 @@
 	ep_dev->dev.parent = parent;
 	ep_dev->dev.release = ep_device_release;
 	dev_set_name(&ep_dev->dev, "ep_%02x", endpoint->desc.bEndpointAddress);
+	device_enable_async_suspend(&ep_dev->dev);
  
 	retval = device_register(&ep_dev->dev);
 	if (retval)
@@ -19,6 +19,7 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/pci.h>
+#include <linux/pm_runtime.h>
 #include <linux/usb.h>
  
 #include <asm/io.h>
  
@@ -37,7 +38,123 @@
  
 /* PCI-based HCs are common, but plenty of non-PCI HCs are used too */
  
+#ifdef CONFIG_PM_SLEEP
  
+/* Coordinate handoffs between EHCI and companion controllers
+ * during system resume
+ */
+
+static DEFINE_MUTEX(companions_mutex);
+
+#define CL_UHCI		PCI_CLASS_SERIAL_USB_UHCI
+#define CL_OHCI		PCI_CLASS_SERIAL_USB_OHCI
+#define CL_EHCI		PCI_CLASS_SERIAL_USB_EHCI
+
+enum companion_action {
+	SET_HS_COMPANION, CLEAR_HS_COMPANION, WAIT_FOR_COMPANIONS
+};
+
+static void companion_common(struct pci_dev *pdev, struct usb_hcd *hcd,
+		enum companion_action action)
+{
+	struct pci_dev		*companion;
+	struct usb_hcd		*companion_hcd;
+	unsigned int		slot = PCI_SLOT(pdev->devfn);
+
+	/* Iterate through other PCI functions in the same slot.
+	 * If pdev is OHCI or UHCI then we are looking for EHCI, and
+	 * vice versa.
+	 */
+	companion = NULL;
+	for (;;) {
+		companion = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, companion);
+		if (!companion)
+			break;
+		if (companion->bus != pdev->bus ||
+				PCI_SLOT(companion->devfn) != slot)
+			continue;
+
+		companion_hcd = pci_get_drvdata(companion);
+		if (!companion_hcd)
+			continue;
+
+		/* For SET_HS_COMPANION, store a pointer to the EHCI bus in
+		 * the OHCI/UHCI companion bus structure.
+		 * For CLEAR_HS_COMPANION, clear the pointer to the EHCI bus
+		 * in the OHCI/UHCI companion bus structure.
+		 * For WAIT_FOR_COMPANIONS, wait until the OHCI/UHCI
+		 * companion controllers have fully resumed.
+		 */
+
+		if ((pdev->class == CL_OHCI || pdev->class == CL_UHCI) &&
+				companion->class == CL_EHCI) {
+			/* action must be SET_HS_COMPANION */
+			dev_dbg(&companion->dev, "HS companion for %s\n",
+					dev_name(&pdev->dev));
+			hcd->self.hs_companion = &companion_hcd->self;
+
+		} else if (pdev->class == CL_EHCI &&
+				(companion->class == CL_OHCI ||
+				companion->class == CL_UHCI)) {
+			switch (action) {
+			case SET_HS_COMPANION:
+				dev_dbg(&pdev->dev, "HS companion for %s\n",
+						dev_name(&companion->dev));
+				companion_hcd->self.hs_companion = &hcd->self;
+				break;
+			case CLEAR_HS_COMPANION:
+				companion_hcd->self.hs_companion = NULL;
+				break;
+			case WAIT_FOR_COMPANIONS:
+				device_pm_wait_for_dev(&pdev->dev,
+						&companion->dev);
+				break;
+			}
+		}
+	}
+}
+
+static void set_hs_companion(struct pci_dev *pdev, struct usb_hcd *hcd)
+{
+	mutex_lock(&companions_mutex);
+	dev_set_drvdata(&pdev->dev, hcd);
+	companion_common(pdev, hcd, SET_HS_COMPANION);
+	mutex_unlock(&companions_mutex);
+}
+
+static void clear_hs_companion(struct pci_dev *pdev, struct usb_hcd *hcd)
+{
+	mutex_lock(&companions_mutex);
+	dev_set_drvdata(&pdev->dev, NULL);
+
+	/* If pdev is OHCI or UHCI, just clear its hs_companion pointer */
+	if (pdev->class == CL_OHCI || pdev->class == CL_UHCI)
+		hcd->self.hs_companion = NULL;
+
+	/* Otherwise search for companion buses and clear their pointers */
+	else
+		companion_common(pdev, hcd, CLEAR_HS_COMPANION);
+	mutex_unlock(&companions_mutex);
+}
+
+static void wait_for_companions(struct pci_dev *pdev, struct usb_hcd *hcd)
+{
+	/* Only EHCI controllers need to wait.
+	 * No locking is needed because a controller cannot be resumed
+	 * while one of its companions is getting unbound.
+	 */
+	if (pdev->class == CL_EHCI)
+		companion_common(pdev, hcd, WAIT_FOR_COMPANIONS);
+}
+
+#else /* !CONFIG_PM_SLEEP */
+
+static inline void set_hs_companion(struct pci_dev *d, struct usb_hcd *h) {}
+static inline void clear_hs_companion(struct pci_dev *d, struct usb_hcd *h) {}
+static inline void wait_for_companions(struct pci_dev *d, struct usb_hcd *h) {}
+
+#endif /* !CONFIG_PM_SLEEP */
+
 /*-------------------------------------------------------------------------*/
  
 /* configure so an HC device and id are always provided */
@@ -123,7 +240,7 @@
 		if (region == PCI_ROM_RESOURCE) {
 			dev_dbg(&dev->dev, "no i/o regions available\n");
 			retval = -EBUSY;
-			goto err1;
+			goto err2;
 		}
 	}
  
@@ -132,6 +249,7 @@
 	retval = usb_add_hcd(hcd, dev->irq, IRQF_DISABLED | IRQF_SHARED);
 	if (retval != 0)
 		goto err4;
+	set_hs_companion(dev, hcd);
 	return retval;
  
  err4:
@@ -142,6 +260,7 @@
 	} else
 		release_region(hcd->rsrc_start, hcd->rsrc_len);
  err2:
+	clear_hs_companion(dev, hcd);
 	usb_put_hcd(hcd);
  err1:
 	pci_disable_device(dev);
@@ -180,6 +299,7 @@
 	} else {
 		release_region(hcd->rsrc_start, hcd->rsrc_len);
 	}
+	clear_hs_companion(dev, hcd);
 	usb_put_hcd(hcd);
 	pci_disable_device(dev);
 }
@@ -344,6 +464,11 @@
 	clear_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
  
 	if (hcd->driver->pci_resume) {
+		/* This call should be made only during system resume,
+		 * not during runtime resume.
+		 */
+		wait_for_companions(pci_dev, hcd);
+
 		retval = hcd->driver->pci_resume(hcd, hibernated);
 		if (retval) {
 			dev_err(dev, "PCI post-resume error %d!\n", retval);
@@ -1817,6 +1817,7 @@
 	/* Tell the world! */
 	announce_device(udev);
  
+	device_enable_async_suspend(&udev->dev);
 	/* Register the device.  The device driver is responsible
 	 * for configuring the device and invoking the add-device
 	 * notifier chain (used by usbfs and possibly others).
@@ -1867,6 +1867,7 @@
 			"adding %s (config #%d, interface %d)\n",
 			dev_name(&intf->dev), configuration,
 			intf->cur_altsetting->desc.bInterfaceNumber);
+		device_enable_async_suspend(&intf->dev);
 		ret = device_add(&intf->dev);
 		if (ret != 0) {
 			dev_err(&dev->dev, "device_add(%s) --> %d\n",
@@ -472,6 +472,23 @@
 	return dev->kobj.state_in_sysfs;
 }
  
+static inline void device_enable_async_suspend(struct device *dev)
+{
+	if (dev->power.status == DPM_ON)
+		dev->power.async_suspend = true;
+}
+
+static inline void device_disable_async_suspend(struct device *dev)
+{
+	if (dev->power.status == DPM_ON)
+		dev->power.async_suspend = false;
+}
+
+static inline bool device_async_suspend_enabled(struct device *dev)
+{
+	return !!dev->power.async_suspend;
+}
+
 void driver_init(void);
  
 /*
@@ -26,6 +26,7 @@
 #include <linux/spinlock.h>
 #include <linux/wait.h>
 #include <linux/timer.h>
+#include <linux/completion.h>
  
 /*
  * Callbacks for platform drivers to implement.
  
@@ -412,9 +413,11 @@
 	pm_message_t		power_state;
 	unsigned int		can_wakeup:1;
 	unsigned int		should_wakeup:1;
+	unsigned		async_suspend:1;
 	enum dpm_state		status;		/* Owned by the PM core */
 #ifdef CONFIG_PM_SLEEP
 	struct list_head	entry;
+	struct completion	completion;
 #endif
 #ifdef CONFIG_PM_RUNTIME
 	struct timer_list	suspend_timer;
@@ -430,6 +433,7 @@
 	unsigned int		request_pending:1;
 	unsigned int		deferred_resume:1;
 	unsigned int		run_wake:1;
+	unsigned int		runtime_auto:1;
 	enum rpm_request	request;
 	enum rpm_status		runtime_status;
 	int			runtime_error;
@@ -508,6 +512,7 @@
 		__suspend_report_result(__func__, fn, ret);		\
 	} while (0)
  
+extern void device_pm_wait_for_dev(struct device *sub, struct device *dev);
 #else /* !CONFIG_PM_SLEEP */
  
 #define device_pm_lock() do {} while (0)
@@ -520,6 +525,7 @@
  
 #define suspend_report_result(fn, ret)		do {} while (0)
  
+static inline void device_pm_wait_for_dev(struct device *a, struct device *b) {}
 #endif /* !CONFIG_PM_SLEEP */
  
 /* How to reorder dpm_list after device_move() */
@@ -28,6 +28,8 @@
 extern int pm_runtime_barrier(struct device *dev);
 extern void pm_runtime_enable(struct device *dev);
 extern void __pm_runtime_disable(struct device *dev, bool check_resume);
+extern void pm_runtime_allow(struct device *dev);
+extern void pm_runtime_forbid(struct device *dev);
  
 static inline bool pm_children_suspended(struct device *dev)
 {
@@ -78,6 +80,8 @@
 static inline int pm_runtime_barrier(struct device *dev) { return 0; }
 static inline void pm_runtime_enable(struct device *dev) {}
 static inline void __pm_runtime_disable(struct device *dev, bool c) {}
+static inline void pm_runtime_allow(struct device *dev) {}
+static inline void pm_runtime_forbid(struct device *dev) {}
  
 static inline bool pm_children_suspended(struct device *dev) { return false; }
 static inline void pm_suspend_ignore_children(struct device *dev, bool en) {}
@@ -6,6 +6,11 @@
  
 extern int pm_trace_enabled;
  
+static inline int pm_trace_is_enabled(void)
+{
+       return pm_trace_enabled;
+}
+
 struct device;
 extern void set_trace_device(struct device *);
 extern void generate_resume_trace(const void *tracedata, unsigned int user);
@@ -16,6 +21,8 @@
 	} while(0)
  
 #else
+
+static inline int pm_trace_is_enabled(void) { return 0; }
  
 #define TRACE_DEVICE(dev) do { } while (0)
 #define TRACE_RESUME(dev) do { } while (0)
@@ -339,6 +339,7 @@
  
 	struct usb_devmap devmap;	/* device address allocation map */
 	struct usb_device *root_hub;	/* Root hub */
+	struct usb_bus *hs_companion;	/* Companion EHCI bus, if any */
 	struct list_head bus_list;	/* list of busses */
  
 	int bandwidth_allocated;	/* on this bus: how much of the time
@@ -27,6 +27,15 @@
 	code. This is helpful when debugging and reporting PM bugs, like
 	suspend support.
  
+config PM_ADVANCED_DEBUG
+	bool "Extra PM attributes in sysfs for low-level debugging/testing"
+	depends on PM_DEBUG
+	default n
+	---help---
+	Add extra sysfs attributes allowing one to access some Power Management
+	fields of device objects from user space.  If you are not a kernel
+	developer interested in debugging/testing Power Management, say "no".
+
 config PM_VERBOSE
 	bool "Verbose Power Management debugging"
 	depends on PM_DEBUG
@@ -84,6 +93,11 @@
 	bool
 	depends on SUSPEND || HIBERNATION || XEN_SAVE_RESTORE
 	default y
+
+config PM_SLEEP_ADVANCED_DEBUG
+	bool
+	depends on PM_ADVANCED_DEBUG
+	default n
  
 config SUSPEND
 	bool "Suspend to RAM and standby"
@@ -44,6 +44,32 @@
 			== NOTIFY_BAD) ? -EINVAL : 0;
 }
  
+/* If set, devices may be suspended and resumed asynchronously. */
+int pm_async_enabled = 1;
+
+static ssize_t pm_async_show(struct kobject *kobj, struct kobj_attribute *attr,
+			     char *buf)
+{
+	return sprintf(buf, "%d\n", pm_async_enabled);
+}
+
+static ssize_t pm_async_store(struct kobject *kobj, struct kobj_attribute *attr,
+			      const char *buf, size_t n)
+{
+	unsigned long val;
+
+	if (strict_strtoul(buf, 10, &val))
+		return -EINVAL;
+
+	if (val > 1)
+		return -EINVAL;
+
+	pm_async_enabled = val;
+	return n;
+}
+
+power_attr(pm_async);
+
 #ifdef CONFIG_PM_DEBUG
 int pm_test_level = TEST_NONE;
  
  
@@ -208,8 +234,11 @@
 #ifdef CONFIG_PM_TRACE
 	&pm_trace_attr.attr,
 #endif
-#if defined(CONFIG_PM_SLEEP) && defined(CONFIG_PM_DEBUG)
+#ifdef CONFIG_PM_SLEEP
+	&pm_async_attr.attr,
+#ifdef CONFIG_PM_DEBUG
 	&pm_test_attr.attr,
+#endif
 #endif
 	NULL,
 };
@@ -1181,7 +1181,7 @@
  
 	memory_bm_position_reset(&copy_bm);
  
-	while (to_free_normal > 0 && to_free_highmem > 0) {
+	while (to_free_normal > 0 || to_free_highmem > 0) {
 		unsigned long pfn = memory_bm_next_pfn(&copy_bm);
 		struct page *page = pfn_to_page(pfn);
  
@@ -1500,7 +1500,7 @@
 {
 	unsigned int nr_pages, nr_highmem;
  
-	printk(KERN_INFO "PM: Creating hibernation image: \n");
+	printk(KERN_INFO "PM: Creating hibernation image:\n");
  
 	drain_local_pages(NULL);
 	nr_pages = count_data_pages();
@@ -657,10 +657,6 @@
 	struct swsusp_info *header;
  
 	*flags_p = swsusp_header->flags;
-	if (IS_ERR(resume_bdev)) {
-		pr_debug("PM: Image device not initialised\n");
-		return PTR_ERR(resume_bdev);
-	}
  
 	memset(&snapshot, 0, sizeof(struct snapshot_handle));
 	error = snapshot_write_next(&snapshot, PAGE_SIZE);
-/*
- * linux/kernel/power/swsusp.c
- *
- * This file provides code to write suspend image to swap and read it back.
- *
- * Copyright (C) 1998-2001 Gabor Kuti <seasons@fornax.hu>
- * Copyright (C) 1998,2001-2005 Pavel Machek <pavel@suse.cz>
- *
- * This file is released under the GPLv2.
- *
- * I'd like to thank the following people for their work:
- *
- * Pavel Machek <pavel@ucw.cz>:
- * Modifications, defectiveness pointing, being with me at the very beginning,
- * suspend to swap space, stop all tasks. Port to 2.4.18-ac and 2.5.17.
- *
- * Steve Doddi <dirk@loth.demon.co.uk>:
- * Support the possibility of hardware state restoring.
- *
- * Raph <grey.havens@earthling.net>:
- * Support for preserving states of network devices and virtual console
- * (including X and svgatextmode)
- *
- * Kurt Garloff <garloff@suse.de>:
- * Straightened the critical function in order to prevent compilers from
- * playing tricks with local variables.
- *
- * Andreas Mohr <a.mohr@mailto.de>
- *
- * Alex Badea <vampire@go.ro>:
- * Fixed runaway init
- *
- * Rafael J. Wysocki <rjw@sisk.pl>
- * Reworked the freeing of memory and the handling of swap
- *
- * More state savers are welcome. Especially for the scsi layer...
- *
- * For TODOs,FIXMEs also look in Documentation/power/swsusp.txt
- */
-
-#include <linux/mm.h>
-#include <linux/suspend.h>
-#include <linux/spinlock.h>
-#include <linux/kernel.h>
-#include <linux/major.h>
-#include <linux/swap.h>
-#include <linux/pm.h>
-#include <linux/swapops.h>
-#include <linux/bootmem.h>
-#include <linux/syscalls.h>
-#include <linux/highmem.h>
-#include <linux/time.h>
-#include <linux/rbtree.h>
-#include <linux/io.h>
-
-#include "power.h"
-
-int in_suspend __nosavedata = 0;
@@ -195,6 +195,15 @@
 	return res;
 }
  
+static void snapshot_deprecated_ioctl(unsigned int cmd)
+{
+	if (printk_ratelimit())
+		printk(KERN_NOTICE "%pf: ioctl '%.8x' is deprecated and will "
+				"be removed soon, update your suspend-to-disk "
+				"utilities\n",
+				__builtin_return_address(0), cmd);
+}
+
 static long snapshot_ioctl(struct file *filp, unsigned int cmd,
 							unsigned long arg)
 {
  
@@ -246,8 +255,9 @@
 		data->frozen = 0;
 		break;
  
-	case SNAPSHOT_CREATE_IMAGE:
 	case SNAPSHOT_ATOMIC_SNAPSHOT:
+		snapshot_deprecated_ioctl(cmd);
+	case SNAPSHOT_CREATE_IMAGE:
 		if (data->mode != O_RDONLY || !data->frozen  || data->ready) {
 			error = -EPERM;
 			break;
  
@@ -275,8 +285,9 @@
 		data->ready = 0;
 		break;
  
-	case SNAPSHOT_PREF_IMAGE_SIZE:
 	case SNAPSHOT_SET_IMAGE_SIZE:
+		snapshot_deprecated_ioctl(cmd);
+	case SNAPSHOT_PREF_IMAGE_SIZE:
 		image_size = arg;
 		break;
  
  
  
  
@@ -290,15 +301,17 @@
 		error = put_user(size, (loff_t __user *)arg);
 		break;
  
-	case SNAPSHOT_AVAIL_SWAP_SIZE:
 	case SNAPSHOT_AVAIL_SWAP:
+		snapshot_deprecated_ioctl(cmd);
+	case SNAPSHOT_AVAIL_SWAP_SIZE:
 		size = count_swap_pages(data->swap, 1);
 		size <<= PAGE_SHIFT;
 		error = put_user(size, (loff_t __user *)arg);
 		break;
  
-	case SNAPSHOT_ALLOC_SWAP_PAGE:
 	case SNAPSHOT_GET_SWAP_PAGE:
+		snapshot_deprecated_ioctl(cmd);
+	case SNAPSHOT_ALLOC_SWAP_PAGE:
 		if (data->swap < 0 || data->swap >= MAX_SWAPFILES) {
 			error = -ENODEV;
 			break;
@@ -321,6 +334,7 @@
 		break;
  
 	case SNAPSHOT_SET_SWAP_FILE: /* This ioctl is deprecated */
+		snapshot_deprecated_ioctl(cmd);
 		if (!swsusp_swap_in_use()) {
 			/*
 			 * User space encodes device types as two-byte values,
@@ -362,6 +376,7 @@
 		break;
  
 	case SNAPSHOT_PMOPS: /* This ioctl is deprecated */
+		snapshot_deprecated_ioctl(cmd);
 		error = -EINVAL;
  
 		switch (arg) {
	1	+What: /sys/devices/.../power/
	2	+Date: January 2009
	3	+Contact: Rafael J. Wysocki <rjw@sisk.pl>
	4	+Description:
	5	+ The /sys/devices/.../power directory contains attributes
	6	+ allowing the user space to check and modify some power
	7	+ management related properties of given device.
	8	+
	9	+What: /sys/devices/.../power/wakeup
	10	+Date: January 2009
	11	+Contact: Rafael J. Wysocki <rjw@sisk.pl>
	12	+Description:
	13	+ The /sys/devices/.../power/wakeup attribute allows the user
	14	+ space to check if the device is enabled to wake up the system
	15	+ from sleep states, such as the memory sleep state (suspend to
	16	+ RAM) and hibernation (suspend to disk), and to enable or disable
	17	+ it to do that as desired.
	18	+
	19	+ Some devices support "wakeup" events, which are hardware signals
	20	+ used to activate the system from a sleep state. Such devices
	21	+ have one of the following two values for the sysfs power/wakeup
	22	+ file:
	23	+
	24	+ + "enabled\n" to issue the events;
	25	+ + "disabled\n" not to do so;
	26	+
	27	+ In that cases the user space can change the setting represented
	28	+ by the contents of this file by writing either "enabled", or
	29	+ "disabled" to it.
	30	+
	31	+ For the devices that are not capable of generating system wakeup
	32	+ events this file contains "\n". In that cases the user space
	33	+ cannot modify the contents of this file and the device cannot be
	34	+ enabled to wake up the system.
	35	+
	36	+What: /sys/devices/.../power/control
	37	+Date: January 2009
	38	+Contact: Rafael J. Wysocki <rjw@sisk.pl>
	39	+Description:
	40	+ The /sys/devices/.../power/control attribute allows the user
	41	+ space to control the run-time power management of the device.
	42	+
	43	+ All devices have one of the following two values for the
	44	+ power/control file:
	45	+
	46	+ + "auto\n" to allow the device to be power managed at run time;
	47	+ + "on\n" to prevent the device from being power managed;
	48	+
	49	+ The default for all devices is "auto", which means that they may
	50	+ be subject to automatic power management, depending on their
	51	+ drivers. Changing this attribute to "on" prevents the driver
	52	+ from power managing the device at run time. Doing that while
	53	+ the device is suspended causes it to be woken up.
	54	+
	55	+What: /sys/devices/.../power/async
	56	+Date: January 2009
	57	+Contact: Rafael J. Wysocki <rjw@sisk.pl>
	58	+Description:
	59	+ The /sys/devices/.../async attribute allows the user space to
	60	+ enable or diasble the device's suspend and resume callbacks to
	61	+ be executed asynchronously (ie. in separate threads, in parallel
	62	+ with the main suspend/resume thread) during system-wide power
	63	+ transitions (eg. suspend to RAM, hibernation).
	64	+
	65	+ All devices have one of the following two values for the
	66	+ power/async file:
	67	+
	68	+ + "enabled\n" to permit the asynchronous suspend/resume;
	69	+ + "disabled\n" to forbid it;
	70	+
	71	+ The value of this attribute may be changed by writing either
	72	+ "enabled", or "disabled" to it.
	73	+
	74	+ It generally is unsafe to permit the asynchronous suspend/resume
	75	+ of a device unless it is certain that all of the PM dependencies
	76	+ of the device are known to the PM core. However, for some
	77	+ devices this attribute is set to "enabled" by bus type code or
	78	+ device drivers and in that cases it should be safe to leave the
	79	+ default value.
...	...	@@ -101,4 +101,17 @@
101	101
102	102	CAUTION: Using it will cause your machine's real-time (CMOS)
103	103	clock to be set to a random invalid time after a resume.
	104	+
	105	+What: /sys/power/pm_async
	106	+Date: January 2009
	107	+Contact: Rafael J. Wysocki <rjw@sisk.pl>
	108	+Description:
	109	+ The /sys/power/pm_async file controls the switch allowing the
	110	+ user space to enable or disable asynchronous suspend and resume
	111	+ of devices. If enabled, this feature will cause some device
	112	+ drivers' suspend and resume callbacks to be executed in parallel
	113	+ with each other and with the main suspend thread. It is enabled
	114	+ if this file contains "1", which is the default. It may be
	115	+ disabled by writing "0" to this file, in which case all devices
	116	+ will be suspended and resumed synchronously.
...	...	@@ -64,6 +64,17 @@
64	64
65	65	---------------------------
66	66
	67	+What: Deprecated snapshot ioctls
	68	+When: 2.6.36
	69	+
	70	+Why: The ioctls in kernel/power/user.c were marked as deprecated long time
	71	+ ago. Now they notify users about that so that they need to replace
	72	+ their userspace. After some more time, remove them completely.
	73	+
	74	+Who: Jiri Slaby <jirislaby@gmail.com>
	75	+
	76	+---------------------------
	77	+
67	78	What: The ieee80211_regdom module parameter
68	79	When: March 2010 / desktop catchup
69	80
...	...	@@ -25,6 +25,7 @@
25	25	#include <linux/resume-trace.h>
26	26	#include <linux/interrupt.h>
27	27	#include <linux/sched.h>
	28	+#include <linux/async.h>
28	29
29	30	#include "../base.h"
30	31	#include "power.h"
...	...	@@ -42,6 +43,7 @@
42	43	LIST_HEAD(dpm_list);
43	44
44	45	static DEFINE_MUTEX(dpm_list_mtx);
	46	+static pm_message_t pm_transition;
45	47
46	48	/*
47	49	* Set once the preparation of devices for a PM transition has started, reset
...	...	@@ -56,6 +58,7 @@
56	58	void device_pm_init(struct device *dev)
57	59	{
58	60	dev->power.status = DPM_ON;
	61	+ init_completion(&dev->power.completion);
59	62	pm_runtime_init(dev);
60	63	}
61	64
...	...	@@ -111,6 +114,7 @@
111	114	pr_debug("PM: Removing info for %s:%s\n",
112	115	dev->bus ? dev->bus->name : "No Bus",
113	116	kobject_name(&dev->kobj));
	117	+ complete_all(&dev->power.completion);
114	118	mutex_lock(&dpm_list_mtx);
115	119	list_del_init(&dev->power.entry);
116	120	mutex_unlock(&dpm_list_mtx);
...	...	@@ -188,6 +192,31 @@
188	192	}
189	193
190	194	/**
	195	+ * dpm_wait - Wait for a PM operation to complete.
	196	+ * @dev: Device to wait for.
	197	+ * @async: If unset, wait only if the device's power.async_suspend flag is set.
	198	+ */
	199	+static void dpm_wait(struct device *dev, bool async)
	200	+{
	201	+ if (!dev)
	202	+ return;
	203	+
	204	+ if (async \|\| (pm_async_enabled && dev->power.async_suspend))
	205	+ wait_for_completion(&dev->power.completion);
	206	+}
	207	+
	208	+static int dpm_wait_fn(struct device dev, void async_ptr)
	209	+{
	210	+ dpm_wait(dev, ((bool )async_ptr));
	211	+ return 0;
	212	+}
	213	+
	214	+static void dpm_wait_for_children(struct device *dev, bool async)
	215	+{
	216	+ device_for_each_child(dev, &async, dpm_wait_fn);
	217	+}
	218	+
	219	+/**
191	220	* pm_op - Execute the PM operation appropriate for given PM event.
192	221	* @dev: Device to handle.
193	222	* @ops: PM operations to choose from.
...	...	@@ -271,8 +300,9 @@
271	300	ktime_t calltime, delta, rettime;
272	301
273	302	if (initcall_debug) {
274		- pr_info("calling %s_i+ @ %i\n",
275		- dev_name(dev), task_pid_nr(current));
	303	+ pr_info("calling %s+ @ %i, parent: %s\n",
	304	+ dev_name(dev), task_pid_nr(current),
	305	+ dev->parent ? dev_name(dev->parent) : "none");
276	306	calltime = ktime_get();
277	307	}
278	308
279	309
280	310
281	311
...	...	@@ -468,16 +498,20 @@
468	498	* device_resume - Execute "resume" callbacks for given device.
469	499	* @dev: Device to handle.
470	500	* @state: PM transition of the system being carried out.
	501	+ * @async: If true, the device is being resumed asynchronously.
471	502	*/
472		-static int device_resume(struct device *dev, pm_message_t state)
	503	+static int device_resume(struct device *dev, pm_message_t state, bool async)
473	504	{
474	505	int error = 0;
475	506
476	507	TRACE_DEVICE(dev);
477	508	TRACE_RESUME(0);
478	509
	510	+ dpm_wait(dev->parent, async);
479	511	down(&dev->sem);
480	512
	513	+ dev->power.status = DPM_RESUMING;
	514	+
481	515	if (dev->bus) {
482	516	if (dev->bus->pm) {
483	517	pm_dev_dbg(dev, state, "");
484	518
...	...	@@ -510,11 +544,29 @@
510	544	}
511	545	End:
512	546	up(&dev->sem);
	547	+ complete_all(&dev->power.completion);
513	548
514	549	TRACE_RESUME(error);
515	550	return error;
516	551	}
517	552
	553	+static void async_resume(void *data, async_cookie_t cookie)
	554	+{
	555	+ struct device dev = (struct device )data;
	556	+ int error;
	557	+
	558	+ error = device_resume(dev, pm_transition, true);
	559	+ if (error)
	560	+ pm_dev_err(dev, pm_transition, " async", error);
	561	+ put_device(dev);
	562	+}
	563	+
	564	+static bool is_async(struct device *dev)
	565	+{
	566	+ return dev->power.async_suspend && pm_async_enabled
	567	+ && !pm_trace_is_enabled();
	568	+}
	569	+
518	570	/**
519	571	* dpm_resume - Execute "resume" callbacks for non-sysdev devices.
520	572	* @state: PM transition of the system being carried out.
521	573
522	574
523	575
524	576
525	577
...	...	@@ -525,21 +577,33 @@
525	577	static void dpm_resume(pm_message_t state)
526	578	{
527	579	struct list_head list;
	580	+ struct device *dev;
528	581	ktime_t starttime = ktime_get();
529	582
530	583	INIT_LIST_HEAD(&list);
531	584	mutex_lock(&dpm_list_mtx);
532		- while (!list_empty(&dpm_list)) {
533		- struct device *dev = to_device(dpm_list.next);
	585	+ pm_transition = state;
534	586
	587	+ list_for_each_entry(dev, &dpm_list, power.entry) {
	588	+ if (dev->power.status < DPM_OFF)
	589	+ continue;
	590	+
	591	+ INIT_COMPLETION(dev->power.completion);
	592	+ if (is_async(dev)) {
	593	+ get_device(dev);
	594	+ async_schedule(async_resume, dev);
	595	+ }
	596	+ }
	597	+
	598	+ while (!list_empty(&dpm_list)) {
	599	+ dev = to_device(dpm_list.next);
535	600	get_device(dev);
536		- if (dev->power.status >= DPM_OFF) {
	601	+ if (dev->power.status >= DPM_OFF && !is_async(dev)) {
537	602	int error;
538	603
539		- dev->power.status = DPM_RESUMING;
540	604	mutex_unlock(&dpm_list_mtx);
541	605
542		- error = device_resume(dev, state);
	606	+ error = device_resume(dev, state, false);
543	607
544	608	mutex_lock(&dpm_list_mtx);
545	609	if (error)
...	...	@@ -554,6 +618,7 @@
554	618	}
555	619	list_splice(&list, &dpm_list);
556	620	mutex_unlock(&dpm_list_mtx);
	621	+ async_synchronize_full();
557	622	dpm_show_time(starttime, state, NULL);
558	623	}
559	624
560	625
561	626
562	627
563	628
...	...	@@ -731,17 +796,24 @@
731	796	return error;
732	797	}
733	798
	799	+static int async_error;
	800	+
734	801	/**
735	802	* device_suspend - Execute "suspend" callbacks for given device.
736	803	* @dev: Device to handle.
737	804	* @state: PM transition of the system being carried out.
	805	+ * @async: If true, the device is being suspended asynchronously.
738	806	*/
739		-static int device_suspend(struct device *dev, pm_message_t state)
	807	+static int __device_suspend(struct device *dev, pm_message_t state, bool async)
740	808	{
741	809	int error = 0;
742	810
	811	+ dpm_wait_for_children(dev, async);
743	812	down(&dev->sem);
744	813
	814	+ if (async_error)
	815	+ goto End;
	816	+
745	817	if (dev->class) {
746	818	if (dev->class->pm) {
747	819	pm_dev_dbg(dev, state, "class ");
748	820
749	821
...	...	@@ -772,12 +844,44 @@
772	844	error = legacy_suspend(dev, state, dev->bus->suspend);
773	845	}
774	846	}
	847	+
	848	+ if (!error)
	849	+ dev->power.status = DPM_OFF;
	850	+
775	851	End:
776	852	up(&dev->sem);
	853	+ complete_all(&dev->power.completion);
777	854
778	855	return error;
779	856	}
780	857
	858	+static void async_suspend(void *data, async_cookie_t cookie)
	859	+{
	860	+ struct device dev = (struct device )data;
	861	+ int error;
	862	+
	863	+ error = __device_suspend(dev, pm_transition, true);
	864	+ if (error) {
	865	+ pm_dev_err(dev, pm_transition, " async", error);
	866	+ async_error = error;
	867	+ }
	868	+
	869	+ put_device(dev);
	870	+}
	871	+
	872	+static int device_suspend(struct device *dev)
	873	+{
	874	+ INIT_COMPLETION(dev->power.completion);
	875	+
	876	+ if (pm_async_enabled && dev->power.async_suspend) {
	877	+ get_device(dev);
	878	+ async_schedule(async_suspend, dev);
	879	+ return 0;
	880	+ }
	881	+
	882	+ return __device_suspend(dev, pm_transition, false);
	883	+}
	884	+
781	885	/**
782	886	* dpm_suspend - Execute "suspend" callbacks for all non-sysdev devices.
783	887	* @state: PM transition of the system being carried out.
784	888
...	...	@@ -790,13 +894,15 @@
790	894
791	895	INIT_LIST_HEAD(&list);
792	896	mutex_lock(&dpm_list_mtx);
	897	+ pm_transition = state;
	898	+ async_error = 0;
793	899	while (!list_empty(&dpm_list)) {
794	900	struct device *dev = to_device(dpm_list.prev);
795	901
796	902	get_device(dev);
797	903	mutex_unlock(&dpm_list_mtx);
798	904
799		- error = device_suspend(dev, state);
	905	+ error = device_suspend(dev);
800	906
801	907	mutex_lock(&dpm_list_mtx);
802	908	if (error) {
803	909
804	910
805	911
...	...	@@ -804,14 +910,18 @@
804	910	put_device(dev);
805	911	break;
806	912	}
807		- dev->power.status = DPM_OFF;
808	913	if (!list_empty(&dev->power.entry))
809	914	list_move(&dev->power.entry, &list);
810	915	put_device(dev);
	916	+ if (async_error)
	917	+ break;
811	918	}
812	919	list_splice(&list, dpm_list.prev);
813	920	mutex_unlock(&dpm_list_mtx);
	921	+ async_synchronize_full();
814	922	if (!error)
	923	+ error = async_error;
	924	+ if (!error)
815	925	dpm_show_time(starttime, state, NULL);
816	926	return error;
817	927	}
...	...	@@ -936,4 +1046,15 @@
936	1046	printk(KERN_ERR "%s(): %pF returns %d\n", function, fn, ret);
937	1047	}
938	1048	EXPORT_SYMBOL_GPL(__suspend_report_result);
	1049	+
	1050	+/**
	1051	+ * device_pm_wait_for_dev - Wait for suspend/resume of a device to complete.
	1052	+ * @dev: Device to wait for.
	1053	+ * @subordinate: Device that needs to wait for @dev.
	1054	+ */
	1055	+void device_pm_wait_for_dev(struct device subordinate, struct device dev)
	1056	+{
	1057	+ dpm_wait(dev, subordinate->power.async_suspend);
	1058	+}
	1059	+EXPORT_SYMBOL_GPL(device_pm_wait_for_dev);
...	...	@@ -12,10 +12,10 @@
12	12
13	13	#ifdef CONFIG_PM_SLEEP
14	14
15		-/*
16		- * main.c
17		- */
	15	+/* kernel/power/main.c */
	16	+extern int pm_async_enabled;
18	17
	18	+/* drivers/base/power/main.c */
19	19	extern struct list_head dpm_list; /* The active device list */
20	20
21	21	static inline struct device to_device(struct list_head entry)
...	...	@@ -1011,6 +1011,50 @@
1011	1011	EXPORT_SYMBOL_GPL(pm_runtime_enable);
1012	1012
1013	1013	/**
	1014	+ * pm_runtime_forbid - Block run-time PM of a device.
	1015	+ * @dev: Device to handle.
	1016	+ *
	1017	+ * Increase the device's usage count and clear its power.runtime_auto flag,
	1018	+ * so that it cannot be suspended at run time until pm_runtime_allow() is called
	1019	+ * for it.
	1020	+ */
	1021	+void pm_runtime_forbid(struct device *dev)
	1022	+{
	1023	+ spin_lock_irq(&dev->power.lock);
	1024	+ if (!dev->power.runtime_auto)
	1025	+ goto out;
	1026	+
	1027	+ dev->power.runtime_auto = false;
	1028	+ atomic_inc(&dev->power.usage_count);
	1029	+ __pm_runtime_resume(dev, false);
	1030	+
	1031	+ out:
	1032	+ spin_unlock_irq(&dev->power.lock);
	1033	+}
	1034	+EXPORT_SYMBOL_GPL(pm_runtime_forbid);
	1035	+
	1036	+/**
	1037	+ * pm_runtime_allow - Unblock run-time PM of a device.
	1038	+ * @dev: Device to handle.
	1039	+ *
	1040	+ * Decrease the device's usage count and set its power.runtime_auto flag.
	1041	+ */
	1042	+void pm_runtime_allow(struct device *dev)
	1043	+{
	1044	+ spin_lock_irq(&dev->power.lock);
	1045	+ if (dev->power.runtime_auto)
	1046	+ goto out;
	1047	+
	1048	+ dev->power.runtime_auto = true;
	1049	+ if (atomic_dec_and_test(&dev->power.usage_count))
	1050	+ __pm_runtime_idle(dev);
	1051	+
	1052	+ out:
	1053	+ spin_unlock_irq(&dev->power.lock);
	1054	+}
	1055	+EXPORT_SYMBOL_GPL(pm_runtime_allow);
	1056	+
	1057	+/**
1014	1058	* pm_runtime_init - Initialize run-time PM fields in given device object.
1015	1059	* @dev: Device object to initialize.
1016	1060	*/
...	...	@@ -1028,6 +1072,7 @@
1028	1072
1029	1073	atomic_set(&dev->power.child_count, 0);
1030	1074	pm_suspend_ignore_children(dev, false);
	1075	+ dev->power.runtime_auto = true;
1031	1076
1032	1077	dev->power.request_pending = false;
1033	1078	dev->power.request = RPM_REQ_NONE;
...	...	@@ -4,9 +4,25 @@
4	4
5	5	#include <linux/device.h>
6	6	#include <linux/string.h>
	7	+#include <linux/pm_runtime.h>
7	8	#include "power.h"
8	9
9	10	/*
	11	+ * control - Report/change current runtime PM setting of the device
	12	+ *
	13	+ * Runtime power management of a device can be blocked with the help of
	14	+ * this attribute. All devices have one of the following two values for
	15	+ * the power/control file:
	16	+ *
	17	+ * + "auto\n" to allow the device to be power managed at run time;
	18	+ * + "on\n" to prevent the device from being power managed at run time;
	19	+ *
	20	+ * The default for all devices is "auto", which means that devices may be
	21	+ * subject to automatic power management, depending on their drivers.
	22	+ * Changing this attribute to "on" prevents the driver from power managing
	23	+ * the device at run time. Doing that while the device is suspended causes
	24	+ * it to be woken up.
	25	+ *
10	26	* wakeup - Report/change current wakeup option for device
11	27	*
12	28	* Some devices support "wakeup" events, which are hardware signals
13	29
...	...	@@ -38,11 +54,61 @@
38	54	* wakeup events internally (unless they are disabled), keeping
39	55	* their hardware in low power modes whenever they're unused. This
40	56	* saves runtime power, without requiring system-wide sleep states.
	57	+ *
	58	+ * async - Report/change current async suspend setting for the device
	59	+ *
	60	+ * Asynchronous suspend and resume of the device during system-wide power
	61	+ * state transitions can be enabled by writing "enabled" to this file.
	62	+ * Analogously, if "disabled" is written to this file, the device will be
	63	+ * suspended and resumed synchronously.
	64	+ *
	65	+ * All devices have one of the following two values for power/async:
	66	+ *
	67	+ * + "enabled\n" to permit the asynchronous suspend/resume of the device;
	68	+ * + "disabled\n" to forbid it;
	69	+ *
	70	+ * NOTE: It generally is unsafe to permit the asynchronous suspend/resume
	71	+ * of a device unless it is certain that all of the PM dependencies of the
	72	+ * device are known to the PM core. However, for some devices this
	73	+ * attribute is set to "enabled" by bus type code or device drivers and in
	74	+ * that cases it should be safe to leave the default value.
41	75	*/
42	76
43	77	static const char enabled[] = "enabled";
44	78	static const char disabled[] = "disabled";
45	79
	80	+#ifdef CONFIG_PM_RUNTIME
	81	+static const char ctrl_auto[] = "auto";
	82	+static const char ctrl_on[] = "on";
	83	+
	84	+static ssize_t control_show(struct device dev, struct device_attribute attr,
	85	+ char *buf)
	86	+{
	87	+ return sprintf(buf, "%s\n",
	88	+ dev->power.runtime_auto ? ctrl_auto : ctrl_on);
	89	+}
	90	+
	91	+static ssize_t control_store(struct device * dev, struct device_attribute *attr,
	92	+ const char * buf, size_t n)
	93	+{
	94	+ char *cp;
	95	+ int len = n;
	96	+
	97	+ cp = memchr(buf, '\n', n);
	98	+ if (cp)
	99	+ len = cp - buf;
	100	+ if (len == sizeof ctrl_auto - 1 && strncmp(buf, ctrl_auto, len) == 0)
	101	+ pm_runtime_allow(dev);
	102	+ else if (len == sizeof ctrl_on - 1 && strncmp(buf, ctrl_on, len) == 0)
	103	+ pm_runtime_forbid(dev);
	104	+ else
	105	+ return -EINVAL;
	106	+ return n;
	107	+}
	108	+
	109	+static DEVICE_ATTR(control, 0644, control_show, control_store);
	110	+#endif
	111	+
46	112	static ssize_t
47	113	wake_show(struct device * dev, struct device_attribute attr, char buf)
48	114	{
49	115
50	116
51	117
...	...	@@ -77,9 +143,43 @@
77	143
78	144	static DEVICE_ATTR(wakeup, 0644, wake_show, wake_store);
79	145
	146	+#ifdef CONFIG_PM_SLEEP_ADVANCED_DEBUG
	147	+static ssize_t async_show(struct device dev, struct device_attribute attr,
	148	+ char *buf)
	149	+{
	150	+ return sprintf(buf, "%s\n",
	151	+ device_async_suspend_enabled(dev) ? enabled : disabled);
	152	+}
80	153
	154	+static ssize_t async_store(struct device dev, struct device_attribute attr,
	155	+ const char *buf, size_t n)
	156	+{
	157	+ char *cp;
	158	+ int len = n;
	159	+
	160	+ cp = memchr(buf, '\n', n);
	161	+ if (cp)
	162	+ len = cp - buf;
	163	+ if (len == sizeof enabled - 1 && strncmp(buf, enabled, len) == 0)
	164	+ device_enable_async_suspend(dev);
	165	+ else if (len == sizeof disabled - 1 && strncmp(buf, disabled, len) == 0)
	166	+ device_disable_async_suspend(dev);
	167	+ else
	168	+ return -EINVAL;
	169	+ return n;
	170	+}
	171	+
	172	+static DEVICE_ATTR(async, 0644, async_show, async_store);
	173	+#endif /* CONFIG_PM_SLEEP_ADVANCED_DEBUG */
	174	+
81	175	static struct attribute * power_attrs[] = {
	176	+#ifdef CONFIG_PM_RUNTIME
	177	+ &dev_attr_control.attr,
	178	+#endif
82	179	&dev_attr_wakeup.attr,
	180	+#ifdef CONFIG_PM_SLEEP_ADVANCED_DEBUG
	181	+ &dev_attr_async.attr,
	182	+#endif
83	183	NULL,
84	184	};
85	185	static struct attribute_group pm_attr_group = {
...	...	@@ -1540,6 +1540,7 @@
1540	1540	int pm;
1541	1541	u16 pmc;
1542	1542
	1543	+ device_enable_async_suspend(&dev->dev);
1543	1544	dev->wakeup_prepared = false;
1544	1545	dev->pm_cap = 0;
1545	1546
...	...	@@ -285,6 +285,7 @@
285	285	pci_name(pdev),
286	286	get_descriptor_id(pdev->pcie_type, service));
287	287	device->parent = &pdev->dev;
	288	+ device_enable_async_suspend(device);
288	289
289	290	retval = device_register(device);
290	291	if (retval)
...	...	@@ -1436,6 +1436,7 @@
1436	1436	if (error)
1437	1437	goto dev_reg_err;
1438	1438	b->bridge = get_device(dev);
	1439	+ device_enable_async_suspend(b->bridge);
1439	1440
1440	1441	if (!parent)
1441	1442	set_dev_node(b->bridge, pcibus_to_node(b));