29 files changed, 89 insertions, 90 deletions

diff --git a/drivers/usb/c67x00/c67x00-sched.c b/drivers/usb/c67x00/c67x00-sched.c
index aa491627a45b..892cc96466eb 100644
--- a/drivers/usb/c67x00/c67x00-sched.c
+++ b/drivers/usb/c67x00/c67x00-sched.c
@@ -344,7 +344,7 @@ void c67x00_endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoint *ep)
                 /* it could happen that we reinitialize this completion, while
                  * somebody was waiting for that completion.  The timeout and
                  * while loop handle such cases, but this might be improved */
-                INIT_COMPLETION(c67x00->endpoint_disable);
+                reinit_completion(&c67x00->endpoint_disable);
                 c67x00_sched_kick(c67x00);
                 wait_for_completion_timeout(&c67x00->endpoint_disable, 1 * HZ);
 
diff --git a/drivers/usb/chipidea/ci_hdrc_imx.c b/drivers/usb/chipidea/ci_hdrc_imx.c
index 023d3cb6aa0a..bb5d976e5b81 100644
--- a/drivers/usb/chipidea/ci_hdrc_imx.c
+++ b/drivers/usb/chipidea/ci_hdrc_imx.c
@@ -115,10 +115,9 @@ static int ci_hdrc_imx_probe(struct platform_device *pdev)
 
         pdata.phy = data->phy;
 
-        if (!pdev->dev.dma_mask)
-                pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
-        if (!pdev->dev.coherent_dma_mask)
-                pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        ret = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (ret)
+                goto err_clk;
 
         if (data->usbmisc_data) {
                 ret = imx_usbmisc_init(data->usbmisc_data);
diff --git a/drivers/usb/core/Kconfig b/drivers/usb/core/Kconfig
index db535b0aa172..fed7f68d025d 100644
--- a/drivers/usb/core/Kconfig
+++ b/drivers/usb/core/Kconfig
@@ -28,7 +28,7 @@ config USB_DEFAULT_PERSIST
         bool "Enable USB persist by default"
         default y
         help
-          Say N here if you don't want USB power session persistance
+          Say N here if you don't want USB power session persistence
           enabled by default.  If you say N it will make suspended USB
           devices that lose power get reenumerated as if they had been
           unplugged, causing any mounted filesystems to be lost.  The
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 06cec635e703..a7c04e24ca48 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -5501,6 +5501,6 @@ acpi_handle usb_get_hub_port_acpi_handle(struct usb_device *hdev,
         if (!hub)
                 return NULL;
 
-        return DEVICE_ACPI_HANDLE(&hub->ports[port1 - 1]->dev);
+        return ACPI_HANDLE(&hub->ports[port1 - 1]->dev);
 }
 #endif
diff --git a/drivers/usb/core/usb-acpi.c b/drivers/usb/core/usb-acpi.c
index 255c14464bf2..4e243c37f17f 100644
--- a/drivers/usb/core/usb-acpi.c
+++ b/drivers/usb/core/usb-acpi.c
@@ -173,7 +173,7 @@ static int usb_acpi_find_device(struct device *dev, acpi_handle *handle)
                 }
 
                 /* root hub's parent is the usb hcd. */
-                parent_handle = DEVICE_ACPI_HANDLE(dev->parent);
+                parent_handle = ACPI_HANDLE(dev->parent);
                 *handle = acpi_get_child(parent_handle, udev->portnum);
                 if (!*handle)
                         return -ENODEV;
@@ -194,7 +194,7 @@ static int usb_acpi_find_device(struct device *dev, acpi_handle *handle)
 
                         raw_port_num = usb_hcd_find_raw_port_number(hcd,
                                 port_num);
-                        *handle = acpi_get_child(DEVICE_ACPI_HANDLE(&udev->dev),
+                        *handle = acpi_get_child(ACPI_HANDLE(&udev->dev),
                                 raw_port_num);
                         if (!*handle)
                                 return -ENODEV;
diff --git a/drivers/usb/dwc3/dwc3-exynos.c b/drivers/usb/dwc3/dwc3-exynos.c
index 2f2e88a3a11a..8b20c70d91e7 100644
--- a/drivers/usb/dwc3/dwc3-exynos.c
+++ b/drivers/usb/dwc3/dwc3-exynos.c
@@ -119,10 +119,9 @@ static int dwc3_exynos_probe(struct platform_device *pdev)
          * Since shared usb code relies on it, set it here for now.
          * Once we move to full device tree support this will vanish off.
          */
-        if (!dev->dma_mask)
-                dev->dma_mask = &dev->coherent_dma_mask;
-        if (!dev->coherent_dma_mask)
-                dev->coherent_dma_mask = DMA_BIT_MASK(32);
+        ret = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(32));
+        if (ret)
+                goto err1;
 
         platform_set_drvdata(pdev, exynos);
 
