Merge branch 3.13-rc4 into usb-next

112 files changed, 955 insertions, 944 deletions

diff --git a/drivers/usb/atm/usbatm.c b/drivers/usb/atm/usbatm.c
index 25a7bfcf666c..dada0146cd7f 100644
--- a/drivers/usb/atm/usbatm.c
+++ b/drivers/usb/atm/usbatm.c
@@ -170,9 +170,9 @@ struct usbatm_control {
 static void usbatm_atm_dev_close(struct atm_dev *atm_dev);
 static int usbatm_atm_open(struct atm_vcc *vcc);
 static void usbatm_atm_close(struct atm_vcc *vcc);
-static int usbatm_atm_ioctl(struct atm_dev *atm_dev, unsigned int cmd, void __user * arg);
+static int usbatm_atm_ioctl(struct atm_dev *atm_dev, unsigned int cmd, void __user *arg);
 static int usbatm_atm_send(struct atm_vcc *vcc, struct sk_buff *skb);
-static int usbatm_atm_proc_read(struct atm_dev *atm_dev, loff_t * pos, char *page);
+static int usbatm_atm_proc_read(struct atm_dev *atm_dev, loff_t *pos, char *page);
 
 static struct atmdev_ops usbatm_atm_devops = {
         .dev_close      = usbatm_atm_dev_close,
@@ -739,7 +739,7 @@ static void usbatm_atm_dev_close(struct atm_dev *atm_dev)
         usbatm_put_instance(instance);  /* taken in usbatm_atm_init */
 }
 
-static int usbatm_atm_proc_read(struct atm_dev *atm_dev, loff_t * pos, char *page)
+static int usbatm_atm_proc_read(struct atm_dev *atm_dev, loff_t *pos, char *page)
 {
         struct usbatm_data *instance = atm_dev->dev_data;
         int left = *pos;
@@ -895,7 +895,7 @@ static void usbatm_atm_close(struct atm_vcc *vcc)
 }
 
 static int usbatm_atm_ioctl(struct atm_dev *atm_dev, unsigned int cmd,
-                          void __user * arg)
+                          void __user *arg)
 {
         struct usbatm_data *instance = atm_dev->dev_data;
 
diff --git a/drivers/usb/c67x00/c67x00-hcd.c b/drivers/usb/c67x00/c67x00-hcd.c
index 75e47b860a53..20ec4eee1ac8 100644
--- a/drivers/usb/c67x00/c67x00-hcd.c
+++ b/drivers/usb/c67x00/c67x00-hcd.c
@@ -384,6 +384,8 @@ int c67x00_hcd_probe(struct c67x00_sie *sie)
                 goto err2;
         }
 
+        device_wakeup_enable(hcd->self.controller);
+
         spin_lock_irqsave(&sie->lock, flags);
         sie->private_data = c67x00;
         sie->irq = c67x00_hcd_irq;
diff --git a/drivers/usb/chipidea/Makefile b/drivers/usb/chipidea/Makefile
index a99d980454a6..7345d2115af2 100644
--- a/drivers/usb/chipidea/Makefile
+++ b/drivers/usb/chipidea/Makefile
@@ -17,5 +17,5 @@ ifneq ($(CONFIG_PCI),)
 endif
 
 ifneq ($(CONFIG_OF),)
-        obj-$(CONFIG_USB_CHIPIDEA)      += ci_hdrc_imx.o usbmisc_imx.o
+        obj-$(CONFIG_USB_CHIPIDEA)      += usbmisc_imx.o ci_hdrc_imx.o
 endif
diff --git a/drivers/usb/chipidea/ci_hdrc_pci.c b/drivers/usb/chipidea/ci_hdrc_pci.c
index d514332ac081..241ae3444fde 100644
--- a/drivers/usb/chipidea/ci_hdrc_pci.c
+++ b/drivers/usb/chipidea/ci_hdrc_pci.c
@@ -112,7 +112,7 @@ static void ci_hdrc_pci_remove(struct pci_dev *pdev)
  *
  * Check "pci.h" for details
  */
