Merge master.kernel.org:/pub/scm/linux/kernel/git/torvalds/linux-2.6

Conflicts:

	drivers/usb/input/Makefile
	drivers/usb/input/gtco.c

6 files changed, 124 insertions, 70 deletions

diff --git a/kernel/power/Kconfig b/kernel/power/Kconfig
index 95f6657fff73..51a4dd0f1b74 100644
--- a/kernel/power/Kconfig
+++ b/kernel/power/Kconfig
@@ -81,29 +81,34 @@ config SOFTWARE_SUSPEND
         bool "Software Suspend"
         depends on PM && SWAP && ((X86 && (!SMP || SUSPEND_SMP)) || ((FRV || PPC32) && !SMP))
         ---help---
-          Enable the possibility of suspending the machine.
-          It doesn't need ACPI or APM.
-          You may suspend your machine by 'swsusp' or 'shutdown -z <time>' 
-          (patch for sysvinit needed). 
+          Enable the suspend to disk (STD) functionality.
 
-          It creates an image which is saved in your active swap. Upon next
+          You can suspend your machine with 'echo disk > /sys/power/state'.
+          Alternatively, you can use the additional userland tools available
+          from <http://suspend.sf.net>.
+
+          In principle it does not require ACPI or APM, although for example
+          ACPI will be used if available.
+
+          It creates an image which is saved in your active swap. Upon the next
           boot, pass the 'resume=/dev/swappartition' argument to the kernel to
           have it detect the saved image, restore memory state from it, and
           continue to run as before. If you do not want the previous state to
-          be reloaded, then use the 'noresume' kernel argument. However, note
-          that your partitions will be fsck'd and you must re-mkswap your swap
-          partitions. It does not work with swap files.
+          be reloaded, then use the 'noresume' kernel command line argument.
+          Note, however, that fsck will be run on your filesystems and you will
+          need to run mkswap against the swap partition used for the suspend.
 
-          Right now you may boot without resuming and then later resume but
-          in meantime you cannot use those swap partitions/files which were
-          involved in suspending. Also in this case there is a risk that buffers
-          on disk won't match with saved ones.
+          It also works with swap files to a limited extent (for details see
+          <file:Documentation/power/swsusp-and-swap-files.txt>).
 
-          For more information take a look at <file:Documentation/power/swsusp.txt>.
+          Right now you may boot without resuming and resume later but in the
+          meantime you cannot use the swap partition(s)/file(s) involved in
+          suspending.  Also in this case you must not use the filesystems
+          that were mounted before the suspend.  In particular, you MUST NOT
+          MOUNT any journaled filesystems mounted before the suspend or they
+          will get corrupted in a nasty way.
 
-          (For now, swsusp is incompatible with PAE aka HIGHMEM_64G on i386.
-          we need identity mapping for resume to work, and that is trivial
-          to get with 4MB pages, but less than trivial on PAE).
+          For more information take a look at <file:Documentation/power/swsusp.txt>.
 
 config PM_STD_PARTITION
         string "Default resume partition"
diff --git a/kernel/power/console.c b/kernel/power/console.c
index 623786d44159..89bcf4973ee5 100644
--- a/kernel/power/console.c
+++ b/kernel/power/console.c
@@ -27,7 +27,15 @@ int pm_prepare_console(void)
                 return 1;
         }
 
