1 files changed, 186 insertions, 142 deletions

diff --git a/drivers/acpi/sleep/main.c b/drivers/acpi/sleep/main.c
index 495c63a3e0af..0489a7d1d42c 100644
--- a/drivers/acpi/sleep/main.c
+++ b/drivers/acpi/sleep/main.c
@@ -24,10 +24,6 @@
 
 u8 sleep_states[ACPI_S_STATE_COUNT];
 
-#ifdef CONFIG_PM_SLEEP
-static u32 acpi_target_sleep_state = ACPI_STATE_S0;
-#endif
-
 static int acpi_sleep_prepare(u32 acpi_state)
 {
 #ifdef CONFIG_ACPI_SLEEP
@@ -49,9 +45,96 @@ static int acpi_sleep_prepare(u32 acpi_state)
         return 0;
 }
 
-#ifdef CONFIG_SUSPEND
-static struct platform_suspend_ops acpi_suspend_ops;
+#ifdef CONFIG_PM_SLEEP
+static u32 acpi_target_sleep_state = ACPI_STATE_S0;
+
+/*
+ * ACPI 1.0 wants us to execute _PTS before suspending devices, so we allow the
+ * user to request that behavior by using the 'acpi_old_suspend_ordering'
+ * kernel command line option that causes the following variable to be set.
+ */
+static bool old_suspend_ordering;
 
