From: "Rafael J. Wysocki" <firstname.lastname@example.org> To: Thomas Gleixner <email@example.com> Cc: Peter Zijlstra <firstname.lastname@example.org>, Linux PM list <email@example.com>, Linux Kernel Mailing List <firstname.lastname@example.org>, Linux PCI <email@example.com> Subject: [PATCH 6/6 v2] irq / PM: Document rules related to system suspend and interrupts Date: Mon, 11 Aug 2014 16:03:09 +0200 [thread overview] Message-ID: <32757447.HpzYdgnW9A@vostro.rjw.lan> (raw) In-Reply-To: <26580319.OZP7jvJnA9@vostro.rjw.lan> From: Rafael J. Wysocki <firstname.lastname@example.org> Add a document describing how IRQs are managed during system suspend and resume, how to set up a wakeup interrupt and what the IRQF_NO_SUSPEND flag is supposed to be used for. Signed-off-by: Rafael J. Wysocki <email@example.com> --- Documentation/power/suspend-and-interrupts.txt | 156 +++++++++++++++++++++++++ 1 file changed, 156 insertions(+) Index: linux-pm/Documentation/power/suspend-and-interrupts.txt =================================================================== --- /dev/null +++ linux-pm/Documentation/power/suspend-and-interrupts.txt @@ -0,0 +1,156 @@ +System Suspend and Device Interrupts + +Copyright (C) 2014 Intel Corp. +Author: Rafael J. Wysocki <firstname.lastname@example.org> + + +Suspending and Resuming Device IRQs +----------------------------------- + +Device interrupt request lines (IRQs) are generally disabled during system +suspend after the "late" phase of suspending devices (that is, after all of the +->prepare, ->suspend and ->suspend_late callbacks have been executed for all +devices). That is done by suspend_device_irqs(). + +The rationale for doing so is that after the "late" phase of device suspend +there is no legitimate reason why any interrupts from suspended devices should +trigger and if any devices have not been suspended properly yet, it is better to +block interrupts from them anyway. Also, in the past we had problems with +interrupt handlers for shared IRQs that device drivers using them were not +prepared for interrupts triggering after their devices had been suspended. +In some cases they would attempt to access, for example, memory address spaces +of suspended devices and cause unpredictable behavior to ensue as a result. +Unfortunately, such problems are very difficult to debug and the introduction +of suspend_device_irqs(), along with the "noirq" phase of device suspend and +resume, was the only practical way to prevent them from happening. + +Device IRQs are re-enabled during system resume, right before the "early" phase +of resuming devices (that is, before starting to execute ->resume_early +callbacks for devices). The function doing that is resume_device_irqs(). + + +The IRQF_NO_SUSPEND Flag +------------------------ + +There are interrupts that can legitimately trigger during the entire system +suspend-resume cycle, including the "noirq" phases of suspending and resuming +devices as well as during the time when nonboot CPUs are taken offline and +brought back online. That applies to timer interrupts in the first place, +but also to IPIs and to some other special-purpose interrupts, such as the ACPI +SCI that isn't associated with any specific device and is used for signaling +many different types of events. + +The IRQF_NO_SUSPEND flag is used to indicate that to the IRQ subsystem when +requesting a special-purpose interrupt. It causes suspend_device_irqs() to +leave the corresponding IRQ enabled so as to allow the interrupt to work all +the time as expected. + +If that IRQ is shared, it will still be left enabled by suspend_device_irqs(), +but the interrupt handlers that were installed for it without IRQF_NO_SUSPEND +set will not be executed after suspend_device_irqs() has returned. Then, the +IRQ subsystem will only execute interrupt handlers for which IRQF_NO_SUSPEND is +set. In that case, if the final result of handing an interrupt is IRQ_NONE, the +IRQ subsystem will assume that the interrupt came from one of the apparently +suspended devices that share the IRQ with an IRQF_NO_SUSPEND interrupt source +(or more of them). As a result, the IRQ will be disabled and marked as +"suspended" to prevent spurious interrupts from triggering going forward. Next +(1) if a system suspend is in progress, it will be aborted or +(2) if the system is in the "freeze" sleep state (suspend-to-idle), it will be + woken up, +to allow the system to recover from that potentially unstable condition +gracefully. + +The IRQF_NO_SUSPEND flag should not be used when requesting interrupts that +subsequently will be configured for waking up the system from sleep states +via enable_irq_wake() (that is, system wakeup interrupts). + + +System Wakeup Interrupts, enable_irq_wake() and disable_irq_wake() +------------------------------------------------------------------ + +System wakeup interrupts generally need to be configured to wake up the system +from sleep states, especially if they are used for different purposes (e.g. as +I/O interrupts) in the working state. + +That may involve turning on a special signal handling logic within the platform +(such as an SoC) so that signals from a given line are routed in a different way +during system sleep so as to trigger a system wakeup when needed. For example, +the platform may include a dedicated interrupt controller used specifically for +handling system wakeup events. Then, if a given interrupt line is supposed to +wake up the system from sleep sates, the corresponding input of that interrupt +controller needs to be enabled to handle signals from the line in question. +After wakeup, it generally is better to disable that input to prevent the +dedicated controller from triggering interrupts unnecessarily. + +The IRQ subsystem provides two helper functions to be used by device drivers for +those purposes. Namely, enable_irq_wake() turns on the platform's logic for +handling the given IRQ as a system wakeup interrupt line and disable_irq_wake() +turns that logic off. + +Calling enable_irq_wake() doesn't prevent the working-state logic for handling +the given IRQ from being disabled by suspend_device_irqs(), so after the "late" +phase of suspending devices the IRQ can only be expected to work as a system +wakeup interrupt line. The IRQ subsystem checks if there are any pending +interrupts on those lines by calling check_wakeup_irqs() at the last (syscore) +stage of full system suspend. If there are any, it aborts the system suspend +by returning -EBUSY from that function. It does not, however, invoke any +interrupt handlers for system wakeup IRQs after suspend_device_irqs(). + + +System Wakeup Interrupts and Suspend-to-Idle +-------------------------------------------- + +Suspend-to-idle (also known as the "freeze" sleep state) is a relatively new +system sleep state that works by idling all of the processors and waiting for +interrupts right after the "noirq" phase of suspending devices. + +Of course, this means that all of the interrupts with the IRQF_NO_SUSPEND flag +set will bring CPUs out of idle while in that state, but they will not cause the +IRQ subsystem to trigger a system wakeup, unless the final result of handling an +interrupt for a shared IRQ is IRQ_NONE. + +System wakeup interrupts, in turn, are generally expected to trigger wakeup from +system sleep states, including suspend-to-idle. For this reason, all of the +IRQs configured for system wakeup with enable_irq_wake(), previously disabled +by suspend_device_irqs(), are re-enabled right before starting the final "go to +an idle state and wait for an interrupt" loop of suspend-to-idle. However, they +are also reconfigured so that the original handlers associated with them will +not be invoked at that time. Those interrupt handlers are all temporarily +replaced with a special "wakeup mode" interrupt handler that disables the IRQ, +marks it as "suspended" and pending and triggers wakeup from suspend-to-idle. + +The rationale here is to keep the behavior consistent with the previously +existing way of handling wakeup interrupts during full system suspends, which +is that (a) interrupt handlers are not executed for them after +suspend_device_irqs() and (b) full system suspends are aborted if any of them +are received after suspend_device_irqs(). Combined with the requirement that +system wakeup interrupts wake up the system from suspend-to-idle, (a) and (b) +imply that interrupt handlers should not be invoked for wakeup interrupts in +suspend-to-idle, although those interrupts should still wake up the system from +that state. The IRQs that triggered wakeup also need to be marked as pending +to avoid losing wakeup events. + +When wakeup from suspend-to-idle is triggered, the wakeup IRQs are disabled +again and their original behavior is restored. They are subsequently re-enabled +by resume_device_irqs(), as usual. + + +IRQF_NO_SUSPEND and enable_irq_wake() +------------------------------------- + +There are no valid reasons to use both enable_irq_wake() and the IRQF_NO_SUSPEND +flag on the same IRQ. + +First of all, if the IRQ is not shared, the rules for handling IRQF_NO_SUSPEND +interrupts (interrupt handlers are invoked after suspend_device_irqs()) are +directly at odds with the rules for handling system wakeup interrupts (interrupt +handlers are not invoked after suspend_device_irqs()). + +Secondly, enable_irq_wake() applies to entire IRQs and not to individual +interrupt handlers, so sharing an IRQ between a system wakeup interrupt source +and an IRQF_NO_SUSPEND interrupt source does not make sense in principle. If +attempted, it leads to situations in which genuine wakeup interrups are lost, +because they are regarded as interrupts from the IRQF_NO_SUSPEND interrupt +source, or are reported as unhandled interrupts, depending on the implementation +of the interrupt handler for that source, the timing of events and other +factors.
next prev parent reply other threads:[~2014-08-11 13:44 UTC|newest] Thread overview: 34+ messages / expand[flat|nested] mbox.gz Atom feed top 2014-08-11 13:56 [PATCH 0/6 v2] irq / PM: Shared IRQs vs IRQF_NO_SUSPEND and suspend-to-idle wakeup interrupts Rafael J. Wysocki 2014-08-11 13:58 ` [PATCH 1/6 v2] PM / sleep: Mechanism for aborting system suspends unconditionally Rafael J. Wysocki 2014-08-11 13:59 ` [PATCH 2/6 v2] irq / PM: Make IRQF_NO_SUSPEND work with shared interrupts Rafael J. Wysocki 2014-08-11 14:00 ` [PATCH 3/6 v2] irq / PM: Make wakeup interrupts work with suspend-to-idle Rafael J. Wysocki 2014-08-11 14:01 ` [PATCH 4/6 v2] x86 / PM: Set IRQCHIP_SKIP_SET_WAKE for IOAPIC IRQ chip objects Rafael J. Wysocki 2014-08-11 14:02 ` [PATCH 5/6 v2] PCI / PM: Make PCIe PME interrupts wake up from suspend-to-idle Rafael J. Wysocki 2014-08-11 14:03 ` Rafael J. Wysocki [this message] 2014-08-26 23:46 ` [PATCH 0/5 v3] irq / PM: Suspend-to-idle wakeup interrupts Rafael J. Wysocki 2014-08-26 23:47 ` [PATCH 1/5 v3] PM / sleep: Mechanism for aborting system suspends unconditionally Rafael J. Wysocki 2014-08-26 23:49 ` [PATCH 2/5 v3] irq / PM: Make wakeup interrupts work with suspend-to-idle Rafael J. Wysocki 2014-08-27 20:32 ` Thomas Gleixner 2014-08-27 22:51 ` Rafael J. Wysocki 2014-08-28 9:23 ` Thomas Gleixner 2014-08-29 1:51 ` Rafael J. Wysocki 2014-08-26 23:50 ` [PATCH 3/5 v3] x86 / PM: Set IRQCHIP_SKIP_SET_WAKE for IOAPIC IRQ chip objects Rafael J. Wysocki 2014-08-26 23:51 ` [PATCH 4/5 v3] PCI / PM: Make PCIe PME interrupts wake up from suspend-to-idle Rafael J. Wysocki 2014-08-26 23:52 ` [PATCH 5/5 v3] irq / PM: Document rules related to system suspend and interrupts Rafael J. Wysocki 2014-08-28 22:44 ` [PATCH 0/5 v3] irq / PM: Suspend-to-idle wakeup interrupts Thomas Gleixner 2014-08-29 0:54 ` Rafael J. Wysocki 2014-08-29 1:09 ` Thomas Gleixner 2014-09-01 14:18 ` [PATCH 00/13] genirq / PM: Wakeup interrupts handling rework (related to suspend-to-idle) Rafael J. Wysocki 2014-09-01 14:19 ` [PATCH 01/13] PM / sleep: Mechanism for aborting system suspends unconditionally Rafael J. Wysocki 2014-09-01 14:20 ` [PATCH 02/13] genirq: Move suspend/resume logic into irq/pm code Rafael J. Wysocki 2014-09-01 14:21 ` [PATCH 03/13] genirq: Add sanity checks for PM options on shared interrupt lines Rafael J. Wysocki 2014-09-01 14:22 ` [PATCH 04/13] genirq: Make use of pm misfeature accounting Rafael J. Wysocki 2014-09-01 14:22 ` [PATCH 05/13] genirq: Move MASK_ON_SUSPEND handling into suspend_device_irqs() Rafael J. Wysocki 2014-09-01 14:23 ` [PATCH 06/13] genirq: Avoid double loop on suspend Rafael J. Wysocki 2014-09-01 14:24 ` [PATCH 07/13] genirq: Distangle edge handler entry Rafael J. Wysocki 2014-09-01 14:24 ` [PATCH 08/13] genirq: Create helper for flow handler entry check Rafael J. Wysocki 2014-09-01 14:26 ` [PATCH 09/13] genirq: Mark wakeup sources as armed on suspend Rafael J. Wysocki 2014-09-01 14:27 ` [PATCH 10/13] genirq: Simplify wakeup mechanism Rafael J. Wysocki 2014-09-01 14:28 ` [PATCH 11/13] x86 / PM: Set IRQCHIP_SKIP_SET_WAKE for IOAPIC IRQ chip objects Rafael J. Wysocki 2014-09-01 14:28 ` [PATCH 12/13] PCI / PM: Make PCIe PME interrupts wake up from suspend-to-idle Rafael J. Wysocki 2014-09-01 14:29 ` [PATCH 13/13] PM / genirq: Document rules related to system suspend and interrupts Rafael J. Wysocki
Reply instructions: You may reply publicly to this message via plain-text email using any one of the following methods: * Save the following mbox file, import it into your mail client, and reply-to-all from there: mbox Avoid top-posting and favor interleaved quoting: https://en.wikipedia.org/wiki/Posting_style#Interleaved_style * Reply using the --to, --cc, and --in-reply-to switches of git-send-email(1): git send-email \ --in-reply-to=32757447.HpzYdgnW9A@vostro.rjw.lan \ --email@example.com \ --firstname.lastname@example.org \ --email@example.com \ --firstname.lastname@example.org \ --email@example.com \ --firstname.lastname@example.org \ --subject='Re: [PATCH 6/6 v2] irq / PM: Document rules related to system suspend and interrupts' \ /path/to/YOUR_REPLY https://kernel.org/pub/software/scm/git/docs/git-send-email.html * If your mail client supports setting the In-Reply-To header via mailto: links, try the mailto: link
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for NNTP newsgroup(s).