3 files changed, 116 insertions, 48 deletions

diff --git a/drivers/base/power/resume.c b/drivers/base/power/resume.c
index 826093ef4c7e..020be36705a6 100644
--- a/drivers/base/power/resume.c
+++ b/drivers/base/power/resume.c
@@ -38,13 +38,35 @@ int resume_device(struct device * dev)
                 dev_dbg(dev,"resuming\n");
                 error = dev->bus->resume(dev);
         }
+        if (dev->class && dev->class->resume) {
+                dev_dbg(dev,"class resume\n");
+                error = dev->class->resume(dev);
+        }
         up(&dev->sem);
         TRACE_RESUME(error);
         return error;
 }
 
 
+static int resume_device_early(struct device * dev)
+{
+        int error = 0;
 
+        TRACE_DEVICE(dev);
+        TRACE_RESUME(0);
+        if (dev->bus && dev->bus->resume_early) {
+                dev_dbg(dev,"EARLY resume\n");
+                error = dev->bus->resume_early(dev);
+        }
+        TRACE_RESUME(error);
+        return error;
+}
+
+/*
+ * 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
+ */
 void dpm_resume(void)
 {
         down(&dpm_list_sem);
@@ -74,6 +96,7 @@ void dpm_resume(void)
 
 void device_resume(void)
 {
+        might_sleep();
         down(&dpm_sem);
         dpm_resume();
         up(&dpm_sem);
@@ -83,12 +106,12 @@ EXPORT_SYMBOL_GPL(device_resume);
 
 
 /**
- *      device_power_up_irq - Power on some devices.
+ *      dpm_power_up - Power on some devices.
  *
  *      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_suspended list.
+ *      interrupts disabled. As devices are powered on, they are moved
+ *      to the dpm_active list.
  *
  *      Interrupts must be disabled when calling this.
  */
@@ -99,16 +122,14 @@ void dpm_power_up(void)
                 struct list_head * entry = dpm_off_irq.next;
                 struct device * dev = to_device(entry);
 
-                get_device(dev);
-                list_move_tail(entry, &dpm_active);
-                resume_device(dev);
-                put_device(dev);
+                list_move_tail(entry, &dpm_off);
+                resume_device_early(dev);
         }
 }
 
 
 /**
- *      device_pm_power_up - Turn on all devices that need special attention.
+ *      device_power_up - Turn on all devices that need special attention.
  *
  *      Power on system devices then devices that required we shut them down
  *      with interrupts disabled.
diff --git a/drivers/base/power/suspend.c b/drivers/base/power/suspend.c
index 69509e02f703..ece136bf97e3 100644
--- a/drivers/base/power/suspend.c
+++ b/drivers/base/power/suspend.c
@@ -34,6 +34,7 @@ static inline char *suspend_verb(u32 event)
         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)";
         }
 }
@@ -65,7 +66,19 @@ int suspend_device(struct device * dev, pm_message_t state)
 
         dev->power.prev_state = dev->power.power_state;
 
-        if (dev->bus && dev->bus->suspend && !dev->power.power_state.event) {
+        if (dev->class && dev->class->suspend && !dev->power.power_state.event) {
+                dev_dbg(dev, "class %s%s\n",
+                        suspend_verb(state.event),
+                        ((state.event == PM_EVENT_SUSPEND)
+                                        && device_may_wakeup(dev))
+                                ? ", may wakeup"
+                                : ""
+                        );
+                error = dev->class->suspend(dev, state);
+                suspend_report_result(dev->class->suspend, error);
+        }
+
+        if (!error && dev->bus && dev->bus->suspend && !dev->power.power_state.event) {
                 dev_dbg(dev, "%s%s\n",
                         suspend_verb(state.event),
                         ((state.event == PM_EVENT_SUSPEND)
@@ -81,15 +94,42 @@ int suspend_device(struct device * dev, pm_message_t state)
 }
 
 
+/*
+ * This is called with interrupts off, only a single CPU
+ * running. We can't do down() on a semaphore (and we don't
+ * need the protection)
+ */
+static int suspend_device_late(struct device *dev, pm_message_t state)
+{
+        int error = 0;
+
+        if (dev->bus && dev->bus->suspend_late && !dev->power.power_state.event) {
+                dev_dbg(dev, "LATE %s%s\n",
+                        suspend_verb(state.event),
+                        ((state.event == PM_EVENT_SUSPEND)
+                                        && device_may_wakeup(dev))
+                                ? ", may wakeup"
+                                : ""
+                        );
+                error = dev->bus->suspend_late(dev, state);
+                suspend_report_result(dev->bus->suspend_late, error);
+        }
+        return error;
+}
+
 /**
  *      device_suspend - Save state and stop all devices in system.
  *      @state:         Power state to put each device in.
  *
  *      Walk the dpm_active list, call ->suspend() for each device, and move
- *      it to dpm_off.
- *      Check the return value for each. If it returns 0, then we move the
- *      the device to the dpm_off list. If it returns -EAGAIN, we move it to
- *      the dpm_off_irq list. If we get a different error, try and back out.
+ *      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).
+ *
+ *      If we get a different error, try and back out.
  *
  *      If we hit a failure with any of the devices, call device_resume()
  *      above to bring the suspended devices back to life.
@@ -100,6 +140,7 @@ int device_suspend(pm_message_t state)
 {
         int error = 0;
 
+        might_sleep();
         down(&dpm_sem);
         down(&dpm_list_sem);
         while (!list_empty(&dpm_active) && error == 0) {
@@ -115,39 +156,27 @@ int device_suspend(pm_message_t state)
 
                 /* Check if the device got removed */
                 if (!list_empty(&dev->power.entry)) {
-                        /* Move it to the dpm_off or dpm_off_irq list */
+                        /* Move it to the dpm_off list */
                         if (!error)
                                 list_move(&dev->power.entry, &dpm_off);
-                        else if (error == -EAGAIN) {
-                                list_move(&dev->power.entry, &dpm_off_irq);
-                                error = 0;
-                        }
                 }
                 if (error)
                         printk(KERN_ERR "Could not suspend device %s: "
-                                "error %d\n", kobject_name(&dev->kobj), error);
+                                "error %d%s\n",
+                                kobject_name(&dev->kobj), error,
+                                error == -EAGAIN ? " (please convert to suspend_late)" : "");
                 put_device(dev);
         }
         up(&dpm_list_sem);
