12 files changed, 577 insertions, 152 deletions
diff --git a/kernel/irq/Makefile b/kernel/irq/Makefile
index 3394f8f52964..7d047808419d 100644
--- a/kernel/irq/Makefile
+++ b/kernel/irq/Makefile
@@ -3,5 +3,5 @@ obj-y := handle.o manage.o spurious.o resend.o chip.o devres.o
 obj-$(CONFIG_GENERIC_IRQ_PROBE) += autoprobe.o
 obj-$(CONFIG_PROC_FS) += proc.o
 obj-$(CONFIG_GENERIC_PENDING_IRQ) += migration.o
-obj-$(CONFIG_NUMA_MIGRATE_IRQ_DESC) += numa_migrate.o
+obj-$(CONFIG_NUMA_IRQ_DESC) += numa_migrate.o
 obj-$(CONFIG_PM_SLEEP) += pm.o
diff --git a/kernel/irq/chip.c b/kernel/irq/chip.c
index c687ba4363f2..ba566c261adc 100644
--- a/kernel/irq/chip.c
+++ b/kernel/irq/chip.c
@@ -166,11 +166,11 @@ int set_irq_data(unsigned int irq, void *data)
 EXPORT_SYMBOL(set_irq_data);
 /**
- *      set_irq_data - set irq type data for an irq
+ *      set_irq_msi - set MSI descriptor data for an irq
 *      @irq:   Interrupt number
 *      @entry: Pointer to MSI descriptor data
 *
- *      Set the hardware irq controller data for an irq
+ *      Set the MSI descriptor entry for an irq
 */
 int set_irq_msi(unsigned int irq, struct msi_desc *entry)
 {
@@ -222,6 +222,34 @@ int set_irq_chip_data(unsigned int irq, void *data)
 }
 EXPORT_SYMBOL(set_irq_chip_data);
+/**
+ *      set_irq_nested_thread - Set/Reset the IRQ_NESTED_THREAD flag of an irq
+ *
+ *      @irq:   Interrupt number
+ *      @nest:  0 to clear / 1 to set the IRQ_NESTED_THREAD flag
+ *
+ *      The IRQ_NESTED_THREAD flag indicates that on
+ *      request_threaded_irq() no separate interrupt thread should be
+ *      created for the irq as the handler are called nested in the
+ *      context of a demultiplexing interrupt handler thread.
+ */
+void set_irq_nested_thread(unsigned int irq, int nest)
+{
+        struct irq_desc *desc = irq_to_desc(irq);
+        unsigned long flags;
+        if (!desc)
+                return;
+        spin_lock_irqsave(&desc->lock, flags);
+        if (nest)
+                desc->status |= IRQ_NESTED_THREAD;
+        else
+                desc->status &= ~IRQ_NESTED_THREAD;
+        spin_unlock_irqrestore(&desc->lock, flags);
+}
+EXPORT_SYMBOL_GPL(set_irq_nested_thread);
 /*
 * default enable function
 */
@@ -299,6 +327,45 @@ static inline void mask_ack_irq(struct irq_desc *desc, int irq)
        }
 }
+/*
+ *      handle_nested_irq - Handle a nested irq from a irq thread
+ *      @irq:   the interrupt number
+ *
+ *      Handle interrupts which are nested into a threaded interrupt
+ *      handler. The handler function is called inside the calling
+ *      threads context.
+ */
+void handle_nested_irq(unsigned int irq)
+{
+        struct irq_desc *desc = irq_to_desc(irq);
+        struct irqaction *action;
+        irqreturn_t action_ret;
+        might_sleep();
+        spin_lock_irq(&desc->lock);
+        kstat_incr_irqs_this_cpu(irq, desc);
+        action = desc->action;
+        if (unlikely(!action || (desc->status & IRQ_DISABLED)))
+                goto out_unlock;
+        desc->status |= IRQ_INPROGRESS;
+        spin_unlock_irq(&desc->lock);
+        action_ret = action->thread_fn(action->irq, action->dev_id);
+        if (!noirqdebug)
+                note_interrupt(irq, desc, action_ret);
+        spin_lock_irq(&desc->lock);
+        desc->status &= ~IRQ_INPROGRESS;
+out_unlock:
+        spin_unlock_irq(&desc->lock);
+}
+EXPORT_SYMBOL_GPL(handle_nested_irq);
 /**
 *      handle_simple_irq - Simple and software-decoded IRQs.
 *      @irq:   the interrupt number
@@ -359,7 +426,6 @@ handle_level_irq(unsigned int irq, struct irq_desc *desc)
        spin_lock(&desc->lock);
        mask_ack_irq(desc, irq);
-        desc = irq_remap_to_desc(irq, desc);
        if (unlikely(desc->status & IRQ_INPROGRESS))
                goto out_unlock;
@@ -383,7 +449,10 @@ handle_level_irq(unsigned int irq, struct irq_desc *desc)
        spin_lock(&desc->lock);
        desc->status &= ~IRQ_INPROGRESS;
-        if (!(desc->status & IRQ_DISABLED) && desc->chip->unmask)
+        if (unlikely(desc->status & IRQ_ONESHOT))
+                desc->status |= IRQ_MASKED;
+        else if (!(desc->status & IRQ_DISABLED) && desc->chip->unmask)
                desc->chip->unmask(irq);
 out_unlock:
        spin_unlock(&desc->lock);
@@ -438,7 +507,6 @@ handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)
        desc->status &= ~IRQ_INPROGRESS;
 out:
        desc->chip->eoi(irq);
-        desc = irq_remap_to_desc(irq, desc);
        spin_unlock(&desc->lock);
 }
@@ -475,7 +543,6 @@ handle_edge_irq(unsigned int irq, struct irq_desc *desc)
                    !desc->action)) {
                desc->status |= (IRQ_PENDING | IRQ_MASKED);
                mask_ack_irq(desc, irq);
-                desc = irq_remap_to_desc(irq, desc);
                goto out_unlock;
        }
        kstat_incr_irqs_this_cpu(irq, desc);
@@ -483,7 +550,6 @@ handle_edge_irq(unsigned int irq, struct irq_desc *desc)
        /* Start handling the irq */
        if (desc->chip->ack)
                desc->chip->ack(irq);
-        desc = irq_remap_to_desc(irq, desc);
        /* Mark the IRQ currently in progress.*/
        desc->status |= IRQ_INPROGRESS;
