18 files changed, 90 insertions, 29 deletions

diff --git a/drivers/phy/allwinner/phy-sun4i-usb.c b/drivers/phy/allwinner/phy-sun4i-usb.c
index 5163097b43df..4bbd9ede38c8 100644
--- a/drivers/phy/allwinner/phy-sun4i-usb.c
+++ b/drivers/phy/allwinner/phy-sun4i-usb.c
@@ -485,8 +485,11 @@ static int sun4i_usb_phy_set_mode(struct phy *_phy,
         struct sun4i_usb_phy_data *data = to_sun4i_usb_phy_data(phy);
         int new_mode;
 
-        if (phy->index != 0)
+        if (phy->index != 0) {
+                if (mode == PHY_MODE_USB_HOST)
+                        return 0;
                 return -EINVAL;
+        }
 
         switch (mode) {
         case PHY_MODE_USB_HOST:
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index 739f8960811a..ec666eb4b7b4 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -558,10 +558,8 @@ static void acm_softint(struct work_struct *work)
                 clear_bit(EVENT_RX_STALL, &acm->flags);
         }
 
-        if (test_bit(EVENT_TTY_WAKEUP, &acm->flags)) {
+        if (test_and_clear_bit(EVENT_TTY_WAKEUP, &acm->flags))
                 tty_port_tty_wakeup(&acm->port);
-                clear_bit(EVENT_TTY_WAKEUP, &acm->flags);
-        }
 }
 
 /*
diff --git a/drivers/usb/common/common.c b/drivers/usb/common/common.c
index 48277bbc15e4..73c8e6591746 100644
--- a/drivers/usb/common/common.c
+++ b/drivers/usb/common/common.c
@@ -145,6 +145,8 @@ enum usb_dr_mode of_usb_get_dr_mode_by_phy(struct device_node *np, int arg0)
 
         do {
                 controller = of_find_node_with_property(controller, "phys");
+                if (!of_device_is_available(controller))
+                        continue;
                 index = 0;
                 do {
                         if (arg0 == -1) {
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 3189181bb628..975d7c1288e3 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -2742,6 +2742,9 @@ int usb_add_hcd(struct usb_hcd *hcd,
                 retval = usb_phy_roothub_set_mode(hcd->phy_roothub,
                                                   PHY_MODE_USB_HOST_SS);
                 if (retval)
+                        retval = usb_phy_roothub_set_mode(hcd->phy_roothub,
+                                                          PHY_MODE_USB_HOST);
+                if (retval)
                         goto err_usb_phy_roothub_power_on;
 
                 retval = usb_phy_roothub_power_on(hcd->phy_roothub);
diff --git a/drivers/usb/dwc3/dwc3-pci.c b/drivers/usb/dwc3/dwc3-pci.c
index fdc6e4e403e8..8cced3609e24 100644
--- a/drivers/usb/dwc3/dwc3-pci.c
+++ b/drivers/usb/dwc3/dwc3-pci.c
@@ -29,6 +29,7 @@
 #define PCI_DEVICE_ID_INTEL_BXT_M               0x1aaa
 #define PCI_DEVICE_ID_INTEL_APL                 0x5aaa
 #define PCI_DEVICE_ID_INTEL_KBP                 0xa2b0
+#define PCI_DEVICE_ID_INTEL_CMLH                0x02ee
 #define PCI_DEVICE_ID_INTEL_GLK                 0x31aa
 #define PCI_DEVICE_ID_INTEL_CNPLP               0x9dee
 #define PCI_DEVICE_ID_INTEL_CNPH                0xa36e
@@ -305,6 +306,9 @@ static const struct pci_device_id dwc3_pci_id_table[] = {
         { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_MRFLD),
           (kernel_ulong_t) &dwc3_pci_mrfld_properties, },
 
+        { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_CMLH),
+          (kernel_ulong_t) &dwc3_pci_intel_properties, },
+
         { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_INTEL_SPTLP),
           (kernel_ulong_t) &dwc3_pci_intel_properties, },
 
diff --git a/drivers/usb/gadget/function/f_hid.c b/drivers/usb/gadget/function/f_hid.c
index 75b113a5b25c..f3816a5c861e 100644
--- a/drivers/usb/gadget/function/f_hid.c
+++ b/drivers/usb/gadget/function/f_hid.c
@@ -391,20 +391,20 @@ try_again:
         req->complete = f_hidg_req_complete;
         req->context  = hidg;
 
+        spin_unlock_irqrestore(&hidg->write_spinlock, flags);
+
         status = usb_ep_queue(hidg->in_ep, req, GFP_ATOMIC);
         if (status < 0) {
                 ERROR(hidg->func.config->cdev,
                         "usb_ep_queue error on int endpoint %zd\n", status);
-                goto release_write_pending_unlocked;
+                goto release_write_pending;
         } else {
                 status = count;
         }
-        spin_unlock_irqrestore(&hidg->write_spinlock, flags);
 
         return status;
 release_write_pending:
         spin_lock_irqsave(&hidg->write_spinlock, flags);
-release_write_pending_unlocked:
         hidg->write_pending = 0;
         spin_unlock_irqrestore(&hidg->write_spinlock, flags);
 
diff --git a/drivers/usb/gadget/udc/net2272.c b/drivers/usb/gadget/udc/net2272.c
index b77f3126580e..c2011cd7df8c 100644
--- a/drivers/usb/gadget/udc/net2272.c
+++ b/drivers/usb/gadget/udc/net2272.c
@@ -945,6 +945,7 @@ net2272_dequeue(struct usb_ep *_ep, struct usb_request *_req)
                         break;
         }
         if (&req->req != _req) {
+                ep->stopped = stopped;
                 spin_unlock_irqrestore(&ep->dev->lock, flags);
                 return -EINVAL;
         }
diff --git a/drivers/usb/gadget/udc/net2280.c b/drivers/usb/gadget/udc/net2280.c
index f63f82450bf4..898339e5df10 100644
--- a/drivers/usb/gadget/udc/net2280.c
+++ b/drivers/usb/gadget/udc/net2280.c
@@ -866,9 +866,6 @@ static void start_queue(struct net2280_ep *ep, u32 dmactl, u32 td_dma)
         (void) readl(&ep->dev->pci->pcimstctl);
 
         writel(BIT(DMA_START), &dma->dmastat);
-
-        if (!ep->is_in)
-                stop_out_naking(ep);
 }
 
 static void start_dma(struct net2280_ep *ep, struct net2280_request *req)
@@ -907,6 +904,7 @@ static void start_dma(struct net2280_ep *ep, struct net2280_request *req)
                         writel(BIT(DMA_START), &dma->dmastat);
                         return;
                 }
+                stop_out_naking(ep);
         }
 
         tmp = dmactl_default;
@@ -1275,9 +1273,9 @@ static int net2280_dequeue(struct usb_ep *_ep, struct usb_request *_req)
                         break;
         }
         if (&req->req != _req) {
+                ep->stopped = stopped;
                 spin_unlock_irqrestore(&ep->dev->lock, flags);
-                dev_err(&ep->dev->pdev->dev, "%s: Request mismatch\n",
-                                                                __func__);
+                ep_dbg(ep->dev, "%s: Request mismatch\n", __func__);
                 return -EINVAL;
         }
 
diff --git a/drivers/usb/host/u132-hcd.c b/drivers/usb/host/u132-hcd.c
index 934584f0a20a..6343fbacd244 100644
--- a/drivers/usb/host/u132-hcd.c
+++ b/drivers/usb/host/u132-hcd.c
@@ -3204,6 +3204,9 @@ static int __init u132_hcd_init(void)
         printk(KERN_INFO "driver %s\n", hcd_name);
         workqueue = create_singlethread_workqueue("u132");
         retval = platform_driver_register(&u132_platform_driver);
+        if (retval)
+                destroy_workqueue(workqueue);
+
         return retval;
 }
 
diff --git a/drivers/usb/host/xhci-dbgcap.c b/drivers/usb/host/xhci-dbgcap.c
index c78be578abb0..d932cc31711e 100644
--- a/drivers/usb/host/xhci-dbgcap.c
+++ b/drivers/usb/host/xhci-dbgcap.c
@@ -516,7 +516,6 @@ static int xhci_do_dbc_stop(struct xhci_hcd *xhci)
                 return -1;
 
         writel(0, &dbc->regs->control);
-        xhci_dbc_mem_cleanup(xhci);
         dbc->state = DS_DISABLED;
 
         return 0;
@@ -562,8 +561,10 @@ static void xhci_dbc_stop(struct xhci_hcd *xhci)
         ret = xhci_do_dbc_stop(xhci);
         spin_unlock_irqrestore(&dbc->lock, flags);
 
-        if (!ret)
+        if (!ret) {
+                xhci_dbc_mem_cleanup(xhci);
                 pm_runtime_put_sync(xhci_to_hcd(xhci)->self.controller);
+        }
 }
 
 static void
diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
index e2eece693655..96a740543183 100644
--- a/drivers/usb/host/xhci-hub.c
+++ b/drivers/usb/host/xhci-hub.c
@@ -1545,20 +1545,25 @@ int xhci_bus_suspend(struct usb_hcd *hcd)
         port_index = max_ports;
         while (port_index--) {
                 u32 t1, t2;
-
+                int retries = 10;
+retry:
                 t1 = readl(ports[port_index]->addr);
                 t2 = xhci_port_state_to_neutral(t1);
                 portsc_buf[port_index] = 0;
 
-                /* Bail out if a USB3 port has a new device in link training */
-                if ((hcd->speed >= HCD_USB3) &&
+                /*
+                 * Give a USB3 port in link training time to finish, but don't
+                 * prevent suspend as port might be stuck
+                 */
+                if ((hcd->speed >= HCD_USB3) && retries-- &&
                     (t1 & PORT_PLS_MASK) == XDEV_POLLING) {
-                        bus_state->bus_suspended = 0;
                         spin_unlock_irqrestore(&xhci->lock, flags);
-                        xhci_dbg(xhci, "Bus suspend bailout, port in polling\n");
-                        return -EBUSY;
+                        msleep(XHCI_PORT_POLLING_LFPS_TIME);
+                        spin_lock_irqsave(&xhci->lock, flags);
+                        xhci_dbg(xhci, "port %d polling in bus suspend, waiting\n",
+                                 port_index);
+                        goto retry;
                 }
-
                 /* suspend ports in U0, or bail out for new connect changes */
                 if ((t1 & PORT_PE) && (t1 & PORT_PLS_MASK) == XDEV_U0) {
                         if ((t1 & PORT_CSC) && wake_enabled) {
diff --git a/drivers/usb/host/xhci-rcar.c b/drivers/usb/host/xhci-rcar.c
index a6e463715779..671bce18782c 100644
--- a/drivers/usb/host/xhci-rcar.c
+++ b/drivers/usb/host/xhci-rcar.c
@@ -246,6 +246,7 @@ int xhci_rcar_init_quirk(struct usb_hcd *hcd)
         if (!xhci_rcar_wait_for_pll_active(hcd))
                 return -ETIMEDOUT;
 
+        xhci->quirks |= XHCI_TRUST_TX_LENGTH;
         return xhci_rcar_download_firmware(hcd);
 }
 
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 40fa25c4d041..9215a28dad40 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -1647,10 +1647,13 @@ static void handle_port_status(struct xhci_hcd *xhci,
                 }
         }
 
-        if ((portsc & PORT_PLC) && (portsc & PORT_PLS_MASK) == XDEV_U0 &&
-                        DEV_SUPERSPEED_ANY(portsc)) {
+        if ((portsc & PORT_PLC) &&
+            DEV_SUPERSPEED_ANY(portsc) &&
+            ((portsc & PORT_PLS_MASK) == XDEV_U0 ||
+             (portsc & PORT_PLS_MASK) == XDEV_U1 ||
+             (portsc & PORT_PLS_MASK) == XDEV_U2)) {
                 xhci_dbg(xhci, "resume SS port %d finished\n", port_id);
-                /* We've just brought the device into U0 through either the
+                /* We've just brought the device into U0/1/2 through either the
                  * Resume state after a device remote wakeup, or through the
                  * U3Exit state after a host-initiated resume.  If it's a device
                  * initiated remote wake, don't pass up the link state change,
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index 652dc36e3012..9334cdee382a 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -452,6 +452,14 @@ struct xhci_op_regs {
  */
 #define XHCI_DEFAULT_BESL       4
 
+/*
+ * USB3 specification define a 360ms tPollingLFPSTiemout for USB3 ports
+ * to complete link training. usually link trainig completes much faster
+ * so check status 10 times with 36ms sleep in places we need to wait for
+ * polling to complete.
+ */
+#define XHCI_PORT_POLLING_LFPS_TIME  36
+
 /**
  * struct xhci_intr_reg - Interrupt Register Set
  * @irq_pending:        IMAN - Interrupt Management Register.  Used to enable
diff --git a/drivers/usb/misc/usb251xb.c b/drivers/usb/misc/usb251xb.c
index 4d72b7d1d383..04684849d683 100644
--- a/drivers/usb/misc/usb251xb.c
+++ b/drivers/usb/misc/usb251xb.c
@@ -547,7 +547,7 @@ static int usb251xb_get_ofdata(struct usb251xb *hub,
          */
         hub->port_swap = USB251XB_DEF_PORT_SWAP;
         of_property_for_each_u32(np, "swap-dx-lanes", prop, p, port) {
-                if ((port >= 0) && (port <= data->port_cnt))
+                if (port <= data->port_cnt)
                         hub->port_swap |= BIT(port);
         }
 
@@ -612,7 +612,7 @@ static int usb251xb_probe(struct usb251xb *hub)
                                                            dev);
         int err;
 
-        if (np) {
+        if (np && of_id) {
                 err = usb251xb_get_ofdata(hub,
                                           (struct usb251xb_data *)of_id->data);
                 if (err) {
diff --git a/drivers/usb/mtu3/Kconfig b/drivers/usb/mtu3/Kconfig
index bcc23486c4ed..928c2cd6fc00 100644
--- a/drivers/usb/mtu3/Kconfig
+++ b/drivers/usb/mtu3/Kconfig
@@ -6,6 +6,7 @@ config USB_MTU3
         tristate "MediaTek USB3 Dual Role controller"
         depends on USB || USB_GADGET
         depends on ARCH_MEDIATEK || COMPILE_TEST
+        depends on EXTCON || !EXTCON
         select USB_XHCI_MTK if USB_SUPPORT && USB_XHCI_HCD
         help
           Say Y or M here if your system runs on MediaTek SoCs with
diff --git a/drivers/usb/typec/tcpm/tcpm.c b/drivers/usb/typec/tcpm/tcpm.c
index 0f62db091d8d..a2233d72ae7c 100644
--- a/drivers/usb/typec/tcpm/tcpm.c
+++ b/drivers/usb/typec/tcpm/tcpm.c
@@ -37,6 +37,7 @@
         S(SRC_ATTACHED),                        \
         S(SRC_STARTUP),                         \
         S(SRC_SEND_CAPABILITIES),               \
+        S(SRC_SEND_CAPABILITIES_TIMEOUT),       \
         S(SRC_NEGOTIATE_CAPABILITIES),          \
         S(SRC_TRANSITION_SUPPLY),               \
         S(SRC_READY),                           \
@@ -2966,10 +2967,34 @@ static void run_state_machine(struct tcpm_port *port)
                         /* port->hard_reset_count = 0; */
                         port->caps_count = 0;
                         port->pd_capable = true;
-                        tcpm_set_state_cond(port, hard_reset_state(port),
+                        tcpm_set_state_cond(port, SRC_SEND_CAPABILITIES_TIMEOUT,
                                             PD_T_SEND_SOURCE_CAP);
                 }
                 break;
+        case SRC_SEND_CAPABILITIES_TIMEOUT:
+                /*
+                 * Error recovery for a PD_DATA_SOURCE_CAP reply timeout.
+                 *
+                 * PD 2.0 sinks are supposed to accept src-capabilities with a
+                 * 3.0 header and simply ignore any src PDOs which the sink does
+                 * not understand such as PPS but some 2.0 sinks instead ignore
+                 * the entire PD_DATA_SOURCE_CAP message, causing contract
+                 * negotiation to fail.
+                 *
+                 * After PD_N_HARD_RESET_COUNT hard-reset attempts, we try
+                 * sending src-capabilities with a lower PD revision to
+                 * make these broken sinks work.
+                 */
+                if (port->hard_reset_count < PD_N_HARD_RESET_COUNT) {
+                        tcpm_set_state(port, HARD_RESET_SEND, 0);
+                } else if (port->negotiated_rev > PD_REV20) {
+                        port->negotiated_rev--;
+                        port->hard_reset_count = 0;
+                        tcpm_set_state(port, SRC_SEND_CAPABILITIES, 0);
+                } else {
+                        tcpm_set_state(port, hard_reset_state(port), 0);
+                }
+                break;
         case SRC_NEGOTIATE_CAPABILITIES:
                 ret = tcpm_pd_check_request(port);
                 if (ret < 0) {
diff --git a/drivers/usb/typec/tcpm/wcove.c b/drivers/usb/typec/tcpm/wcove.c
index 423208e19383..6770afd40765 100644
--- a/drivers/usb/typec/tcpm/wcove.c
+++ b/drivers/usb/typec/tcpm/wcove.c
@@ -615,8 +615,13 @@ static int wcove_typec_probe(struct platform_device *pdev)
         wcove->dev = &pdev->dev;
         wcove->regmap = pmic->regmap;
 
-        irq = regmap_irq_get_virq(pmic->irq_chip_data_chgr,
-                                  platform_get_irq(pdev, 0));
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(&pdev->dev, "Failed to get IRQ: %d\n", irq);
+                return irq;
+        }
+
+        irq = regmap_irq_get_virq(pmic->irq_chip_data_chgr, irq);
         if (irq < 0)
                 return irq;