Introduce new top level suspend and hibernation callbacks

Introduce 'struct pm_ops' and 'struct pm_ext_ops' ('ext' meaning
'extended') representing suspend and hibernation operations for bus
types, device classes, device types and device drivers.

Modify the PM core to use 'struct pm_ops' and 'struct pm_ext_ops'
objects, if defined, instead of the ->suspend(), ->resume(),
->suspend_late(), and ->resume_early() callbacks (the old callbacks
will be considered as legacy and gradually phased out).

The main purpose of doing this is to separate suspend (aka S2RAM and
standby) callbacks from hibernation callbacks in such a way that the
new callbacks won't take arguments and the semantics of each of them
will be clearly specified.  This has been requested for multiple
times by many people, including Linus himself, and the reason is that
within the current scheme if ->resume() is called, for example, it's
difficult to say why it's been called (ie. is it a resume from RAM or
from hibernation or a suspend/hibernation failure etc.?).

The second purpose is to make the suspend/hibernation callbacks more
flexible so that device drivers can handle more than they can within
the current scheme.  For example, some drivers may need to prevent
new children of the device from being registered before their
->suspend() callbacks are executed or they may want to carry out some
operations requiring the availability of some other devices, not
directly bound via the parent-child relationship, in order to prepare
for the execution of ->suspend(), etc.

Ultimately, we'd like to stop using the freezing of tasks for suspend
and therefore the drivers' suspend/hibernation code will have to take
care of the handling of the user space during suspend/hibernation.
That, in turn, would be difficult within the current scheme, without
the new ->prepare() and ->complete() callbacks.

Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Acked-by: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>

3 files changed, 527 insertions, 154 deletions

diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 45cc3d9eacb8..d571204aaff7 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -12,11 +12,9 @@
  * and add it to the list of power-controlled devices. sysfs entries for
  * controlling device power management will also be added.
  *
- * A different set of lists than the global subsystem list are used to
- * keep track of power info because we use different lists to hold
- * devices based on what stage of the power management process they
- * are in. The power domain dependencies may also differ from the
- * ancestral dependencies that the subsystem list maintains.
+ * A separate list is used for keeping track of power info, because the power
+ * domain dependencies may differ from the ancestral dependencies that the
+ * subsystem list maintains.
  */
 
 #include <linux/device.h>
@@ -30,31 +28,40 @@
 #include "power.h"
 
 /*
- * The entries in the dpm_active list are in a depth first order, simply
+ * The entries in the dpm_list list are in a depth first order, simply
  * because children are guaranteed to be discovered after parents, and
  * are inserted at the back of the list on discovery.
  *
- * All the other lists are kept in the same order, for consistency.
- * However the lists aren't always traversed in the same order.
- * Semaphores must be acquired from the top (i.e., front) down
- * and released in the opposite order.  Devices must be suspended
- * from the bottom (i.e., end) up and resumed in the opposite order.
- * That way no parent will be suspended while it still has an active
- * child.
- *
  * Since device_pm_add() may be called with a device semaphore held,
  * we must never try to acquire a device semaphore while holding
  * dpm_list_mutex.
  */
 
-LIST_HEAD(dpm_active);
-static LIST_HEAD(dpm_off);
-static LIST_HEAD(dpm_off_irq);
+LIST_HEAD(dpm_list);
 
 static DEFINE_MUTEX(dpm_list_mtx);
 
