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: (21 commits)
  PM / Hibernate: Reduce autotuned default image size
  PM / Core: Introduce struct syscore_ops for core subsystems PM
  PM QoS: Make pm_qos settings readable
  PM / OPP: opp_find_freq_exact() documentation fix
  PM: Documentation/power/states.txt: fix repetition
  PM: Make system-wide PM and runtime PM treat subsystems consistently
  PM: Simplify kernel/power/Kconfig
  PM: Add support for device power domains
  PM: Drop pm_flags that is not necessary
  PM: Allow pm_runtime_suspend() to succeed during system suspend
  PM: Clean up PM_TRACE dependencies and drop unnecessary Kconfig option
  PM: Remove CONFIG_PM_OPS
  PM: Reorder power management Kconfig options
  PM: Make CONFIG_PM depend on (CONFIG_PM_SLEEP || CONFIG_PM_RUNTIME)
  PM / ACPI: Remove references to pm_flags from bus.c
  PM: Do not create wakeup sysfs files for devices that cannot wake up
  USB / Hub: Do not call device_set_wakeup_capable() under spinlock
  PM: Use appropriate printk() priority level in trace.c
  PM / Wakeup: Don't update events_check_enabled in pm_get_wakeup_count()
  PM / Wakeup: Make pm_save_wakeup_count() work as documented
  ...

21 files changed, 405 insertions, 207 deletions

diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index 2aa042a5da6d..3a17ca5fff6f 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -7,7 +7,6 @@ menuconfig ACPI
         depends on !IA64_HP_SIM
         depends on IA64 || X86
         depends on PCI
-        depends on PM
         select PNP
         default y
         help
diff --git a/drivers/acpi/bus.c b/drivers/acpi/bus.c
index 7ced61f39492..9749980ca6ca 100644
--- a/drivers/acpi/bus.c
+++ b/drivers/acpi/bus.c
@@ -40,6 +40,7 @@
 #include <acpi/acpi_bus.h>
 #include <acpi/acpi_drivers.h>
 #include <linux/dmi.h>
+#include <linux/suspend.h>
 
 #include "internal.h"
 
@@ -1006,8 +1007,7 @@ struct kobject *acpi_kobj;
 
 static int __init acpi_init(void)
 {
-        int result = 0;
-
+        int result;
 
         if (acpi_disabled) {
                 printk(KERN_INFO PREFIX "Interpreter disabled.\n");
@@ -1022,29 +1022,18 @@ static int __init acpi_init(void)
 
         init_acpi_device_notify();
         result = acpi_bus_init();
-
-        if (!result) {
-                pci_mmcfg_late_init();
-                if (!(pm_flags & PM_APM))
-                        pm_flags |= PM_ACPI;
-                else {
-                        printk(KERN_INFO PREFIX
-                               "APM is already active, exiting\n");
-                        disable_acpi();
-                        result = -ENODEV;
-                }
-        } else
+        if (result) {
                 disable_acpi();
-
-        if (acpi_disabled)
                 return result;
+        }
 
+        pci_mmcfg_late_init();
         acpi_scan_init();
         acpi_ec_init();
         acpi_debugfs_init();
         acpi_sleep_proc_init();
         acpi_wakeup_device_init();
-        return result;
+        return 0;
 }
 
 subsys_initcall(acpi_init);
diff --git a/drivers/acpi/sleep.c b/drivers/acpi/sleep.c
index d6a8cd14de2e..8ea092fad3f6 100644
--- a/drivers/acpi/sleep.c
+++ b/drivers/acpi/sleep.c
@@ -585,7 +585,7 @@ int acpi_suspend(u32 acpi_state)
         return -EINVAL;
 }
 
