5 files changed, 132 insertions, 127 deletions

diff --git a/kernel/power/disk.c b/kernel/power/disk.c
index 06331374d86..b5f0543ed84 100644
--- a/kernel/power/disk.c
+++ b/kernel/power/disk.c
@@ -30,30 +30,69 @@ char resume_file[256] = CONFIG_PM_STD_PARTITION;
 dev_t swsusp_resume_device;
 sector_t swsusp_resume_block;
 
+enum {
+        HIBERNATION_INVALID,
+        HIBERNATION_PLATFORM,
+        HIBERNATION_TEST,
+        HIBERNATION_TESTPROC,
+        HIBERNATION_SHUTDOWN,
+        HIBERNATION_REBOOT,
+        /* keep last */
+        __HIBERNATION_AFTER_LAST
+};
+#define HIBERNATION_MAX (__HIBERNATION_AFTER_LAST-1)
+#define HIBERNATION_FIRST (HIBERNATION_INVALID + 1)
+
+static int hibernation_mode = HIBERNATION_SHUTDOWN;
+
+struct hibernation_ops *hibernation_ops;
+
+/**
+ * hibernation_set_ops - set the global hibernate operations
+ * @ops: the hibernation operations to use in subsequent hibernation transitions
+ */
+
+void hibernation_set_ops(struct hibernation_ops *ops)
+{
+        if (ops && !(ops->prepare && ops->enter && ops->finish)) {
+                WARN_ON(1);
+                return;
+        }
+        mutex_lock(&pm_mutex);
+        hibernation_ops = ops;
+        if (ops)
+                hibernation_mode = HIBERNATION_PLATFORM;
+        else if (hibernation_mode == HIBERNATION_PLATFORM)
+                hibernation_mode = HIBERNATION_SHUTDOWN;
+
+        mutex_unlock(&pm_mutex);
+}
+
+
 /**
  *      platform_prepare - prepare the machine for hibernation using the
  *      platform driver if so configured and return an error code if it fails
  */
 
-static inline int platform_prepare(void)
+static int platform_prepare(void)
 {
-        int error = 0;
+        return (hibernation_mode == HIBERNATION_PLATFORM && hibernation_ops) ?
+                hibernation_ops->prepare() : 0;
+}
 
-        switch (pm_disk_mode) {
-        case PM_DISK_TEST:
-        case PM_DISK_TESTPROC:
-        case PM_DISK_SHUTDOWN:
-        case PM_DISK_REBOOT:
-                break;
-        default:
-                if (pm_ops && pm_ops->prepare)
-                        error = pm_ops->prepare(PM_SUSPEND_DISK);
-        }
-        return error;
+/**
+ *      platform_finish - switch the machine to the normal mode of operation
+ *      using the platform driver (must be called after platform_prepare())
+ */
+
+static void platform_finish(void)
+{
+        if (hibernation_mode == HIBERNATION_PLATFORM && hibernation_ops)
+                hibernation_ops->finish();
 }
 
 /**
- *      power_down - Shut machine down for hibernate.
+ *      power_down - Shut the machine down for hibernation.
  *
  *      Use the platform driver, if configured so; otherwise try
  *      to power off or reboot.
@@ -61,20 +100,20 @@ static inline int platform_prepare(void)
 
 static void power_down(void)
 {
-        switch (pm_disk_mode) {
-        case PM_DISK_TEST:
-        case PM_DISK_TESTPROC:
+        switch (hibernation_mode) {
+        case HIBERNATION_TEST:
+        case HIBERNATION_TESTPROC:
                 break;
-        case PM_DISK_SHUTDOWN:
+        case HIBERNATION_SHUTDOWN:
                 kernel_power_off();
                 break;
-        case PM_DISK_REBOOT:
+        case HIBERNATION_REBOOT:
                 kernel_restart(NULL);
                 break;
-        default:
-                if (pm_ops && pm_ops->enter) {
+        case HIBERNATION_PLATFORM:
+                if (hibernation_ops) {
                         kernel_shutdown_prepare(SYSTEM_SUSPEND_DISK);
-                        pm_ops->enter(PM_SUSPEND_DISK);
+                        hibernation_ops->enter();
                         break;
                 }
         }
@@ -87,20 +126,6 @@ static void power_down(void)
         while(1);
 }
 
-static inline void platform_finish(void)
-{
-        switch (pm_disk_mode) {
-        case PM_DISK_TEST:
-        case PM_DISK_TESTPROC:
-        case PM_DISK_SHUTDOWN:
-        case PM_DISK_REBOOT:
-                break;
-        default:
-                if (pm_ops && pm_ops->finish)
-                        pm_ops->finish(PM_SUSPEND_DISK);
-        }
-}
-
 static void unprepare_processes(void)
 {
         thaw_processes();
@@ -120,13 +145,10 @@ static int prepare_processes(void)
 }
 
 /**
- *      pm_suspend_disk - The granpappy of hibernation power management.
- *
- *      If not, then call swsusp to do its thing, then figure out how
- *      to power down the system.
+ *      hibernate - The granpappy of the built-in hibernation management
  */
 
