This flag is a NOOP and can be removed now.
Signed-off-by: Yong Zhang <yong.zhang0@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
 
        pci_set_master(dev);
 
-       retval = usb_add_hcd(hcd, dev->irq, IRQF_DISABLED | IRQF_SHARED);
+       retval = usb_add_hcd(hcd, dev->irq, IRQF_SHARED);
        if (retval != 0)
                goto unmap_registers;
        set_hs_companion(dev, hcd);
 
        /* request UDC and maybe VBUS irqs */
        udc->udp_irq = platform_get_irq(pdev, 0);
        retval = request_irq(udc->udp_irq, at91_udc_irq,
-                       IRQF_DISABLED, driver_name, udc);
+                       0, driver_name, udc);
        if (retval < 0) {
                DBG("request irq %d failed\n", udc->udp_irq);
                goto fail1;
                                  jiffies + VBUS_POLL_TIMEOUT);
                } else {
                        if (request_irq(udc->board.vbus_pin, at91_vbus_irq,
-                                       IRQF_DISABLED, driver_name, udc)) {
+                                       0, driver_name, udc)) {
                                DBG("request vbus irq %d failed\n",
                                    udc->board.vbus_pin);
                                retval = -EBUSY;
 
        fusb300->gadget.name = udc_name;
        fusb300->reg = reg;
 
-       ret = request_irq(ires->start, fusb300_irq, IRQF_DISABLED | IRQF_SHARED,
+       ret = request_irq(ires->start, fusb300_irq, IRQF_SHARED,
                          udc_name, fusb300);
        if (ret < 0) {
                pr_err("request_irq error (%d)\n", ret);
        }
 
        ret = request_irq(ires1->start, fusb300_irq,
-                       IRQF_DISABLED | IRQF_SHARED, udc_name, fusb300);
+                       IRQF_SHARED, udc_name, fusb300);
        if (ret < 0) {
                pr_err("request_irq1 error (%d)\n", ret);
                goto clean_up;
 
 
        for (i = 0; i < IMX_USB_NB_EP + 1; i++) {
                ret = request_irq(imx_usb->usbd_int[i], intr_handler(i),
-                                    IRQF_DISABLED, driver_name, imx_usb);
+                                    0, driver_name, imx_usb);
                if (ret) {
                        dev_err(&pdev->dev, "can't get irq %i, err %d\n",
                                imx_usb->usbd_int[i], ret);
 
        m66592->timer.data = (unsigned long)m66592;
        m66592->reg = reg;
 
-       ret = request_irq(ires->start, m66592_irq, IRQF_DISABLED | IRQF_SHARED,
+       ret = request_irq(ires->start, m66592_irq, IRQF_SHARED,
                        udc_name, m66592);
        if (ret < 0) {
                pr_err("request_irq error (%d)\n", ret);
 
        }
        udc->irq = r->start;
        if (request_irq(udc->irq, mv_udc_irq,
-               IRQF_DISABLED | IRQF_SHARED, driver_name, udc)) {
+               IRQF_SHARED, driver_name, udc)) {
                dev_err(&dev->dev, "Request irq %d for UDC failed\n",
                        udc->irq);
                retval = -ENODEV;
 
        }
 #ifdef USE_ISO
        status = request_irq(pdev->resource[3].start, omap_udc_iso_irq,
-                       IRQF_DISABLED, "omap_udc iso", udc);
+                       0, "omap_udc iso", udc);
        if (status != 0) {
                ERR("can't get irq %d, err %d\n",
                        (int) pdev->resource[3].start, status);
 
 
        /* irq setup after old hardware state is cleaned up */
        retval = request_irq(irq, pxa25x_udc_irq,
-                       IRQF_DISABLED, driver_name, dev);
+                       0, driver_name, dev);
        if (retval != 0) {
                pr_err("%s: can't get irq %d, err %d\n",
                        driver_name, irq, retval);
        if (machine_is_lubbock()) {
                retval = request_irq(LUBBOCK_USB_DISC_IRQ,
                                lubbock_vbus_irq,
-                               IRQF_DISABLED | IRQF_SAMPLE_RANDOM,
+                               IRQF_SAMPLE_RANDOM,
                                driver_name, dev);
                if (retval != 0) {
                        pr_err("%s: can't get irq %i, err %d\n",
                }
                retval = request_irq(LUBBOCK_USB_IRQ,
                                lubbock_vbus_irq,
-                               IRQF_DISABLED | IRQF_SAMPLE_RANDOM,
+                               IRQF_SAMPLE_RANDOM,
                                driver_name, dev);
                if (retval != 0) {
                        pr_err("%s: can't get irq %i, err %d\n",
 
 
        disable_controller(r8a66597); /* make sure controller is disabled */
 
-       ret = request_irq(irq, r8a66597_irq, IRQF_DISABLED | IRQF_SHARED,
+       ret = request_irq(irq, r8a66597_irq, IRQF_SHARED,
                        udc_name, r8a66597);
        if (ret < 0) {
                printk(KERN_ERR "request_irq error (%d)\n", ret);
 
 
        /* irq setup after old hardware state is cleaned up */
        retval = request_irq(IRQ_USBD, s3c2410_udc_irq,
-                            IRQF_DISABLED, gadget_name, udc);
+                            0, gadget_name, udc);
 
        if (retval != 0) {
                dev_err(dev, "cannot get irq %i, err %d\n", IRQ_USBD, retval);
                }
 
                retval = request_irq(irq, s3c2410_udc_vbus_irq,
-                                    IRQF_DISABLED | IRQF_TRIGGER_RISING
+                                    IRQF_TRIGGER_RISING
                                     | IRQF_TRIGGER_FALLING | IRQF_SHARED,
                                     gadget_name, udc);
 
 
                goto err_release_region;
        }
 
-       ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+       ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
        if (ret)
                goto err_iounmap;
 
 
        ehci->hcs_params = readl(&ehci->caps->hcs_params);
 
        ret = usb_add_hcd(hcd, pdev->resource[1].start,
-                         IRQF_DISABLED | IRQF_SHARED);
+                         IRQF_SHARED);
        if (ret == 0) {
                platform_set_drvdata(pdev, hcd);
                return ret;
 
 
        /* Don't need to set host mode here. It will be done by tdi_reset() */
 
-       retval = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+       retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
        if (retval != 0)
                goto err4;
 
 
        priv->hcd = hcd;
        platform_set_drvdata(pdev, priv);
 
-       ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+       ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
        if (ret)
                goto err_add;
 
 
        /* cache this readonly data; minimize chip reads */
        ehci->hcs_params = ehci_readl(ehci, &ehci->caps->hcs_params);
 
-       ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+       ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
        if (ret) {
                dev_dbg(&pdev->dev, "failed to add hcd with err %d\n", ret);
                goto err3;
 
        /* cache this readonly data; minimize chip reads */
        omap_ehci->hcs_params = readl(&omap_ehci->caps->hcs_params);
 
-       ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+       ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
        if (ret) {
                dev_err(dev, "failed to add hcd with err %d\n", ret);
                goto err_add_hcd;
 
                printk(KERN_WARNING "Orion ehci -USB phy version isn't supported.\n");
        }
 
-       err = usb_add_hcd(hcd, irq, IRQF_SHARED | IRQF_DISABLED);
+       err = usb_add_hcd(hcd, irq, IRQF_SHARED);
        if (err)
                goto err4;
 
 
 
        ps3_system_bus_set_drvdata(dev, hcd);
 
-       result = usb_add_hcd(hcd, virq, IRQF_DISABLED);
+       result = usb_add_hcd(hcd, virq, 0);
 
        if (result) {
                dev_dbg(&dev->core, "%s:%d: usb_add_hcd failed (%d)\n",
 
        /* cache this readonly data; minimize chip reads */
        ehci->hcs_params = readl(&ehci->caps->hcs_params);
 
-       err = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+       err = usb_add_hcd(hcd, irq, IRQF_SHARED);
        if (err) {
                dev_err(&pdev->dev, "Failed to add USB HCD\n");
                goto fail;
 
        clk_enable(priv->fclk);
        clk_enable(priv->iclk);
 
-       ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+       ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
        if (ret != 0) {
                dev_err(&pdev->dev, "Failed to add hcd");
                goto fail_add_hcd;
 
        ehci->clk = usbh_clk;
 
        spear_start_ehci(ehci);
-       retval = usb_add_hcd(hcd, irq, IRQF_SHARED | IRQF_DISABLED);
+       retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
        if (retval)
                goto fail_add_hcd;
 
 
        }
 #endif
 
-       err = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+       err = usb_add_hcd(hcd, irq, IRQF_SHARED);
        if (err) {
                dev_err(&pdev->dev, "Failed to add USB HCD\n");
                goto fail;
 
        ehci_port_power(ehci, 1);
 
        ret = usb_add_hcd(hcd, pdev->resource[1].start,
-                         IRQF_DISABLED | IRQF_SHARED);
+                         IRQF_SHARED);
        if (ret == 0) {
                platform_set_drvdata(pdev, hcd);
                return ret;
 
        }
 
        ret = request_irq(fhci->timer->irq, fhci_frame_limit_timer_irq,
-                         IRQF_DISABLED, "qe timer (usb)", hcd);
+                         0, "qe timer (usb)", hcd);
        if (ret) {
                dev_err(dev, "failed to request timer irq");
                goto err_timer_irq;
        out_be16(&fhci->regs->usb_event, 0xffff);
        out_be16(&fhci->regs->usb_mask, 0);
 
-       ret = usb_add_hcd(hcd, usb_irq, IRQF_DISABLED);
+       ret = usb_add_hcd(hcd, usb_irq, 0);
        if (ret < 0)
                goto err_add_hcd;
 
 
        dev_info(imx21->dev, "Hardware HC revision: 0x%02X\n",
                (readl(imx21->regs + USBOTG_HWMODE) >> 16) & 0xFF);
 
-       ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+       ret = usb_add_hcd(hcd, irq, 0);
        if (ret != 0) {
                dev_err(imx21->dev, "usb_add_hcd() returned %d\n", ret);
                goto failed_add_hcd;
 
                goto err6;
        }
 
-       ret = usb_add_hcd(hcd, irq, irqflags | IRQF_DISABLED);
+       ret = usb_add_hcd(hcd, irq, irqflags);
        if (ret)
                goto err6;
 
 
        if (irq_res->flags & IORESOURCE_IRQ_LOWLEVEL)
                irq_flags |= IRQF_TRIGGER_LOW;
 
-       retval = usb_add_hcd(hcd, irq, irq_flags | IRQF_DISABLED | IRQF_SHARED);
+       retval = usb_add_hcd(hcd, irq, irq_flags | IRQF_SHARED);
        if (retval != 0)
                goto err6;
        pr_info("%s, irq %d\n", hcd->product_desc, irq);
 
                devflags |= ISP1760_FLAG_DREQ_POL_HIGH;
 
        hcd = isp1760_register(memory.start, res_len, virq,
-               IRQF_SHARED | IRQF_DISABLED, &dev->dev, dev_name(&dev->dev),
+               IRQF_SHARED, &dev->dev, dev_name(&dev->dev),
                devflags);
        if (IS_ERR(hcd)) {
                ret = PTR_ERR(hcd);
 
        dev->dev.dma_mask = NULL;
        hcd = isp1760_register(pci_mem_phy0, memlength, dev->irq,
-               IRQF_SHARED | IRQF_DISABLED, &dev->dev, dev_name(&dev->dev),
+               IRQF_SHARED, &dev->dev, dev_name(&dev->dev),
                devflags);
        if (IS_ERR(hcd)) {
                ret_status = -ENODEV;
        resource_size_t mem_size;
        struct isp1760_platform_data *priv = pdev->dev.platform_data;
        unsigned int devflags = 0;
-       unsigned long irqflags = IRQF_SHARED | IRQF_DISABLED;
+       unsigned long irqflags = IRQF_SHARED;
 
        mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
        if (!mem_res) {
 
 
        ohci_hcd_init(hcd_to_ohci(hcd));
 
-       ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+       ret = usb_add_hcd(hcd, irq, 0);
        if (ret)
                goto err_stop_hcd;
 
 
        ohci_hcd_init(hcd_to_ohci(hcd));
 
        ret = usb_add_hcd(hcd, pdev->resource[1].start,
-                         IRQF_DISABLED | IRQF_SHARED);
+                         IRQF_SHARED);
        if (ret == 0) {
                platform_set_drvdata(pdev, hcd);
                return ret;
 
                error = -ENODEV;
                goto err4;
        }
-       error = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+       error = usb_add_hcd(hcd, irq, 0);
        if (error)
                goto err4;
 
 
 
        ohci_hcd_init(hcd_to_ohci(hcd));
 
-       retval = usb_add_hcd(hcd, pdev->resource[1].start, IRQF_DISABLED);
+       retval = usb_add_hcd(hcd, pdev->resource[1].start, 0);
        if (retval == 0)
                return retval;
 
 
 
        ohci_hcd_init(ohci);
 
-       ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+       ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
        if (ret) {
                dev_dbg(&pdev->dev, "failed to add hcd with err %d\n", ret);
                goto err3;
 
  * This file is licenced under the GPL.
  */
 
-#include <linux/signal.h>      /* IRQF_DISABLED */
+#include <linux/signal.h>
 #include <linux/jiffies.h>
 #include <linux/platform_device.h>
 #include <linux/clk.h>
                retval = -ENXIO;
                goto err3;
        }
-       retval = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+       retval = usb_add_hcd(hcd, irq, 0);
        if (retval)
                goto err3;
 
 
 
        ohci_hcd_init(hcd_to_ohci(hcd));
 
-       ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+       ret = usb_add_hcd(hcd, irq, 0);
        if (ret) {
                dev_dbg(dev, "failed to add hcd with err %d\n", ret);
                goto err_add_hcd;
 
        ohci_hcd_init(ohci);
 
        dev_info(&pdev->dev, "at 0x%p, irq %d\n", hcd->regs, hcd->irq);
-       ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+       ret = usb_add_hcd(hcd, irq, 0);
        if (ret == 0)
                return ret;
 
 
 
        ohci_hcd_init(hcd_to_ohci(hcd));
 
-       retval = usb_add_hcd(hcd, dev->resource[1].start, IRQF_DISABLED);
+       retval = usb_add_hcd(hcd, dev->resource[1].start, 0);
        if (retval == 0)
                return retval;
 
 
 
        ohci_hcd_init(ohci);
 
-       rv = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+       rv = usb_add_hcd(hcd, irq, 0);
        if (rv == 0)
                return 0;
 
 
 #endif
        ohci_hcd_init(ohci);
 
-       retval = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+       retval = usb_add_hcd(hcd, irq, 0);
        if (retval == 0)
                return retval;
 
 
 
        ps3_system_bus_set_drvdata(dev, hcd);
 
-       result = usb_add_hcd(hcd, virq, IRQF_DISABLED);
+       result = usb_add_hcd(hcd, virq, 0);
 
        if (result) {
                dev_dbg(&dev->core, "%s:%d: usb_add_hcd failed (%d)\n",
 
 
        ohci_hcd_init(hcd_to_ohci(hcd));
 
-       retval = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+       retval = usb_add_hcd(hcd, irq, 0);
        if (retval == 0)
                return retval;
 
 
 
        ohci_hcd_init(hcd_to_ohci(hcd));
 
-       retval = usb_add_hcd(hcd, dev->resource[1].start, IRQF_DISABLED);
+       retval = usb_add_hcd(hcd, dev->resource[1].start, 0);
        if (retval != 0)
                goto err_ioremap;
 
 
        sa1111_start_hc(dev);
        ohci_hcd_init(hcd_to_ohci(hcd));
 
-       retval = usb_add_hcd(hcd, dev->irq[1], IRQF_DISABLED);
+       retval = usb_add_hcd(hcd, dev->irq[1], 0);
        if (retval == 0)
                return retval;
 
 
        hcd->regs = (void __iomem *)res->start;
        hcd->rsrc_start = res->start;
        hcd->rsrc_len = resource_size(res);
-       ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+       ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
        if (ret != 0) {
                err("Failed to add hcd");
                usb_put_hcd(hcd);
 
 
        ohci_hcd_init(hcd_to_ohci(hcd));
 
-       retval = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+       retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
        if (retval)
                goto err5;
 
 
        spear_start_ohci(ohci_p);
        ohci_hcd_init(hcd_to_ohci(hcd));
 
-       retval = usb_add_hcd(hcd, platform_get_irq(pdev, 0), IRQF_DISABLED);
+       retval = usb_add_hcd(hcd, platform_get_irq(pdev, 0), 0);
        if (retval == 0)
                return retval;
 
 
        hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
        if (!hcd->regs)
                goto err_put_hcd;
-       err = usb_add_hcd(hcd, dev->irq, IRQF_DISABLED | IRQF_SHARED);
+       err = usb_add_hcd(hcd, dev->irq, IRQF_SHARED);
        if (err)
                goto err_iounmap;
 
 
        ohci = hcd_to_ohci(hcd);
        ohci_hcd_init(ohci);
 
-       ret = usb_add_hcd(hcd, irq, IRQF_DISABLED);
+       ret = usb_add_hcd(hcd, irq, 0);
        if (ret)
                goto err_add_hcd;
 
 
        hcd->rsrc_start = res->start;
        hcd->has_tt = 1;
 
-       ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | irq_trigger);
+       ret = usb_add_hcd(hcd, irq, irq_trigger);
        if (ret != 0) {
                dev_err(&pdev->dev, "Failed to add hcd\n");
                goto clean_up3;
 
         * Use resource IRQ flags if set by platform device setup.
         */
        irqflags |= IRQF_SHARED;
-       retval = usb_add_hcd(hcd, irq, IRQF_DISABLED | irqflags);
+       retval = usb_add_hcd(hcd, irq, irqflags);
        if (retval != 0)
                goto err6;
 
 
        *((struct xhci_hcd **) xhci->shared_hcd->hcd_priv) = xhci;
 
        retval = usb_add_hcd(xhci->shared_hcd, dev->irq,
-                       IRQF_DISABLED | IRQF_SHARED);
+                       IRQF_SHARED);
        if (retval)
                goto put_usb3_hcd;
        /* Roothub already marked as USB 3.0 speed */
 
        controller->controller.channel_program = dma_channel_program;
        controller->controller.channel_abort = dma_channel_abort;
 
-       if (request_irq(irq, dma_controller_irq, IRQF_DISABLED,
+       if (request_irq(irq, dma_controller_irq, 0,
                        dev_name(musb->controller), &controller->controller)) {
                dev_err(dev, "request_irq %d failed!\n", irq);
                dma_controller_destroy(&controller->controller);
 
 
        if (otg_dev)
                status = request_irq(otg_dev->resource[1].start, omap_otg_irq,
-                               IRQF_DISABLED, DRIVER_NAME, isp);
+                               0, DRIVER_NAME, isp);
        else
                status = -ENODEV;
 
 
 
        /* irq settings */
        ret = request_irq(priv->irq, usbhs_interrupt,
-                         IRQF_DISABLED, dev_name(dev), priv);
+                         0, dev_name(dev), priv);
        if (ret) {
                dev_err(dev, "irq request err\n");
                goto mod_init_gadget_err;