@@ -524,7 +590,7 @@ out_unlock:
 }
 /**
- *      handle_percpu_IRQ - Per CPU local irq handler
+ *      handle_percpu_irq - Per CPU local irq handler
 *      @irq:   the interrupt number
 *      @desc:  the interrupt description structure for this irq
 *
@@ -544,10 +610,8 @@ handle_percpu_irq(unsigned int irq, struct irq_desc *desc)
        if (!noirqdebug)
                note_interrupt(irq, desc, action_ret);
-        if (desc->chip->eoi) {
+        if (desc->chip->eoi)
                desc->chip->eoi(irq);
-                desc = irq_remap_to_desc(irq, desc);
-        }
 }
 void
@@ -578,14 +642,13 @@ __set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
                desc->chip = &dummy_irq_chip;
        }
+        chip_bus_lock(irq, desc);
        spin_lock_irqsave(&desc->lock, flags);
        /* Uninstall? */
        if (handle == handle_bad_irq) {
-                if (desc->chip != &no_irq_chip) {
+                if (desc->chip != &no_irq_chip)
                        mask_ack_irq(desc, irq);
-                        desc = irq_remap_to_desc(irq, desc);
-                }
                desc->status |= IRQ_DISABLED;
                desc->depth = 1;
        }
@@ -599,6 +662,7 @@ __set_irq_handler(unsigned int irq, irq_flow_handler_t handle, int is_chained,
                desc->chip->startup(irq);
        }
        spin_unlock_irqrestore(&desc->lock, flags);
+        chip_bus_sync_unlock(irq, desc);
 }
 EXPORT_SYMBOL_GPL(__set_irq_handler);
diff --git a/kernel/irq/devres.c b/kernel/irq/devres.c
index 38a25b8d8bff..d06df9c41cba 100644
--- a/kernel/irq/devres.c
+++ b/kernel/irq/devres.c
@@ -26,10 +26,12 @@ static int devm_irq_match(struct device *dev, void *res, void *data)
 }
 /**
- *      devm_request_irq - allocate an interrupt line for a managed device
+ *      devm_request_threaded_irq - allocate an interrupt line for a managed device
 *      @dev: device to request interrupt for
 *      @irq: Interrupt line to allocate
 *      @handler: Function to be called when the IRQ occurs
+ *      @thread_fn: function to be called in a threaded interrupt context. NULL
+ *                  for devices which handle everything in @handler
 *      @irqflags: Interrupt type flags
 *      @devname: An ascii name for the claiming device
 *      @dev_id: A cookie passed back to the handler function
@@ -42,9 +44,10 @@ static int devm_irq_match(struct device *dev, void *res, void *data)
 *      If an IRQ allocated with this function needs to be freed
 *      separately, dev_free_irq() must be used.
 */