-int pm_suspend_disk(void)
+int hibernate(void)
 {
         int error;
 
@@ -143,7 +165,8 @@ int pm_suspend_disk(void)
         if (error)
                 goto Finish;
 
-        if (pm_disk_mode == PM_DISK_TESTPROC) {
+        mutex_lock(&pm_mutex);
+        if (hibernation_mode == HIBERNATION_TESTPROC) {
                 printk("swsusp debug: Waiting for 5 seconds.\n");
                 mdelay(5000);
                 goto Thaw;
@@ -168,7 +191,7 @@ int pm_suspend_disk(void)
         if (error)
                 goto Enable_cpus;
 
-        if (pm_disk_mode == PM_DISK_TEST) {
+        if (hibernation_mode == HIBERNATION_TEST) {
                 printk("swsusp debug: Waiting for 5 seconds.\n");
                 mdelay(5000);
                 goto Enable_cpus;
@@ -205,6 +228,7 @@ int pm_suspend_disk(void)
         device_resume();
         resume_console();
  Thaw:
+        mutex_unlock(&pm_mutex);
         unprepare_processes();
  Finish:
         free_basic_memory_bitmaps();
@@ -220,7 +244,7 @@ int pm_suspend_disk(void)
  *      Called as a late_initcall (so all devices are discovered and
  *      initialized), we call swsusp to see if we have a saved image or not.
  *      If so, we quiesce devices, the restore the saved image. We will
- *      return above (in pm_suspend_disk() ) if everything goes well.
+ *      return above (in hibernate() ) if everything goes well.
  *      Otherwise, we fail gracefully and return to the normally
  *      scheduled program.
  *
@@ -315,25 +339,26 @@ static int software_resume(void)
 late_initcall(software_resume);
 
 
-static const char * const pm_disk_modes[] = {
-        [PM_DISK_PLATFORM]      = "platform",
-        [PM_DISK_SHUTDOWN]      = "shutdown",
-        [PM_DISK_REBOOT]        = "reboot",
-        [PM_DISK_TEST]          = "test",
-        [PM_DISK_TESTPROC]      = "testproc",
+static const char * const hibernation_modes[] = {
+        [HIBERNATION_PLATFORM]  = "platform",
+        [HIBERNATION_SHUTDOWN]  = "shutdown",
+        [HIBERNATION_REBOOT]    = "reboot",
+        [HIBERNATION_TEST]      = "test",
+        [HIBERNATION_TESTPROC]  = "testproc",
 };
 
 /**
- *      disk - Control suspend-to-disk mode
+ *      disk - Control hibernation mode
  *
  *      Suspend-to-disk can be handled in several ways. We have a few options
  *      for putting the system to sleep - using the platform driver (e.g. ACPI
- *      or other pm_ops), powering off the system or rebooting the system
- *      (for testing) as well as the two test modes.
+ *      or other hibernation_ops), powering off the system or rebooting the
+ *      system (for testing) as well as the two test modes.
  *
  *      The system can support 'platform', and that is known a priori (and
- *      encoded in pm_ops). However, the user may choose 'shutdown' or 'reboot'
- *      as alternatives, as well as the test modes 'test' and 'testproc'.
+ *      encoded by the presence of hibernation_ops). However, the user may
+ *      choose 'shutdown' or 'reboot' as alternatives, as well as one fo the
+ *      test modes, 'test' or 'testproc'.
  *
  *      show() will display what the mode is currently set to.
  *      store() will accept one of
@@ -345,7 +370,7 @@ static const char * const pm_disk_modes[] = {
  *      'testproc'
  *
  *      It will only change to 'platform' if the system
- *      supports it (as determined from pm_ops->pm_disk_mode).
+ *      supports it (as determined by having hibernation_ops).
  */
 
 static ssize_t disk_show(struct kset *kset, char *buf)
@@ -353,28 +378,25 @@ static ssize_t disk_show(struct kset *kset, char *buf)
         int i;
         char *start = buf;
 
-        for (i = PM_DISK_PLATFORM; i < PM_DISK_MAX; i++) {
-                if (!pm_disk_modes[i])
+        for (i = HIBERNATION_FIRST; i <= HIBERNATION_MAX; i++) {
+                if (!hibernation_modes[i])
                         continue;
                 switch (i) {
-                case PM_DISK_SHUTDOWN:
-                case PM_DISK_REBOOT:
-                case PM_DISK_TEST:
-                case PM_DISK_TESTPROC:
+                case HIBERNATION_SHUTDOWN:
+                case HIBERNATION_REBOOT:
+                case HIBERNATION_TEST:
+                case HIBERNATION_TESTPROC:
                         break;
-                default:
-                        if (pm_ops && pm_ops->enter &&
-                            (i == pm_ops->pm_disk_mode))
+                case HIBERNATION_PLATFORM:
+                        if (hibernation_ops)
                                 break;
                         /* not a valid mode, continue with loop */
                         continue;
                 }
-                if (i == pm_disk_mode)
-                        buf += sprintf(buf, "[%s]", pm_disk_modes[i]);
+                if (i == hibernation_mode)
+                        buf += sprintf(buf, "[%s] ", hibernation_modes[i]);
                 else
-                        buf += sprintf(buf, "%s", pm_disk_modes[i]);
-                if (i+1 != PM_DISK_MAX)
-                        buf += sprintf(buf, " ");
+                        buf += sprintf(buf, "%s ", hibernation_modes[i]);
         }
         buf += sprintf(buf, "\n");
         return buf-start;
@@ -387,39 +409,38 @@ static ssize_t disk_store(struct kset *kset, const char *buf, size_t n)
         int i;
         int len;
         char *p;
-        suspend_disk_method_t mode = 0;
+        int mode = HIBERNATION_INVALID;
 
         p = memchr(buf, '\n', n);
         len = p ? p - buf : n;
 
         mutex_lock(&pm_mutex);
-        for (i = PM_DISK_PLATFORM; i < PM_DISK_MAX; i++) {
-                if (!strncmp(buf, pm_disk_modes[i], len)) {
+        for (i = HIBERNATION_FIRST; i <= HIBERNATION_MAX; i++) {
+                if (!strncmp(buf, hibernation_modes[i], len)) {
                         mode = i;
                         break;
                 }
         }
-        if (mode) {
+        if (mode != HIBERNATION_INVALID) {
                 switch (mode) {
-                case PM_DISK_SHUTDOWN:
-                case PM_DISK_REBOOT:
-                case PM_DISK_TEST:
-                case PM_DISK_TESTPROC:
-                        pm_disk_mode = mode;
+                case HIBERNATION_SHUTDOWN:
+                case HIBERNATION_REBOOT:
+                case HIBERNATION_TEST:
+                case HIBERNATION_TESTPROC:
+                        hibernation_mode = mode;
                         break;
-                default:
-                        if (pm_ops && pm_ops->enter &&
-                            (mode == pm_ops->pm_disk_mode))
-                                pm_disk_mode = mode;
+                case HIBERNATION_PLATFORM:
+                        if (hibernation_ops)
+                                hibernation_mode = mode;
                         else
                                 error = -EINVAL;
                 }
-        } else {
+        } else
                 error = -EINVAL;
-        }
 
-        pr_debug("PM: suspend-to-disk mode set to '%s'\n",
-                 pm_disk_modes[mode]);
+        if (!error)
+                pr_debug("PM: suspend-to-disk mode set to '%s'\n",
+                         hibernation_modes[mode]);
         mutex_unlock(&pm_mutex);
         return error ? error : n;
 }
diff --git a/kernel/power/main.c b/kernel/power/main.c
index f6dda685e7e..40d56a31245 100644
--- a/kernel/power/main.c
+++ b/kernel/power/main.c
@@ -30,7 +30,6 @@
 DEFINE_MUTEX(pm_mutex);
 
 struct pm_ops *pm_ops;
-suspend_disk_method_t pm_disk_mode = PM_DISK_SHUTDOWN;
 
 /**
  *      pm_set_ops - Set the global power method table. 
@@ -41,10 +40,6 @@ void pm_set_ops(struct pm_ops * ops)
 {
         mutex_lock(&pm_mutex);
         pm_ops = ops;
-        if (ops && ops->pm_disk_mode != PM_DISK_INVALID) {
-                pm_disk_mode = ops->pm_disk_mode;
-        } else
-                pm_disk_mode = PM_DISK_SHUTDOWN;
         mutex_unlock(&pm_mutex);
 }
 
@@ -184,24 +179,12 @@ static void suspend_finish(suspend_state_t state)
 static const char * const pm_states[PM_SUSPEND_MAX] = {
         [PM_SUSPEND_STANDBY]    = "standby",
         [PM_SUSPEND_MEM]        = "mem",
-        [PM_SUSPEND_DISK]       = "disk",
 };
 
 static inline int valid_state(suspend_state_t state)
 {
-        /* Suspend-to-disk does not really need low-level support.
-         * It can work with shutdown/reboot if needed. If it isn't
-         * configured, then it cannot be supported.
-         */
-        if (state == PM_SUSPEND_DISK)
-#ifdef CONFIG_SOFTWARE_SUSPEND
-                return 1;
-#else
-                return 0;
-#endif
-
-        /* all other states need lowlevel support and need to be
-         * valid to the lowlevel implementation, no valid callback
+        /* All states need lowlevel support and need to be valid
+         * to the lowlevel implementation, no valid callback
          * implies that none are valid. */
         if (!pm_ops || !pm_ops->valid || !pm_ops->valid(state))
                 return 0;
@@ -229,11 +212,6 @@ static int enter_state(suspend_state_t state)
         if (!mutex_trylock(&pm_mutex))
                 return -EBUSY;
 
-        if (state == PM_SUSPEND_DISK) {
-                error = pm_suspend_disk();
-                goto Unlock;
-        }
-
         pr_debug("PM: Preparing system for %s sleep\n", pm_states[state]);
         if ((error = suspend_prepare(state)))
                 goto Unlock;
@@ -251,7 +229,7 @@ static int enter_state(suspend_state_t state)
 
 /**
  *      pm_suspend - Externally visible function for suspending system.
- *      @state:         Enumarted value of state to enter.
+ *      @state:         Enumerated value of state to enter.
  *
  *      Determine whether or not value is within range, get state 
  *      structure, and enter (above).
@@ -289,7 +267,13 @@ static ssize_t state_show(struct kset *kset, char *buf)
                 if (pm_states[i] && valid_state(i))
                         s += sprintf(s,"%s ", pm_states[i]);
         }
-        s += sprintf(s,"\n");
+#ifdef CONFIG_SOFTWARE_SUSPEND
+        s += sprintf(s, "%s\n", "disk");
+#else
+        if (s != buf)
+                /* convert the last space to a newline */
+                *(s-1) = '\n';
+#endif
         return (s - buf);
 }
 
@@ -304,6 +288,12 @@ static ssize_t state_store(struct kset *kset, const char *buf, size_t n)
         p = memchr(buf, '\n', n);
         len = p ? p - buf : n;
 
+        /* First, check if we are requested to hibernate */
+        if (!strncmp(buf, "disk", len)) {
+                error = hibernate();
+                return error ? error : n;
+        }
+
         for (s = &pm_states[state]; state < PM_SUSPEND_MAX; s++, state++) {
                 if (*s && !strncmp(buf, *s, len))
                         break;
diff --git a/kernel/power/power.h b/kernel/power/power.h
index 34b43542785..51381487103 100644
--- a/kernel/power/power.h
+++ b/kernel/power/power.h
@@ -25,12 +25,7 @@ struct swsusp_info {
  */
 #define SPARE_PAGES     ((1024 * 1024) >> PAGE_SHIFT)
 
-extern int pm_suspend_disk(void);
-#else
-static inline int pm_suspend_disk(void)
-{
-        return -EPERM;
-}
+extern struct hibernation_ops *hibernation_ops;
 #endif
 
 extern int pfn_is_nosave(unsigned long);
diff --git a/kernel/power/snapshot.c b/kernel/power/snapshot.c
index b7039772b05..48383ea7229 100644
--- a/kernel/power/snapshot.c
+++ b/kernel/power/snapshot.c
@@ -1227,7 +1227,7 @@ asmlinkage int swsusp_save(void)
         nr_copy_pages = nr_pages;
         nr_meta_pages = DIV_ROUND_UP(nr_pages * sizeof(long), PAGE_SIZE);
 
-        printk("swsusp: critical section/: done (%d pages copied)\n", nr_pages);
+        printk("swsusp: critical section: done (%d pages copied)\n", nr_pages);
 
         return 0;
 }
diff --git a/kernel/power/user.c b/kernel/power/user.c
index 040560d9c31..24d7d78e6f4 100644
--- a/kernel/power/user.c
+++ b/kernel/power/user.c
@@ -130,16 +130,16 @@ static inline int platform_prepare(void)
 {
         int error = 0;
 
-        if (pm_ops && pm_ops->prepare)
-                error = pm_ops->prepare(PM_SUSPEND_DISK);
+        if (hibernation_ops)
+                error = hibernation_ops->prepare();
 
         return error;
 }
 
 static inline void platform_finish(void)
 {
-        if (pm_ops && pm_ops->finish)
-                pm_ops->finish(PM_SUSPEND_DISK);
+        if (hibernation_ops)
+                hibernation_ops->finish();
 }
 
 static inline int snapshot_suspend(int platform_suspend)
@@ -384,7 +384,7 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
                 switch (arg) {
 
                 case PMOPS_PREPARE:
-                        if (pm_ops && pm_ops->enter) {
+                        if (hibernation_ops) {
                                 data->platform_suspend = 1;
                                 error = 0;
                         } else {
@@ -395,8 +395,7 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
                 case PMOPS_ENTER:
                         if (data->platform_suspend) {
                                 kernel_shutdown_prepare(SYSTEM_SUSPEND_DISK);
-                                error = pm_ops->enter(PM_SUSPEND_DISK);
-                                error = 0;
+                                error = hibernation_ops->enter();
                         }
                         break;