7 files changed, 168 insertions, 37 deletions

diff --git a/kernel/irq/chip.c b/kernel/irq/chip.c
index dc04c166c54d..6397df2d6945 100644
--- a/kernel/irq/chip.c
+++ b/kernel/irq/chip.c
@@ -281,6 +281,19 @@ void unmask_irq(struct irq_desc *desc)
         }
 }
 
+void unmask_threaded_irq(struct irq_desc *desc)
+{
+        struct irq_chip *chip = desc->irq_data.chip;
+
+        if (chip->flags & IRQCHIP_EOI_THREADED)
+                chip->irq_eoi(&desc->irq_data);
+
+        if (chip->irq_unmask) {
+                chip->irq_unmask(&desc->irq_data);
+                irq_state_clr_masked(desc);
+        }
+}
+
 /*
  *      handle_nested_irq - Handle a nested irq from a irq thread
  *      @irq:   the interrupt number
@@ -435,6 +448,27 @@ static inline void preflow_handler(struct irq_desc *desc)
 static inline void preflow_handler(struct irq_desc *desc) { }
 #endif
 
+static void cond_unmask_eoi_irq(struct irq_desc *desc, struct irq_chip *chip)
+{
+        if (!(desc->istate & IRQS_ONESHOT)) {
+                chip->irq_eoi(&desc->irq_data);
+                return;
+        }
+        /*
+         * We need to unmask in the following cases:
+         * - Oneshot irq which did not wake the thread (caused by a
+         *   spurious interrupt or a primary handler handling it
+         *   completely).
+         */
+        if (!irqd_irq_disabled(&desc->irq_data) &&
+            irqd_irq_masked(&desc->irq_data) && !desc->threads_oneshot) {
+                chip->irq_eoi(&desc->irq_data);
+                unmask_irq(desc);
+        } else if (!(chip->flags & IRQCHIP_EOI_THREADED)) {
+                chip->irq_eoi(&desc->irq_data);
+        }
+}
+
 /**
  *      handle_fasteoi_irq - irq handler for transparent controllers
  *      @irq:   the interrupt number
@@ -448,6 +482,8 @@ static inline void preflow_handler(struct irq_desc *desc) { }
 void
 handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)
 {
+        struct irq_chip *chip = desc->irq_data.chip;
+
         raw_spin_lock(&desc->lock);
 
         if (unlikely(irqd_irq_inprogress(&desc->irq_data)))
@@ -473,18 +509,14 @@ handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc)
         preflow_handler(desc);
         handle_irq_event(desc);
 
-        if (desc->istate & IRQS_ONESHOT)
-                cond_unmask_irq(desc);
+        cond_unmask_eoi_irq(desc, chip);
 
-out_eoi:
-        desc->irq_data.chip->irq_eoi(&desc->irq_data);
-out_unlock:
         raw_spin_unlock(&desc->lock);
         return;
 out:
-        if (!(desc->irq_data.chip->flags & IRQCHIP_EOI_IF_HANDLED))
-                goto out_eoi;
-        goto out_unlock;
+        if (!(chip->flags & IRQCHIP_EOI_IF_HANDLED))
+                chip->irq_eoi(&desc->irq_data);
+        raw_spin_unlock(&desc->lock);
 }
 
 /**
diff --git a/kernel/irq/handle.c b/kernel/irq/handle.c
index 131ca176b497..635480270858 100644
--- a/kernel/irq/handle.c
+++ b/kernel/irq/handle.c
@@ -41,6 +41,7 @@ irqreturn_t no_action(int cpl, void *dev_id)
 {
         return IRQ_NONE;
 }
+EXPORT_SYMBOL_GPL(no_action);
 
 static void warn_no_thread(unsigned int irq, struct irqaction *action)
 {
@@ -51,7 +52,7 @@ static void warn_no_thread(unsigned int irq, struct irqaction *action)
                "but no thread function available.", irq, action->name);
 }
 
-static void irq_wake_thread(struct irq_desc *desc, struct irqaction *action)
+void __irq_wake_thread(struct irq_desc *desc, struct irqaction *action)
 {
         /*
          * In case the thread crashed and was killed we just pretend that
@@ -157,7 +158,7 @@ handle_irq_event_percpu(struct irq_desc *desc, struct irqaction *action)
                                 break;
                         }
 
-                        irq_wake_thread(desc, action);
+                        __irq_wake_thread(desc, action);
 
                         /* Fall through to add to randomness */
                 case IRQ_HANDLED:
diff --git a/kernel/irq/internals.h b/kernel/irq/internals.h
index 001fa5bab490..ddf1ffeb79f1 100644
--- a/kernel/irq/internals.h
+++ b/kernel/irq/internals.h
@@ -6,6 +6,7 @@
  * of this file for your non core code.
  */
 #include <linux/irqdesc.h>
+#include <linux/kernel_stat.h>
 
 #ifdef CONFIG_SPARSE_IRQ
 # define IRQ_BITMAP_BITS        (NR_IRQS + 8196)
