Since commit [
e58aa3d2: genirq: Run irq handlers with interrupts disabled],
We run all interrupt handlers with interrupts disabled
and we even check and yell when an interrupt handler
returns with interrupts enabled (see commit [
b738a50a:
genirq: Warn when handler enables interrupts]).
So now this flag is a NOOP and can be removed.
Signed-off-by: Yong Zhang <yong.zhang0@gmail.com>
Signed-off-by: Paul Mundt <lethal@linux-sh.org>
 
        printk("SnapGear: EraseConfig init\n");
 
        /* Setup "EraseConfig" switch on external IRQ 0 */
-       if (request_irq(irq, eraseconfig_interrupt, IRQF_DISABLED,
-                               "Erase Config", NULL))
+       if (request_irq(irq, eraseconfig_interrupt, 0, "Erase Config", NULL))
                printk("SnapGear: failed to register IRQ%d for Reset witch\n",
                                irq);
        else
 
 static struct irqaction cayman_action_smsc = {
        .name           = "Cayman SMSC Mux",
        .handler        = cayman_interrupt_smsc,
-       .flags          = IRQF_DISABLED,
 };
 
 static struct irqaction cayman_action_pci2 = {
        .name           = "Cayman PCI2 Mux",
        .handler        = cayman_interrupt_pci2,
-       .flags          = IRQF_DISABLED,
 };
 
 static void enable_cayman_irq(struct irq_data *data)
 
        int ret;
 
        ret = request_irq(HP680_BTN_IRQ, hp6x0_apm_interrupt,
-                         IRQF_DISABLED, MODNAME, NULL);
+                         0, MODNAME, NULL);
        if (unlikely(ret < 0)) {
                printk(KERN_ERR MODNAME ": IRQ %d request failed\n",
                       HP680_BTN_IRQ);
 
 {
        int ret;
 
-       ret = request_irq(HW_EVENT_G2_DMA, g2_dma_interrupt, IRQF_DISABLED,
+       ret = request_irq(HW_EVENT_G2_DMA, g2_dma_interrupt, 0,
                          "g2 DMA handler", &g2_dma_info);
        if (unlikely(ret))
                return -EINVAL;
 
 static struct irqaction pvr2_dma_irq = {
        .name           = "pvr2 DMA handler",
        .handler        = pvr2_dma_interrupt,
-       .flags          = IRQF_DISABLED,
 };
 
 static struct dma_ops pvr2_dma_ops = {
 
 #if defined(CONFIG_SH_DMA_IRQ_MULTI)
                                IRQF_SHARED,
 #else
-                               IRQF_DISABLED,
+                               0,
 #endif
                                chan->dev_id, chan);
 }
 #if defined(CONFIG_SH_DMA_IRQ_MULTI)
                                IRQF_SHARED,
 #else
-                               IRQF_DISABLED,
+                               0,
 #endif
                                dmae_name[n], (void *)dmae_name[n]);
                if (unlikely(i < 0)) {
 
        or = __raw_readl(DMAOR);
        __raw_writel(or | DMAOR_BRG | DMAOR_DMEN, DMAOR);
 
-       ret = request_irq(DMABRGI0, dmabrg_irq, IRQF_DISABLED,
+       ret = request_irq(DMABRGI0, dmabrg_irq, 0,
                        "DMABRG USB address error", NULL);
        if (ret)
                goto out0;
 
-       ret = request_irq(DMABRGI1, dmabrg_irq, IRQF_DISABLED,
+       ret = request_irq(DMABRGI1, dmabrg_irq, 0,
                        "DMABRG Transfer End", NULL);
        if (ret)
                goto out1;
 
-       ret = request_irq(DMABRGI2, dmabrg_irq, IRQF_DISABLED,
+       ret = request_irq(DMABRGI2, dmabrg_irq, 0,
                        "DMABRG Transfer Half", NULL);
        if (ret == 0)
                return ret;
 
        u32 uval;
 
         if (request_irq(IRQ_ERR, pcish5_err_irq,
-                        IRQF_DISABLED, "PCI Error",NULL) < 0) {
+                        0, "PCI Error",NULL) < 0) {
                 printk(KERN_ERR "PCISH5: Cannot hook PCI_PERR interrupt\n");
                 return -EINVAL;
         }
 
         if (request_irq(IRQ_SERR, pcish5_serr_irq,
-                        IRQF_DISABLED, "PCI SERR interrupt", NULL) < 0) {
+                        0, "PCI SERR interrupt", NULL) < 0) {
                 printk(KERN_ERR "PCISH5: Cannot hook PCI_SERR interrupt\n");
                 return -EINVAL;
         }
 
                     PCI_STATUS_SIG_TARGET_ABORT | \
                     PCI_STATUS_PARITY, hose->reg_base + PCI_STATUS);
 
-       ret = request_irq(hose->serr_irq, sh7780_pci_serr_irq, IRQF_DISABLED,
+       ret = request_irq(hose->serr_irq, sh7780_pci_serr_irq, 0,
                          "PCI SERR interrupt", hose);
        if (unlikely(ret)) {
                printk(KERN_ERR "PCI: Failed hooking SERR IRQ\n");
 
        BUG_ON(!psw_info);
 
        ret = request_irq(irq, psw_info->irq_handler,
-                         IRQF_DISABLED | psw_info->irq_flags,
+                         psw_info->irq_flags,
                          psw_info->name ? psw_info->name : DRV_NAME, pdev);
        if (unlikely(ret < 0))
                goto err;
 
 
        for (i = 0; i < SMP_MSG_NR; i++)
                request_irq(104 + i, ipi_interrupt_handler,
-                           IRQF_DISABLED | IRQF_PERCPU, "IPI", (void *)(long)i);
+                           IRQF_PERCPU, "IPI", (void *)(long)i);
 
        for (i = 0; i < max_cpus; i++)
                set_cpu_present(i, true);