genirq: Add IRQ_INPROGRESS to core

We need to maintain the flag for now in both fields status and istate.
Add a CONFIG_GENERIC_HARDIRQS_NO_COMPAT switch to allow testing w/o
the status one. Wrap the access to status IRQ_INPROGRESS in a inline
which can be turned of with CONFIG_GENERIC_HARDIRQS_NO_COMPAT along
with the define.

There is no reason that anything outside of core looks at this. That
needs some modifications, but we'll get there.

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>

diff --git a/include/linux/irq.h b/include/linux/irq.h
index 047a695511dfa3d23c2ec53b80e6a03fbf32baa0..274590fc55a32b03cd23d72f52a0c55af4d8b851 100644 (file)
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -50,7 +50,11 @@ typedef      void (*irq_flow_handler_t)(unsigned int irq,
 #define IRQ_TYPE_PROBE         0x00000010      /* Probing in progress */
 
 /* Internal flags */
-#define IRQ_INPROGRESS         0x00000100      /* IRQ handler active - do not enter! */
+
+#ifndef CONFIG_GENERIC_HARDIRQS_NO_COMPAT
+#define IRQ_INPROGRESS         0x00000100      /* DEPRECATED */
+#endif
+
 #define IRQ_DISABLED           0x00000200      /* IRQ disabled - do not enter! */
 #define IRQ_PENDING            0x00000400      /* IRQ pending - replay on enable */
 #define IRQ_REPLAY             0x00000800      /* IRQ has been replayed but not acked yet */

diff --git a/kernel/irq/Kconfig b/kernel/irq/Kconfig
index 4cd5d7135e0f5c1ba83211417332430f696f30e7..9e2256de1d1a69353fc650ee154b97773f05a594 100644 (file)
--- a/kernel/irq/Kconfig
+++ b/kernel/irq/Kconfig
@@ -13,6 +13,9 @@ config GENERIC_HARDIRQS
 config GENERIC_HARDIRQS_NO_DEPRECATED
        def_bool n
 
+config GENERIC_HARDIRQS_NO_COMPAT
+       def_bool n
+
 # Options selectable by the architecture code
 config HAVE_SPARSE_IRQ
        def_bool n

diff --git a/kernel/irq/chip.c b/kernel/irq/chip.c
index 34245e7d12138bc72a8ad246cfa314642289300a..075385549dcd914c9e1e6bd0d4328a46de569ae6 100644 (file)
--- a/kernel/irq/chip.c
+++ b/kernel/irq/chip.c
@@ -383,7 +383,8 @@ void handle_nested_irq(unsigned int irq)
        if (unlikely(!action || (desc->status & IRQ_DISABLED)))
                goto out_unlock;
 
-       desc->status |= IRQ_INPROGRESS;
+       irq_compat_set_progress(desc);
+       desc->istate |= IRQS_INPROGRESS;
        raw_spin_unlock_irq(&desc->lock);
 
        action_ret = action->thread_fn(action->irq, action->dev_id);
@@ -391,7 +392,8 @@ void handle_nested_irq(unsigned int irq)
                note_interrupt(irq, desc, action_ret);
 
        raw_spin_lock_irq(&desc->lock);
-       desc->status &= ~IRQ_INPROGRESS;
+       desc->istate &= ~IRQS_INPROGRESS;
+       irq_compat_clr_progress(desc);
 
 out_unlock:
        raw_spin_unlock_irq(&desc->lock);
@@ -422,7 +424,7 @@ handle_simple_irq(unsigned int irq, struct irq_desc *desc)
 {
        raw_spin_lock(&desc->lock);
 
-       if (unlikely(desc->status & IRQ_INPROGRESS))
+       if (unlikely(desc->istate & IRQS_INPROGRESS))
                if (!irq_check_poll(desc))
                        goto out_unlock;
 
@@ -454,7 +456,7 @@ handle_level_irq(unsigned int irq, struct irq_desc *desc)
        raw_spin_lock(&desc->lock);
        mask_ack_irq(desc);
 
-       if (unlikely(desc->status & IRQ_INPROGRESS))
+       if (unlikely(desc->istate & IRQS_INPROGRESS))
                if (!irq_check_poll(desc))
                        goto out_unlock;
 
@@ -492,7 +494,7 @@ handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)
 {
        raw_spin_lock(&desc->lock);
 
-       if (unlikely(desc->status & IRQ_INPROGRESS))
+       if (unlikely(desc->istate & IRQS_INPROGRESS))
                if (!irq_check_poll(desc))
                        goto out;
 
@@ -542,8 +544,8 @@ handle_edge_irq(unsigned int irq, struct irq_desc *desc)
         * we shouldn't process the IRQ. Mark it pending, handle
         * the necessary masking and go out
         */
-       if (unlikely((desc->status & (IRQ_INPROGRESS | IRQ_DISABLED)) ||
-                   !desc->action)) {
+       if (unlikely((desc->istate & (IRQS_INPROGRESS) ||
+                     (desc->status & IRQ_DISABLED) || !desc->action))) {
                if (!irq_check_poll(desc)) {
                        desc->status |= IRQ_PENDING;
                        mask_ack_irq(desc);

diff --git a/kernel/irq/compat.h b/kernel/irq/compat.h
new file mode 100644 (file)
index 0000000..aac6e40
--- /dev/null
+++ b/kernel/irq/compat.h
@@ -0,0 +1,17 @@
+/*
+ * Compat layer for transition period
+ */
+#ifndef CONFIG_GENERIC_HARDIRQS_NO_COMPAT
+static inline void irq_compat_set_progress(struct irq_desc *desc)
+{
+       desc->status |= IRQ_INPROGRESS;
+}
+
+static inline void irq_compat_clr_progress(struct irq_desc *desc)
+{
+       desc->status &= ~IRQ_INPROGRESS;
+}
+#else
+static inline void irq_compat_set_progress(struct irq_desc *desc) { }
+static inline void irq_compat_clr_progress(struct irq_desc *desc) { }
+#endif

diff --git a/kernel/irq/handle.c b/kernel/irq/handle.c
index ff40e0f5e2e2f33146620f054e6cfefb69462c57..d4ae0b1ccc00f0fb2bf7af1551f9c475104c3da4 100644 (file)
--- a/kernel/irq/handle.c
+++ b/kernel/irq/handle.c
@@ -123,13 +123,15 @@ irqreturn_t handle_irq_event(struct irq_desc *desc)
        irqreturn_t ret;
 
        desc->status &= ~IRQ_PENDING;
-       desc->status |= IRQ_INPROGRESS;
+       irq_compat_set_progress(desc);
+       desc->istate |= IRQS_INPROGRESS;
        raw_spin_unlock(&desc->lock);
 
        ret = handle_irq_event_percpu(desc, action);
 
        raw_spin_lock(&desc->lock);
-       desc->status &= ~IRQ_INPROGRESS;
+       desc->istate &= ~IRQS_INPROGRESS;
+       irq_compat_clr_progress(desc);
        return ret;
 }
 

diff --git a/kernel/irq/internals.h b/kernel/irq/internals.h
index f5d28e1e1eda1c02540579d6f21e382b2d6a4380..d1cb1f8df6fe0a9479f6511bcfedf149b448b7af 100644 (file)
--- a/kernel/irq/internals.h
+++ b/kernel/irq/internals.h
@@ -13,6 +13,7 @@
 # define IRQ_BITMAP_BITS       NR_IRQS
 #endif
 
+#include "compat.h"
 #include "settings.h"
 
 #define istate core_internal_state__do_not_mess_with_it
@@ -40,11 +41,13 @@ enum {
  * IRQS_SPURIOUS_DISABLED      - was disabled due to spurious interrupt
  *                               detection
  * IRQS_POLL_INPROGRESS                - polling in progress
+ * IRQS_INPROGRESS             - Interrupt in progress
  */
 enum {
        IRQS_AUTODETECT         = 0x00000001,
        IRQS_SPURIOUS_DISABLED  = 0x00000002,
        IRQS_POLL_INPROGRESS    = 0x00000008,
+       IRQS_INPROGRESS         = 0x00000010,
 };
 
 #define irq_data_to_desc(data) container_of(data, struct irq_desc, irq_data)
@@ -128,7 +131,6 @@ static inline void print_irq_desc(unsigned int irq, struct irq_desc *desc)
                print_symbol("%s\n", (unsigned long)desc->action->handler);
        }
 
-       P(IRQ_INPROGRESS);
        P(IRQ_DISABLED);
        P(IRQ_PENDING);
        P(IRQ_REPLAY);
@@ -143,6 +145,7 @@ static inline void print_irq_desc(unsigned int irq, struct irq_desc *desc)
        P(IRQ_NOAUTOEN);
 
        PS(IRQS_AUTODETECT);
+       PS(IRQS_INPROGRESS);
 }
 
 #undef P

diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index 5b918ffa46afa2436800fc1adeb52b334e8a1d95..7e5a50825088b9fdb1dffffcb3ea7f2dc2f52181 100644 (file)
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -30,7 +30,7 @@
 void synchronize_irq(unsigned int irq)
 {
        struct irq_desc *desc = irq_to_desc(irq);
-       unsigned int status;
+       unsigned int state;
 
        if (!desc)
                return;
@@ -42,16 +42,16 @@ void synchronize_irq(unsigned int irq)
                 * Wait until we're out of the critical section.  This might
                 * give the wrong answer due to the lack of memory barriers.
                 */
-               while (desc->status & IRQ_INPROGRESS)
+               while (desc->istate & IRQS_INPROGRESS)
                        cpu_relax();
 
                /* Ok, that indicated we're done: double-check carefully. */
                raw_spin_lock_irqsave(&desc->lock, flags);
-               status = desc->status;
+               state = desc->istate;
                raw_spin_unlock_irqrestore(&desc->lock, flags);
 
                /* Oops, that failed? */
-       } while (status & IRQ_INPROGRESS);
+       } while (state & IRQS_INPROGRESS);
 
        /*
         * We made sure that no hardirq handler is running. Now verify
@@ -637,9 +637,9 @@ again:
         * The thread is faster done than the hard interrupt handler
         * on the other CPU. If we unmask the irq line then the
         * interrupt can come in again and masks the line, leaves due
-        * to IRQ_INPROGRESS and the irq line is masked forever.
+        * to IRQS_INPROGRESS and the irq line is masked forever.
         */
-       if (unlikely(desc->status & IRQ_INPROGRESS)) {
+       if (unlikely(desc->istate & IRQS_INPROGRESS)) {
                raw_spin_unlock_irq(&desc->lock);
                chip_bus_sync_unlock(desc);
                cpu_relax();
@@ -897,8 +897,9 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
                        desc->status |= IRQ_PER_CPU;
 #endif
 
-               desc->status &= ~(IRQ_WAITING | IRQ_ONESHOT | IRQ_INPROGRESS);
-               desc->istate &= ~(IRQS_AUTODETECT | IRQS_SPURIOUS_DISABLED);
+               desc->status &= ~(IRQ_WAITING | IRQ_ONESHOT);
+               desc->istate &= ~(IRQS_AUTODETECT | IRQS_SPURIOUS_DISABLED | \
+                                 IRQS_INPROGRESS);
 
                if (new->flags & IRQF_ONESHOT)
                        desc->status |= IRQ_ONESHOT;

diff --git a/kernel/irq/settings.h b/kernel/irq/settings.h
index 610f55597ce7eed64a062e5e1d4a09986dd66444..a96140eea409e08dc36946ccbf27c34cea875a9f 100644 (file)
--- a/kernel/irq/settings.h
+++ b/kernel/irq/settings.h
@@ -5,3 +5,6 @@
 enum {
        _IRQ_DEFAULT_INIT_FLAGS = IRQ_DEFAULT_INIT_FLAGS,
 };
+
+#undef IRQ_INPROGRESS
+#define IRQ_INPROGRESS         GOT_YOU_MORON

diff --git a/kernel/irq/spurious.c b/kernel/irq/spurious.c
index 21c46178b1a6a968ba66f233f706129737d7dcda..51504837d8ccea4426ce2462e971f2be8a97f32f 100644 (file)
--- a/kernel/irq/spurious.c
+++ b/kernel/irq/spurious.c
@@ -45,10 +45,10 @@ bool irq_wait_for_poll(struct irq_desc *desc)
 #ifdef CONFIG_SMP
        do {
                raw_spin_unlock(&desc->lock);
-               while (desc->status & IRQ_INPROGRESS)
+               while (desc->istate & IRQS_INPROGRESS)
                        cpu_relax();
                raw_spin_lock(&desc->lock);
-       } while (desc->status & IRQ_INPROGRESS);
+       } while (desc->istate & IRQS_INPROGRESS);
        /* Might have been disabled in meantime */
        return !(desc->status & IRQ_DISABLED) && desc->action;
 #else
@@ -88,7 +88,7 @@ static int try_one_irq(int irq, struct irq_desc *desc, bool force)
                goto out;
 
        /* Already running on another processor */
-       if (desc->status & IRQ_INPROGRESS) {
+       if (desc->istate & IRQS_INPROGRESS) {
                /*
                 * Already running: If it is shared get the other
                 * CPU to go looking for our mystery interrupt too