-#ifdef CONFIG_PM_OPS
+#ifdef CONFIG_PM
 /**
  *      acpi_pm_device_sleep_state - return preferred power state of ACPI device
  *              in the system sleep state given by %acpi_target_sleep_state
@@ -671,7 +671,7 @@ int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p)
                 *d_min_p = d_min;
         return d_max;
 }
-#endif /* CONFIG_PM_OPS */
+#endif /* CONFIG_PM */
 
 #ifdef CONFIG_PM_SLEEP
 /**
diff --git a/drivers/base/Makefile b/drivers/base/Makefile
index 5f51c3b4451e..4c5701c15f53 100644
--- a/drivers/base/Makefile
+++ b/drivers/base/Makefile
@@ -1,6 +1,6 @@
 # Makefile for the Linux device tree
 
-obj-y                   := core.o sys.o bus.o dd.o \
+obj-y                   := core.o sys.o bus.o dd.o syscore.o \
                            driver.o class.o platform.o \
                            cpu.o firmware.o init.o map.o devres.o \
                            attribute_container.o transport_class.o
diff --git a/drivers/base/power/Makefile b/drivers/base/power/Makefile
index abe46edfe5b4..118c1b92a511 100644
--- a/drivers/base/power/Makefile
+++ b/drivers/base/power/Makefile
@@ -1,7 +1,6 @@
-obj-$(CONFIG_PM)        += sysfs.o
+obj-$(CONFIG_PM)        += sysfs.o generic_ops.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
 obj-$(CONFIG_PM_OPP)    += opp.o
 
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 83404973f97a..052dc53eef38 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -423,26 +423,22 @@ static int device_resume_noirq(struct device *dev, pm_message_t state)
         TRACE_DEVICE(dev);
         TRACE_RESUME(0);
 
-        if (dev->bus && dev->bus->pm) {
-                pm_dev_dbg(dev, state, "EARLY ");
-                error = pm_noirq_op(dev, dev->bus->pm, state);
-                if (error)
-                        goto End;
+        if (dev->pwr_domain) {
+                pm_dev_dbg(dev, state, "EARLY power domain ");
+                pm_noirq_op(dev, &dev->pwr_domain->ops, state);
         }
 
         if (dev->type && dev->type->pm) {
                 pm_dev_dbg(dev, state, "EARLY type ");
                 error = pm_noirq_op(dev, dev->type->pm, state);
-                if (error)
-                        goto End;
-        }
-
-        if (dev->class && dev->class->pm) {
+        } else if (dev->class && dev->class->pm) {
                 pm_dev_dbg(dev, state, "EARLY class ");
                 error = pm_noirq_op(dev, dev->class->pm, state);
+        } else if (dev->bus && dev->bus->pm) {
+                pm_dev_dbg(dev, state, "EARLY ");
+                error = pm_noirq_op(dev, dev->bus->pm, state);
         }
 
-End:
         TRACE_RESUME(error);
         return error;
 }
@@ -518,36 +514,39 @@ static int device_resume(struct device *dev, pm_message_t state, bool async)
 
         dev->power.in_suspend = false;
 
-        if (dev->bus) {
-                if (dev->bus->pm) {
-                        pm_dev_dbg(dev, state, "");
-                        error = pm_op(dev, dev->bus->pm, state);
-                } else if (dev->bus->resume) {
-                        pm_dev_dbg(dev, state, "legacy ");
-                        error = legacy_resume(dev, dev->bus->resume);
-                }
-                if (error)
-                        goto End;
+        if (dev->pwr_domain) {
+                pm_dev_dbg(dev, state, "power domain ");
+                pm_op(dev, &dev->pwr_domain->ops, state);
         }
 
-        if (dev->type) {
-                if (dev->type->pm) {
-                        pm_dev_dbg(dev, state, "type ");
-                        error = pm_op(dev, dev->type->pm, state);
-                }
-                if (error)
-                        goto End;
+        if (dev->type && dev->type->pm) {
+                pm_dev_dbg(dev, state, "type ");
+                error = pm_op(dev, dev->type->pm, state);
+                goto End;
         }
 
         if (dev->class) {
                 if (dev->class->pm) {
                         pm_dev_dbg(dev, state, "class ");
                         error = pm_op(dev, dev->class->pm, state);
+                        goto End;
                 } else if (dev->class->resume) {
                         pm_dev_dbg(dev, state, "legacy class ");
                         error = legacy_resume(dev, dev->class->resume);
+                        goto End;
                 }
         }
+
+        if (dev->bus) {
+                if (dev->bus->pm) {
+                        pm_dev_dbg(dev, state, "");
+                        error = pm_op(dev, dev->bus->pm, state);
+                } else if (dev->bus->resume) {
+                        pm_dev_dbg(dev, state, "legacy ");
+                        error = legacy_resume(dev, dev->bus->resume);
+                }
+        }
+
  End:
         device_unlock(dev);
         complete_all(&dev->power.completion);
@@ -629,19 +628,23 @@ static void device_complete(struct device *dev, pm_message_t state)
 {
         device_lock(dev);
 
-        if (dev->class && dev->class->pm && dev->class->pm->complete) {
-                pm_dev_dbg(dev, state, "completing class ");
-                dev->class->pm->complete(dev);
+        if (dev->pwr_domain && dev->pwr_domain->ops.complete) {
+                pm_dev_dbg(dev, state, "completing power domain ");
+                dev->pwr_domain->ops.complete(dev);
         }
 
-        if (dev->type && dev->type->pm && dev->type->pm->complete) {
+        if (dev->type && dev->type->pm) {
                 pm_dev_dbg(dev, state, "completing type ");
-                dev->type->pm->complete(dev);
-        }
-
-        if (dev->bus && dev->bus->pm && dev->bus->pm->complete) {
+                if (dev->type->pm->complete)
+                        dev->type->pm->complete(dev);
+        } else if (dev->class && dev->class->pm) {
+                pm_dev_dbg(dev, state, "completing class ");
+                if (dev->class->pm->complete)
+                        dev->class->pm->complete(dev);
+        } else if (dev->bus && dev->bus->pm) {
                 pm_dev_dbg(dev, state, "completing ");
-                dev->bus->pm->complete(dev);
+                if (dev->bus->pm->complete)
+                        dev->bus->pm->complete(dev);
         }
 
         device_unlock(dev);
@@ -669,7 +672,6 @@ static void dpm_complete(pm_message_t state)
                 mutex_unlock(&dpm_list_mtx);
 
                 device_complete(dev, state);
-                pm_runtime_put_sync(dev);
 
                 mutex_lock(&dpm_list_mtx);
                 put_device(dev);
@@ -727,29 +729,31 @@ static pm_message_t resume_event(pm_message_t sleep_state)
  */
 static int device_suspend_noirq(struct device *dev, pm_message_t state)
 {
-        int error = 0;
-
-        if (dev->class && dev->class->pm) {
-                pm_dev_dbg(dev, state, "LATE class ");
-                error = pm_noirq_op(dev, dev->class->pm, state);
-                if (error)
-                        goto End;
-        }
+        int error;
 
         if (dev->type && dev->type->pm) {
                 pm_dev_dbg(dev, state, "LATE type ");
                 error = pm_noirq_op(dev, dev->type->pm, state);
                 if (error)
-                        goto End;
-        }
-
-        if (dev->bus && dev->bus->pm) {
+                        return error;
+        } else if (dev->class && dev->class->pm) {
+                pm_dev_dbg(dev, state, "LATE class ");
+                error = pm_noirq_op(dev, dev->class->pm, state);
+                if (error)
+                        return error;
+        } else if (dev->bus && dev->bus->pm) {
                 pm_dev_dbg(dev, state, "LATE ");
                 error = pm_noirq_op(dev, dev->bus->pm, state);
+                if (error)
+                        return error;
         }
 
-End:
-        return error;
+        if (dev->pwr_domain) {
+                pm_dev_dbg(dev, state, "LATE power domain ");
+                pm_noirq_op(dev, &dev->pwr_domain->ops, state);
+        }
+
+        return 0;
 }
 
 /**
@@ -836,25 +840,22 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async)
                 goto End;
         }
 
+        if (dev->type && dev->type->pm) {
+                pm_dev_dbg(dev, state, "type ");
+                error = pm_op(dev, dev->type->pm, state);
+                goto Domain;
+        }
+
         if (dev->class) {
                 if (dev->class->pm) {
                         pm_dev_dbg(dev, state, "class ");
                         error = pm_op(dev, dev->class->pm, state);
+                        goto Domain;
                 } else if (dev->class->suspend) {
                         pm_dev_dbg(dev, state, "legacy class ");
                         error = legacy_suspend(dev, state, dev->class->suspend);
+                        goto Domain;
                 }
-                if (error)
-                        goto End;
-        }
-
-        if (dev->type) {
-                if (dev->type->pm) {
-                        pm_dev_dbg(dev, state, "type ");
-                        error = pm_op(dev, dev->type->pm, state);
-                }
-                if (error)
-                        goto End;
         }
 
         if (dev->bus) {
@@ -867,6 +868,12 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async)
                 }
         }
 
+ Domain:
+        if (!error && dev->pwr_domain) {
+                pm_dev_dbg(dev, state, "power domain ");
+                pm_op(dev, &dev->pwr_domain->ops, state);
+        }
+
  End:
         device_unlock(dev);
         complete_all(&dev->power.completion);
@@ -957,27 +964,34 @@ static int device_prepare(struct device *dev, pm_message_t state)
 
         device_lock(dev);
 
-        if (dev->bus && dev->bus->pm && dev->bus->pm->prepare) {
+        if (dev->type && dev->type->pm) {
+                pm_dev_dbg(dev, state, "preparing type ");
+                if (dev->type->pm->prepare)
+                        error = dev->type->pm->prepare(dev);
+                suspend_report_result(dev->type->pm->prepare, error);
+                if (error)
+                        goto End;
+        } else if (dev->class && dev->class->pm) {
+                pm_dev_dbg(dev, state, "preparing class ");
+                if (dev->class->pm->prepare)
+                        error = dev->class->pm->prepare(dev);
+                suspend_report_result(dev->class->pm->prepare, error);
+                if (error)
+                        goto End;
+        } else if (dev->bus && dev->bus->pm) {
                 pm_dev_dbg(dev, state, "preparing ");
-                error = dev->bus->pm->prepare(dev);
+                if (dev->bus->pm->prepare)
+                        error = dev->bus->pm->prepare(dev);
                 suspend_report_result(dev->bus->pm->prepare, error);
                 if (error)
                         goto End;
         }
 
-        if (dev->type && dev->type->pm && dev->type->pm->prepare) {
-                pm_dev_dbg(dev, state, "preparing type ");
-                error = dev->type->pm->prepare(dev);
-                suspend_report_result(dev->type->pm->prepare, error);
-                if (error)
-                        goto End;
+        if (dev->pwr_domain && dev->pwr_domain->ops.prepare) {
+                pm_dev_dbg(dev, state, "preparing power domain ");
+                dev->pwr_domain->ops.prepare(dev);
         }
 
-        if (dev->class && dev->class->pm && dev->class->pm->prepare) {
-                pm_dev_dbg(dev, state, "preparing class ");
-                error = dev->class->pm->prepare(dev);
-                suspend_report_result(dev->class->pm->prepare, error);
-        }
  End:
         device_unlock(dev);
 
@@ -1005,12 +1019,9 @@ static int dpm_prepare(pm_message_t state)
                 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 {
-                        error = device_prepare(dev, state);
-                }
+                pm_runtime_put_sync(dev);
+                error = pm_wakeup_pending() ?
+                                -EBUSY : device_prepare(dev, state);
 
                 mutex_lock(&dpm_list_mtx);
                 if (error) {
diff --git a/drivers/base/power/opp.c b/drivers/base/power/opp.c
index 2bb9b4cf59d7..56a6899f5e9e 100644
--- a/drivers/base/power/opp.c
+++ b/drivers/base/power/opp.c
@@ -222,7 +222,7 @@ int opp_get_opp_count(struct device *dev)
  * opp_find_freq_exact() - search for an exact frequency
  * @dev:                device for which we do this operation
  * @freq:               frequency to search for
- * @is_available:       true/false - match for available opp
+ * @available:          true/false - match for available opp
  *
  * Searches for exact match in the opp list and returns pointer to the matching
  * opp if found, else returns ERR_PTR in case of error and should be handled
diff --git a/drivers/base/power/power.h b/drivers/base/power/power.h
index 698dde742587..f2a25f18fde7 100644
--- a/drivers/base/power/power.h
+++ b/drivers/base/power/power.h
@@ -58,19 +58,18 @@ static inline void device_pm_move_last(struct device *dev) {}
  * sysfs.c
  */
 
