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 / Runtime: Add runtime PM statistics (v3)
  PM / Runtime: Make runtime_status attribute not debug-only (v. 2)
  PM: Do not use dynamically allocated objects in pm_wakeup_event()
  PM / Suspend: Fix ordering of calls in suspend error paths
  PM / Hibernate: Fix snapshot error code path
  PM / Hibernate: Fix hibernation_platform_enter()
  pm_qos: Get rid of the allocation in pm_qos_add_request()
  pm_qos: Reimplement using plists
  plist: Add plist_last
  PM: Make it possible to avoid races between wakeup and system sleep
  PNPACPI: Add support for remote wakeup
  PM: describe kernel policy regarding wakeup defaults (v. 2)
  PM / Hibernate: Fix typos in comments in kernel/power/swap.c

29 files changed, 734 insertions, 188 deletions

diff --git a/Documentation/ABI/testing/sysfs-power b/Documentation/ABI/testing/sysfs-power
index d6a801f45b48..2875f1f74a07 100644
--- a/Documentation/ABI/testing/sysfs-power
+++ b/Documentation/ABI/testing/sysfs-power
@@ -114,3 +114,18 @@ Description:
                 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.
+
+What:           /sys/power/wakeup_count
+Date:           July 2010
+Contact:        Rafael J. Wysocki <rjw@sisk.pl>
+Description:
+                The /sys/power/wakeup_count file allows user space to put the
+                system into a sleep state while taking into account the
+                concurrent arrival of wakeup events.  Reading from it returns
+                the current number of registered wakeup events and it blocks if
+                some wakeup events are being processed at the time the file is
+                read from.  Writing to it will only succeed if the current
+                number of wakeup events is equal to the written value and, if
+                successful, will make the kernel abort a subsequent transition
+                to a sleep state if any wakeup events are reported after the
+                write has returned.
diff --git a/drivers/base/power/Makefile b/drivers/base/power/Makefile
index 89de75325cea..cbccf9a3cee4 100644
--- a/drivers/base/power/Makefile
+++ b/drivers/base/power/Makefile
@@ -1,5 +1,5 @@
 obj-$(CONFIG_PM)        += sysfs.o
-obj-$(CONFIG_PM_SLEEP)  += main.o
+obj-$(CONFIG_PM_SLEEP)  += main.o wakeup.o
 obj-$(CONFIG_PM_RUNTIME)        += runtime.o
 obj-$(CONFIG_PM_OPS)    += generic_ops.o
 obj-$(CONFIG_PM_TRACE_RTC)      += trace.o
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 941fcb87e52a..5419a49ff135 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -59,6 +59,7 @@ void device_pm_init(struct device *dev)
 {
         dev->power.status = DPM_ON;
         init_completion(&dev->power.completion);
+        dev->power.wakeup_count = 0;
         pm_runtime_init(dev);
 }
 
diff --git a/drivers/base/power/runtime.c b/drivers/base/power/runtime.c
index b0ec0e9f27e9..b78c401ffa73 100644
--- a/drivers/base/power/runtime.c
+++ b/drivers/base/power/runtime.c
@@ -123,6 +123,45 @@ int pm_runtime_idle(struct device *dev)
 }
 EXPORT_SYMBOL_GPL(pm_runtime_idle);
 
+
+/**
+ * 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.
+ */
+void update_pm_runtime_accounting(struct device *dev)
+{
+        unsigned long now = jiffies;
+        int delta;
+
+        delta = now - dev->power.accounting_timestamp;
+
+        if (delta < 0)
+                delta = 0;
+
+        dev->power.accounting_timestamp = now;
+
+        if (dev->power.disable_depth > 0)
+                return;
+
+        if (dev->power.runtime_status == RPM_SUSPENDED)
+                dev->power.suspended_jiffies += delta;
+        else
+                dev->power.active_jiffies += delta;
+}
+
+static void __update_runtime_status(struct device *dev, enum rpm_status status)
+{
+        update_pm_runtime_accounting(dev);
+        dev->power.runtime_status = status;
+}
+
 /**
  * __pm_runtime_suspend - Carry out run-time suspend of given device.
  * @dev: Device to suspend.
@@ -197,7 +236,7 @@ int __pm_runtime_suspend(struct device *dev, bool from_wq)
                 goto repeat;
         }
 
-        dev->power.runtime_status = RPM_SUSPENDING;
+        __update_runtime_status(dev, RPM_SUSPENDING);
         dev->power.deferred_resume = false;
 
         if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_suspend) {
@@ -228,7 +267,7 @@ int __pm_runtime_suspend(struct device *dev, bool from_wq)
         }
 
         if (retval) {
-                dev->power.runtime_status = RPM_ACTIVE;
+                __update_runtime_status(dev, RPM_ACTIVE);
                 if (retval == -EAGAIN || retval == -EBUSY) {
                         if (dev->power.timer_expires == 0)
                                 notify = true;
@@ -237,7 +276,7 @@ int __pm_runtime_suspend(struct device *dev, bool from_wq)
                         pm_runtime_cancel_pending(dev);
                 }
         } else {
-                dev->power.runtime_status = RPM_SUSPENDED;
+                __update_runtime_status(dev, RPM_SUSPENDED);
                 pm_runtime_deactivate_timer(dev);
 
                 if (dev->parent) {
@@ -381,7 +420,7 @@ int __pm_runtime_resume(struct device *dev, bool from_wq)
                 goto repeat;
         }
 
-        dev->power.runtime_status = RPM_RESUMING;
+        __update_runtime_status(dev, RPM_RESUMING);
 
         if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_resume) {
                 spin_unlock_irq(&dev->power.lock);
@@ -411,10 +450,10 @@ int __pm_runtime_resume(struct device *dev, bool from_wq)
         }
 
         if (retval) {
-                dev->power.runtime_status = RPM_SUSPENDED;
+                __update_runtime_status(dev, RPM_SUSPENDED);
                 pm_runtime_cancel_pending(dev);
         } else {
-                dev->power.runtime_status = RPM_ACTIVE;
+                __update_runtime_status(dev, RPM_ACTIVE);
                 if (parent)