diff --git a/drivers/usb/gadget/f_fs.c b/drivers/usb/gadget/f_fs.c
index 44cf775a8627..774e8b89cdb5 100644
--- a/drivers/usb/gadget/f_fs.c
+++ b/drivers/usb/gadget/f_fs.c
@@ -373,7 +373,7 @@ static int __ffs_ep0_queue_wait(struct ffs_data *ffs, char *data, size_t len)
         if (req->buf == NULL)
                 req->buf = (void *)0xDEADBABE;
 
-        INIT_COMPLETION(ffs->ep0req_completion);
+        reinit_completion(&ffs->ep0req_completion);
 
         ret = usb_ep_queue(ffs->gadget->ep0, req, GFP_ATOMIC);
         if (unlikely(ret < 0))
diff --git a/drivers/usb/gadget/lpc32xx_udc.c b/drivers/usb/gadget/lpc32xx_udc.c
index 67128be1e1b7..6a2a65aa0057 100644
--- a/drivers/usb/gadget/lpc32xx_udc.c
+++ b/drivers/usb/gadget/lpc32xx_udc.c
@@ -3078,7 +3078,9 @@ static int __init lpc32xx_udc_probe(struct platform_device *pdev)
                  udc->isp1301_i2c_client->addr);
 
         pdev->dev.dma_mask = &lpc32xx_usbd_dmamask;
-        pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        retval = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
+        if (retval)
+                goto resource_fail;
 
         udc->board = &lpc32xx_usbddata;
 
diff --git a/drivers/usb/gadget/tcm_usb_gadget.c b/drivers/usb/gadget/tcm_usb_gadget.c
index eccea1df702d..6c3d7950d2a9 100644
--- a/drivers/usb/gadget/tcm_usb_gadget.c
+++ b/drivers/usb/gadget/tcm_usb_gadget.c
@@ -1923,15 +1923,15 @@ static int usbg_register_configfs(void)
         }
 
         fabric->tf_ops = usbg_ops;