-extern int dpm_sysfs_add(struct device *);
-extern void dpm_sysfs_remove(struct device *);
-extern void rpm_sysfs_remove(struct device *);
+extern int dpm_sysfs_add(struct device *dev);
+extern void dpm_sysfs_remove(struct device *dev);
+extern void rpm_sysfs_remove(struct device *dev);
+extern int wakeup_sysfs_add(struct device *dev);
+extern void wakeup_sysfs_remove(struct device *dev);
 
 #else /* CONFIG_PM */
 
-static inline int dpm_sysfs_add(struct device *dev)
-{
-        return 0;
-}
-
-static inline void dpm_sysfs_remove(struct device *dev)
-{
-}
+static inline int dpm_sysfs_add(struct device *dev) { return 0; }
+static inline void dpm_sysfs_remove(struct device *dev) {}
+static inline void rpm_sysfs_remove(struct device *dev) {}
+static inline int wakeup_sysfs_add(struct device *dev) { return 0; }
+static inline void wakeup_sysfs_remove(struct device *dev) {}
 
 #endif
diff --git a/drivers/base/power/runtime.c b/drivers/base/power/runtime.c
index 42615b419dfb..54597c859ecb 100644
--- a/drivers/base/power/runtime.c
+++ b/drivers/base/power/runtime.c
@@ -168,6 +168,7 @@ static int rpm_check_suspend_allowed(struct device *dev)
 static int rpm_idle(struct device *dev, int rpmflags)
 {
         int (*callback)(struct device *);
+        int (*domain_callback)(struct device *);
         int retval;
 
         retval = rpm_check_suspend_allowed(dev);
@@ -213,19 +214,28 @@ static int rpm_idle(struct device *dev, int rpmflags)
 
         dev->power.idle_notification = true;
 
-        if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_idle)
-                callback = dev->bus->pm->runtime_idle;
-        else if (dev->type && dev->type->pm && dev->type->pm->runtime_idle)
+        if (dev->type && dev->type->pm)
                 callback = dev->type->pm->runtime_idle;
         else if (dev->class && dev->class->pm)
                 callback = dev->class->pm->runtime_idle;
