ACPI / PM: Ignore spurious SCI wakeups from suspend-to-idle

The ACPI SCI (System Control Interrupt) is set up as a wakeup IRQ
during suspend-to-idle transitions and, consequently, any events
signaled through it wake up the system from that state.  However,
on some systems some of the events signaled via the ACPI SCI while
suspended to idle should not cause the system to wake up.  In fact,
quite often they should just be discarded.

Arguably, systems should not resume entirely on such events, but in
order to decide which events really should cause the system to resume
and which are spurious, it is necessary to resume up to the point
when ACPI SCIs are actually handled and processed, which is after
executing dpm_resume_noirq() in the system resume path.

For this reasons, add a loop around freeze_enter() in which the
platforms can process events signaled via multiplexed IRQ lines
like the ACPI SCI and add suspend-to-idle hooks that can be
used for this purpose to struct platform_freeze_ops.

In the ACPI case, the ->wake hook is used for checking if the SCI
has triggered while suspended and deferring the interrupt-induced
system wakeup until the events signaled through it are actually
processed sufficiently to decide whether or not the system should
resume.  In turn, the ->sync hook allows all of the relevant event
queues to be flushed so as to prevent events from being missed due
to race conditions.

In addition to that, some ACPI code processing wakeup events needs
to be modified to use the "hard" version of wakeup triggers, so that
it will cause a system resume to happen on device-induced wakeup
events even if the "soft" mechanism to prevent the system from
suspending is not enabled.  However, to preserve the existing
behavior with respect to suspend-to-RAM, this only is done in
the suspend-to-idle case and only if an SCI has occurred while
suspended.

Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>

2 files changed, 30 insertions, 7 deletions

diff --git a/kernel/power/process.c b/kernel/power/process.c
index c7209f060eeb..78672d324a6e 100644
--- a/kernel/power/process.c
+++ b/kernel/power/process.c
@@ -132,7 +132,7 @@ int freeze_processes(void)
         if (!pm_freezing)
                 atomic_inc(&system_freezing_cnt);
 
-        pm_wakeup_clear();
+        pm_wakeup_clear(true);
         pr_info("Freezing user space processes ... ");
         pm_freezing = true;
         error = try_to_freeze_tasks(true);
diff --git a/kernel/power/suspend.c b/kernel/power/suspend.c
index 15e6baef5c73..3ecf275d7e44 100644
--- a/kernel/power/suspend.c
+++ b/kernel/power/suspend.c
@@ -72,6 +72,8 @@ static void freeze_begin(void)
 
 static void freeze_enter(void)
 {
+        trace_suspend_resume(TPS("machine_suspend"), PM_SUSPEND_FREEZE, true);
+
         spin_lock_irq(&suspend_freeze_lock);
         if (pm_wakeup_pending())
                 goto out;
@@ -84,11 +86,9 @@ static void freeze_enter(void)
 
         /* Push all the CPUs into the idle loop. */
         wake_up_all_idle_cpus();
-        pr_debug("PM: suspend-to-idle\n");
         /* Make the current CPU wait so it can enter the idle loop too. */
         wait_event(suspend_freeze_wait_head,
                    suspend_freeze_state == FREEZE_STATE_WAKE);
-        pr_debug("PM: resume from suspend-to-idle\n");
 
         cpuidle_pause();
         put_online_cpus();
@@ -98,6 +98,31 @@ static void freeze_enter(void)
  out:
         suspend_freeze_state = FREEZE_STATE_NONE;
         spin_unlock_irq(&suspend_freeze_lock);
+
+        trace_suspend_resume(TPS("machine_suspend"), PM_SUSPEND_FREEZE, false);
+}
+
+static void s2idle_loop(void)
+{
+        pr_debug("PM: suspend-to-idle\n");
+
+        do {
+                freeze_enter();
+
+                if (freeze_ops && freeze_ops->wake)
+                        freeze_ops->wake();
+
+                dpm_resume_noirq(PMSG_RESUME);
+                if (freeze_ops && freeze_ops->sync)
+                        freeze_ops->sync();
+
+                if (pm_wakeup_pending())
+                        break;
+
+                pm_wakeup_clear(false);
+        } while (!dpm_suspend_noirq(PMSG_SUSPEND));
+
+        pr_debug("PM: resume from suspend-to-idle\n");
 }
 
 void freeze_wake(void)
@@ -371,10 +396,8 @@ static int suspend_enter(suspend_state_t state, bool *wakeup)
          * all the devices are suspended.
          */
         if (state == PM_SUSPEND_FREEZE) {
-                trace_suspend_resume(TPS("machine_suspend"), state, true);
-                freeze_enter();
-                trace_suspend_resume(TPS("machine_suspend"), state, false);
-                goto Platform_wake;
+                s2idle_loop();
+                goto Platform_early_resume;
         }
 
         error = disable_nonboot_cpus();