138 lines · plain
1====================================2System Suspend and Device Interrupts3====================================4 5Copyright (C) 2014 Intel Corp.6Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com>7 8 9Suspending and Resuming Device IRQs10-----------------------------------11 12Device interrupt request lines (IRQs) are generally disabled during system13suspend after the "late" phase of suspending devices (that is, after all of the14->prepare, ->suspend and ->suspend_late callbacks have been executed for all15devices). That is done by suspend_device_irqs().16 17The rationale for doing so is that after the "late" phase of device suspend18there is no legitimate reason why any interrupts from suspended devices should19trigger and if any devices have not been suspended properly yet, it is better to20block interrupts from them anyway. Also, in the past we had problems with21interrupt handlers for shared IRQs that device drivers implementing them were22not prepared for interrupts triggering after their devices had been suspended.23In some cases they would attempt to access, for example, memory address spaces24of suspended devices and cause unpredictable behavior to ensue as a result.25Unfortunately, such problems are very difficult to debug and the introduction26of suspend_device_irqs(), along with the "noirq" phase of device suspend and27resume, was the only practical way to mitigate them.28 29Device IRQs are re-enabled during system resume, right before the "early" phase30of resuming devices (that is, before starting to execute ->resume_early31callbacks for devices). The function doing that is resume_device_irqs().32 33 34The IRQF_NO_SUSPEND Flag35------------------------36 37There are interrupts that can legitimately trigger during the entire system38suspend-resume cycle, including the "noirq" phases of suspending and resuming39devices as well as during the time when nonboot CPUs are taken offline and40brought back online. That applies to timer interrupts in the first place,41but also to IPIs and to some other special-purpose interrupts.42 43The IRQF_NO_SUSPEND flag is used to indicate that to the IRQ subsystem when44requesting a special-purpose interrupt. It causes suspend_device_irqs() to45leave the corresponding IRQ enabled so as to allow the interrupt to work as46expected during the suspend-resume cycle, but does not guarantee that the47interrupt will wake the system from a suspended state -- for such cases it is48necessary to use enable_irq_wake().49 50Note that the IRQF_NO_SUSPEND flag affects the entire IRQ and not just one51user of it. Thus, if the IRQ is shared, all of the interrupt handlers installed52for it will be executed as usual after suspend_device_irqs(), even if the53IRQF_NO_SUSPEND flag was not passed to request_irq() (or equivalent) by some of54the IRQ's users. For this reason, using IRQF_NO_SUSPEND and IRQF_SHARED at the55same time should be avoided.56 57 58System Wakeup Interrupts, enable_irq_wake() and disable_irq_wake()59------------------------------------------------------------------60 61System wakeup interrupts generally need to be configured to wake up the system62from sleep states, especially if they are used for different purposes (e.g. as63I/O interrupts) in the working state.64 65That may involve turning on a special signal handling logic within the platform66(such as an SoC) so that signals from a given line are routed in a different way67during system sleep so as to trigger a system wakeup when needed. For example,68the platform may include a dedicated interrupt controller used specifically for69handling system wakeup events. Then, if a given interrupt line is supposed to70wake up the system from sleep states, the corresponding input of that interrupt71controller needs to be enabled to receive signals from the line in question.72After wakeup, it generally is better to disable that input to prevent the73dedicated controller from triggering interrupts unnecessarily.74 75The IRQ subsystem provides two helper functions to be used by device drivers for76those purposes. Namely, enable_irq_wake() turns on the platform's logic for77handling the given IRQ as a system wakeup interrupt line and disable_irq_wake()78turns that logic off.79 80Calling enable_irq_wake() causes suspend_device_irqs() to treat the given IRQ81in a special way. Namely, the IRQ remains enabled, but on the first interrupt82it will be disabled, marked as pending and "suspended" so that it will be83re-enabled by resume_device_irqs() during the subsequent system resume. Also84the PM core is notified about the event which causes the system suspend in85progress to be aborted (that doesn't have to happen immediately, but at one86of the points where the suspend thread looks for pending wakeup events).87 88This way every interrupt from a wakeup interrupt source will either cause the89system suspend currently in progress to be aborted or wake up the system if90already suspended. However, after suspend_device_irqs() interrupt handlers are91not executed for system wakeup IRQs. They are only executed for IRQF_NO_SUSPEND92IRQs at that time, but those IRQs should not be configured for system wakeup93using enable_irq_wake().94 95 96Interrupts and Suspend-to-Idle97------------------------------98 99Suspend-to-idle (also known as the "freeze" sleep state) is a relatively new100system sleep state that works by idling all of the processors and waiting for101interrupts right after the "noirq" phase of suspending devices.102 103Of course, this means that all of the interrupts with the IRQF_NO_SUSPEND flag104set will bring CPUs out of idle while in that state, but they will not cause the105IRQ subsystem to trigger a system wakeup.106 107System wakeup interrupts, in turn, will trigger wakeup from suspend-to-idle in108analogy with what they do in the full system suspend case. The only difference109is that the wakeup from suspend-to-idle is signaled using the usual working110state interrupt delivery mechanisms and doesn't require the platform to use111any special interrupt handling logic for it to work.112 113 114IRQF_NO_SUSPEND and enable_irq_wake()115-------------------------------------116 117There are very few valid reasons to use both enable_irq_wake() and the118IRQF_NO_SUSPEND flag on the same IRQ, and it is never valid to use both for the119same device.120 121First of all, if the IRQ is not shared, the rules for handling IRQF_NO_SUSPEND122interrupts (interrupt handlers are invoked after suspend_device_irqs()) are123directly at odds with the rules for handling system wakeup interrupts (interrupt124handlers are not invoked after suspend_device_irqs()).125 126Second, both enable_irq_wake() and IRQF_NO_SUSPEND apply to entire IRQs and not127to individual interrupt handlers, so sharing an IRQ between a system wakeup128interrupt source and an IRQF_NO_SUSPEND interrupt source does not generally129make sense.130 131In rare cases an IRQ can be shared between a wakeup device driver and an132IRQF_NO_SUSPEND user. In order for this to be safe, the wakeup device driver133must be able to discern spurious IRQs from genuine wakeup events (signalling134the latter to the core with pm_system_wakeup()), must use enable_irq_wake() to135ensure that the IRQ will function as a wakeup source, and must request the IRQ136with IRQF_COND_SUSPEND to tell the core that it meets these requirements. If137these requirements are not met, it is not valid to use IRQF_COND_SUSPEND.138