+        else if (dev->bus && dev->bus->pm)
+                callback = dev->bus->pm->runtime_idle;
         else
                 callback = NULL;
 
-        if (callback) {
+        if (dev->pwr_domain)
+                domain_callback = dev->pwr_domain->ops.runtime_idle;
+        else
+                domain_callback = NULL;
+
+        if (callback || domain_callback) {
                 spin_unlock_irq(&dev->power.lock);
 
-                callback(dev);
+                if (domain_callback)
+                        retval = domain_callback(dev);
+
+                if (!retval && callback)
+                        callback(dev);
 
                 spin_lock_irq(&dev->power.lock);
         }
@@ -372,12 +382,12 @@ static int rpm_suspend(struct device *dev, int rpmflags)
 
         __update_runtime_status(dev, RPM_SUSPENDING);
 
-        if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_suspend)
-                callback = dev->bus->pm->runtime_suspend;
-        else if (dev->type && dev->type->pm && dev->type->pm->runtime_suspend)
+        if (dev->type && dev->type->pm)
                 callback = dev->type->pm->runtime_suspend;
         else if (dev->class && dev->class->pm)
                 callback = dev->class->pm->runtime_suspend;
+        else if (dev->bus && dev->bus->pm)
+                callback = dev->bus->pm->runtime_suspend;
         else
                 callback = NULL;
 
@@ -390,6 +400,8 @@ static int rpm_suspend(struct device *dev, int rpmflags)
                 else
                         pm_runtime_cancel_pending(dev);
         } else {
+                if (dev->pwr_domain)
+                        rpm_callback(dev->pwr_domain->ops.runtime_suspend, dev);
  no_callback:
                 __update_runtime_status(dev, RPM_SUSPENDED);
                 pm_runtime_deactivate_timer(dev);
@@ -569,12 +581,15 @@ static int rpm_resume(struct device *dev, int rpmflags)
 
         __update_runtime_status(dev, RPM_RESUMING);
 
-        if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_resume)
-                callback = dev->bus->pm->runtime_resume;
-        else if (dev->type && dev->type->pm && dev->type->pm->runtime_resume)
+        if (dev->pwr_domain)
+                rpm_callback(dev->pwr_domain->ops.runtime_resume, dev);
+
+        if (dev->type && dev->type->pm)
                 callback = dev->type->pm->runtime_resume;
         else if (dev->class && dev->class->pm)
                 callback = dev->class->pm->runtime_resume;
+        else if (dev->bus && dev->bus->pm)
+                callback = dev->bus->pm->runtime_resume;
         else
                 callback = NULL;
 
