genirq: Add chip flag to force mask on suspend

On suspend we disable all interrupts in the core code, but this does
not mask the interrupt line in the default implementation as we use a
lazy disable approach. That means we mark the interrupt disabled, but
leave the hardware unmasked. That's an optimization because we avoid
the hardware access for the common case where no interrupt happens
after we marked it disabled. If an interrupt happens, then the
interrupt flow handler masks the line at the hardware level and marks
it pending.

Suspend makes use of this delayed disable as it "disables" all
interrupts when preparing the suspend transition. Right before the
system goes into hardware suspend state it checks whether one of the
interrupts which is marked as a wakeup interrupt came in after
disabling it.

Most interrupt chips have a separate register which selects the
interrupts which can wake up the system from suspend, so we don't have
to mask any on the non wakeup interrupts.

But now we have to deal with brilliant designed hardware which lacks
such a wakeup configuration facility. For such hardware it's necessary
to mask all non wakeup interrupts before going into suspend in order
to avoid the wakeup from random interrupts.

Rather than working around this in the affected interrupt chip
implementations we can solve this elegant in the core code itself.

Add a flag IRQCHIP_MASK_ON_SUSPEND which can be set by the irq chip
implementation to indicate, that the interrupts which are not selected
as wakeup sources must be masked in the suspend path. Mask them in the
loop which checks the wakeup interrupts pending flag.

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Reviewed-by: Abhijeet Dharmapurikar <adharmap@codeaurora.org>
LKML-Reference: <alpine.LFD.2.00.1103112112310.2787@localhost6.localdomain6>

diff --git a/include/linux/irq.h b/include/linux/irq.h
index ff62d0145b8fb131d58a10812f82005f242e89e5..1d3577f30d45f62c55ef18f12eb6204b7f0dd1e9 100644 (file)
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -330,10 +330,12 @@ struct irq_chip {
  *
  * IRQCHIP_SET_TYPE_MASKED:    Mask before calling chip.irq_set_type()
  * IRQCHIP_EOI_IF_HANDLED:     Only issue irq_eoi() when irq was handled
+ * IRQCHIP_MASK_ON_SUSPEND:    Mask non wake irqs in the suspend path
  */
 enum {
        IRQCHIP_SET_TYPE_MASKED         = (1 <<  0),
        IRQCHIP_EOI_IF_HANDLED          = (1 <<  1),
+       IRQCHIP_MASK_ON_SUSPEND         = (1 <<  2),
 };
 
 /* This include will go away once we isolated irq_desc usage to core code */

diff --git a/kernel/irq/pm.c b/kernel/irq/pm.c
index 1329f0eff49e5f5b99c5793d04e084ddef169205..f76fc00c98776746a12fb5dce9111cb4033b1553 100644 (file)
--- a/kernel/irq/pm.c
+++ b/kernel/irq/pm.c
@@ -68,10 +68,24 @@ int check_wakeup_irqs(void)
        struct irq_desc *desc;
        int irq;
 
-       for_each_irq_desc(irq, desc)
-               if (irqd_is_wakeup_set(&desc->irq_data) &&
-                   (desc->istate & IRQS_PENDING))
-                       return -EBUSY;
+       for_each_irq_desc(irq, desc) {
+               if (irqd_is_wakeup_set(&desc->irq_data)) {
+                       if (desc->istate & IRQS_PENDING)
+                               return -EBUSY;
+                       continue;
+               }
+               /*
+                * Check the non wakeup interrupts whether they need
+                * to be masked before finally going into suspend
+                * state. That's for hardware which has no wakeup
+                * source configuration facility. The chip
+                * implementation indicates that with
+                * IRQCHIP_MASK_ON_SUSPEND.
+                */
+               if (desc->istate & IRQS_SUSPENDED &&
+                   irq_desc_get_chip(desc)->flags & IRQCHIP_MASK_ON_SUSPEND)
+                       mask_irq(desc);
+       }
 
        return 0;
 }