-/* 'true' if all devices have been suspended, protected by dpm_list_mtx */
-static bool all_sleeping;
+/*
+ * Set once the preparation of devices for a PM transition has started, reset
+ * before starting to resume devices.  Protected by dpm_list_mtx.
+ */
+static bool transition_started;
+
+/**
+ *      device_pm_lock - lock the list of active devices used by the PM core
+ */
+void device_pm_lock(void)
+{
+        mutex_lock(&dpm_list_mtx);
+}
+
+/**
+ *      device_pm_unlock - unlock the list of active devices used by the PM core
+ */
+void device_pm_unlock(void)
+{
+        mutex_unlock(&dpm_list_mtx);
+}
 
 /**
  *      device_pm_add - add a device to the list of active devices
@@ -68,17 +75,25 @@ int device_pm_add(struct device *dev)
                  dev->bus ? dev->bus->name : "No Bus",
                  kobject_name(&dev->kobj));
         mutex_lock(&dpm_list_mtx);
-        if ((dev->parent && dev->parent->power.sleeping) || all_sleeping) {
-                if (dev->parent->power.sleeping)
-                        dev_warn(dev, "parent %s is sleeping\n",
+        if (dev->parent) {
+                if (dev->parent->power.status >= DPM_SUSPENDING) {
+                        dev_warn(dev, "parent %s is sleeping, will not add\n",
                                 dev->parent->bus_id);
-                else
-                        dev_warn(dev, "all devices are sleeping\n");
+                        WARN_ON(true);
+                }
+        } else if (transition_started) {
+                /*
+                 * We refuse to register parentless devices while a PM
+                 * transition is in progress in order to avoid leaving them
+                 * unhandled down the road
+                 */
                 WARN_ON(true);
         }
         error = dpm_sysfs_add(dev);
-        if (!error)
-                list_add_tail(&dev->power.entry, &dpm_active);
+        if (!error) {
+                dev->power.status = DPM_ON;
+                list_add_tail(&dev->power.entry, &dpm_list);
+        }
         mutex_unlock(&dpm_list_mtx);
         return error;
 }
@@ -100,73 +115,243 @@ void device_pm_remove(struct device *dev)
         mutex_unlock(&dpm_list_mtx);
 }
 