diff --git a/drivers/base/power/sysfs.c b/drivers/base/power/sysfs.c
index 0b1e46bf3e56..fff49bee781d 100644
--- a/drivers/base/power/sysfs.c
+++ b/drivers/base/power/sysfs.c
@@ -431,26 +431,18 @@ static ssize_t async_store(struct device *dev, struct device_attribute *attr,
 static DEVICE_ATTR(async, 0644, async_show, async_store);
 #endif /* CONFIG_PM_ADVANCED_DEBUG */
 
-static struct attribute * power_attrs[] = {
-        &dev_attr_wakeup.attr,
-#ifdef CONFIG_PM_SLEEP
-        &dev_attr_wakeup_count.attr,
-        &dev_attr_wakeup_active_count.attr,
-        &dev_attr_wakeup_hit_count.attr,
-        &dev_attr_wakeup_active.attr,
-        &dev_attr_wakeup_total_time_ms.attr,
-        &dev_attr_wakeup_max_time_ms.attr,
-        &dev_attr_wakeup_last_time_ms.attr,
-#endif
+static struct attribute *power_attrs[] = {
 #ifdef CONFIG_PM_ADVANCED_DEBUG
+#ifdef CONFIG_PM_SLEEP
         &dev_attr_async.attr,
+#endif
 #ifdef CONFIG_PM_RUNTIME
         &dev_attr_runtime_status.attr,
         &dev_attr_runtime_usage.attr,
         &dev_attr_runtime_active_kids.attr,
         &dev_attr_runtime_enabled.attr,
 #endif
-#endif
+#endif /* CONFIG_PM_ADVANCED_DEBUG */
         NULL,
 };
 static struct attribute_group pm_attr_group = {
@@ -458,9 +450,26 @@ static struct attribute_group pm_attr_group = {
         .attrs  = power_attrs,
 };
 
-#ifdef CONFIG_PM_RUNTIME
+static struct attribute *wakeup_attrs[] = {
+#ifdef CONFIG_PM_SLEEP
+        &dev_attr_wakeup.attr,
+        &dev_attr_wakeup_count.attr,
+        &dev_attr_wakeup_active_count.attr,
+        &dev_attr_wakeup_hit_count.attr,
+        &dev_attr_wakeup_active.attr,
+        &dev_attr_wakeup_total_time_ms.attr,
+        &dev_attr_wakeup_max_time_ms.attr,
+        &dev_attr_wakeup_last_time_ms.attr,
+#endif
+        NULL,
+};
+static struct attribute_group pm_wakeup_attr_group = {
+        .name   = power_group_name,
+        .attrs  = wakeup_attrs,
+};
 
 static struct attribute *runtime_attrs[] = {
+#ifdef CONFIG_PM_RUNTIME
 #ifndef CONFIG_PM_ADVANCED_DEBUG
         &dev_attr_runtime_status.attr,
 #endif
@@ -468,6 +477,7 @@ static struct attribute *runtime_attrs[] = {
         &dev_attr_runtime_suspended_time.attr,
         &dev_attr_runtime_active_time.attr,
         &dev_attr_autosuspend_delay_ms.attr,
+#endif /* CONFIG_PM_RUNTIME */
         NULL,
 };
 static struct attribute_group pm_runtime_attr_group = {
@@ -480,35 +490,49 @@ int dpm_sysfs_add(struct device *dev)
         int rc;
 
         rc = sysfs_create_group(&dev->kobj, &pm_attr_group);
-        if (rc == 0 && !dev->power.no_callbacks) {
+        if (rc)
+                return rc;
+
+        if (pm_runtime_callbacks_present(dev)) {
                 rc = sysfs_merge_group(&dev->kobj, &pm_runtime_attr_group);
                 if (rc)
-                        sysfs_remove_group(&dev->kobj, &pm_attr_group);
+                        goto err_out;
+        }
+
+        if (device_can_wakeup(dev)) {
+                rc = sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
+                if (rc) {
+                        if (pm_runtime_callbacks_present(dev))
+                                sysfs_unmerge_group(&dev->kobj,
+                                                    &pm_runtime_attr_group);
+                        goto err_out;
+                }
         }
+        return 0;
+
+ err_out:
+        sysfs_remove_group(&dev->kobj, &pm_attr_group);
         return rc;
 }
 
-void rpm_sysfs_remove(struct device *dev)
+int wakeup_sysfs_add(struct device *dev)
 {
-        sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
+        return sysfs_merge_group(&dev->kobj, &pm_wakeup_attr_group);
 }
 
-void dpm_sysfs_remove(struct device *dev)
+void wakeup_sysfs_remove(struct device *dev)
 {
-        rpm_sysfs_remove(dev);
-        sysfs_remove_group(&dev->kobj, &pm_attr_group);
+        sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
 }
 
-#else /* CONFIG_PM_RUNTIME */
-
-int dpm_sysfs_add(struct device * dev)
+void rpm_sysfs_remove(struct device *dev)
 {
-        return sysfs_create_group(&dev->kobj, &pm_attr_group);
+        sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
 }
 
-void dpm_sysfs_remove(struct device * dev)
+void dpm_sysfs_remove(struct device *dev)
 {
+        rpm_sysfs_remove(dev);
+        sysfs_unmerge_group(&dev->kobj, &pm_wakeup_attr_group);
         sysfs_remove_group(&dev->kobj, &pm_attr_group);
 }
-
-#endif
diff --git a/drivers/base/power/trace.c b/drivers/base/power/trace.c
index 9f4258df4cfd..c80e138b62fe 100644
--- a/drivers/base/power/trace.c
+++ b/drivers/base/power/trace.c
@@ -112,7 +112,7 @@ static unsigned int read_magic_time(void)
         unsigned int val;
 
         get_rtc_time(&time);
-        printk("Time: %2d:%02d:%02d  Date: %02d/%02d/%02d\n",
+        pr_info("Time: %2d:%02d:%02d  Date: %02d/%02d/%02d\n",
                 time.tm_hour, time.tm_min, time.tm_sec,
                 time.tm_mon + 1, time.tm_mday, time.tm_year % 100);
         val = time.tm_year;                             /* 100 years */
@@ -179,7 +179,7 @@ static int show_file_hash(unsigned int value)
                 unsigned int hash = hash_string(lineno, file, FILEHASH);
                 if (hash != value)
                         continue;
-                printk("  hash matches %s:%u\n", file, lineno);
+                pr_info("  hash matches %s:%u\n", file, lineno);
                 match++;
         }
         return match;
@@ -255,7 +255,7 @@ static int late_resume_init(void)
         val = val / FILEHASH;
         dev = val /* % DEVHASH */;
 
-        printk("  Magic number: %d:%d:%d\n", user, file, dev);
+        pr_info("  Magic number: %d:%d:%d\n", user, file, dev);
         show_file_hash(file);
         show_dev_hash(dev);
         return 0;
diff --git a/drivers/base/power/wakeup.c b/drivers/base/power/wakeup.c
index 8ec406d8f548..4573c83df6dd 100644
--- a/drivers/base/power/wakeup.c
+++ b/drivers/base/power/wakeup.c
@@ -24,12 +24,26 @@
  */
 bool events_check_enabled;
 
-/* The counter of registered wakeup events. */
-static atomic_t event_count = ATOMIC_INIT(0);
-/* A preserved old value of event_count. */
+/*
+ * Combined counters of registered wakeup events and wakeup events in progress.
+ * They need to be modified together atomically, so it's better to use one
+ * atomic variable to hold them both.
+ */
+static atomic_t combined_event_count = ATOMIC_INIT(0);
+
+#define IN_PROGRESS_BITS        (sizeof(int) * 4)
+#define MAX_IN_PROGRESS         ((1 << IN_PROGRESS_BITS) - 1)
+
+static void split_counters(unsigned int *cnt, unsigned int *inpr)
+{
+        unsigned int comb = atomic_read(&combined_event_count);
+
+        *cnt = (comb >> IN_PROGRESS_BITS);
+        *inpr = comb & MAX_IN_PROGRESS;
+}
+
+/* A preserved old value of the events counter. */
 static unsigned int saved_count;
-/* The counter of wakeup events being processed. */
-static atomic_t events_in_progress = ATOMIC_INIT(0);
 
 static DEFINE_SPINLOCK(events_lock);
 
@@ -228,6 +242,35 @@ int device_wakeup_disable(struct device *dev)
 EXPORT_SYMBOL_GPL(device_wakeup_disable);
 
 /**
+ * device_set_wakeup_capable - Set/reset device wakeup capability flag.
+ * @dev: Device to handle.
+ * @capable: Whether or not @dev is capable of waking up the system from sleep.
+ *
+ * If @capable is set, set the @dev's power.can_wakeup flag and add its
+ * wakeup-related attributes to sysfs.  Otherwise, unset the @dev's
+ * power.can_wakeup flag and remove its wakeup-related attributes from sysfs.
+ *
+ * This function may sleep and it can't be called from any context where
+ * sleeping is not allowed.
+ */
+void device_set_wakeup_capable(struct device *dev, bool capable)
+{
+        if (!!dev->power.can_wakeup == !!capable)
+                return;
+
+        if (device_is_registered(dev)) {
+                if (capable) {
+                        if (wakeup_sysfs_add(dev))
+                                return;
+                } else {
+                        wakeup_sysfs_remove(dev);
+                }
+        }
+        dev->power.can_wakeup = capable;
+}
+EXPORT_SYMBOL_GPL(device_set_wakeup_capable);
+
+/**
  * device_init_wakeup - Device wakeup initialization.
  * @dev: Device to handle.
  * @enable: Whether or not to enable @dev as a wakeup device.
@@ -307,7 +350,8 @@ static void wakeup_source_activate(struct wakeup_source *ws)
         ws->timer_expires = jiffies;
         ws->last_time = ktime_get();
 
-        atomic_inc(&events_in_progress);
+        /* Increment the counter of events in progress. */
+        atomic_inc(&combined_event_count);
 }
 
 /**
@@ -394,14 +438,10 @@ static void wakeup_source_deactivate(struct wakeup_source *ws)
         del_timer(&ws->timer);
 
         /*
-         * event_count has to be incremented before events_in_progress is
-         * modified, so that the callers of pm_check_wakeup_events() and
-         * pm_save_wakeup_count() don't see the old value of event_count and
-         * events_in_progress equal to zero at the same time.
+         * Increment the counter of registered wakeup events and decrement the
+         * couter of wakeup events in progress simultaneously.
          */
-        atomic_inc(&event_count);
-        smp_mb__before_atomic_dec();
-        atomic_dec(&events_in_progress);
+        atomic_add(MAX_IN_PROGRESS, &combined_event_count);
 }
 
 /**
@@ -556,8 +596,10 @@ bool pm_wakeup_pending(void)
 
         spin_lock_irqsave(&events_lock, flags);
         if (events_check_enabled) {
-                ret = ((unsigned int)atomic_read(&event_count) != saved_count)
-                        || atomic_read(&events_in_progress);
+                unsigned int cnt, inpr;
+
+                split_counters(&cnt, &inpr);
+                ret = (cnt != saved_count || inpr > 0);
                 events_check_enabled = !ret;
         }
         spin_unlock_irqrestore(&events_lock, flags);
@@ -573,25 +615,25 @@ bool pm_wakeup_pending(void)
  * Store the number of registered wakeup events at the address in @count.  Block
  * if the current number of wakeup events being processed is nonzero.
  *
- * Return false if the wait for the number of wakeup events being processed to
+ * Return 'false' if the wait for the number of wakeup events being processed to
  * drop down to zero has been interrupted by a signal (and the current number
- * of wakeup events being processed is still nonzero).  Otherwise return true.
+ * of wakeup events being processed is still nonzero).  Otherwise return 'true'.
  */
 bool pm_get_wakeup_count(unsigned int *count)
 {
-        bool ret;
-
-        if (capable(CAP_SYS_ADMIN))
-                events_check_enabled = false;
+        unsigned int cnt, inpr;
 
-        while (atomic_read(&events_in_progress) && !signal_pending(current)) {
+        for (;;) {
+                split_counters(&cnt, &inpr);
+                if (inpr == 0 || signal_pending(current))
+                        break;
                 pm_wakeup_update_hit_counts();
                 schedule_timeout_interruptible(msecs_to_jiffies(TIMEOUT));
         }
 
-        ret = !atomic_read(&events_in_progress);
-        *count = atomic_read(&event_count);
-        return ret;
+        split_counters(&cnt, &inpr);
+        *count = cnt;
+        return !inpr;
 }
 
 /**
@@ -600,24 +642,25 @@ bool pm_get_wakeup_count(unsigned int *count)
  *
  * If @count is equal to the current number of registered wakeup events and the
  * current number of wakeup events being processed is zero, store @count as the
- * old number of registered wakeup events to be used by pm_check_wakeup_events()
- * and return true.  Otherwise return false.
+ * old number of registered wakeup events for pm_check_wakeup_events(), enable
+ * wakeup events detection and return 'true'.  Otherwise disable wakeup events
+ * detection and return 'false'.
  */
 bool pm_save_wakeup_count(unsigned int count)
 {
-        bool ret = false;
+        unsigned int cnt, inpr;
 
+        events_check_enabled = false;
         spin_lock_irq(&events_lock);
-        if (count == (unsigned int)atomic_read(&event_count)
-            && !atomic_read(&events_in_progress)) {
+        split_counters(&cnt, &inpr);
+        if (cnt == count && inpr == 0) {
                 saved_count = count;
                 events_check_enabled = true;
-                ret = true;
         }
         spin_unlock_irq(&events_lock);
-        if (!ret)
+        if (!events_check_enabled)
                 pm_wakeup_update_hit_counts();
-        return ret;
+        return events_check_enabled;
 }
 
 static struct dentry *wakeup_sources_stats_dentry;
diff --git a/drivers/base/syscore.c b/drivers/base/syscore.c
new file mode 100644
index 000000000000..90af2943f9e4
--- /dev/null
+++ b/drivers/base/syscore.c
@@ -0,0 +1,117 @@
+/*
+ *  syscore.c - Execution of system core operations.
+ *
+ *  Copyright (C) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
+ *
+ *  This file is released under the GPLv2.
+ */
+
+#include <linux/syscore_ops.h>
+#include <linux/mutex.h>
+#include <linux/module.h>
+
+static LIST_HEAD(syscore_ops_list);
+static DEFINE_MUTEX(syscore_ops_lock);
+
+/**
+ * register_syscore_ops - Register a set of system core operations.
+ * @ops: System core operations to register.
+ */
+void register_syscore_ops(struct syscore_ops *ops)
+{
+        mutex_lock(&syscore_ops_lock);
+        list_add_tail(&ops->node, &syscore_ops_list);
+        mutex_unlock(&syscore_ops_lock);
+}
+EXPORT_SYMBOL_GPL(register_syscore_ops);
+
+/**
+ * unregister_syscore_ops - Unregister a set of system core operations.
+ * @ops: System core operations to unregister.
+ */
+void unregister_syscore_ops(struct syscore_ops *ops)
+{
+        mutex_lock(&syscore_ops_lock);
+        list_del(&ops->node);
+        mutex_unlock(&syscore_ops_lock);
+}
+EXPORT_SYMBOL_GPL(unregister_syscore_ops);
+
+#ifdef CONFIG_PM_SLEEP
+/**
+ * syscore_suspend - Execute all the registered system core suspend callbacks.
+ *
+ * This function is executed with one CPU on-line and disabled interrupts.
+ */
+int syscore_suspend(void)
+{
+        struct syscore_ops *ops;
+        int ret = 0;
+
+        WARN_ONCE(!irqs_disabled(),
+                "Interrupts enabled before system core suspend.\n");
+
+        list_for_each_entry_reverse(ops, &syscore_ops_list, node)
+                if (ops->suspend) {
+                        if (initcall_debug)
+                                pr_info("PM: Calling %pF\n", ops->suspend);
+                        ret = ops->suspend();
+                        if (ret)
+                                goto err_out;
+                        WARN_ONCE(!irqs_disabled(),
+                                "Interrupts enabled after %pF\n", ops->suspend);
+                }
+
+        return 0;
+
+ err_out:
+        pr_err("PM: System core suspend callback %pF failed.\n", ops->suspend);
+
+        list_for_each_entry_continue(ops, &syscore_ops_list, node)
+                if (ops->resume)
+                        ops->resume();
+
+        return ret;
+}
+
+/**
+ * syscore_resume - Execute all the registered system core resume callbacks.
+ *
+ * This function is executed with one CPU on-line and disabled interrupts.
+ */
+void syscore_resume(void)
+{
+        struct syscore_ops *ops;
+
+        WARN_ONCE(!irqs_disabled(),
+                "Interrupts enabled before system core resume.\n");
+
+        list_for_each_entry(ops, &syscore_ops_list, node)
+                if (ops->resume) {
+                        if (initcall_debug)
+                                pr_info("PM: Calling %pF\n", ops->resume);
+                        ops->resume();
+                        WARN_ONCE(!irqs_disabled(),
+                                "Interrupts enabled after %pF\n", ops->resume);
+                }
+}
+#endif /* CONFIG_PM_SLEEP */
+
+/**
+ * syscore_shutdown - Execute all the registered system core shutdown callbacks.
+ */
+void syscore_shutdown(void)
+{
+        struct syscore_ops *ops;
+
+        mutex_lock(&syscore_ops_lock);
+
+        list_for_each_entry_reverse(ops, &syscore_ops_list, node)
+                if (ops->shutdown) {
+                        if (initcall_debug)
+                                pr_info("PM: Calling %pF\n", ops->shutdown);
+                        ops->shutdown();
+                }
+
+        mutex_unlock(&syscore_ops_lock);
+}
diff --git a/drivers/net/e1000e/netdev.c b/drivers/net/e1000e/netdev.c
index 2e5022849f18..6d513a383340 100644
--- a/drivers/net/e1000e/netdev.c
+++ b/drivers/net/e1000e/netdev.c
@@ -5338,7 +5338,7 @@ void e1000e_disable_aspm(struct pci_dev *pdev, u16 state)
         __e1000e_disable_aspm(pdev, state);
 }
 
-#ifdef CONFIG_PM_OPS
+#ifdef CONFIG_PM
 static bool e1000e_pm_ready(struct e1000_adapter *adapter)
 {
         return !!adapter->tx_ring->buffer_info;
@@ -5489,7 +5489,7 @@ static int e1000_runtime_resume(struct device *dev)
         return __e1000_resume(pdev);
 }
 #endif /* CONFIG_PM_RUNTIME */
-#endif /* CONFIG_PM_OPS */
+#endif /* CONFIG_PM */
 
 static void e1000_shutdown(struct pci_dev *pdev)
 {
@@ -6196,7 +6196,7 @@ static DEFINE_PCI_DEVICE_TABLE(e1000_pci_tbl) = {
 };
 MODULE_DEVICE_TABLE(pci, e1000_pci_tbl);
 
-#ifdef CONFIG_PM_OPS
+#ifdef CONFIG_PM
 static const struct dev_pm_ops e1000_pm_ops = {
         SET_SYSTEM_SLEEP_PM_OPS(e1000_suspend, e1000_resume)
         SET_RUNTIME_PM_OPS(e1000_runtime_suspend,
@@ -6210,7 +6210,7 @@ static struct pci_driver e1000_driver = {
         .id_table = e1000_pci_tbl,
         .probe    = e1000_probe,
         .remove   = __devexit_p(e1000_remove),
-#ifdef CONFIG_PM_OPS
+#ifdef CONFIG_PM
         .driver.pm = &e1000_pm_ops,
 #endif
         .shutdown = e1000_shutdown,
diff --git a/drivers/net/pch_gbe/pch_gbe_main.c b/drivers/net/pch_gbe/pch_gbe_main.c
index b99e90aca37d..8c66e22c3a0a 100644
--- a/drivers/net/pch_gbe/pch_gbe_main.c
+++ b/drivers/net/pch_gbe/pch_gbe_main.c
@@ -2446,7 +2446,7 @@ static struct pci_driver pch_gbe_pcidev = {
         .id_table = pch_gbe_pcidev_id,
         .probe = pch_gbe_probe,
         .remove = pch_gbe_remove,
-#ifdef CONFIG_PM_OPS
+#ifdef CONFIG_PM
         .driver.pm = &pch_gbe_pm_ops,
 #endif
         .shutdown = pch_gbe_shutdown,
diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index 88246dd46452..d86ea8b01137 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -431,7 +431,7 @@ static void pci_device_shutdown(struct device *dev)
         pci_msix_shutdown(pci_dev);
 }
 
-#ifdef CONFIG_PM_OPS
+#ifdef CONFIG_PM
 
 /* Auxiliary functions used for system resume and run-time resume. */
 
@@ -1059,7 +1059,7 @@ static int pci_pm_runtime_idle(struct device *dev)
 
 #endif /* !CONFIG_PM_RUNTIME */
 
-#ifdef CONFIG_PM_OPS
+#ifdef CONFIG_PM
 
 const struct dev_pm_ops pci_dev_pm_ops = {
         .prepare = pci_pm_prepare,
diff --git a/drivers/scsi/Makefile b/drivers/scsi/Makefile
index 2e9a87e8e7d8..ef6de669424b 100644
--- a/drivers/scsi/Makefile
+++ b/drivers/scsi/Makefile
@@ -165,7 +165,7 @@ scsi_mod-$(CONFIG_SCSI_NETLINK)	+= scsi_netlink.o
 scsi_mod-$(CONFIG_SYSCTL)       += scsi_sysctl.o
 scsi_mod-$(CONFIG_SCSI_PROC_FS) += scsi_proc.o
 scsi_mod-y                      += scsi_trace.o
-scsi_mod-$(CONFIG_PM_OPS)       += scsi_pm.o
+scsi_mod-$(CONFIG_PM)           += scsi_pm.o
 
 scsi_tgt-y                      += scsi_tgt_lib.o scsi_tgt_if.o
 
diff --git a/drivers/scsi/scsi_priv.h b/drivers/scsi/scsi_priv.h
index b4056d14f812..342ee1a9c41d 100644
--- a/drivers/scsi/scsi_priv.h
+++ b/drivers/scsi/scsi_priv.h
@@ -146,7 +146,7 @@ static inline void scsi_netlink_exit(void) {}
 #endif
 
 /* scsi_pm.c */
-#ifdef CONFIG_PM_OPS
+#ifdef CONFIG_PM
 extern const struct dev_pm_ops scsi_bus_pm_ops;
 #endif
 #ifdef CONFIG_PM_RUNTIME
diff --git a/drivers/scsi/scsi_sysfs.c b/drivers/scsi/scsi_sysfs.c
index 490ce213204e..e44ff64233fd 100644
--- a/drivers/scsi/scsi_sysfs.c
+++ b/drivers/scsi/scsi_sysfs.c
@@ -383,7 +383,7 @@ struct bus_type scsi_bus_type = {
         .name           = "scsi",
         .match          = scsi_bus_match,
         .uevent         = scsi_bus_uevent,
-#ifdef CONFIG_PM_OPS
+#ifdef CONFIG_PM
         .pm             = &scsi_bus_pm_ops,
 #endif
 };
diff --git a/drivers/usb/core/hcd-pci.c b/drivers/usb/core/hcd-pci.c
index f71e8e307e0f..64a035ba2eab 100644
--- a/drivers/usb/core/hcd-pci.c
+++ b/drivers/usb/core/hcd-pci.c
@@ -335,7 +335,7 @@ void usb_hcd_pci_shutdown(struct pci_dev *dev)
 }
 EXPORT_SYMBOL_GPL(usb_hcd_pci_shutdown);
 
-#ifdef  CONFIG_PM_OPS
+#ifdef  CONFIG_PM
 
 #ifdef  CONFIG_PPC_PMAC
 static void powermac_set_asic(struct pci_dev *pci_dev, int enable)
@@ -580,4 +580,4 @@ const struct dev_pm_ops usb_hcd_pci_pm_ops = {
 };
 EXPORT_SYMBOL_GPL(usb_hcd_pci_pm_ops);
 
-#endif  /* CONFIG_PM_OPS */
+#endif  /* CONFIG_PM */
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 0f299b7aad60..19d3435e6140 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -1465,6 +1465,7 @@ void usb_set_device_state(struct usb_device *udev,
                 enum usb_device_state new_state)
 {
         unsigned long flags;
+        int wakeup = -1;
 
         spin_lock_irqsave(&device_state_lock, flags);
         if (udev->state == USB_STATE_NOTATTACHED)
@@ -1479,11 +1480,10 @@ void usb_set_device_state(struct usb_device *udev,
                                         || new_state == USB_STATE_SUSPENDED)
                                 ;       /* No change to wakeup settings */
                         else if (new_state == USB_STATE_CONFIGURED)
-                                device_set_wakeup_capable(&udev->dev,
-                                        (udev->actconfig->desc.bmAttributes
-                                         & USB_CONFIG_ATT_WAKEUP));
+                                wakeup = udev->actconfig->desc.bmAttributes
+                                         & USB_CONFIG_ATT_WAKEUP;
                         else
-                                device_set_wakeup_capable(&udev->dev, 0);
+                                wakeup = 0;
                 }
                 if (udev->state == USB_STATE_SUSPENDED &&
                         new_state != USB_STATE_SUSPENDED)
@@ -1495,6 +1495,8 @@ void usb_set_device_state(struct usb_device *udev,
         } else
                 recursively_mark_NOTATTACHED(udev);
         spin_unlock_irqrestore(&device_state_lock, flags);
+        if (wakeup >= 0)
+                device_set_wakeup_capable(&udev->dev, wakeup);
 }
 EXPORT_SYMBOL_GPL(usb_set_device_state);