8 files changed, 50 insertions, 37 deletions

diff --git a/drivers/usb/host/ohci-hcd.c b/drivers/usb/host/ohci-hcd.c
index 84f88fa411cd..d088c340e4d0 100644
--- a/drivers/usb/host/ohci-hcd.c
+++ b/drivers/usb/host/ohci-hcd.c
@@ -447,7 +447,8 @@ static int ohci_init (struct ohci_hcd *ohci)
         struct usb_hcd *hcd = ohci_to_hcd(ohci);
 
         /* Accept arbitrarily long scatter-gather lists */
-        hcd->self.sg_tablesize = ~0;
+        if (!(hcd->driver->flags & HCD_LOCAL_MEM))
+                hcd->self.sg_tablesize = ~0;
 
         if (distrust_firmware)
                 ohci->flags |= OHCI_QUIRK_HUB_POWER;
diff --git a/drivers/usb/host/xhci-dbgcap.c b/drivers/usb/host/xhci-dbgcap.c
index a1ab8acf39ba..c359bae7b754 100644
--- a/drivers/usb/host/xhci-dbgcap.c
+++ b/drivers/usb/host/xhci-dbgcap.c
@@ -328,13 +328,14 @@ dbc_ep_do_queue(struct dbc_ep *dep, struct dbc_request *req)
 int dbc_ep_queue(struct dbc_ep *dep, struct dbc_request *req,
                  gfp_t gfp_flags)
 {
+        unsigned long           flags;
         struct xhci_dbc         *dbc = dep->dbc;
         int                     ret = -ESHUTDOWN;
 
-        spin_lock(&dbc->lock);
+        spin_lock_irqsave(&dbc->lock, flags);
         if (dbc->state == DS_CONFIGURED)
                 ret = dbc_ep_do_queue(dep, req);
-        spin_unlock(&dbc->lock);
+        spin_unlock_irqrestore(&dbc->lock, flags);
 
         mod_delayed_work(system_wq, &dbc->event_work, 0);
 
@@ -521,15 +522,16 @@ static void xhci_do_dbc_stop(struct xhci_hcd *xhci)
 static int xhci_dbc_start(struct xhci_hcd *xhci)
 {
         int                     ret;
+        unsigned long           flags;
         struct xhci_dbc         *dbc = xhci->dbc;
 
         WARN_ON(!dbc);
 
         pm_runtime_get_sync(xhci_to_hcd(xhci)->self.controller);
 
-        spin_lock(&dbc->lock);
+        spin_lock_irqsave(&dbc->lock, flags);
         ret = xhci_do_dbc_start(xhci);
-        spin_unlock(&dbc->lock);
+        spin_unlock_irqrestore(&dbc->lock, flags);
 
         if (ret) {
                 pm_runtime_put(xhci_to_hcd(xhci)->self.controller);
@@ -541,6 +543,7 @@ static int xhci_dbc_start(struct xhci_hcd *xhci)
 
 static void xhci_dbc_stop(struct xhci_hcd *xhci)
 {
+        unsigned long           flags;
         struct xhci_dbc         *dbc = xhci->dbc;
         struct dbc_port         *port = &dbc->port;
 
@@ -551,9 +554,9 @@ static void xhci_dbc_stop(struct xhci_hcd *xhci)
         if (port->registered)
                 xhci_dbc_tty_unregister_device(xhci);
 
-        spin_lock(&dbc->lock);
+        spin_lock_irqsave(&dbc->lock, flags);
         xhci_do_dbc_stop(xhci);
-        spin_unlock(&dbc->lock);
+        spin_unlock_irqrestore(&dbc->lock, flags);
 
         pm_runtime_put_sync(xhci_to_hcd(xhci)->self.controller);
 }
@@ -779,14 +782,15 @@ static void xhci_dbc_handle_events(struct work_struct *work)
         int                     ret;
         enum evtreturn          evtr;
         struct xhci_dbc         *dbc;
+        unsigned long           flags;
         struct xhci_hcd         *xhci;
 
         dbc = container_of(to_delayed_work(work), struct xhci_dbc, event_work);
         xhci = dbc->xhci;
 
-        spin_lock(&dbc->lock);
+        spin_lock_irqsave(&dbc->lock, flags);
         evtr = xhci_dbc_do_handle_events(dbc);
-        spin_unlock(&dbc->lock);
+        spin_unlock_irqrestore(&dbc->lock, flags);
 
         switch (evtr) {
         case EVT_GSER:
diff --git a/drivers/usb/host/xhci-dbgtty.c b/drivers/usb/host/xhci-dbgtty.c
index 8d47b6fbf973..75f0b92694ba 100644
--- a/drivers/usb/host/xhci-dbgtty.c
+++ b/drivers/usb/host/xhci-dbgtty.c
@@ -92,21 +92,23 @@ static void dbc_start_rx(struct dbc_port *port)
 static void
 dbc_read_complete(struct xhci_hcd *xhci, struct dbc_request *req)
 {
+        unsigned long           flags;
         struct xhci_dbc         *dbc = xhci->dbc;
         struct dbc_port         *port = &dbc->port;
 
-        spin_lock(&port->port_lock);
+        spin_lock_irqsave(&port->port_lock, flags);
         list_add_tail(&req->list_pool, &port->read_queue);
         tasklet_schedule(&port->push);
-        spin_unlock(&port->port_lock);
+        spin_unlock_irqrestore(&port->port_lock, flags);
 }
 
 static void dbc_write_complete(struct xhci_hcd *xhci, struct dbc_request *req)
 {
+        unsigned long           flags;
         struct xhci_dbc         *dbc = xhci->dbc;
         struct dbc_port         *port = &dbc->port;
 
-        spin_lock(&port->port_lock);
+        spin_lock_irqsave(&port->port_lock, flags);
         list_add(&req->list_pool, &port->write_pool);
         switch (req->status) {
         case 0:
@@ -119,7 +121,7 @@ static void dbc_write_complete(struct xhci_hcd *xhci, struct dbc_request *req)
                           req->status);
                 break;
         }
-        spin_unlock(&port->port_lock);
+        spin_unlock_irqrestore(&port->port_lock, flags);
 }
 
 static void xhci_dbc_free_req(struct dbc_ep *dep, struct dbc_request *req)
@@ -327,12 +329,13 @@ static void dbc_rx_push(unsigned long _port)
 {
         struct dbc_request      *req;
         struct tty_struct       *tty;
+        unsigned long           flags;
         bool                    do_push = false;
         bool                    disconnect = false;
         struct dbc_port         *port = (void *)_port;
         struct list_head        *queue = &port->read_queue;
 
-        spin_lock_irq(&port->port_lock);
+        spin_lock_irqsave(&port->port_lock, flags);
         tty = port->port.tty;
         while (!list_empty(queue)) {
                 req = list_first_entry(queue, struct dbc_request, list_pool);
@@ -392,16 +395,17 @@ static void dbc_rx_push(unsigned long _port)
         if (!disconnect)
                 dbc_start_rx(port);
 
-        spin_unlock_irq(&port->port_lock);
+        spin_unlock_irqrestore(&port->port_lock, flags);
 }
 
 static int dbc_port_activate(struct tty_port *_port, struct tty_struct *tty)
 {
+        unsigned long   flags;
         struct dbc_port *port = container_of(_port, struct dbc_port, port);
 
-        spin_lock_irq(&port->port_lock);
+        spin_lock_irqsave(&port->port_lock, flags);
         dbc_start_rx(port);
-        spin_unlock_irq(&port->port_lock);
+        spin_unlock_irqrestore(&port->port_lock, flags);
 
         return 0;
 }
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index 5262fa571a5d..d9f831b67e57 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -126,6 +126,9 @@ static void xhci_pci_quirks(struct device *dev, struct xhci_hcd *xhci)
         if (pdev->vendor == PCI_VENDOR_ID_AMD && usb_amd_find_chipset_info())
                 xhci->quirks |= XHCI_AMD_PLL_FIX;
 
+        if (pdev->vendor == PCI_VENDOR_ID_AMD && pdev->device == 0x43bb)
+                xhci->quirks |= XHCI_SUSPEND_DELAY;
+
         if (pdev->vendor == PCI_VENDOR_ID_AMD)
                 xhci->quirks |= XHCI_TRUST_TX_LENGTH;
 
diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
index 6f038306c14d..6652e2d5bd2e 100644
--- a/drivers/usb/host/xhci-plat.c
+++ b/drivers/usb/host/xhci-plat.c
@@ -360,7 +360,6 @@ static int __maybe_unused xhci_plat_suspend(struct device *dev)
 {
         struct usb_hcd  *hcd = dev_get_drvdata(dev);
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
-        int ret;
 
         /*
          * xhci_suspend() needs `do_wakeup` to know whether host is allowed
@@ -370,12 +369,7 @@ static int __maybe_unused xhci_plat_suspend(struct device *dev)
          * reconsider this when xhci_plat_suspend enlarges its scope, e.g.,
          * also applies to runtime suspend.
          */
-        ret = xhci_suspend(xhci, device_may_wakeup(dev));
-
-        if (!device_may_wakeup(dev) && !IS_ERR(xhci->clk))
-                clk_disable_unprepare(xhci->clk);
-
-        return ret;
+        return xhci_suspend(xhci, device_may_wakeup(dev));
 }
 
 static int __maybe_unused xhci_plat_resume(struct device *dev)
@@ -384,9 +378,6 @@ static int __maybe_unused xhci_plat_resume(struct device *dev)
         struct xhci_hcd *xhci = hcd_to_xhci(hcd);
         int ret;
 
-        if (!device_may_wakeup(dev) && !IS_ERR(xhci->clk))
-                clk_prepare_enable(xhci->clk);
-
         ret = xhci_priv_resume_quirk(hcd);
         if (ret)
                 return ret;
diff --git a/drivers/usb/host/xhci-rcar.c b/drivers/usb/host/xhci-rcar.c
index f0b559660007..f33ffc2bc4ed 100644
--- a/drivers/usb/host/xhci-rcar.c
+++ b/drivers/usb/host/xhci-rcar.c
@@ -83,6 +83,10 @@ static const struct soc_device_attribute rcar_quirks_match[]  = {
                 .soc_id = "r8a7796",
                 .data = (void *)RCAR_XHCI_FIRMWARE_V3,
         },
+        {
+                .soc_id = "r8a77965",
+                .data = (void *)RCAR_XHCI_FIRMWARE_V3,
+        },
         { /* sentinel */ },
 };
 
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 25d4b748a56f..5d37700ae4b0 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -877,6 +877,9 @@ int xhci_suspend(struct xhci_hcd *xhci, bool do_wakeup)
         clear_bit(HCD_FLAG_POLL_RH, &xhci->shared_hcd->flags);
         del_timer_sync(&xhci->shared_hcd->rh_timer);
 
+        if (xhci->quirks & XHCI_SUSPEND_DELAY)
+                usleep_range(1000, 1500);
+
         spin_lock_irq(&xhci->lock);
         clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
         clear_bit(HCD_FLAG_HW_ACCESSIBLE, &xhci->shared_hcd->flags);
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index e4d7d3d06a75..866e141d4972 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -718,11 +718,12 @@ struct xhci_ep_ctx {
 /* bits 10:14 are Max Primary Streams */
 /* bit 15 is Linear Stream Array */
 /* Interval - period between requests to an endpoint - 125u increments. */
-#define EP_INTERVAL(p)          (((p) & 0xff) << 16)
-#define EP_INTERVAL_TO_UFRAMES(p)               (1 << (((p) >> 16) & 0xff))
-#define CTX_TO_EP_INTERVAL(p)   (((p) >> 16) & 0xff)
-#define EP_MAXPSTREAMS_MASK     (0x1f << 10)
-#define EP_MAXPSTREAMS(p)       (((p) << 10) & EP_MAXPSTREAMS_MASK)
+#define EP_INTERVAL(p)                  (((p) & 0xff) << 16)
+#define EP_INTERVAL_TO_UFRAMES(p)       (1 << (((p) >> 16) & 0xff))
+#define CTX_TO_EP_INTERVAL(p)           (((p) >> 16) & 0xff)
+#define EP_MAXPSTREAMS_MASK             (0x1f << 10)
+#define EP_MAXPSTREAMS(p)               (((p) << 10) & EP_MAXPSTREAMS_MASK)
+#define CTX_TO_EP_MAXPSTREAMS(p)        (((p) & EP_MAXPSTREAMS_MASK) >> 10)
 /* Endpoint is set up with a Linear Stream Array (vs. Secondary Stream Array) */
 #define EP_HAS_LSA              (1 << 15)
 /* hosts with LEC=1 use bits 31:24 as ESIT high bits. */
@@ -1825,6 +1826,7 @@ struct xhci_hcd {
 #define XHCI_U2_DISABLE_WAKE    (1 << 27)
 #define XHCI_ASMEDIA_MODIFY_FLOWCONTROL (1 << 28)
 #define XHCI_HW_LPM_DISABLE     (1 << 29)
+#define XHCI_SUSPEND_DELAY      (1 << 30)
 
         unsigned int            num_active_eps;
         unsigned int            limit_active_eps;
@@ -2549,21 +2551,22 @@ static inline const char *xhci_decode_ep_context(u32 info, u32 info2, u64 deq,
         u8 burst;
         u8 cerr;
         u8 mult;
-        u8 lsa;
-        u8 hid;
+
+        bool lsa;
+        bool hid;
 
         esit = CTX_TO_MAX_ESIT_PAYLOAD_HI(info) << 16 |
                 CTX_TO_MAX_ESIT_PAYLOAD(tx_info);
 
         ep_state = info & EP_STATE_MASK;
-        max_pstr = info & EP_MAXPSTREAMS_MASK;
+        max_pstr = CTX_TO_EP_MAXPSTREAMS(info);
         interval = CTX_TO_EP_INTERVAL(info);
         mult = CTX_TO_EP_MULT(info) + 1;
-        lsa = info & EP_HAS_LSA;
+        lsa = !!(info & EP_HAS_LSA);
 
         cerr = (info2 & (3 << 1)) >> 1;
         ep_type = CTX_TO_EP_TYPE(info2);
-        hid = info2 & (1 << 7);
+        hid = !!(info2 & (1 << 7));
         burst = CTX_TO_MAX_BURST(info2);
         maxp = MAX_PACKET_DECODED(info2);