-int devm_request_irq(struct device *dev, unsigned int irq,
+int devm_request_threaded_irq(struct device *dev, unsigned int irq,
-                     irq_handler_t handler, unsigned long irqflags,
+                              irq_handler_t handler, irq_handler_t thread_fn,
-                     const char *devname, void *dev_id)
+                              unsigned long irqflags, const char *devname,
+                              void *dev_id)
 {
        struct irq_devres *dr;
        int rc;
@@ -54,7 +57,8 @@ int devm_request_irq(struct device *dev, unsigned int irq,
        if (!dr)
                return -ENOMEM;
-        rc = request_irq(irq, handler, irqflags, devname, dev_id);
+        rc = request_threaded_irq(irq, handler, thread_fn, irqflags, devname,
+                                  dev_id);
        if (rc) {
                devres_free(dr);
                return rc;
@@ -66,7 +70,7 @@ int devm_request_irq(struct device *dev, unsigned int irq,
        return 0;
 }
-EXPORT_SYMBOL(devm_request_irq);
+EXPORT_SYMBOL(devm_request_threaded_irq);
 /**
 *      devm_free_irq - free an interrupt
diff --git a/kernel/irq/handle.c b/kernel/irq/handle.c
index 9ebf77968871..17c71bb565c6 100644
--- a/kernel/irq/handle.c
+++ b/kernel/irq/handle.c
@@ -11,6 +11,8 @@
 */
 #include <linux/irq.h>
+#include <linux/sched.h>
+#include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/random.h>
 #include <linux/interrupt.h>
@@ -18,6 +20,7 @@
 #include <linux/rculist.h>
 #include <linux/hash.h>
 #include <linux/bootmem.h>
+#include <trace/events/irq.h>
 #include "internals.h"
@@ -43,7 +46,7 @@ void handle_bad_irq(unsigned int irq, struct irq_desc *desc)
 #if defined(CONFIG_SMP) && defined(CONFIG_GENERIC_HARDIRQS)
 static void __init init_irq_default_affinity(void)
 {
-        alloc_bootmem_cpumask_var(&irq_default_affinity);
+        alloc_cpumask_var(&irq_default_affinity, GFP_NOWAIT);
        cpumask_setall(irq_default_affinity);
 }
 #else
@@ -80,45 +83,48 @@ static struct irq_desc irq_desc_init = {
        .lock       = __SPIN_LOCK_UNLOCKED(irq_desc_init.lock),
 };
-void init_kstat_irqs(struct irq_desc *desc, int cpu, int nr)
+void __ref init_kstat_irqs(struct irq_desc *desc, int node, int nr)
 {
-        int node;
        void *ptr;
-        node = cpu_to_node(cpu);
+        if (slab_is_available())
-        ptr = kzalloc_node(nr * sizeof(*desc->kstat_irqs), GFP_ATOMIC, node);
+                ptr = kzalloc_node(nr * sizeof(*desc->kstat_irqs),
+                                   GFP_ATOMIC, node);
+        else
+                ptr = alloc_bootmem_node(NODE_DATA(node),
+                                nr * sizeof(*desc->kstat_irqs));
        /*
         * don't overwite if can not get new one
         * init_copy_kstat_irqs() could still use old one
         */
        if (ptr) {
-                printk(KERN_DEBUG "  alloc kstat_irqs on cpu %d node %d\n",
+                printk(KERN_DEBUG "  alloc kstat_irqs on node %d\n", node);
-                         cpu, node);
                desc->kstat_irqs = ptr;
        }
 }
-static void init_one_irq_desc(int irq, struct irq_desc *desc, int cpu)
+static void init_one_irq_desc(int irq, struct irq_desc *desc, int node)
 {
        memcpy(desc, &irq_desc_init, sizeof(struct irq_desc));
        spin_lock_init(&desc->lock);
        desc->irq = irq;
 #ifdef CONFIG_SMP
-        desc->cpu = cpu;
+        desc->node = node;
 #endif
        lockdep_set_class(&desc->lock, &irq_desc_lock_class);
-        init_kstat_irqs(desc, cpu, nr_cpu_ids);
+        init_kstat_irqs(desc, node, nr_cpu_ids);
        if (!desc->kstat_irqs) {
                printk(KERN_ERR "can not alloc kstat_irqs\n");
                BUG_ON(1);
        }
-        if (!init_alloc_desc_masks(desc, cpu, false)) {
+        if (!alloc_desc_masks(desc, node, false)) {
                printk(KERN_ERR "can not alloc irq_desc cpumasks\n");
                BUG_ON(1);
        }
-        arch_init_chip_data(desc, cpu);
+        init_desc_masks(desc);
+        arch_init_chip_data(desc, node);
 }
 /*
@@ -145,6 +151,7 @@ int __init early_irq_init(void)
 {
        struct irq_desc *desc;
        int legacy_count;
+        int node;
        int i;
        init_irq_default_affinity();
@@ -155,20 +162,24 @@ int __init early_irq_init(void)
        desc = irq_desc_legacy;
        legacy_count = ARRAY_SIZE(irq_desc_legacy);
+        node = first_online_node;
        /* allocate irq_desc_ptrs array based on nr_irqs */
-        irq_desc_ptrs = alloc_bootmem(nr_irqs * sizeof(void *));
+        irq_desc_ptrs = kcalloc(nr_irqs, sizeof(void *), GFP_NOWAIT);
        /* allocate based on nr_cpu_ids */
-        /* FIXME: invert kstat_irgs, and it'd be a per_cpu_alloc'd thing */
+        kstat_irqs_legacy = kzalloc_node(NR_IRQS_LEGACY * nr_cpu_ids *
-        kstat_irqs_legacy = alloc_bootmem(NR_IRQS_LEGACY * nr_cpu_ids *
+                                          sizeof(int), GFP_NOWAIT, node);
-                                          sizeof(int));
        for (i = 0; i < legacy_count; i++) {
                desc[i].irq = i;
+#ifdef CONFIG_SMP
+                desc[i].node = node;
+#endif
                desc[i].kstat_irqs = kstat_irqs_legacy + i * nr_cpu_ids;
                lockdep_set_class(&desc[i].lock, &irq_desc_lock_class);
-                init_alloc_desc_masks(&desc[i], 0, true);
+                alloc_desc_masks(&desc[i], node, true);
+                init_desc_masks(&desc[i]);
                irq_desc_ptrs[i] = desc + i;
        }
@@ -186,11 +197,10 @@ struct irq_desc *irq_to_desc(unsigned int irq)
        return NULL;
 }
-struct irq_desc *irq_to_desc_alloc_cpu(unsigned int irq, int cpu)
+struct irq_desc * __ref irq_to_desc_alloc_node(unsigned int irq, int node)
 {
        struct irq_desc *desc;
        unsigned long flags;
-        int node;
        if (irq >= nr_irqs) {
                WARN(1, "irq (%d) >= nr_irqs (%d) in irq_to_desc_alloc\n",
@@ -209,15 +219,17 @@ struct irq_desc *irq_to_desc_alloc_cpu(unsigned int irq, int cpu)
        if (desc)
                goto out_unlock;
-        node = cpu_to_node(cpu);
+        if (slab_is_available())
-        desc = kzalloc_node(sizeof(*desc), GFP_ATOMIC, node);
+                desc = kzalloc_node(sizeof(*desc), GFP_ATOMIC, node);
-        printk(KERN_DEBUG "  alloc irq_desc for %d on cpu %d node %d\n",
+        else
-                 irq, cpu, node);
+                desc = alloc_bootmem_node(NODE_DATA(node), sizeof(*desc));
+        printk(KERN_DEBUG "  alloc irq_desc for %d on node %d\n", irq, node);
        if (!desc) {
                printk(KERN_ERR "can not alloc irq_desc\n");
                BUG_ON(1);
        }
-        init_one_irq_desc(irq, desc, cpu);
+        init_one_irq_desc(irq, desc, node);
        irq_desc_ptrs[irq] = desc;
@@ -255,7 +267,8 @@ int __init early_irq_init(void)
        for (i = 0; i < count; i++) {
                desc[i].irq = i;
-                init_alloc_desc_masks(&desc[i], 0, true);
+                alloc_desc_masks(&desc[i], 0, true);
+                init_desc_masks(&desc[i]);
                desc[i].kstat_irqs = kstat_irqs_all[i];
        }
        return arch_early_irq_init();
@@ -266,7 +279,7 @@ struct irq_desc *irq_to_desc(unsigned int irq)
        return (irq < NR_IRQS) ? irq_desc + irq : NULL;
 }
-struct irq_desc *irq_to_desc_alloc_cpu(unsigned int irq, int cpu)
+struct irq_desc *irq_to_desc_alloc_node(unsigned int irq, int node)
 {
        return irq_to_desc(irq);
 }
@@ -338,6 +351,15 @@ irqreturn_t no_action(int cpl, void *dev_id)
        return IRQ_NONE;
 }
+static void warn_no_thread(unsigned int irq, struct irqaction *action)
+{
+        if (test_and_set_bit(IRQTF_WARNED, &action->thread_flags))
+                return;
+        printk(KERN_WARNING "IRQ %d device %s returned IRQ_WAKE_THREAD "
+               "but no thread function available.", irq, action->name);
+}
 /**
 * handle_IRQ_event - irq action chain handler
 * @irq:        the interrupt number
@@ -350,15 +372,54 @@ irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action)
        irqreturn_t ret, retval = IRQ_NONE;
        unsigned int status = 0;
-        WARN_ONCE(!in_irq(), "BUG: IRQ handler called from non-hardirq context!");
        if (!(action->flags & IRQF_DISABLED))
                local_irq_enable_in_hardirq();
        do {
+                trace_irq_handler_entry(irq, action);
                ret = action->handler(irq, action->dev_id);
-                if (ret == IRQ_HANDLED)
+                trace_irq_handler_exit(irq, action, ret);
+                switch (ret) {
+                case IRQ_WAKE_THREAD:
+                        /*
+                         * Set result to handled so the spurious check
+                         * does not trigger.
+                         */
+                        ret = IRQ_HANDLED;
+                        /*
+                         * Catch drivers which return WAKE_THREAD but
+                         * did not set up a thread function
+                         */
+                        if (unlikely(!action->thread_fn)) {
+                                warn_no_thread(irq, action);
+                                break;
+                        }
+                        /*
+                         * Wake up the handler thread for this
+                         * action. In case the thread crashed and was
+                         * killed we just pretend that we handled the
+                         * interrupt. The hardirq handler above has
+                         * disabled the device interrupt, so no irq
+                         * storm is lurking.
+                         */
+                        if (likely(!test_bit(IRQTF_DIED,
+                                             &action->thread_flags))) {
+                                set_bit(IRQTF_RUNTHREAD, &action->thread_flags);
+                                wake_up_process(action->thread);
+                        }
+                        /* Fall through to add to randomness */
+                case IRQ_HANDLED:
                        status |= action->flags;
+                        break;
+                default:
+                        break;
+                }
                retval |= ret;
                action = action->next;
        } while (action);
@@ -401,11 +462,8 @@ unsigned int __do_IRQ(unsigned int irq)
                /*
                 * No locking required for CPU-local interrupts:
                 */
-                if (desc->chip->ack) {
+                if (desc->chip->ack)
                        desc->chip->ack(irq);
-                        /* get new one */
-                        desc = irq_remap_to_desc(irq, desc);
-                }
                if (likely(!(desc->status & IRQ_DISABLED))) {
                        action_ret = handle_IRQ_event(irq, desc->action);
                        if (!noirqdebug)
@@ -416,10 +474,8 @@ unsigned int __do_IRQ(unsigned int irq)
        }
        spin_lock(&desc->lock);
-        if (desc->chip->ack) {
+        if (desc->chip->ack)
                desc->chip->ack(irq);
-                desc = irq_remap_to_desc(irq, desc);
-        }
        /*
         * REPLAY is when Linux resends an IRQ that was dropped earlier
         * WAITING is used by probe to mark irqs that are being tested
diff --git a/kernel/irq/internals.h b/kernel/irq/internals.h
index 01ce20eab38f..1b5d742c6a77 100644
--- a/kernel/irq/internals.h
+++ b/kernel/irq/internals.h
@@ -16,7 +16,7 @@ extern void __disable_irq(struct irq_desc *desc, unsigned int irq, bool susp);
 extern void __enable_irq(struct irq_desc *desc, unsigned int irq, bool resume);
 extern struct lock_class_key irq_desc_lock_class;
-extern void init_kstat_irqs(struct irq_desc *desc, int cpu, int nr);
+extern void init_kstat_irqs(struct irq_desc *desc, int node, int nr);
 extern void clear_kstat_irqs(struct irq_desc *desc);
 extern spinlock_t sparse_irq_lock;
@@ -42,6 +42,21 @@ static inline void unregister_handler_proc(unsigned int irq,
 extern int irq_select_affinity_usr(unsigned int irq);
+extern void irq_set_thread_affinity(struct irq_desc *desc);
+/* Inline functions for support of irq chips on slow busses */
+static inline void chip_bus_lock(unsigned int irq, struct irq_desc *desc)
+{
+        if (unlikely(desc->chip->bus_lock))
+                desc->chip->bus_lock(irq);
+}
+static inline void chip_bus_sync_unlock(unsigned int irq, struct irq_desc *desc)
+{
+        if (unlikely(desc->chip->bus_sync_unlock))
+                desc->chip->bus_sync_unlock(irq);
+}
 /*
 * Debugging printout:
 */
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index 8c68d5b95d48..7305b297d1eb 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -8,16 +8,15 @@
 */
 #include <linux/irq.h>
+#include <linux/kthread.h>
 #include <linux/module.h>
 #include <linux/random.h>
 #include <linux/interrupt.h>
 #include <linux/slab.h>
+#include <linux/sched.h>
 #include "internals.h"
-#if defined(CONFIG_SMP) && defined(CONFIG_GENERIC_HARDIRQS)
-cpumask_var_t irq_default_affinity;
 /**
 *      synchronize_irq - wait for pending IRQ handlers (on other CPUs)
 *      @irq: interrupt number to wait for
@@ -53,9 +52,18 @@ void synchronize_irq(unsigned int irq)
                /* Oops, that failed? */
        } while (status & IRQ_INPROGRESS);
+        /*
+         * We made sure that no hardirq handler is running. Now verify
+         * that no threaded handlers are active.
+         */
+        wait_event(desc->wait_for_threads, !atomic_read(&desc->threads_active));
 }
 EXPORT_SYMBOL(synchronize_irq);