-        TF_CIT_TMPL(fabric)->tfc_wwn_cit.ct_attrs = usbg_wwn_attrs;
-        TF_CIT_TMPL(fabric)->tfc_tpg_base_cit.ct_attrs = usbg_base_attrs;
-        TF_CIT_TMPL(fabric)->tfc_tpg_attrib_cit.ct_attrs = NULL;
-        TF_CIT_TMPL(fabric)->tfc_tpg_param_cit.ct_attrs = NULL;
-        TF_CIT_TMPL(fabric)->tfc_tpg_np_base_cit.ct_attrs = NULL;
-        TF_CIT_TMPL(fabric)->tfc_tpg_nacl_base_cit.ct_attrs = NULL;
-        TF_CIT_TMPL(fabric)->tfc_tpg_nacl_attrib_cit.ct_attrs = NULL;
-        TF_CIT_TMPL(fabric)->tfc_tpg_nacl_auth_cit.ct_attrs = NULL;
-        TF_CIT_TMPL(fabric)->tfc_tpg_nacl_param_cit.ct_attrs = NULL;
+        fabric->tf_cit_tmpl.tfc_wwn_cit.ct_attrs = usbg_wwn_attrs;
+        fabric->tf_cit_tmpl.tfc_tpg_base_cit.ct_attrs = usbg_base_attrs;
+        fabric->tf_cit_tmpl.tfc_tpg_attrib_cit.ct_attrs = NULL;
+        fabric->tf_cit_tmpl.tfc_tpg_param_cit.ct_attrs = NULL;
+        fabric->tf_cit_tmpl.tfc_tpg_np_base_cit.ct_attrs = NULL;
+        fabric->tf_cit_tmpl.tfc_tpg_nacl_base_cit.ct_attrs = NULL;
+        fabric->tf_cit_tmpl.tfc_tpg_nacl_attrib_cit.ct_attrs = NULL;
+        fabric->tf_cit_tmpl.tfc_tpg_nacl_auth_cit.ct_attrs = NULL;
+        fabric->tf_cit_tmpl.tfc_tpg_nacl_param_cit.ct_attrs = NULL;
         ret = target_fabric_configfs_register(fabric);
         if (ret < 0) {
                 printk(KERN_ERR "target_fabric_configfs_register() failed"
diff --git a/drivers/usb/host/bcma-hcd.c b/drivers/usb/host/bcma-hcd.c
index df13d425e9c5..205f4a336583 100644
--- a/drivers/usb/host/bcma-hcd.c
+++ b/drivers/usb/host/bcma-hcd.c
@@ -227,8 +227,7 @@ static int bcma_hcd_probe(struct bcma_device *dev)
 
         /* TODO: Probably need checks here; is the core connected? */
 
-        if (dma_set_mask(dev->dma_dev, DMA_BIT_MASK(32)) ||
-            dma_set_coherent_mask(dev->dma_dev, DMA_BIT_MASK(32)))
+        if (dma_set_mask_and_coherent(dev->dma_dev, DMA_BIT_MASK(32)))
                 return -EOPNOTSUPP;
 
         usb_dev = kzalloc(sizeof(struct bcma_hcd_device), GFP_KERNEL);
diff --git a/drivers/usb/host/ehci-atmel.c b/drivers/usb/host/ehci-atmel.c
index f417526fb1f4..284f8417eae5 100644
--- a/drivers/usb/host/ehci-atmel.c
+++ b/drivers/usb/host/ehci-atmel.c
@@ -96,10 +96,9 @@ static int ehci_atmel_drv_probe(struct platform_device *pdev)
          * Since shared usb code relies on it, set it here for now.
          * Once we have dma capability bindings this can go away.
          */
-        if (!pdev->dev.dma_mask)
-                pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
-        if (!pdev->dev.coherent_dma_mask)
-                pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        retval = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (retval)
+                goto fail_create_hcd;
 
         hcd = usb_create_hcd(driver, &pdev->dev, dev_name(&pdev->dev));
         if (!hcd) {
diff --git a/drivers/usb/host/ehci-exynos.c b/drivers/usb/host/ehci-exynos.c
index 016352e0f5a7..e97c198e052f 100644
--- a/drivers/usb/host/ehci-exynos.c
+++ b/drivers/usb/host/ehci-exynos.c
@@ -84,10 +84,9 @@ static int exynos_ehci_probe(struct platform_device *pdev)
          * Since shared usb code relies on it, set it here for now.
          * Once we move to full device tree support this will vanish off.
          */
-        if (!pdev->dev.dma_mask)
-                pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
-        if (!pdev->dev.coherent_dma_mask)
-                pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        err = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (err)
+                return err;
 
         exynos_setup_vbus_gpio(pdev);
 
diff --git a/drivers/usb/host/ehci-octeon.c b/drivers/usb/host/ehci-octeon.c
index ab0397e4d8f3..4c528b2c033a 100644
--- a/drivers/usb/host/ehci-octeon.c
+++ b/drivers/usb/host/ehci-octeon.c
@@ -116,8 +116,10 @@ static int ehci_octeon_drv_probe(struct platform_device *pdev)
          * We can DMA from anywhere. But the descriptors must be in
          * the lower 4GB.
          */
-        pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
         pdev->dev.dma_mask = &ehci_octeon_dma_mask;
+        ret = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(32));
+        if (ret)
+                return ret;
 
         hcd = usb_create_hcd(&ehci_octeon_hc_driver, &pdev->dev, "octeon");
         if (!hcd)
diff --git a/drivers/usb/host/ehci-omap.c b/drivers/usb/host/ehci-omap.c
index 78b01fa475bb..6fa82d6b7661 100644
--- a/drivers/usb/host/ehci-omap.c
+++ b/drivers/usb/host/ehci-omap.c
@@ -104,7 +104,7 @@ static int ehci_hcd_omap_probe(struct platform_device *pdev)
         struct resource *res;
         struct usb_hcd  *hcd;
         void __iomem *regs;
-        int ret = -ENODEV;
+        int ret;
         int irq;
         int i;
         struct omap_hcd *omap;
@@ -144,11 +144,11 @@ static int ehci_hcd_omap_probe(struct platform_device *pdev)
          * Since shared usb code relies on it, set it here for now.
          * Once we have dma capability bindings this can go away.
          */
-        if (!dev->dma_mask)
-                dev->dma_mask = &dev->coherent_dma_mask;
-        if (!dev->coherent_dma_mask)
-                dev->coherent_dma_mask = DMA_BIT_MASK(32);
+        ret = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(32));
+        if (ret)
+                return ret;
 
+        ret = -ENODEV;
         hcd = usb_create_hcd(&ehci_omap_hc_driver, dev,
                         dev_name(dev));
         if (!hcd) {
diff --git a/drivers/usb/host/ehci-orion.c b/drivers/usb/host/ehci-orion.c
index d1dfb9db5b42..2ba76730e650 100644
--- a/drivers/usb/host/ehci-orion.c
+++ b/drivers/usb/host/ehci-orion.c
@@ -180,10 +180,9 @@ static int ehci_orion_drv_probe(struct platform_device *pdev)
          * set. Since shared usb code relies on it, set it here for
          * now. Once we have dma capability bindings this can go away.
          */
-        if (!pdev->dev.dma_mask)
-                pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
-        if (!pdev->dev.coherent_dma_mask)
-                pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        err = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (err)
+                goto err1;
 
         if (!request_mem_region(res->start, resource_size(res),
                                 ehci_orion_hc_driver.description)) {
diff --git a/drivers/usb/host/ehci-platform.c b/drivers/usb/host/ehci-platform.c
index f6b790ca8cf2..7f30b7168d5a 100644
--- a/drivers/usb/host/ehci-platform.c
+++ b/drivers/usb/host/ehci-platform.c
@@ -78,7 +78,7 @@ static int ehci_platform_probe(struct platform_device *dev)
         struct resource *res_mem;
         struct usb_ehci_pdata *pdata;
         int irq;
-        int err = -ENOMEM;
+        int err;
 
         if (usb_disabled())
                 return -ENODEV;
@@ -89,10 +89,10 @@ static int ehci_platform_probe(struct platform_device *dev)
          */
         if (!dev_get_platdata(&dev->dev))
                 dev->dev.platform_data = &ehci_platform_defaults;
-        if (!dev->dev.dma_mask)
-                dev->dev.dma_mask = &dev->dev.coherent_dma_mask;
-        if (!dev->dev.coherent_dma_mask)
-                dev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+
+        err = dma_coerce_mask_and_coherent(&dev->dev, DMA_BIT_MASK(32));
+        if (err)
+                return err;
 
         pdata = dev_get_platdata(&dev->dev);
 
diff --git a/drivers/usb/host/ehci-spear.c b/drivers/usb/host/ehci-spear.c
index 1cf0adba3fc8..ee6f9ffaa0e7 100644
--- a/drivers/usb/host/ehci-spear.c
+++ b/drivers/usb/host/ehci-spear.c
@@ -81,10 +81,9 @@ static int spear_ehci_hcd_drv_probe(struct platform_device *pdev)
          * Since shared usb code relies on it, set it here for now.
          * Once we have dma capability bindings this can go away.
          */
-        if (!pdev->dev.dma_mask)
-                pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
-        if (!pdev->dev.coherent_dma_mask)
-                pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        retval = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (retval)
+                goto fail;
 
         usbh_clk = devm_clk_get(&pdev->dev, NULL);
         if (IS_ERR(usbh_clk)) {
diff --git a/drivers/usb/host/ehci-tegra.c b/drivers/usb/host/ehci-tegra.c
index e6d8e26e48cc..b9fd0396011e 100644
--- a/drivers/usb/host/ehci-tegra.c
+++ b/drivers/usb/host/ehci-tegra.c
@@ -362,10 +362,9 @@ static int tegra_ehci_probe(struct platform_device *pdev)
          * Since shared usb code relies on it, set it here for now.
          * Once we have dma capability bindings this can go away.
          */
-        if (!pdev->dev.dma_mask)
-                pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
-        if (!pdev->dev.coherent_dma_mask)
-                pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        err = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (err)
+                return err;
 
         hcd = usb_create_hcd(&tegra_ehci_hc_driver, &pdev->dev,
                                         dev_name(&pdev->dev));
diff --git a/drivers/usb/host/ohci-at91.c b/drivers/usb/host/ohci-at91.c
index 476b5a5baf25..418444ebb1b8 100644
--- a/drivers/usb/host/ohci-at91.c
+++ b/drivers/usb/host/ohci-at91.c
@@ -469,7 +469,7 @@ MODULE_DEVICE_TABLE(of, at91_ohci_dt_ids);
 static int ohci_at91_of_init(struct platform_device *pdev)
 {
         struct device_node *np = pdev->dev.of_node;
-        int i, gpio;
+        int i, gpio, ret;
         enum of_gpio_flags flags;
         struct at91_usbh_data   *pdata;
         u32 ports;
@@ -481,10 +481,9 @@ static int ohci_at91_of_init(struct platform_device *pdev)
          * Since shared usb code relies on it, set it here for now.
          * Once we have dma capability bindings this can go away.
          */
-        if (!pdev->dev.dma_mask)
-                pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
-        if (!pdev->dev.coherent_dma_mask)
-                pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        ret = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (ret)
+                return ret;
 
         pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
         if (!pdata)
diff --git a/drivers/usb/host/ohci-exynos.c b/drivers/usb/host/ohci-exynos.c
index a87baedc0aa7..91ec9b2cd378 100644
--- a/drivers/usb/host/ohci-exynos.c
+++ b/drivers/usb/host/ohci-exynos.c
@@ -71,10 +71,9 @@ static int exynos_ohci_probe(struct platform_device *pdev)
          * Since shared usb code relies on it, set it here for now.
          * Once we move to full device tree support this will vanish off.
          */
-        if (!pdev->dev.dma_mask)
-                pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
-        if (!pdev->dev.coherent_dma_mask)
-                pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        err = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (err)
+                return err;
 
         hcd = usb_create_hcd(&exynos_ohci_hc_driver,
                                 &pdev->dev, dev_name(&pdev->dev));
diff --git a/drivers/usb/host/ohci-nxp.c b/drivers/usb/host/ohci-nxp.c
index 9ab7e24ba65d..e99db8a6d55f 100644
--- a/drivers/usb/host/ohci-nxp.c
+++ b/drivers/usb/host/ohci-nxp.c
@@ -181,8 +181,9 @@ static int ohci_hcd_nxp_probe(struct platform_device *pdev)
                 return -EPROBE_DEFER;
         }
 
-        pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
-        pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
+        ret = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (ret)
+                goto fail_disable;
 
         dev_dbg(&pdev->dev, "%s: " DRIVER_DESC " (nxp)\n", hcd_name);
         if (usb_disabled()) {
diff --git a/drivers/usb/host/ohci-octeon.c b/drivers/usb/host/ohci-octeon.c
index 342dc7e543b8..6c16dcef15c6 100644
--- a/drivers/usb/host/ohci-octeon.c
+++ b/drivers/usb/host/ohci-octeon.c
@@ -127,8 +127,9 @@ static int ohci_octeon_drv_probe(struct platform_device *pdev)
         }
 
         /* Ohci is a 32-bit device. */
-        pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
-        pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
+        ret = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (ret)
+                return ret;
 
         hcd = usb_create_hcd(&ohci_octeon_hc_driver, &pdev->dev, "octeon");
         if (!hcd)
diff --git a/drivers/usb/host/ohci-omap3.c b/drivers/usb/host/ohci-omap3.c
index 408d06a68571..21457417a856 100644
--- a/drivers/usb/host/ohci-omap3.c
+++ b/drivers/usb/host/ohci-omap3.c
@@ -65,7 +65,7 @@ static int ohci_hcd_omap3_probe(struct platform_device *pdev)
         struct usb_hcd          *hcd = NULL;
         void __iomem            *regs = NULL;
         struct resource         *res;
-        int                     ret = -ENODEV;
+        int                     ret;
         int                     irq;
 
         if (usb_disabled())
@@ -99,11 +99,11 @@ static int ohci_hcd_omap3_probe(struct platform_device *pdev)
          * Since shared usb code relies on it, set it here for now.
          * Once we have dma capability bindings this can go away.
          */
-        if (!dev->dma_mask)
-                dev->dma_mask = &dev->coherent_dma_mask;
-        if (!dev->coherent_dma_mask)
-                dev->coherent_dma_mask = DMA_BIT_MASK(32);
+        ret = dma_coerce_mask_and_coherent(dev, DMA_BIT_MASK(32));
+        if (ret)
+                goto err_io;
 
+        ret = -ENODEV;
         hcd = usb_create_hcd(&ohci_omap3_hc_driver, dev,
                         dev_name(dev));
         if (!hcd) {
diff --git a/drivers/usb/host/ohci-pxa27x.c b/drivers/usb/host/ohci-pxa27x.c
index deea5d1d6394..e89ac4d4b87e 100644
--- a/drivers/usb/host/ohci-pxa27x.c
+++ b/drivers/usb/host/ohci-pxa27x.c
@@ -298,6 +298,7 @@ static int ohci_pxa_of_init(struct platform_device *pdev)
         struct device_node *np = pdev->dev.of_node;
         struct pxaohci_platform_data *pdata;
         u32 tmp;
+        int ret;
 
         if (!np)
                 return 0;
@@ -306,10 +307,9 @@ static int ohci_pxa_of_init(struct platform_device *pdev)
          * Since shared usb code relies on it, set it here for now.
          * Once we have dma capability bindings this can go away.
          */
-        if (!pdev->dev.dma_mask)
-                pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
-        if (!pdev->dev.coherent_dma_mask)
-                pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        ret = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (ret)
+                return ret;
 
         pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
         if (!pdata)
diff --git a/drivers/usb/host/ohci-sa1111.c b/drivers/usb/host/ohci-sa1111.c
index 17b2a7dad77b..aa9e127bbe71 100644
--- a/drivers/usb/host/ohci-sa1111.c
+++ b/drivers/usb/host/ohci-sa1111.c
@@ -185,6 +185,12 @@ static int ohci_hcd_sa1111_probe(struct sa1111_dev *dev)
         if (usb_disabled())
                 return -ENODEV;
 
+        /*
+         * We don't call dma_set_mask_and_coherent() here because the
+         * DMA mask has already been appropraitely setup by the core
+         * SA-1111 bus code (which includes bug workarounds.)
+         */
+
         hcd = usb_create_hcd(&ohci_sa1111_hc_driver, &dev->dev, "sa1111");
         if (!hcd)
                 return -ENOMEM;
diff --git a/drivers/usb/host/ohci-spear.c b/drivers/usb/host/ohci-spear.c
index 31ff3fc4e26f..6b02107d281d 100644
--- a/drivers/usb/host/ohci-spear.c
+++ b/drivers/usb/host/ohci-spear.c
@@ -56,10 +56,9 @@ static int spear_ohci_hcd_drv_probe(struct platform_device *pdev)
          * Since shared usb code relies on it, set it here for now.
          * Once we have dma capability bindings this can go away.
          */
-        if (!pdev->dev.dma_mask)
-                pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
-        if (!pdev->dev.coherent_dma_mask)
-                pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        retval = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (retval)
+                goto fail;
 
         usbh_clk = devm_clk_get(&pdev->dev, NULL);
         if (IS_ERR(usbh_clk)) {
diff --git a/drivers/usb/host/ssb-hcd.c b/drivers/usb/host/ssb-hcd.c
index 74af2c6287d2..0196f766df73 100644
--- a/drivers/usb/host/ssb-hcd.c
+++ b/drivers/usb/host/ssb-hcd.c
@@ -163,8 +163,7 @@ static int ssb_hcd_probe(struct ssb_device *dev,
 
         /* TODO: Probably need checks here; is the core connected? */
 
-        if (dma_set_mask(dev->dma_dev, DMA_BIT_MASK(32)) ||
-            dma_set_coherent_mask(dev->dma_dev, DMA_BIT_MASK(32)))
+        if (dma_set_mask_and_coherent(dev->dma_dev, DMA_BIT_MASK(32)))
                 return -EOPNOTSUPP;
 
         usb_dev = kzalloc(sizeof(struct ssb_hcd_device), GFP_KERNEL);
diff --git a/drivers/usb/host/uhci-platform.c b/drivers/usb/host/uhci-platform.c
index ded842bc6578..3003fefaa964 100644
--- a/drivers/usb/host/uhci-platform.c
+++ b/drivers/usb/host/uhci-platform.c
@@ -75,10 +75,9 @@ static int uhci_hcd_platform_probe(struct platform_device *pdev)
          * Since shared usb code relies on it, set it here for now.
          * Once we have dma capability bindings this can go away.
          */
-        if (!pdev->dev.dma_mask)
-                pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask;
-        if (!pdev->dev.coherent_dma_mask)
-                pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
+        ret = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
+        if (ret)
+                return ret;
 
         hcd = usb_create_hcd(&uhci_platform_hc_driver, &pdev->dev,
                         pdev->name);
diff --git a/drivers/usb/serial/mos7720.c b/drivers/usb/serial/mos7720.c
index 84657e07dc5d..439c951f261b 100644
--- a/drivers/usb/serial/mos7720.c
+++ b/drivers/usb/serial/mos7720.c
@@ -455,7 +455,7 @@ static int parport_prologue(struct parport *pp)
                 return -1;
         }
         mos_parport->msg_pending = true;   /* synch usb call pending */
-        INIT_COMPLETION(mos_parport->syncmsg_compl);
+        reinit_completion(&mos_parport->syncmsg_compl);
         spin_unlock(&release_lock);
 
         mutex_lock(&mos_parport->serial->disc_mutex);