-        if (error) {
-                /* we failed... before resuming, bring back devices from
-                 * dpm_off_irq list back to main dpm_off list, we do want
-                 * to call resume() on them, in case they partially suspended
-                 * despite returning -EAGAIN
-                 */
-                while (!list_empty(&dpm_off_irq)) {
-                        struct list_head * entry = dpm_off_irq.next;
-                        list_move(entry, &dpm_off);
-                }
+        if (error)
                 dpm_resume();
-        }
+
         up(&dpm_sem);
         return error;
 }
 
 EXPORT_SYMBOL_GPL(device_suspend);
 
-
 /**
  *      device_power_down - Shut down special devices.
  *      @state:         Power state to enter.
@@ -162,14 +191,17 @@ int device_power_down(pm_message_t state)
         int error = 0;
         struct device * dev;
 
-        list_for_each_entry_reverse(dev, &dpm_off_irq, power.entry) {
-                if ((error = suspend_device(dev, state)))
-                        break;
+        while (!list_empty(&dpm_off)) {
+                struct list_head * entry = dpm_off.prev;
+
+                dev = to_device(entry);
+                error = suspend_device_late(dev, state);
+                if (error)
+                        goto Error;
+                list_move(&dev->power.entry, &dpm_off_irq);
         }
-        if (error)
-                goto Error;
-        if ((error = sysdev_suspend(state)))
-                goto Error;
+
+        error = sysdev_suspend(state);
  Done:
         return error;
  Error:
diff --git a/drivers/base/power/sysfs.c b/drivers/base/power/sysfs.c
index 40d7242a07c1..2d47517dbe32 100644
--- a/drivers/base/power/sysfs.c
+++ b/drivers/base/power/sysfs.c
@@ -7,22 +7,29 @@
 #include "power.h"
 
 
+#ifdef  CONFIG_PM_SYSFS_DEPRECATED
+
 /**
  *      state - Control current power state of device
  *
  *      show() returns the current power state of the device. '0' indicates
- *      the device is on. Other values (1-3) indicate the device is in a low
+ *      the device is on. Other values (2) indicate the device is in some low
  *      power state.
  *
- *      store() sets the current power state, which is an integer value
- *      between 0-3. If the device is on ('0'), and the value written is
- *      greater than 0, then the device is placed directly into the low-power
- *      state (via its driver's ->suspend() method).
- *      If the device is currently in a low-power state, and the value is 0,
- *      the device is powered back on (via the ->resume() method).
- *      If the device is in a low-power state, and a different low-power state
- *      is requested, the device is first resumed, then suspended into the new
- *      low-power state.
+ *      store() sets the current power state, which is an integer valued
+ *      0, 2, or 3.  Devices with bus.suspend_late(), or bus.resume_early()
+ *      methods fail this operation; those methods couldn't be called.
+ *      Otherwise,
+ *
+ *      - If the recorded dev->power.power_state.event matches the
+ *        target value, nothing is done.
+ *      - If the recorded event code is nonzero, the device is reactivated
+ *        by calling bus.resume() and/or class.resume().
+ *      - If the target value is nonzero, the device is suspended by
+ *        calling class.suspend() and/or bus.suspend() with event code
+ *        PM_EVENT_SUSPEND.
+ *
+ *      This mechanism is DEPRECATED and should only be used for testing.
  */
 
 static ssize_t state_show(struct device * dev, struct device_attribute *attr, char * buf)
@@ -38,6 +45,10 @@ static ssize_t state_store(struct device * dev, struct device_attribute *attr, c
         pm_message_t state;
         int error = -EINVAL;
 
+        /* disallow incomplete suspend sequences */
+        if (dev->bus && (dev->bus->suspend_late || dev->bus->resume_early))
+                return error;
+
         state.event = PM_EVENT_SUSPEND;
         /* Older apps expected to write "3" here - confused with PCI D3 */
         if ((n == 1) && !strcmp(buf, "3"))
@@ -57,6 +68,8 @@ static ssize_t state_store(struct device * dev, struct device_attribute *attr, c
 static DEVICE_ATTR(state, 0644, state_show, state_store);
 
 
+#endif  /* CONFIG_PM_SYSFS_DEPRECATED */
+
 /*
  *      wakeup - Report/change current wakeup option for device
  *
@@ -130,7 +143,9 @@ static DEVICE_ATTR(wakeup, 0644, wake_show, wake_store);
 
 
 static struct attribute * power_attrs[] = {
+#ifdef  CONFIG_PM_SYSFS_DEPRECATED
         &dev_attr_state.attr,
+#endif
         &dev_attr_wakeup.attr,
         NULL,
 };