21 files changed, 344 insertions, 159 deletions

diff --git a/drivers/hv/vmbus_drv.c b/drivers/hv/vmbus_drv.c
index 077bb1bdac34..3f0a95290e14 100644
--- a/drivers/hv/vmbus_drv.c
+++ b/drivers/hv/vmbus_drv.c
@@ -25,7 +25,6 @@
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/device.h>
-#include <linux/irq.h>
 #include <linux/interrupt.h>
 #include <linux/sysctl.h>
 #include <linux/slab.h>
@@ -558,9 +557,6 @@ static struct bus_type  hv_bus = {
         .dev_groups =           vmbus_groups,
 };
 
-static const char *driver_name = "hyperv";
-
-
 struct onmessage_work_context {
         struct work_struct work;
         struct hv_message msg;
@@ -619,7 +615,7 @@ static void vmbus_on_msg_dpc(unsigned long data)
         }
 }
 
-static irqreturn_t vmbus_isr(int irq, void *dev_id)
+static void vmbus_isr(void)
 {
         int cpu = smp_processor_id();
         void *page_addr;
@@ -629,7 +625,7 @@ static irqreturn_t vmbus_isr(int irq, void *dev_id)
 
         page_addr = hv_context.synic_event_page[cpu];
         if (page_addr == NULL)
-                return IRQ_NONE;
+                return;
 
         event = (union hv_synic_event_flags *)page_addr +
                                          VMBUS_MESSAGE_SINT;
@@ -665,28 +661,8 @@ static irqreturn_t vmbus_isr(int irq, void *dev_id)
         msg = (struct hv_message *)page_addr + VMBUS_MESSAGE_SINT;
 
         /* Check if there are actual msgs to be processed */
-        if (msg->header.message_type != HVMSG_NONE) {
-                handled = true;
+        if (msg->header.message_type != HVMSG_NONE)
                 tasklet_schedule(&msg_dpc);
-        }
-
-        if (handled)
-                return IRQ_HANDLED;
-        else
-                return IRQ_NONE;
-}
-
-/*
- * vmbus interrupt flow handler:
- * vmbus interrupts can concurrently occur on multiple CPUs and
- * can be handled concurrently.
- */
-
-static void vmbus_flow_handler(unsigned int irq, struct irq_desc *desc)
-{
-        kstat_incr_irqs_this_cpu(irq, desc);
-
-        desc->action->handler(irq, desc->action->dev_id);
 }
 
 /*
@@ -715,25 +691,7 @@ static int vmbus_bus_init(int irq)
         if (ret)
                 goto err_cleanup;
 
-        ret = request_irq(irq, vmbus_isr, 0, driver_name, hv_acpi_dev);
-
-        if (ret != 0) {
-                pr_err("Unable to request IRQ %d\n",
-                           irq);
-                goto err_unregister;
-        }
-
-        /*
-         * Vmbus interrupts can be handled concurrently on
-         * different CPUs. Establish an appropriate interrupt flow
-         * handler that can support this model.
-         */
-        irq_set_handler(irq, vmbus_flow_handler);
-
-        /*
-         * Register our interrupt handler.
-         */
-        hv_register_vmbus_handler(irq, vmbus_isr);
+        hv_setup_vmbus_irq(vmbus_isr);
 
         ret = hv_synic_alloc();
         if (ret)
@@ -753,9 +711,8 @@ static int vmbus_bus_init(int irq)
 
 err_alloc:
         hv_synic_free();
-        free_irq(irq, hv_acpi_dev);
+        hv_remove_vmbus_irq();
 
-err_unregister:
         bus_unregister(&hv_bus);
 
 err_cleanup:
@@ -947,7 +904,6 @@ static int __init hv_acpi_init(void)
         /*
          * Get irq resources first.
          */
-
         ret = acpi_bus_register_driver(&vmbus_acpi_driver);
 
         if (ret)