+#ifdef CONFIG_SMP
+cpumask_var_t irq_default_affinity;
 /**
 *      irq_can_set_affinity - Check if the affinity of a given irq can be set
 *      @irq:           Interrupt to check
@@ -73,6 +81,26 @@ int irq_can_set_affinity(unsigned int irq)
 }
 /**
+ *      irq_set_thread_affinity - Notify irq threads to adjust affinity
+ *      @desc:          irq descriptor which has affitnity changed
+ *
+ *      We just set IRQTF_AFFINITY and delegate the affinity setting
+ *      to the interrupt thread itself. We can not call
+ *      set_cpus_allowed_ptr() here as we hold desc->lock and this
+ *      code can be called from hard interrupt context.
+ */
+void irq_set_thread_affinity(struct irq_desc *desc)
+{
+        struct irqaction *action = desc->action;
+        while (action) {
+                if (action->thread)
+                        set_bit(IRQTF_AFFINITY, &action->thread_flags);
+                action = action->next;
+        }
+}
+/**
 *      irq_set_affinity - Set the irq affinity of a given irq
 *      @irq:           Interrupt to set affinity
 *      @cpumask:       cpumask
@@ -89,16 +117,21 @@ int irq_set_affinity(unsigned int irq, const struct cpumask *cpumask)
        spin_lock_irqsave(&desc->lock, flags);
 #ifdef CONFIG_GENERIC_PENDING_IRQ
-        if (desc->status & IRQ_MOVE_PCNTXT || desc->status & IRQ_DISABLED) {
+        if (desc->status & IRQ_MOVE_PCNTXT) {
-                cpumask_copy(desc->affinity, cpumask);
+                if (!desc->chip->set_affinity(irq, cpumask)) {
-                desc->chip->set_affinity(irq, cpumask);
+                        cpumask_copy(desc->affinity, cpumask);
-        } else {
+                        irq_set_thread_affinity(desc);
+                }
+        }
+        else {
                desc->status |= IRQ_MOVE_PENDING;
                cpumask_copy(desc->pending_mask, cpumask);
        }
 #else
-        cpumask_copy(desc->affinity, cpumask);
+        if (!desc->chip->set_affinity(irq, cpumask)) {
-        desc->chip->set_affinity(irq, cpumask);
+                cpumask_copy(desc->affinity, cpumask);
+                irq_set_thread_affinity(desc);
+        }
 #endif
        desc->status |= IRQ_AFFINITY_SET;
        spin_unlock_irqrestore(&desc->lock, flags);
@@ -150,6 +183,8 @@ int irq_select_affinity_usr(unsigned int irq)
        spin_lock_irqsave(&desc->lock, flags);
        ret = setup_affinity(irq, desc);
+        if (!ret)
+                irq_set_thread_affinity(desc);
        spin_unlock_irqrestore(&desc->lock, flags);
        return ret;
@@ -195,9 +230,11 @@ void disable_irq_nosync(unsigned int irq)
        if (!desc)
                return;
+        chip_bus_lock(irq, desc);
        spin_lock_irqsave(&desc->lock, flags);
        __disable_irq(desc, irq, false);
        spin_unlock_irqrestore(&desc->lock, flags);
+        chip_bus_sync_unlock(irq, desc);
 }
 EXPORT_SYMBOL(disable_irq_nosync);
@@ -259,7 +296,8 @@ void __enable_irq(struct irq_desc *desc, unsigned int irq, bool resume)
 *      matches the last disable, processing of interrupts on this
 *      IRQ line is re-enabled.
 *
- *      This function may be called from IRQ context.
+ *      This function may be called from IRQ context only when
+ *      desc->chip->bus_lock and desc->chip->bus_sync_unlock are NULL !
 */
 void enable_irq(unsigned int irq)
 {
@@ -269,9 +307,11 @@ void enable_irq(unsigned int irq)
        if (!desc)
                return;
+        chip_bus_lock(irq, desc);
        spin_lock_irqsave(&desc->lock, flags);
        __enable_irq(desc, irq, false);
        spin_unlock_irqrestore(&desc->lock, flags);
+        chip_bus_sync_unlock(irq, desc);
 }
 EXPORT_SYMBOL(enable_irq);