+/**
+ *      pm_op - execute the PM operation appropiate for given PM event
+ *      @dev:   Device.
+ *      @ops:   PM operations to choose from.
+ *      @state: PM transition of the system being carried out.
+ */
+static int pm_op(struct device *dev, struct pm_ops *ops, pm_message_t state)
+{
+        int error = 0;
+
+        switch (state.event) {
+#ifdef CONFIG_SUSPEND
+        case PM_EVENT_SUSPEND:
+                if (ops->suspend) {
+                        error = ops->suspend(dev);
+                        suspend_report_result(ops->suspend, error);
+                }
+                break;
+        case PM_EVENT_RESUME:
+                if (ops->resume) {
+                        error = ops->resume(dev);
+                        suspend_report_result(ops->resume, error);
+                }
+                break;
+#endif /* CONFIG_SUSPEND */
+#ifdef CONFIG_HIBERNATION
+        case PM_EVENT_FREEZE:
+        case PM_EVENT_QUIESCE:
+                if (ops->freeze) {
+                        error = ops->freeze(dev);
+                        suspend_report_result(ops->freeze, error);
+                }
+                break;
+        case PM_EVENT_HIBERNATE:
+                if (ops->poweroff) {
+                        error = ops->poweroff(dev);
+                        suspend_report_result(ops->poweroff, error);
+                }
+                break;
+        case PM_EVENT_THAW:
+        case PM_EVENT_RECOVER:
+                if (ops->thaw) {
+                        error = ops->thaw(dev);
+                        suspend_report_result(ops->thaw, error);
+                }
+                break;
+        case PM_EVENT_RESTORE:
+                if (ops->restore) {
+                        error = ops->restore(dev);
+                        suspend_report_result(ops->restore, error);
+                }
+                break;
+#endif /* CONFIG_HIBERNATION */
+        default:
+                error = -EINVAL;
+        }
+        return error;
+}
+
+/**
+ *      pm_noirq_op - execute the PM operation appropiate for given PM event
+ *      @dev:   Device.
+ *      @ops:   PM operations to choose from.
+ *      @state: PM transition of the system being carried out.
+ *
+ *      The operation is executed with interrupts disabled by the only remaining
+ *      functional CPU in the system.
+ */
+static int pm_noirq_op(struct device *dev, struct pm_ext_ops *ops,
+                        pm_message_t state)
+{
+        int error = 0;
+
+        switch (state.event) {
+#ifdef CONFIG_SUSPEND
+        case PM_EVENT_SUSPEND:
+                if (ops->suspend_noirq) {
+                        error = ops->suspend_noirq(dev);
+                        suspend_report_result(ops->suspend_noirq, error);
+                }
+                break;
+        case PM_EVENT_RESUME:
+                if (ops->resume_noirq) {
+                        error = ops->resume_noirq(dev);
+                        suspend_report_result(ops->resume_noirq, error);
+                }
+                break;
+#endif /* CONFIG_SUSPEND */
+#ifdef CONFIG_HIBERNATION
+        case PM_EVENT_FREEZE:
+        case PM_EVENT_QUIESCE:
+                if (ops->freeze_noirq) {
+                        error = ops->freeze_noirq(dev);
+                        suspend_report_result(ops->freeze_noirq, error);
+                }
+                break;
+        case PM_EVENT_HIBERNATE:
+                if (ops->poweroff_noirq) {
+                        error = ops->poweroff_noirq(dev);
+                        suspend_report_result(ops->poweroff_noirq, error);
+                }
+                break;
+        case PM_EVENT_THAW:
+        case PM_EVENT_RECOVER:
+                if (ops->thaw_noirq) {
+                        error = ops->thaw_noirq(dev);
+                        suspend_report_result(ops->thaw_noirq, error);
+                }
+                break;
+        case PM_EVENT_RESTORE:
+                if (ops->restore_noirq) {
+                        error = ops->restore_noirq(dev);
+                        suspend_report_result(ops->restore_noirq, error);
+                }
+                break;
+#endif /* CONFIG_HIBERNATION */
+        default:
+                error = -EINVAL;
+        }
+        return error;
+}
+
+static char *pm_verb(int event)
+{
+        switch (event) {
+        case PM_EVENT_SUSPEND:
+                return "suspend";
+        case PM_EVENT_RESUME:
+                return "resume";
+        case PM_EVENT_FREEZE:
+                return "freeze";
+        case PM_EVENT_QUIESCE:
+                return "quiesce";
+        case PM_EVENT_HIBERNATE:
+                return "hibernate";
+        case PM_EVENT_THAW:
+                return "thaw";
+        case PM_EVENT_RESTORE:
+                return "restore";
+        case PM_EVENT_RECOVER:
+                return "recover";
+        default:
+                return "(unknown PM event)";
+        }
+}
+
+static void pm_dev_dbg(struct device *dev, pm_message_t state, char *info)
+{
+        dev_dbg(dev, "%s%s%s\n", info, pm_verb(state.event),
+                ((state.event & PM_EVENT_SLEEP) && device_may_wakeup(dev)) ?
+                ", may wakeup" : "");
+}
+
+static void pm_dev_err(struct device *dev, pm_message_t state, char *info,
+                        int error)
+{
+        printk(KERN_ERR "PM: Device %s failed to %s%s: error %d\n",
+                kobject_name(&dev->kobj), pm_verb(state.event), info, error);
+}
+
 /*------------------------- Resume routines -------------------------*/
 
 /**
- *      resume_device_early - Power on one device (early resume).
+ *      resume_device_noirq - Power on one device (early resume).
  *      @dev:   Device.
+ *      @state: PM transition of the system being carried out.
  *
  *      Must be called with interrupts disabled.
  */