@@ -978,8 +934,7 @@ cleanup:
 
 static void __exit vmbus_exit(void)
 {
-
-        free_irq(irq, hv_acpi_dev);
+        hv_remove_vmbus_irq();
         vmbus_free_channels();
         bus_unregister(&hv_bus);
         hv_cleanup();
diff --git a/drivers/irqchip/Makefile b/drivers/irqchip/Makefile
index 5194afb39e78..1c0c151d108c 100644
--- a/drivers/irqchip/Makefile
+++ b/drivers/irqchip/Makefile
@@ -12,6 +12,7 @@ obj-$(CONFIG_METAG_PERFCOUNTER_IRQS)	+= irq-metag.o
 obj-$(CONFIG_ARCH_MOXART)               += irq-moxart.o
 obj-$(CONFIG_ORION_IRQCHIP)             += irq-orion.o
 obj-$(CONFIG_ARCH_SUNXI)                += irq-sun4i.o
+obj-$(CONFIG_ARCH_SUNXI)                += irq-sunxi-nmi.o
 obj-$(CONFIG_ARCH_SPEAR3XX)             += spear-shirq.o
 obj-$(CONFIG_ARM_GIC)                   += irq-gic.o
 obj-$(CONFIG_ARM_NVIC)                  += irq-nvic.o
diff --git a/drivers/irqchip/irq-armada-370-xp.c b/drivers/irqchip/irq-armada-370-xp.c
index 540956465ed2..41be897df8d5 100644
--- a/drivers/irqchip/irq-armada-370-xp.c
+++ b/drivers/irqchip/irq-armada-370-xp.c
@@ -18,6 +18,7 @@
 #include <linux/init.h>
 #include <linux/irq.h>
 #include <linux/interrupt.h>
+#include <linux/irqchip/chained_irq.h>
 #include <linux/io.h>
 #include <linux/of_address.h>
 #include <linux/of_irq.h>
@@ -42,6 +43,7 @@
 #define ARMADA_370_XP_INT_SOURCE_CTL(irq)       (0x100 + irq*4)
 
 #define ARMADA_370_XP_CPU_INTACK_OFFS           (0x44)
+#define ARMADA_375_PPI_CAUSE                    (0x10)
 
 #define ARMADA_370_XP_SW_TRIG_INT_OFFS           (0x4)
 #define ARMADA_370_XP_IN_DRBEL_MSK_OFFS          (0xc)
@@ -352,7 +354,63 @@ static struct irq_domain_ops armada_370_xp_mpic_irq_ops = {
         .xlate = irq_domain_xlate_onecell,
 };
 
-static asmlinkage void __exception_irq_entry
+#ifdef CONFIG_PCI_MSI
+static void armada_370_xp_handle_msi_irq(struct pt_regs *regs, bool is_chained)
+{
+        u32 msimask, msinr;
+
+        msimask = readl_relaxed(per_cpu_int_base +
+                                ARMADA_370_XP_IN_DRBEL_CAUSE_OFFS)
+                & PCI_MSI_DOORBELL_MASK;
+
+        writel(~msimask, per_cpu_int_base +
+               ARMADA_370_XP_IN_DRBEL_CAUSE_OFFS);
+
+        for (msinr = PCI_MSI_DOORBELL_START;
+             msinr < PCI_MSI_DOORBELL_END; msinr++) {
+                int irq;
+
+                if (!(msimask & BIT(msinr)))
+                        continue;
+
+                irq = irq_find_mapping(armada_370_xp_msi_domain,
+                                       msinr - 16);
+
+                if (is_chained)
+                        generic_handle_irq(irq);
+                else
+                        handle_IRQ(irq, regs);
+        }
+}
+#else
+static void armada_370_xp_handle_msi_irq(struct pt_regs *r, bool b) {}
+#endif
+
+static void armada_370_xp_mpic_handle_cascade_irq(unsigned int irq,
+                                                  struct irq_desc *desc)
+{
+        struct irq_chip *chip = irq_get_chip(irq);
+        unsigned long irqmap, irqn;
+        unsigned int cascade_irq;
+
+        chained_irq_enter(chip, desc);
+
+        irqmap = readl_relaxed(per_cpu_int_base + ARMADA_375_PPI_CAUSE);
+
+        if (irqmap & BIT(0)) {
+                armada_370_xp_handle_msi_irq(NULL, true);
+                irqmap &= ~BIT(0);
+        }
+
+        for_each_set_bit(irqn, &irqmap, BITS_PER_LONG) {
+                cascade_irq = irq_find_mapping(armada_370_xp_mpic_domain, irqn);
+                generic_handle_irq(cascade_irq);
+        }
+
+        chained_irq_exit(chip, desc);
+}
+
+static void __exception_irq_entry
 armada_370_xp_handle_irq(struct pt_regs *regs)
 {
         u32 irqstat, irqnr;
@@ -372,31 +430,9 @@ armada_370_xp_handle_irq(struct pt_regs *regs)
                         continue;
                 }
 
-#ifdef CONFIG_PCI_MSI
                 /* MSI handling */
-                if (irqnr == 1) {
-                        u32 msimask, msinr;
-
-                        msimask = readl_relaxed(per_cpu_int_base +
-                                                ARMADA_370_XP_IN_DRBEL_CAUSE_OFFS)
-                                & PCI_MSI_DOORBELL_MASK;
-
-                        writel(~msimask, per_cpu_int_base +
-                               ARMADA_370_XP_IN_DRBEL_CAUSE_OFFS);
-
-                        for (msinr = PCI_MSI_DOORBELL_START;
-                             msinr < PCI_MSI_DOORBELL_END; msinr++) {
-                                int irq;
-
-                                if (!(msimask & BIT(msinr)))
-                                        continue;
-
-                                irq = irq_find_mapping(armada_370_xp_msi_domain,
-                                                       msinr - 16);
-                                handle_IRQ(irq, regs);
-                        }
-                }
-#endif
+                if (irqnr == 1)
+                        armada_370_xp_handle_msi_irq(regs, false);
 
 #ifdef CONFIG_SMP
                 /* IPI Handling */
@@ -427,6 +463,7 @@ static int __init armada_370_xp_mpic_of_init(struct device_node *node,
                                              struct device_node *parent)
 {
         struct resource main_int_res, per_cpu_int_res;
+        int parent_irq;
         u32 control;
 
         BUG_ON(of_address_to_resource(node, 0, &main_int_res));
@@ -455,8 +492,6 @@ static int __init armada_370_xp_mpic_of_init(struct device_node *node,
 
         BUG_ON(!armada_370_xp_mpic_domain);
 
-        irq_set_default_host(armada_370_xp_mpic_domain);
-
 #ifdef CONFIG_SMP
         armada_xp_mpic_smp_cpu_init();
 
@@ -472,7 +507,14 @@ static int __init armada_370_xp_mpic_of_init(struct device_node *node,
 
         armada_370_xp_msi_init(node, main_int_res.start);
 
-        set_handle_irq(armada_370_xp_handle_irq);
+        parent_irq = irq_of_parse_and_map(node, 0);
+        if (parent_irq <= 0) {
+                irq_set_default_host(armada_370_xp_mpic_domain);
+                set_handle_irq(armada_370_xp_handle_irq);
+        } else {
+                irq_set_chained_handler(parent_irq,
+                                        armada_370_xp_mpic_handle_cascade_irq);
+        }
 
         return 0;
 }
diff --git a/drivers/irqchip/irq-bcm2835.c b/drivers/irqchip/irq-bcm2835.c
index 1693b8e7f26a..5916d6cdafa1 100644
--- a/drivers/irqchip/irq-bcm2835.c
+++ b/drivers/irqchip/irq-bcm2835.c
@@ -95,7 +95,7 @@ struct armctrl_ic {
 };
 
 static struct armctrl_ic intc __read_mostly;
-static asmlinkage void __exception_irq_entry bcm2835_handle_irq(
+static void __exception_irq_entry bcm2835_handle_irq(
         struct pt_regs *regs);
 
 static void armctrl_mask_irq(struct irq_data *d)
@@ -196,7 +196,7 @@ static void armctrl_handle_shortcut(int bank, struct pt_regs *regs,
         handle_IRQ(irq_linear_revmap(intc.domain, irq), regs);
 }
 
-static asmlinkage void __exception_irq_entry bcm2835_handle_irq(
+static void __exception_irq_entry bcm2835_handle_irq(
         struct pt_regs *regs)
 {
         u32 stat, irq;
diff --git a/drivers/irqchip/irq-gic.c b/drivers/irqchip/irq-gic.c
index 341c6016812d..531769b2433a 100644
--- a/drivers/irqchip/irq-gic.c
+++ b/drivers/irqchip/irq-gic.c
@@ -50,7 +50,7 @@
 
 union gic_base {
         void __iomem *common_base;
-        void __percpu __iomem **percpu_base;
+        void __percpu * __iomem *percpu_base;
 };
 
 struct gic_chip_data {
@@ -279,7 +279,7 @@ static int gic_set_wake(struct irq_data *d, unsigned int on)
 #define gic_set_wake    NULL
 #endif
 
-static asmlinkage void __exception_irq_entry gic_handle_irq(struct pt_regs *regs)
+static void __exception_irq_entry gic_handle_irq(struct pt_regs *regs)
 {
         u32 irqstat, irqnr;
         struct gic_chip_data *gic = &gic_data[0];
@@ -648,7 +648,7 @@ static void __init gic_pm_init(struct gic_chip_data *gic)
 #endif
 
 #ifdef CONFIG_SMP
-void gic_raise_softirq(const struct cpumask *mask, unsigned int irq)
+static void gic_raise_softirq(const struct cpumask *mask, unsigned int irq)
 {
         int cpu;
         unsigned long flags, map = 0;
@@ -869,7 +869,7 @@ static struct notifier_block gic_cpu_notifier = {
 };
 #endif
 
-const struct irq_domain_ops gic_irq_domain_ops = {
+static const struct irq_domain_ops gic_irq_domain_ops = {
         .map = gic_irq_domain_map,
         .xlate = gic_irq_domain_xlate,
 };
@@ -974,7 +974,8 @@ void __init gic_init_bases(unsigned int gic_nr, int irq_start,
 #ifdef CONFIG_OF
 static int gic_cnt __initdata;
 
-int __init gic_of_init(struct device_node *node, struct device_node *parent)
+static int __init
+gic_of_init(struct device_node *node, struct device_node *parent)
 {
         void __iomem *cpu_base;
         void __iomem *dist_base;
diff --git a/drivers/irqchip/irq-mmp.c b/drivers/irqchip/irq-mmp.c
index 2cb7cd0bc2f5..3c8827fe83f3 100644
--- a/drivers/irqchip/irq-mmp.c
+++ b/drivers/irqchip/irq-mmp.c
@@ -194,8 +194,7 @@ static struct mmp_intc_conf mmp2_conf = {
         .conf_mask      = 0x7f,
 };
 
-static asmlinkage void __exception_irq_entry
-mmp_handle_irq(struct pt_regs *regs)
+static void __exception_irq_entry mmp_handle_irq(struct pt_regs *regs)
 {
         int irq, hwirq;
 
@@ -207,8 +206,7 @@ mmp_handle_irq(struct pt_regs *regs)
         handle_IRQ(irq, regs);
 }
 
-static asmlinkage void __exception_irq_entry
-mmp2_handle_irq(struct pt_regs *regs)
+static void __exception_irq_entry mmp2_handle_irq(struct pt_regs *regs)
 {
         int irq, hwirq;
 
diff --git a/drivers/irqchip/irq-moxart.c b/drivers/irqchip/irq-moxart.c
index 5552fc2bf28a..00b3cc908f76 100644
--- a/drivers/irqchip/irq-moxart.c
+++ b/drivers/irqchip/irq-moxart.c
@@ -44,7 +44,7 @@ struct moxart_irq_data {
 
 static struct moxart_irq_data intc;
 
-static asmlinkage void __exception_irq_entry handle_irq(struct pt_regs *regs)
+static void __exception_irq_entry handle_irq(struct pt_regs *regs)
 {
         u32 irqstat;
         int hwirq;
diff --git a/drivers/irqchip/irq-orion.c b/drivers/irqchip/irq-orion.c
index 8e41be62812e..e25f246cd2fb 100644
--- a/drivers/irqchip/irq-orion.c
+++ b/drivers/irqchip/irq-orion.c
@@ -30,7 +30,7 @@
 
 static struct irq_domain *orion_irq_domain;
 
-static asmlinkage void
+static void
 __exception_irq_entry orion_handle_irq(struct pt_regs *regs)
 {
         struct irq_domain_chip_generic *dgc = orion_irq_domain->gc;
diff --git a/drivers/irqchip/irq-sirfsoc.c b/drivers/irqchip/irq-sirfsoc.c
index 3a070c587ed9..581eefe331ae 100644
--- a/drivers/irqchip/irq-sirfsoc.c
+++ b/drivers/irqchip/irq-sirfsoc.c
@@ -47,7 +47,7 @@ sirfsoc_alloc_gc(void __iomem *base, unsigned int irq_start, unsigned int num)
         ct->regs.mask = SIRFSOC_INT_RISC_MASK0;
 }
 
-static asmlinkage void __exception_irq_entry sirfsoc_handle_irq(struct pt_regs *regs)
+static void __exception_irq_entry sirfsoc_handle_irq(struct pt_regs *regs)
 {
         void __iomem *base = sirfsoc_irqdomain->host_data;
         u32 irqstat, irqnr;
diff --git a/drivers/irqchip/irq-sun4i.c b/drivers/irqchip/irq-sun4i.c
index a5438d889245..6fcef4a95a18 100644
--- a/drivers/irqchip/irq-sun4i.c
+++ b/drivers/irqchip/irq-sun4i.c
@@ -36,18 +36,16 @@
 static void __iomem *sun4i_irq_base;
 static struct irq_domain *sun4i_irq_domain;
 
-static asmlinkage void __exception_irq_entry sun4i_handle_irq(struct pt_regs *regs);
+static void __exception_irq_entry sun4i_handle_irq(struct pt_regs *regs);
 
 static void sun4i_irq_ack(struct irq_data *irqd)
 {
         unsigned int irq = irqd_to_hwirq(irqd);
-        unsigned int irq_off = irq % 32;
-        int reg = irq / 32;
-        u32 val;
 
-        val = readl(sun4i_irq_base + SUN4I_IRQ_PENDING_REG(reg));
-        writel(val | (1 << irq_off),
-               sun4i_irq_base + SUN4I_IRQ_PENDING_REG(reg));
+        if (irq != 0)
+                return; /* Only IRQ 0 / the ENMI needs to be acked */
+
+        writel(BIT(0), sun4i_irq_base + SUN4I_IRQ_PENDING_REG(0));
 }
 
 static void sun4i_irq_mask(struct irq_data *irqd)
@@ -76,16 +74,16 @@ static void sun4i_irq_unmask(struct irq_data *irqd)
 
 static struct irq_chip sun4i_irq_chip = {
         .name           = "sun4i_irq",
-        .irq_ack        = sun4i_irq_ack,
+        .irq_eoi        = sun4i_irq_ack,
         .irq_mask       = sun4i_irq_mask,
         .irq_unmask     = sun4i_irq_unmask,
+        .flags          = IRQCHIP_EOI_THREADED | IRQCHIP_EOI_IF_HANDLED,
 };
 
 static int sun4i_irq_map(struct irq_domain *d, unsigned int virq,
                          irq_hw_number_t hw)
 {
-        irq_set_chip_and_handler(virq, &sun4i_irq_chip,
-                                 handle_level_irq);
+        irq_set_chip_and_handler(virq, &sun4i_irq_chip, handle_fasteoi_irq);
         set_irq_flags(virq, IRQF_VALID | IRQF_PROBE);
 
         return 0;
@@ -109,7 +107,7 @@ static int __init sun4i_of_init(struct device_node *node,
         writel(0, sun4i_irq_base + SUN4I_IRQ_ENABLE_REG(1));
         writel(0, sun4i_irq_base + SUN4I_IRQ_ENABLE_REG(2));
 
-        /* Mask all the interrupts */
+        /* Unmask all the interrupts, ENABLE_REG(x) is used for masking */
         writel(0, sun4i_irq_base + SUN4I_IRQ_MASK_REG(0));
         writel(0, sun4i_irq_base + SUN4I_IRQ_MASK_REG(1));
         writel(0, sun4i_irq_base + SUN4I_IRQ_MASK_REG(2));
@@ -134,16 +132,30 @@ static int __init sun4i_of_init(struct device_node *node,
 
         return 0;
 }
-IRQCHIP_DECLARE(allwinner_sun4i_ic, "allwinner,sun4i-ic", sun4i_of_init);
+IRQCHIP_DECLARE(allwinner_sun4i_ic, "allwinner,sun4i-a10-ic", sun4i_of_init);
 
-static asmlinkage void __exception_irq_entry sun4i_handle_irq(struct pt_regs *regs)
+static void __exception_irq_entry sun4i_handle_irq(struct pt_regs *regs)
 {
         u32 irq, hwirq;
 
+        /*
+         * hwirq == 0 can mean one of 3 things:
+         * 1) no more irqs pending
+         * 2) irq 0 pending
+         * 3) spurious irq
+         * So if we immediately get a reading of 0, check the irq-pending reg
+         * to differentiate between 2 and 3. We only do this once to avoid
+         * the extra check in the common case of 1 hapening after having
+         * read the vector-reg once.
+         */
         hwirq = readl(sun4i_irq_base + SUN4I_IRQ_VECTOR_REG) >> 2;
-        while (hwirq != 0) {
+        if (hwirq == 0 &&
+                  !(readl(sun4i_irq_base + SUN4I_IRQ_PENDING_REG(0)) & BIT(0)))
+                return;
+
+        do {
                 irq = irq_find_mapping(sun4i_irq_domain, hwirq);
                 handle_IRQ(irq, regs);
                 hwirq = readl(sun4i_irq_base + SUN4I_IRQ_VECTOR_REG) >> 2;
-        }
+        } while (hwirq != 0);
 }
diff --git a/drivers/irqchip/irq-sunxi-nmi.c b/drivers/irqchip/irq-sunxi-nmi.c
new file mode 100644
index 000000000000..12f547a44ae4
--- /dev/null
+++ b/drivers/irqchip/irq-sunxi-nmi.c
@@ -0,0 +1,208 @@
+/*
+ * Allwinner A20/A31 SoCs NMI IRQ chip driver.
+ *
+ * Carlo Caione <carlo.caione@gmail.com>
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2.  This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include <linux/bitops.h>
+#include <linux/device.h>
+#include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/irqdomain.h>
+#include <linux/of_irq.h>
+#include <linux/of_address.h>
+#include <linux/of_platform.h>
+#include <linux/irqchip/chained_irq.h>
+#include "irqchip.h"
+
+#define SUNXI_NMI_SRC_TYPE_MASK 0x00000003
+
+enum {
+        SUNXI_SRC_TYPE_LEVEL_LOW = 0,
+        SUNXI_SRC_TYPE_EDGE_FALLING,
+        SUNXI_SRC_TYPE_LEVEL_HIGH,
+        SUNXI_SRC_TYPE_EDGE_RISING,
+};
+
+struct sunxi_sc_nmi_reg_offs {
+        u32 ctrl;
+        u32 pend;
+        u32 enable;
+};
+
+static struct sunxi_sc_nmi_reg_offs sun7i_reg_offs = {
+        .ctrl   = 0x00,
+        .pend   = 0x04,
+        .enable = 0x08,
+};
+
+static struct sunxi_sc_nmi_reg_offs sun6i_reg_offs = {
+        .ctrl   = 0x00,
+        .pend   = 0x04,
+        .enable = 0x34,
+};
+
+static inline void sunxi_sc_nmi_write(struct irq_chip_generic *gc, u32 off,
+                                      u32 val)
+{
+        irq_reg_writel(val, gc->reg_base + off);
+}
+
+static inline u32 sunxi_sc_nmi_read(struct irq_chip_generic *gc, u32 off)
+{
+        return irq_reg_readl(gc->reg_base + off);
+}
+
+static void sunxi_sc_nmi_handle_irq(unsigned int irq, struct irq_desc *desc)
+{
+        struct irq_domain *domain = irq_desc_get_handler_data(desc);
+        struct irq_chip *chip = irq_get_chip(irq);
+        unsigned int virq = irq_find_mapping(domain, 0);
+
+        chained_irq_enter(chip, desc);
+        generic_handle_irq(virq);
+        chained_irq_exit(chip, desc);
+}
+
+static int sunxi_sc_nmi_set_type(struct irq_data *data, unsigned int flow_type)
+{
+        struct irq_chip_generic *gc = irq_data_get_irq_chip_data(data);
+        struct irq_chip_type *ct = gc->chip_types;
+        u32 src_type_reg;
+        u32 ctrl_off = ct->regs.type;
+        unsigned int src_type;
+        unsigned int i;
+
+        irq_gc_lock(gc);
+
+        switch (flow_type & IRQF_TRIGGER_MASK) {
+        case IRQ_TYPE_EDGE_FALLING:
+                src_type = SUNXI_SRC_TYPE_EDGE_FALLING;
+                break;
+        case IRQ_TYPE_EDGE_RISING:
+                src_type = SUNXI_SRC_TYPE_EDGE_RISING;
+                break;
+        case IRQ_TYPE_LEVEL_HIGH:
+                src_type = SUNXI_SRC_TYPE_LEVEL_HIGH;
+                break;
+        case IRQ_TYPE_NONE:
+        case IRQ_TYPE_LEVEL_LOW:
+                src_type = SUNXI_SRC_TYPE_LEVEL_LOW;
+                break;
+        default:
+                irq_gc_unlock(gc);
+                pr_err("%s: Cannot assign multiple trigger modes to IRQ %d.\n",
+                        __func__, data->irq);
+                return -EBADR;
+        }
+
+        irqd_set_trigger_type(data, flow_type);
+        irq_setup_alt_chip(data, flow_type);
+
+        for (i = 0; i <= gc->num_ct; i++, ct++)
+                if (ct->type & flow_type)
+                        ctrl_off = ct->regs.type;
+
+        src_type_reg = sunxi_sc_nmi_read(gc, ctrl_off);
+        src_type_reg &= ~SUNXI_NMI_SRC_TYPE_MASK;
+        src_type_reg |= src_type;
+        sunxi_sc_nmi_write(gc, ctrl_off, src_type_reg);
+
+        irq_gc_unlock(gc);
+
+        return IRQ_SET_MASK_OK;
+}
+
+static int __init sunxi_sc_nmi_irq_init(struct device_node *node,
+                                        struct sunxi_sc_nmi_reg_offs *reg_offs)
+{
+        struct irq_domain *domain;
+        struct irq_chip_generic *gc;
+        unsigned int irq;
+        unsigned int clr = IRQ_NOREQUEST | IRQ_NOPROBE | IRQ_NOAUTOEN;
+        int ret;
+
+
+        domain = irq_domain_add_linear(node, 1, &irq_generic_chip_ops, NULL);
+        if (!domain) {
+                pr_err("%s: Could not register interrupt domain.\n", node->name);
+                return -ENOMEM;
+        }
+
+        ret = irq_alloc_domain_generic_chips(domain, 1, 2, node->name,
+                                             handle_fasteoi_irq, clr, 0,
+                                             IRQ_GC_INIT_MASK_CACHE);
+        if (ret) {
+                 pr_err("%s: Could not allocate generic interrupt chip.\n",
+                         node->name);
+                 goto fail_irqd_remove;
+        }
+
+        irq = irq_of_parse_and_map(node, 0);
+        if (irq <= 0) {
+                pr_err("%s: unable to parse irq\n", node->name);
+                ret = -EINVAL;
+                goto fail_irqd_remove;
+        }
+
+        gc = irq_get_domain_generic_chip(domain, 0);
+        gc->reg_base = of_iomap(node, 0);
+        if (!gc->reg_base) {
+                pr_err("%s: unable to map resource\n", node->name);
+                ret = -ENOMEM;
+                goto fail_irqd_remove;
+        }
+
+        gc->chip_types[0].type                  = IRQ_TYPE_LEVEL_MASK;
+        gc->chip_types[0].chip.irq_mask         = irq_gc_mask_clr_bit;
+        gc->chip_types[0].chip.irq_unmask       = irq_gc_mask_set_bit;
+        gc->chip_types[0].chip.irq_eoi          = irq_gc_ack_set_bit;
+        gc->chip_types[0].chip.irq_set_type     = sunxi_sc_nmi_set_type;
+        gc->chip_types[0].chip.flags            = IRQCHIP_EOI_THREADED | IRQCHIP_EOI_IF_HANDLED;
+        gc->chip_types[0].regs.ack              = reg_offs->pend;
+        gc->chip_types[0].regs.mask             = reg_offs->enable;
+        gc->chip_types[0].regs.type             = reg_offs->ctrl;
+
+        gc->chip_types[1].type                  = IRQ_TYPE_EDGE_BOTH;
+        gc->chip_types[1].chip.name             = gc->chip_types[0].chip.name;
+        gc->chip_types[1].chip.irq_ack          = irq_gc_ack_set_bit;
+        gc->chip_types[1].chip.irq_mask         = irq_gc_mask_clr_bit;
+        gc->chip_types[1].chip.irq_unmask       = irq_gc_mask_set_bit;
+        gc->chip_types[1].chip.irq_set_type     = sunxi_sc_nmi_set_type;
+        gc->chip_types[1].regs.ack              = reg_offs->pend;
+        gc->chip_types[1].regs.mask             = reg_offs->enable;
+        gc->chip_types[1].regs.type             = reg_offs->ctrl;
+        gc->chip_types[1].handler               = handle_edge_irq;
+
+        sunxi_sc_nmi_write(gc, reg_offs->enable, 0);
+        sunxi_sc_nmi_write(gc, reg_offs->pend, 0x1);
+
+        irq_set_handler_data(irq, domain);
+        irq_set_chained_handler(irq, sunxi_sc_nmi_handle_irq);
+
+        return 0;
+
+fail_irqd_remove:
+        irq_domain_remove(domain);
+
+        return ret;
+}
+
+static int __init sun6i_sc_nmi_irq_init(struct device_node *node,
+                                        struct device_node *parent)
+{
+        return sunxi_sc_nmi_irq_init(node, &sun6i_reg_offs);
+}
+IRQCHIP_DECLARE(sun6i_sc_nmi, "allwinner,sun6i-a31-sc-nmi", sun6i_sc_nmi_irq_init);
+
+static int __init sun7i_sc_nmi_irq_init(struct device_node *node,
+                                        struct device_node *parent)
+{
+        return sunxi_sc_nmi_irq_init(node, &sun7i_reg_offs);
+}
+IRQCHIP_DECLARE(sun7i_sc_nmi, "allwinner,sun7i-a20-sc-nmi", sun7i_sc_nmi_irq_init);
diff --git a/drivers/irqchip/irq-vic.c b/drivers/irqchip/irq-vic.c
index 8e21ae0bab46..473f09a74d4d 100644
--- a/drivers/irqchip/irq-vic.c
+++ b/drivers/irqchip/irq-vic.c
@@ -228,7 +228,7 @@ static int handle_one_vic(struct vic_device *vic, struct pt_regs *regs)
  * Keep iterating over all registered VIC's until there are no pending
  * interrupts.
  */
-static asmlinkage void __exception_irq_entry vic_handle_irq(struct pt_regs *regs)
+static void __exception_irq_entry vic_handle_irq(struct pt_regs *regs)
 {
         int i, handled;
 
diff --git a/drivers/irqchip/irq-vt8500.c b/drivers/irqchip/irq-vt8500.c
index 1846e7d66681..eb6e91efdec8 100644
--- a/drivers/irqchip/irq-vt8500.c
+++ b/drivers/irqchip/irq-vt8500.c
@@ -178,8 +178,7 @@ static struct irq_domain_ops vt8500_irq_domain_ops = {
         .xlate = irq_domain_xlate_onecell,
 };
 
-static asmlinkage
-void __exception_irq_entry vt8500_handle_irq(struct pt_regs *regs)
+static void __exception_irq_entry vt8500_handle_irq(struct pt_regs *regs)
 {
         u32 stat, i;
         int irqnr, virq;
diff --git a/drivers/irqchip/irq-xtensa-mx.c b/drivers/irqchip/irq-xtensa-mx.c
index f693f1bc1348..e1c2f9632893 100644
--- a/drivers/irqchip/irq-xtensa-mx.c
+++ b/drivers/irqchip/irq-xtensa-mx.c
@@ -122,7 +122,7 @@ static int xtensa_mx_irq_retrigger(struct irq_data *d)
 static int xtensa_mx_irq_set_affinity(struct irq_data *d,
                 const struct cpumask *dest, bool force)
 {
-        unsigned mask = 1u << cpumask_any(dest);
+        unsigned mask = 1u << cpumask_any_and(dest, cpu_online_mask);
 
         set_er(mask, MIROUT(d->hwirq - HW_IRQ_MX_BASE));
         return 0;
diff --git a/drivers/irqchip/irq-zevio.c b/drivers/irqchip/irq-zevio.c
index 8ed04c4a43ee..ceb3a4318f73 100644
--- a/drivers/irqchip/irq-zevio.c
+++ b/drivers/irqchip/irq-zevio.c
@@ -50,7 +50,7 @@ static void zevio_irq_ack(struct irq_data *irqd)
         readl(gc->reg_base + regs->ack);
 }
 
-static asmlinkage void __exception_irq_entry zevio_handle_irq(struct pt_regs *regs)
+static void __exception_irq_entry zevio_handle_irq(struct pt_regs *regs)
 {
         int irqnr;
 
diff --git a/drivers/irqchip/irqchip.c b/drivers/irqchip/irqchip.c
index f496afce29de..cad3e2495552 100644
--- a/drivers/irqchip/irqchip.c
+++ b/drivers/irqchip/irqchip.c
@@ -10,8 +10,7 @@
 
 #include <linux/init.h>
 #include <linux/of_irq.h>
-
-#include "irqchip.h"
+#include <linux/irqchip.h>
 
 /*
  * This special of_device_id is the sentinel at the end of the
diff --git a/drivers/pci/host/pcie-designware.c b/drivers/pci/host/pcie-designware.c
index 17ce88f79d2b..2e48ecf09e2c 100644
--- a/drivers/pci/host/pcie-designware.c
+++ b/drivers/pci/host/pcie-designware.c
@@ -294,14 +294,12 @@ no_valid_irq:
 static void clear_irq(unsigned int irq)
 {
         unsigned int pos, nvec;
-        struct irq_desc *desc;
         struct msi_desc *msi;
         struct pcie_port *pp;
         struct irq_data *data = irq_get_irq_data(irq);
 
         /* get the port structure */
-        desc = irq_to_desc(irq);
-        msi = irq_desc_get_msi_desc(desc);
+        msi = irq_data_get_msi(data);
         pp = sys_to_pcie(msi->dev->bus->sysdata);
         if (!pp) {
                 BUG();
diff --git a/drivers/s390/cio/cio.c b/drivers/s390/cio/cio.c
index d691e6a13aae..9e058c4657a3 100644
--- a/drivers/s390/cio/cio.c
+++ b/drivers/s390/cio/cio.c
@@ -18,6 +18,7 @@
 #include <linux/device.h>
 #include <linux/kernel_stat.h>
 #include <linux/interrupt.h>
+#include <linux/irq.h>
 #include <asm/cio.h>
 #include <asm/delay.h>
 #include <asm/irq.h>
@@ -584,8 +585,6 @@ static irqreturn_t do_cio_interrupt(int irq, void *dummy)
         return IRQ_HANDLED;
 }
 
-static struct irq_desc *irq_desc_io;
-
 static struct irqaction io_interrupt = {
         .name    = "IO",
         .handler = do_cio_interrupt,
@@ -596,7 +595,6 @@ void __init init_cio_interrupts(void)
         irq_set_chip_and_handler(IO_INTERRUPT,
                                  &dummy_irq_chip, handle_percpu_irq);
         setup_irq(IO_INTERRUPT, &io_interrupt);
-        irq_desc_io = irq_to_desc(IO_INTERRUPT);
 }
 
 #ifdef CONFIG_CCW_CONSOLE
@@ -623,7 +621,7 @@ void cio_tsch(struct subchannel *sch)
                 local_bh_disable();
                 irq_enter();
         }
-        kstat_incr_irqs_this_cpu(IO_INTERRUPT, irq_desc_io);
+        kstat_incr_irq_this_cpu(IO_INTERRUPT);
         if (sch->driver && sch->driver->irq)
                 sch->driver->irq(sch);
         else
diff --git a/drivers/xen/events/events_2l.c b/drivers/xen/events/events_2l.c
index d7ff91757307..5db43fc100a4 100644
--- a/drivers/xen/events/events_2l.c
+++ b/drivers/xen/events/events_2l.c
@@ -166,7 +166,6 @@ static void evtchn_2l_handle_events(unsigned cpu)
         int start_word_idx, start_bit_idx;
         int word_idx, bit_idx;
         int i;
-        struct irq_desc *desc;
         struct shared_info *s = HYPERVISOR_shared_info;
         struct vcpu_info *vcpu_info = __this_cpu_read(xen_vcpu);
 
@@ -176,11 +175,8 @@ static void evtchn_2l_handle_events(unsigned cpu)
                 unsigned int evtchn = evtchn_from_irq(irq);
                 word_idx = evtchn / BITS_PER_LONG;
                 bit_idx = evtchn % BITS_PER_LONG;
-                if (active_evtchns(cpu, s, word_idx) & (1ULL << bit_idx)) {
-                        desc = irq_to_desc(irq);
-                        if (desc)
-                                generic_handle_irq_desc(irq, desc);
-                }
+                if (active_evtchns(cpu, s, word_idx) & (1ULL << bit_idx))
+                        generic_handle_irq(irq);
         }
 
         /*
@@ -245,11 +241,8 @@ static void evtchn_2l_handle_events(unsigned cpu)
                         port = (word_idx * BITS_PER_EVTCHN_WORD) + bit_idx;
                         irq = get_evtchn_to_irq(port);
 
-                        if (irq != -1) {
-                                desc = irq_to_desc(irq);
-                                if (desc)
-                                        generic_handle_irq_desc(irq, desc);
-                        }
+                        if (irq != -1)
+                                generic_handle_irq(irq);
 
                         bit_idx = (bit_idx + 1) % BITS_PER_EVTCHN_WORD;
 
diff --git a/drivers/xen/events/events_base.c b/drivers/xen/events/events_base.c
index f4a9e3311297..c3458f58de90 100644
--- a/drivers/xen/events/events_base.c
+++ b/drivers/xen/events/events_base.c
@@ -336,9 +336,8 @@ static void bind_evtchn_to_cpu(unsigned int chn, unsigned int cpu)
 
         BUG_ON(irq == -1);
 #ifdef CONFIG_SMP
-        cpumask_copy(irq_to_desc(irq)->irq_data.affinity, cpumask_of(cpu));
+        cpumask_copy(irq_get_irq_data(irq)->affinity, cpumask_of(cpu));
 #endif
-
         xen_evtchn_port_bind_to_cpu(info, cpu);
 
         info->cpu = cpu;
@@ -373,10 +372,8 @@ static void xen_irq_init(unsigned irq)
 {
         struct irq_info *info;
 #ifdef CONFIG_SMP
-        struct irq_desc *desc = irq_to_desc(irq);
-
         /* By default all event channels notify CPU#0. */
-        cpumask_copy(desc->irq_data.affinity, cpumask_of(0));
+        cpumask_copy(irq_get_irq_data(irq)->affinity, cpumask_of(0));
 #endif
 
         info = kzalloc(sizeof(*info), GFP_KERNEL);
@@ -490,13 +487,6 @@ static void pirq_query_unmask(int irq)
                 info->u.pirq.flags |= PIRQ_NEEDS_EOI;
 }
 
-static bool probing_irq(int irq)
-{
-        struct irq_desc *desc = irq_to_desc(irq);
-
-        return desc && desc->action == NULL;
-}
-
 static void eoi_pirq(struct irq_data *data)
 {
         int evtchn = evtchn_from_irq(data->irq);
@@ -538,8 +528,7 @@ static unsigned int __startup_pirq(unsigned int irq)
                                         BIND_PIRQ__WILL_SHARE : 0;
         rc = HYPERVISOR_event_channel_op(EVTCHNOP_bind_pirq, &bind_pirq);
         if (rc != 0) {
-                if (!probing_irq(irq))
-                        pr_info("Failed to obtain physical IRQ %d\n", irq);
+                pr_warn("Failed to obtain physical IRQ %d\n", irq);
                 return 0;
         }
         evtchn = bind_pirq.port;
@@ -772,17 +761,12 @@ error_irq:
 
 int xen_destroy_irq(int irq)
 {
-        struct irq_desc *desc;
         struct physdev_unmap_pirq unmap_irq;
         struct irq_info *info = info_for_irq(irq);
         int rc = -ENOENT;
 
         mutex_lock(&irq_mapping_update_lock);
 
-        desc = irq_to_desc(irq);
-        if (!desc)
-                goto out;
-
         if (xen_initial_domain()) {
                 unmap_irq.pirq = info->u.pirq.pirq;
                 unmap_irq.domid = info->u.pirq.domid;
@@ -1251,6 +1235,7 @@ void xen_evtchn_do_upcall(struct pt_regs *regs)
 #ifdef CONFIG_X86
         exit_idle();
 #endif
+        inc_irq_stat(irq_hv_callback_count);
 
         __xen_evtchn_do_upcall();
 
@@ -1339,7 +1324,7 @@ static int rebind_irq_to_cpu(unsigned irq, unsigned tcpu)
 static int set_affinity_irq(struct irq_data *data, const struct cpumask *dest,
                             bool force)
 {
-        unsigned tcpu = cpumask_first(dest);
+        unsigned tcpu = cpumask_first_and(dest, cpu_online_mask);
 
         return rebind_irq_to_cpu(data->irq, tcpu);
 }
diff --git a/drivers/xen/events/events_fifo.c b/drivers/xen/events/events_fifo.c
index 1de2a191b395..96109a9972b6 100644
--- a/drivers/xen/events/events_fifo.c
+++ b/drivers/xen/events/events_fifo.c
@@ -235,14 +235,10 @@ static uint32_t clear_linked(volatile event_word_t *word)
 static void handle_irq_for_port(unsigned port)
 {
         int irq;
-        struct irq_desc *desc;
 
         irq = get_evtchn_to_irq(port);
-        if (irq != -1) {
-                desc = irq_to_desc(irq);
-                if (desc)
-                        generic_handle_irq_desc(irq, desc);
-        }
+        if (irq != -1)
+                generic_handle_irq(irq);
 }
 
 static void consume_one_event(unsigned cpu,