-        set_console(SUSPEND_CONSOLE);
+        if (set_console(SUSPEND_CONSOLE)) {
+                /*
+                 * We're unable to switch to the SUSPEND_CONSOLE.
+                 * Let the calling function know so it can decide
+                 * what to do.
+                 */
+                release_console_sem();
+                return 1;
+        }
         release_console_sem();
 
         if (vt_waitactive(SUSPEND_CONSOLE)) {
diff --git a/kernel/power/disk.c b/kernel/power/disk.c
index 406b20adb27a..02e4fb69111a 100644
--- a/kernel/power/disk.c
+++ b/kernel/power/disk.c
@@ -39,7 +39,13 @@ static inline int platform_prepare(void)
 {
         int error = 0;
 
-        if (pm_disk_mode == PM_DISK_PLATFORM) {
+        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);
         }
@@ -48,40 +54,48 @@ static inline int platform_prepare(void)
 
 /**
  *      power_down - Shut machine down for hibernate.
- *      @mode:          Suspend-to-disk mode
  *
- *      Use the platform driver, if configured so, and return gracefully if it
- *      fails.
- *      Otherwise, try to power off and reboot. If they fail, halt the machine,
- *      there ain't no turning back.
+ *      Use the platform driver, if configured so; otherwise try
+ *      to power off or reboot.
  */
 
-static void power_down(suspend_disk_method_t mode)
+static void power_down(void)
 {
-        switch(mode) {
-        case PM_DISK_PLATFORM:
-                if (pm_ops && pm_ops->enter) {
-                        kernel_shutdown_prepare(SYSTEM_SUSPEND_DISK);
-                        pm_ops->enter(PM_SUSPEND_DISK);
-                        break;
-                }
+        switch (pm_disk_mode) {
+        case PM_DISK_TEST:
+        case PM_DISK_TESTPROC:
+                break;
         case PM_DISK_SHUTDOWN:
                 kernel_power_off();
                 break;
         case PM_DISK_REBOOT:
                 kernel_restart(NULL);
                 break;
+        default:
+                if (pm_ops && pm_ops->enter) {
+                        kernel_shutdown_prepare(SYSTEM_SUSPEND_DISK);
+                        pm_ops->enter(PM_SUSPEND_DISK);
+                        break;
+                }
         }
         kernel_halt();
-        /* Valid image is on the disk, if we continue we risk serious data corruption
-           after resume. */
+        /*
+         * Valid image is on the disk, if we continue we risk serious data
+         * corruption after resume.
+         */
         printk(KERN_CRIT "Please power me down manually\n");
         while(1);
 }
 
 static inline void platform_finish(void)
 {
-        if (pm_disk_mode == PM_DISK_PLATFORM) {
+        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);
         }
@@ -108,8 +122,6 @@ static int prepare_processes(void)
 /**
  *      pm_suspend_disk - The granpappy of hibernation power management.
  *
- *      If we're going through the firmware, then get it over with quickly.
- *
  *      If not, then call swsusp to do its thing, then figure out how
  *      to power down the system.
  */
@@ -166,7 +178,7 @@ int pm_suspend_disk(void)
                 pr_debug("PM: writing image.\n");
                 error = swsusp_write();
                 if (!error)
-                        power_down(pm_disk_mode);
+                        power_down();
                 else {
                         swsusp_free();
                         goto Thaw;
@@ -240,12 +252,6 @@ static int software_resume(void)
                 goto Done;
         }
 
-        error = platform_prepare();
-        if (error) {
-                swsusp_free();
-                goto Thaw;
-        }
-
         pr_debug("PM: Reading swsusp image.\n");
 
         error = swsusp_read();
@@ -268,7 +274,6 @@ static int software_resume(void)
         enable_nonboot_cpus();
  Free:
         swsusp_free();
-        platform_finish();
         device_resume();
         resume_console();
  Thaw:
@@ -285,7 +290,6 @@ late_initcall(software_resume);
 
 
 static const char * const pm_disk_modes[] = {
-        [PM_DISK_FIRMWARE]      = "firmware",
         [PM_DISK_PLATFORM]      = "platform",
         [PM_DISK_SHUTDOWN]      = "shutdown",
         [PM_DISK_REBOOT]        = "reboot",
@@ -296,27 +300,25 @@ static const char * const pm_disk_modes[] = {
 /**
  *      disk - Control suspend-to-disk mode
  *
- *      Suspend-to-disk can be handled in several ways. The greatest
- *      distinction is who writes memory to disk - the firmware or the OS.
- *      If the firmware does it, we assume that it also handles suspending
- *      the system.
- *      If the OS does it, then we have three options for putting the system
- *      to sleep - using the platform driver (e.g. ACPI or other PM registers),
- *      powering off the system or rebooting the system (for testing).
+ *      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.
  *
- *      The system will support either 'firmware' or 'platform', and that is
- *      known a priori (and encoded in pm_ops). But, the user may choose
- *      'shutdown' or 'reboot' as alternatives.
+ *      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'.
  *
  *      show() will display what the mode is currently set to.
  *      store() will accept one of
  *
- *      'firmware'
  *      'platform'
  *      'shutdown'
  *      'reboot'
+ *      'test'
+ *      'testproc'
  *
- *      It will only change to 'firmware' or 'platform' if the system
+ *      It will only change to 'platform' if the system
  *      supports it (as determined from pm_ops->pm_disk_mode).
  */
 
@@ -338,17 +340,21 @@ static ssize_t disk_store(struct subsystem * s, const char * buf, size_t n)
         len = p ? p - buf : n;
 
         mutex_lock(&pm_mutex);
-        for (i = PM_DISK_FIRMWARE; i < PM_DISK_MAX; i++) {
+        for (i = PM_DISK_PLATFORM; i < PM_DISK_MAX; i++) {
                 if (!strncmp(buf, pm_disk_modes[i], len)) {
                         mode = i;
                         break;
                 }
         }
         if (mode) {
-                if (mode == PM_DISK_SHUTDOWN || mode == PM_DISK_REBOOT ||
-                     mode == PM_DISK_TEST || mode == PM_DISK_TESTPROC) {
+                switch (mode) {
+                case PM_DISK_SHUTDOWN:
+                case PM_DISK_REBOOT:
+                case PM_DISK_TEST:
+                case PM_DISK_TESTPROC:
                         pm_disk_mode = mode;
-                } else {
+                        break;
+                default:
                         if (pm_ops && pm_ops->enter &&
                             (mode == pm_ops->pm_disk_mode))
                                 pm_disk_mode = mode;
diff --git a/kernel/power/main.c b/kernel/power/main.c
index e1c413120469..72419a3b1beb 100644
--- a/kernel/power/main.c
+++ b/kernel/power/main.c
@@ -30,7 +30,7 @@
 DEFINE_MUTEX(pm_mutex);
 
 struct pm_ops *pm_ops;
-suspend_disk_method_t pm_disk_mode = PM_DISK_PLATFORM;
+suspend_disk_method_t pm_disk_mode = PM_DISK_SHUTDOWN;
 
 /**
  *      pm_set_ops - Set the global power method table. 
@@ -41,9 +41,26 @@ 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);
 }
 
+/**
+ * pm_valid_only_mem - generic memory-only valid callback
+ *
+ * pm_ops drivers that implement mem suspend only and only need
+ * to check for that in their .valid callback can use this instead
+ * of rolling their own .valid callback.
+ */
+int pm_valid_only_mem(suspend_state_t state)
+{
+        return state == PM_SUSPEND_MEM;
+}
+
+
 static inline void pm_finish(suspend_state_t state)
 {
         if (pm_ops->finish)
@@ -111,13 +128,24 @@ static int suspend_prepare(suspend_state_t state)
         return error;
 }
 
+/* default implementation */
+void __attribute__ ((weak)) arch_suspend_disable_irqs(void)
+{
+        local_irq_disable();
+}
+
+/* default implementation */
+void __attribute__ ((weak)) arch_suspend_enable_irqs(void)
+{
+        local_irq_enable();
+}
 
 int suspend_enter(suspend_state_t state)
 {
         int error = 0;
-        unsigned long flags;
 
-        local_irq_save(flags);
+        arch_suspend_disable_irqs();
+        BUG_ON(!irqs_disabled());
 
         if ((error = device_power_down(PMSG_SUSPEND))) {
                 printk(KERN_ERR "Some devices failed to power down\n");
@@ -126,7 +154,8 @@ int suspend_enter(suspend_state_t state)
         error = pm_ops->enter(state);
         device_power_up();
  Done:
-        local_irq_restore(flags);
+        arch_suspend_enable_irqs();
+        BUG_ON(irqs_disabled());
         return error;
 }
 
@@ -167,7 +196,10 @@ static inline int valid_state(suspend_state_t state)
         if (state == PM_SUSPEND_DISK)
                 return 1;
 
-        if (pm_ops && pm_ops->valid && !pm_ops->valid(state))
+        /* all other 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;
         return 1;
 }
diff --git a/kernel/power/swsusp.c b/kernel/power/swsusp.c
index 7fb834397a0d..175370824f37 100644
--- a/kernel/power/swsusp.c
+++ b/kernel/power/swsusp.c
@@ -229,13 +229,13 @@ int swsusp_shrink_memory(void)
                 size += highmem_size;
                 for_each_zone (zone)
                         if (populated_zone(zone)) {
+                                tmp += snapshot_additional_pages(zone);
                                 if (is_highmem(zone)) {
                                         highmem_size -=
                                         zone_page_state(zone, NR_FREE_PAGES);
                                 } else {
                                         tmp -= zone_page_state(zone, NR_FREE_PAGES);
                                         tmp += zone->lowmem_reserve[ZONE_NORMAL];
-                                        tmp += snapshot_additional_pages(zone);
                                 }
                         }
 
diff --git a/kernel/power/user.c b/kernel/power/user.c
index dd09efe7df54..7cf6713b2325 100644
--- a/kernel/power/user.c
+++ b/kernel/power/user.c
@@ -368,9 +368,12 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
                 if (error) {
                         printk(KERN_ERR "Failed to suspend some devices.\n");
                 } else {
-                        /* Enter S3, system is already frozen */
-                        suspend_enter(PM_SUSPEND_MEM);
-
+                        error = disable_nonboot_cpus();
+                        if (!error) {
+                                /* Enter S3, system is already frozen */
+                                suspend_enter(PM_SUSPEND_MEM);
+                                enable_nonboot_cpus();
+                        }
                         /* Wake up devices */
                         device_resume();
                 }