-static int resume_device_early(struct device *dev)
+static int resume_device_noirq(struct device *dev, pm_message_t state)
 {
         int error = 0;
 
         TRACE_DEVICE(dev);
         TRACE_RESUME(0);
 
-        if (dev->bus && dev->bus->resume_early) {
-                dev_dbg(dev, "EARLY resume\n");
+        if (!dev->bus)
+                goto End;
+
+        if (dev->bus->pm) {
+                pm_dev_dbg(dev, state, "EARLY ");
+                error = pm_noirq_op(dev, dev->bus->pm, state);
+        } else if (dev->bus->resume_early) {
+                pm_dev_dbg(dev, state, "legacy EARLY ");
                 error = dev->bus->resume_early(dev);
         }
-
+ End:
         TRACE_RESUME(error);
         return error;
 }
 
 /**
  *      dpm_power_up - Power on all regular (non-sysdev) devices.
+ *      @state: PM transition of the system being carried out.
  *
- *      Walk the dpm_off_irq list and power each device up. This
- *      is used for devices that required they be powered down with
- *      interrupts disabled. As devices are powered on, they are moved
- *      to the dpm_off list.
+ *      Execute the appropriate "noirq resume" callback for all devices marked
+ *      as DPM_OFF_IRQ.
  *
  *      Must be called with interrupts disabled and only one CPU running.
  */
-static void dpm_power_up(void)
+static void dpm_power_up(pm_message_t state)
 {
+        struct device *dev;
 
-        while (!list_empty(&dpm_off_irq)) {
-                struct list_head *entry = dpm_off_irq.next;
-                struct device *dev = to_device(entry);
+        list_for_each_entry(dev, &dpm_list, power.entry)
+                if (dev->power.status > DPM_OFF) {
+                        int error;
 
-                list_move_tail(entry, &dpm_off);
-                resume_device_early(dev);
-        }
+                        dev->power.status = DPM_OFF;
+                        error = resume_device_noirq(dev, state);
+                        if (error)
+                                pm_dev_err(dev, state, " early", error);
+                }
 }
 
 /**
  *      device_power_up - Turn on all devices that need special attention.
+ *      @state: PM transition of the system being carried out.
  *
  *      Power on system devices, then devices that required we shut them down
  *      with interrupts disabled.
  *
  *      Must be called with interrupts disabled.
  */
-void device_power_up(void)
+void device_power_up(pm_message_t state)
 {
         sysdev_resume();
-        dpm_power_up();
+        dpm_power_up(state);
 }
 EXPORT_SYMBOL_GPL(device_power_up);
 
 /**
  *      resume_device - Restore state for one device.
  *      @dev:   Device.
- *
+ *      @state: PM transition of the system being carried out.
  */
-static int resume_device(struct device *dev)
+static int resume_device(struct device *dev, pm_message_t state)
 {
         int error = 0;
 
@@ -175,21 +360,40 @@ static int resume_device(struct device *dev)
 
         down(&dev->sem);
 
-        if (dev->bus && dev->bus->resume) {
-                dev_dbg(dev,"resuming\n");
-                error = dev->bus->resume(dev);
+        if (dev->bus) {
+                if (dev->bus->pm) {
+                        pm_dev_dbg(dev, state, "");
+                        error = pm_op(dev, &dev->bus->pm->base, state);
+                } else if (dev->bus->resume) {
+                        pm_dev_dbg(dev, state, "legacy ");
+                        error = dev->bus->resume(dev);
+                }
+                if (error)
+                        goto End;
         }
 
-        if (!error && dev->type && dev->type->resume) {
-                dev_dbg(dev,"resuming\n");
-                error = dev->type->resume(dev);
+        if (dev->type) {
+                if (dev->type->pm) {
+                        pm_dev_dbg(dev, state, "type ");
+                        error = pm_op(dev, dev->type->pm, state);
+                } else if (dev->type->resume) {
+                        pm_dev_dbg(dev, state, "legacy type ");
+                        error = dev->type->resume(dev);
+                }
+                if (error)
+                        goto End;
         }
 
-        if (!error && dev->class && dev->class->resume) {
-                dev_dbg(dev,"class resume\n");
-                error = dev->class->resume(dev);
+        if (dev->class) {
+                if (dev->class->pm) {
+                        pm_dev_dbg(dev, state, "class ");
+                        error = pm_op(dev, dev->class->pm, state);
+                } else if (dev->class->resume) {
+                        pm_dev_dbg(dev, state, "legacy class ");
+                        error = dev->class->resume(dev);
+                }
         }
-
+ End:
         up(&dev->sem);
 
         TRACE_RESUME(error);
@@ -198,78 +402,161 @@ static int resume_device(struct device *dev)
 
 /**
  *      dpm_resume - Resume every device.
+ *      @state: PM transition of the system being carried out.
  *
- *      Resume the devices that have either not gone through
- *      the late suspend, or that did go through it but also
- *      went through the early resume.
+ *      Execute the appropriate "resume" callback for all devices the status of
+ *      which indicates that they are inactive.
+ */
+static void dpm_resume(pm_message_t state)
+{
+        struct list_head list;
+
+        INIT_LIST_HEAD(&list);
+        mutex_lock(&dpm_list_mtx);
+        transition_started = false;
+        while (!list_empty(&dpm_list)) {
+                struct device *dev = to_device(dpm_list.next);
+
+                get_device(dev);
+                if (dev->power.status >= DPM_OFF) {
+                        int error;
+
+                        dev->power.status = DPM_RESUMING;
+                        mutex_unlock(&dpm_list_mtx);
+
+                        error = resume_device(dev, state);
+
+                        mutex_lock(&dpm_list_mtx);
+                        if (error)
+                                pm_dev_err(dev, state, "", error);
+                } else if (dev->power.status == DPM_SUSPENDING) {
+                        /* Allow new children of the device to be registered */
+                        dev->power.status = DPM_RESUMING;
+                }
+                if (!list_empty(&dev->power.entry))
+                        list_move_tail(&dev->power.entry, &list);
+                put_device(dev);
+        }
+        list_splice(&list, &dpm_list);
+        mutex_unlock(&dpm_list_mtx);
+}
+
+/**
+ *      complete_device - Complete a PM transition for given device
+ *      @dev:   Device.
+ *      @state: PM transition of the system being carried out.
+ */
+static void complete_device(struct device *dev, pm_message_t state)
+{
+        down(&dev->sem);
+
+        if (dev->class && dev->class->pm && dev->class->pm->complete) {
+                pm_dev_dbg(dev, state, "completing class ");
+                dev->class->pm->complete(dev);
+        }
+
+        if (dev->type && dev->type->pm && dev->type->pm->complete) {
+                pm_dev_dbg(dev, state, "completing type ");
+                dev->type->pm->complete(dev);
+        }
+
+        if (dev->bus && dev->bus->pm && dev->bus->pm->base.complete) {
+                pm_dev_dbg(dev, state, "completing ");
+                dev->bus->pm->base.complete(dev);
+        }
+
+        up(&dev->sem);
+}
+
+/**
+ *      dpm_complete - Complete a PM transition for all devices.
+ *      @state: PM transition of the system being carried out.
  *
- *      Take devices from the dpm_off_list, resume them,
- *      and put them on the dpm_locked list.
+ *      Execute the ->complete() callbacks for all devices that are not marked
+ *      as DPM_ON.
  */
-static void dpm_resume(void)
+static void dpm_complete(pm_message_t state)
 {
+        struct list_head list;
+
+        INIT_LIST_HEAD(&list);
         mutex_lock(&dpm_list_mtx);
-        all_sleeping = false;
-        while(!list_empty(&dpm_off)) {
-                struct list_head *entry = dpm_off.next;
-                struct device *dev = to_device(entry);
+        while (!list_empty(&dpm_list)) {
+                struct device *dev = to_device(dpm_list.prev);
 
-                list_move_tail(entry, &dpm_active);
-                dev->power.sleeping = false;
-                mutex_unlock(&dpm_list_mtx);
-                resume_device(dev);
-                mutex_lock(&dpm_list_mtx);
+                get_device(dev);
+                if (dev->power.status > DPM_ON) {
+                        dev->power.status = DPM_ON;
+                        mutex_unlock(&dpm_list_mtx);
+
+                        complete_device(dev, state);
+
+                        mutex_lock(&dpm_list_mtx);
+                }
+                if (!list_empty(&dev->power.entry))
+                        list_move(&dev->power.entry, &list);
+                put_device(dev);
         }
+        list_splice(&list, &dpm_list);
         mutex_unlock(&dpm_list_mtx);
 }
 
 /**
  *      device_resume - Restore state of each device in system.
+ *      @state: PM transition of the system being carried out.
  *
  *      Resume all the devices, unlock them all, and allow new
  *      devices to be registered once again.
  */
-void device_resume(void)
+void device_resume(pm_message_t state)
 {
         might_sleep();
-        dpm_resume();
+        dpm_resume(state);
+        dpm_complete(state);
 }
 EXPORT_SYMBOL_GPL(device_resume);
 
 
 /*------------------------- Suspend routines -------------------------*/
 
-static inline char *suspend_verb(u32 event)
+/**
+ *      resume_event - return a PM message representing the resume event
+ *                     corresponding to given sleep state.
+ *      @sleep_state: PM message representing a sleep state.
+ */
+static pm_message_t resume_event(pm_message_t sleep_state)
 {
-        switch (event) {
-        case PM_EVENT_SUSPEND:  return "suspend";
-        case PM_EVENT_FREEZE:   return "freeze";
-        case PM_EVENT_PRETHAW:  return "prethaw";
-        default:                return "(unknown suspend event)";
+        switch (sleep_state.event) {
+        case PM_EVENT_SUSPEND:
+                return PMSG_RESUME;
+        case PM_EVENT_FREEZE:
+        case PM_EVENT_QUIESCE:
+                return PMSG_RECOVER;
+        case PM_EVENT_HIBERNATE:
+                return PMSG_RESTORE;
         }
-}
-
-static void
-suspend_device_dbg(struct device *dev, pm_message_t state, char *info)
-{
-        dev_dbg(dev, "%s%s%s\n", info, suspend_verb(state.event),
-                ((state.event == PM_EVENT_SUSPEND) && device_may_wakeup(dev)) ?
-                ", may wakeup" : "");
+        return PMSG_ON;
 }
 
 /**
- *      suspend_device_late - Shut down one device (late suspend).
+ *      suspend_device_noirq - Shut down one device (late suspend).
  *      @dev:   Device.
- *      @state: Power state device is entering.
+ *      @state: PM transition of the system being carried out.
  *
  *      This is called with interrupts off and only a single CPU running.
  */
-static int suspend_device_late(struct device *dev, pm_message_t state)
+static int suspend_device_noirq(struct device *dev, pm_message_t state)
 {
         int error = 0;
 
-        if (dev->bus && dev->bus->suspend_late) {
-                suspend_device_dbg(dev, state, "LATE ");
+        if (!dev->bus)
+                return 0;
+
+        if (dev->bus->pm) {
+                pm_dev_dbg(dev, state, "LATE ");
+                error = pm_noirq_op(dev, dev->bus->pm, state);
+        } else if (dev->bus->suspend_late) {
+                pm_dev_dbg(dev, state, "legacy LATE ");
                 error = dev->bus->suspend_late(dev, state);
                 suspend_report_result(dev->bus->suspend_late, error);
         }
@@ -278,37 +565,30 @@ static int suspend_device_late(struct device *dev, pm_message_t state)
 
 /**
  *      device_power_down - Shut down special devices.
- *      @state:         Power state to enter.
+ *      @state: PM transition of the system being carried out.
  *
- *      Power down devices that require interrupts to be disabled
- *      and move them from the dpm_off list to the dpm_off_irq list.
+ *      Power down devices that require interrupts to be disabled.
  *      Then power down system devices.
  *
  *      Must be called with interrupts disabled and only one CPU running.
  */
 int device_power_down(pm_message_t state)
 {
+        struct device *dev;
         int error = 0;
 
-        while (!list_empty(&dpm_off)) {
-                struct list_head *entry = dpm_off.prev;
-                struct device *dev = to_device(entry);
-
-                error = suspend_device_late(dev, state);
+        list_for_each_entry_reverse(dev, &dpm_list, power.entry) {
+                error = suspend_device_noirq(dev, state);
                 if (error) {
-                        printk(KERN_ERR "Could not power down device %s: "
-                                        "error %d\n",
-                                        kobject_name(&dev->kobj), error);
+                        pm_dev_err(dev, state, " late", error);
                         break;
                 }
-                if (!list_empty(&dev->power.entry))
-                        list_move(&dev->power.entry, &dpm_off_irq);
+                dev->power.status = DPM_OFF_IRQ;
         }
-
         if (!error)
                 error = sysdev_suspend(state);
         if (error)
-                dpm_power_up();
+                dpm_power_up(resume_event(state));
         return error;
 }
 EXPORT_SYMBOL_GPL(device_power_down);
@@ -316,7 +596,7 @@ EXPORT_SYMBOL_GPL(device_power_down);
 /**
  *      suspend_device - Save state of one device.
  *      @dev:   Device.
- *      @state: Power state device is entering.
+ *      @state: PM transition of the system being carried out.
  */
 static int suspend_device(struct device *dev, pm_message_t state)
 {
@@ -324,24 +604,43 @@ static int suspend_device(struct device *dev, pm_message_t state)
 
         down(&dev->sem);
 
-        if (dev->class && dev->class->suspend) {
-                suspend_device_dbg(dev, state, "class ");
-                error = dev->class->suspend(dev, state);
-                suspend_report_result(dev->class->suspend, error);
+        if (dev->class) {
+                if (dev->class->pm) {
+                        pm_dev_dbg(dev, state, "class ");
+                        error = pm_op(dev, dev->class->pm, state);
+                } else if (dev->class->suspend) {
+                        pm_dev_dbg(dev, state, "legacy class ");
+                        error = dev->class->suspend(dev, state);
+                        suspend_report_result(dev->class->suspend, error);
+                }
+                if (error)
+                        goto End;
         }
 
-        if (!error && dev->type && dev->type->suspend) {
-                suspend_device_dbg(dev, state, "type ");
-                error = dev->type->suspend(dev, state);
-                suspend_report_result(dev->type->suspend, error);
+        if (dev->type) {
+                if (dev->type->pm) {
+                        pm_dev_dbg(dev, state, "type ");
+                        error = pm_op(dev, dev->type->pm, state);
+                } else if (dev->type->suspend) {
+                        pm_dev_dbg(dev, state, "legacy type ");
+                        error = dev->type->suspend(dev, state);
+                        suspend_report_result(dev->type->suspend, error);
+                }
+                if (error)
+                        goto End;
         }
 
-        if (!error && dev->bus && dev->bus->suspend) {
-                suspend_device_dbg(dev, state, "");
-                error = dev->bus->suspend(dev, state);
-                suspend_report_result(dev->bus->suspend, error);
+        if (dev->bus) {
+                if (dev->bus->pm) {
+                        pm_dev_dbg(dev, state, "");
+                        error = pm_op(dev, &dev->bus->pm->base, state);
+                } else if (dev->bus->suspend) {
+                        pm_dev_dbg(dev, state, "legacy ");
+                        error = dev->bus->suspend(dev, state);
+                        suspend_report_result(dev->bus->suspend, error);
+                }
         }
-
+ End:
         up(&dev->sem);
 
         return error;
@@ -349,67 +648,141 @@ static int suspend_device(struct device *dev, pm_message_t state)
 
 /**
  *      dpm_suspend - Suspend every device.
- *      @state: Power state to put each device in.
+ *      @state: PM transition of the system being carried out.
  *
- *      Walk the dpm_locked list.  Suspend each device and move it
- *      to the dpm_off list.
- *
- *      (For historical reasons, if it returns -EAGAIN, that used to mean
- *      that the device would be called again with interrupts disabled.
- *      These days, we use the "suspend_late()" callback for that, so we
- *      print a warning and consider it an error).
+ *      Execute the appropriate "suspend" callbacks for all devices.
  */
 static int dpm_suspend(pm_message_t state)
 {
+        struct list_head list;
         int error = 0;
 
+        INIT_LIST_HEAD(&list);
         mutex_lock(&dpm_list_mtx);
-        while (!list_empty(&dpm_active)) {
-                struct list_head *entry = dpm_active.prev;
-                struct device *dev = to_device(entry);
-
-                WARN_ON(dev->parent && dev->parent->power.sleeping);
+        while (!list_empty(&dpm_list)) {
+                struct device *dev = to_device(dpm_list.prev);
 
-                dev->power.sleeping = true;
+                get_device(dev);
                 mutex_unlock(&dpm_list_mtx);
+
                 error = suspend_device(dev, state);
+
                 mutex_lock(&dpm_list_mtx);
                 if (error) {
-                        printk(KERN_ERR "Could not suspend device %s: "
-                                        "error %d%s\n",
-                                        kobject_name(&dev->kobj),
-                                        error,
-                                        (error == -EAGAIN ?
-                                        " (please convert to suspend_late)" :
-                                        ""));
-                        dev->power.sleeping = false;
+                        pm_dev_err(dev, state, "", error);
+                        put_device(dev);
                         break;
                 }
+                dev->power.status = DPM_OFF;
                 if (!list_empty(&dev->power.entry))
-                        list_move(&dev->power.entry, &dpm_off);
+                        list_move(&dev->power.entry, &list);
+                put_device(dev);
         }
-        if (!error)
-                all_sleeping = true;
+        list_splice(&list, dpm_list.prev);
         mutex_unlock(&dpm_list_mtx);
+        return error;
+}
+
+/**
+ *      prepare_device - Execute the ->prepare() callback(s) for given device.
+ *      @dev:   Device.
+ *      @state: PM transition of the system being carried out.
+ */
+static int prepare_device(struct device *dev, pm_message_t state)
+{
+        int error = 0;
+
+        down(&dev->sem);
+
+        if (dev->bus && dev->bus->pm && dev->bus->pm->base.prepare) {
+                pm_dev_dbg(dev, state, "preparing ");
+                error = dev->bus->pm->base.prepare(dev);
+                suspend_report_result(dev->bus->pm->base.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->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:
+        up(&dev->sem);
+
+        return error;
+}
 
+/**
+ *      dpm_prepare - Prepare all devices for a PM transition.
+ *      @state: PM transition of the system being carried out.
+ *
+ *      Execute the ->prepare() callback for all devices.
+ */
+static int dpm_prepare(pm_message_t state)
+{
+        struct list_head list;
+        int error = 0;
+
+        INIT_LIST_HEAD(&list);
+        mutex_lock(&dpm_list_mtx);
+        transition_started = true;
+        while (!list_empty(&dpm_list)) {
+                struct device *dev = to_device(dpm_list.next);
+
+                get_device(dev);
+                dev->power.status = DPM_PREPARING;
+                mutex_unlock(&dpm_list_mtx);
+
+                error = prepare_device(dev, state);
+
+                mutex_lock(&dpm_list_mtx);
+                if (error) {
+                        dev->power.status = DPM_ON;
+                        if (error == -EAGAIN) {
+                                put_device(dev);
+                                continue;
+                        }
+                        printk(KERN_ERR "PM: Failed to prepare device %s "
+                                "for power transition: error %d\n",
+                                kobject_name(&dev->kobj), error);
+                        put_device(dev);
+                        break;
+                }
+                dev->power.status = DPM_SUSPENDING;
+                if (!list_empty(&dev->power.entry))
+                        list_move_tail(&dev->power.entry, &list);
+                put_device(dev);
+        }
+        list_splice(&list, &dpm_list);
+        mutex_unlock(&dpm_list_mtx);
         return error;
 }
 
 /**
  *      device_suspend - Save state and stop all devices in system.
- *      @state: new power management state
+ *      @state: PM transition of the system being carried out.
  *
- *      Prevent new devices from being registered, then lock all devices
- *      and suspend them.
+ *      Prepare and suspend all devices.
  */
 int device_suspend(pm_message_t state)
 {
         int error;
 
         might_sleep();
-        error = dpm_suspend(state);
+        error = dpm_prepare(state);
+        if (!error)
+                error = dpm_suspend(state);
         if (error)
-                device_resume();
+                device_resume(resume_event(state));
         return error;
 }
 EXPORT_SYMBOL_GPL(device_suspend);
diff --git a/drivers/base/power/power.h b/drivers/base/power/power.h
index a6894f2a4b99..a3252c0e2887 100644
--- a/drivers/base/power/power.h
+++ b/drivers/base/power/power.h
@@ -4,7 +4,7 @@
  * main.c
  */
 
-extern struct list_head dpm_active;     /* The active device list */
+extern struct list_head dpm_list;       /* The active device list */
 
 static inline struct device *to_device(struct list_head *entry)
 {
diff --git a/drivers/base/power/trace.c b/drivers/base/power/trace.c
index 2b4b392dcbc1..8c1e656b5f8b 100644
--- a/drivers/base/power/trace.c
+++ b/drivers/base/power/trace.c
@@ -188,9 +188,9 @@ static int show_file_hash(unsigned int value)
 static int show_dev_hash(unsigned int value)
 {
         int match = 0;
-        struct list_head * entry = dpm_active.prev;
+        struct list_head *entry = dpm_list.prev;
 
-        while (entry != &dpm_active) {
+        while (entry != &dpm_list) {
                 struct device * dev = to_device(entry);
                 unsigned int hash = hash_string(DEVSEED, dev->bus_id, DEVHASH);
                 if (hash == value) {