@@ -402,6 +442,165 @@ int __irq_set_trigger(struct irq_desc *desc, unsigned int irq,
 }
 /*
+ * Default primary interrupt handler for threaded interrupts. Is
+ * assigned as primary handler when request_threaded_irq is called
+ * with handler == NULL. Useful for oneshot interrupts.
+ */
+static irqreturn_t irq_default_primary_handler(int irq, void *dev_id)
+{
+        return IRQ_WAKE_THREAD;
+}
+/*
+ * Primary handler for nested threaded interrupts. Should never be
+ * called.
+ */
+static irqreturn_t irq_nested_primary_handler(int irq, void *dev_id)
+{
+        WARN(1, "Primary handler called for nested irq %d\n", irq);
+        return IRQ_NONE;
+}
+static int irq_wait_for_interrupt(struct irqaction *action)
+{
+        while (!kthread_should_stop()) {
+                set_current_state(TASK_INTERRUPTIBLE);
+                if (test_and_clear_bit(IRQTF_RUNTHREAD,
+                                       &action->thread_flags)) {
+                        __set_current_state(TASK_RUNNING);
+                        return 0;
+                }
+                schedule();
+        }
+        return -1;
+}
+/*
+ * Oneshot interrupts keep the irq line masked until the threaded
+ * handler finished. unmask if the interrupt has not been disabled and
+ * is marked MASKED.
+ */
+static void irq_finalize_oneshot(unsigned int irq, struct irq_desc *desc)
+{
+        chip_bus_lock(irq, desc);
+        spin_lock_irq(&desc->lock);
+        if (!(desc->status & IRQ_DISABLED) && (desc->status & IRQ_MASKED)) {
+                desc->status &= ~IRQ_MASKED;
+                desc->chip->unmask(irq);
+        }
+        spin_unlock_irq(&desc->lock);
+        chip_bus_sync_unlock(irq, desc);
+}
+#ifdef CONFIG_SMP
+/*
+ * Check whether we need to change the affinity of the interrupt thread.
+ */
+static void
+irq_thread_check_affinity(struct irq_desc *desc, struct irqaction *action)
+{
+        cpumask_var_t mask;
+        if (!test_and_clear_bit(IRQTF_AFFINITY, &action->thread_flags))
+                return;
+        /*
+         * In case we are out of memory we set IRQTF_AFFINITY again and
+         * try again next time
+         */
+        if (!alloc_cpumask_var(&mask, GFP_KERNEL)) {
+                set_bit(IRQTF_AFFINITY, &action->thread_flags);
+                return;
+        }
+        spin_lock_irq(&desc->lock);
+        cpumask_copy(mask, desc->affinity);
+        spin_unlock_irq(&desc->lock);
+        set_cpus_allowed_ptr(current, mask);
+        free_cpumask_var(mask);
+}
+#else
+static inline void
+irq_thread_check_affinity(struct irq_desc *desc, struct irqaction *action) { }
+#endif
+/*
+ * Interrupt handler thread
+ */
+static int irq_thread(void *data)
+{
+        struct sched_param param = { .sched_priority = MAX_USER_RT_PRIO/2, };
+        struct irqaction *action = data;
+        struct irq_desc *desc = irq_to_desc(action->irq);
+        int wake, oneshot = desc->status & IRQ_ONESHOT;
+        sched_setscheduler(current, SCHED_FIFO, &param);
+        current->irqaction = action;
+        while (!irq_wait_for_interrupt(action)) {
+                irq_thread_check_affinity(desc, action);
+                atomic_inc(&desc->threads_active);
+                spin_lock_irq(&desc->lock);
+                if (unlikely(desc->status & IRQ_DISABLED)) {
+                        /*
+                         * CHECKME: We might need a dedicated
+                         * IRQ_THREAD_PENDING flag here, which
+                         * retriggers the thread in check_irq_resend()
+                         * but AFAICT IRQ_PENDING should be fine as it
+                         * retriggers the interrupt itself --- tglx
+                         */
+                        desc->status |= IRQ_PENDING;
+                        spin_unlock_irq(&desc->lock);
+                } else {
+                        spin_unlock_irq(&desc->lock);
+                        action->thread_fn(action->irq, action->dev_id);
+                        if (oneshot)
+                                irq_finalize_oneshot(action->irq, desc);
+                }
+                wake = atomic_dec_and_test(&desc->threads_active);
+                if (wake && waitqueue_active(&desc->wait_for_threads))
+                        wake_up(&desc->wait_for_threads);
+        }
+        /*
+         * Clear irqaction. Otherwise exit_irq_thread() would make
+         * fuzz about an active irq thread going into nirvana.
+         */
+        current->irqaction = NULL;
+        return 0;
+}
+/*
+ * Called from do_exit()
+ */
+void exit_irq_thread(void)
+{
+        struct task_struct *tsk = current;
+        if (!tsk->irqaction)
+                return;
+        printk(KERN_ERR
+               "exiting task \"%s\" (%d) is an active IRQ thread (irq %d)\n",
+               tsk->comm ? tsk->comm : "", tsk->pid, tsk->irqaction->irq);
+        /*
+         * Set the THREAD DIED flag to prevent further wakeups of the
+         * soon to be gone threaded handler.
+         */
+        set_bit(IRQTF_DIED, &tsk->irqaction->flags);
+}
+/*
 * Internal function to register an irqaction - typically used to
 * allocate special interrupts that are part of the architecture.
 */
@@ -411,7 +610,7 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
        struct irqaction *old, **old_ptr;
        const char *old_name = NULL;
        unsigned long flags;
-        int shared = 0;
+        int nested, shared = 0;
        int ret;
        if (!desc)
