PM: merge device power-management source files

This patch (as993) merges the suspend.c and resume.c files in
drivers/base/power into main.c, making some public symbols private.

Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Acked-by: Rafael J. Wysocki <rjw@sisk.pl>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

5 files changed, 343 insertions, 394 deletions

diff --git a/drivers/base/power/Makefile b/drivers/base/power/Makefile
index 9caeaea753a3..a803733c839e 100644
--- a/drivers/base/power/Makefile
+++ b/drivers/base/power/Makefile
@@ -1,5 +1,5 @@
 obj-y                   := shutdown.o
-obj-$(CONFIG_PM_SLEEP)  += main.o suspend.o resume.o sysfs.o
+obj-$(CONFIG_PM_SLEEP)  += main.o sysfs.o
 obj-$(CONFIG_PM_TRACE)  += trace.o
 
 ifeq ($(CONFIG_DEBUG_DRIVER),y)
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index eb9f38d0aa58..0ab4ab21f564 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -20,19 +20,24 @@
  */
 
 #include <linux/device.h>
+#include <linux/kallsyms.h>
 #include <linux/mutex.h>
+#include <linux/pm.h>
+#include <linux/resume-trace.h>
 
+#include "../base.h"
 #include "power.h"
 
 LIST_HEAD(dpm_active);
-LIST_HEAD(dpm_off);
-LIST_HEAD(dpm_off_irq);
+static LIST_HEAD(dpm_off);
+static LIST_HEAD(dpm_off_irq);
 
-DEFINE_MUTEX(dpm_mtx);
-DEFINE_MUTEX(dpm_list_mtx);
+static DEFINE_MUTEX(dpm_mtx);
+static DEFINE_MUTEX(dpm_list_mtx);
 
 int (*platform_enable_wakeup)(struct device *dev, int is_on);
 
+
 int device_pm_add(struct device *dev)
 {
         int error;
@@ -61,3 +66,334 @@ void device_pm_remove(struct device *dev)
 }
 
 
+/*------------------------- Resume routines -------------------------*/
+
+/**
+ *      resume_device - Restore state for one device.
+ *      @dev:   Device.
+ *
+ */
+
+static int resume_device(struct device * dev)
+{
+        int error = 0;
+
+        TRACE_DEVICE(dev);
+        TRACE_RESUME(0);
+
+        down(&dev->sem);
+
+        if (dev->bus && dev->bus->resume) {
+                dev_dbg(dev,"resuming\n");
+                error = dev->bus->resume(dev);
+        }
+
+        if (!error && dev->type && dev->type->resume) {
+                dev_dbg(dev,"resuming\n");
+                error = dev->type->resume(dev);
+        }
+
+        if (!error && 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
+ */
+static void dpm_resume(void)
+{
+        mutex_lock(&dpm_list_mtx);
+        while(!list_empty(&dpm_off)) {
+                struct list_head * entry = dpm_off.next;
+                struct device * dev = to_device(entry);
+
+                get_device(dev);
+                list_move_tail(entry, &dpm_active);
+
+                mutex_unlock(&dpm_list_mtx);
+                resume_device(dev);
+                mutex_lock(&dpm_list_mtx);
+                put_device(dev);
+        }
+        mutex_unlock(&dpm_list_mtx);
+}
+
+
+/**
+ *      device_resume - Restore state of each device in system.
+ *
+ *      Walk the dpm_off list, remove each entry, resume the device,
+ *      then add it to the dpm_active list.
+ */
+
+void device_resume(void)
+{
+        might_sleep();
+        mutex_lock(&dpm_mtx);
+        dpm_resume();
+        mutex_unlock(&dpm_mtx);
+}
+
+EXPORT_SYMBOL_GPL(device_resume);
+
+
+/**
+ *      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_active list.
+ *
+ *      Interrupts must be disabled when calling this.
+ */
+
+static void dpm_power_up(void)
+{
+        while(!list_empty(&dpm_off_irq)) {
+                struct list_head * entry = dpm_off_irq.next;
+                struct device * dev = to_device(entry);
+
+                list_move_tail(entry, &dpm_off);
+                resume_device_early(dev);
+        }
+}
+
+
+/**
+ *      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.
+ *      Called with interrupts disabled.
+ */
+
+void device_power_up(void)
+{
+        sysdev_resume();
+        dpm_power_up();
+}
+
+EXPORT_SYMBOL_GPL(device_power_up);
+
+
+/*------------------------- Suspend routines -------------------------*/
+
+/*
+ * The entries in the dpm_active 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 list on the suspend path are done in reverse order, so we operate
+ * on the leaves of the device tree (or forests, depending on how you want
+ * to look at it ;) first. As nodes are removed from the back of the list,