Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/hpa/linux...

[~andy/linux] / kernel / power / disk.c

diff --git a/kernel/power/disk.c b/kernel/power/disk.c
index 555c0f0b2f7eaa20110b57064cb5f701b4e764df..05b64790fe8391ed5189eee02144e5cf63f3fa2b 100644 (file)
--- a/kernel/power/disk.c
+++ b/kernel/power/disk.c
@@ -92,6 +92,17 @@ static int platform_pre_snapshot(int platform_mode)
                hibernation_ops->pre_snapshot() : 0;
 }
 
+/**
+ *     platform_leave - prepare the machine for switching to the normal mode
+ *     of operation using the platform driver (called with interrupts disabled)
+ */
+
+static void platform_leave(int platform_mode)
+{
+       if (platform_mode && hibernation_ops)
+               hibernation_ops->leave();
+}
+
 /**
  *     platform_finish - switch the machine to the normal mode of operation
  *     using the platform driver (must be called after platform_prepare())
@@ -128,6 +139,51 @@ static void platform_restore_cleanup(int platform_mode)
                hibernation_ops->restore_cleanup();
 }
 
+/**
+ *     create_image - freeze devices that need to be frozen with interrupts
+ *     off, create the hibernation image and thaw those devices.  Control
+ *     reappears in this routine after a restore.
+ */
+
+int create_image(int platform_mode)
+{
+       int error;
+
+       error = arch_prepare_suspend();
+       if (error)
+               return error;
+
+       local_irq_disable();
+       /* At this point, device_suspend() has been called, but *not*
+        * device_power_down(). We *must* call device_power_down() now.
+        * Otherwise, drivers for some devices (e.g. interrupt controllers)
+        * become desynchronized with the actual state of the hardware
+        * at resume time, and evil weirdness ensues.
+        */
+       error = device_power_down(PMSG_FREEZE);
+       if (error) {
+               printk(KERN_ERR "Some devices failed to power down, "
+                       KERN_ERR "aborting suspend\n");
+               goto Enable_irqs;
+       }
+
+       save_processor_state();
+       error = swsusp_arch_suspend();
+       if (error)
+               printk(KERN_ERR "Error %d while creating the image\n", error);
+       /* Restore control flow magically appears here */
+       restore_processor_state();
+       if (!in_suspend)
+               platform_leave(platform_mode);
+       /* NOTE:  device_power_up() is just a resume() for devices
+        * that suspended with irqs off ... no overall powerup.
+        */
+       device_power_up();
+ Enable_irqs:
+       local_irq_enable();
+       return error;
+}
+
 /**
  *     hibernation_snapshot - quiesce devices and create the hibernation
  *     snapshot image.
@@ -163,7 +219,7 @@ int hibernation_snapshot(int platform_mode)
        if (!error) {
                if (hibernation_mode != HIBERNATION_TEST) {
                        in_suspend = 1;
-                       error = swsusp_suspend();
+                       error = create_image(platform_mode);
                        /* Control returns here after successful restore */
                } else {
                        printk("swsusp debug: Waiting for 5 seconds.\n");
@@ -222,21 +278,50 @@ int hibernation_platform_enter(void)
 {
        int error;
 
-       if (hibernation_ops) {
-               kernel_shutdown_prepare(SYSTEM_SUSPEND_DISK);
-               /*
-                * We have cancelled the power transition by running
-                * hibernation_ops->finish() before saving the image, so we
-                * should let the firmware know that we're going to enter the
-                * sleep state after all
-                */
-               error = hibernation_ops->prepare();
-               sysdev_shutdown();
-               if (!error)
-                       error = hibernation_ops->enter();
-       } else {
-               error = -ENOSYS;
+       if (!hibernation_ops)
+               return -ENOSYS;
+
+       /*
+        * We have cancelled the power transition by running
+        * hibernation_ops->finish() before saving the image, so we should let
+        * the firmware know that we're going to enter the sleep state after all
+        */
+       error = hibernation_ops->start();
+       if (error)
+               return error;
+
+       suspend_console();
+       error = device_suspend(PMSG_SUSPEND);
+       if (error)
+               goto Resume_console;
+
+       error = hibernation_ops->prepare();
+       if (error)
+               goto Resume_devices;
+
+       error = disable_nonboot_cpus();
+       if (error)
+               goto Finish;
+
+       local_irq_disable();
+       error = device_power_down(PMSG_SUSPEND);
+       if (!error) {
+               hibernation_ops->enter();
+               /* We should never get here */
+               while (1);
        }
+       local_irq_enable();
+
+       /*
+        * We don't need to reenable the nonboot CPUs or resume consoles, since
+        * the system is going to be halted anyway.
+        */
+ Finish:
+       hibernation_ops->finish();
+ Resume_devices:
+       device_resume();
+ Resume_console:
+       resume_console();
        return error;
 }
 
@@ -253,14 +338,14 @@ static void power_down(void)
        case HIBERNATION_TEST:
        case HIBERNATION_TESTPROC:
                break;
-       case HIBERNATION_SHUTDOWN:
-               kernel_power_off();
-               break;
        case HIBERNATION_REBOOT:
                kernel_restart(NULL);
                break;
        case HIBERNATION_PLATFORM:
                hibernation_platform_enter();
+       case HIBERNATION_SHUTDOWN:
+               kernel_power_off();
+               break;
        }
        kernel_halt();
        /*
@@ -371,7 +456,17 @@ static int software_resume(void)
        int error;
        unsigned int flags;
 
-       mutex_lock(&pm_mutex);
+       /*
+        * name_to_dev_t() below takes a sysfs buffer mutex when sysfs
+        * is configured into the kernel. Since the regular hibernate
+        * trigger path is via sysfs which takes a buffer mutex before
+        * calling hibernate functions (which take pm_mutex) this can
+        * cause lockdep to complain about a possible ABBA deadlock
+        * which cannot happen since we're in the boot code here and
+        * sysfs can't be invoked yet. Therefore, we use a subclass
+        * here to avoid lockdep complaining.
+        */
+       mutex_lock_nested(&pm_mutex, SINGLE_DEPTH_NESTING);
        if (!swsusp_resume_device) {
                if (!strlen(resume_file)) {
                        mutex_unlock(&pm_mutex);