@@ -436,6 +635,47 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
                rand_initialize_irq(irq);
        }
+        /* Oneshot interrupts are not allowed with shared */
+        if ((new->flags & IRQF_ONESHOT) && (new->flags & IRQF_SHARED))
+                return -EINVAL;
+        /*
+         * Check whether the interrupt nests into another interrupt
+         * thread.
+         */
+        nested = desc->status & IRQ_NESTED_THREAD;
+        if (nested) {
+                if (!new->thread_fn)
+                        return -EINVAL;
+                /*
+                 * Replace the primary handler which was provided from
+                 * the driver for non nested interrupt handling by the
+                 * dummy function which warns when called.
+                 */
+                new->handler = irq_nested_primary_handler;
+        }
+        /*
+         * Create a handler thread when a thread function is supplied
+         * and the interrupt does not nest into another interrupt
+         * thread.
+         */
+        if (new->thread_fn && !nested) {
+                struct task_struct *t;
+                t = kthread_create(irq_thread, new, "irq/%d-%s", irq,
+                                   new->name);
+                if (IS_ERR(t))
+                        return PTR_ERR(t);
+                /*
+                 * We keep the reference to the task struct even if
+                 * the thread dies to avoid that the interrupt code
+                 * references an already freed task_struct.
+                 */
+                get_task_struct(t);
+                new->thread = t;
+        }
        /*
         * The following block of code has to be executed atomically
         */
@@ -473,15 +713,15 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
        if (!shared) {
                irq_chip_set_defaults(desc->chip);
+                init_waitqueue_head(&desc->wait_for_threads);
                /* Setup the type (level, edge polarity) if configured: */
                if (new->flags & IRQF_TRIGGER_MASK) {
                        ret = __irq_set_trigger(desc, irq,
                                        new->flags & IRQF_TRIGGER_MASK);
-                        if (ret) {
+                        if (ret)
-                                spin_unlock_irqrestore(&desc->lock, flags);
+                                goto out_thread;
-                                return ret;
-                        }
                } else
                        compat_irq_chip_set_default_handler(desc);
 #if defined(CONFIG_IRQ_PER_CPU)
@@ -489,9 +729,12 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
                        desc->status |= IRQ_PER_CPU;
 #endif
-                desc->status &= ~(IRQ_AUTODETECT | IRQ_WAITING |
+                desc->status &= ~(IRQ_AUTODETECT | IRQ_WAITING | IRQ_ONESHOT |
                                  IRQ_INPROGRESS | IRQ_SPURIOUS_DISABLED);
+                if (new->flags & IRQF_ONESHOT)
+                        desc->status |= IRQ_ONESHOT;
                if (!(desc->status & IRQ_NOAUTOEN)) {
                        desc->depth = 0;
                        desc->status &= ~IRQ_DISABLED;
@@ -516,6 +759,7 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
                                (int)(new->flags & IRQF_TRIGGER_MASK));
        }
+        new->irq = irq;
        *old_ptr = new;
        /* Reset broken irq detection when installing new handler */
@@ -533,7 +777,13 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
        spin_unlock_irqrestore(&desc->lock, flags);
-        new->irq = irq;
+        /*
+         * Strictly no need to wake it up, but hung_task complains
+         * when no hard interrupt wakes the thread up.
+         */
+        if (new->thread)
+                wake_up_process(new->thread);
        register_irq_proc(irq, desc);
        new->dir = NULL;
        register_handler_proc(irq, new);
@@ -549,8 +799,19 @@ mismatch:
                dump_stack();
        }
 #endif
+        ret = -EBUSY;
+out_thread:
        spin_unlock_irqrestore(&desc->lock, flags);
-        return -EBUSY;
+        if (new->thread) {
+                struct task_struct *t = new->thread;
+                new->thread = NULL;
+                if (likely(!test_bit(IRQTF_DIED, &new->thread_flags)))
+                        kthread_stop(t);
+                put_task_struct(t);
+        }
+        return ret;
 }
 /**
@@ -622,6 +883,7 @@ static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
                else
                        desc->chip->disable(irq);
        }
        spin_unlock_irqrestore(&desc->lock, flags);
        unregister_handler_proc(irq, action);
@@ -644,6 +906,13 @@ static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
                local_irq_restore(flags);
        }
 #endif
+        if (action->thread) {
+                if (!test_bit(IRQTF_DIED, &action->thread_flags))
+                        kthread_stop(action->thread);
+                put_task_struct(action->thread);
+        }
        return action;
 }
@@ -676,14 +945,26 @@ EXPORT_SYMBOL_GPL(remove_irq);
 */
 void free_irq(unsigned int irq, void *dev_id)
 {
+        struct irq_desc *desc = irq_to_desc(irq);
+        if (!desc)
+                return;
+        chip_bus_lock(irq, desc);
        kfree(__free_irq(irq, dev_id));
+        chip_bus_sync_unlock(irq, desc);
 }
 EXPORT_SYMBOL(free_irq);
 /**
- *      request_irq - allocate an interrupt line
+ *      request_threaded_irq - allocate an interrupt line
 *      @irq: Interrupt line to allocate
- *      @handler: Function to be called when the IRQ occurs
+ *      @handler: Function to be called when the IRQ occurs.
+ *                Primary handler for threaded interrupts
+ *                If NULL and thread_fn != NULL the default
+ *                primary handler is installed
+ *      @thread_fn: Function called from the irq handler thread
+ *                  If NULL, no irq thread is created
 *      @irqflags: Interrupt type flags
 *      @devname: An ascii name for the claiming device
 *      @dev_id: A cookie passed back to the handler function
@@ -695,6 +976,15 @@ EXPORT_SYMBOL(free_irq);
 *      raises, you must take care both to initialise your hardware
 *      and to set up the interrupt handler in the right order.
 *
+ *      If you want to set up a threaded irq handler for your device
+ *      then you need to supply @handler and @thread_fn. @handler ist
+ *      still called in hard interrupt context and has to check
+ *      whether the interrupt originates from the device. If yes it
+ *      needs to disable the interrupt on the device and return
+ *      IRQ_WAKE_THREAD which will wake up the handler thread and run
+ *      @thread_fn. This split handler design is necessary to support
+ *      shared interrupts.
+ *
 *      Dev_id must be globally unique. Normally the address of the
 *      device data structure is used as the cookie. Since the handler
 *      receives this value it makes sense to use it.
@@ -710,8 +1000,9 @@ EXPORT_SYMBOL(free_irq);
 *      IRQF_TRIGGER_*          Specify active edge(s) or level
 *
 */