@@ -73,6 +74,7 @@ extern void irq_percpu_enable(struct irq_desc *desc, unsigned int cpu);
 extern void irq_percpu_disable(struct irq_desc *desc, unsigned int cpu);
 extern void mask_irq(struct irq_desc *desc);
 extern void unmask_irq(struct irq_desc *desc);
+extern void unmask_threaded_irq(struct irq_desc *desc);
 
 extern void init_kstat_irqs(struct irq_desc *desc, int node, int nr);
 
@@ -82,6 +84,7 @@ irqreturn_t handle_irq_event(struct irq_desc *desc);
 /* Resending of interrupts :*/
 void check_irq_resend(struct irq_desc *desc, unsigned int irq);
 bool irq_wait_for_poll(struct irq_desc *desc);
+void __irq_wake_thread(struct irq_desc *desc, struct irqaction *action);
 
 #ifdef CONFIG_PROC_FS
 extern void register_irq_proc(unsigned int irq, struct irq_desc *desc);
@@ -179,3 +182,9 @@ static inline bool irqd_has_set(struct irq_data *d, unsigned int mask)
 {
         return d->state_use_accessors & mask;
 }
+
+static inline void kstat_incr_irqs_this_cpu(unsigned int irq, struct irq_desc *desc)
+{
+        __this_cpu_inc(*desc->kstat_irqs);
+        __this_cpu_inc(kstat.irqs_sum);
+}
diff --git a/kernel/irq/irqdesc.c b/kernel/irq/irqdesc.c
index 8ab8e9390297..a7174617616b 100644
--- a/kernel/irq/irqdesc.c
+++ b/kernel/irq/irqdesc.c
@@ -489,6 +489,11 @@ void dynamic_irq_cleanup(unsigned int irq)
         raw_spin_unlock_irqrestore(&desc->lock, flags);
 }
 
