|
@@ -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
|
|
@@ -50,9 +46,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[] = {
|
|
@@ -66,7 +149,6 @@ static u32 acpi_suspend_states[] = {
|
|
|
* 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];
|
|
@@ -82,25 +164,6 @@ static int acpi_suspend_begin(suspend_state_t pm_state)
|
|
|
return error;
|
|
|
}
|
|
|
|
|
|
-/**
|
|
|
- * 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
|
|
@@ -109,7 +172,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;
|
|
@@ -166,39 +228,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;
|
|
|
-}
|
|
|
-
|
|
|
-/**
|
|
|
- * 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;
|
|
@@ -218,10 +247,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_pm_finish,
|
|
|
+ .end = acpi_pm_end,
|
|
|
+};
|
|
|
+
|
|
|
+/**
|
|
|
+ * 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 acpi_suspend_begin_old(suspend_state_t pm_state)
|
|
|
+{
|
|
|
+ int error = acpi_suspend_begin(pm_state);
|
|
|
+
|
|
|
+ if (!error)
|
|
|
+ error = __acpi_pm_prepare();
|
|
|
+ return error;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+ * 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_suspend_finish,
|
|
|
- .end = acpi_suspend_end,
|
|
|
+ .finish = acpi_pm_finish,
|
|
|
+ .end = acpi_pm_end,
|
|
|
+ .recover = acpi_pm_finish,
|
|
|
};
|
|
|
#endif /* CONFIG_SUSPEND */
|
|
|
|
|
@@ -229,22 +287,9 @@ static struct platform_suspend_ops acpi_suspend_ops = {
|
|
|
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;
|
|
@@ -274,52 +319,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)
|
|
|
{
|
|
@@ -461,13 +509,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");
|
|
|
}
|