-int request_irq(unsigned int irq, irq_handler_t handler,
+int request_threaded_irq(unsigned int irq, irq_handler_t handler,
-                unsigned long irqflags, const char *devname, void *dev_id)
+                         irq_handler_t thread_fn, unsigned long irqflags,
+                         const char *devname, void *dev_id)
 {
        struct irqaction *action;
        struct irq_desc *desc;
@@ -751,19 +1042,27 @@ int request_irq(unsigned int irq, irq_handler_t handler,
        if (desc->status & IRQ_NOREQUEST)
                return -EINVAL;
-        if (!handler)
-                return -EINVAL;
+        if (!handler) {
+                if (!thread_fn)
+                        return -EINVAL;
+                handler = irq_default_primary_handler;
+        }
        action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
        if (!action)
                return -ENOMEM;
        action->handler = handler;
+        action->thread_fn = thread_fn;
        action->flags = irqflags;
        action->name = devname;
        action->dev_id = dev_id;
+        chip_bus_lock(irq, desc);
        retval = __setup_irq(irq, desc, action);
+        chip_bus_sync_unlock(irq, desc);
        if (retval)
                kfree(action);
@@ -788,4 +1087,4 @@ int request_irq(unsigned int irq, irq_handler_t handler,
 #endif
        return retval;
 }
-EXPORT_SYMBOL(request_irq);
+EXPORT_SYMBOL(request_threaded_irq);
diff --git a/kernel/irq/migration.c b/kernel/irq/migration.c
index e05ad9be43b7..fcb6c96f2627 100644
--- a/kernel/irq/migration.c
+++ b/kernel/irq/migration.c
@@ -1,5 +1,8 @@
 #include <linux/irq.h>
+#include <linux/interrupt.h>
+#include "internals.h"
 void move_masked_irq(int irq)
 {
@@ -39,11 +42,12 @@ void move_masked_irq(int irq)
         * masking the irqs.
         */
        if (likely(cpumask_any_and(desc->pending_mask, cpu_online_mask)
-                   < nr_cpu_ids)) {
+                   < nr_cpu_ids))
-                cpumask_and(desc->affinity,
+                if (!desc->chip->set_affinity(irq, desc->pending_mask)) {
-                            desc->pending_mask, cpu_online_mask);
+                        cpumask_copy(desc->affinity, desc->pending_mask);
-                desc->chip->set_affinity(irq, desc->affinity);
+                        irq_set_thread_affinity(desc);
-        }
+                }
        cpumask_clear(desc->pending_mask);
 }