+void kstat_incr_irq_this_cpu(unsigned int irq)
+{
+        kstat_incr_irqs_this_cpu(irq, irq_to_desc(irq));
+}
+
 unsigned int kstat_irqs_cpu(unsigned int irq, int cpu)
 {
         struct irq_desc *desc = irq_to_desc(irq);
diff --git a/kernel/irq/manage.c b/kernel/irq/manage.c
index d3bf660cb57f..2486a4c1a710 100644
--- a/kernel/irq/manage.c
+++ b/kernel/irq/manage.c
@@ -32,24 +32,10 @@ static int __init setup_forced_irqthreads(char *arg)
 early_param("threadirqs", setup_forced_irqthreads);
 #endif
 
-/**
- *      synchronize_irq - wait for pending IRQ handlers (on other CPUs)
- *      @irq: interrupt number to wait for
- *
- *      This function waits for any pending IRQ handlers for this interrupt
- *      to complete before returning. If you use this function while
- *      holding a resource the IRQ handler may need you will deadlock.
- *
- *      This function may be called - with care - from IRQ context.
- */
-void synchronize_irq(unsigned int irq)
+static void __synchronize_hardirq(struct irq_desc *desc)
 {
-        struct irq_desc *desc = irq_to_desc(irq);
         bool inprogress;
 
-        if (!desc)
-                return;
-
         do {
                 unsigned long flags;
 
@@ -67,12 +53,56 @@ void synchronize_irq(unsigned int irq)
 
                 /* Oops, that failed? */
         } while (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));
+/**
+ *      synchronize_hardirq - wait for pending hard IRQ handlers (on other CPUs)
+ *      @irq: interrupt number to wait for
+ *
+ *      This function waits for any pending hard IRQ handlers for this
+ *      interrupt to complete before returning. If you use this
+ *      function while holding a resource the IRQ handler may need you
+ *      will deadlock. It does not take associated threaded handlers
+ *      into account.
+ *
+ *      Do not use this for shutdown scenarios where you must be sure
+ *      that all parts (hardirq and threaded handler) have completed.
+ *
+ *      This function may be called - with care - from IRQ context.
+ */
+void synchronize_hardirq(unsigned int irq)
+{
+        struct irq_desc *desc = irq_to_desc(irq);
+
+        if (desc)
+                __synchronize_hardirq(desc);
+}
+EXPORT_SYMBOL(synchronize_hardirq);
+
+/**
+ *      synchronize_irq - wait for pending IRQ handlers (on other CPUs)
+ *      @irq: interrupt number to wait for
+ *
+ *      This function waits for any pending IRQ handlers for this interrupt
+ *      to complete before returning. If you use this function while
+ *      holding a resource the IRQ handler may need you will deadlock.
+ *
+ *      This function may be called - with care - from IRQ context.
+ */
+void synchronize_irq(unsigned int irq)
+{
+        struct irq_desc *desc = irq_to_desc(irq);
+
+        if (desc) {
+                __synchronize_hardirq(desc);
+                /*
+                 * 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);
 
@@ -718,7 +748,7 @@ again:
 
         if (!desc->threads_oneshot && !irqd_irq_disabled(&desc->irq_data) &&
             irqd_irq_masked(&desc->irq_data))
-                unmask_irq(desc);
+                unmask_threaded_irq(desc);
 
 out_unlock:
         raw_spin_unlock_irq(&desc->lock);
@@ -727,7 +757,7 @@ out_unlock:
 
 #ifdef CONFIG_SMP
 /*
- * Check whether we need to chasnge the affinity of the interrupt thread.
+ * 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)
@@ -880,6 +910,33 @@ static int irq_thread(void *data)
         return 0;
 }
 
+/**
+ *      irq_wake_thread - wake the irq thread for the action identified by dev_id
+ *      @irq:           Interrupt line
+ *      @dev_id:        Device identity for which the thread should be woken
+ *
+ */
+void irq_wake_thread(unsigned int irq, void *dev_id)
+{
+        struct irq_desc *desc = irq_to_desc(irq);
+        struct irqaction *action;
+        unsigned long flags;
+
+        if (!desc || WARN_ON(irq_settings_is_per_cpu_devid(desc)))
+                return;
+
+        raw_spin_lock_irqsave(&desc->lock, flags);
+        for (action = desc->action; action; action = action->next) {
+                if (action->dev_id == dev_id) {
+                        if (action->thread)
+                                __irq_wake_thread(desc, action);
+                        break;
+                }
+        }
+        raw_spin_unlock_irqrestore(&desc->lock, flags);
+}
+EXPORT_SYMBOL_GPL(irq_wake_thread);
+
 static void irq_setup_forced_threading(struct irqaction *new)
 {
         if (!force_irqthreads)
@@ -896,6 +953,23 @@ static void irq_setup_forced_threading(struct irqaction *new)
         }
 }
 
+static int irq_request_resources(struct irq_desc *desc)
+{
+        struct irq_data *d = &desc->irq_data;
+        struct irq_chip *c = d->chip;
+
+        return c->irq_request_resources ? c->irq_request_resources(d) : 0;
+}
+
+static void irq_release_resources(struct irq_desc *desc)
+{
+        struct irq_data *d = &desc->irq_data;
+        struct irq_chip *c = d->chip;
+
+        if (c->irq_release_resources)
+                c->irq_release_resources(d);
+}
+
 /*
  * Internal function to register an irqaction - typically used to
  * allocate special interrupts that are part of the architecture.
@@ -1091,6 +1165,13 @@ __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
         }
 
         if (!shared) {
+                ret = irq_request_resources(desc);
+                if (ret) {
+                        pr_err("Failed to request resources for %s (irq %d) on irqchip %s\n",
+                               new->name, irq, desc->irq_data.chip->name);
+                        goto out_mask;
+                }
+
                 init_waitqueue_head(&desc->wait_for_threads);
 
                 /* Setup the type (level, edge polarity) if configured: */
@@ -1261,8 +1342,10 @@ static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
         *action_ptr = action->next;
 
         /* If this was the last handler, shut down the IRQ line: */
-        if (!desc->action)
+        if (!desc->action) {
                 irq_shutdown(desc);
+                irq_release_resources(desc);
+        }
 
 #ifdef CONFIG_SMP
         /* make sure affinity_hint is cleaned up */
diff --git a/kernel/irq/proc.c b/kernel/irq/proc.c
index 36f6ee181b0c..ac1ba2f11032 100644
--- a/kernel/irq/proc.c
+++ b/kernel/irq/proc.c
@@ -324,15 +324,15 @@ void register_irq_proc(unsigned int irq, struct irq_desc *desc)
 
 #ifdef CONFIG_SMP
         /* create /proc/irq/<irq>/smp_affinity */
-        proc_create_data("smp_affinity", 0600, desc->dir,
+        proc_create_data("smp_affinity", 0644, desc->dir,
                          &irq_affinity_proc_fops, (void *)(long)irq);
 
         /* create /proc/irq/<irq>/affinity_hint */
-        proc_create_data("affinity_hint", 0400, desc->dir,
+        proc_create_data("affinity_hint", 0444, desc->dir,
                          &irq_affinity_hint_proc_fops, (void *)(long)irq);
 
         /* create /proc/irq/<irq>/smp_affinity_list */
-        proc_create_data("smp_affinity_list", 0600, desc->dir,
+        proc_create_data("smp_affinity_list", 0644, desc->dir,
                          &irq_affinity_list_proc_fops, (void *)(long)irq);
 
         proc_create_data("node", 0444, desc->dir,
@@ -372,7 +372,7 @@ void unregister_handler_proc(unsigned int irq, struct irqaction *action)
 static void register_default_affinity_proc(void)
 {
 #ifdef CONFIG_SMP
-        proc_create("irq/default_smp_affinity", 0600, NULL,
+        proc_create("irq/default_smp_affinity", 0644, NULL,
                     &default_affinity_proc_fops);
 #endif
 }
diff --git a/kernel/softirq.c b/kernel/softirq.c
index 490fcbb1dc5b..b50990a5bea0 100644
--- a/kernel/softirq.c
+++ b/kernel/softirq.c
@@ -25,6 +25,7 @@
 #include <linux/smp.h>
 #include <linux/smpboot.h>
 #include <linux/tick.h>
+#include <linux/irq.h>
 
 #define CREATE_TRACE_POINTS
 #include <trace/events/irq.h>