-static DEFINE_PCI_DEVICE_TABLE(ci_hdrc_pci_id_table) = {
+static const struct pci_device_id ci_hdrc_pci_id_table[] = {
         {
                 PCI_DEVICE(0x153F, 0x1004),
                 .driver_data = (kernel_ulong_t)&pci_platdata,
diff --git a/drivers/usb/chipidea/core.c b/drivers/usb/chipidea/core.c
index 5d8981c5235e..50754073fae0 100644
--- a/drivers/usb/chipidea/core.c
+++ b/drivers/usb/chipidea/core.c
@@ -208,7 +208,8 @@ static int hw_device_init(struct ci_hdrc *ci, void __iomem *base)
         reg = hw_read(ci, CAP_HCCPARAMS, HCCPARAMS_LEN) >>
                 __ffs(HCCPARAMS_LEN);
         ci->hw_bank.lpm  = reg;
-        hw_alloc_regmap(ci, !!reg);
+        if (reg)
+                hw_alloc_regmap(ci, !!reg);
         ci->hw_bank.size = ci->hw_bank.op - ci->hw_bank.abs;
         ci->hw_bank.size += OP_LAST;
         ci->hw_bank.size /= sizeof(u32);
diff --git a/drivers/usb/chipidea/host.c b/drivers/usb/chipidea/host.c
index 59e6020ea753..526cd77563d8 100644
--- a/drivers/usb/chipidea/host.c
+++ b/drivers/usb/chipidea/host.c
@@ -88,7 +88,8 @@ static int host_start(struct ci_hdrc *ci)
         return ret;
 
 disable_reg:
-        regulator_disable(ci->platdata->reg_vbus);
+        if (ci->platdata->reg_vbus)
+                regulator_disable(ci->platdata->reg_vbus);
 
 put_hcd:
         usb_put_hcd(hcd);
diff --git a/drivers/usb/chipidea/usbmisc_imx.c b/drivers/usb/chipidea/usbmisc_imx.c
index 8a1094b1182f..cd061abe3507 100644
--- a/drivers/usb/chipidea/usbmisc_imx.c
+++ b/drivers/usb/chipidea/usbmisc_imx.c
@@ -21,6 +21,10 @@
 #define MX25_USB_PHY_CTRL_OFFSET        0x08
 #define MX25_BM_EXTERNAL_VBUS_DIVIDER   BIT(23)
 
+#define MX27_H1_PM_BIT                  BIT(8)
+#define MX27_H2_PM_BIT                  BIT(16)
+#define MX27_OTG_PM_BIT                 BIT(24)
+
 #define MX53_USB_OTG_PHY_CTRL_0_OFFSET  0x08
 #define MX53_USB_UH2_CTRL_OFFSET        0x14
 #define MX53_USB_UH3_CTRL_OFFSET        0x18
@@ -68,6 +72,36 @@ static int usbmisc_imx25_post(struct imx_usbmisc_data *data)
         return 0;
 }
 
+static int usbmisc_imx27_init(struct imx_usbmisc_data *data)
+{
+        unsigned long flags;
+        u32 val;
+
+        switch (data->index) {
+        case 0:
+                val = MX27_OTG_PM_BIT;
+                break;
+        case 1:
+                val = MX27_H1_PM_BIT;
+                break;
+        case 2:
+                val = MX27_H2_PM_BIT;
+                break;
+        default:
+                return -EINVAL;
+        };
+
+        spin_lock_irqsave(&usbmisc->lock, flags);
+        if (data->disable_oc)
+                val = readl(usbmisc->base) | val;
+        else
+                val = readl(usbmisc->base) & ~val;
+        writel(val, usbmisc->base);
+        spin_unlock_irqrestore(&usbmisc->lock, flags);
+
+        return 0;
+}
+
 static int usbmisc_imx53_init(struct imx_usbmisc_data *data)
 {
         void __iomem *reg = NULL;
@@ -128,6 +162,10 @@ static const struct usbmisc_ops imx25_usbmisc_ops = {
         .post = usbmisc_imx25_post,
 };
 
+static const struct usbmisc_ops imx27_usbmisc_ops = {
+        .init = usbmisc_imx27_init,
+};
+
 static const struct usbmisc_ops imx53_usbmisc_ops = {
         .init = usbmisc_imx53_init,
 };
@@ -162,6 +200,14 @@ static const struct of_device_id usbmisc_imx_dt_ids[] = {
                 .data = &imx25_usbmisc_ops,
         },
         {
+                .compatible = "fsl,imx27-usbmisc",
+                .data = &imx27_usbmisc_ops,
+        },
+        {
+                .compatible = "fsl,imx51-usbmisc",
+                .data = &imx53_usbmisc_ops,
+        },
+        {
                 .compatible = "fsl,imx53-usbmisc",
                 .data = &imx53_usbmisc_ops,
         },
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index e8404319ca68..900f7ff805ee 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -262,6 +262,7 @@ static void acm_ctrl_irq(struct urb *urb)
         struct usb_cdc_notification *dr = urb->transfer_buffer;
         unsigned char *data;
         int newctrl;
+        int difference;
         int retval;
         int status = urb->status;
 
@@ -302,20 +303,31 @@ static void acm_ctrl_irq(struct urb *urb)
                         tty_port_tty_hangup(&acm->port, false);
                 }
 
+                difference = acm->ctrlin ^ newctrl;
+                spin_lock(&acm->read_lock);
                 acm->ctrlin = newctrl;
+                acm->oldcount = acm->iocount;
+
+                if (difference & ACM_CTRL_DSR)
+                        acm->iocount.dsr++;
+                if (difference & ACM_CTRL_BRK)
+                        acm->iocount.brk++;
+                if (difference & ACM_CTRL_RI)
+                        acm->iocount.rng++;
+                if (difference & ACM_CTRL_DCD)
+                        acm->iocount.dcd++;
+                if (difference & ACM_CTRL_FRAMING)
+                        acm->iocount.frame++;
+                if (difference & ACM_CTRL_PARITY)
+                        acm->iocount.parity++;
+                if (difference & ACM_CTRL_OVERRUN)
+                        acm->iocount.overrun++;
+                spin_unlock(&acm->read_lock);
+
+                if (difference)
+                        wake_up_all(&acm->wioctl);
 
-                dev_dbg(&acm->control->dev,
-                        "%s - input control lines: dcd%c dsr%c break%c "
-                        "ring%c framing%c parity%c overrun%c\n",
-                        __func__,
-                        acm->ctrlin & ACM_CTRL_DCD ? '+' : '-',
-                        acm->ctrlin & ACM_CTRL_DSR ? '+' : '-',
-                        acm->ctrlin & ACM_CTRL_BRK ? '+' : '-',
-                        acm->ctrlin & ACM_CTRL_RI  ? '+' : '-',
-                        acm->ctrlin & ACM_CTRL_FRAMING ? '+' : '-',
-                        acm->ctrlin & ACM_CTRL_PARITY ? '+' : '-',
-                        acm->ctrlin & ACM_CTRL_OVERRUN ? '+' : '-');
-                        break;
+                break;
 
         default:
                 dev_dbg(&acm->control->dev,
@@ -796,6 +808,72 @@ static int set_serial_info(struct acm *acm,
         return retval;
 }
 
+static int wait_serial_change(struct acm *acm, unsigned long arg)
+{
+        int rv = 0;
+        DECLARE_WAITQUEUE(wait, current);
+        struct async_icount old, new;
+
+        if (arg & (TIOCM_DSR | TIOCM_RI | TIOCM_CD ))
+                return -EINVAL;
+        do {
+                spin_lock_irq(&acm->read_lock);
+                old = acm->oldcount;
+                new = acm->iocount;
+                acm->oldcount = new;
+                spin_unlock_irq(&acm->read_lock);
+
+                if ((arg & TIOCM_DSR) &&
+                        old.dsr != new.dsr)
+                        break;
+                if ((arg & TIOCM_CD)  &&
+                        old.dcd != new.dcd)
+                        break;
+                if ((arg & TIOCM_RI) &&
+                        old.rng != new.rng)
+                        break;
+
+                add_wait_queue(&acm->wioctl, &wait);
+                set_current_state(TASK_INTERRUPTIBLE);
+                schedule();
+                remove_wait_queue(&acm->wioctl, &wait);
+                if (acm->disconnected) {
+                        if (arg & TIOCM_CD)
+                                break;
+                        else
+                                rv = -ENODEV;
+                } else {
+                        if (signal_pending(current))
+                                rv = -ERESTARTSYS;
+                }
+        } while (!rv);
+
+        
+
+        return rv;
+}
+
+static int get_serial_usage(struct acm *acm,
+                            struct serial_icounter_struct __user *count)
+{
+        struct serial_icounter_struct icount;
+        int rv = 0;
+
+        memset(&icount, 0, sizeof(icount));
+        icount.dsr = acm->iocount.dsr;
+        icount.rng = acm->iocount.rng;
+        icount.dcd = acm->iocount.dcd;
+        icount.frame = acm->iocount.frame;
+        icount.overrun = acm->iocount.overrun;
+        icount.parity = acm->iocount.parity;
+        icount.brk = acm->iocount.brk;
+
+        if (copy_to_user(count, &icount, sizeof(icount)) > 0)
+                rv = -EFAULT;
+
+        return rv;
+}
+
 static int acm_tty_ioctl(struct tty_struct *tty,
                                         unsigned int cmd, unsigned long arg)
 {
@@ -809,6 +887,18 @@ static int acm_tty_ioctl(struct tty_struct *tty,
         case TIOCSSERIAL:
                 rv = set_serial_info(acm, (struct serial_struct __user *) arg);
                 break;
+        case TIOCMIWAIT:
+                rv = usb_autopm_get_interface(acm->control);
+                if (rv < 0) {
+                        rv = -EIO;
+                        break;
+                }
+                rv = wait_serial_change(acm, arg);
+                usb_autopm_put_interface(acm->control);
+                break;
+        case TIOCGICOUNT:
+                rv = get_serial_usage(acm, (struct serial_icounter_struct __user *) arg);
+                break;
         }
 
         return rv;
@@ -1167,6 +1257,7 @@ made_compressed_probe:
         acm->readsize = readsize;
         acm->rx_buflimit = num_rx_buf;
         INIT_WORK(&acm->work, acm_softint);
+        init_waitqueue_head(&acm->wioctl);
         spin_lock_init(&acm->write_lock);
         spin_lock_init(&acm->read_lock);
         mutex_init(&acm->mutex);
@@ -1383,6 +1474,7 @@ static void acm_disconnect(struct usb_interface *intf)
                 device_remove_file(&acm->control->dev,
                                 &dev_attr_iCountryCodeRelDate);
         }
+        wake_up_all(&acm->wioctl);
         device_remove_file(&acm->control->dev, &dev_attr_bmCapabilities);
         usb_set_intfdata(acm->control, NULL);
         usb_set_intfdata(acm->data, NULL);
diff --git a/drivers/usb/class/cdc-acm.h b/drivers/usb/class/cdc-acm.h
index 0f76e4af600e..e38dc785808f 100644
--- a/drivers/usb/class/cdc-acm.h
+++ b/drivers/usb/class/cdc-acm.h
@@ -106,6 +106,9 @@ struct acm {
         struct work_struct work;                        /* work queue entry for line discipline waking up */
         unsigned int ctrlin;                            /* input control lines (DCD, DSR, RI, break, overruns) */
         unsigned int ctrlout;                           /* output control lines (DTR, RTS) */
+        struct async_icount iocount;                    /* counters for control line changes */
+        struct async_icount oldcount;                   /* for comparison of counter */
+        wait_queue_head_t wioctl;                       /* for ioctl */
         unsigned int writesize;                         /* max packet size for the output bulk endpoint */
         unsigned int readsize,ctrlsize;                 /* buffer sizes for freeing */
         unsigned int minor;                             /* acm minor number */
diff --git a/drivers/usb/core/config.c b/drivers/usb/core/config.c
index a6b2cabe7930..548d1996590f 100644
--- a/drivers/usb/core/config.c
+++ b/drivers/usb/core/config.c
@@ -651,10 +651,6 @@ void usb_destroy_configuration(struct usb_device *dev)
  *
  * hub-only!! ... and only in reset path, or usb_new_device()
  * (used by real hubs and virtual root hubs)
- *
- * NOTE: if this is a WUSB device and is not authorized, we skip the
- *       whole thing. A non-authorized USB device has no
- *       configurations.
  */
 int usb_get_configuration(struct usb_device *dev)
 {
@@ -666,8 +662,6 @@ int usb_get_configuration(struct usb_device *dev)
         struct usb_config_descriptor *desc;
 
         cfgno = 0;
-        if (dev->authorized == 0)       /* Not really an error */
-                goto out_not_authorized;
         result = -ENOMEM;
         if (ncfg > USB_MAXCONFIG) {
                 dev_warn(ddev, "too many configurations: %d, "
@@ -751,7 +745,6 @@ int usb_get_configuration(struct usb_device *dev)
 
 err:
         kfree(desc);
-out_not_authorized:
         dev->descriptor.bNumConfigurations = cfgno;
 err2:
         if (result == -ENOMEM)
diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
index 47aade2a5e74..8d989b1d3dc5 100644
--- a/drivers/usb/core/driver.c
+++ b/drivers/usb/core/driver.c
@@ -839,7 +839,7 @@ int usb_register_device_driver(struct usb_device_driver *new_udriver,
                 return -ENODEV;
 
         new_udriver->drvwrap.for_devices = 1;
-        new_udriver->drvwrap.driver.name = (char *) new_udriver->name;
+        new_udriver->drvwrap.driver.name = new_udriver->name;
         new_udriver->drvwrap.driver.bus = &usb_bus_type;
         new_udriver->drvwrap.driver.probe = usb_probe_device;
         new_udriver->drvwrap.driver.remove = usb_unbind_device;
@@ -900,7 +900,7 @@ int usb_register_driver(struct usb_driver *new_driver, struct module *owner,
                 return -ENODEV;
 
         new_driver->drvwrap.for_devices = 0;
-        new_driver->drvwrap.driver.name = (char *) new_driver->name;
+        new_driver->drvwrap.driver.name = new_driver->name;
         new_driver->drvwrap.driver.bus = &usb_bus_type;
         new_driver->drvwrap.driver.probe = usb_probe_interface;
         new_driver->drvwrap.driver.remove = usb_unbind_interface;
diff --git a/drivers/usb/core/hcd-pci.c b/drivers/usb/core/hcd-pci.c
index dfe9d0f22978..d59d99347d54 100644
--- a/drivers/usb/core/hcd-pci.c
+++ b/drivers/usb/core/hcd-pci.c
@@ -282,6 +282,7 @@ int usb_hcd_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
 
         if (retval != 0)
                 goto unmap_registers;
+        device_wakeup_enable(hcd->self.controller);
 
         if (pci_dev_run_wake(dev))
                 pm_runtime_put_noidle(&dev->dev);
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 6bffb8c87bc9..6297c9e50de2 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -44,6 +44,7 @@
 
 #include <linux/usb.h>
 #include <linux/usb/hcd.h>
+#include <linux/usb/phy.h>
 
 #include "usb.h"
 
@@ -2588,6 +2589,24 @@ int usb_add_hcd(struct usb_hcd *hcd,
         int retval;
         struct usb_device *rhdev;
 
+        if (IS_ENABLED(CONFIG_USB_PHY) && !hcd->phy) {
+                struct usb_phy *phy = usb_get_phy_dev(hcd->self.controller, 0);
+
+                if (IS_ERR(phy)) {
+                        retval = PTR_ERR(phy);
+                        if (retval == -EPROBE_DEFER)
+                                return retval;
+                } else {
+                        retval = usb_phy_init(phy);
+                        if (retval) {
+                                usb_put_phy(phy);
+                                return retval;
+                        }
+                        hcd->phy = phy;
+                        hcd->remove_phy = 1;
+                }
+        }
+
         dev_info(hcd->self.controller, "%s\n", hcd->product_desc);
 
         /* Keep old behaviour if authorized_default is not in [0, 1]. */
@@ -2603,7 +2622,7 @@ int usb_add_hcd(struct usb_hcd *hcd,
          */
         if ((retval = hcd_buffer_create(hcd)) != 0) {
                 dev_dbg(hcd->self.controller, "pool alloc failed\n");
-                return retval;
+                goto err_remove_phy;
         }
 
         if ((retval = usb_register_bus(&hcd->self)) < 0)
@@ -2693,12 +2712,6 @@ int usb_add_hcd(struct usb_hcd *hcd,
         if (hcd->uses_new_polling && HCD_POLL_RH(hcd))
                 usb_hcd_poll_rh_status(hcd);
 
-        /*
-         * Host controllers don't generate their own wakeup requests;
-         * they only forward requests from the root hub.  Therefore
-         * controllers should always be enabled for remote wakeup.
-         */
-        device_wakeup_enable(hcd->self.controller);
         return retval;
 
 error_create_attr_group:
@@ -2734,6 +2747,12 @@ err_allocate_root_hub:
         usb_deregister_bus(&hcd->self);
 err_register_bus:
         hcd_buffer_destroy(hcd);
+err_remove_phy:
+        if (hcd->remove_phy && hcd->phy) {
+                usb_phy_shutdown(hcd->phy);
+                usb_put_phy(hcd->phy);
+                hcd->phy = NULL;
+        }
         return retval;
 }
 EXPORT_SYMBOL_GPL(usb_add_hcd);
@@ -2806,6 +2825,11 @@ void usb_remove_hcd(struct usb_hcd *hcd)
         usb_put_dev(hcd->self.root_hub);
         usb_deregister_bus(&hcd->self);
         hcd_buffer_destroy(hcd);
+        if (hcd->remove_phy && hcd->phy) {
+                usb_phy_shutdown(hcd->phy);
+                usb_put_phy(hcd->phy);
+                hcd->phy = NULL;
+        }
 }
 EXPORT_SYMBOL_GPL(usb_remove_hcd);
 
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index bd9dc3504b51..162e94dbed53 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -2235,17 +2235,13 @@ static int usb_enumerate_device(struct usb_device *udev)
                         return err;
                 }
         }
-        if (udev->wusb == 1 && udev->authorized == 0) {
-                udev->product = kstrdup("n/a (unauthorized)", GFP_KERNEL);
-                udev->manufacturer = kstrdup("n/a (unauthorized)", GFP_KERNEL);
-                udev->serial = kstrdup("n/a (unauthorized)", GFP_KERNEL);
-        } else {
-                /* read the standard strings and cache them if present */
-                udev->product = usb_cache_string(udev, udev->descriptor.iProduct);
-                udev->manufacturer = usb_cache_string(udev,
-                                                      udev->descriptor.iManufacturer);
-                udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);
-        }
+
+        /* read the standard strings and cache them if present */
+        udev->product = usb_cache_string(udev, udev->descriptor.iProduct);
+        udev->manufacturer = usb_cache_string(udev,
+                                              udev->descriptor.iManufacturer);
+        udev->serial = usb_cache_string(udev, udev->descriptor.iSerialNumber);
+
         err = usb_enumerate_device_otg(udev);
         if (err < 0)
                 return err;
@@ -2427,16 +2423,6 @@ int usb_deauthorize_device(struct usb_device *usb_dev)
         usb_dev->authorized = 0;
         usb_set_configuration(usb_dev, -1);
 
-        kfree(usb_dev->product);
-        usb_dev->product = kstrdup("n/a (unauthorized)", GFP_KERNEL);
-        kfree(usb_dev->manufacturer);
-        usb_dev->manufacturer = kstrdup("n/a (unauthorized)", GFP_KERNEL);
-        kfree(usb_dev->serial);
-        usb_dev->serial = kstrdup("n/a (unauthorized)", GFP_KERNEL);
-
-        usb_destroy_configuration(usb_dev);
-        usb_dev->descriptor.bNumConfigurations = 0;
-
 out_unauthorized:
         usb_unlock_device(usb_dev);
         return 0;
@@ -2464,17 +2450,7 @@ int usb_authorize_device(struct usb_device *usb_dev)
                 goto error_device_descriptor;
         }
 
-        kfree(usb_dev->product);
-        usb_dev->product = NULL;
-        kfree(usb_dev->manufacturer);
-        usb_dev->manufacturer = NULL;
-        kfree(usb_dev->serial);
-        usb_dev->serial = NULL;
-
         usb_dev->authorized = 1;
-        result = usb_enumerate_device(usb_dev);
-        if (result < 0)
-                goto error_enumerate;
         /* Choose and set the configuration.  This registers the interfaces
          * with the driver core and lets interface drivers bind to them.
          */
@@ -2490,7 +2466,6 @@ int usb_authorize_device(struct usb_device *usb_dev)
         }
         dev_info(&usb_dev->dev, "authorized to connect\n");
 
-error_enumerate:
 error_device_descriptor:
         usb_autosuspend_device(usb_dev);
 error_autoresume:
@@ -2523,6 +2498,21 @@ static unsigned hub_is_wusb(struct usb_hub *hub)
 #define HUB_LONG_RESET_TIME     200
 #define HUB_RESET_TIMEOUT       800
 
+/*
+ * "New scheme" enumeration causes an extra state transition to be
+ * exposed to an xhci host and causes USB3 devices to receive control
+ * commands in the default state.  This has been seen to cause
+ * enumeration failures, so disable this enumeration scheme for USB3
+ * devices.
+ */
+static bool use_new_scheme(struct usb_device *udev, int retry)
+{
+        if (udev->speed == USB_SPEED_SUPER)
+                return false;
+
+        return USE_NEW_SCHEME(retry);
+}
+
 static int hub_port_reset(struct usb_hub *hub, int port1,
                         struct usb_device *udev, unsigned int delay, bool warm);
 
@@ -3981,6 +3971,20 @@ static void hub_set_initial_usb2_lpm_policy(struct usb_device *udev)
         }
 }
 
+static int hub_enable_device(struct usb_device *udev)
+{
+        struct usb_hcd *hcd = bus_to_hcd(udev->bus);
+
+        if (!hcd->driver->enable_device)
+                return 0;
+        if (udev->state == USB_STATE_ADDRESS)
+                return 0;
+        if (udev->state != USB_STATE_DEFAULT)
+                return -EINVAL;
+
+        return hcd->driver->enable_device(hcd, udev);
+}
+
 /* Reset device, (re)assign address, get device descriptor.
  * Device connection must be stable, no more debouncing needed.
  * Returns device in USB_STATE_ADDRESS, except on error.
@@ -4093,7 +4097,7 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
          * this area, and this is how Linux has done it for ages.
          * Change it cautiously.
          *
-         * NOTE:  If USE_NEW_SCHEME() is true we will start by issuing
+         * NOTE:  If use_new_scheme() is true we will start by issuing
          * a 64-byte GET_DESCRIPTOR request.  This is what Windows does,
          * so it may help with some non-standards-compliant devices.
          * Otherwise we start with SET_ADDRESS and then try to read the
@@ -4101,10 +4105,17 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
          * value.
          */
         for (i = 0; i < GET_DESCRIPTOR_TRIES; (++i, msleep(100))) {
-                if (USE_NEW_SCHEME(retry_counter) && !(hcd->driver->flags & HCD_USB3)) {
+                bool did_new_scheme = false;
+
+                if (use_new_scheme(udev, retry_counter)) {
                         struct usb_device_descriptor *buf;
                         int r = 0;
 
+                        did_new_scheme = true;
+                        retval = hub_enable_device(udev);
+                        if (retval < 0)
+                                goto fail;
+
 #define GET_DESCRIPTOR_BUFSIZE  64
                         buf = kmalloc(GET_DESCRIPTOR_BUFSIZE, GFP_NOIO);
                         if (!buf) {
@@ -4193,7 +4204,11 @@ hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,
                          *  - read ep0 maxpacket even for high and low speed,
                          */
                         msleep(10);
-                        if (USE_NEW_SCHEME(retry_counter) && !(hcd->driver->flags & HCD_USB3))
+                        /* use_new_scheme() checks the speed which may have
+                         * changed since the initial look so we cache the result
+                         * in did_new_scheme
+                         */
+                        if (did_new_scheme)
                                 break;
                 }
 
diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c
index 12924dbfdc2c..8f37063c0a49 100644
--- a/drivers/usb/core/quirks.c
+++ b/drivers/usb/core/quirks.c
@@ -98,9 +98,6 @@ static const struct usb_device_id usb_quirk_list[] = {
         /* Alcor Micro Corp. Hub */
         { USB_DEVICE(0x058f, 0x9254), .driver_info = USB_QUIRK_RESET_RESUME },
 
-        /* MicroTouch Systems touchscreen */
-        { USB_DEVICE(0x0596, 0x051e), .driver_info = USB_QUIRK_RESET_RESUME },
-
         /* appletouch */
         { USB_DEVICE(0x05ac, 0x021a), .driver_info = USB_QUIRK_RESET_RESUME },
 
diff --git a/drivers/usb/core/urb.c b/drivers/usb/core/urb.c
index e62208356c89..07c58af6b5c0 100644
--- a/drivers/usb/core/urb.c
+++ b/drivers/usb/core/urb.c
@@ -492,9 +492,9 @@ int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
                 /* too small? */
                 switch (dev->speed) {
                 case USB_SPEED_WIRELESS:
-                        if (urb->interval < 6)
+                        if ((urb->interval < 6)
+                                && (xfertype == USB_ENDPOINT_XFER_INT))
                                 return -EINVAL;
-                        break;
                 default:
                         if (urb->interval <= 0)
                                 return -EINVAL;
diff --git a/drivers/usb/dwc3/dwc3-pci.c b/drivers/usb/dwc3/dwc3-pci.c
index 31443aeedcdb..665686e7c8cd 100644
--- a/drivers/usb/dwc3/dwc3-pci.c
+++ b/drivers/usb/dwc3/dwc3-pci.c
@@ -182,7 +182,7 @@ static void dwc3_pci_remove(struct pci_dev *pci)
         pci_disable_device(pci);
 }
 
-static DEFINE_PCI_DEVICE_TABLE(dwc3_pci_id_table) = {
+static const struct pci_device_id dwc3_pci_id_table[] = {
         {
                 PCI_DEVICE(PCI_VENDOR_ID_SYNOPSYS,
                                 PCI_DEVICE_ID_SYNOPSYS_HAPSUSB3),
diff --git a/drivers/usb/gadget/amd5536udc.c b/drivers/usb/gadget/amd5536udc.c
index 54a1e2954cea..f0ff4a675e9d 100644
--- a/drivers/usb/gadget/amd5536udc.c
+++ b/drivers/usb/gadget/amd5536udc.c
@@ -3338,7 +3338,7 @@ static int udc_remote_wakeup(struct udc *dev)
 }
 
 /* PCI device parameters */
-static DEFINE_PCI_DEVICE_TABLE(pci_id) = {
+static const struct pci_device_id pci_id[] = {
         {
                 PCI_DEVICE(PCI_VENDOR_ID_AMD, 0x2096),
                 .class =        (PCI_CLASS_SERIAL_USB << 8) | 0xfe,
diff --git a/drivers/usb/gadget/fsl_qe_udc.c b/drivers/usb/gadget/fsl_qe_udc.c
index 807127d56fa3..6315ee698d4d 100644
--- a/drivers/usb/gadget/fsl_qe_udc.c
+++ b/drivers/usb/gadget/fsl_qe_udc.c
@@ -2717,7 +2717,7 @@ MODULE_DEVICE_TABLE(of, qe_udc_match);
 
 static struct platform_driver udc_driver = {
         .driver = {
-                .name = (char *)driver_name,
+                .name = driver_name,
                 .owner = THIS_MODULE,
                 .of_match_table = qe_udc_match,
         },
diff --git a/drivers/usb/gadget/fsl_udc_core.c b/drivers/usb/gadget/fsl_udc_core.c
index 36ac7cfba91d..b7dea4eec32c 100644
--- a/drivers/usb/gadget/fsl_udc_core.c
+++ b/drivers/usb/gadget/fsl_udc_core.c
@@ -2666,7 +2666,7 @@ static struct platform_driver udc_driver = {
         .suspend        = fsl_udc_suspend,
         .resume         = fsl_udc_resume,
         .driver         = {
-                        .name = (char *)driver_name,
+                        .name = driver_name,
                         .owner = THIS_MODULE,
                         /* udc suspend/resume called from OTG driver */
                         .suspend = fsl_udc_otg_suspend,
diff --git a/drivers/usb/gadget/pch_udc.c b/drivers/usb/gadget/pch_udc.c
index 32d5e923750b..78a3d9289816 100644
--- a/drivers/usb/gadget/pch_udc.c
+++ b/drivers/usb/gadget/pch_udc.c
@@ -3210,7 +3210,7 @@ finished:
         return retval;
 }
 
-static DEFINE_PCI_DEVICE_TABLE(pch_udc_pcidev_id) = {
+static const struct pci_device_id pch_udc_pcidev_id[] = {
         {
                 PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_EG20T_UDC),
                 .class = (PCI_CLASS_SERIAL_USB << 8) | 0xfe,
diff --git a/drivers/usb/host/Makefile b/drivers/usb/host/Makefile
index 01e879ef3654..7530468c9a4f 100644
--- a/drivers/usb/host/Makefile
+++ b/drivers/usb/host/Makefile
@@ -2,8 +2,6 @@
 # Makefile for USB Host Controller Drivers
 #
 
-ccflags-$(CONFIG_USB_DEBUG) := -DDEBUG
-
 # tell define_trace.h where to find the xhci trace header
 CFLAGS_xhci-trace.o := -I$(src)
 
diff --git a/drivers/usb/host/ehci-atmel.c b/drivers/usb/host/ehci-atmel.c
index 284f8417eae5..ec9f7b75d497 100644
--- a/drivers/usb/host/ehci-atmel.c
+++ b/drivers/usb/host/ehci-atmel.c
@@ -153,6 +153,7 @@ static int ehci_atmel_drv_probe(struct platform_device *pdev)
         retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (retval)
                 goto fail_add_hcd;
+        device_wakeup_enable(hcd->self.controller);
 
         return retval;
 
diff --git a/drivers/usb/host/ehci-dbg.c b/drivers/usb/host/ehci-dbg.c
index 4a9c2edbcb2b..524cbf26d992 100644
--- a/drivers/usb/host/ehci-dbg.c
+++ b/drivers/usb/host/ehci-dbg.c
@@ -18,7 +18,7 @@
 
 /* this file is part of ehci-hcd.c */
 
-#if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
+#ifdef CONFIG_DYNAMIC_DEBUG
 
 /* check the values in the HCSPARAMS register
  * (host controller _Structural_ parameters)
@@ -62,7 +62,7 @@ static inline void dbg_hcs_params (struct ehci_hcd *ehci, char *label) {}
 
 #endif
 
-#if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
+#ifdef CONFIG_DYNAMIC_DEBUG
 
 /* check the values in the HCCPARAMS register
  * (host controller _Capability_ parameters)
@@ -101,7 +101,7 @@ static inline void dbg_hcc_params (struct ehci_hcd *ehci, char *label) {}
 
 #endif
 
-#if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
+#ifdef CONFIG_DYNAMIC_DEBUG
 
 static void __maybe_unused
 dbg_qtd (const char *label, struct ehci_hcd *ehci, struct ehci_qtd *qtd)
@@ -301,7 +301,7 @@ static inline int __maybe_unused
 dbg_port_buf (char *buf, unsigned len, const char *label, int port, u32 status)
 { return 0; }
 
-#endif  /* DEBUG || CONFIG_DYNAMIC_DEBUG */
+#endif  /* CONFIG_DYNAMIC_DEBUG */
 
 /* functions have the "wrong" filename when they're output... */
 #define dbg_status(ehci, label, status) { \
@@ -818,7 +818,7 @@ static ssize_t fill_registers_buffer(struct debug_buffer *buf)
 
 #ifdef  CONFIG_PCI
         /* EHCI 0.96 and later may have "extended capabilities" */
-        if (hcd->self.controller->bus == &pci_bus_type) {
+        if (dev_is_pci(hcd->self.controller)) {
                 struct pci_dev  *pdev;
                 u32             offset, cap, cap2;
                 unsigned        count = 256/4;
diff --git a/drivers/usb/host/ehci-exynos.c b/drivers/usb/host/ehci-exynos.c
index e97c198e052f..d1d8c47777c5 100644
--- a/drivers/usb/host/ehci-exynos.c
+++ b/drivers/usb/host/ehci-exynos.c
@@ -166,6 +166,7 @@ skip_phy:
                 dev_err(&pdev->dev, "Failed to add USB HCD\n");
                 goto fail_add_hcd;
         }
+        device_wakeup_enable(hcd->self.controller);
 
         platform_set_drvdata(pdev, hcd);
 
diff --git a/drivers/usb/host/ehci-fsl.c b/drivers/usb/host/ehci-fsl.c
index a06d5012201f..854a68fa59a6 100644
--- a/drivers/usb/host/ehci-fsl.c
+++ b/drivers/usb/host/ehci-fsl.c
@@ -138,6 +138,7 @@ static int usb_hcd_fsl_probe(const struct hc_driver *driver,
         retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (retval != 0)
                 goto err4;
+        device_wakeup_enable(hcd->self.controller);
 
 #ifdef CONFIG_USB_OTG
         if (pdata->operating_mode == FSL_USB2_DR_OTG) {
@@ -413,7 +414,7 @@ static int ehci_fsl_mpc512x_drv_suspend(struct device *dev)
         struct fsl_usb2_platform_data *pdata = dev_get_platdata(dev);
         u32 tmp;
 
-#if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
+#ifdef CONFIG_DYNAMIC_DEBUG
         u32 mode = ehci_readl(ehci, hcd->regs + FSL_SOC_USB_USBMODE);
         mode &= USBMODE_CM_MASK;
         tmp = ehci_readl(ehci, hcd->regs + 0x140);      /* usbcmd */
diff --git a/drivers/usb/host/ehci-grlib.c b/drivers/usb/host/ehci-grlib.c
index b52a66ce92e8..054792c56271 100644
--- a/drivers/usb/host/ehci-grlib.c
+++ b/drivers/usb/host/ehci-grlib.c
@@ -140,6 +140,7 @@ static int ehci_hcd_grlib_probe(struct platform_device *op)
         if (rv)
                 goto err_ioremap;
 
+        device_wakeup_enable(hcd->self.controller);
         return 0;
 
 err_ioremap:
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index e8ba4c44223a..471142725ffe 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -71,7 +71,6 @@
 static const char       hcd_name [] = "ehci_hcd";
 
 
-#undef VERBOSE_DEBUG
 #undef EHCI_URB_TRACE
 
 /* magic numbers that can affect system performance */
@@ -714,13 +713,6 @@ static irqreturn_t ehci_irq (struct usb_hcd *hcd)
         cmd = ehci_readl(ehci, &ehci->regs->command);
         bh = 0;
 
-#ifdef  VERBOSE_DEBUG
-        /* unrequested/ignored: Frame List Rollover */
-        dbg_status (ehci, "irq", status);
-#endif
-
-        /* INT, ERR, and IAA interrupt rates can be throttled */
-
         /* normal [4.15.1.2] or error [4.15.1.1] completion */
         if (likely ((status & (STS_INT|STS_ERR)) != 0)) {
                 if (likely ((status & STS_ERR) == 0))
@@ -1320,7 +1312,7 @@ static int __init ehci_hcd_init(void)
                  sizeof(struct ehci_qh), sizeof(struct ehci_qtd),
                  sizeof(struct ehci_itd), sizeof(struct ehci_sitd));
 
-#if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
+#ifdef CONFIG_DYNAMIC_DEBUG
         ehci_debug_root = debugfs_create_dir("ehci", usb_debug_root);
         if (!ehci_debug_root) {
                 retval = -ENOENT;
@@ -1369,7 +1361,7 @@ clean2:
         platform_driver_unregister(&PLATFORM_DRIVER);
 clean0:
 #endif
-#if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
+#ifdef CONFIG_DYNAMIC_DEBUG
         debugfs_remove(ehci_debug_root);
         ehci_debug_root = NULL;
 err_debug:
@@ -1393,7 +1385,7 @@ static void __exit ehci_hcd_cleanup(void)
 #ifdef PS3_SYSTEM_BUS_DRIVER
         ps3_ehci_driver_unregister(&PS3_SYSTEM_BUS_DRIVER);
 #endif
-#if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
+#ifdef CONFIG_DYNAMIC_DEBUG
         debugfs_remove(ehci_debug_root);
 #endif
         clear_bit(USB_EHCI_LOADED, &usb_hcds_loaded);
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index 835fc0844a66..47b858fc50b2 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -1114,10 +1114,8 @@ static int ehci_hub_control (
                 if (test_bit(wIndex, &ehci->port_c_suspend))
                         status |= USB_PORT_STAT_C_SUSPEND << 16;
 
-#ifndef VERBOSE_DEBUG
-        if (status & ~0xffff)   /* only if wPortChange is interesting */
-#endif
-                dbg_port (ehci, "GetStatus", wIndex + 1, temp);
+                if (status & ~0xffff)   /* only if wPortChange is interesting */
+                        dbg_port(ehci, "GetStatus", wIndex + 1, temp);
                 put_unaligned_le32(status, buf);
                 break;
         case SetHubFeature:
diff --git a/drivers/usb/host/ehci-mv.c b/drivers/usb/host/ehci-mv.c
index 417c10da9450..bd61612a7251 100644
--- a/drivers/usb/host/ehci-mv.c
+++ b/drivers/usb/host/ehci-mv.c
@@ -178,7 +178,7 @@ static int mv_ehci_probe(struct platform_device *pdev)
 
         ehci_mv->phy_regs = devm_ioremap(&pdev->dev, r->start,
                                          resource_size(r));
-        if (ehci_mv->phy_regs == 0) {
+        if (!ehci_mv->phy_regs) {
                 dev_err(&pdev->dev, "failed to map phy I/O memory\n");
                 retval = -EFAULT;
                 goto err_put_hcd;
@@ -257,6 +257,7 @@ static int mv_ehci_probe(struct platform_device *pdev)
                                 "failed to add hcd with err %d\n", retval);
                         goto err_set_vbus;
                 }
+                device_wakeup_enable(hcd->self.controller);
         }
 
         if (pdata->private_init)
diff --git a/drivers/usb/host/ehci-mxc.c b/drivers/usb/host/ehci-mxc.c
index 0528dc4526c8..dbe5e4eea08d 100644
--- a/drivers/usb/host/ehci-mxc.c
+++ b/drivers/usb/host/ehci-mxc.c
@@ -155,6 +155,7 @@ static int ehci_mxc_drv_probe(struct platform_device *pdev)
         if (ret)
                 goto err_add;
 
+        device_wakeup_enable(hcd->self.controller);
         return 0;
 
 err_add:
diff --git a/drivers/usb/host/ehci-octeon.c b/drivers/usb/host/ehci-octeon.c
index 4c528b2c033a..c4ad7ed6b3f8 100644
--- a/drivers/usb/host/ehci-octeon.c
+++ b/drivers/usb/host/ehci-octeon.c
@@ -158,6 +158,7 @@ static int ehci_octeon_drv_probe(struct platform_device *pdev)
                 dev_dbg(&pdev->dev, "failed to add hcd with err %d\n", ret);
                 goto err3;
         }
+        device_wakeup_enable(hcd->self.controller);
 
         platform_set_drvdata(pdev, hcd);
 
diff --git a/drivers/usb/host/ehci-omap.c b/drivers/usb/host/ehci-omap.c
index 6fa82d6b7661..a24720beb39d 100644
--- a/drivers/usb/host/ehci-omap.c
+++ b/drivers/usb/host/ehci-omap.c
@@ -215,6 +215,7 @@ static int ehci_hcd_omap_probe(struct platform_device *pdev)
                 dev_err(dev, "failed to add hcd with err %d\n", ret);
                 goto err_pm_runtime;
         }
+        device_wakeup_enable(hcd->self.controller);
 
         /*
          * Bring PHYs out of reset for non PHY modes.
diff --git a/drivers/usb/host/ehci-orion.c b/drivers/usb/host/ehci-orion.c
index 2ba76730e650..aa8b92bf5361 100644
--- a/drivers/usb/host/ehci-orion.c
+++ b/drivers/usb/host/ehci-orion.c
@@ -252,6 +252,7 @@ static int ehci_orion_drv_probe(struct platform_device *pdev)
         if (err)
                 goto err4;
 
+        device_wakeup_enable(hcd->self.controller);
         return 0;
 
 err4:
diff --git a/drivers/usb/host/ehci-platform.c b/drivers/usb/host/ehci-platform.c
index 7f30b7168d5a..01536cfd361d 100644
--- a/drivers/usb/host/ehci-platform.c
+++ b/drivers/usb/host/ehci-platform.c
@@ -132,6 +132,7 @@ static int ehci_platform_probe(struct platform_device *dev)
         if (err)
                 goto err_put_hcd;
 
+        device_wakeup_enable(hcd->self.controller);
         platform_set_drvdata(dev, hcd);
 
         return err;
diff --git a/drivers/usb/host/ehci-pmcmsp.c b/drivers/usb/host/ehci-pmcmsp.c
index 893b707f0000..af3974a5e7c2 100644
--- a/drivers/usb/host/ehci-pmcmsp.c
+++ b/drivers/usb/host/ehci-pmcmsp.c
@@ -210,8 +210,10 @@ int usb_hcd_msp_probe(const struct hc_driver *driver,
 
 
         retval = usb_add_hcd(hcd, res->start, IRQF_SHARED);
-        if (retval == 0)
+        if (retval == 0) {
+                device_wakeup_enable(hcd->self.controller);
                 return 0;
+        }
 
         usb_remove_hcd(hcd);
 err3:
diff --git a/drivers/usb/host/ehci-ppc-of.c b/drivers/usb/host/ehci-ppc-of.c
index 875d2fcc9e0e..b0965eb6c0db 100644
--- a/drivers/usb/host/ehci-ppc-of.c
+++ b/drivers/usb/host/ehci-ppc-of.c
@@ -169,6 +169,7 @@ static int ehci_hcd_ppc_of_probe(struct platform_device *op)
         if (rv)
                 goto err_ioremap;
 
+        device_wakeup_enable(hcd->self.controller);
         return 0;
 
 err_ioremap:
diff --git a/drivers/usb/host/ehci-ps3.c b/drivers/usb/host/ehci-ps3.c
index 8188542ba17e..7934ff9b35e1 100644
--- a/drivers/usb/host/ehci-ps3.c
+++ b/drivers/usb/host/ehci-ps3.c
@@ -189,6 +189,7 @@ static int ps3_ehci_probe(struct ps3_system_bus_device *dev)
                 goto fail_add_hcd;
         }
 
+        device_wakeup_enable(hcd->self.controller);
         return result;
 
 fail_add_hcd:
diff --git a/drivers/usb/host/ehci-q.c b/drivers/usb/host/ehci-q.c
index db05bd8ee9d5..54f5332f814d 100644
--- a/drivers/usb/host/ehci-q.c
+++ b/drivers/usb/host/ehci-q.c
@@ -168,13 +168,13 @@ static void ehci_clear_tt_buffer(struct ehci_hcd *ehci, struct ehci_qh *qh,
          * Note: this routine is never called for Isochronous transfers.
          */
         if (urb->dev->tt && !usb_pipeint(urb->pipe) && !qh->clearing_tt) {
-#if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
+#ifdef CONFIG_DYNAMIC_DEBUG
                 struct usb_device *tt = urb->dev->tt->hub;
                 dev_dbg(&tt->dev,
                         "clear tt buffer port %d, a%d ep%d t%08x\n",
                         urb->dev->ttport, urb->dev->devnum,
                         usb_pipeendpoint(urb->pipe), token);
-#endif /* DEBUG || CONFIG_DYNAMIC_DEBUG */
+#endif /* CONFIG_DYNAMIC_DEBUG */
                 if (!ehci_is_TDI(ehci)
                                 || urb->dev->tt->hub !=
                                    ehci_to_hcd(ehci)->self.root_hub) {
diff --git a/drivers/usb/host/ehci-sead3.c b/drivers/usb/host/ehci-sead3.c
index 8a734498079b..cf1267673868 100644
--- a/drivers/usb/host/ehci-sead3.c
+++ b/drivers/usb/host/ehci-sead3.c
@@ -126,6 +126,7 @@ static int ehci_hcd_sead3_drv_probe(struct platform_device *pdev)
                           IRQF_SHARED);
         if (ret == 0) {
                 platform_set_drvdata(pdev, hcd);
+                device_wakeup_enable(hcd->self.controller);
                 return ret;
         }
 
diff --git a/drivers/usb/host/ehci-sh.c b/drivers/usb/host/ehci-sh.c
index dc899eb2b861..9b9b9f5b016e 100644
--- a/drivers/usb/host/ehci-sh.c
+++ b/drivers/usb/host/ehci-sh.c
@@ -151,6 +151,7 @@ static int ehci_hcd_sh_probe(struct platform_device *pdev)
                 dev_err(&pdev->dev, "Failed to add hcd");
                 goto fail_add_hcd;
         }
+        device_wakeup_enable(hcd->self.controller);
 
         priv->hcd = hcd;
         platform_set_drvdata(pdev, priv);
diff --git a/drivers/usb/host/ehci-spear.c b/drivers/usb/host/ehci-spear.c
index ee6f9ffaa0e7..8bd915b2ae8c 100644
--- a/drivers/usb/host/ehci-spear.c
+++ b/drivers/usb/host/ehci-spear.c
@@ -130,6 +130,7 @@ static int spear_ehci_hcd_drv_probe(struct platform_device *pdev)
         if (retval)
                 goto err_stop_ehci;
 
+        device_wakeup_enable(hcd->self.controller);
         return retval;
 
 err_stop_ehci:
diff --git a/drivers/usb/host/ehci-tegra.c b/drivers/usb/host/ehci-tegra.c
index b9fd0396011e..a8f4471dae7b 100644
--- a/drivers/usb/host/ehci-tegra.c
+++ b/drivers/usb/host/ehci-tegra.c
@@ -455,6 +455,7 @@ static int tegra_ehci_probe(struct platform_device *pdev)
                 dev_err(&pdev->dev, "Failed to add USB HCD\n");
                 goto cleanup_otg_set_host;
         }
+        device_wakeup_enable(hcd->self.controller);
 
         return err;
 
diff --git a/drivers/usb/host/ehci-tilegx.c b/drivers/usb/host/ehci-tilegx.c
index 67026ffbf9a8..f3713d32c9a1 100644
--- a/drivers/usb/host/ehci-tilegx.c
+++ b/drivers/usb/host/ehci-tilegx.c
@@ -170,6 +170,7 @@ static int ehci_hcd_tilegx_drv_probe(struct platform_device *pdev)
         ret = usb_add_hcd(hcd, pdata->irq, IRQF_SHARED);
         if (ret == 0) {
                 platform_set_drvdata(pdev, hcd);
+                device_wakeup_enable(hcd->self.controller);
                 return ret;
         }
 
diff --git a/drivers/usb/host/ehci-w90x900.c b/drivers/usb/host/ehci-w90x900.c
index cdad8438c02b..12c1a563c3f2 100644
--- a/drivers/usb/host/ehci-w90x900.c
+++ b/drivers/usb/host/ehci-w90x900.c
@@ -94,6 +94,7 @@ static int usb_w90x900_probe(const struct hc_driver *driver,
         if (retval != 0)
                 goto err4;
 
+        device_wakeup_enable(hcd->self.controller);
         return retval;
 err4:
         iounmap(hcd->regs);
diff --git a/drivers/usb/host/ehci-xilinx-of.c b/drivers/usb/host/ehci-xilinx-of.c
index 95979f9f4381..3cd2efa4e678 100644
--- a/drivers/usb/host/ehci-xilinx-of.c
+++ b/drivers/usb/host/ehci-xilinx-of.c
@@ -191,8 +191,10 @@ static int ehci_hcd_xilinx_of_probe(struct platform_device *op)
         ehci->caps = hcd->regs + 0x100;
 
         rv = usb_add_hcd(hcd, irq, 0);
-        if (rv == 0)
+        if (rv == 0) {
+                device_wakeup_enable(hcd->self.controller);
                 return 0;
+        }
 
 err_irq:
         usb_put_hcd(hcd);
diff --git a/drivers/usb/host/ehci.h b/drivers/usb/host/ehci.h
index e8f41c5e771b..c35a6e2b94e5 100644
--- a/drivers/usb/host/ehci.h
+++ b/drivers/usb/host/ehci.h
@@ -38,7 +38,7 @@ typedef __u16 __bitwise __hc16;
 #endif
 
 /* statistics can be kept for tuning/monitoring */
-#if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
+#ifdef CONFIG_DYNAMIC_DEBUG
 #define EHCI_STATS
 #endif
 
@@ -248,7 +248,7 @@ struct ehci_hcd {			/* one per controller */
 #endif
 
         /* debug files */
-#if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
+#ifdef CONFIG_DYNAMIC_DEBUG
         struct dentry           *debug_dir;
 #endif
 
@@ -832,9 +832,9 @@ static inline u32 hc32_to_cpup (const struct ehci_hcd *ehci, const __hc32 *x)
         dev_warn(ehci_to_hcd(ehci)->self.controller , fmt , ## args)
 
 
-#if !defined(DEBUG) && !defined(CONFIG_DYNAMIC_DEBUG)
+#ifndef CONFIG_DYNAMIC_DEBUG
 #define STUB_DEBUG_FILES
-#endif  /* !DEBUG && !CONFIG_DYNAMIC_DEBUG */
+#endif
 
 /*-------------------------------------------------------------------------*/
 
diff --git a/drivers/usb/host/fhci-hcd.c b/drivers/usb/host/fhci-hcd.c
index 0551c0af0fd1..1cf68eaf2ed8 100644
--- a/drivers/usb/host/fhci-hcd.c
+++ b/drivers/usb/host/fhci-hcd.c
@@ -754,6 +754,8 @@ static int of_fhci_probe(struct platform_device *ofdev)
         if (ret < 0)
                 goto err_add_hcd;
 
+        device_wakeup_enable(hcd->self.controller);
+
         fhci_dfs_create(fhci);
 
         return 0;
diff --git a/drivers/usb/host/fotg210-hcd.c b/drivers/usb/host/fotg210-hcd.c
index 55486bd23cf1..98a89d16cc3e 100644
--- a/drivers/usb/host/fotg210-hcd.c
+++ b/drivers/usb/host/fotg210-hcd.c
@@ -56,12 +56,9 @@
 
 static const char       hcd_name[] = "fotg210_hcd";
 
-#undef VERBOSE_DEBUG
 #undef FOTG210_URB_TRACE
 
-#ifdef DEBUG
 #define FOTG210_STATS
-#endif
 
 /* magic numbers that can affect system performance */
 #define FOTG210_TUNE_CERR               3 /* 0-3 qtd retries; 0 == don't stop */
@@ -107,14 +104,6 @@ MODULE_PARM_DESC(hird, "host initiated resume duration, +1 for each 75us");
 #define fotg210_warn(fotg210, fmt, args...) \
         dev_warn(fotg210_to_hcd(fotg210)->self.controller , fmt , ## args)
 
-#ifdef VERBOSE_DEBUG
-#       define fotg210_vdbg fotg210_dbg
-#else
-        static inline void fotg210_vdbg(struct fotg210_hcd *fotg210, ...) {}
-#endif
-
-#ifdef  DEBUG
-
 /* check the values in the HCSPARAMS register
  * (host controller _Structural_ parameters)
  * see EHCI spec, Table 2-4 for each value
@@ -129,13 +118,6 @@ static void dbg_hcs_params(struct fotg210_hcd *fotg210, char *label)
                 HCS_N_PORTS(params)
                 );
 }
-#else
-
-static inline void dbg_hcs_params(struct fotg210_hcd *fotg210, char *label) {}
-
-#endif
-
-#ifdef  DEBUG
 
 /* check the values in the HCCPARAMS register
  * (host controller _Capability_ parameters)
@@ -152,13 +134,6 @@ static void dbg_hcc_params(struct fotg210_hcd *fotg210, char *label)
                 HCC_PGM_FRAMELISTLEN(params) ? "256/512/1024" : "1024",
                 HCC_CANPARK(params) ? " park" : "");
 }
-#else
-
-static inline void dbg_hcc_params(struct fotg210_hcd *fotg210, char *label) {}
-
-#endif
-
-#ifdef  DEBUG
 
 static void __maybe_unused
 dbg_qtd(const char *label, struct fotg210_hcd *fotg210, struct fotg210_qtd *qtd)
@@ -272,8 +247,8 @@ dbg_command_buf(char *buf, unsigned len, const char *label, u32 command)
                 );
 }
 
-static int
-dbg_port_buf(char *buf, unsigned len, const char *label, int port, u32 status)
+static char
+*dbg_port_buf(char *buf, unsigned len, const char *label, int port, u32 status)
 {
         char    *sig;
 
@@ -293,7 +268,7 @@ dbg_port_buf(char *buf, unsigned len, const char *label, int port, u32 status)
                 break;
         }
 
-        return scnprintf(buf, len,
+        scnprintf(buf, len,
                 "%s%sport:%d status %06x %d "
                 "sig=%s%s%s%s%s%s%s%s",
                 label, label[0] ? " " : "", port, status,
@@ -306,31 +281,9 @@ dbg_port_buf(char *buf, unsigned len, const char *label, int port, u32 status)
                 (status & PORT_PE) ? " PE" : "",
                 (status & PORT_CSC) ? " CSC" : "",
                 (status & PORT_CONNECT) ? " CONNECT" : "");
+        return buf;
 }
 
-#else
-static inline void __maybe_unused
-dbg_qh(char *label, struct fotg210_hcd *fotg210, struct fotg210_qh *qh)
-{}
-
-static inline int __maybe_unused
-dbg_status_buf(char *buf, unsigned len, const char *label, u32 status)
-{ return 0; }
-
-static inline int __maybe_unused
-dbg_command_buf(char *buf, unsigned len, const char *label, u32 command)
-{ return 0; }
-
-static inline int __maybe_unused
-dbg_intr_buf(char *buf, unsigned len, const char *label, u32 enable)
-{ return 0; }
-
-static inline int __maybe_unused
-dbg_port_buf(char *buf, unsigned len, const char *label, int port, u32 status)
-{ return 0; }
-
-#endif  /* DEBUG */
-
 /* functions have the "wrong" filename when they're output... */
 #define dbg_status(fotg210, label, status) { \
         char _buf[80]; \
@@ -346,19 +299,11 @@ dbg_port_buf(char *buf, unsigned len, const char *label, int port, u32 status)
 
 #define dbg_port(fotg210, label, port, status) { \
         char _buf[80]; \
-        dbg_port_buf(_buf, sizeof(_buf), label, port, status); \
-        fotg210_dbg(fotg210, "%s\n", _buf); \
+        fotg210_dbg(fotg210, "%s\n", dbg_port_buf(_buf, sizeof(_buf), label, port, status) ); \
 }
 
 /*-------------------------------------------------------------------------*/
 
-#ifdef STUB_DEBUG_FILES
-
-static inline void create_debug_files(struct fotg210_hcd *bus) { }
-static inline void remove_debug_files(struct fotg210_hcd *bus) { }
-
-#else
-
 /* troubleshooting help: expose state in debugfs */
 
 static int debug_async_open(struct inode *, struct file *);
@@ -954,7 +899,6 @@ static inline void remove_debug_files(struct fotg210_hcd *fotg210)
         debugfs_remove_recursive(fotg210->debug_dir);
 }
 
-#endif /* STUB_DEBUG_FILES */
 /*-------------------------------------------------------------------------*/
 
 /*
@@ -1398,7 +1342,7 @@ static void fotg210_iaa_watchdog(struct fotg210_hcd *fotg210)
                                        &fotg210->regs->status);
                 }
 
-                fotg210_vdbg(fotg210, "IAA watchdog: status %x cmd %x\n",
+                fotg210_dbg(fotg210, "IAA watchdog: status %x cmd %x\n",
                                 status, cmd);
                 end_unlink_async(fotg210);
         }
@@ -1810,10 +1754,8 @@ static int fotg210_hub_control(
                 if (test_bit(wIndex, &fotg210->port_c_suspend))
                         status |= USB_PORT_STAT_C_SUSPEND << 16;
 
-#ifndef VERBOSE_DEBUG
-        if (status & ~0xffff)   /* only if wPortChange is interesting */
-#endif
-                dbg_port(fotg210, "GetStatus", wIndex + 1, temp);
+                if (status & ~0xffff)   /* only if wPortChange is interesting */
+                        dbg_port(fotg210, "GetStatus", wIndex + 1, temp);
                 put_unaligned_le32(status, buf);
                 break;
         case SetHubFeature:
@@ -1856,7 +1798,7 @@ static int fotg210_hub_control(
                          * which can be fine if this root hub has a
                          * transaction translator built in.
                          */
-                        fotg210_vdbg(fotg210, "port %d reset\n", wIndex + 1);
+                        fotg210_dbg(fotg210, "port %d reset\n", wIndex + 1);
                         temp |= PORT_RESET;
                         temp &= ~PORT_PE;
 
@@ -2274,13 +2216,12 @@ static void fotg210_clear_tt_buffer(struct fotg210_hcd *fotg210,
          * Note: this routine is never called for Isochronous transfers.
          */
         if (urb->dev->tt && !usb_pipeint(urb->pipe) && !qh->clearing_tt) {
-#ifdef DEBUG
                 struct usb_device *tt = urb->dev->tt->hub;
                 dev_dbg(&tt->dev,
                         "clear tt buffer port %d, a%d ep%d t%08x\n",
                         urb->dev->ttport, urb->dev->devnum,
                         usb_pipeendpoint(urb->pipe), token);
-#endif /* DEBUG */
+
                 if (urb->dev->tt->hub !=
                     fotg210_to_hcd(fotg210)->self.root_hub) {
                         if (usb_hub_clear_tt_buffer(urb) == 0)
@@ -2341,7 +2282,7 @@ static int qtd_copy_status(
                         status = -EPROTO;
                 }
 
-                fotg210_vdbg(fotg210,
+                fotg210_dbg(fotg210,
                         "dev%d ep%d%s qtd token %08x --> status %d\n",
                         usb_pipedevice(urb->pipe),
                         usb_pipeendpoint(urb->pipe),
@@ -3583,11 +3524,9 @@ periodic_usecs(struct fotg210_hcd *fotg210, unsigned frame, unsigned uframe)
                         break;
                 }
         }
-#ifdef  DEBUG
         if (usecs > fotg210->uframe_periodic_max)
                 fotg210_err(fotg210, "uframe %d sched overrun: %d usecs\n",
                         frame * 8 + uframe, usecs);
-#endif
         return usecs;
 }
 
@@ -4646,7 +4585,7 @@ static void itd_link_urb(
         if (unlikely(list_empty(&stream->td_list))) {
                 fotg210_to_hcd(fotg210)->self.bandwidth_allocated
                                 += stream->bandwidth;
-                fotg210_vdbg(fotg210,
+                fotg210_dbg(fotg210,
                         "schedule devp %s ep%d%s-iso period %d start %d.%d\n",
                         urb->dev->devpath, stream->bEndpointAddress & 0x0f,
                         (stream->bEndpointAddress & USB_DIR_IN) ? "in" : "out",
@@ -4779,7 +4718,7 @@ static bool itd_complete(struct fotg210_hcd *fotg210, struct fotg210_itd *itd)
         if (unlikely(list_is_singular(&stream->td_list))) {
                 fotg210_to_hcd(fotg210)->self.bandwidth_allocated
                                 -= stream->bandwidth;
-                fotg210_vdbg(fotg210,
+                fotg210_dbg(fotg210,
                         "deschedule devp %s ep%d%s-iso\n",
                         dev->devpath, stream->bEndpointAddress & 0x0f,
                         (stream->bEndpointAddress & USB_DIR_IN) ? "in" : "out");
@@ -5444,10 +5383,8 @@ static irqreturn_t fotg210_irq(struct usb_hcd *hcd)
         cmd = fotg210_readl(fotg210, &fotg210->regs->command);
         bh = 0;
 
-#ifdef  VERBOSE_DEBUG
         /* unrequested/ignored: Frame List Rollover */
         dbg_status(fotg210, "irq", status);
-#endif
 
         /* INT, ERR, and IAA interrupt rates can be throttled */
 
@@ -5952,6 +5889,7 @@ static int fotg210_hcd_probe(struct platform_device *pdev)
                 dev_err(dev, "failed to add hcd with err %d\n", retval);
                 goto fail_add_hcd;
         }
+        device_wakeup_enable(hcd->self.controller);
 
         return retval;
 
@@ -6013,13 +5951,11 @@ static int __init fotg210_hcd_init(void)
                  sizeof(struct fotg210_qh), sizeof(struct fotg210_qtd),
                  sizeof(struct fotg210_itd));
 
-#ifdef DEBUG
         fotg210_debug_root = debugfs_create_dir("fotg210", usb_debug_root);
         if (!fotg210_debug_root) {
                 retval = -ENOENT;
                 goto err_debug;
         }
-#endif
 
         retval = platform_driver_register(&fotg210_hcd_driver);
         if (retval < 0)
@@ -6028,11 +5964,9 @@ static int __init fotg210_hcd_init(void)
 
         platform_driver_unregister(&fotg210_hcd_driver);
 clean:
-#ifdef DEBUG
         debugfs_remove(fotg210_debug_root);
         fotg210_debug_root = NULL;
 err_debug:
-#endif
         clear_bit(USB_EHCI_LOADED, &usb_hcds_loaded);
         return retval;
 }
@@ -6041,9 +5975,7 @@ module_init(fotg210_hcd_init);
 static void __exit fotg210_hcd_cleanup(void)
 {
         platform_driver_unregister(&fotg210_hcd_driver);
-#ifdef DEBUG
         debugfs_remove(fotg210_debug_root);
-#endif
         clear_bit(USB_EHCI_LOADED, &usb_hcds_loaded);
 }
 module_exit(fotg210_hcd_cleanup);
diff --git a/drivers/usb/host/fotg210.h b/drivers/usb/host/fotg210.h
index 8920f9d32564..ac6cd1bfd208 100644
--- a/drivers/usb/host/fotg210.h
+++ b/drivers/usb/host/fotg210.h
@@ -174,9 +174,7 @@ struct fotg210_hcd {			/* one per controller */
 #endif
 
         /* debug files */
-#ifdef DEBUG
         struct dentry           *debug_dir;
-#endif
 };
 
 /* convert between an HCD pointer and the corresponding FOTG210_HCD */
@@ -741,10 +739,4 @@ static inline unsigned fotg210_read_frame_index(struct fotg210_hcd *fotg210)
 })
 /*-------------------------------------------------------------------------*/
 
-#ifndef DEBUG
-#define STUB_DEBUG_FILES
-#endif  /* DEBUG */
-
-/*-------------------------------------------------------------------------*/
-
 #endif /* __LINUX_FOTG210_H */
diff --git a/drivers/usb/host/fusbh200-hcd.c b/drivers/usb/host/fusbh200-hcd.c
index e1c6d850a7e1..ba9499060f63 100644
--- a/drivers/usb/host/fusbh200-hcd.c
+++ b/drivers/usb/host/fusbh200-hcd.c
@@ -57,13 +57,8 @@
 
 static const char       hcd_name [] = "fusbh200_hcd";
 
-#undef VERBOSE_DEBUG
 #undef FUSBH200_URB_TRACE
 
-#ifdef DEBUG
-#define FUSBH200_STATS
-#endif
-
 /* magic numbers that can affect system performance */
 #define FUSBH200_TUNE_CERR              3       /* 0-3 qtd retries; 0 == don't stop */
 #define FUSBH200_TUNE_RL_HS             4       /* nak throttle; see 4.9 */
@@ -108,14 +103,6 @@ MODULE_PARM_DESC(hird, "host initiated resume duration, +1 for each 75us");
 #define fusbh200_warn(fusbh200, fmt, args...) \
         dev_warn (fusbh200_to_hcd(fusbh200)->self.controller , fmt , ## args )
 
-#ifdef VERBOSE_DEBUG
-#       define fusbh200_vdbg fusbh200_dbg
-#else
-        static inline void fusbh200_vdbg(struct fusbh200_hcd *fusbh200, ...) {}
-#endif
-
-#ifdef  DEBUG
-
 /* check the values in the HCSPARAMS register
  * (host controller _Structural_ parameters)
  * see EHCI spec, Table 2-4 for each value
@@ -130,13 +117,6 @@ static void dbg_hcs_params (struct fusbh200_hcd *fusbh200, char *label)
                 HCS_N_PORTS (params)
                 );
 }
-#else
-
-static inline void dbg_hcs_params (struct fusbh200_hcd *fusbh200, char *label) {}
-
-#endif
-
-#ifdef  DEBUG
 
 /* check the values in the HCCPARAMS register
  * (host controller _Capability_ parameters)
@@ -153,13 +133,6 @@ static void dbg_hcc_params (struct fusbh200_hcd *fusbh200, char *label)
                 HCC_PGM_FRAMELISTLEN(params) ? "256/512/1024" : "1024",
                 HCC_CANPARK(params) ? " park" : "");
 }
-#else
-
-static inline void dbg_hcc_params (struct fusbh200_hcd *fusbh200, char *label) {}
-
-#endif
-
-#ifdef  DEBUG
 
 static void __maybe_unused
 dbg_qtd (const char *label, struct fusbh200_hcd *fusbh200, struct fusbh200_qtd *qtd)
@@ -302,29 +275,6 @@ dbg_port_buf (char *buf, unsigned len, const char *label, int port, u32 status)
                 (status & PORT_CONNECT) ? " CONNECT" : "");
 }
 
-#else
-static inline void __maybe_unused
-dbg_qh (char *label, struct fusbh200_hcd *fusbh200, struct fusbh200_qh *qh)
-{}
-
-static inline int __maybe_unused
-dbg_status_buf (char *buf, unsigned len, const char *label, u32 status)
-{ return 0; }
-
-static inline int __maybe_unused
-dbg_command_buf (char *buf, unsigned len, const char *label, u32 command)
-{ return 0; }
-
-static inline int __maybe_unused
-dbg_intr_buf (char *buf, unsigned len, const char *label, u32 enable)
-{ return 0; }
-
-static inline int __maybe_unused
-dbg_port_buf (char *buf, unsigned len, const char *label, int port, u32 status)
-{ return 0; }
-
-#endif  /* DEBUG */
-
 /* functions have the "wrong" filename when they're output... */
 #define dbg_status(fusbh200, label, status) { \
         char _buf [80]; \
@@ -346,13 +296,6 @@ dbg_port_buf (char *buf, unsigned len, const char *label, int port, u32 status)
 
 /*-------------------------------------------------------------------------*/
 
-#ifdef STUB_DEBUG_FILES
-
-static inline void create_debug_files (struct fusbh200_hcd *bus) { }
-static inline void remove_debug_files (struct fusbh200_hcd *bus) { }
-
-#else
-
 /* troubleshooting help: expose state in debugfs */
 
 static int debug_async_open(struct inode *, struct file *);
@@ -775,7 +718,6 @@ static ssize_t fill_registers_buffer(struct debug_buffer *buf)
                 next += temp;
         }
 
-#ifdef FUSBH200_STATS
         temp = scnprintf (next, size,
                 "irq normal %ld err %ld iaa %ld (lost %ld)\n",
                 fusbh200->stats.normal, fusbh200->stats.error, fusbh200->stats.iaa,
@@ -787,7 +729,6 @@ static ssize_t fill_registers_buffer(struct debug_buffer *buf)
                 fusbh200->stats.complete, fusbh200->stats.unlink);
         size -= temp;
         next += temp;
-#endif
 
 done:
         spin_unlock_irqrestore (&fusbh200->lock, flags);
@@ -928,7 +869,6 @@ static inline void remove_debug_files (struct fusbh200_hcd *fusbh200)
         debugfs_remove_recursive(fusbh200->debug_dir);
 }
 
-#endif /* STUB_DEBUG_FILES */
 /*-------------------------------------------------------------------------*/
 
 /*
@@ -1362,7 +1302,7 @@ static void fusbh200_iaa_watchdog(struct fusbh200_hcd *fusbh200)
                         fusbh200_writel(fusbh200, STS_IAA, &fusbh200->regs->status);
                 }
 
-                fusbh200_vdbg(fusbh200, "IAA watchdog: status %x cmd %x\n",
+                fusbh200_dbg(fusbh200, "IAA watchdog: status %x cmd %x\n",
                                 status, cmd);
                 end_unlink_async(fusbh200);
         }
@@ -1769,10 +1709,8 @@ static int fusbh200_hub_control (
                 if (test_bit(wIndex, &fusbh200->port_c_suspend))
                         status |= USB_PORT_STAT_C_SUSPEND << 16;
 
-#ifndef VERBOSE_DEBUG
-        if (status & ~0xffff)   /* only if wPortChange is interesting */
-#endif
-                dbg_port (fusbh200, "GetStatus", wIndex + 1, temp);
+                if (status & ~0xffff)   /* only if wPortChange is interesting */
+                        dbg_port(fusbh200, "GetStatus", wIndex + 1, temp);
                 put_unaligned_le32(status, buf);
                 break;
         case SetHubFeature:
@@ -1814,7 +1752,7 @@ static int fusbh200_hub_control (
                          * which can be fine if this root hub has a
                          * transaction translator built in.
                          */
-                        fusbh200_vdbg (fusbh200, "port %d reset\n", wIndex + 1);
+                        fusbh200_dbg(fusbh200, "port %d reset\n", wIndex + 1);
                         temp |= PORT_RESET;
                         temp &= ~PORT_PE;
 
@@ -2230,13 +2168,13 @@ static void fusbh200_clear_tt_buffer(struct fusbh200_hcd *fusbh200, struct fusbh
          * Note: this routine is never called for Isochronous transfers.
          */
         if (urb->dev->tt && !usb_pipeint(urb->pipe) && !qh->clearing_tt) {
-#ifdef DEBUG
                 struct usb_device *tt = urb->dev->tt->hub;
+
                 dev_dbg(&tt->dev,
                         "clear tt buffer port %d, a%d ep%d t%08x\n",
                         urb->dev->ttport, urb->dev->devnum,
                         usb_pipeendpoint(urb->pipe), token);
-#endif /* DEBUG */
+
                 if (urb->dev->tt->hub !=
                     fusbh200_to_hcd(fusbh200)->self.root_hub) {
                         if (usb_hub_clear_tt_buffer(urb) == 0)
@@ -2297,7 +2235,7 @@ static int qtd_copy_status (
                         status = -EPROTO;
                 }
 
-                fusbh200_vdbg (fusbh200,
+                fusbh200_dbg(fusbh200,
                         "dev%d ep%d%s qtd token %08x --> status %d\n",
                         usb_pipedevice (urb->pipe),
                         usb_pipeendpoint (urb->pipe),
@@ -3529,11 +3467,9 @@ periodic_usecs (struct fusbh200_hcd *fusbh200, unsigned frame, unsigned uframe)
                         break;
                 }
         }
-#ifdef  DEBUG
         if (usecs > fusbh200->uframe_periodic_max)
                 fusbh200_err (fusbh200, "uframe %d sched overrun: %d usecs\n",
                         frame * 8 + uframe, usecs);
-#endif
         return usecs;
 }
 
@@ -4586,7 +4522,7 @@ static void itd_link_urb(
         if (unlikely (list_empty(&stream->td_list))) {
                 fusbh200_to_hcd(fusbh200)->self.bandwidth_allocated
                                 += stream->bandwidth;
-                fusbh200_vdbg (fusbh200,
+                fusbh200_dbg(fusbh200,
                         "schedule devp %s ep%d%s-iso period %d start %d.%d\n",
                         urb->dev->devpath, stream->bEndpointAddress & 0x0f,
                         (stream->bEndpointAddress & USB_DIR_IN) ? "in" : "out",
@@ -4717,7 +4653,7 @@ static bool itd_complete(struct fusbh200_hcd *fusbh200, struct fusbh200_itd *itd
         if (unlikely(list_is_singular(&stream->td_list))) {
                 fusbh200_to_hcd(fusbh200)->self.bandwidth_allocated
                                 -= stream->bandwidth;
-                fusbh200_vdbg (fusbh200,
+                fusbh200_dbg(fusbh200,
                         "deschedule devp %s ep%d%s-iso\n",
                         dev->devpath, stream->bEndpointAddress & 0x0f,
                         (stream->bEndpointAddress & USB_DIR_IN) ? "in" : "out");
@@ -5115,13 +5051,11 @@ static void fusbh200_stop (struct usb_hcd *hcd)
         spin_unlock_irq (&fusbh200->lock);
         fusbh200_mem_cleanup (fusbh200);
 
-#ifdef  FUSBH200_STATS
         fusbh200_dbg(fusbh200, "irq normal %ld err %ld iaa %ld (lost %ld)\n",
                 fusbh200->stats.normal, fusbh200->stats.error, fusbh200->stats.iaa,
                 fusbh200->stats.lost_iaa);
         fusbh200_dbg (fusbh200, "complete %ld unlink %ld\n",
                 fusbh200->stats.complete, fusbh200->stats.unlink);
-#endif
 
         dbg_status (fusbh200, "fusbh200_stop completed",
                     fusbh200_readl(fusbh200, &fusbh200->regs->status));
@@ -5365,13 +5299,6 @@ static irqreturn_t fusbh200_irq (struct usb_hcd *hcd)
         cmd = fusbh200_readl(fusbh200, &fusbh200->regs->command);
         bh = 0;
 
-#ifdef  VERBOSE_DEBUG
-        /* unrequested/ignored: Frame List Rollover */
-        dbg_status (fusbh200, "irq", status);
-#endif
-
-        /* INT, ERR, and IAA interrupt rates can be throttled */
-
         /* normal [4.15.1.2] or error [4.15.1.1] completion */
         if (likely ((status & (STS_INT|STS_ERR)) != 0)) {
                 if (likely ((status & STS_ERR) == 0))
@@ -5871,6 +5798,7 @@ static int fusbh200_hcd_probe(struct platform_device *pdev)
                 dev_err(dev, "failed to add hcd with err %d\n", retval);
                 goto fail_add_hcd;
         }
+        device_wakeup_enable(hcd->self.controller);
 
         return retval;
 
@@ -5936,13 +5864,11 @@ static int __init fusbh200_hcd_init(void)
                  sizeof(struct fusbh200_qh), sizeof(struct fusbh200_qtd),
                  sizeof(struct fusbh200_itd));
 
-#ifdef DEBUG
         fusbh200_debug_root = debugfs_create_dir("fusbh200", usb_debug_root);
         if (!fusbh200_debug_root) {
                 retval = -ENOENT;
                 goto err_debug;
         }
-#endif
 
         retval = platform_driver_register(&fusbh200_hcd_fusbh200_driver);
         if (retval < 0)
@@ -5951,11 +5877,9 @@ static int __init fusbh200_hcd_init(void)
 
         platform_driver_unregister(&fusbh200_hcd_fusbh200_driver);
 clean:
-#ifdef DEBUG
         debugfs_remove(fusbh200_debug_root);
         fusbh200_debug_root = NULL;
 err_debug:
-#endif
         clear_bit(USB_EHCI_LOADED, &usb_hcds_loaded);
         return retval;
 }
@@ -5964,9 +5888,7 @@ module_init(fusbh200_hcd_init);
 static void __exit fusbh200_hcd_cleanup(void)
 {
         platform_driver_unregister(&fusbh200_hcd_fusbh200_driver);
-#ifdef DEBUG
         debugfs_remove(fusbh200_debug_root);
-#endif
         clear_bit(USB_EHCI_LOADED, &usb_hcds_loaded);
 }
 module_exit(fusbh200_hcd_cleanup);
diff --git a/drivers/usb/host/fusbh200.h b/drivers/usb/host/fusbh200.h
index 797c9e855270..6b719e066c3f 100644
--- a/drivers/usb/host/fusbh200.h
+++ b/drivers/usb/host/fusbh200.h
@@ -165,17 +165,11 @@ struct fusbh200_hcd {			/* one per controller */
         u8                      sbrn;           /* packed release number */
 
         /* irq statistics */
-#ifdef FUSBH200_STATS
         struct fusbh200_stats   stats;
 #       define COUNT(x) do { (x)++; } while (0)
-#else
-#       define COUNT(x) do {} while (0)
-#endif
 
         /* debug files */
-#ifdef DEBUG
         struct dentry           *debug_dir;
-#endif
 };
 
 /* convert between an HCD pointer and the corresponding FUSBH200_HCD */
@@ -734,10 +728,4 @@ static inline unsigned fusbh200_read_frame_index(struct fusbh200_hcd *fusbh200)
 })
 /*-------------------------------------------------------------------------*/
 
-#ifndef DEBUG
-#define STUB_DEBUG_FILES
-#endif  /* DEBUG */
-
-/*-------------------------------------------------------------------------*/
-
 #endif /* __LINUX_FUSBH200_H */
diff --git a/drivers/usb/host/hwa-hc.c b/drivers/usb/host/hwa-hc.c
index ada0a52797b1..f0b97bb08791 100644
--- a/drivers/usb/host/hwa-hc.c
+++ b/drivers/usb/host/hwa-hc.c
@@ -86,7 +86,7 @@ static int __hwahc_set_cluster_id(struct hwahc *hwahc, u8 cluster_id)
                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                         cluster_id,
                         wa->usb_iface->cur_altsetting->desc.bInterfaceNumber,
-                        NULL, 0, 1000 /* FIXME: arbitrary */);
+                        NULL, 0, USB_CTRL_SET_TIMEOUT);
         if (result < 0)
                 dev_err(dev, "Cannot set WUSB Cluster ID to 0x%02x: %d\n",
                         cluster_id, result);
@@ -106,7 +106,7 @@ static int __hwahc_op_set_num_dnts(struct wusbhc *wusbhc, u8 interval, u8 slots)
                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                         interval << 8 | slots,
                         wa->usb_iface->cur_altsetting->desc.bInterfaceNumber,
-                        NULL, 0, 1000 /* FIXME: arbitrary */);
+                        NULL, 0, USB_CTRL_SET_TIMEOUT);
 }
 
 /*
@@ -224,7 +224,7 @@ static int hwahc_op_urb_dequeue(struct usb_hcd *usb_hcd, struct urb *urb,
         struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
         struct hwahc *hwahc = container_of(wusbhc, struct hwahc, wusbhc);
 
-        return wa_urb_dequeue(&hwahc->wa, urb);
+        return wa_urb_dequeue(&hwahc->wa, urb, status);
 }
 
 /*
@@ -281,7 +281,7 @@ static void __hwahc_op_wusbhc_stop(struct wusbhc *wusbhc, int delay)
                               USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                               delay * 1000,
                               iface_no,
-                              NULL, 0, 1000 /* FIXME: arbitrary */);
+                              NULL, 0, USB_CTRL_SET_TIMEOUT);
         if (ret == 0)
                 msleep(delay);
 
@@ -310,7 +310,7 @@ static int __hwahc_op_bwa_set(struct wusbhc *wusbhc, s8 stream_index,
                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                         stream_index,
                         wa->usb_iface->cur_altsetting->desc.bInterfaceNumber,
-                        NULL, 0, 1000 /* FIXME: arbitrary */);
+                        NULL, 0, USB_CTRL_SET_TIMEOUT);
         if (result < 0) {
                 dev_err(dev, "Cannot set WUSB stream index: %d\n", result);
                 goto out;
@@ -321,7 +321,7 @@ static int __hwahc_op_bwa_set(struct wusbhc *wusbhc, s8 stream_index,
                         WUSB_REQ_SET_WUSB_MAS,
                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                         0, wa->usb_iface->cur_altsetting->desc.bInterfaceNumber,
-                        mas_le, 32, 1000 /* FIXME: arbitrary */);
+                        mas_le, 32, USB_CTRL_SET_TIMEOUT);
         if (result < 0)
                 dev_err(dev, "Cannot set WUSB MAS allocation: %d\n", result);
 out:
@@ -355,7 +355,7 @@ static int __hwahc_op_mmcie_add(struct wusbhc *wusbhc, u8 interval,
                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                         interval << 8 | repeat_cnt,
                         handle << 8 | iface_no,
-                        wuie, wuie->bLength, 1000 /* FIXME: arbitrary */);
+                        wuie, wuie->bLength, USB_CTRL_SET_TIMEOUT);
 }
 
 /*
@@ -372,7 +372,7 @@ static int __hwahc_op_mmcie_rm(struct wusbhc *wusbhc, u8 handle)
                         WUSB_REQ_REMOVE_MMC_IE,
                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                         0, handle << 8 | iface_no,
-                        NULL, 0, 1000 /* FIXME: arbitrary */);
+                        NULL, 0, USB_CTRL_SET_TIMEOUT);
 }
 
 /*
@@ -415,7 +415,7 @@ static int __hwahc_op_dev_info_set(struct wusbhc *wusbhc,
                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                         0, wusb_dev->port_idx << 8 | iface_no,
                         dev_info, sizeof(struct hwa_dev_info),
-                        1000 /* FIXME: arbitrary */);
+                        USB_CTRL_SET_TIMEOUT);
         kfree(dev_info);
         return ret;
 }
@@ -455,7 +455,7 @@ static int __hwahc_dev_set_key(struct wusbhc *wusbhc, u8 port_idx, u32 tkid,
                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                         USB_DT_KEY << 8 | key_idx,
                         port_idx << 8 | iface_no,
-                        keyd, keyd_len, 1000 /* FIXME: arbitrary */);
+                        keyd, keyd_len, USB_CTRL_SET_TIMEOUT);
 
         kzfree(keyd); /* clear keys etc. */
         return result;
@@ -497,7 +497,7 @@ static int __hwahc_op_set_ptk(struct wusbhc *wusbhc, u8 port_idx, u32 tkid,
                         USB_REQ_SET_ENCRYPTION,
                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                         encryption_value, port_idx << 8 | iface_no,
-                        NULL, 0, 1000 /* FIXME: arbitrary */);
+                        NULL, 0, USB_CTRL_SET_TIMEOUT);
         if (result < 0)
                 dev_err(wusbhc->dev, "Can't set host's WUSB encryption for "
                         "port index %u to %s (value %d): %d\n", port_idx,
@@ -791,6 +791,7 @@ static int hwahc_probe(struct usb_interface *usb_iface,
                 dev_err(dev, "Cannot add HCD: %d\n", result);
                 goto error_add_hcd;
         }
+        device_wakeup_enable(usb_hcd->self.controller);
         result = wusbhc_b_create(&hwahc->wusbhc);
         if (result < 0) {
                 dev_err(dev, "Cannot setup phase B of WUSBHC: %d\n", result);
diff --git a/drivers/usb/host/imx21-dbg.c b/drivers/usb/host/imx21-dbg.c
index ec98ecee3517..4f320d050da7 100644
--- a/drivers/usb/host/imx21-dbg.c
+++ b/drivers/usb/host/imx21-dbg.c
@@ -18,6 +18,10 @@
 
 /* this file is part of imx21-hcd.c */
 
+#ifdef CONFIG_DYNAMIC_DEBUG
+#define DEBUG
+#endif
+
 #ifndef DEBUG
 
 static inline void create_debug_files(struct imx21 *imx21) { }
diff --git a/drivers/usb/host/imx21-hcd.c b/drivers/usb/host/imx21-hcd.c
index adb01d950a16..207bad99301f 100644
--- a/drivers/usb/host/imx21-hcd.c
+++ b/drivers/usb/host/imx21-hcd.c
@@ -62,6 +62,10 @@
 
 #include "imx21-hcd.h"
 
+#ifdef CONFIG_DYNAMIC_DEBUG
+#define DEBUG
+#endif
+
 #ifdef DEBUG
 #define DEBUG_LOG_FRAME(imx21, etd, event) \
         (etd)->event##_frame = readl((imx21)->regs + USBH_FRMNUB)
@@ -1906,6 +1910,7 @@ static int imx21_probe(struct platform_device *pdev)
                 dev_err(imx21->dev, "usb_add_hcd() returned %d\n", ret);
                 goto failed_add_hcd;
         }
+        device_wakeup_enable(hcd->self.controller);
 
         return 0;
 
@@ -1926,7 +1931,7 @@ failed_request_mem:
 
 static struct platform_driver imx21_hcd_driver = {
         .driver = {
-                   .name = (char *)hcd_name,
+                   .name = hcd_name,
                    },
         .probe = imx21_probe,
         .remove = imx21_remove,
diff --git a/drivers/usb/host/imx21-hcd.h b/drivers/usb/host/imx21-hcd.h
index c005770a73e9..05122f8a6983 100644
--- a/drivers/usb/host/imx21-hcd.h
+++ b/drivers/usb/host/imx21-hcd.h
@@ -24,6 +24,10 @@
 #ifndef __LINUX_IMX21_HCD_H__
 #define __LINUX_IMX21_HCD_H__
 
+#ifdef CONFIG_DYNAMIC_DEBUG
+#define DEBUG
+#endif
+
 #include <linux/platform_data/usb-mx2.h>
 
 #define NUM_ISO_ETDS    2
diff --git a/drivers/usb/host/isp116x-hcd.c b/drivers/usb/host/isp116x-hcd.c
index c7d0f8f231be..2740f65936bd 100644
--- a/drivers/usb/host/isp116x-hcd.c
+++ b/drivers/usb/host/isp116x-hcd.c
@@ -1645,6 +1645,8 @@ static int isp116x_probe(struct platform_device *pdev)
         if (ret)
                 goto err6;
 
+        device_wakeup_enable(hcd->self.controller);
+
         ret = create_debug_file(isp116x);
         if (ret) {
                 ERR("Couldn't create debugfs entry\n");
@@ -1705,7 +1707,7 @@ static struct platform_driver isp116x_driver = {
         .suspend = isp116x_suspend,
         .resume = isp116x_resume,
         .driver = {
-                .name = (char *)hcd_name,
+                .name = hcd_name,
                 .owner  = THIS_MODULE,
         },
 };
diff --git a/drivers/usb/host/isp1362-hcd.c b/drivers/usb/host/isp1362-hcd.c
index 935a2dd367a8..34645ae9313d 100644
--- a/drivers/usb/host/isp1362-hcd.c
+++ b/drivers/usb/host/isp1362-hcd.c
@@ -2746,6 +2746,8 @@ static int isp1362_probe(struct platform_device *pdev)
         retval = usb_add_hcd(hcd, irq, irq_flags | IRQF_SHARED);
         if (retval != 0)
                 goto err6;
+        device_wakeup_enable(hcd->self.controller);
+
         pr_info("%s, irq %d\n", hcd->product_desc, irq);
 
         create_debug_file(isp1362_hcd);
@@ -2829,7 +2831,7 @@ static struct platform_driver isp1362_driver = {
         .suspend = isp1362_suspend,
         .resume = isp1362_resume,
         .driver = {
-                .name = (char *)hcd_name,
+                .name = hcd_name,
                 .owner = THIS_MODULE,
         },
 };
diff --git a/drivers/usb/host/isp1760-hcd.c b/drivers/usb/host/isp1760-hcd.c
index 2facee53eab1..51a0ae9cdd1d 100644
--- a/drivers/usb/host/isp1760-hcd.c
+++ b/drivers/usb/host/isp1760-hcd.c
@@ -2250,6 +2250,7 @@ struct usb_hcd *isp1760_register(phys_addr_t res_start, resource_size_t res_len,
         ret = usb_add_hcd(hcd, irq, irqflags);
         if (ret)
                 goto err_unmap;
+        device_wakeup_enable(hcd->self.controller);
 
         return hcd;
 
diff --git a/drivers/usb/host/ohci-at91.c b/drivers/usb/host/ohci-at91.c
index 418444ebb1b8..29d2093e3cee 100644
--- a/drivers/usb/host/ohci-at91.c
+++ b/drivers/usb/host/ohci-at91.c
@@ -200,8 +200,10 @@ static int usb_hcd_at91_probe(const struct hc_driver *driver,
         at91_start_hc(pdev);
 
         retval = usb_add_hcd(hcd, pdev->resource[1].start, IRQF_SHARED);
-        if (retval == 0)
+        if (retval == 0) {
+                device_wakeup_enable(hcd->self.controller);
                 return retval;
+        }
 
         /* Error handling */
         at91_stop_hc(pdev);
@@ -635,10 +637,17 @@ ohci_hcd_at91_drv_suspend(struct platform_device *pdev, pm_message_t mesg)
 {
         struct usb_hcd  *hcd = platform_get_drvdata(pdev);
         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
+        bool            do_wakeup = device_may_wakeup(&pdev->dev);
+        int             ret;
 
-        if (device_may_wakeup(&pdev->dev))
+        if (do_wakeup)
                 enable_irq_wake(hcd->irq);
 
+        ret = ohci_suspend(hcd, do_wakeup);
+        if (ret) {
+                disable_irq_wake(hcd->irq);
+                return ret;
+        }
         /*
          * The integrated transceivers seem unable to notice disconnect,
          * reconnect, or wakeup without the 48 MHz clock active.  so for
@@ -657,7 +666,7 @@ ohci_hcd_at91_drv_suspend(struct platform_device *pdev, pm_message_t mesg)
                 at91_stop_clock();
         }
 
-        return 0;
+        return ret;
 }
 
 static int ohci_hcd_at91_drv_resume(struct platform_device *pdev)
diff --git a/drivers/usb/host/ohci-da8xx.c b/drivers/usb/host/ohci-da8xx.c
index 9be59f11e051..f0fe0d26314d 100644
--- a/drivers/usb/host/ohci-da8xx.c
+++ b/drivers/usb/host/ohci-da8xx.c
@@ -348,6 +348,8 @@ static int usb_hcd_da8xx_probe(const struct hc_driver *driver,
         if (error)
                 goto err4;
 
+        device_wakeup_enable(hcd->self.controller);
+
         if (hub->ocic_notify) {
                 error = hub->ocic_notify(ohci_da8xx_ocic_handler);
                 if (!error)
@@ -406,19 +408,27 @@ static int ohci_hcd_da8xx_drv_remove(struct platform_device *dev)
 }
 
 #ifdef CONFIG_PM
-static int ohci_da8xx_suspend(struct platform_device *dev, pm_message_t message)
+static int ohci_da8xx_suspend(struct platform_device *pdev,
+                                pm_message_t message)
 {
-        struct usb_hcd  *hcd    = platform_get_drvdata(dev);
+        struct usb_hcd  *hcd    = platform_get_drvdata(pdev);
         struct ohci_hcd *ohci   = hcd_to_ohci(hcd);
+        bool            do_wakeup       = device_may_wakeup(&pdev->dev);
+        int             ret;
+
 
         if (time_before(jiffies, ohci->next_statechange))
                 msleep(5);
         ohci->next_statechange = jiffies;
 
+        ret = ohci_suspend(hcd, do_wakeup);
+        if (ret)
+                return ret;
+
         ohci_da8xx_clock(0);
         hcd->state = HC_STATE_SUSPENDED;
-        dev->dev.power.power_state = PMSG_SUSPEND;
-        return 0;
+
+        return ret;
 }
 
 static int ohci_da8xx_resume(struct platform_device *dev)
diff --git a/drivers/usb/host/ohci-dbg.c b/drivers/usb/host/ohci-dbg.c
index 3fca52ec02ac..45032e933e18 100644
--- a/drivers/usb/host/ohci-dbg.c
+++ b/drivers/usb/host/ohci-dbg.c
@@ -9,8 +9,6 @@
 
 /*-------------------------------------------------------------------------*/
 
-#ifdef DEBUG
-
 #define edstring(ed_type) ({ char *temp; \
         switch (ed_type) { \
         case PIPE_CONTROL:      temp = "ctrl"; break; \
@@ -20,57 +18,6 @@
         } temp;})
 #define pipestring(pipe) edstring(usb_pipetype(pipe))
 
-/* debug| print the main components of an URB
- * small: 0) header + data packets 1) just header
- */
-static void __maybe_unused
-urb_print(struct urb * urb, char * str, int small, int status)
-{
-        unsigned int pipe= urb->pipe;
-
-        if (!urb->dev || !urb->dev->bus) {
-                printk(KERN_DEBUG "%s URB: no dev\n", str);
-                return;
-        }
-
-#ifndef OHCI_VERBOSE_DEBUG
-        if (status != 0)
-#endif
-        printk(KERN_DEBUG "%s %p dev=%d ep=%d%s-%s flags=%x len=%d/%d stat=%d\n",
-                    str,
-                    urb,
-                    usb_pipedevice (pipe),
-                    usb_pipeendpoint (pipe),
-                    usb_pipeout (pipe)? "out" : "in",
-                    pipestring (pipe),
-                    urb->transfer_flags,
-                    urb->actual_length,
-                    urb->transfer_buffer_length,
-                    status);
-
-#ifdef  OHCI_VERBOSE_DEBUG
-        if (!small) {
-                int i, len;
-
-                if (usb_pipecontrol (pipe)) {
-                        printk (KERN_DEBUG "%s: setup(8):", __FILE__);
-                        for (i = 0; i < 8 ; i++)
-                                printk (" %02x", ((__u8 *) urb->setup_packet) [i]);
-                        printk ("\n");
-                }
-                if (urb->transfer_buffer_length > 0 && urb->transfer_buffer) {
-                        printk (KERN_DEBUG "%s: data(%d/%d):", __FILE__,
-                                urb->actual_length,
-                                urb->transfer_buffer_length);
-                        len = usb_pipeout (pipe)?
-                                                urb->transfer_buffer_length: urb->actual_length;
-                        for (i = 0; i < 16 && i < len; i++)
-                                printk (" %02x", ((__u8 *) urb->transfer_buffer) [i]);
-                        printk ("%s stat:%d\n", i < len? "...": "", status);
-                }
-        }
-#endif
-}
 
 #define ohci_dbg_sw(ohci, next, size, format, arg...) \
         do { \
@@ -407,22 +354,8 @@ ohci_dump_ed (const struct ohci_hcd *ohci, const char *label,
         }
 }
 
-#else
-static inline void ohci_dump (struct ohci_hcd *controller, int verbose) {}
-
-#undef OHCI_VERBOSE_DEBUG
-
-#endif /* DEBUG */
-
 /*-------------------------------------------------------------------------*/
 
-#ifdef STUB_DEBUG_FILES
-
-static inline void create_debug_files (struct ohci_hcd *bus) { }
-static inline void remove_debug_files (struct ohci_hcd *bus) { }
-
-#else
-
 static int debug_async_open(struct inode *, struct file *);
 static int debug_periodic_open(struct inode *, struct file *);
 static int debug_registers_open(struct inode *, struct file *);
@@ -871,7 +804,5 @@ static inline void remove_debug_files (struct ohci_hcd *ohci)
         debugfs_remove(ohci->debug_dir);
 }
 
-#endif
-
 /*-------------------------------------------------------------------------*/
 
diff --git a/drivers/usb/host/ohci-exynos.c b/drivers/usb/host/ohci-exynos.c
index 91ec9b2cd378..68588d8a09bb 100644
--- a/drivers/usb/host/ohci-exynos.c
+++ b/drivers/usb/host/ohci-exynos.c
@@ -146,6 +146,7 @@ skip_phy:
                 dev_err(&pdev->dev, "Failed to add USB HCD\n");
                 goto fail_add_hcd;
         }
+        device_wakeup_enable(hcd->self.controller);
         return 0;
 
 fail_add_hcd:
@@ -191,23 +192,14 @@ static int exynos_ohci_suspend(struct device *dev)
         struct exynos_ohci_hcd *exynos_ohci = to_exynos_ohci(hcd);
         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
         struct platform_device *pdev = to_platform_device(dev);
+        bool do_wakeup = device_may_wakeup(dev);
         unsigned long flags;
-        int rc = 0;
+        int rc = ohci_suspend(hcd, do_wakeup);
 
-        /*
-         * Root hub was already suspended. Disable irq emission and
-         * mark HW unaccessible, bail out if RH has been resumed. Use
-         * the spinlock to properly synchronize with possible pending
-         * RH suspend or resume activity.
-         */
-        spin_lock_irqsave(&ohci->lock, flags);
-        if (ohci->rh_state != OHCI_RH_SUSPENDED &&
-                        ohci->rh_state != OHCI_RH_HALTED) {
-                rc = -EINVAL;
-                goto fail;
-        }
+        if (rc)
+                return rc;
 
-        clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+        spin_lock_irqsave(&ohci->lock, flags);
 
         if (exynos_ohci->otg)
                 exynos_ohci->otg->set_host(exynos_ohci->otg, &hcd->self);
@@ -216,10 +208,9 @@ static int exynos_ohci_suspend(struct device *dev)
 
         clk_disable_unprepare(exynos_ohci->clk);
 
-fail:
         spin_unlock_irqrestore(&ohci->lock, flags);
 
-        return rc;
+        return 0;
 }
 
 static int exynos_ohci_resume(struct device *dev)
diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index 8ada13f8dde2..3586460fb2a1 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -51,8 +51,6 @@
 
 /*-------------------------------------------------------------------------*/
 
-#undef OHCI_VERBOSE_DEBUG       /* not always helpful */
-
 /* For initializing controller (mask in an HCFS mode too) */
 #define OHCI_CONTROL_INIT       OHCI_CTRL_CBSR
 #define OHCI_INTR_INIT \
@@ -127,10 +125,6 @@ static int ohci_urb_enqueue (
         unsigned long   flags;
         int             retval = 0;
 
-#ifdef OHCI_VERBOSE_DEBUG
-        urb_print(urb, "SUB", usb_pipein(pipe), -EINPROGRESS);
-#endif
-
         /* every endpoint has a ed, locate and maybe (re)initialize it */
         if (! (ed = ed_get (ohci, urb->ep, urb->dev, pipe, urb->interval)))
                 return -ENOMEM;
@@ -284,10 +278,6 @@ static int ohci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
         unsigned long           flags;
         int                     rc;
 
-#ifdef OHCI_VERBOSE_DEBUG
-        urb_print(urb, "UNLINK", 1, status);
-#endif
-
         spin_lock_irqsave (&ohci->lock, flags);
         rc = usb_hcd_check_unlink_urb(hcd, urb, status);
         if (rc) {
@@ -840,7 +830,7 @@ static irqreturn_t ohci_irq (struct usb_hcd *hcd)
         }
 
         if (ints & OHCI_INTR_RHSC) {
-                ohci_vdbg(ohci, "rhsc\n");
+                ohci_dbg(ohci, "rhsc\n");
                 ohci->next_statechange = jiffies + STATECHANGE_DELAY;
                 ohci_writel(ohci, OHCI_INTR_RD | OHCI_INTR_RHSC,
                                 &regs->intrstatus);
@@ -862,7 +852,7 @@ static irqreturn_t ohci_irq (struct usb_hcd *hcd)
          * this might not happen.
          */
         else if (ints & OHCI_INTR_RD) {
-                ohci_vdbg(ohci, "resume detect\n");
+                ohci_dbg(ohci, "resume detect\n");
                 ohci_writel(ohci, OHCI_INTR_RD, &regs->intrstatus);
                 set_bit(HCD_FLAG_POLL_RH, &hcd->flags);
                 if (ohci->autostop) {
@@ -1036,6 +1026,7 @@ int ohci_suspend(struct usb_hcd *hcd, bool do_wakeup)
 {
         struct ohci_hcd *ohci = hcd_to_ohci (hcd);
         unsigned long   flags;
+        int             rc = 0;
 
         /* Disable irq emission and mark HW unaccessible. Use
          * the spinlock to properly synchronize with possible pending
@@ -1048,7 +1039,13 @@ int ohci_suspend(struct usb_hcd *hcd, bool do_wakeup)
         clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
         spin_unlock_irqrestore (&ohci->lock, flags);
 
-        return 0;
+        synchronize_irq(hcd->irq);
+
+        if (do_wakeup && HCD_WAKEUP_PENDING(hcd)) {
+                ohci_resume(hcd, false);
+                rc = -EBUSY;
+        }
+        return rc;
 }
 EXPORT_SYMBOL_GPL(ohci_suspend);
 
@@ -1233,13 +1230,11 @@ static int __init ohci_hcd_mod_init(void)
                 sizeof (struct ed), sizeof (struct td));
         set_bit(USB_OHCI_LOADED, &usb_hcds_loaded);
 
-#ifdef DEBUG
         ohci_debug_root = debugfs_create_dir("ohci", usb_debug_root);
         if (!ohci_debug_root) {
                 retval = -ENOENT;
                 goto error_debug;
         }
-#endif
 
 #ifdef PS3_SYSTEM_BUS_DRIVER
         retval = ps3_ohci_driver_register(&PS3_SYSTEM_BUS_DRIVER);
@@ -1314,11 +1309,9 @@ static int __init ohci_hcd_mod_init(void)
         ps3_ohci_driver_unregister(&PS3_SYSTEM_BUS_DRIVER);
  error_ps3:
 #endif
-#ifdef DEBUG
         debugfs_remove(ohci_debug_root);
         ohci_debug_root = NULL;
  error_debug:
-#endif
 
         clear_bit(USB_OHCI_LOADED, &usb_hcds_loaded);
         return retval;
@@ -1348,9 +1341,7 @@ static void __exit ohci_hcd_mod_exit(void)
 #ifdef PS3_SYSTEM_BUS_DRIVER
         ps3_ohci_driver_unregister(&PS3_SYSTEM_BUS_DRIVER);
 #endif
-#ifdef DEBUG
         debugfs_remove(ohci_debug_root);
-#endif
         clear_bit(USB_OHCI_LOADED, &usb_hcds_loaded);
 }
 module_exit(ohci_hcd_mod_exit);
diff --git a/drivers/usb/host/ohci-hub.c b/drivers/usb/host/ohci-hub.c
index 61705a760e7d..c81c8721cc5a 100644
--- a/drivers/usb/host/ohci-hub.c
+++ b/drivers/usb/host/ohci-hub.c
@@ -725,10 +725,8 @@ static int ohci_hub_control (
                 temp = roothub_portstatus (ohci, wIndex);
                 put_unaligned_le32(temp, buf);
 
-#ifndef OHCI_VERBOSE_DEBUG
-        if (*(u16*)(buf+2))     /* only if wPortChange is interesting */
-#endif
-                dbg_port (ohci, "GetStatus", wIndex, temp);
+                if (*(u16*)(buf+2))     /* only if wPortChange is interesting */
+                        dbg_port(ohci, "GetStatus", wIndex, temp);
                 break;
         case SetHubFeature:
                 switch (wValue) {
diff --git a/drivers/usb/host/ohci-jz4740.c b/drivers/usb/host/ohci-jz4740.c
index d4ef53990d73..efe31f3ab4ea 100644
--- a/drivers/usb/host/ohci-jz4740.c
+++ b/drivers/usb/host/ohci-jz4740.c
@@ -217,6 +217,7 @@ static int jz4740_ohci_probe(struct platform_device *pdev)
                 dev_err(&pdev->dev, "Failed to add hcd: %d\n", ret);
                 goto err_disable;
         }
+        device_wakeup_enable(hcd->self.controller);
 
         return 0;
 
diff --git a/drivers/usb/host/ohci-nxp.c b/drivers/usb/host/ohci-nxp.c
index e99db8a6d55f..719f28e5e3ac 100644
--- a/drivers/usb/host/ohci-nxp.c
+++ b/drivers/usb/host/ohci-nxp.c
@@ -274,8 +274,10 @@ static int ohci_hcd_nxp_probe(struct platform_device *pdev)
 
         dev_info(&pdev->dev, "at 0x%p, irq %d\n", hcd->regs, hcd->irq);
         ret = usb_add_hcd(hcd, irq, 0);
-        if (ret == 0)
+        if (ret == 0) {
+                device_wakeup_enable(hcd->self.controller);
                 return ret;
+        }
 
         ohci_nxp_stop_hc();
 fail_resource:
diff --git a/drivers/usb/host/ohci-octeon.c b/drivers/usb/host/ohci-octeon.c
index 6c16dcef15c6..49b220dc2f9b 100644
--- a/drivers/usb/host/ohci-octeon.c
+++ b/drivers/usb/host/ohci-octeon.c
@@ -171,6 +171,8 @@ static int ohci_octeon_drv_probe(struct platform_device *pdev)
                 goto err3;
         }
 
+        device_wakeup_enable(hcd->self.controller);
+
         platform_set_drvdata(pdev, hcd);
 
         return 0;
diff --git a/drivers/usb/host/ohci-omap.c b/drivers/usb/host/ohci-omap.c
index f253214741ba..a44a4fede1c4 100644
--- a/drivers/usb/host/ohci-omap.c
+++ b/drivers/usb/host/ohci-omap.c
@@ -367,6 +367,7 @@ static int usb_hcd_omap_probe (const struct hc_driver *driver,
         if (retval)
                 goto err3;
 
+        device_wakeup_enable(hcd->self.controller);
         return 0;
 err3:
         iounmap(hcd->regs);
diff --git a/drivers/usb/host/ohci-omap3.c b/drivers/usb/host/ohci-omap3.c
index 21457417a856..ec15aebe8786 100644
--- a/drivers/usb/host/ohci-omap3.c
+++ b/drivers/usb/host/ohci-omap3.c
@@ -130,6 +130,7 @@ static int ohci_hcd_omap3_probe(struct platform_device *pdev)
                 dev_dbg(dev, "failed to add hcd with err %d\n", ret);
                 goto err_add_hcd;
         }
+        device_wakeup_enable(hcd->self.controller);
 
         return 0;
 
diff --git a/drivers/usb/host/ohci-platform.c b/drivers/usb/host/ohci-platform.c
index f351ff5b171f..68f674cd095f 100644
--- a/drivers/usb/host/ohci-platform.c
+++ b/drivers/usb/host/ohci-platform.c
@@ -108,6 +108,8 @@ static int ohci_platform_probe(struct platform_device *dev)
         if (err)
                 goto err_put_hcd;
 
+        device_wakeup_enable(hcd->self.controller);
+
         platform_set_drvdata(dev, hcd);
 
         return err;
diff --git a/drivers/usb/host/ohci-ppc-of.c b/drivers/usb/host/ohci-ppc-of.c
index 81f3eba215c1..83e33d464082 100644
--- a/drivers/usb/host/ohci-ppc-of.c
+++ b/drivers/usb/host/ohci-ppc-of.c
@@ -147,8 +147,10 @@ static int ohci_hcd_ppc_of_probe(struct platform_device *op)
         ohci_hcd_init(ohci);
 
         rv = usb_add_hcd(hcd, irq, 0);
-        if (rv == 0)
+        if (rv == 0) {
+                device_wakeup_enable(hcd->self.controller);
                 return 0;
+        }
 
         /* by now, 440epx is known to show usb_23 erratum */
         np = of_find_compatible_node(NULL, NULL, "ibm,usb-ehci-440epx");
diff --git a/drivers/usb/host/ohci-ps3.c b/drivers/usb/host/ohci-ps3.c
index 7d35cd9e2862..71d8bc4c27f6 100644
--- a/drivers/usb/host/ohci-ps3.c
+++ b/drivers/usb/host/ohci-ps3.c
@@ -173,6 +173,7 @@ static int ps3_ohci_probe(struct ps3_system_bus_device *dev)
                 goto fail_add_hcd;
         }
 
+        device_wakeup_enable(hcd->self.controller);
         return result;
 
 fail_add_hcd:
diff --git a/drivers/usb/host/ohci-pxa27x.c b/drivers/usb/host/ohci-pxa27x.c
index 9b7435f0dcd6..9352a4d42563 100644
--- a/drivers/usb/host/ohci-pxa27x.c
+++ b/drivers/usb/host/ohci-pxa27x.c
@@ -443,8 +443,10 @@ int usb_hcd_pxa27x_probe (const struct hc_driver *driver, struct platform_device
         ohci->num_ports = 3;
 
         retval = usb_add_hcd(hcd, irq, 0);
-        if (retval == 0)
+        if (retval == 0) {
+                device_wakeup_enable(hcd->self.controller);
                 return retval;
+        }
 
         pxa27x_stop_hc(pxa_ohci, &pdev->dev);
  err3:
diff --git a/drivers/usb/host/ohci-q.c b/drivers/usb/host/ohci-q.c
index e7f577e63624..d4253e319428 100644
--- a/drivers/usb/host/ohci-q.c
+++ b/drivers/usb/host/ohci-q.c
@@ -68,10 +68,6 @@ __acquires(ohci->lock)
                 break;
         }
 
-#ifdef OHCI_VERBOSE_DEBUG
-        urb_print(urb, "RET", usb_pipeout (urb->pipe), status);
-#endif
-
         /* urb->complete() can reenter this HCD */
         usb_hcd_unlink_urb_from_ep(ohci_to_hcd(ohci), urb);
         spin_unlock (&ohci->lock);
@@ -147,7 +143,7 @@ static void periodic_link (struct ohci_hcd *ohci, struct ed *ed)
 {
         unsigned        i;
 
-        ohci_vdbg (ohci, "link %sed %p branch %d [%dus.], interval %d\n",
+        ohci_dbg(ohci, "link %sed %p branch %d [%dus.], interval %d\n",
                 (ed->hwINFO & cpu_to_hc32 (ohci, ED_ISO)) ? "iso " : "",
                 ed, ed->branch, ed->load, ed->interval);
 
@@ -294,7 +290,7 @@ static void periodic_unlink (struct ohci_hcd *ohci, struct ed *ed)
         }
         ohci_to_hcd(ohci)->self.bandwidth_allocated -= ed->load / ed->interval;
 
-        ohci_vdbg (ohci, "unlink %sed %p branch %d [%dus.], interval %d\n",
+        ohci_dbg(ohci, "unlink %sed %p branch %d [%dus.], interval %d\n",
                 (ed->hwINFO & cpu_to_hc32 (ohci, ED_ISO)) ? "iso " : "",
                 ed, ed->branch, ed->load, ed->interval);
 }
@@ -765,7 +761,7 @@ static int td_done(struct ohci_hcd *ohci, struct urb *urb, struct td *td)
                 urb->iso_frame_desc [td->index].status = cc_to_error [cc];
 
                 if (cc != TD_CC_NOERROR)
-                        ohci_vdbg (ohci,
+                        ohci_dbg(ohci,
                                 "urb %p iso td %p (%d) len %d cc %d\n",
                                 urb, td, 1 + td->index, dlen, cc);
 
@@ -797,7 +793,7 @@ static int td_done(struct ohci_hcd *ohci, struct urb *urb, struct td *td)
                 }
 
                 if (cc != TD_CC_NOERROR && cc < 0x0E)
-                        ohci_vdbg (ohci,
+                        ohci_dbg(ohci,
                                 "urb %p td %p (%d) cc %d, len=%d/%d\n",
                                 urb, td, 1 + td->index, cc,
                                 urb->actual_length,
diff --git a/drivers/usb/host/ohci-s3c2410.c b/drivers/usb/host/ohci-s3c2410.c
index f90101b9cdb9..ff7c8f1c48fb 100644
--- a/drivers/usb/host/ohci-s3c2410.c
+++ b/drivers/usb/host/ohci-s3c2410.c
@@ -395,6 +395,7 @@ static int usb_hcd_s3c2410_probe(const struct hc_driver *driver,
         if (retval != 0)
                 goto err_ioremap;
 
+        device_wakeup_enable(hcd->self.controller);
         return 0;
 
  err_ioremap:
@@ -426,28 +427,15 @@ static int ohci_hcd_s3c2410_drv_remove(struct platform_device *pdev)
 static int ohci_hcd_s3c2410_drv_suspend(struct device *dev)
 {
         struct usb_hcd *hcd = dev_get_drvdata(dev);
-        struct ohci_hcd *ohci = hcd_to_ohci(hcd);
         struct platform_device *pdev = to_platform_device(dev);
-        unsigned long flags;
+        bool do_wakeup = device_may_wakeup(dev);
         int rc = 0;
 
-        /*
-         * Root hub was already suspended. Disable irq emission and
-         * mark HW unaccessible, bail out if RH has been resumed. Use
-         * the spinlock to properly synchronize with possible pending
-         * RH suspend or resume activity.
-         */
-        spin_lock_irqsave(&ohci->lock, flags);
-        if (ohci->rh_state != OHCI_RH_SUSPENDED) {
-                rc = -EINVAL;
-                goto bail;
-        }
-
-        clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
+        rc = ohci_suspend(hcd, do_wakeup);
+        if (rc)
+                return rc;
 
         s3c2410_stop_hc(pdev);
-bail:
-        spin_unlock_irqrestore(&ohci->lock, flags);
 
         return rc;
 }
diff --git a/drivers/usb/host/ohci-sa1111.c b/drivers/usb/host/ohci-sa1111.c
index aa9e127bbe71..2ac266d692a2 100644
--- a/drivers/usb/host/ohci-sa1111.c
+++ b/drivers/usb/host/ohci-sa1111.c
@@ -211,8 +211,10 @@ static int ohci_hcd_sa1111_probe(struct sa1111_dev *dev)
                 goto err2;
 
         ret = usb_add_hcd(hcd, dev->irq[1], 0);
-        if (ret == 0)
+        if (ret == 0) {
+                device_wakeup_enable(hcd->self.controller);
                 return ret;
+        }
 
         sa1111_stop_hc(dev);
  err2:
diff --git a/drivers/usb/host/ohci-sm501.c b/drivers/usb/host/ohci-sm501.c
index 2a5de5fecd8f..4e81c804c73e 100644
--- a/drivers/usb/host/ohci-sm501.c
+++ b/drivers/usb/host/ohci-sm501.c
@@ -168,6 +168,7 @@ static int ohci_hcd_sm501_drv_probe(struct platform_device *pdev)
         retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (retval)
                 goto err5;
+        device_wakeup_enable(hcd->self.controller);
 
         /* enable power and unmask interrupts */
 
diff --git a/drivers/usb/host/ohci-spear.c b/drivers/usb/host/ohci-spear.c
index 6b02107d281d..4cb98abc0bef 100644
--- a/drivers/usb/host/ohci-spear.c
+++ b/drivers/usb/host/ohci-spear.c
@@ -103,8 +103,10 @@ static int spear_ohci_hcd_drv_probe(struct platform_device *pdev)
         ohci = hcd_to_ohci(hcd);
 
         retval = usb_add_hcd(hcd, platform_get_irq(pdev, 0), 0);
-        if (retval == 0)
+        if (retval == 0) {
+                device_wakeup_enable(hcd->self.controller);
                 return retval;
+        }
 
         clk_disable_unprepare(sohci_p->clk);
 err_put_hcd:
@@ -129,20 +131,26 @@ static int spear_ohci_hcd_drv_remove(struct platform_device *pdev)
 }
 
 #if defined(CONFIG_PM)
-static int spear_ohci_hcd_drv_suspend(struct platform_device *dev,
+static int spear_ohci_hcd_drv_suspend(struct platform_device *pdev,
                 pm_message_t message)
 {
-        struct usb_hcd *hcd = platform_get_drvdata(dev);
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
         struct ohci_hcd *ohci = hcd_to_ohci(hcd);
         struct spear_ohci *sohci_p = to_spear_ohci(hcd);
+        bool do_wakeup = device_may_wakeup(&pdev->dev);
+        int ret;
 
         if (time_before(jiffies, ohci->next_statechange))
                 msleep(5);
         ohci->next_statechange = jiffies;
 
+        ret = ohci_suspend(hcd, do_wakeup);
+        if (ret)
+                return ret;
+
         clk_disable_unprepare(sohci_p->clk);
 
-        return 0;
+        return ret;
 }
 
 static int spear_ohci_hcd_drv_resume(struct platform_device *dev)
diff --git a/drivers/usb/host/ohci-tilegx.c b/drivers/usb/host/ohci-tilegx.c
index 22540ab71f55..0b183e0b0a8a 100644
--- a/drivers/usb/host/ohci-tilegx.c
+++ b/drivers/usb/host/ohci-tilegx.c
@@ -159,6 +159,7 @@ static int ohci_hcd_tilegx_drv_probe(struct platform_device *pdev)
         ret = usb_add_hcd(hcd, pdata->irq, IRQF_SHARED);
         if (ret == 0) {
                 platform_set_drvdata(pdev, hcd);
+                device_wakeup_enable(hcd->self.controller);
                 return ret;
         }
 
diff --git a/drivers/usb/host/ohci-tmio.c b/drivers/usb/host/ohci-tmio.c
index ecb09a5ada9c..9c44093b8e1e 100644
--- a/drivers/usb/host/ohci-tmio.c
+++ b/drivers/usb/host/ohci-tmio.c
@@ -250,6 +250,7 @@ static int ohci_hcd_tmio_drv_probe(struct platform_device *dev)
         if (ret)
                 goto err_add_hcd;
 
+        device_wakeup_enable(hcd->self.controller);
         if (ret == 0)
                 return ret;
 
diff --git a/drivers/usb/host/ohci.h b/drivers/usb/host/ohci.h
index e2e5faa5a402..9250cada13f0 100644
--- a/drivers/usb/host/ohci.h
+++ b/drivers/usb/host/ohci.h
@@ -415,12 +415,11 @@ struct ohci_hcd {
         struct ed               *ed_to_check;
         unsigned                zf_delay;
 
-#ifdef DEBUG
         struct dentry           *debug_dir;
         struct dentry           *debug_async;
         struct dentry           *debug_periodic;
         struct dentry           *debug_registers;
-#endif
+
         /* platform-specific data -- must come last */
         unsigned long           priv[0] __aligned(sizeof(s64));
 
@@ -474,10 +473,6 @@ static inline struct usb_hcd *ohci_to_hcd (const struct ohci_hcd *ohci)
 
 /*-------------------------------------------------------------------------*/
 
-#ifndef DEBUG
-#define STUB_DEBUG_FILES
-#endif  /* DEBUG */
-
 #define ohci_dbg(ohci, fmt, args...) \
         dev_dbg (ohci_to_hcd(ohci)->self.controller , fmt , ## args )
 #define ohci_err(ohci, fmt, args...) \
@@ -487,12 +482,6 @@ static inline struct usb_hcd *ohci_to_hcd (const struct ohci_hcd *ohci)
 #define ohci_warn(ohci, fmt, args...) \
         dev_warn (ohci_to_hcd(ohci)->self.controller , fmt , ## args )
 
-#ifdef OHCI_VERBOSE_DEBUG
-#       define ohci_vdbg ohci_dbg
-#else
-#       define ohci_vdbg(ohci, fmt, args...) do { } while (0)
-#endif
-
 /*-------------------------------------------------------------------------*/
 
 /*
diff --git a/drivers/usb/host/oxu210hp-hcd.c b/drivers/usb/host/oxu210hp-hcd.c
index 4a6df2d8f902..778eeaf2dd14 100644
--- a/drivers/usb/host/oxu210hp-hcd.c
+++ b/drivers/usb/host/oxu210hp-hcd.c
@@ -60,6 +60,10 @@
 #define oxu_info(oxu, fmt, args...) \
                 dev_info(oxu_to_hcd(oxu)->self.controller , fmt , ## args)
 
+#ifdef CONFIG_DYNAMIC_DEBUG
+#define DEBUG
+#endif
+
 static inline struct usb_hcd *oxu_to_hcd(struct oxu_hcd *oxu)
 {
         return container_of((void *) oxu, struct usb_hcd, hcd_priv);
@@ -3747,6 +3751,7 @@ static struct usb_hcd *oxu_create(struct platform_device *pdev,
         if (ret < 0)
                 return ERR_PTR(ret);
 
+        device_wakeup_enable(hcd->self.controller);
         return hcd;
 }
 
diff --git a/drivers/usb/host/r8a66597-hcd.c b/drivers/usb/host/r8a66597-hcd.c
index 2ad004ae747c..47b1322c7a77 100644
--- a/drivers/usb/host/r8a66597-hcd.c
+++ b/drivers/usb/host/r8a66597-hcd.c
@@ -2514,6 +2514,7 @@ static int r8a66597_probe(struct platform_device *pdev)
                 dev_err(&pdev->dev, "Failed to add hcd\n");
                 goto clean_up3;
         }
+        device_wakeup_enable(hcd->self.controller);
 
         return 0;
 
@@ -2534,7 +2535,7 @@ static struct platform_driver r8a66597_driver = {
         .probe =        r8a66597_probe,
         .remove =       r8a66597_remove,
         .driver         = {
-                .name = (char *) hcd_name,
+                .name = hcd_name,
                 .owner  = THIS_MODULE,
                 .pm     = R8A66597_DEV_PM_OPS,
         },
diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c
index 79620c39217e..0115e7f51d94 100644
--- a/drivers/usb/host/sl811-hcd.c
+++ b/drivers/usb/host/sl811-hcd.c
@@ -1732,6 +1732,8 @@ sl811h_probe(struct platform_device *dev)
         if (retval != 0)
                 goto err6;
 
+        device_wakeup_enable(hcd->self.controller);
+
         create_debug_file(sl811);
         return retval;
 
diff --git a/drivers/usb/host/u132-hcd.c b/drivers/usb/host/u132-hcd.c
index e402beb5a069..c0671750671f 100644
--- a/drivers/usb/host/u132-hcd.c
+++ b/drivers/usb/host/u132-hcd.c
@@ -3133,6 +3133,7 @@ static int u132_probe(struct platform_device *pdev)
                         u132_u132_put_kref(u132);
                         return retval;
                 } else {
+                        device_wakeup_enable(hcd->self.controller);
                         u132_monitor_queue_work(u132, 100);
                         return 0;
                 }
@@ -3217,7 +3218,7 @@ static struct platform_driver u132_platform_driver = {
         .suspend = u132_suspend,
         .resume = u132_resume,
         .driver = {
-                   .name = (char *)hcd_name,
+                   .name = hcd_name,
                    .owner = THIS_MODULE,
                    },
 };
diff --git a/drivers/usb/host/uhci-debug.c b/drivers/usb/host/uhci-debug.c
index 8e239cdd95d5..1b28a000d5c6 100644
--- a/drivers/usb/host/uhci-debug.c
+++ b/drivers/usb/host/uhci-debug.c
@@ -20,7 +20,7 @@
 
 static struct dentry *uhci_debugfs_root;
 
-#ifdef DEBUG
+#ifdef CONFIG_DYNAMIC_DEBUG
 
 /* Handle REALLY large printks so we don't overflow buffers */
 static void lprintk(char *buf)
@@ -635,7 +635,7 @@ static const struct file_operations uhci_debug_operations = {
 
 #endif  /* CONFIG_DEBUG_FS */
 
-#else   /* DEBUG */
+#else   /* CONFIG_DYNAMIC_DEBUG*/
 
 static inline void lprintk(char *buf)
 {}
diff --git a/drivers/usb/host/uhci-grlib.c b/drivers/usb/host/uhci-grlib.c
index 53c23ff7d685..ab25dc397e8b 100644
--- a/drivers/usb/host/uhci-grlib.c
+++ b/drivers/usb/host/uhci-grlib.c
@@ -141,6 +141,7 @@ static int uhci_hcd_grlib_probe(struct platform_device *op)
         if (rv)
                 goto err_uhci;
 
+        device_wakeup_enable(hcd->self.controller);
         return 0;
 
 err_uhci:
diff --git a/drivers/usb/host/uhci-hcd.c b/drivers/usb/host/uhci-hcd.c
index 4a86b63745b8..27f35e8f161b 100644
--- a/drivers/usb/host/uhci-hcd.c
+++ b/drivers/usb/host/uhci-hcd.c
@@ -69,18 +69,21 @@ MODULE_PARM_DESC(ignore_oc, "ignore hardware overcurrent indications");
  *            show all queues in /sys/kernel/debug/uhci/[pci_addr]
  * debug = 3, show all TDs in URBs when dumping
  */
-#ifdef DEBUG
-#define DEBUG_CONFIGURED        1
+#ifdef CONFIG_DYNAMIC_DEBUG
+
 static int debug = 1;
 module_param(debug, int, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(debug, "Debug level");
+static char *errbuf;
 
 #else
-#define DEBUG_CONFIGURED        0
-#define debug                   0
+
+#define debug 0
+#define errbuf NULL
+
 #endif
 
-static char *errbuf;
+
 #define ERRBUF_LEN    (32 * 1024)
 
 static struct kmem_cache *uhci_up_cachep;       /* urb_priv */
@@ -516,13 +519,12 @@ static void release_uhci(struct uhci_hcd *uhci)
 {
         int i;
 
-        if (DEBUG_CONFIGURED) {
-                spin_lock_irq(&uhci->lock);
-                uhci->is_initialized = 0;
-                spin_unlock_irq(&uhci->lock);
 
-                debugfs_remove(uhci->dentry);
-        }
+        spin_lock_irq(&uhci->lock);
+        uhci->is_initialized = 0;
+        spin_unlock_irq(&uhci->lock);
+
+        debugfs_remove(uhci->dentry);
 
         for (i = 0; i < UHCI_NUM_SKELQH; i++)
                 uhci_free_qh(uhci, uhci->skelqh[i]);
@@ -868,14 +870,14 @@ static int __init uhci_hcd_init(void)
                         ignore_oc ? ", overcurrent ignored" : "");
         set_bit(USB_UHCI_LOADED, &usb_hcds_loaded);
 
-        if (DEBUG_CONFIGURED) {
-                errbuf = kmalloc(ERRBUF_LEN, GFP_KERNEL);
-                if (!errbuf)
-                        goto errbuf_failed;
-                uhci_debugfs_root = debugfs_create_dir("uhci", usb_debug_root);
-                if (!uhci_debugfs_root)
-                        goto debug_failed;
-        }
+#ifdef CONFIG_DYNAMIC_DEBUG
+        errbuf = kmalloc(ERRBUF_LEN, GFP_KERNEL);
+        if (!errbuf)
+                goto errbuf_failed;
+        uhci_debugfs_root = debugfs_create_dir("uhci", usb_debug_root);
+        if (!uhci_debugfs_root)
+                goto debug_failed;
+#endif
 
         uhci_up_cachep = kmem_cache_create("uhci_urb_priv",
                 sizeof(struct urb_priv), 0, 0, NULL);
@@ -906,12 +908,14 @@ clean0:
         kmem_cache_destroy(uhci_up_cachep);
 
 up_failed:
+#if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
         debugfs_remove(uhci_debugfs_root);
 
 debug_failed:
         kfree(errbuf);
 
 errbuf_failed:
+#endif
 
         clear_bit(USB_UHCI_LOADED, &usb_hcds_loaded);
         return retval;
@@ -927,7 +931,9 @@ static void __exit uhci_hcd_cleanup(void)
 #endif
         kmem_cache_destroy(uhci_up_cachep);
         debugfs_remove(uhci_debugfs_root);
+#ifdef CONFIG_DYNAMIC_DEBUG
         kfree(errbuf);
+#endif
         clear_bit(USB_UHCI_LOADED, &usb_hcds_loaded);
 }
 
diff --git a/drivers/usb/host/uhci-pci.c b/drivers/usb/host/uhci-pci.c
index 4cd79888804b..940304c33224 100644
--- a/drivers/usb/host/uhci-pci.c
+++ b/drivers/usb/host/uhci-pci.c
@@ -279,7 +279,7 @@ static const struct hc_driver uhci_driver = {
         .hub_control =          uhci_hub_control,
 };
 
-static DEFINE_PCI_DEVICE_TABLE(uhci_pci_ids) = { {
+static const struct pci_device_id uhci_pci_ids[] = { {
         /* handle any USB UHCI controller */
         PCI_DEVICE_CLASS(PCI_CLASS_SERIAL_USB_UHCI, ~0),
         .driver_data =  (unsigned long) &uhci_driver,
diff --git a/drivers/usb/host/uhci-platform.c b/drivers/usb/host/uhci-platform.c
index 3003fefaa964..44e6c9da8892 100644
--- a/drivers/usb/host/uhci-platform.c
+++ b/drivers/usb/host/uhci-platform.c
@@ -108,6 +108,7 @@ static int uhci_hcd_platform_probe(struct platform_device *pdev)
         if (ret)
                 goto err_uhci;
 
+        device_wakeup_enable(hcd->self.controller);
         return 0;
 
 err_uhci:
diff --git a/drivers/usb/host/whci/hcd.c b/drivers/usb/host/whci/hcd.c
index 1b0888f8da9a..d7b363a418de 100644
--- a/drivers/usb/host/whci/hcd.c
+++ b/drivers/usb/host/whci/hcd.c
@@ -293,6 +293,7 @@ static int whc_probe(struct umc_dev *umc)
                 dev_err(dev, "cannot add HCD: %d\n", ret);
                 goto error_usb_add_hcd;
         }
+        device_wakeup_enable(usb_hcd->self.controller);
 
         ret = wusbhc_b_create(wusbhc);
         if (ret) {
diff --git a/drivers/usb/host/xhci-dbg.c b/drivers/usb/host/xhci-dbg.c
index 73503a81ee81..b016d38199f2 100644
--- a/drivers/usb/host/xhci-dbg.c
+++ b/drivers/usb/host/xhci-dbg.c
@@ -32,7 +32,7 @@ void xhci_dbg_regs(struct xhci_hcd *xhci)
 
         xhci_dbg(xhci, "// xHCI capability registers at %p:\n",
                         xhci->cap_regs);
-        temp = xhci_readl(xhci, &xhci->cap_regs->hc_capbase);
+        temp = readl(&xhci->cap_regs->hc_capbase);
         xhci_dbg(xhci, "// @%p = 0x%x (CAPLENGTH AND HCIVERSION)\n",
                         &xhci->cap_regs->hc_capbase, temp);
         xhci_dbg(xhci, "//   CAPLENGTH: 0x%x\n",
@@ -44,13 +44,13 @@ void xhci_dbg_regs(struct xhci_hcd *xhci)
 
         xhci_dbg(xhci, "// xHCI operational registers at %p:\n", xhci->op_regs);
 
-        temp = xhci_readl(xhci, &xhci->cap_regs->run_regs_off);
+        temp = readl(&xhci->cap_regs->run_regs_off);
         xhci_dbg(xhci, "// @%p = 0x%x RTSOFF\n",
                         &xhci->cap_regs->run_regs_off,
                         (unsigned int) temp & RTSOFF_MASK);
         xhci_dbg(xhci, "// xHCI runtime registers at %p:\n", xhci->run_regs);
 
-        temp = xhci_readl(xhci, &xhci->cap_regs->db_off);
+        temp = readl(&xhci->cap_regs->db_off);
         xhci_dbg(xhci, "// @%p = 0x%x DBOFF\n", &xhci->cap_regs->db_off, temp);
         xhci_dbg(xhci, "// Doorbell array at %p:\n", xhci->dba);
 }
@@ -61,7 +61,7 @@ static void xhci_print_cap_regs(struct xhci_hcd *xhci)
 
         xhci_dbg(xhci, "xHCI capability registers at %p:\n", xhci->cap_regs);
 
-        temp = xhci_readl(xhci, &xhci->cap_regs->hc_capbase);
+        temp = readl(&xhci->cap_regs->hc_capbase);
         xhci_dbg(xhci, "CAPLENGTH AND HCIVERSION 0x%x:\n",
                         (unsigned int) temp);
         xhci_dbg(xhci, "CAPLENGTH: 0x%x\n",
@@ -69,7 +69,7 @@ static void xhci_print_cap_regs(struct xhci_hcd *xhci)
         xhci_dbg(xhci, "HCIVERSION: 0x%x\n",
                         (unsigned int) HC_VERSION(temp));
 
-        temp = xhci_readl(xhci, &xhci->cap_regs->hcs_params1);
+        temp = readl(&xhci->cap_regs->hcs_params1);
         xhci_dbg(xhci, "HCSPARAMS 1: 0x%x\n",
                         (unsigned int) temp);
         xhci_dbg(xhci, "  Max device slots: %u\n",
@@ -79,7 +79,7 @@ static void xhci_print_cap_regs(struct xhci_hcd *xhci)
         xhci_dbg(xhci, "  Max ports: %u\n",
                         (unsigned int) HCS_MAX_PORTS(temp));
 
-        temp = xhci_readl(xhci, &xhci->cap_regs->hcs_params2);
+        temp = readl(&xhci->cap_regs->hcs_params2);
         xhci_dbg(xhci, "HCSPARAMS 2: 0x%x\n",
                         (unsigned int) temp);
         xhci_dbg(xhci, "  Isoc scheduling threshold: %u\n",
@@ -87,7 +87,7 @@ static void xhci_print_cap_regs(struct xhci_hcd *xhci)
         xhci_dbg(xhci, "  Maximum allowed segments in event ring: %u\n",
                         (unsigned int) HCS_ERST_MAX(temp));
 
-        temp = xhci_readl(xhci, &xhci->cap_regs->hcs_params3);
+        temp = readl(&xhci->cap_regs->hcs_params3);
         xhci_dbg(xhci, "HCSPARAMS 3 0x%x:\n",
                         (unsigned int) temp);
         xhci_dbg(xhci, "  Worst case U1 device exit latency: %u\n",
@@ -95,14 +95,14 @@ static void xhci_print_cap_regs(struct xhci_hcd *xhci)
         xhci_dbg(xhci, "  Worst case U2 device exit latency: %u\n",
                         (unsigned int) HCS_U2_LATENCY(temp));
 
-        temp = xhci_readl(xhci, &xhci->cap_regs->hcc_params);
+        temp = readl(&xhci->cap_regs->hcc_params);
         xhci_dbg(xhci, "HCC PARAMS 0x%x:\n", (unsigned int) temp);
         xhci_dbg(xhci, "  HC generates %s bit addresses\n",
                         HCC_64BIT_ADDR(temp) ? "64" : "32");
         /* FIXME */
         xhci_dbg(xhci, "  FIXME: more HCCPARAMS debugging\n");
 
-        temp = xhci_readl(xhci, &xhci->cap_regs->run_regs_off);
+        temp = readl(&xhci->cap_regs->run_regs_off);
         xhci_dbg(xhci, "RTSOFF 0x%x:\n", temp & RTSOFF_MASK);
 }
 
@@ -110,7 +110,7 @@ static void xhci_print_command_reg(struct xhci_hcd *xhci)
 {
         u32 temp;
 
-        temp = xhci_readl(xhci, &xhci->op_regs->command);
+        temp = readl(&xhci->op_regs->command);
         xhci_dbg(xhci, "USBCMD 0x%x:\n", temp);
         xhci_dbg(xhci, "  HC is %s\n",
                         (temp & CMD_RUN) ? "running" : "being stopped");
@@ -128,7 +128,7 @@ static void xhci_print_status(struct xhci_hcd *xhci)
 {
         u32 temp;
 
-        temp = xhci_readl(xhci, &xhci->op_regs->status);
+        temp = readl(&xhci->op_regs->status);
         xhci_dbg(xhci, "USBSTS 0x%x:\n", temp);
         xhci_dbg(xhci, "  Event ring is %sempty\n",
                         (temp & STS_EINT) ? "not " : "");
@@ -163,7 +163,7 @@ static void xhci_print_ports(struct xhci_hcd *xhci)
                 for (j = 0; j < NUM_PORT_REGS; ++j) {
                         xhci_dbg(xhci, "%p port %s reg = 0x%x\n",
                                         addr, names[j],
-                                        (unsigned int) xhci_readl(xhci, addr));
+                                        (unsigned int) readl(addr));
                         addr++;
                 }
         }
@@ -177,7 +177,7 @@ void xhci_print_ir_set(struct xhci_hcd *xhci, int set_num)
         u64 temp_64;
 
         addr = &ir_set->irq_pending;
-        temp = xhci_readl(xhci, addr);
+        temp = readl(addr);
         if (temp == XHCI_INIT_VALUE)
                 return;
 
@@ -187,28 +187,28 @@ void xhci_print_ir_set(struct xhci_hcd *xhci, int set_num)
                         (unsigned int)temp);
 
         addr = &ir_set->irq_control;
-        temp = xhci_readl(xhci, addr);
+        temp = readl(addr);
         xhci_dbg(xhci, "  %p: ir_set.control = 0x%x\n", addr,
                         (unsigned int)temp);
 
         addr = &ir_set->erst_size;
-        temp = xhci_readl(xhci, addr);
+        temp = readl(addr);
         xhci_dbg(xhci, "  %p: ir_set.erst_size = 0x%x\n", addr,
                         (unsigned int)temp);
 
         addr = &ir_set->rsvd;
-        temp = xhci_readl(xhci, addr);
+        temp = readl(addr);
         if (temp != XHCI_INIT_VALUE)
                 xhci_dbg(xhci, "  WARN: %p: ir_set.rsvd = 0x%x\n",
                                 addr, (unsigned int)temp);
 
         addr = &ir_set->erst_base;
-        temp_64 = xhci_read_64(xhci, addr);
+        temp_64 = readq(addr);
         xhci_dbg(xhci, "  %p: ir_set.erst_base = @%08llx\n",
                         addr, temp_64);
 
         addr = &ir_set->erst_dequeue;
-        temp_64 = xhci_read_64(xhci, addr);
+        temp_64 = readq(addr);
         xhci_dbg(xhci, "  %p: ir_set.erst_dequeue = @%08llx\n",
                         addr, temp_64);
 }
@@ -219,12 +219,12 @@ void xhci_print_run_regs(struct xhci_hcd *xhci)
         int i;
 
         xhci_dbg(xhci, "xHCI runtime registers at %p:\n", xhci->run_regs);
-        temp = xhci_readl(xhci, &xhci->run_regs->microframe_index);
+        temp = readl(&xhci->run_regs->microframe_index);
         xhci_dbg(xhci, "  %p: Microframe index = 0x%x\n",
                         &xhci->run_regs->microframe_index,
                         (unsigned int) temp);
         for (i = 0; i < 7; ++i) {
-                temp = xhci_readl(xhci, &xhci->run_regs->rsvd[i]);
+                temp = readl(&xhci->run_regs->rsvd[i]);
                 if (temp != XHCI_INIT_VALUE)
                         xhci_dbg(xhci, "  WARN: %p: Rsvd[%i] = 0x%x\n",
                                         &xhci->run_regs->rsvd[i],
@@ -412,7 +412,7 @@ void xhci_dbg_cmd_ptrs(struct xhci_hcd *xhci)
 {
         u64 val;
 
-        val = xhci_read_64(xhci, &xhci->op_regs->cmd_ring);
+        val = readq(&xhci->op_regs->cmd_ring);
         xhci_dbg(xhci, "// xHC command ring deq ptr low bits + flags = @%08x\n",
                         lower_32_bits(val));
         xhci_dbg(xhci, "// xHC command ring deq ptr high bits = @%08x\n",
diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
index 805f2348eeba..9992fbfec85f 100644
--- a/drivers/usb/host/xhci-hub.c
+++ b/drivers/usb/host/xhci-hub.c
@@ -94,7 +94,7 @@ static void xhci_usb2_hub_descriptor(struct usb_hcd *hcd, struct xhci_hcd *xhci,
          */
         memset(port_removable, 0, sizeof(port_removable));
         for (i = 0; i < ports; i++) {
-                portsc = xhci_readl(xhci, xhci->usb2_ports[i]);
+                portsc = readl(xhci->usb2_ports[i]);
                 /* If a device is removable, PORTSC reports a 0, same as in the
                  * hub descriptor DeviceRemovable bits.
                  */
@@ -148,7 +148,7 @@ static void xhci_usb3_hub_descriptor(struct usb_hcd *hcd, struct xhci_hcd *xhci,
         port_removable = 0;
         /* bit 0 is reserved, bit 1 is for port 1, etc. */
         for (i = 0; i < ports; i++) {
-                portsc = xhci_readl(xhci, xhci->usb3_ports[i]);
+                portsc = readl(xhci->usb3_ports[i]);
                 if (portsc & PORT_DEV_REMOVE)
                         port_removable |= 1 << (i + 1);
         }
@@ -342,8 +342,8 @@ static void xhci_disable_port(struct usb_hcd *hcd, struct xhci_hcd *xhci,
         }
 
         /* Write 1 to disable the port */
-        xhci_writel(xhci, port_status | PORT_PE, addr);
-        port_status = xhci_readl(xhci, addr);
+        writel(port_status | PORT_PE, addr);
+        port_status = readl(addr);
         xhci_dbg(xhci, "disable port, actual port %d status  = 0x%x\n",
                         wIndex, port_status);
 }
@@ -388,8 +388,8 @@ static void xhci_clear_port_change_bit(struct xhci_hcd *xhci, u16 wValue,
                 return;
         }
         /* Change bits are all write 1 to clear */
-        xhci_writel(xhci, port_status | status, addr);
-        port_status = xhci_readl(xhci, addr);
+        writel(port_status | status, addr);
+        port_status = readl(addr);
         xhci_dbg(xhci, "clear port %s change, actual port %d status  = 0x%x\n",
                         port_change_bit, wIndex, port_status);
 }
@@ -415,11 +415,11 @@ void xhci_set_link_state(struct xhci_hcd *xhci, __le32 __iomem **port_array,
 {
         u32 temp;
 
-        temp = xhci_readl(xhci, port_array[port_id]);
+        temp = readl(port_array[port_id]);
         temp = xhci_port_state_to_neutral(temp);
         temp &= ~PORT_PLS_MASK;
         temp |= PORT_LINK_STROBE | link_state;
-        xhci_writel(xhci, temp, port_array[port_id]);
+        writel(temp, port_array[port_id]);
 }
 
 static void xhci_set_remote_wake_mask(struct xhci_hcd *xhci,
@@ -427,7 +427,7 @@ static void xhci_set_remote_wake_mask(struct xhci_hcd *xhci,
 {
         u32 temp;
 
-        temp = xhci_readl(xhci, port_array[port_id]);
+        temp = readl(port_array[port_id]);
         temp = xhci_port_state_to_neutral(temp);
 
         if (wake_mask & USB_PORT_FEAT_REMOTE_WAKE_CONNECT)
@@ -445,7 +445,7 @@ static void xhci_set_remote_wake_mask(struct xhci_hcd *xhci,
         else
                 temp &= ~PORT_WKOC_E;
 
-        xhci_writel(xhci, temp, port_array[port_id]);
+        writel(temp, port_array[port_id]);
 }
 
 /* Test and clear port RWC bit */
@@ -454,11 +454,11 @@ void xhci_test_and_clear_bit(struct xhci_hcd *xhci, __le32 __iomem **port_array,
 {
         u32 temp;
 
-        temp = xhci_readl(xhci, port_array[port_id]);
+        temp = readl(port_array[port_id]);
         if (temp & port_bit) {
                 temp = xhci_port_state_to_neutral(temp);
                 temp |= port_bit;
-                xhci_writel(xhci, temp, port_array[port_id]);
+                writel(temp, port_array[port_id]);
         }
 }
 
@@ -623,8 +623,7 @@ static u32 xhci_get_port_status(struct usb_hcd *hcd,
                                 }
                                 xhci_ring_device(xhci, slot_id);
                         } else {
-                                int port_status = xhci_readl(xhci,
-                                                port_array[wIndex]);
+                                int port_status = readl(port_array[wIndex]);
                                 xhci_warn(xhci, "Port resume took longer than %i msec, port status = 0x%x\n",
                                                 XHCI_MAX_REXIT_TIMEOUT,
                                                 port_status);
@@ -733,12 +732,12 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 /* Set the U1 and U2 exit latencies. */
                 memcpy(buf, &usb_bos_descriptor,
                                 USB_DT_BOS_SIZE + USB_DT_USB_SS_CAP_SIZE);
-                temp = xhci_readl(xhci, &xhci->cap_regs->hcs_params3);
+                temp = readl(&xhci->cap_regs->hcs_params3);
                 buf[12] = HCS_U1_LATENCY(temp);
                 put_unaligned_le16(HCS_U2_LATENCY(temp), &buf[13]);
 
                 /* Indicate whether the host has LTM support. */
-                temp = xhci_readl(xhci, &xhci->cap_regs->hcc_params);
+                temp = readl(&xhci->cap_regs->hcc_params);
                 if (HCC_LTC(temp))
                         buf[8] |= USB_LTM_SUPPORT;
 
@@ -748,7 +747,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 if (!wIndex || wIndex > max_ports)
                         goto error;
                 wIndex--;
-                temp = xhci_readl(xhci, port_array[wIndex]);
+                temp = readl(port_array[wIndex]);
                 if (temp == 0xffffffff) {
                         retval = -ENODEV;
                         break;
@@ -775,7 +774,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 if (!wIndex || wIndex > max_ports)
                         goto error;
                 wIndex--;
-                temp = xhci_readl(xhci, port_array[wIndex]);
+                temp = readl(port_array[wIndex]);
                 if (temp == 0xffffffff) {
                         retval = -ENODEV;
                         break;
@@ -784,7 +783,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 /* FIXME: What new port features do we need to support? */
                 switch (wValue) {
                 case USB_PORT_FEAT_SUSPEND:
-                        temp = xhci_readl(xhci, port_array[wIndex]);
+                        temp = readl(port_array[wIndex]);
                         if ((temp & PORT_PLS_MASK) != XDEV_U0) {
                                 /* Resume the port to U0 first */
                                 xhci_set_link_state(xhci, port_array, wIndex,
@@ -797,7 +796,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                          * a port unless the port reports that it is in the
                          * enabled (PED = ‘1’,PLS < ‘3’) state.
                          */
-                        temp = xhci_readl(xhci, port_array[wIndex]);
+                        temp = readl(port_array[wIndex]);
                         if ((temp & PORT_PE) == 0 || (temp & PORT_RESET)
                                 || (temp & PORT_PLS_MASK) >= XDEV_U3) {
                                 xhci_warn(xhci, "USB core suspending device "
@@ -822,11 +821,11 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         msleep(10); /* wait device to enter */
                         spin_lock_irqsave(&xhci->lock, flags);
 
-                        temp = xhci_readl(xhci, port_array[wIndex]);
+                        temp = readl(port_array[wIndex]);
                         bus_state->suspended_ports |= 1 << wIndex;
                         break;
                 case USB_PORT_FEAT_LINK_STATE:
-                        temp = xhci_readl(xhci, port_array[wIndex]);
+                        temp = readl(port_array[wIndex]);
 
                         /* Disable port */
                         if (link_state == USB_SS_PORT_LS_SS_DISABLED) {
@@ -839,9 +838,8 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                                 temp |= PORT_CSC | PORT_PEC | PORT_WRC |
                                         PORT_OCC | PORT_RC | PORT_PLC |
                                         PORT_CEC;
-                                xhci_writel(xhci, temp | PORT_PE,
-                                        port_array[wIndex]);
-                                temp = xhci_readl(xhci, port_array[wIndex]);
+                                writel(temp | PORT_PE, port_array[wIndex]);
+                                temp = readl(port_array[wIndex]);
                                 break;
                         }
 
@@ -850,7 +848,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                                 xhci_dbg(xhci, "Enable port %d\n", wIndex);
                                 xhci_set_link_state(xhci, port_array, wIndex,
                                                 link_state);
-                                temp = xhci_readl(xhci, port_array[wIndex]);
+                                temp = readl(port_array[wIndex]);
                                 break;
                         }
 
@@ -884,7 +882,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         msleep(20); /* wait device to enter */
                         spin_lock_irqsave(&xhci->lock, flags);
 
-                        temp = xhci_readl(xhci, port_array[wIndex]);
+                        temp = readl(port_array[wIndex]);
                         if (link_state == USB_SS_PORT_LS_U3)
                                 bus_state->suspended_ports |= 1 << wIndex;
                         break;
@@ -895,10 +893,9 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                          * However, khubd will ignore the roothub events until
                          * the roothub is registered.
                          */
-                        xhci_writel(xhci, temp | PORT_POWER,
-                                        port_array[wIndex]);
+                        writel(temp | PORT_POWER, port_array[wIndex]);
 
-                        temp = xhci_readl(xhci, port_array[wIndex]);
+                        temp = readl(port_array[wIndex]);
                         xhci_dbg(xhci, "set port power, actual port %d status  = 0x%x\n", wIndex, temp);
 
                         spin_unlock_irqrestore(&xhci->lock, flags);
@@ -911,52 +908,52 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         break;
                 case USB_PORT_FEAT_RESET:
                         temp = (temp | PORT_RESET);
-                        xhci_writel(xhci, temp, port_array[wIndex]);
+                        writel(temp, port_array[wIndex]);
 
-                        temp = xhci_readl(xhci, port_array[wIndex]);
+                        temp = readl(port_array[wIndex]);
                         xhci_dbg(xhci, "set port reset, actual port %d status  = 0x%x\n", wIndex, temp);
                         break;
                 case USB_PORT_FEAT_REMOTE_WAKE_MASK:
                         xhci_set_remote_wake_mask(xhci, port_array,
                                         wIndex, wake_mask);
-                        temp = xhci_readl(xhci, port_array[wIndex]);
+                        temp = readl(port_array[wIndex]);
                         xhci_dbg(xhci, "set port remote wake mask, "
                                         "actual port %d status  = 0x%x\n",
                                         wIndex, temp);
                         break;
                 case USB_PORT_FEAT_BH_PORT_RESET:
                         temp |= PORT_WR;
-                        xhci_writel(xhci, temp, port_array[wIndex]);
+                        writel(temp, port_array[wIndex]);
 
-                        temp = xhci_readl(xhci, port_array[wIndex]);
+                        temp = readl(port_array[wIndex]);
                         break;
                 case USB_PORT_FEAT_U1_TIMEOUT:
                         if (hcd->speed != HCD_USB3)
                                 goto error;
-                        temp = xhci_readl(xhci, port_array[wIndex] + PORTPMSC);
+                        temp = readl(port_array[wIndex] + PORTPMSC);
                         temp &= ~PORT_U1_TIMEOUT_MASK;
                         temp |= PORT_U1_TIMEOUT(timeout);
-                        xhci_writel(xhci, temp, port_array[wIndex] + PORTPMSC);
+                        writel(temp, port_array[wIndex] + PORTPMSC);
                         break;
                 case USB_PORT_FEAT_U2_TIMEOUT:
                         if (hcd->speed != HCD_USB3)
                                 goto error;
-                        temp = xhci_readl(xhci, port_array[wIndex] + PORTPMSC);
+                        temp = readl(port_array[wIndex] + PORTPMSC);
                         temp &= ~PORT_U2_TIMEOUT_MASK;
                         temp |= PORT_U2_TIMEOUT(timeout);
-                        xhci_writel(xhci, temp, port_array[wIndex] + PORTPMSC);
+                        writel(temp, port_array[wIndex] + PORTPMSC);
                         break;
                 default:
                         goto error;
                 }
                 /* unblock any posted writes */
-                temp = xhci_readl(xhci, port_array[wIndex]);
+                temp = readl(port_array[wIndex]);
                 break;
         case ClearPortFeature:
                 if (!wIndex || wIndex > max_ports)
                         goto error;
                 wIndex--;
-                temp = xhci_readl(xhci, port_array[wIndex]);
+                temp = readl(port_array[wIndex]);
                 if (temp == 0xffffffff) {
                         retval = -ENODEV;
                         break;
@@ -965,7 +962,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 temp = xhci_port_state_to_neutral(temp);
                 switch (wValue) {
                 case USB_PORT_FEAT_SUSPEND:
-                        temp = xhci_readl(xhci, port_array[wIndex]);
+                        temp = readl(port_array[wIndex]);
                         xhci_dbg(xhci, "clear USB_PORT_FEAT_SUSPEND\n");
                         xhci_dbg(xhci, "PORTSC %04x\n", temp);
                         if (temp & PORT_RESET)
@@ -1008,8 +1005,7 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                                         port_array[wIndex], temp);
                         break;
                 case USB_PORT_FEAT_POWER:
-                        xhci_writel(xhci, temp & ~PORT_POWER,
-                                port_array[wIndex]);
+                        writel(temp & ~PORT_POWER, port_array[wIndex]);
 
                         spin_unlock_irqrestore(&xhci->lock, flags);
                         temp = usb_acpi_power_manageable(hcd->self.root_hub,
@@ -1070,7 +1066,7 @@ int xhci_hub_status_data(struct usb_hcd *hcd, char *buf)
         spin_lock_irqsave(&xhci->lock, flags);
         /* For each port, did anything change?  If so, set that bit in buf. */
         for (i = 0; i < max_ports; i++) {
-                temp = xhci_readl(xhci, port_array[i]);
+                temp = readl(port_array[i]);
                 if (temp == 0xffffffff) {
                         retval = -ENODEV;
                         break;
@@ -1124,7 +1120,7 @@ int xhci_bus_suspend(struct usb_hcd *hcd)
                 u32 t1, t2;
                 int slot_id;
 
-                t1 = xhci_readl(xhci, port_array[port_index]);
+                t1 = readl(port_array[port_index]);
                 t2 = xhci_port_state_to_neutral(t1);
 
                 if ((t1 & PORT_PE) && !(t1 & PORT_PLS_MASK)) {
@@ -1157,7 +1153,7 @@ int xhci_bus_suspend(struct usb_hcd *hcd)
 
                 t1 = xhci_port_state_to_neutral(t1);
                 if (t1 != t2)
-                        xhci_writel(xhci, t2, port_array[port_index]);
+                        writel(t2, port_array[port_index]);
         }
         hcd->state = HC_STATE_SUSPENDED;
         bus_state->next_statechange = jiffies + msecs_to_jiffies(10);
@@ -1187,9 +1183,9 @@ int xhci_bus_resume(struct usb_hcd *hcd)
         }
 
         /* delay the irqs */
-        temp = xhci_readl(xhci, &xhci->op_regs->command);
+        temp = readl(&xhci->op_regs->command);
         temp &= ~CMD_EIE;
-        xhci_writel(xhci, temp, &xhci->op_regs->command);
+        writel(temp, &xhci->op_regs->command);
 
         port_index = max_ports;
         while (port_index--) {
@@ -1198,7 +1194,7 @@ int xhci_bus_resume(struct usb_hcd *hcd)
                 u32 temp;
                 int slot_id;
 
-                temp = xhci_readl(xhci, port_array[port_index]);
+                temp = readl(port_array[port_index]);
                 if (DEV_SUPERSPEED(temp))
                         temp &= ~(PORT_RWC_BITS | PORT_CEC | PORT_WAKE_BITS);
                 else
@@ -1235,17 +1231,17 @@ int xhci_bus_resume(struct usb_hcd *hcd)
                         if (slot_id)
                                 xhci_ring_device(xhci, slot_id);
                 } else
-                        xhci_writel(xhci, temp, port_array[port_index]);
+                        writel(temp, port_array[port_index]);
         }
 
-        (void) xhci_readl(xhci, &xhci->op_regs->command);
+        (void) readl(&xhci->op_regs->command);
 
         bus_state->next_statechange = jiffies + msecs_to_jiffies(5);
         /* re-enable irqs */
-        temp = xhci_readl(xhci, &xhci->op_regs->command);
+        temp = readl(&xhci->op_regs->command);
         temp |= CMD_EIE;
-        xhci_writel(xhci, temp, &xhci->op_regs->command);
-        temp = xhci_readl(xhci, &xhci->op_regs->command);
+        writel(temp, &xhci->op_regs->command);
+        temp = readl(&xhci->op_regs->command);
 
         spin_unlock_irqrestore(&xhci->lock, flags);
         return 0;
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index 49b8bd063fab..873c272b3ef5 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -57,7 +57,7 @@ static struct xhci_segment *xhci_segment_alloc(struct xhci_hcd *xhci,
         /* If the cycle state is 0, set the cycle bit to 1 for all the TRBs */
         if (cycle_state == 0) {
                 for (i = 0; i < TRBS_PER_SEGMENT; i++)
-                        seg->trbs[i].link.control |= TRB_CYCLE;
+                        seg->trbs[i].link.control |= cpu_to_le32(TRB_CYCLE);
         }
         seg->dma = dma;
         seg->next = NULL;
@@ -308,7 +308,8 @@ static void xhci_reinit_cached_ring(struct xhci_hcd *xhci,
                                 sizeof(union xhci_trb)*TRBS_PER_SEGMENT);
                 if (cycle_state == 0) {
                         for (i = 0; i < TRBS_PER_SEGMENT; i++)
-                                seg->trbs[i].link.control |= TRB_CYCLE;
+                                seg->trbs[i].link.control |=
+                                        cpu_to_le32(TRB_CYCLE);
                 }
                 /* All endpoint rings have link TRBs */
                 xhci_link_segments(xhci, seg, seg->next, type);
@@ -432,10 +433,10 @@ static void xhci_free_stream_ctx(struct xhci_hcd *xhci,
                 unsigned int num_stream_ctxs,
                 struct xhci_stream_ctx *stream_ctx, dma_addr_t dma)
 {
-        struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller);
+        struct device *dev = xhci_to_hcd(xhci)->self.controller;
 
         if (num_stream_ctxs > MEDIUM_STREAM_ARRAY_SIZE)
-                dma_free_coherent(&pdev->dev,
+                dma_free_coherent(dev,
                                 sizeof(struct xhci_stream_ctx)*num_stream_ctxs,
                                 stream_ctx, dma);
         else if (num_stream_ctxs <= SMALL_STREAM_ARRAY_SIZE)
@@ -460,10 +461,10 @@ static struct xhci_stream_ctx *xhci_alloc_stream_ctx(struct xhci_hcd *xhci,
                 unsigned int num_stream_ctxs, dma_addr_t *dma,
                 gfp_t mem_flags)
 {
-        struct pci_dev *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller);
+        struct device *dev = xhci_to_hcd(xhci)->self.controller;
 
         if (num_stream_ctxs > MEDIUM_STREAM_ARRAY_SIZE)
-                return dma_alloc_coherent(&pdev->dev,
+                return dma_alloc_coherent(dev,
                                 sizeof(struct xhci_stream_ctx)*num_stream_ctxs,
                                 dma, mem_flags);
         else if (num_stream_ctxs <= SMALL_STREAM_ARRAY_SIZE)
@@ -721,8 +722,7 @@ void xhci_free_stream_info(struct xhci_hcd *xhci,
                                 stream_info->stream_ctx_array,
                                 stream_info->ctx_array_dma);
 
-        if (stream_info)
-                kfree(stream_info->stream_rings);
+        kfree(stream_info->stream_rings);
         kfree(stream_info);
 }
 
@@ -1616,7 +1616,7 @@ static void scratchpad_free(struct xhci_hcd *xhci)
 {
         int num_sp;
         int i;
-        struct pci_dev  *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller);
+        struct device *dev = xhci_to_hcd(xhci)->self.controller;
 
         if (!xhci->scratchpad)
                 return;
@@ -1624,13 +1624,13 @@ static void scratchpad_free(struct xhci_hcd *xhci)
         num_sp = HCS_MAX_SCRATCHPAD(xhci->hcs_params2);
 
         for (i = 0; i < num_sp; i++) {
-                dma_free_coherent(&pdev->dev, xhci->page_size,
+                dma_free_coherent(dev, xhci->page_size,
                                     xhci->scratchpad->sp_buffers[i],
                                     xhci->scratchpad->sp_dma_buffers[i]);
         }
         kfree(xhci->scratchpad->sp_dma_buffers);
         kfree(xhci->scratchpad->sp_buffers);
-        dma_free_coherent(&pdev->dev, num_sp * sizeof(u64),
+        dma_free_coherent(dev, num_sp * sizeof(u64),
                             xhci->scratchpad->sp_array,
                             xhci->scratchpad->sp_dma);
         kfree(xhci->scratchpad);
@@ -1692,7 +1692,7 @@ void xhci_free_command(struct xhci_hcd *xhci,
 
 void xhci_mem_cleanup(struct xhci_hcd *xhci)
 {
-        struct pci_dev  *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller);
+        struct device   *dev = xhci_to_hcd(xhci)->self.controller;
         struct xhci_cd  *cur_cd, *next_cd;
         int size;
         int i, j, num_ports;
@@ -1700,7 +1700,7 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
         /* Free the Event Ring Segment Table and the actual Event Ring */
         size = sizeof(struct xhci_erst_entry)*(xhci->erst.num_entries);
         if (xhci->erst.entries)
-                dma_free_coherent(&pdev->dev, size,
+                dma_free_coherent(dev, size,
                                 xhci->erst.entries, xhci->erst.erst_dma_addr);
         xhci->erst.entries = NULL;
         xhci_dbg_trace(xhci, trace_xhci_dbg_init, "Freed ERST");
@@ -1748,7 +1748,7 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
                         "Freed medium stream array pool");
 
         if (xhci->dcbaa)
-                dma_free_coherent(&pdev->dev, sizeof(*xhci->dcbaa),
+                dma_free_coherent(dev, sizeof(*xhci->dcbaa),
                                 xhci->dcbaa, xhci->dcbaa->dma);
         xhci->dcbaa = NULL;
 
@@ -1958,7 +1958,7 @@ static void xhci_set_hc_event_deq(struct xhci_hcd *xhci)
                 xhci_warn(xhci, "WARN something wrong with SW event ring "
                                 "dequeue ptr.\n");
         /* Update HC event ring dequeue pointer */
-        temp = xhci_read_64(xhci, &xhci->ir_set->erst_dequeue);
+        temp = readq(&xhci->ir_set->erst_dequeue);
         temp &= ERST_PTR_MASK;
         /* Don't clear the EHB bit (which is RW1C) because
          * there might be more events to service.
@@ -1967,7 +1967,7 @@ static void xhci_set_hc_event_deq(struct xhci_hcd *xhci)
         xhci_dbg_trace(xhci, trace_xhci_dbg_init,
                         "// Write event ring dequeue pointer, "
                         "preserving EHB bit");
-        xhci_write_64(xhci, ((u64) deq & (u64) ~ERST_PTR_MASK) | temp,
+        writeq(((u64) deq & (u64) ~ERST_PTR_MASK) | temp,
                         &xhci->ir_set->erst_dequeue);
 }
 
@@ -1986,7 +1986,7 @@ static void xhci_add_in_port(struct xhci_hcd *xhci, unsigned int num_ports,
         }
 
         /* Port offset and count in the third dword, see section 7.2 */
-        temp = xhci_readl(xhci, addr + 2);
+        temp = readl(addr + 2);
         port_offset = XHCI_EXT_PORT_OFF(temp);
         port_count = XHCI_EXT_PORT_COUNT(temp);
         xhci_dbg_trace(xhci, trace_xhci_dbg_init,
@@ -2069,7 +2069,7 @@ static int xhci_setup_port_arrays(struct xhci_hcd *xhci, gfp_t flags)
         int cap_count = 0;
 
         addr = &xhci->cap_regs->hcc_params;
-        offset = XHCI_HCC_EXT_CAPS(xhci_readl(xhci, addr));
+        offset = XHCI_HCC_EXT_CAPS(readl(addr));
         if (offset == 0) {
                 xhci_err(xhci, "No Extended Capability registers, "
                                 "unable to set up roothub.\n");
@@ -2106,7 +2106,7 @@ static int xhci_setup_port_arrays(struct xhci_hcd *xhci, gfp_t flags)
         /* count extended protocol capability entries for later caching */
         do {
                 u32 cap_id;
-                cap_id = xhci_readl(xhci, tmp_addr);
+                cap_id = readl(tmp_addr);
                 if (XHCI_EXT_CAPS_ID(cap_id) == XHCI_EXT_CAPS_PROTOCOL)
                         cap_count++;
                 tmp_offset = XHCI_EXT_CAPS_NEXT(cap_id);
@@ -2120,7 +2120,7 @@ static int xhci_setup_port_arrays(struct xhci_hcd *xhci, gfp_t flags)
         while (1) {
                 u32 cap_id;
 
-                cap_id = xhci_readl(xhci, addr);
+                cap_id = readl(addr);
                 if (XHCI_EXT_CAPS_ID(cap_id) == XHCI_EXT_CAPS_PROTOCOL)
                         xhci_add_in_port(xhci, num_ports, addr,
                                         (u8) XHCI_EXT_PORT_MAJOR(cap_id),
@@ -2224,7 +2224,7 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
 
         INIT_LIST_HEAD(&xhci->cancel_cmd_list);
 
-        page_size = xhci_readl(xhci, &xhci->op_regs->page_size);
+        page_size = readl(&xhci->op_regs->page_size);
         xhci_dbg_trace(xhci, trace_xhci_dbg_init,
                         "Supported page size register = 0x%x", page_size);
         for (i = 0; i < 16; i++) {
@@ -2247,14 +2247,14 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
          * Program the Number of Device Slots Enabled field in the CONFIG
          * register with the max value of slots the HC can handle.
          */
-        val = HCS_MAX_SLOTS(xhci_readl(xhci, &xhci->cap_regs->hcs_params1));
+        val = HCS_MAX_SLOTS(readl(&xhci->cap_regs->hcs_params1));
         xhci_dbg_trace(xhci, trace_xhci_dbg_init,
                         "// xHC can handle at most %d device slots.", val);
-        val2 = xhci_readl(xhci, &xhci->op_regs->config_reg);
+        val2 = readl(&xhci->op_regs->config_reg);
         val |= (val2 & ~HCS_SLOTS_MASK);
         xhci_dbg_trace(xhci, trace_xhci_dbg_init,
                         "// Setting Max device slots reg = 0x%x.", val);
-        xhci_writel(xhci, val, &xhci->op_regs->config_reg);
+        writel(val, &xhci->op_regs->config_reg);
 
         /*
          * Section 5.4.8 - doorbell array must be
@@ -2269,7 +2269,7 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
         xhci_dbg_trace(xhci, trace_xhci_dbg_init,
                         "// Device context base array address = 0x%llx (DMA), %p (virt)",
                         (unsigned long long)xhci->dcbaa->dma, xhci->dcbaa);
-        xhci_write_64(xhci, dma, &xhci->op_regs->dcbaa_ptr);
+        writeq(dma, &xhci->op_regs->dcbaa_ptr);
 
         /*
          * Initialize the ring segment pool.  The ring must be a contiguous
@@ -2312,13 +2312,13 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
                         (unsigned long long)xhci->cmd_ring->first_seg->dma);
 
         /* Set the address in the Command Ring Control register */
-        val_64 = xhci_read_64(xhci, &xhci->op_regs->cmd_ring);
+        val_64 = readq(&xhci->op_regs->cmd_ring);
         val_64 = (val_64 & (u64) CMD_RING_RSVD_BITS) |
                 (xhci->cmd_ring->first_seg->dma & (u64) ~CMD_RING_RSVD_BITS) |
                 xhci->cmd_ring->cycle_state;
         xhci_dbg_trace(xhci, trace_xhci_dbg_init,
                         "// Setting command ring address to 0x%x", val);
-        xhci_write_64(xhci, val_64, &xhci->op_regs->cmd_ring);
+        writeq(val_64, &xhci->op_regs->cmd_ring);
         xhci_dbg_cmd_ptrs(xhci);
 
         xhci->lpm_command = xhci_alloc_command(xhci, true, true, flags);
@@ -2331,7 +2331,7 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
          */
         xhci->cmd_ring_reserved_trbs++;
 
-        val = xhci_readl(xhci, &xhci->cap_regs->db_off);
+        val = readl(&xhci->cap_regs->db_off);
         val &= DBOFF_MASK;
         xhci_dbg_trace(xhci, trace_xhci_dbg_init,
                         "// Doorbell array is located at offset 0x%x"
@@ -2382,13 +2382,13 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
         }
 
         /* set ERST count with the number of entries in the segment table */
-        val = xhci_readl(xhci, &xhci->ir_set->erst_size);
+        val = readl(&xhci->ir_set->erst_size);
         val &= ERST_SIZE_MASK;
         val |= ERST_NUM_SEGS;
         xhci_dbg_trace(xhci, trace_xhci_dbg_init,
                         "// Write ERST size = %i to ir_set 0 (some bits preserved)",
                         val);
-        xhci_writel(xhci, val, &xhci->ir_set->erst_size);
+        writel(val, &xhci->ir_set->erst_size);
 
         xhci_dbg_trace(xhci, trace_xhci_dbg_init,
                         "// Set ERST entries to point to event ring.");
@@ -2396,10 +2396,10 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
         xhci_dbg_trace(xhci, trace_xhci_dbg_init,
                         "// Set ERST base address for ir_set 0 = 0x%llx",
                         (unsigned long long)xhci->erst.erst_dma_addr);
-        val_64 = xhci_read_64(xhci, &xhci->ir_set->erst_base);
+        val_64 = readq(&xhci->ir_set->erst_base);
         val_64 &= ERST_PTR_MASK;
         val_64 |= (xhci->erst.erst_dma_addr & (u64) ~ERST_PTR_MASK);
-        xhci_write_64(xhci, val_64, &xhci->ir_set->erst_base);
+        writeq(val_64, &xhci->ir_set->erst_base);
 
         /* Set the event ring dequeue address */
         xhci_set_hc_event_deq(xhci);
@@ -2431,10 +2431,10 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
          * is necessary for allowing USB 3.0 devices to do remote wakeup from
          * U3 (device suspend).
          */
-        temp = xhci_readl(xhci, &xhci->op_regs->dev_notification);
+        temp = readl(&xhci->op_regs->dev_notification);
         temp &= ~DEV_NOTE_MASK;
         temp |= DEV_NOTE_FWAKE;
-        xhci_writel(xhci, temp, &xhci->op_regs->dev_notification);
+        writel(temp, &xhci->op_regs->dev_notification);
 
         return 0;
 
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index b8dffd59eb25..4221dee924b5 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -331,6 +331,7 @@ static const struct hc_driver xhci_pci_hc_driver = {
         .check_bandwidth =      xhci_check_bandwidth,
         .reset_bandwidth =      xhci_reset_bandwidth,
         .address_device =       xhci_address_device,
+        .enable_device =        xhci_enable_device,
         .update_hub_device =    xhci_update_hub_device,
         .reset_device =         xhci_discover_or_reset_device,
 
diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
index d9c169f470d3..8abda5c73ca1 100644
--- a/drivers/usb/host/xhci-plat.c
+++ b/drivers/usb/host/xhci-plat.c
@@ -69,6 +69,7 @@ static const struct hc_driver xhci_plat_xhci_driver = {
         .check_bandwidth =      xhci_check_bandwidth,
         .reset_bandwidth =      xhci_reset_bandwidth,
         .address_device =       xhci_address_device,
+        .enable_device =        xhci_enable_device,
         .update_hub_device =    xhci_update_hub_device,
         .reset_device =         xhci_discover_or_reset_device,
 
@@ -139,6 +140,7 @@ static int xhci_plat_probe(struct platform_device *pdev)
         ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (ret)
                 goto unmap_registers;
+        device_wakeup_enable(hcd->self.controller);
 
         /* USB 2.0 roothub is stored in the platform_device now. */
         hcd = platform_get_drvdata(pdev);
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 53c2e296467f..c06df38b57b0 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -295,9 +295,9 @@ void xhci_ring_cmd_db(struct xhci_hcd *xhci)
                 return;
 
         xhci_dbg(xhci, "// Ding dong!\n");
-        xhci_writel(xhci, DB_VALUE_HOST, &xhci->dba->doorbell[0]);
+        writel(DB_VALUE_HOST, &xhci->dba->doorbell[0]);
         /* Flush PCI posted writes */
-        xhci_readl(xhci, &xhci->dba->doorbell[0]);
+        readl(&xhci->dba->doorbell[0]);
 }
 
 static int xhci_abort_cmd_ring(struct xhci_hcd *xhci)
@@ -313,14 +313,13 @@ static int xhci_abort_cmd_ring(struct xhci_hcd *xhci)
                 return 0;
         }
 
-        temp_64 = xhci_read_64(xhci, &xhci->op_regs->cmd_ring);
+        temp_64 = readq(&xhci->op_regs->cmd_ring);
         if (!(temp_64 & CMD_RING_RUNNING)) {
                 xhci_dbg(xhci, "Command ring had been stopped\n");
                 return 0;
         }
         xhci->cmd_ring_state = CMD_RING_STATE_ABORTED;
-        xhci_write_64(xhci, temp_64 | CMD_RING_ABORT,
-                        &xhci->op_regs->cmd_ring);
+        writeq(temp_64 | CMD_RING_ABORT, &xhci->op_regs->cmd_ring);
 
         /* Section 4.6.1.2 of xHCI 1.0 spec says software should
          * time the completion od all xHCI commands, including
@@ -427,7 +426,7 @@ void xhci_ring_ep_doorbell(struct xhci_hcd *xhci,
         if ((ep_state & EP_HALT_PENDING) || (ep_state & SET_DEQ_PENDING) ||
             (ep_state & EP_HALTED))
                 return;
-        xhci_writel(xhci, DB_VALUE(ep_index, stream_id), db_addr);
+        writel(DB_VALUE(ep_index, stream_id), db_addr);
         /* The CPU has better things to do at this point than wait for a
          * write-posting flush.  It'll get there soon enough.
          */
@@ -1655,7 +1654,7 @@ static void handle_device_notification(struct xhci_hcd *xhci,
         u32 slot_id;
         struct usb_device *udev;
 
-        slot_id = TRB_TO_SLOT_ID(event->generic.field[3]);
+        slot_id = TRB_TO_SLOT_ID(le32_to_cpu(event->generic.field[3]));
         if (!xhci->devs[slot_id]) {
                 xhci_warn(xhci, "Device Notification event for "
                                 "unused slot %u\n", slot_id);
@@ -1739,7 +1738,7 @@ static void handle_port_status(struct xhci_hcd *xhci,
         faked_port_index = find_faked_portnum_from_hw_portnum(hcd, xhci,
                         port_id);
 
-        temp = xhci_readl(xhci, port_array[faked_port_index]);
+        temp = readl(port_array[faked_port_index]);
         if (hcd->state == HC_STATE_SUSPENDED) {
                 xhci_dbg(xhci, "resume root hub\n");
                 usb_hcd_resume_root_hub(hcd);
@@ -1748,7 +1747,7 @@ static void handle_port_status(struct xhci_hcd *xhci,
         if ((temp & PORT_PLC) && (temp & PORT_PLS_MASK) == XDEV_RESUME) {
                 xhci_dbg(xhci, "port resume event for port %d\n", port_id);
 
-                temp1 = xhci_readl(xhci, &xhci->op_regs->command);
+                temp1 = readl(&xhci->op_regs->command);
                 if (!(temp1 & CMD_RUN)) {
                         xhci_warn(xhci, "xHC is not running.\n");
                         goto cleanup;
@@ -2831,7 +2830,7 @@ irqreturn_t xhci_irq(struct usb_hcd *hcd)
 
         spin_lock(&xhci->lock);
         /* Check if the xHC generated the interrupt, or the irq is shared */
-        status = xhci_readl(xhci, &xhci->op_regs->status);
+        status = readl(&xhci->op_regs->status);
         if (status == 0xffffffff)
                 goto hw_died;
 
@@ -2853,16 +2852,16 @@ hw_died:
          * Write 1 to clear the interrupt status.
          */
         status |= STS_EINT;
-        xhci_writel(xhci, status, &xhci->op_regs->status);
+        writel(status, &xhci->op_regs->status);
         /* FIXME when MSI-X is supported and there are multiple vectors */
         /* Clear the MSI-X event interrupt status */
 
         if (hcd->irq) {
                 u32 irq_pending;
                 /* Acknowledge the PCI interrupt */
-                irq_pending = xhci_readl(xhci, &xhci->ir_set->irq_pending);
+                irq_pending = readl(&xhci->ir_set->irq_pending);
                 irq_pending |= IMAN_IP;
-                xhci_writel(xhci, irq_pending, &xhci->ir_set->irq_pending);
+                writel(irq_pending, &xhci->ir_set->irq_pending);
         }
 
         if (xhci->xhc_state & XHCI_STATE_DYING) {
@@ -2871,9 +2870,8 @@ hw_died:
                 /* Clear the event handler busy flag (RW1C);
                  * the event ring should be empty.
                  */
-                temp_64 = xhci_read_64(xhci, &xhci->ir_set->erst_dequeue);
-                xhci_write_64(xhci, temp_64 | ERST_EHB,
-                                &xhci->ir_set->erst_dequeue);
+                temp_64 = readq(&xhci->ir_set->erst_dequeue);
+                writeq(temp_64 | ERST_EHB, &xhci->ir_set->erst_dequeue);
                 spin_unlock(&xhci->lock);
 
                 return IRQ_HANDLED;
@@ -2885,7 +2883,7 @@ hw_died:
          */
         while (xhci_handle_event(xhci) > 0) {}
 
-        temp_64 = xhci_read_64(xhci, &xhci->ir_set->erst_dequeue);
+        temp_64 = readq(&xhci->ir_set->erst_dequeue);
         /* If necessary, update the HW's version of the event ring deq ptr. */
         if (event_ring_deq != xhci->event_ring->dequeue) {
                 deq = xhci_trb_virt_to_dma(xhci->event_ring->deq_seg,
@@ -2900,7 +2898,7 @@ hw_died:
 
         /* Clear the event handler busy flag (RW1C); event ring is empty. */
         temp_64 |= ERST_EHB;
-        xhci_write_64(xhci, temp_64, &xhci->ir_set->erst_dequeue);
+        writeq(temp_64, &xhci->ir_set->erst_dequeue);
 
         spin_unlock(&xhci->lock);
 
@@ -3981,7 +3979,7 @@ int xhci_queue_isoc_tx_prepare(struct xhci_hcd *xhci, gfp_t mem_flags,
         if (ret)
                 return ret;
 
-        start_frame = xhci_readl(xhci, &xhci->run_regs->microframe_index);
+        start_frame = readl(&xhci->run_regs->microframe_index);
         start_frame &= 0x3fff;
 
         urb->start_frame = start_frame;
@@ -4056,12 +4054,12 @@ int xhci_queue_slot_control(struct xhci_hcd *xhci, u32 trb_type, u32 slot_id)
 
 /* Queue an address device command TRB */
 int xhci_queue_address_device(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
-                u32 slot_id)
+                              u32 slot_id, enum xhci_setup_dev setup)
 {
         return queue_command(xhci, lower_32_bits(in_ctx_ptr),
                         upper_32_bits(in_ctx_ptr), 0,
-                        TRB_TYPE(TRB_ADDR_DEV) | SLOT_ID_FOR_TRB(slot_id),
-                        false);
+                        TRB_TYPE(TRB_ADDR_DEV) | SLOT_ID_FOR_TRB(slot_id)
+                        | (setup == SETUP_CONTEXT_ONLY ? TRB_BSR : 0), false);
 }
 
 int xhci_queue_vendor_command(struct xhci_hcd *xhci,
diff --git a/drivers/usb/host/xhci-trace.h b/drivers/usb/host/xhci-trace.h
index 20364cc8d2fb..dde3959b7a33 100644
--- a/drivers/usb/host/xhci-trace.h
+++ b/drivers/usb/host/xhci-trace.h
@@ -116,12 +116,12 @@ DECLARE_EVENT_CLASS(xhci_log_event,
                 __field(u64, dma)
                 __field(u32, status)
                 __field(u32, flags)
-                __dynamic_array(__le32, trb, 4)
+                __dynamic_array(u8, trb, sizeof(struct xhci_generic_trb))
         ),
         TP_fast_assign(
                 __entry->va = trb_va;
-                __entry->dma = le64_to_cpu(((u64)ev->field[1]) << 32 |
-                                                ev->field[0]);
+                __entry->dma = ((u64)le32_to_cpu(ev->field[1])) << 32 |
+                                        le32_to_cpu(ev->field[0]);
                 __entry->status = le32_to_cpu(ev->field[2]);
                 __entry->flags = le32_to_cpu(ev->field[3]);
                 memcpy(__get_dynamic_array(trb), trb_va,
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 4265b48856f6..d68ec1aa473d 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -60,7 +60,7 @@ int xhci_handshake(struct xhci_hcd *xhci, void __iomem *ptr,
         u32     result;
 
         do {
-                result = xhci_readl(xhci, ptr);
+                result = readl(ptr);
                 if (result == ~(u32)0)          /* card removed */
                         return -ENODEV;
                 result &= mask;
@@ -82,13 +82,13 @@ void xhci_quiesce(struct xhci_hcd *xhci)
         u32 mask;
 
         mask = ~(XHCI_IRQS);
-        halted = xhci_readl(xhci, &xhci->op_regs->status) & STS_HALT;
+        halted = readl(&xhci->op_regs->status) & STS_HALT;
         if (!halted)
                 mask &= ~CMD_RUN;
 
-        cmd = xhci_readl(xhci, &xhci->op_regs->command);
+        cmd = readl(&xhci->op_regs->command);
         cmd &= mask;
-        xhci_writel(xhci, cmd, &xhci->op_regs->command);
+        writel(cmd, &xhci->op_regs->command);
 }
 
 /*
@@ -124,11 +124,11 @@ static int xhci_start(struct xhci_hcd *xhci)
         u32 temp;
         int ret;
 
-        temp = xhci_readl(xhci, &xhci->op_regs->command);
+        temp = readl(&xhci->op_regs->command);
         temp |= (CMD_RUN);
         xhci_dbg_trace(xhci, trace_xhci_dbg_init, "// Turn on HC, cmd = 0x%x.",
                         temp);
-        xhci_writel(xhci, temp, &xhci->op_regs->command);
+        writel(temp, &xhci->op_regs->command);
 
         /*
          * Wait for the HCHalted Status bit to be 0 to indicate the host is
@@ -158,16 +158,16 @@ int xhci_reset(struct xhci_hcd *xhci)
         u32 state;
         int ret, i;
 
-        state = xhci_readl(xhci, &xhci->op_regs->status);
+        state = readl(&xhci->op_regs->status);
         if ((state & STS_HALT) == 0) {
                 xhci_warn(xhci, "Host controller not halted, aborting reset.\n");
                 return 0;
         }
 
         xhci_dbg_trace(xhci, trace_xhci_dbg_init, "// Reset the HC");
-        command = xhci_readl(xhci, &xhci->op_regs->command);
+        command = readl(&xhci->op_regs->command);
         command |= CMD_RESET;
-        xhci_writel(xhci, command, &xhci->op_regs->command);
+        writel(command, &xhci->op_regs->command);
 
         ret = xhci_handshake(xhci, &xhci->op_regs->command,
                         CMD_RESET, 0, 10 * 1000 * 1000);
@@ -422,7 +422,7 @@ static void compliance_mode_recovery(unsigned long arg)
         xhci = (struct xhci_hcd *)arg;
 
         for (i = 0; i < xhci->num_usb3_ports; i++) {
-                temp = xhci_readl(xhci, xhci->usb3_ports[i]);
+                temp = readl(xhci->usb3_ports[i]);
                 if ((temp & PORT_PLS_MASK) == USB_SS_PORT_LS_COMP_MOD) {
                         /*
                          * Compliance Mode Detected. Letting USB Core
@@ -604,31 +604,30 @@ int xhci_run(struct usb_hcd *hcd)
         xhci_dbg(xhci, "Event ring:\n");
         xhci_debug_ring(xhci, xhci->event_ring);
         xhci_dbg_ring_ptrs(xhci, xhci->event_ring);
-        temp_64 = xhci_read_64(xhci, &xhci->ir_set->erst_dequeue);
+        temp_64 = readq(&xhci->ir_set->erst_dequeue);
         temp_64 &= ~ERST_PTR_MASK;
         xhci_dbg_trace(xhci, trace_xhci_dbg_init,
                         "ERST deq = 64'h%0lx", (long unsigned int) temp_64);
 
         xhci_dbg_trace(xhci, trace_xhci_dbg_init,
                         "// Set the interrupt modulation register");
-        temp = xhci_readl(xhci, &xhci->ir_set->irq_control);
+        temp = readl(&xhci->ir_set->irq_control);
         temp &= ~ER_IRQ_INTERVAL_MASK;
         temp |= (u32) 160;
-        xhci_writel(xhci, temp, &xhci->ir_set->irq_control);
+        writel(temp, &xhci->ir_set->irq_control);
 
         /* Set the HCD state before we enable the irqs */
-        temp = xhci_readl(xhci, &xhci->op_regs->command);
+        temp = readl(&xhci->op_regs->command);
         temp |= (CMD_EIE);
         xhci_dbg_trace(xhci, trace_xhci_dbg_init,
                         "// Enable interrupts, cmd = 0x%x.", temp);
-        xhci_writel(xhci, temp, &xhci->op_regs->command);
+        writel(temp, &xhci->op_regs->command);
 
-        temp = xhci_readl(xhci, &xhci->ir_set->irq_pending);
+        temp = readl(&xhci->ir_set->irq_pending);
         xhci_dbg_trace(xhci, trace_xhci_dbg_init,
                         "// Enabling event ring interrupter %p by writing 0x%x to irq_pending",
                         xhci->ir_set, (unsigned int) ER_IRQ_ENABLE(temp));
-        xhci_writel(xhci, ER_IRQ_ENABLE(temp),
-                        &xhci->ir_set->irq_pending);
+        writel(ER_IRQ_ENABLE(temp), &xhci->ir_set->irq_pending);
         xhci_print_ir_set(xhci, 0);
 
         if (xhci->quirks & XHCI_NEC_HOST)
@@ -698,18 +697,17 @@ void xhci_stop(struct usb_hcd *hcd)
 
         xhci_dbg_trace(xhci, trace_xhci_dbg_init,
                         "// Disabling event ring interrupts");
-        temp = xhci_readl(xhci, &xhci->op_regs->status);
-        xhci_writel(xhci, temp & ~STS_EINT, &xhci->op_regs->status);
-        temp = xhci_readl(xhci, &xhci->ir_set->irq_pending);
-        xhci_writel(xhci, ER_IRQ_DISABLE(temp),
-                        &xhci->ir_set->irq_pending);
+        temp = readl(&xhci->op_regs->status);
+        writel(temp & ~STS_EINT, &xhci->op_regs->status);
+        temp = readl(&xhci->ir_set->irq_pending);
+        writel(ER_IRQ_DISABLE(temp), &xhci->ir_set->irq_pending);
         xhci_print_ir_set(xhci, 0);
 
         xhci_dbg_trace(xhci, trace_xhci_dbg_init, "cleaning up memory");
         xhci_mem_cleanup(xhci);
         xhci_dbg_trace(xhci, trace_xhci_dbg_init,
                         "xhci_stop completed - status = %x",
-                        xhci_readl(xhci, &xhci->op_regs->status));
+                        readl(&xhci->op_regs->status));
 }
 
 /*
@@ -739,7 +737,7 @@ void xhci_shutdown(struct usb_hcd *hcd)
 
         xhci_dbg_trace(xhci, trace_xhci_dbg_init,
                         "xhci_shutdown completed - status = %x",
-                        xhci_readl(xhci, &xhci->op_regs->status));
+                        readl(&xhci->op_regs->status));
 
         /* Yet another workaround for spurious wakeups at shutdown with HSW */
         if (xhci->quirks & XHCI_SPURIOUS_WAKEUP)
@@ -749,28 +747,28 @@ void xhci_shutdown(struct usb_hcd *hcd)
 #ifdef CONFIG_PM
 static void xhci_save_registers(struct xhci_hcd *xhci)
 {
-        xhci->s3.command = xhci_readl(xhci, &xhci->op_regs->command);
-        xhci->s3.dev_nt = xhci_readl(xhci, &xhci->op_regs->dev_notification);
-        xhci->s3.dcbaa_ptr = xhci_read_64(xhci, &xhci->op_regs->dcbaa_ptr);
-        xhci->s3.config_reg = xhci_readl(xhci, &xhci->op_regs->config_reg);
-        xhci->s3.erst_size = xhci_readl(xhci, &xhci->ir_set->erst_size);
-        xhci->s3.erst_base = xhci_read_64(xhci, &xhci->ir_set->erst_base);
-        xhci->s3.erst_dequeue = xhci_read_64(xhci, &xhci->ir_set->erst_dequeue);
-        xhci->s3.irq_pending = xhci_readl(xhci, &xhci->ir_set->irq_pending);
-        xhci->s3.irq_control = xhci_readl(xhci, &xhci->ir_set->irq_control);
+        xhci->s3.command = readl(&xhci->op_regs->command);
+        xhci->s3.dev_nt = readl(&xhci->op_regs->dev_notification);
+        xhci->s3.dcbaa_ptr = readq(&xhci->op_regs->dcbaa_ptr);
+        xhci->s3.config_reg = readl(&xhci->op_regs->config_reg);
+        xhci->s3.erst_size = readl(&xhci->ir_set->erst_size);
+        xhci->s3.erst_base = readq(&xhci->ir_set->erst_base);
+        xhci->s3.erst_dequeue = readq(&xhci->ir_set->erst_dequeue);
+        xhci->s3.irq_pending = readl(&xhci->ir_set->irq_pending);
+        xhci->s3.irq_control = readl(&xhci->ir_set->irq_control);
 }
 
 static void xhci_restore_registers(struct xhci_hcd *xhci)
 {
-        xhci_writel(xhci, xhci->s3.command, &xhci->op_regs->command);
-        xhci_writel(xhci, xhci->s3.dev_nt, &xhci->op_regs->dev_notification);
-        xhci_write_64(xhci, xhci->s3.dcbaa_ptr, &xhci->op_regs->dcbaa_ptr);
-        xhci_writel(xhci, xhci->s3.config_reg, &xhci->op_regs->config_reg);
-        xhci_writel(xhci, xhci->s3.erst_size, &xhci->ir_set->erst_size);
-        xhci_write_64(xhci, xhci->s3.erst_base, &xhci->ir_set->erst_base);
-        xhci_write_64(xhci, xhci->s3.erst_dequeue, &xhci->ir_set->erst_dequeue);
-        xhci_writel(xhci, xhci->s3.irq_pending, &xhci->ir_set->irq_pending);
-        xhci_writel(xhci, xhci->s3.irq_control, &xhci->ir_set->irq_control);
+        writel(xhci->s3.command, &xhci->op_regs->command);
+        writel(xhci->s3.dev_nt, &xhci->op_regs->dev_notification);
+        writeq(xhci->s3.dcbaa_ptr, &xhci->op_regs->dcbaa_ptr);
+        writel(xhci->s3.config_reg, &xhci->op_regs->config_reg);
+        writel(xhci->s3.erst_size, &xhci->ir_set->erst_size);
+        writeq(xhci->s3.erst_base, &xhci->ir_set->erst_base);
+        writeq(xhci->s3.erst_dequeue, &xhci->ir_set->erst_dequeue);
+        writel(xhci->s3.irq_pending, &xhci->ir_set->irq_pending);
+        writel(xhci->s3.irq_control, &xhci->ir_set->irq_control);
 }
 
 static void xhci_set_cmd_ring_deq(struct xhci_hcd *xhci)
@@ -778,7 +776,7 @@ static void xhci_set_cmd_ring_deq(struct xhci_hcd *xhci)
         u64     val_64;
 
         /* step 2: initialize command ring buffer */
-        val_64 = xhci_read_64(xhci, &xhci->op_regs->cmd_ring);
+        val_64 = readq(&xhci->op_regs->cmd_ring);
         val_64 = (val_64 & (u64) CMD_RING_RSVD_BITS) |
                 (xhci_trb_virt_to_dma(xhci->cmd_ring->deq_seg,
                                       xhci->cmd_ring->dequeue) &
@@ -787,7 +785,7 @@ static void xhci_set_cmd_ring_deq(struct xhci_hcd *xhci)
         xhci_dbg_trace(xhci, trace_xhci_dbg_init,
                         "// Setting command ring address to 0x%llx",
                         (long unsigned long) val_64);
-        xhci_write_64(xhci, val_64, &xhci->op_regs->cmd_ring);
+        writeq(val_64, &xhci->op_regs->cmd_ring);
 }
 
 /*
@@ -866,9 +864,9 @@ int xhci_suspend(struct xhci_hcd *xhci)
         /* skipped assuming that port suspend has done */
 
         /* step 2: clear Run/Stop bit */
-        command = xhci_readl(xhci, &xhci->op_regs->command);
+        command = readl(&xhci->op_regs->command);
         command &= ~CMD_RUN;
-        xhci_writel(xhci, command, &xhci->op_regs->command);
+        writel(command, &xhci->op_regs->command);
 
         /* Some chips from Fresco Logic need an extraordinary delay */
         delay *= (xhci->quirks & XHCI_SLOW_SUSPEND) ? 10 : 1;
@@ -885,9 +883,9 @@ int xhci_suspend(struct xhci_hcd *xhci)
         xhci_save_registers(xhci);
 
         /* step 4: set CSS flag */
-        command = xhci_readl(xhci, &xhci->op_regs->command);
+        command = readl(&xhci->op_regs->command);
         command |= CMD_CSS;
-        xhci_writel(xhci, command, &xhci->op_regs->command);
+        writel(command, &xhci->op_regs->command);
         if (xhci_handshake(xhci, &xhci->op_regs->status,
                                 STS_SAVE, 0, 10 * 1000)) {
                 xhci_warn(xhci, "WARN: xHC save state timeout\n");
@@ -951,16 +949,16 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
                 xhci_set_cmd_ring_deq(xhci);
                 /* step 3: restore state and start state*/
                 /* step 3: set CRS flag */
-                command = xhci_readl(xhci, &xhci->op_regs->command);
+                command = readl(&xhci->op_regs->command);
                 command |= CMD_CRS;
-                xhci_writel(xhci, command, &xhci->op_regs->command);
+                writel(command, &xhci->op_regs->command);
                 if (xhci_handshake(xhci, &xhci->op_regs->status,
                               STS_RESTORE, 0, 10 * 1000)) {
                         xhci_warn(xhci, "WARN: xHC restore state timeout\n");
                         spin_unlock_irq(&xhci->lock);
                         return -ETIMEDOUT;
                 }
-                temp = xhci_readl(xhci, &xhci->op_regs->status);
+                temp = readl(&xhci->op_regs->status);
         }
 
         /* If restore operation fails, re-initialize the HC during resume */
@@ -984,17 +982,16 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
                 xhci_cleanup_msix(xhci);
 
                 xhci_dbg(xhci, "// Disabling event ring interrupts\n");
-                temp = xhci_readl(xhci, &xhci->op_regs->status);
-                xhci_writel(xhci, temp & ~STS_EINT, &xhci->op_regs->status);
-                temp = xhci_readl(xhci, &xhci->ir_set->irq_pending);
-                xhci_writel(xhci, ER_IRQ_DISABLE(temp),
-                                &xhci->ir_set->irq_pending);
+                temp = readl(&xhci->op_regs->status);
+                writel(temp & ~STS_EINT, &xhci->op_regs->status);
+                temp = readl(&xhci->ir_set->irq_pending);
+                writel(ER_IRQ_DISABLE(temp), &xhci->ir_set->irq_pending);
                 xhci_print_ir_set(xhci, 0);
 
                 xhci_dbg(xhci, "cleaning up memory\n");
                 xhci_mem_cleanup(xhci);
                 xhci_dbg(xhci, "xhci_stop completed - status = %x\n",
-                            xhci_readl(xhci, &xhci->op_regs->status));
+                            readl(&xhci->op_regs->status));
 
                 /* USB core calls the PCI reinit and start functions twice:
                  * first with the primary HCD, and then with the secondary HCD.
@@ -1023,9 +1020,9 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
         }
 
         /* step 4: set Run/Stop bit */
-        command = xhci_readl(xhci, &xhci->op_regs->command);
+        command = readl(&xhci->op_regs->command);
         command |= CMD_RUN;
-        xhci_writel(xhci, command, &xhci->op_regs->command);
+        writel(command, &xhci->op_regs->command);
         xhci_handshake(xhci, &xhci->op_regs->status, STS_HALT,
                   0, 250 * 1000);
 
@@ -1464,7 +1461,7 @@ int xhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
         ret = usb_hcd_check_unlink_urb(hcd, urb, status);
         if (ret || !urb->hcpriv)
                 goto done;
-        temp = xhci_readl(xhci, &xhci->op_regs->status);
+        temp = readl(&xhci->op_regs->status);
         if (temp == 0xffffffff || (xhci->xhc_state & XHCI_STATE_HALTED)) {
                 xhci_dbg_trace(xhci, trace_xhci_dbg_cancel_urb,
                                 "HW died, freeing TD.");
@@ -1892,8 +1889,8 @@ static u32 xhci_count_num_new_endpoints(struct xhci_hcd *xhci,
          * (bit 1).  The default control endpoint is added during the Address
          * Device command and is never removed until the slot is disabled.
          */
-        valid_add_flags = ctrl_ctx->add_flags >> 2;
-        valid_drop_flags = ctrl_ctx->drop_flags >> 2;
+        valid_add_flags = le32_to_cpu(ctrl_ctx->add_flags) >> 2;
+        valid_drop_flags = le32_to_cpu(ctrl_ctx->drop_flags) >> 2;
 
         /* Use hweight32 to count the number of ones in the add flags, or
          * number of endpoints added.  Don't count endpoints that are changed
@@ -1909,8 +1906,8 @@ static unsigned int xhci_count_num_dropped_endpoints(struct xhci_hcd *xhci,
         u32 valid_add_flags;
         u32 valid_drop_flags;
 
-        valid_add_flags = ctrl_ctx->add_flags >> 2;
-        valid_drop_flags = ctrl_ctx->drop_flags >> 2;
+        valid_add_flags = le32_to_cpu(ctrl_ctx->add_flags) >> 2;
+        valid_drop_flags = le32_to_cpu(ctrl_ctx->drop_flags) >> 2;
 
         return hweight32(valid_drop_flags) -
                 hweight32(valid_add_flags & valid_drop_flags);
@@ -3585,7 +3582,7 @@ void xhci_free_dev(struct usb_hcd *hcd, struct usb_device *udev)
 
         spin_lock_irqsave(&xhci->lock, flags);
         /* Don't disable the slot if the host controller is dead. */
-        state = xhci_readl(xhci, &xhci->op_regs->status);
+        state = readl(&xhci->op_regs->status);
         if (state == 0xffffffff || (xhci->xhc_state & XHCI_STATE_DYING) ||
                         (xhci->xhc_state & XHCI_STATE_HALTED)) {
                 xhci_free_virt_device(xhci, udev->slot_id);
@@ -3712,13 +3709,15 @@ disable_slot:
 }
 
 /*
- * Issue an Address Device command (which will issue a SetAddress request to
- * the device).
+ * Issue an Address Device command and optionally send a corresponding
+ * SetAddress request to the device.
  * We should be protected by the usb_address0_mutex in khubd's hub_port_init, so
  * we should only issue and wait on one address command at the same time.
  */
-int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
+static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
+                             enum xhci_setup_dev setup)
 {
+        const char *act = setup == SETUP_CONTEXT_ONLY ? "context" : "address";
         unsigned long flags;
         int timeleft;
         struct xhci_virt_device *virt_dev;
@@ -3771,12 +3770,12 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
         xhci_dbg(xhci, "Slot ID %d Input Context:\n", udev->slot_id);
         xhci_dbg_ctx(xhci, virt_dev->in_ctx, 2);
         trace_xhci_address_ctx(xhci, virt_dev->in_ctx,
-                                slot_ctx->dev_info >> 27);
+                                le32_to_cpu(slot_ctx->dev_info) >> 27);
 
         spin_lock_irqsave(&xhci->lock, flags);
         cmd_trb = xhci_find_next_enqueue(xhci->cmd_ring);
         ret = xhci_queue_address_device(xhci, virt_dev->in_ctx->dma,
-                                        udev->slot_id);
+                                        udev->slot_id, setup);
         if (ret) {
                 spin_unlock_irqrestore(&xhci->lock, flags);
                 xhci_dbg_trace(xhci, trace_xhci_dbg_address,
@@ -3794,8 +3793,8 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
          * command on a timeout.
          */
         if (timeleft <= 0) {
-                xhci_warn(xhci, "%s while waiting for address device command\n",
-                                timeleft == 0 ? "Timeout" : "Signal");
+                xhci_warn(xhci, "%s while waiting for setup %s command\n",
+                          timeleft == 0 ? "Timeout" : "Signal", act);
                 /* cancel the address device command */
                 ret = xhci_cancel_cmd(xhci, NULL, cmd_trb);
                 if (ret < 0)
@@ -3806,26 +3805,27 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
         switch (virt_dev->cmd_status) {
         case COMP_CTX_STATE:
         case COMP_EBADSLT:
-                xhci_err(xhci, "Setup ERROR: address device command for slot %d.\n",
-                                udev->slot_id);
+                xhci_err(xhci, "Setup ERROR: setup %s command for slot %d.\n",
+                         act, udev->slot_id);
                 ret = -EINVAL;
                 break;
         case COMP_TX_ERR:
-                dev_warn(&udev->dev, "Device not responding to set address.\n");
+                dev_warn(&udev->dev, "Device not responding to setup %s.\n", act);
                 ret = -EPROTO;
                 break;
         case COMP_DEV_ERR:
-                dev_warn(&udev->dev, "ERROR: Incompatible device for address "
-                                "device command.\n");
+                dev_warn(&udev->dev,
+                         "ERROR: Incompatible device for setup %s command\n", act);
                 ret = -ENODEV;
                 break;
         case COMP_SUCCESS:
                 xhci_dbg_trace(xhci, trace_xhci_dbg_address,
-                                "Successful Address Device command");
+                               "Successful setup %s command", act);
                 break;
         default:
-                xhci_err(xhci, "ERROR: unexpected command completion "
-                                "code 0x%x.\n", virt_dev->cmd_status);
+                xhci_err(xhci,
+                         "ERROR: unexpected setup %s command completion code 0x%x.\n",
+                         act, virt_dev->cmd_status);
                 xhci_dbg(xhci, "Slot ID %d Output Context:\n", udev->slot_id);
                 xhci_dbg_ctx(xhci, virt_dev->out_ctx, 2);
                 trace_xhci_address_ctx(xhci, virt_dev->out_ctx, 1);
@@ -3835,7 +3835,7 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
         if (ret) {
                 return ret;
         }
-        temp_64 = xhci_read_64(xhci, &xhci->op_regs->dcbaa_ptr);
+        temp_64 = readq(&xhci->op_regs->dcbaa_ptr);
         xhci_dbg_trace(xhci, trace_xhci_dbg_address,
                         "Op regs DCBAA ptr = %#016llx", temp_64);
         xhci_dbg_trace(xhci, trace_xhci_dbg_address,
@@ -3850,7 +3850,7 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
         xhci_dbg(xhci, "Slot ID %d Input Context:\n", udev->slot_id);
         xhci_dbg_ctx(xhci, virt_dev->in_ctx, 2);
         trace_xhci_address_ctx(xhci, virt_dev->in_ctx,
-                                slot_ctx->dev_info >> 27);
+                                le32_to_cpu(slot_ctx->dev_info) >> 27);
         xhci_dbg(xhci, "Slot ID %d Output Context:\n", udev->slot_id);
         xhci_dbg_ctx(xhci, virt_dev->out_ctx, 2);
         /*
@@ -3859,7 +3859,7 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
          */
         slot_ctx = xhci_get_slot_ctx(xhci, virt_dev->out_ctx);
         trace_xhci_address_ctx(xhci, virt_dev->out_ctx,
-                                slot_ctx->dev_info >> 27);
+                                le32_to_cpu(slot_ctx->dev_info) >> 27);
         /* Zero the input context control for later use */
         ctrl_ctx->add_flags = 0;
         ctrl_ctx->drop_flags = 0;
@@ -3871,6 +3871,16 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
         return 0;
 }
 
+int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
+{
+        return xhci_setup_device(hcd, udev, SETUP_CONTEXT_ADDRESS);
+}
+
+int xhci_enable_device(struct usb_hcd *hcd, struct usb_device *udev)
+{
+        return xhci_setup_device(hcd, udev, SETUP_CONTEXT_ONLY);
+}
+
 /*
  * Transfer the port index into real index in the HW port status
  * registers. Caculate offset between the port's PORTSC register
@@ -4042,7 +4052,7 @@ int xhci_set_usb2_hardware_lpm(struct usb_hcd *hcd,
         port_array = xhci->usb2_ports;
         port_num = udev->portnum - 1;
         pm_addr = port_array[port_num] + PORTPMSC;
-        pm_val = xhci_readl(xhci, pm_addr);
+        pm_val = readl(pm_addr);
         hlpm_addr = port_array[port_num] + PORTHLPMC;
         field = le32_to_cpu(udev->bos->ext_cap->bmAttributes);
 
@@ -4082,26 +4092,26 @@ int xhci_set_usb2_hardware_lpm(struct usb_hcd *hcd,
                         spin_lock_irqsave(&xhci->lock, flags);
 
                         hlpm_val = xhci_calculate_usb2_hw_lpm_params(udev);
-                        xhci_writel(xhci, hlpm_val, hlpm_addr);
+                        writel(hlpm_val, hlpm_addr);
                         /* flush write */
-                        xhci_readl(xhci, hlpm_addr);
+                        readl(hlpm_addr);
                 } else {
                         hird = xhci_calculate_hird_besl(xhci, udev);
                 }
 
                 pm_val &= ~PORT_HIRD_MASK;
                 pm_val |= PORT_HIRD(hird) | PORT_RWE | PORT_L1DS(udev->slot_id);
-                xhci_writel(xhci, pm_val, pm_addr);
-                pm_val = xhci_readl(xhci, pm_addr);
+                writel(pm_val, pm_addr);
+                pm_val = readl(pm_addr);
                 pm_val |= PORT_HLE;
-                xhci_writel(xhci, pm_val, pm_addr);
+                writel(pm_val, pm_addr);
                 /* flush write */
-                xhci_readl(xhci, pm_addr);
+                readl(pm_addr);
         } else {
                 pm_val &= ~(PORT_HLE | PORT_RWE | PORT_HIRD_MASK | PORT_L1DS_MASK);
-                xhci_writel(xhci, pm_val, pm_addr);
+                writel(pm_val, pm_addr);
                 /* flush write */
-                xhci_readl(xhci, pm_addr);
+                readl(pm_addr);
                 if (udev->usb2_hw_lpm_besl_capable) {
                         spin_unlock_irqrestore(&xhci->lock, flags);
                         mutex_lock(hcd->bandwidth_mutex);
@@ -4455,7 +4465,7 @@ static u16 xhci_calculate_lpm_timeout(struct usb_hcd *hcd,
         if (!config)
                 return timeout;
 
-        for (i = 0; i < USB_MAXINTERFACES; i++) {
+        for (i = 0; i < config->desc.bNumInterfaces; i++) {
                 struct usb_driver *driver;
                 struct usb_interface *intf = config->interface[i];
 
@@ -4704,7 +4714,7 @@ int xhci_get_frame(struct usb_hcd *hcd)
 {
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
         /* EHCI mods by the periodic size.  Why? */
-        return xhci_readl(xhci, &xhci->run_regs->microframe_index) >> 3;
+        return readl(&xhci->run_regs->microframe_index) >> 3;
 }
 
 int xhci_gen_setup(struct usb_hcd *hcd, xhci_get_quirks_t get_quirks)
@@ -4748,16 +4758,16 @@ int xhci_gen_setup(struct usb_hcd *hcd, xhci_get_quirks_t get_quirks)
 
         xhci->cap_regs = hcd->regs;
         xhci->op_regs = hcd->regs +
-                HC_LENGTH(xhci_readl(xhci, &xhci->cap_regs->hc_capbase));
+                HC_LENGTH(readl(&xhci->cap_regs->hc_capbase));
         xhci->run_regs = hcd->regs +
-                (xhci_readl(xhci, &xhci->cap_regs->run_regs_off) & RTSOFF_MASK);
+                (readl(&xhci->cap_regs->run_regs_off) & RTSOFF_MASK);
         /* Cache read-only capability registers */
-        xhci->hcs_params1 = xhci_readl(xhci, &xhci->cap_regs->hcs_params1);
-        xhci->hcs_params2 = xhci_readl(xhci, &xhci->cap_regs->hcs_params2);
-        xhci->hcs_params3 = xhci_readl(xhci, &xhci->cap_regs->hcs_params3);
-        xhci->hcc_params = xhci_readl(xhci, &xhci->cap_regs->hc_capbase);
+        xhci->hcs_params1 = readl(&xhci->cap_regs->hcs_params1);
+        xhci->hcs_params2 = readl(&xhci->cap_regs->hcs_params2);
+        xhci->hcs_params3 = readl(&xhci->cap_regs->hcs_params3);
+        xhci->hcc_params = readl(&xhci->cap_regs->hc_capbase);
         xhci->hci_version = HC_VERSION(xhci->hcc_params);
-        xhci->hcc_params = xhci_readl(xhci, &xhci->cap_regs->hcc_params);
+        xhci->hcc_params = readl(&xhci->cap_regs->hcc_params);
         xhci_print_registers(xhci);
 
         get_quirks(dev, xhci);
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index 03c74b7965f8..24344aab2107 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -28,6 +28,17 @@
 #include <linux/kernel.h>
 #include <linux/usb/hcd.h>
 
+/*
+ * Registers should always be accessed with double word or quad word accesses.
+ *
+ * Some xHCI implementations may support 64-bit address pointers.  Registers
+ * with 64-bit address pointers should be written to with dword accesses by
+ * writing the low dword first (ptr[0]), then the high dword (ptr[1]) second.
+ * xHCI implementations that do not support 64-bit address pointers will ignore
+ * the high dword, and write order is irrelevant.
+ */
+#include <asm-generic/io-64-nonatomic-lo-hi.h>
+
 /* Code sharing between pci-quirks and xhci hcd */
 #include        "xhci-ext-caps.h"
 #include "pci-quirks.h"
@@ -752,7 +763,7 @@ struct xhci_stream_ctx {
 };
 
 /* Stream Context Types (section 6.4.1) - bits 3:1 of stream ctx deq ptr */
-#define SCT_FOR_CTX(p)          (((p) << 1) & 0x7)
+#define SCT_FOR_CTX(p)          (((p) & 0x7) << 1)
 /* Secondary stream array type, dequeue pointer is to a transfer ring */
 #define SCT_SEC_TR              0
 /* Primary stream array type, dequeue pointer is to a transfer ring */
@@ -1097,6 +1108,14 @@ struct xhci_event_cmd {
 };
 
 /* flags bitmasks */
+
+/* Address device - disable SetAddress */
+#define TRB_BSR         (1<<9)
+enum xhci_setup_dev {
+        SETUP_CONTEXT_ONLY,
+        SETUP_CONTEXT_ADDRESS,
+};
+
 /* bits 16:23 are the virtual function ID */
 /* bits 24:31 are the slot ID */
 #define TRB_TO_SLOT_ID(p)       (((p) & (0xff<<24)) >> 24)
@@ -1595,47 +1614,6 @@ static inline struct usb_hcd *xhci_to_hcd(struct xhci_hcd *xhci)
 #define xhci_warn_ratelimited(xhci, fmt, args...) \
         dev_warn_ratelimited(xhci_to_hcd(xhci)->self.controller , fmt , ## args)
 
-/* TODO: copied from ehci.h - can be refactored? */
-/* xHCI spec says all registers are little endian */
-static inline unsigned int xhci_readl(const struct xhci_hcd *xhci,
-                __le32 __iomem *regs)
-{
-        return readl(regs);
-}
-static inline void xhci_writel(struct xhci_hcd *xhci,
-                const unsigned int val, __le32 __iomem *regs)
-{
-        writel(val, regs);
-}
-
-/*
- * Registers should always be accessed with double word or quad word accesses.
- *
- * Some xHCI implementations may support 64-bit address pointers.  Registers
- * with 64-bit address pointers should be written to with dword accesses by
- * writing the low dword first (ptr[0]), then the high dword (ptr[1]) second.
- * xHCI implementations that do not support 64-bit address pointers will ignore
- * the high dword, and write order is irrelevant.
- */
-static inline u64 xhci_read_64(const struct xhci_hcd *xhci,
-                __le64 __iomem *regs)
-{
-        __u32 __iomem *ptr = (__u32 __iomem *) regs;
-        u64 val_lo = readl(ptr);
-        u64 val_hi = readl(ptr + 1);
-        return val_lo + (val_hi << 32);
-}
-static inline void xhci_write_64(struct xhci_hcd *xhci,
-                                 const u64 val, __le64 __iomem *regs)
-{
-        __u32 __iomem *ptr = (__u32 __iomem *) regs;
-        u32 val_lo = lower_32_bits(val);
-        u32 val_hi = upper_32_bits(val);
-
-        writel(val_lo, ptr);
-        writel(val_hi, ptr + 1);
-}
-
 static inline int xhci_link_trb_quirk(struct xhci_hcd *xhci)
 {
         return xhci->quirks & XHCI_LINK_TRB_QUIRK;
@@ -1790,6 +1768,7 @@ int xhci_free_streams(struct usb_hcd *hcd, struct usb_device *udev,
                 struct usb_host_endpoint **eps, unsigned int num_eps,
                 gfp_t mem_flags);
 int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev);
+int xhci_enable_device(struct usb_hcd *hcd, struct usb_device *udev);
 int xhci_update_device(struct usb_hcd *hcd, struct usb_device *udev);
 int xhci_set_usb2_hardware_lpm(struct usb_hcd *hcd,
                                 struct usb_device *udev, int enable);
@@ -1813,7 +1792,7 @@ int xhci_is_vendor_info_code(struct xhci_hcd *xhci, unsigned int trb_comp_code);
 void xhci_ring_cmd_db(struct xhci_hcd *xhci);
 int xhci_queue_slot_control(struct xhci_hcd *xhci, u32 trb_type, u32 slot_id);
 int xhci_queue_address_device(struct xhci_hcd *xhci, dma_addr_t in_ctx_ptr,
-                u32 slot_id);
+                u32 slot_id, enum xhci_setup_dev);
 int xhci_queue_vendor_command(struct xhci_hcd *xhci,
                 u32 field1, u32 field2, u32 field3, u32 field4);
 int xhci_queue_stop_endpoint(struct xhci_hcd *xhci, int slot_id,
diff --git a/drivers/usb/misc/usbtest.c b/drivers/usb/misc/usbtest.c
index b4152820d655..bff058ea222e 100644
--- a/drivers/usb/misc/usbtest.c
+++ b/drivers/usb/misc/usbtest.c
@@ -619,8 +619,8 @@ static int is_good_ext(struct usbtest_dev *tdev, u8 *buf)
         }
 
         attr = le32_to_cpu(ext->bmAttributes);
-        /* bits[1:4] is used and others are reserved */
-        if (attr & ~0x1e) {     /* reserved == 0 */
+        /* bits[1:15] is used and others are reserved */
+        if (attr & ~0xfffe) {   /* reserved == 0 */
                 ERROR(tdev, "reserved bits set\n");
                 return 0;
         }
@@ -763,7 +763,7 @@ static int ch9_postconfig(struct usbtest_dev *dev)
          * there's always [9.4.3] a bos device descriptor [9.6.2] in USB
          * 3.0 spec
          */
-        if (le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0300) {
+        if (le16_to_cpu(udev->descriptor.bcdUSB) >= 0x0210) {
                 struct usb_bos_descriptor *bos = NULL;
                 struct usb_dev_cap_header *header = NULL;
                 unsigned total, num, length;
@@ -944,7 +944,7 @@ struct ctrl_ctx {
         int                     last;
 };
 
-#define NUM_SUBCASES    15              /* how many test subcases here? */
+#define NUM_SUBCASES    16              /* how many test subcases here? */
 
 struct subcase {
         struct usb_ctrlrequest  setup;
@@ -1218,6 +1218,15 @@ test_ctrl_queue(struct usbtest_dev *dev, struct usbtest_param *param)
                         }
                         expected = -EREMOTEIO;
                         break;
+                case 15:
+                        req.wValue = cpu_to_le16(USB_DT_BOS << 8);
+                        if (udev->bos)
+                                len = le16_to_cpu(udev->bos->desc->wTotalLength);
+                        else
+                                len = sizeof(struct usb_bos_descriptor);
+                        if (udev->speed != USB_SPEED_SUPER)
+                                expected = -EPIPE;
+                        break;
                 default:
                         ERROR(dev, "bogus number of ctrl queue testcases!\n");
                         context.status = -EINVAL;
diff --git a/drivers/usb/musb/musb_host.c b/drivers/usb/musb/musb_host.c
index 6582a20bec05..e2083757e87c 100644
--- a/drivers/usb/musb/musb_host.c
+++ b/drivers/usb/musb/musb_host.c
@@ -2657,6 +2657,7 @@ int musb_host_setup(struct musb *musb, int power_budget)
         if (ret < 0)
                 return ret;
 
+        device_wakeup_enable(hcd->self.controller);
         return 0;
 }
 
diff --git a/drivers/usb/phy/phy-msm-usb.c b/drivers/usb/phy/phy-msm-usb.c
index e9d4cd960ecd..37752832b770 100644
--- a/drivers/usb/phy/phy-msm-usb.c
+++ b/drivers/usb/phy/phy-msm-usb.c
@@ -669,6 +669,7 @@ static void msm_otg_start_host(struct usb_phy *phy, int on)
                         pdata->setup_gpio(OTG_STATE_A_HOST);
 #ifdef CONFIG_USB
                 usb_add_hcd(hcd, hcd->irq, IRQF_SHARED);
+                device_wakeup_enable(hcd->self.controller);
 #endif
         } else {
                 dev_dbg(phy->dev, "host off\n");
diff --git a/drivers/usb/phy/phy-mv-usb.c b/drivers/usb/phy/phy-mv-usb.c
index 98f6ac6a78ea..44f316e287ef 100644
--- a/drivers/usb/phy/phy-mv-usb.c
+++ b/drivers/usb/phy/phy-mv-usb.c
@@ -213,10 +213,12 @@ static void mv_otg_start_host(struct mv_otg *mvotg, int on)
 
         hcd = bus_to_hcd(otg->host);
 
-        if (on)
+        if (on) {
                 usb_add_hcd(hcd, hcd->irq, IRQF_SHARED);
-        else
+                device_wakeup_enable(hcd->self.controller);
+        } else {
                 usb_remove_hcd(hcd);
+        }
 #endif /* CONFIG_USB */
 }
 
diff --git a/drivers/usb/renesas_usbhs/mod_host.c b/drivers/usb/renesas_usbhs/mod_host.c
index e40f565004d0..10e1ded9c9cc 100644
--- a/drivers/usb/renesas_usbhs/mod_host.c
+++ b/drivers/usb/renesas_usbhs/mod_host.c
@@ -1469,6 +1469,7 @@ static int usbhsh_start(struct usbhs_priv *priv)
         ret = usb_add_hcd(hcd, 0, 0);
         if (ret < 0)
                 return 0;
+        device_wakeup_enable(hcd->self.controller);
 
         /*
          * pipe initialize and enable DCP
diff --git a/drivers/usb/storage/protocol.c b/drivers/usb/storage/protocol.c
index 5dfb4c36a1b0..12e3c2fac642 100644
--- a/drivers/usb/storage/protocol.c
+++ b/drivers/usb/storage/protocol.c
@@ -135,69 +135,42 @@ unsigned int usb_stor_access_xfer_buf(unsigned char *buffer,
         unsigned int buflen, struct scsi_cmnd *srb, struct scatterlist **sgptr,
         unsigned int *offset, enum xfer_buf_dir dir)
 {
-        unsigned int cnt;
+        unsigned int cnt = 0;
         struct scatterlist *sg = *sgptr;
+        struct sg_mapping_iter miter;
+        unsigned int nents = scsi_sg_count(srb);
 
-        /* We have to go through the list one entry
-         * at a time.  Each s-g entry contains some number of pages, and
-         * each page has to be kmap()'ed separately.  If the page is already
-         * in kernel-addressable memory then kmap() will return its address.
-         * If the page is not directly accessible -- such as a user buffer
-         * located in high memory -- then kmap() will map it to a temporary
-         * position in the kernel's virtual address space.
-         */
-
-        if (!sg)
+        if (sg)
+                nents = sg_nents(sg);
+        else
                 sg = scsi_sglist(srb);
 
-        /* This loop handles a single s-g list entry, which may
-         * include multiple pages.  Find the initial page structure
-         * and the starting offset within the page, and update
-         * the *offset and **sgptr values for the next loop.
-         */
-        cnt = 0;
-        while (cnt < buflen && sg) {
-                struct page *page = sg_page(sg) +
-                                ((sg->offset + *offset) >> PAGE_SHIFT);
-                unsigned int poff = (sg->offset + *offset) & (PAGE_SIZE-1);
-                unsigned int sglen = sg->length - *offset;
-
-                if (sglen > buflen - cnt) {
-
-                        /* Transfer ends within this s-g entry */
-                        sglen = buflen - cnt;
-                        *offset += sglen;
-                } else {
+        sg_miter_start(&miter, sg, nents, dir == FROM_XFER_BUF ?
+                SG_MITER_FROM_SG: SG_MITER_TO_SG);
 
-                        /* Transfer continues to next s-g entry */
-                        *offset = 0;
-                        sg = sg_next(sg);
-                }
+        if (!sg_miter_skip(&miter, *offset))
+                return cnt;
+
+        while (sg_miter_next(&miter) && cnt < buflen) {
+                unsigned int len = min_t(unsigned int, miter.length,
+                                buflen - cnt);
+
+                if (dir == FROM_XFER_BUF)
+                        memcpy(buffer + cnt, miter.addr, len);
+                else
+                        memcpy(miter.addr, buffer + cnt, len);
 
-                /* Transfer the data for all the pages in this
-                        * s-g entry.  For each page: call kmap(), do the
-                        * transfer, and call kunmap() immediately after. */
-                while (sglen > 0) {
-                        unsigned int plen = min(sglen, (unsigned int)
-                                        PAGE_SIZE - poff);
-                        unsigned char *ptr = kmap(page);
-
-                        if (dir == TO_XFER_BUF)
-                                memcpy(ptr + poff, buffer + cnt, plen);
-                        else
-                                memcpy(buffer + cnt, ptr + poff, plen);
-                        kunmap(page);
-
-                        /* Start at the beginning of the next page */
-                        poff = 0;
-                        ++page;
-                        cnt += plen;
-                        sglen -= plen;
+                if (*offset + len < miter.piter.sg->length) {
+                        *offset += len;
+                        *sgptr = miter.piter.sg;
+                } else {
+                        *offset = 0;
+                        *sgptr = sg_next(miter.piter.sg);
                 }
+                cnt += len;
         }
-        *sgptr = sg;
+        sg_miter_stop(&miter);
 
-        /* Return the amount actually transferred */
         return cnt;
 }
 EXPORT_SYMBOL_GPL(usb_stor_access_xfer_buf);
diff --git a/drivers/usb/wusbcore/cbaf.c b/drivers/usb/wusbcore/cbaf.c
index f06ed82e63d1..56310fc9b9c3 100644
--- a/drivers/usb/wusbcore/cbaf.c
+++ b/drivers/usb/wusbcore/cbaf.c
@@ -144,7 +144,7 @@ static int cbaf_check(struct cbaf *cbaf)
                 CBAF_REQ_GET_ASSOCIATION_INFORMATION,
                 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                 0, cbaf->usb_iface->cur_altsetting->desc.bInterfaceNumber,
-                cbaf->buffer, cbaf->buffer_size, 1000 /* FIXME: arbitrary */);
+                cbaf->buffer, cbaf->buffer_size, USB_CTRL_GET_TIMEOUT);
         if (result < 0) {
                 dev_err(dev, "Cannot get available association types: %d\n",
                         result);
@@ -265,7 +265,7 @@ static int cbaf_send_host_info(struct cbaf *cbaf)
                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                         0x0101,
                         cbaf->usb_iface->cur_altsetting->desc.bInterfaceNumber,
-                        hi, hi_size, 1000 /* FIXME: arbitrary */);
+                        hi, hi_size, USB_CTRL_SET_TIMEOUT);
 }
 
 /*
@@ -288,7 +288,7 @@ static int cbaf_cdid_get(struct cbaf *cbaf)
                 CBAF_REQ_GET_ASSOCIATION_REQUEST,
                 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                 0x0200, cbaf->usb_iface->cur_altsetting->desc.bInterfaceNumber,
-                di, cbaf->buffer_size, 1000 /* FIXME: arbitrary */);
+                di, cbaf->buffer_size, USB_CTRL_GET_TIMEOUT);
         if (result < 0) {
                 dev_err(dev, "Cannot request device information: %d\n", result);
                 return result;
@@ -536,7 +536,7 @@ static int cbaf_cc_upload(struct cbaf *cbaf)
                 CBAF_REQ_SET_ASSOCIATION_RESPONSE,
                 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                 0x0201, cbaf->usb_iface->cur_altsetting->desc.bInterfaceNumber,
-                ccd, sizeof(*ccd), 1000 /* FIXME: arbitrary */);
+                ccd, sizeof(*ccd), USB_CTRL_SET_TIMEOUT);
 
         return result;
 }
diff --git a/drivers/usb/wusbcore/security.c b/drivers/usb/wusbcore/security.c
index 4c40d0dbf53d..790c0b5c354c 100644
--- a/drivers/usb/wusbcore/security.c
+++ b/drivers/usb/wusbcore/security.c
@@ -165,7 +165,7 @@ static int wusb_dev_set_encryption(struct usb_device *usb_dev, int value)
         result = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
                         USB_REQ_SET_ENCRYPTION,
                         USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
-                        value, 0, NULL, 0, 1000 /* FIXME: arbitrary */);
+                        value, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
         if (result < 0)
                 dev_err(dev, "Can't set device's WUSB encryption to "
                         "%s (value %d): %d\n",
@@ -191,7 +191,7 @@ static int wusb_dev_set_gtk(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev)
                 USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
                 USB_DT_KEY << 8 | key_index, 0,
                 &wusbhc->gtk.descr, wusbhc->gtk.descr.bLength,
-                1000);
+                USB_CTRL_SET_TIMEOUT);
 }
 
 
@@ -301,8 +301,9 @@ int wusb_dev_update_address(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev)
 
         /* Set address 0 */
         result = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
-                                 USB_REQ_SET_ADDRESS, 0,
-                                 0, 0, NULL, 0, 1000 /* FIXME: arbitrary */);
+                        USB_REQ_SET_ADDRESS,
+                        USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
+                         0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
         if (result < 0) {
                 dev_err(dev, "auth failed: can't set address 0: %d\n",
                         result);
@@ -316,9 +317,10 @@ int wusb_dev_update_address(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev)
 
         /* Set new (authenticated) address. */
         result = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
-                                 USB_REQ_SET_ADDRESS, 0,
-                                 new_address, 0, NULL, 0,
-                                 1000 /* FIXME: arbitrary */);
+                        USB_REQ_SET_ADDRESS,
+                        USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
+                        new_address, 0, NULL, 0,
+                        USB_CTRL_SET_TIMEOUT);
         if (result < 0) {
                 dev_err(dev, "auth failed: can't set address %u: %d\n",
                         new_address, result);
@@ -381,7 +383,7 @@ int wusb_dev_4way_handshake(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev,
                 usb_dev, usb_sndctrlpipe(usb_dev, 0),
                 USB_REQ_SET_HANDSHAKE,
                 USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
-                1, 0, &hs[0], sizeof(hs[0]), 1000 /* FIXME: arbitrary */);
+                1, 0, &hs[0], sizeof(hs[0]), USB_CTRL_SET_TIMEOUT);
         if (result < 0) {
                 dev_err(dev, "Handshake1: request failed: %d\n", result);
                 goto error_hs1;
@@ -392,7 +394,7 @@ int wusb_dev_4way_handshake(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev,
                 usb_dev, usb_rcvctrlpipe(usb_dev, 0),
                 USB_REQ_GET_HANDSHAKE,
                 USB_DIR_IN | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
-                2, 0, &hs[1], sizeof(hs[1]), 1000 /* FIXME: arbitrary */);
+                2, 0, &hs[1], sizeof(hs[1]), USB_CTRL_GET_TIMEOUT);
         if (result < 0) {
                 dev_err(dev, "Handshake2: request failed: %d\n", result);
                 goto error_hs2;
@@ -469,7 +471,7 @@ int wusb_dev_4way_handshake(struct wusbhc *wusbhc, struct wusb_dev *wusb_dev,
                 usb_dev, usb_sndctrlpipe(usb_dev, 0),
                 USB_REQ_SET_HANDSHAKE,
                 USB_DIR_OUT | USB_TYPE_STANDARD | USB_RECIP_DEVICE,
-                3, 0, &hs[2], sizeof(hs[2]), 1000 /* FIXME: arbitrary */);
+                3, 0, &hs[2], sizeof(hs[2]), USB_CTRL_SET_TIMEOUT);
         if (result < 0) {
                 dev_err(dev, "Handshake3: request failed: %d\n", result);
                 goto error_hs3;
diff --git a/drivers/usb/wusbcore/wa-hc.h b/drivers/usb/wusbcore/wa-hc.h
index e614f02f0cf2..b93d2cbdf33f 100644
--- a/drivers/usb/wusbcore/wa-hc.h
+++ b/drivers/usb/wusbcore/wa-hc.h
@@ -332,7 +332,7 @@ static inline int rpipe_avail_inc(struct wa_rpipe *rpipe)
 /* Transferring data */
 extern int wa_urb_enqueue(struct wahc *, struct usb_host_endpoint *,
                           struct urb *, gfp_t);
-extern int wa_urb_dequeue(struct wahc *, struct urb *);
+extern int wa_urb_dequeue(struct wahc *, struct urb *, int);
 extern void wa_handle_notif_xfer(struct wahc *, struct wa_notif_hdr *);
 
 
@@ -366,7 +366,7 @@ static inline int __wa_feature(struct wahc *wa, unsigned op, u16 feature)
                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                         feature,
                         wa->usb_iface->cur_altsetting->desc.bInterfaceNumber,
-                        NULL, 0, 1000 /* FIXME: arbitrary */);
+                        NULL, 0, USB_CTRL_SET_TIMEOUT);
 }
 
 
@@ -400,8 +400,7 @@ s32 __wa_get_status(struct wahc *wa)
                 USB_REQ_GET_STATUS,
                 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
                 0, wa->usb_iface->cur_altsetting->desc.bInterfaceNumber,
-                &wa->status, sizeof(wa->status),
-                1000 /* FIXME: arbitrary */);
+                &wa->status, sizeof(wa->status), USB_CTRL_GET_TIMEOUT);
         if (result >= 0)
                 result = wa->status;
         return result;
diff --git a/drivers/usb/wusbcore/wa-rpipe.c b/drivers/usb/wusbcore/wa-rpipe.c
index b48e74cc54d7..accdd15f5393 100644
--- a/drivers/usb/wusbcore/wa-rpipe.c
+++ b/drivers/usb/wusbcore/wa-rpipe.c
@@ -80,7 +80,7 @@ static int __rpipe_get_descr(struct wahc *wa,
                 USB_REQ_GET_DESCRIPTOR,
                 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_RPIPE,
                 USB_DT_RPIPE<<8, index, descr, sizeof(*descr),
-                1000 /* FIXME: arbitrary */);
+                USB_CTRL_GET_TIMEOUT);
         if (result < 0) {
                 dev_err(dev, "rpipe %u: get descriptor failed: %d\n",
                         index, (int)result);
@@ -118,7 +118,7 @@ static int __rpipe_set_descr(struct wahc *wa,
                 USB_REQ_SET_DESCRIPTOR,
                 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
                 USB_DT_RPIPE<<8, index, descr, sizeof(*descr),
-                HZ / 10);
+                USB_CTRL_SET_TIMEOUT);
         if (result < 0) {
                 dev_err(dev, "rpipe %u: set descriptor failed: %d\n",
                         index, (int)result);
@@ -237,7 +237,7 @@ static int __rpipe_reset(struct wahc *wa, unsigned index)
                 wa->usb_dev, usb_sndctrlpipe(wa->usb_dev, 0),
                 USB_REQ_RPIPE_RESET,
                 USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
-                0, index, NULL, 0, 1000 /* FIXME: arbitrary */);
+                0, index, NULL, 0, USB_CTRL_SET_TIMEOUT);
         if (result < 0)
                 dev_err(dev, "rpipe %u: reset failed: %d\n",
                         index, result);
@@ -527,7 +527,7 @@ void rpipe_ep_disable(struct wahc *wa, struct usb_host_endpoint *ep)
                         wa->usb_dev, usb_rcvctrlpipe(wa->usb_dev, 0),
                         USB_REQ_RPIPE_ABORT,
                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
-                        0, index, NULL, 0, 1000 /* FIXME: arbitrary */);
+                        0, index, NULL, 0, USB_CTRL_SET_TIMEOUT);
                 rpipe_put(rpipe);
         }
         mutex_unlock(&wa->rpipe_mutex);
@@ -548,7 +548,7 @@ void rpipe_clear_feature_stalled(struct wahc *wa, struct usb_host_endpoint *ep)
                         wa->usb_dev, usb_rcvctrlpipe(wa->usb_dev, 0),
                         USB_REQ_CLEAR_FEATURE,
                         USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_RPIPE,
-                        RPIPE_STALL, index, NULL, 0, 1000);
+                        RPIPE_STALL, index, NULL, 0, USB_CTRL_SET_TIMEOUT);
         }
         mutex_unlock(&wa->rpipe_mutex);
 }
diff --git a/drivers/usb/wusbcore/wa-xfer.c b/drivers/usb/wusbcore/wa-xfer.c
index ed5abe87b049..a70e142da330 100644
--- a/drivers/usb/wusbcore/wa-xfer.c
+++ b/drivers/usb/wusbcore/wa-xfer.c
@@ -124,6 +124,8 @@ struct wa_seg {
         u8 index;                       /* which segment we are */
         int isoc_frame_count;   /* number of isoc frames in this segment. */
         int isoc_frame_offset;  /* starting frame offset in the xfer URB. */
+        /* Isoc frame that the current transfer buffer corresponds to. */
+        int isoc_frame_index;
         int isoc_size;  /* size of all isoc frames sent by this seg. */
         enum wa_seg_status status;
         ssize_t result;                 /* bytes xfered or error */
@@ -158,8 +160,6 @@ struct wa_xfer {
         unsigned is_dma:1;
         size_t seg_size;
         int result;
-        /* Isoc frame that the current transfer buffer corresponds to. */
-        int dto_isoc_frame_index;
 
         gfp_t gfp;                      /* allocation mask */
 
@@ -282,6 +282,7 @@ static void wa_xfer_giveback(struct wa_xfer *xfer)
 
         spin_lock_irqsave(&xfer->wa->xfer_list_lock, flags);
         list_del_init(&xfer->list_node);
+        usb_hcd_unlink_urb_from_ep(&(xfer->wa->wusb->usb_hcd), xfer->urb);
         spin_unlock_irqrestore(&xfer->wa->xfer_list_lock, flags);
         /* FIXME: segmentation broken -- kills DWA */
         wusbhc_giveback_urb(xfer->wa->wusb, xfer->urb, xfer->result);
@@ -372,10 +373,10 @@ static unsigned __wa_xfer_is_done(struct wa_xfer *xfer)
                                 seg->result);
                         goto out;
                 case WA_SEG_ABORTED:
-                        dev_dbg(dev, "xfer %p ID %08X#%u ABORTED: result %d\n",
-                                xfer, wa_xfer_id(xfer), seg->index,
-                                urb->status);
-                        xfer->result = urb->status;
+                        xfer->result = seg->result;
+                        dev_dbg(dev, "xfer %p ID %08X#%u: ABORTED result %zu(0x%08zX)\n",
+                                xfer, wa_xfer_id(xfer), seg->index, seg->result,
+                                seg->result);
                         goto out;
                 default:
                         dev_warn(dev, "xfer %p ID %08X#%u: is_done bad state %d\n",
@@ -700,23 +701,23 @@ static void wa_seg_dto_cb(struct urb *urb)
         if (usb_pipeisoc(xfer->urb->pipe)) {
                 /* Alereon HWA sends all isoc frames in a single transfer. */
                 if (wa->quirks & WUSB_QUIRK_ALEREON_HWA_CONCAT_ISOC)
-                        xfer->dto_isoc_frame_index += seg->isoc_frame_count;
+                        seg->isoc_frame_index += seg->isoc_frame_count;
                 else
-                        xfer->dto_isoc_frame_index += 1;
-                if (xfer->dto_isoc_frame_index < seg->isoc_frame_count) {
+                        seg->isoc_frame_index += 1;
+                if (seg->isoc_frame_index < seg->isoc_frame_count) {
                         data_send_done = 0;
                         holding_dto = 1; /* checked in error cases. */
                         /*
                          * if this is the last isoc frame of the segment, we
                          * can release DTO after sending this frame.
                          */
-                        if ((xfer->dto_isoc_frame_index + 1) >=
+                        if ((seg->isoc_frame_index + 1) >=
                                 seg->isoc_frame_count)
                                 release_dto = 1;
                 }
                 dev_dbg(dev, "xfer 0x%08X#%u: isoc frame = %d, holding_dto = %d, release_dto = %d.\n",
-                        wa_xfer_id(xfer), seg->index,
-                        xfer->dto_isoc_frame_index, holding_dto, release_dto);
+                        wa_xfer_id(xfer), seg->index, seg->isoc_frame_index,
+                        holding_dto, release_dto);
         }
         spin_unlock_irqrestore(&xfer->lock, flags);
 
@@ -736,8 +737,7 @@ static void wa_seg_dto_cb(struct urb *urb)
                          * send the URB and release DTO if we no longer need it.
                          */
                          __wa_populate_dto_urb_isoc(xfer, seg,
-                                seg->isoc_frame_offset +
-                                xfer->dto_isoc_frame_index);
+                                seg->isoc_frame_offset + seg->isoc_frame_index);
 
                         /* resubmit the URB with the next isoc frame. */
                         result = usb_submit_urb(seg->dto_urb, GFP_ATOMIC);
@@ -1259,8 +1259,11 @@ static int __wa_xfer_setup(struct wa_xfer *xfer, struct urb *urb)
                 for (cnt = 1; cnt < xfer->segs; cnt++) {
                         struct wa_xfer_packet_info_hwaiso *packet_desc;
                         struct wa_seg *seg = xfer->seg[cnt];
+                        struct wa_xfer_hwaiso *xfer_iso;
 
                         xfer_hdr = &seg->xfer_hdr;
+                        xfer_iso = container_of(xfer_hdr,
+                                                struct wa_xfer_hwaiso, hdr);
                         packet_desc = ((void *)xfer_hdr) + xfer_hdr_size;
                         /*
                          * Copy values from the 0th header. Segment specific
@@ -1270,6 +1273,8 @@ static int __wa_xfer_setup(struct wa_xfer *xfer, struct urb *urb)
                         xfer_hdr->bTransferSegment = cnt;
                         xfer_hdr->dwTransferLength =
                                 cpu_to_le32(seg->isoc_size);
+                        xfer_iso->dwNumOfPackets =
+                                        cpu_to_le32(seg->isoc_frame_count);
                         __wa_setup_isoc_packet_descr(packet_desc, xfer, seg);
                         seg->status = WA_SEG_READY;
                 }
@@ -1323,12 +1328,12 @@ static int __wa_seg_submit(struct wa_rpipe *rpipe, struct wa_xfer *xfer,
                 struct wahc *wa = xfer->wa;
 
                 result = usb_submit_urb(seg->isoc_pack_desc_urb, GFP_ATOMIC);
+                seg->isoc_frame_index = 0;
                 if (result < 0) {
                         pr_err("%s: xfer %p#%u: ISO packet descriptor submit failed: %d\n",
                                __func__, xfer, seg->index, result);
                         goto error_iso_pack_desc_submit;
                 }
-                xfer->dto_isoc_frame_index = 0;
                 /*
                  * If this segment contains more than one isoc frame, hold
                  * onto the dto resource until we send all frames.
@@ -1567,7 +1572,8 @@ static int wa_urb_enqueue_b(struct wa_xfer *xfer)
         wusb_dev = __wusb_dev_get_by_usb_dev(wusbhc, urb->dev);
         if (wusb_dev == NULL) {
                 mutex_unlock(&wusbhc->mutex);
-                pr_err("%s: error wusb dev gone\n", __func__);
+                dev_err(&(urb->dev->dev), "%s: error wusb dev gone\n",
+                        __func__);
                 goto error_dev_gone;
         }
         mutex_unlock(&wusbhc->mutex);
@@ -1576,18 +1582,18 @@ static int wa_urb_enqueue_b(struct wa_xfer *xfer)
         xfer->wusb_dev = wusb_dev;
         result = urb->status;
         if (urb->status != -EINPROGRESS) {
-                pr_err("%s: error_dequeued\n", __func__);
+                dev_err(&(urb->dev->dev), "%s: error_dequeued\n", __func__);
                 goto error_dequeued;
         }
 
         result = __wa_xfer_setup(xfer, urb);
         if (result < 0) {
-                pr_err("%s: error_xfer_setup\n", __func__);
+                dev_err(&(urb->dev->dev), "%s: error_xfer_setup\n", __func__);
                 goto error_xfer_setup;
         }
         result = __wa_xfer_submit(xfer);
         if (result < 0) {
-                pr_err("%s: error_xfer_submit\n", __func__);
+                dev_err(&(urb->dev->dev), "%s: error_xfer_submit\n", __func__);
                 goto error_xfer_submit;
         }
         spin_unlock_irqrestore(&xfer->lock, flags);
@@ -1730,6 +1736,12 @@ int wa_urb_enqueue(struct wahc *wa, struct usb_host_endpoint *ep,
                 dump_stack();
         }
 
+        spin_lock_irqsave(&wa->xfer_list_lock, my_flags);
+        result = usb_hcd_link_urb_to_ep(&(wa->wusb->usb_hcd), urb);
+        spin_unlock_irqrestore(&wa->xfer_list_lock, my_flags);
+        if (result < 0)
+                goto error_link_urb;
+
         result = -ENOMEM;
         xfer = kzalloc(sizeof(*xfer), gfp);
         if (xfer == NULL)
@@ -1769,6 +1781,9 @@ int wa_urb_enqueue(struct wahc *wa, struct usb_host_endpoint *ep,
                            __func__, result);
                         wa_put(xfer->wa);
                         wa_xfer_put(xfer);
+                        spin_lock_irqsave(&wa->xfer_list_lock, my_flags);
+                        usb_hcd_unlink_urb_from_ep(&(wa->wusb->usb_hcd), urb);
+                        spin_unlock_irqrestore(&wa->xfer_list_lock, my_flags);
                         return result;
                 }
         }
@@ -1777,6 +1792,10 @@ int wa_urb_enqueue(struct wahc *wa, struct usb_host_endpoint *ep,
 error_dequeued:
         kfree(xfer);
 error_kmalloc:
+        spin_lock_irqsave(&wa->xfer_list_lock, my_flags);
+        usb_hcd_unlink_urb_from_ep(&(wa->wusb->usb_hcd), urb);
+        spin_unlock_irqrestore(&wa->xfer_list_lock, my_flags);
+error_link_urb:
         return result;
 }
 EXPORT_SYMBOL_GPL(wa_urb_enqueue);
@@ -1799,7 +1818,7 @@ EXPORT_SYMBOL_GPL(wa_urb_enqueue);
  * asynch request] and then make sure we cancel each segment.
  *
  */
-int wa_urb_dequeue(struct wahc *wa, struct urb *urb)
+int wa_urb_dequeue(struct wahc *wa, struct urb *urb, int status)
 {
         unsigned long flags, flags2;
         struct wa_xfer *xfer;
@@ -1807,6 +1826,14 @@ int wa_urb_dequeue(struct wahc *wa, struct urb *urb)
         struct wa_rpipe *rpipe;
         unsigned cnt, done = 0, xfer_abort_pending;
         unsigned rpipe_ready = 0;
+        int result;
+
+        /* check if it is safe to unlink. */
+        spin_lock_irqsave(&wa->xfer_list_lock, flags);
+        result = usb_hcd_check_unlink_urb(&(wa->wusb->usb_hcd), urb, status);
+        spin_unlock_irqrestore(&wa->xfer_list_lock, flags);
+        if (result)
+                return result;
 
         xfer = urb->hcpriv;
         if (xfer == NULL) {
@@ -1822,9 +1849,10 @@ int wa_urb_dequeue(struct wahc *wa, struct urb *urb)
         pr_debug("%s: DEQUEUE xfer id 0x%08X\n", __func__, wa_xfer_id(xfer));
         rpipe = xfer->ep->hcpriv;
         if (rpipe == NULL) {
-                pr_debug("%s: xfer id 0x%08X has no RPIPE.  %s",
-                        __func__, wa_xfer_id(xfer),
+                pr_debug("%s: xfer %p id 0x%08X has no RPIPE.  %s",
+                        __func__, xfer, wa_xfer_id(xfer),
                         "Probably already aborted.\n" );
+                result = -ENOENT;
                 goto out_unlock;
         }
         /* Check the delayed list -> if there, release and complete */
@@ -1855,6 +1883,7 @@ int wa_urb_dequeue(struct wahc *wa, struct urb *urb)
                          * segments will be completed in the DTI interrupt.
                          */
                         seg->status = WA_SEG_ABORTED;
+                        seg->result = -ENOENT;
                         spin_lock_irqsave(&rpipe->seg_lock, flags2);
                         list_del(&seg->list_node);
                         xfer->segs_done++;
@@ -1894,12 +1923,12 @@ int wa_urb_dequeue(struct wahc *wa, struct urb *urb)
                 wa_xfer_completion(xfer);
         if (rpipe_ready)
                 wa_xfer_delayed_run(rpipe);
-        return 0;
+        return result;
 
 out_unlock:
         spin_unlock_irqrestore(&xfer->lock, flags);
 out:
-        return 0;
+        return result;
 
 dequeue_delayed:
         list_del_init(&xfer->list_node);
@@ -1935,7 +1964,7 @@ static int wa_xfer_status_to_errno(u8 status)
                 [WA_XFER_STATUS_NOT_FOUND] =            0,
                 [WA_XFER_STATUS_INSUFFICIENT_RESOURCE] = -ENOMEM,
                 [WA_XFER_STATUS_TRANSACTION_ERROR] =    -EILSEQ,
-                [WA_XFER_STATUS_ABORTED] =              -EINTR,
+                [WA_XFER_STATUS_ABORTED] =              -ENOENT,
                 [WA_XFER_STATUS_RPIPE_NOT_READY] =      EINVAL,
                 [WA_XFER_INVALID_FORMAT] =              EINVAL,
                 [WA_XFER_UNEXPECTED_SEGMENT_NUMBER] =   EINVAL,
@@ -1968,7 +1997,7 @@ static int wa_xfer_status_to_errno(u8 status)
  * the xfer will complete cleanly.
  */
 static void wa_complete_remaining_xfer_segs(struct wa_xfer *xfer,
-                struct wa_seg *incoming_seg)
+                struct wa_seg *incoming_seg, enum wa_seg_status status)
 {
         int index;
         struct wa_rpipe *rpipe = xfer->ep->hcpriv;
@@ -1990,7 +2019,7 @@ static void wa_complete_remaining_xfer_segs(struct wa_xfer *xfer,
                  */
                 case WA_SEG_DELAYED:
                         xfer->segs_done++;
-                        current_seg->status = incoming_seg->status;
+                        current_seg->status = status;
                         break;
                 case WA_SEG_ABORTED:
                         break;
@@ -2003,6 +2032,58 @@ static void wa_complete_remaining_xfer_segs(struct wa_xfer *xfer,
         }
 }
 
+/* Populate the wa->buf_in_urb based on the current transfer state. */
+static int wa_populate_buf_in_urb(struct wahc *wa, struct wa_xfer *xfer,
+        unsigned int seg_idx, unsigned int bytes_transferred)
+{
+        int result = 0;
+        struct wa_seg *seg = xfer->seg[seg_idx];
+
+        BUG_ON(wa->buf_in_urb->status == -EINPROGRESS);
+        /* this should always be 0 before a resubmit. */
+        wa->buf_in_urb->num_mapped_sgs  = 0;
+
+        if (xfer->is_dma) {
+                wa->buf_in_urb->transfer_dma = xfer->urb->transfer_dma
+                        + (seg_idx * xfer->seg_size);
+                wa->buf_in_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+                wa->buf_in_urb->transfer_buffer = NULL;
+                wa->buf_in_urb->sg = NULL;
+                wa->buf_in_urb->num_sgs = 0;
+        } else {
+                /* do buffer or SG processing. */
+                wa->buf_in_urb->transfer_flags &= ~URB_NO_TRANSFER_DMA_MAP;
+
+                if (xfer->urb->transfer_buffer) {
+                        wa->buf_in_urb->transfer_buffer =
+                                xfer->urb->transfer_buffer
+                                + (seg_idx * xfer->seg_size);
+                        wa->buf_in_urb->sg = NULL;
+                        wa->buf_in_urb->num_sgs = 0;
+                } else {
+                        /* allocate an SG list to store seg_size bytes
+                                and copy the subset of the xfer->urb->sg
+                                that matches the buffer subset we are
+                                about to read. */
+                        wa->buf_in_urb->sg = wa_xfer_create_subset_sg(
+                                xfer->urb->sg,
+                                seg_idx * xfer->seg_size,
+                                bytes_transferred,
+                                &(wa->buf_in_urb->num_sgs));
+
+                        if (!(wa->buf_in_urb->sg)) {
+                                wa->buf_in_urb->num_sgs = 0;
+                                result = -ENOMEM;
+                        }
+                        wa->buf_in_urb->transfer_buffer = NULL;
+                }
+        }
+        wa->buf_in_urb->transfer_buffer_length = bytes_transferred;
+        wa->buf_in_urb->context = seg;
+
+        return result;
+}
+
 /*
  * Process a xfer result completion message
  *
@@ -2016,12 +2097,13 @@ static void wa_xfer_result_chew(struct wahc *wa, struct wa_xfer *xfer,
         int result;
         struct device *dev = &wa->usb_iface->dev;
         unsigned long flags;
-        u8 seg_idx;
+        unsigned int seg_idx;
         struct wa_seg *seg;
         struct wa_rpipe *rpipe;
         unsigned done = 0;
         u8 usb_status;
         unsigned rpipe_ready = 0;
+        unsigned bytes_transferred = le32_to_cpu(xfer_result->dwTransferLength);
 
         spin_lock_irqsave(&xfer->lock, flags);
         seg_idx = xfer_result->bTransferSegment & 0x7f;
@@ -2054,66 +2136,33 @@ static void wa_xfer_result_chew(struct wahc *wa, struct wa_xfer *xfer,
         /* FIXME: we ignore warnings, tally them for stats */
         if (usb_status & 0x40)          /* Warning?... */
                 usb_status = 0;         /* ... pass */
+        /*
+         * If the last segment bit is set, complete the remaining segments.
+         * When the current segment is completed, either in wa_buf_in_cb for
+         * transfers with data or below for no data, the xfer will complete.
+         */
+        if (xfer_result->bTransferSegment & 0x80)
+                wa_complete_remaining_xfer_segs(xfer, seg, WA_SEG_DONE);
         if (usb_pipeisoc(xfer->urb->pipe)) {
                 /* set up WA state to read the isoc packet status next. */
                 wa->dti_isoc_xfer_in_progress = wa_xfer_id(xfer);
                 wa->dti_isoc_xfer_seg = seg_idx;
                 wa->dti_state = WA_DTI_ISOC_PACKET_STATUS_PENDING;
-        } else if (xfer->is_inbound) {  /* IN data phase: read to buffer */
+        } else if ((xfer->is_inbound)
+                        && (bytes_transferred > 0)) {
+                /* IN data phase: read to buffer */
                 seg->status = WA_SEG_DTI_PENDING;
-                BUG_ON(wa->buf_in_urb->status == -EINPROGRESS);
-                /* this should always be 0 before a resubmit. */
-                wa->buf_in_urb->num_mapped_sgs  = 0;
-
-                if (xfer->is_dma) {
-                        wa->buf_in_urb->transfer_dma =
-                                xfer->urb->transfer_dma
-                                + (seg_idx * xfer->seg_size);
-                        wa->buf_in_urb->transfer_flags
-                                |= URB_NO_TRANSFER_DMA_MAP;
-                        wa->buf_in_urb->transfer_buffer = NULL;
-                        wa->buf_in_urb->sg = NULL;
-                        wa->buf_in_urb->num_sgs = 0;
-                } else {
-                        /* do buffer or SG processing. */
-                        wa->buf_in_urb->transfer_flags
-                                &= ~URB_NO_TRANSFER_DMA_MAP;
-
-                        if (xfer->urb->transfer_buffer) {
-                                wa->buf_in_urb->transfer_buffer =
-                                        xfer->urb->transfer_buffer
-                                        + (seg_idx * xfer->seg_size);
-                                wa->buf_in_urb->sg = NULL;
-                                wa->buf_in_urb->num_sgs = 0;
-                        } else {
-                                /* allocate an SG list to store seg_size bytes
-                                        and copy the subset of the xfer->urb->sg
-                                        that matches the buffer subset we are
-                                        about to read. */
-                                wa->buf_in_urb->sg = wa_xfer_create_subset_sg(
-                                        xfer->urb->sg,
-                                        seg_idx * xfer->seg_size,
-                                        le32_to_cpu(
-                                                xfer_result->dwTransferLength),
-                                        &(wa->buf_in_urb->num_sgs));
-
-                                if (!(wa->buf_in_urb->sg)) {
-                                        wa->buf_in_urb->num_sgs = 0;
-                                        goto error_sg_alloc;
-                                }
-                                wa->buf_in_urb->transfer_buffer = NULL;
-                        }
-                }
-                wa->buf_in_urb->transfer_buffer_length =
-                        le32_to_cpu(xfer_result->dwTransferLength);
-                wa->buf_in_urb->context = seg;
+                result = wa_populate_buf_in_urb(wa, xfer, seg_idx,
+                        bytes_transferred);
+                if (result < 0)
+                        goto error_buf_in_populate;
                 result = usb_submit_urb(wa->buf_in_urb, GFP_ATOMIC);
                 if (result < 0)
                         goto error_submit_buf_in;
         } else {
-                /* OUT data phase, complete it -- */
+                /* OUT data phase or no data, complete it -- */
                 seg->status = WA_SEG_DONE;
-                seg->result = le32_to_cpu(xfer_result->dwTransferLength);
+                seg->result = bytes_transferred;
                 xfer->segs_done++;
                 rpipe_ready = rpipe_avail_inc(rpipe);
                 done = __wa_xfer_is_done(xfer);
@@ -2137,13 +2186,13 @@ error_submit_buf_in:
         seg->result = result;
         kfree(wa->buf_in_urb->sg);
         wa->buf_in_urb->sg = NULL;
-error_sg_alloc:
+error_buf_in_populate:
         __wa_xfer_abort(xfer);
         seg->status = WA_SEG_ERROR;
 error_complete:
         xfer->segs_done++;
         rpipe_ready = rpipe_avail_inc(rpipe);
-        wa_complete_remaining_xfer_segs(xfer, seg);
+        wa_complete_remaining_xfer_segs(xfer, seg, seg->status);
         done = __wa_xfer_is_done(xfer);
         /*
          * queue work item to clear STALL for control endpoints.
@@ -2172,7 +2221,7 @@ error_complete:
 
 error_bad_seg:
         spin_unlock_irqrestore(&xfer->lock, flags);
-        wa_urb_dequeue(wa, xfer->urb);
+        wa_urb_dequeue(wa, xfer->urb, -ENOENT);
         if (printk_ratelimit())
                 dev_err(dev, "xfer %p#%u: bad segment\n", xfer, seg_idx);
         if (edc_inc(&wa->dti_edc, EDC_MAX_ERRORS, EDC_ERROR_TIMEFRAME)) {