diff --git a/kernel/irq/numa_migrate.c b/kernel/irq/numa_migrate.c
index 243d6121e50e..3fd30197da2e 100644
--- a/kernel/irq/numa_migrate.c
+++ b/kernel/irq/numa_migrate.c
@@ -15,9 +15,9 @@
 static void init_copy_kstat_irqs(struct irq_desc *old_desc,
                                 struct irq_desc *desc,
-                                 int cpu, int nr)
+                                 int node, int nr)
 {
-        init_kstat_irqs(desc, cpu, nr);
+        init_kstat_irqs(desc, node, nr);
        if (desc->kstat_irqs != old_desc->kstat_irqs)
                memcpy(desc->kstat_irqs, old_desc->kstat_irqs,
@@ -34,36 +34,36 @@ static void free_kstat_irqs(struct irq_desc *old_desc, struct irq_desc *desc)
 }
 static bool init_copy_one_irq_desc(int irq, struct irq_desc *old_desc,
-                 struct irq_desc *desc, int cpu)
+                 struct irq_desc *desc, int node)
 {
        memcpy(desc, old_desc, sizeof(struct irq_desc));
-        if (!init_alloc_desc_masks(desc, cpu, false)) {
+        if (!alloc_desc_masks(desc, node, false)) {
                printk(KERN_ERR "irq %d: can not get new irq_desc cpumask "
                                "for migration.\n", irq);
                return false;
        }
        spin_lock_init(&desc->lock);
-        desc->cpu = cpu;
+        desc->node = node;
        lockdep_set_class(&desc->lock, &irq_desc_lock_class);
-        init_copy_kstat_irqs(old_desc, desc, cpu, nr_cpu_ids);
+        init_copy_kstat_irqs(old_desc, desc, node, nr_cpu_ids);
        init_copy_desc_masks(old_desc, desc);
-        arch_init_copy_chip_data(old_desc, desc, cpu);
+        arch_init_copy_chip_data(old_desc, desc, node);
        return true;
 }
 static void free_one_irq_desc(struct irq_desc *old_desc, struct irq_desc *desc)
 {
        free_kstat_irqs(old_desc, desc);
+        free_desc_masks(old_desc, desc);
        arch_free_chip_data(old_desc, desc);
 }
 static struct irq_desc *__real_move_irq_desc(struct irq_desc *old_desc,
-                                                int cpu)
+                                                int node)
 {
        struct irq_desc *desc;
        unsigned int irq;
        unsigned long flags;
-        int node;
        irq = old_desc->irq;
@@ -75,7 +75,6 @@ static struct irq_desc *__real_move_irq_desc(struct irq_desc *old_desc,
        if (desc && old_desc != desc)
                goto out_unlock;
-        node = cpu_to_node(cpu);
        desc = kzalloc_node(sizeof(*desc), GFP_ATOMIC, node);
        if (!desc) {
                printk(KERN_ERR "irq %d: can not get new irq_desc "
@@ -84,7 +83,7 @@ static struct irq_desc *__real_move_irq_desc(struct irq_desc *old_desc,
                desc = old_desc;
                goto out_unlock;
        }
-        if (!init_copy_one_irq_desc(irq, old_desc, desc, cpu)) {
+        if (!init_copy_one_irq_desc(irq, old_desc, desc, node)) {
                /* still use old one */
                kfree(desc);
                desc = old_desc;
@@ -96,9 +95,7 @@ static struct irq_desc *__real_move_irq_desc(struct irq_desc *old_desc,
        /* free the old one */
        free_one_irq_desc(old_desc, desc);
-        spin_unlock(&old_desc->lock);
        kfree(old_desc);
-        spin_lock(&desc->lock);
        return desc;
@@ -108,24 +105,14 @@ out_unlock:
        return desc;
 }
-struct irq_desc *move_irq_desc(struct irq_desc *desc, int cpu)
+struct irq_desc *move_irq_desc(struct irq_desc *desc, int node)
 {
-        int old_cpu;
+        /* those static or target node is -1, do not move them */
-        int node, old_node;
+        if (desc->irq < NR_IRQS_LEGACY || node == -1)
-        /* those all static, do move them */
-        if (desc->irq < NR_IRQS_LEGACY)
                return desc;
-        old_cpu = desc->cpu;
+        if (desc->node != node)
-        if (old_cpu != cpu) {
+                desc = __real_move_irq_desc(desc, node);
-                node = cpu_to_node(cpu);
-                old_node = cpu_to_node(old_cpu);
-                if (old_node != node)
-                        desc = __real_move_irq_desc(desc, cpu);
-                else
-                        desc->cpu = cpu;
-        }
        return desc;
 }
diff --git a/kernel/irq/pm.c b/kernel/irq/pm.c
index 638d8bedec14..a0bb09e79867 100644
--- a/kernel/irq/pm.c
+++ b/kernel/irq/pm.c
@@ -15,10 +15,10 @@
 /**
 * suspend_device_irqs - disable all currently enabled interrupt lines
 *
- * During system-wide suspend or hibernation device interrupts need to be
+ * During system-wide suspend or hibernation device drivers need to be prevented
- * disabled at the chip level and this function is provided for this purpose.
+ * from receiving interrupts and this function is provided for this purpose.
- * It disables all interrupt lines that are enabled at the moment and sets the
+ * It marks all interrupt lines in use, except for the timer ones, as disabled
- * IRQ_SUSPENDED flag for them.
+ * and sets the IRQ_SUSPENDED flag for each of them.
 */
 void suspend_device_irqs(void)
 {
diff --git a/kernel/irq/proc.c b/kernel/irq/proc.c
index 692363dd591f..0832145fea97 100644
--- a/kernel/irq/proc.c
+++ b/kernel/irq/proc.c
@@ -136,7 +136,7 @@ out:
 static int default_affinity_open(struct inode *inode, struct file *file)
 {
-        return single_open(file, default_affinity_show, NULL);
+        return single_open(file, default_affinity_show, PDE(inode)->data);
 }
 static const struct file_operations default_affinity_proc_fops = {
@@ -148,18 +148,28 @@ static const struct file_operations default_affinity_proc_fops = {
 };
 #endif
-static int irq_spurious_read(char *page, char **start, off_t off,
+static int irq_spurious_proc_show(struct seq_file *m, void *v)
-                                  int count, int *eof, void *data)
 {
-        struct irq_desc *desc = irq_to_desc((long) data);
+        struct irq_desc *desc = irq_to_desc((long) m->private);
-        return sprintf(page, "count %u\n"
-                             "unhandled %u\n"
+        seq_printf(m, "count %u\n" "unhandled %u\n" "last_unhandled %u ms\n",
-                             "last_unhandled %u ms\n",
+                   desc->irq_count, desc->irqs_unhandled,
-                        desc->irq_count,
+                   jiffies_to_msecs(desc->last_unhandled));
-                        desc->irqs_unhandled,
+        return 0;
-                        jiffies_to_msecs(desc->last_unhandled));
+}
+static int irq_spurious_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, irq_spurious_proc_show, NULL);
 }
+static const struct file_operations irq_spurious_proc_fops = {
+        .open           = irq_spurious_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
 #define MAX_NAMELEN 128
 static int name_unique(unsigned int irq, struct irqaction *new_action)
@@ -204,7 +214,6 @@ void register_handler_proc(unsigned int irq, struct irqaction *action)
 void register_irq_proc(unsigned int irq, struct irq_desc *desc)
 {
        char name [MAX_NAMELEN];
-        struct proc_dir_entry *entry;
        if (!root_irq_dir || (desc->chip == &no_irq_chip) || desc->dir)
                return;
@@ -214,6 +223,8 @@ void register_irq_proc(unsigned int irq, struct irq_desc *desc)
        /* create /proc/irq/1234 */
        desc->dir = proc_mkdir(name, root_irq_dir);
+        if (!desc->dir)
+                return;
 #ifdef CONFIG_SMP
        /* create /proc/irq/<irq>/smp_affinity */
@@ -221,11 +232,8 @@ void register_irq_proc(unsigned int irq, struct irq_desc *desc)
                         &irq_affinity_proc_fops, (void *)(long)irq);
 #endif
-        entry = create_proc_entry("spurious", 0444, desc->dir);
+        proc_create_data("spurious", 0444, desc->dir,
-        if (entry) {
+                         &irq_spurious_proc_fops, (void *)(long)irq);
-                entry->data = (void *)(long)irq;
-                entry->read_proc = irq_spurious_read;
-        }
 }
 #undef MAX_NAMELEN
diff --git a/kernel/irq/resend.c b/kernel/irq/resend.c
index 89c7117acf2b..090c3763f3a2 100644
--- a/kernel/irq/resend.c
+++ b/kernel/irq/resend.c
@@ -70,8 +70,7 @@ void check_irq_resend(struct irq_desc *desc, unsigned int irq)
        if ((status & (IRQ_LEVEL | IRQ_PENDING | IRQ_REPLAY)) == IRQ_PENDING) {
                desc->status = (status & ~IRQ_PENDING) | IRQ_REPLAY;
-                if (!desc->chip || !desc->chip->retrigger ||
+                if (!desc->chip->retrigger || !desc->chip->retrigger(irq)) {
-                                        !desc->chip->retrigger(irq)) {
 #ifdef CONFIG_HARDIRQS_SW_RESEND
                        /* Set it pending and activate the softirq: */
                        set_bit(irq, irqs_resend);
diff --git a/kernel/irq/spurious.c b/kernel/irq/spurious.c
index 4d568294de3e..22b0a6eedf24 100644
--- a/kernel/irq/spurious.c
+++ b/kernel/irq/spurious.c
@@ -104,7 +104,7 @@ static int misrouted_irq(int irq)
        return ok;
 }
-static void poll_all_shared_irqs(void)
+static void poll_spurious_irqs(unsigned long dummy)
 {
        struct irq_desc *desc;
        int i;
@@ -121,25 +121,15 @@ static void poll_all_shared_irqs(void)
                if (!(status & IRQ_SPURIOUS_DISABLED))
                        continue;
+                local_irq_disable();
                try_one_irq(i, desc);
+                local_irq_enable();
        }
-}
-static void poll_spurious_irqs(unsigned long dummy)
-{
-        poll_all_shared_irqs();
        mod_timer(&poll_spurious_irq_timer,
                  jiffies + POLL_SPURIOUS_IRQ_INTERVAL);
 }
-#ifdef CONFIG_DEBUG_SHIRQ
-void debug_poll_all_shared_irqs(void)
-{
-        poll_all_shared_irqs();
-}
-#endif
 /*
 * If 99,900 of the previous 100,000 interrupts have not been handled
 * then assume that the IRQ is stuck in some manner. Drop a diagnostic
@@ -297,7 +287,6 @@ static int __init irqfixup_setup(char *str)
 __setup("irqfixup", irqfixup_setup);
 module_param(irqfixup, int, 0644);
-MODULE_PARM_DESC("irqfixup", "0: No fixup, 1: irqfixup mode, 2: irqpoll mode");
 static int __init irqpoll_setup(char *str)
 {