+void __init acpi_old_suspend_ordering(void)
+{
+        old_suspend_ordering = true;
+}
+
+/**
+ *      acpi_pm_disable_gpes - Disable the GPEs.
+ */
+static int acpi_pm_disable_gpes(void)
+{
+        acpi_hw_disable_all_gpes();
+        return 0;
+}
+
+/**
+ *      __acpi_pm_prepare - Prepare the platform to enter the target state.
+ *
+ *      If necessary, set the firmware waking vector and do arch-specific
+ *      nastiness to get the wakeup code to the waking vector.
+ */
+static int __acpi_pm_prepare(void)
+{
+        int error = acpi_sleep_prepare(acpi_target_sleep_state);
+
+        if (error)
+                acpi_target_sleep_state = ACPI_STATE_S0;
+        return error;
+}
+
+/**
+ *      acpi_pm_prepare - Prepare the platform to enter the target sleep
+ *              state and disable the GPEs.
+ */
+static int acpi_pm_prepare(void)
+{
+        int error = __acpi_pm_prepare();
+
+        if (!error)
+                acpi_hw_disable_all_gpes();
+        return error;
+}
+
+/**
+ *      acpi_pm_finish - Instruct the platform to leave a sleep state.
+ *
+ *      This is called after we wake back up (or if entering the sleep state
+ *      failed).
+ */
+static void acpi_pm_finish(void)
+{
+        u32 acpi_state = acpi_target_sleep_state;
+
+        if (acpi_state == ACPI_STATE_S0)
+                return;
+
+        printk(KERN_INFO PREFIX "Waking up from system sleep state S%d\n",
+                acpi_state);
+        acpi_disable_wakeup_device(acpi_state);
+        acpi_leave_sleep_state(acpi_state);
+
+        /* reset firmware waking vector */
+        acpi_set_firmware_waking_vector((acpi_physical_address) 0);
+
+        acpi_target_sleep_state = ACPI_STATE_S0;
+}
+
+/**
+ *      acpi_pm_end - Finish up suspend sequence.
+ */
+static void acpi_pm_end(void)
+{
+        /*
+         * This is necessary in case acpi_pm_finish() is not called during a
+         * failing transition to a sleep state.
+         */
+        acpi_target_sleep_state = ACPI_STATE_S0;
+}
+#endif /* CONFIG_PM_SLEEP */
+
+#ifdef CONFIG_SUSPEND
 extern void do_suspend_lowlevel(void);
 
 static u32 acpi_suspend_states[] = {
@@ -61,13 +144,10 @@ static u32 acpi_suspend_states[] = {
         [PM_SUSPEND_MAX] = ACPI_STATE_S5
 };
 
-static int init_8259A_after_S1;
-
 /**
  *      acpi_suspend_begin - Set the target system sleep state to the state
  *              associated with given @pm_state, if supported.
  */
-
 static int acpi_suspend_begin(suspend_state_t pm_state)
 {
         u32 acpi_state = acpi_suspend_states[pm_state];
@@ -84,25 +164,6 @@ static int acpi_suspend_begin(suspend_state_t pm_state)
 }
 
 /**
- *      acpi_suspend_prepare - Do preliminary suspend work.
- *
- *      If necessary, set the firmware waking vector and do arch-specific
- *      nastiness to get the wakeup code to the waking vector.
- */
-
-static int acpi_suspend_prepare(void)
-{
-        int error = acpi_sleep_prepare(acpi_target_sleep_state);
-
-        if (error) {
-                acpi_target_sleep_state = ACPI_STATE_S0;
-                return error;
-        }
-
-        return ACPI_SUCCESS(acpi_hw_disable_all_gpes()) ? 0 : -EFAULT;
-}
-
-/**
  *      acpi_suspend_enter - Actually enter a sleep state.
  *      @pm_state: ignored
  *
@@ -110,7 +171,6 @@ static int acpi_suspend_prepare(void)
  *      assembly, which in turn call acpi_enter_sleep_state().
  *      It's unfortunate, but it works. Please fix if you're feeling frisky.
  */
-
 static int acpi_suspend_enter(suspend_state_t pm_state)
 {
         acpi_status status = AE_OK;
@@ -167,46 +227,6 @@ static int acpi_suspend_enter(suspend_state_t pm_state)
         return ACPI_SUCCESS(status) ? 0 : -EFAULT;
 }
 
-/**
- *      acpi_suspend_finish - Instruct the platform to leave a sleep state.
- *
- *      This is called after we wake back up (or if entering the sleep state
- *      failed). 
- */
-
-static void acpi_suspend_finish(void)
-{
-        u32 acpi_state = acpi_target_sleep_state;
-
-        acpi_disable_wakeup_device(acpi_state);
-        acpi_leave_sleep_state(acpi_state);
-
-        /* reset firmware waking vector */
-        acpi_set_firmware_waking_vector((acpi_physical_address) 0);
-
-        acpi_target_sleep_state = ACPI_STATE_S0;
-
-#ifdef CONFIG_X86
-        if (init_8259A_after_S1) {
-                printk("Broken toshiba laptop -> kicking interrupts\n");
-                init_8259A(0);
-        }
-#endif
-}
-
-/**
- *      acpi_suspend_end - Finish up suspend sequence.
- */
-
-static void acpi_suspend_end(void)
-{
-        /*
-         * This is necessary in case acpi_suspend_finish() is not called during a
-         * failing transition to a sleep state.
-         */
-        acpi_target_sleep_state = ACPI_STATE_S0;
-}
-
 static int acpi_suspend_state_valid(suspend_state_t pm_state)
 {
         u32 acpi_state;
@@ -226,30 +246,39 @@ static int acpi_suspend_state_valid(suspend_state_t pm_state)
 static struct platform_suspend_ops acpi_suspend_ops = {
         .valid = acpi_suspend_state_valid,
         .begin = acpi_suspend_begin,
-        .prepare = acpi_suspend_prepare,
+        .prepare = acpi_pm_prepare,
         .enter = acpi_suspend_enter,
-        .finish = acpi_suspend_finish,
-        .end = acpi_suspend_end,
+        .finish = acpi_pm_finish,
+        .end = acpi_pm_end,
 };
 
-/*
- * Toshiba fails to preserve interrupts over S1, reinitialization
- * of 8259 is needed after S1 resume.
+/**
+ *      acpi_suspend_begin_old - Set the target system sleep state to the
+ *              state associated with given @pm_state, if supported, and
+ *              execute the _PTS control method.  This function is used if the
+ *              pre-ACPI 2.0 suspend ordering has been requested.
  */
-static int __init init_ints_after_s1(const struct dmi_system_id *d)
+static int acpi_suspend_begin_old(suspend_state_t pm_state)
 {
-        printk(KERN_WARNING "%s with broken S1 detected.\n", d->ident);
-        init_8259A_after_S1 = 1;
-        return 0;
+        int error = acpi_suspend_begin(pm_state);
+
+        if (!error)
+                error = __acpi_pm_prepare();
+        return error;
 }
 
-static struct dmi_system_id __initdata acpisleep_dmi_table[] = {
-        {
-         .callback = init_ints_after_s1,
-         .ident = "Toshiba Satellite 4030cdt",
-         .matches = {DMI_MATCH(DMI_PRODUCT_NAME, "S4030CDT/4.3"),},
-         },
-        {},
+/*
+ * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
+ * been requested.
+ */
+static struct platform_suspend_ops acpi_suspend_ops_old = {
+        .valid = acpi_suspend_state_valid,
+        .begin = acpi_suspend_begin_old,
+        .prepare = acpi_pm_disable_gpes,
+        .enter = acpi_suspend_enter,
+        .finish = acpi_pm_finish,
+        .end = acpi_pm_end,
+        .recover = acpi_pm_finish,
 };
 #endif /* CONFIG_SUSPEND */
 
@@ -257,22 +286,9 @@ static struct dmi_system_id __initdata acpisleep_dmi_table[] = {
 static int acpi_hibernation_begin(void)
 {
         acpi_target_sleep_state = ACPI_STATE_S4;
-
         return 0;
 }
 
-static int acpi_hibernation_prepare(void)
-{
-        int error = acpi_sleep_prepare(ACPI_STATE_S4);
-
-        if (error) {
-                acpi_target_sleep_state = ACPI_STATE_S0;
-                return error;
-        }
-
-        return ACPI_SUCCESS(acpi_hw_disable_all_gpes()) ? 0 : -EFAULT;
-}
-
 static int acpi_hibernation_enter(void)
 {
         acpi_status status = AE_OK;
@@ -302,52 +318,55 @@ static void acpi_hibernation_leave(void)
         acpi_leave_sleep_state_prep(ACPI_STATE_S4);
 }
 
-static void acpi_hibernation_finish(void)
+static void acpi_pm_enable_gpes(void)
 {
-        acpi_disable_wakeup_device(ACPI_STATE_S4);
-        acpi_leave_sleep_state(ACPI_STATE_S4);
-
-        /* reset firmware waking vector */
-        acpi_set_firmware_waking_vector((acpi_physical_address) 0);
-
-        acpi_target_sleep_state = ACPI_STATE_S0;
+        acpi_hw_enable_all_runtime_gpes();
 }
 
-static void acpi_hibernation_end(void)
-{
-        /*
-         * This is necessary in case acpi_hibernation_finish() is not called
-         * during a failing transition to the sleep state.
-         */
-        acpi_target_sleep_state = ACPI_STATE_S0;
-}
+static struct platform_hibernation_ops acpi_hibernation_ops = {
+        .begin = acpi_hibernation_begin,
+        .end = acpi_pm_end,
+        .pre_snapshot = acpi_pm_prepare,
+        .finish = acpi_pm_finish,
+        .prepare = acpi_pm_prepare,
+        .enter = acpi_hibernation_enter,
+        .leave = acpi_hibernation_leave,
+        .pre_restore = acpi_pm_disable_gpes,
+        .restore_cleanup = acpi_pm_enable_gpes,
+};
 
-static int acpi_hibernation_pre_restore(void)
+/**
+ *      acpi_hibernation_begin_old - Set the target system sleep state to
+ *              ACPI_STATE_S4 and execute the _PTS control method.  This
+ *              function is used if the pre-ACPI 2.0 suspend ordering has been
+ *              requested.
+ */
+static int acpi_hibernation_begin_old(void)
 {
-        acpi_status status;
-
-        status = acpi_hw_disable_all_gpes();
-
-        return ACPI_SUCCESS(status) ? 0 : -EFAULT;
-}
+        int error = acpi_sleep_prepare(ACPI_STATE_S4);
 
-static void acpi_hibernation_restore_cleanup(void)
-{
-        acpi_hw_enable_all_runtime_gpes();
+        if (!error)
+                acpi_target_sleep_state = ACPI_STATE_S4;
+        return error;
 }
 
-static struct platform_hibernation_ops acpi_hibernation_ops = {
-        .begin = acpi_hibernation_begin,
-        .end = acpi_hibernation_end,
-        .pre_snapshot = acpi_hibernation_prepare,
-        .finish = acpi_hibernation_finish,
-        .prepare = acpi_hibernation_prepare,
+/*
+ * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
+ * been requested.
+ */
+static struct platform_hibernation_ops acpi_hibernation_ops_old = {
+        .begin = acpi_hibernation_begin_old,
+        .end = acpi_pm_end,
+        .pre_snapshot = acpi_pm_disable_gpes,
+        .finish = acpi_pm_finish,
+        .prepare = acpi_pm_disable_gpes,
         .enter = acpi_hibernation_enter,
         .leave = acpi_hibernation_leave,
-        .pre_restore = acpi_hibernation_pre_restore,
-        .restore_cleanup = acpi_hibernation_restore_cleanup,
+        .pre_restore = acpi_pm_disable_gpes,
+        .restore_cleanup = acpi_pm_enable_gpes,
+        .recover = acpi_pm_finish,
 };
-#endif                          /* CONFIG_HIBERNATION */
+#endif /* CONFIG_HIBERNATION */
 
 int acpi_suspend(u32 acpi_state)
 {
@@ -368,8 +387,8 @@ int acpi_suspend(u32 acpi_state)
 /**
  *      acpi_pm_device_sleep_state - return preferred power state of ACPI device
  *              in the system sleep state given by %acpi_target_sleep_state
- *      @dev: device to examine
- *      @wake: if set, the device should be able to wake up the system
+ *      @dev: device to examine; its driver model wakeup flags control
+ *              whether it should be able to wake up the system
  *      @d_min_p: used to store the upper limit of allowed states range
  *      Return value: preferred power state of the device on success, -ENODEV on
  *              failure (ie. if there's no 'struct acpi_device' for @dev)
@@ -387,7 +406,7 @@ int acpi_suspend(u32 acpi_state)
  *      via @wake.
  */
 
-int acpi_pm_device_sleep_state(struct device *dev, int wake, int *d_min_p)
+int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p)
 {
         acpi_handle handle = DEVICE_ACPI_HANDLE(dev);
         struct acpi_device *adev;
@@ -426,7 +445,7 @@ int acpi_pm_device_sleep_state(struct device *dev, int wake, int *d_min_p)
          * can wake the system.  _S0W may be valid, too.
          */
         if (acpi_target_sleep_state == ACPI_STATE_S0 ||
-            (wake && adev->wakeup.state.enabled &&
+            (device_may_wakeup(dev) && adev->wakeup.state.enabled &&
              adev->wakeup.sleep_state <= acpi_target_sleep_state)) {
                 acpi_status status;
 
@@ -448,6 +467,31 @@ int acpi_pm_device_sleep_state(struct device *dev, int wake, int *d_min_p)
                 *d_min_p = d_min;
         return d_max;
 }
+
+/**
+ *      acpi_pm_device_sleep_wake - enable or disable the system wake-up
+ *                                  capability of given device
+ *      @dev: device to handle
+ *      @enable: 'true' - enable, 'false' - disable the wake-up capability
+ */
+int acpi_pm_device_sleep_wake(struct device *dev, bool enable)
+{
+        acpi_handle handle;
+        struct acpi_device *adev;
+
+        if (!device_may_wakeup(dev))
+                return -EINVAL;
+
+        handle = DEVICE_ACPI_HANDLE(dev);
+        if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &adev))) {
+                printk(KERN_DEBUG "ACPI handle has no context!\n");
+                return -ENODEV;
+        }
+
+        return enable ?
+                acpi_enable_wakeup_device_power(adev, acpi_target_sleep_state) :
+                acpi_disable_wakeup_device_power(adev);
+}
 #endif
 
 static void acpi_power_off_prepare(void)
@@ -472,8 +516,6 @@ int __init acpi_sleep_init(void)
         u8 type_a, type_b;
 #ifdef CONFIG_SUSPEND
         int i = 0;
-
-        dmi_check_system(acpisleep_dmi_table);
 #endif
 
         if (acpi_disabled)
@@ -491,13 +533,15 @@ int __init acpi_sleep_init(void)
                 }
         }
 
-        suspend_set_ops(&acpi_suspend_ops);
+        suspend_set_ops(old_suspend_ordering ?
+                &acpi_suspend_ops_old : &acpi_suspend_ops);
 #endif
 
 #ifdef CONFIG_HIBERNATION
         status = acpi_get_sleep_type_data(ACPI_STATE_S4, &type_a, &type_b);
         if (ACPI_SUCCESS(status)) {
-                hibernation_set_ops(&acpi_hibernation_ops);
+                hibernation_set_ops(old_suspend_ordering ?
+                        &acpi_hibernation_ops_old : &acpi_hibernation_ops);
                 sleep_states[ACPI_STATE_S4] = 1;
                 printk(" S4");
         }