Merge tag 'usb-for-v4.1-part2' of git://git.kernel.org/pub/scm/linux/kernel/git/balbi/usb into usb-testing

Felipe writes:

usb: generic resume timeout for v4.1

This part 2 pull request contains only the patches
which make sure everybody on linux uses the same
resume timeout value.

Signed-off-by: Felipe Balbi <balbi@ti.com>

16 files changed, 59 insertions, 28 deletions

diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index d7c3d5a35946..3b7151687776 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -3406,10 +3406,10 @@ int usb_port_resume(struct usb_device *udev, pm_message_t msg)
         if (status) {
                 dev_dbg(&port_dev->dev, "can't resume, status %d\n", status);
         } else {
-                /* drive resume for at least 20 msec */
+                /* drive resume for USB_RESUME_TIMEOUT msec */
                 dev_dbg(&udev->dev, "usb %sresume\n",
                                 (PMSG_IS_AUTO(msg) ? "auto-" : ""));
-                msleep(25);
+                msleep(USB_RESUME_TIMEOUT);
 
                 /* Virtual root hubs can trigger on GET_PORT_STATUS to
                  * stop resume signaling.  Then finish the resume
diff --git a/drivers/usb/dwc2/hcd.c b/drivers/usb/dwc2/hcd.c
index 6f4acfa9252e..93bd4a10ab52 100644
--- a/drivers/usb/dwc2/hcd.c
+++ b/drivers/usb/dwc2/hcd.c
@@ -1529,7 +1529,7 @@ static int dwc2_hcd_hub_control(struct dwc2_hsotg *hsotg, u16 typereq,
                         dev_dbg(hsotg->dev,
                                 "ClearPortFeature USB_PORT_FEAT_SUSPEND\n");
                         writel(0, hsotg->regs + PCGCTL);
-                        usleep_range(20000, 40000);
+                        msleep(USB_RESUME_TIMEOUT);
 
                         hprt0 = dwc2_read_hprt0(hsotg);
                         hprt0 |= HPRT0_RES;
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index 85e56d1abd23..f4d88dfb26a7 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -792,12 +792,12 @@ static irqreturn_t ehci_irq (struct usb_hcd *hcd)
                                         ehci->reset_done[i] == 0))
                                 continue;
 
-                        /* start 20 msec resume signaling from this port,
-                         * and make hub_wq collect PORT_STAT_C_SUSPEND to
-                         * stop that signaling.  Use 5 ms extra for safety,
-                         * like usb_port_resume() does.
+                        /* start USB_RESUME_TIMEOUT msec resume signaling from
+                         * this port, and make hub_wq collect
+                         * PORT_STAT_C_SUSPEND to stop that signaling.
                          */
-                        ehci->reset_done[i] = jiffies + msecs_to_jiffies(25);
+                        ehci->reset_done[i] = jiffies +
+                                msecs_to_jiffies(USB_RESUME_TIMEOUT);
                         set_bit(i, &ehci->resuming_ports);
                         ehci_dbg (ehci, "port %d remote wakeup\n", i + 1);
                         usb_hcd_start_port_resume(&hcd->self, i);
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index d7b4b511b5c6..69208447d213 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -471,10 +471,13 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
                 ehci_writel(ehci, temp, &ehci->regs->port_status [i]);
         }
 
-        /* msleep for 20ms only if code is trying to resume port */
+        /*
+         * msleep for USB_RESUME_TIMEOUT ms only if code is trying to resume
+         * port
+         */
         if (resume_needed) {
                 spin_unlock_irq(&ehci->lock);
-                msleep(20);
+                msleep(USB_RESUME_TIMEOUT);
                 spin_lock_irq(&ehci->lock);
                 if (ehci->shutdown)
                         goto shutdown;
@@ -942,7 +945,7 @@ int ehci_hub_control(
                         temp &= ~PORT_WAKE_BITS;
                         ehci_writel(ehci, temp | PORT_RESUME, status_reg);
                         ehci->reset_done[wIndex] = jiffies
-                                        + msecs_to_jiffies(20);
+                                        + msecs_to_jiffies(USB_RESUME_TIMEOUT);
                         set_bit(wIndex, &ehci->resuming_ports);
                         usb_hcd_start_port_resume(&hcd->self, wIndex);
                         break;
diff --git a/drivers/usb/host/fotg210-hcd.c b/drivers/usb/host/fotg210-hcd.c
index af08ff12954d..000ed80ab592 100644
--- a/drivers/usb/host/fotg210-hcd.c
+++ b/drivers/usb/host/fotg210-hcd.c
@@ -1595,7 +1595,7 @@ static int fotg210_hub_control(
                         /* resume signaling for 20 msec */
                         fotg210_writel(fotg210, temp | PORT_RESUME, status_reg);
                         fotg210->reset_done[wIndex] = jiffies
-                                        + msecs_to_jiffies(20);
+                                        + msecs_to_jiffies(USB_RESUME_TIMEOUT);
                         break;
                 case USB_PORT_FEAT_C_SUSPEND:
                         clear_bit(wIndex, &fotg210->port_c_suspend);
diff --git a/drivers/usb/host/fusbh200-hcd.c b/drivers/usb/host/fusbh200-hcd.c
index eb39a451ef06..00e492eaba6a 100644
--- a/drivers/usb/host/fusbh200-hcd.c
+++ b/drivers/usb/host/fusbh200-hcd.c
@@ -1550,10 +1550,9 @@ static int fusbh200_hub_control (
                         if ((temp & PORT_PE) == 0)
                                 goto error;
 
-                        /* resume signaling for 20 msec */
                         fusbh200_writel(fusbh200, temp | PORT_RESUME, status_reg);
                         fusbh200->reset_done[wIndex] = jiffies
-                                        + msecs_to_jiffies(20);
+                                        + msecs_to_jiffies(USB_RESUME_TIMEOUT);
                         break;
                 case USB_PORT_FEAT_C_SUSPEND:
                         clear_bit(wIndex, &fusbh200->port_c_suspend);
diff --git a/drivers/usb/host/isp116x-hcd.c b/drivers/usb/host/isp116x-hcd.c
index aa335fa716d1..13181dcd9820 100644
--- a/drivers/usb/host/isp116x-hcd.c
+++ b/drivers/usb/host/isp116x-hcd.c
@@ -1490,7 +1490,7 @@ static int isp116x_bus_resume(struct usb_hcd *hcd)
         spin_unlock_irq(&isp116x->lock);
 
         hcd->state = HC_STATE_RESUMING;
-        msleep(20);
+        msleep(USB_RESUME_TIMEOUT);
 
         /* Go operational */
         spin_lock_irq(&isp116x->lock);
diff --git a/drivers/usb/host/oxu210hp-hcd.c b/drivers/usb/host/oxu210hp-hcd.c
index 681ce57bf7b9..6352f54e65a1 100644
--- a/drivers/usb/host/oxu210hp-hcd.c
+++ b/drivers/usb/host/oxu210hp-hcd.c
@@ -2500,11 +2500,12 @@ static irqreturn_t oxu210_hcd_irq(struct usb_hcd *hcd)
                                         || oxu->reset_done[i] != 0)
                                 continue;
 
-                        /* start 20 msec resume signaling from this port,
-                         * and make hub_wq collect PORT_STAT_C_SUSPEND to
+                        /* start USB_RESUME_TIMEOUT resume signaling from this
+                         * port, and make hub_wq collect PORT_STAT_C_SUSPEND to
                          * stop that signaling.
                          */
-                        oxu->reset_done[i] = jiffies + msecs_to_jiffies(20);
+                        oxu->reset_done[i] = jiffies +
+                                msecs_to_jiffies(USB_RESUME_TIMEOUT);
                         oxu_dbg(oxu, "port %d remote wakeup\n", i + 1);
                         mod_timer(&hcd->rh_timer, oxu->reset_done[i]);
                 }
diff --git a/drivers/usb/host/r8a66597-hcd.c b/drivers/usb/host/r8a66597-hcd.c
index 5cbaa9846ab9..4cbd0633c5c2 100644
--- a/drivers/usb/host/r8a66597-hcd.c
+++ b/drivers/usb/host/r8a66597-hcd.c
@@ -2301,7 +2301,7 @@ static int r8a66597_bus_resume(struct usb_hcd *hcd)
                 rh->port &= ~USB_PORT_STAT_SUSPEND;
                 rh->port |= USB_PORT_STAT_C_SUSPEND << 16;
                 r8a66597_mdfy(r8a66597, RESUME, RESUME | UACT, dvstctr_reg);
-                msleep(50);
+                msleep(USB_RESUME_TIMEOUT);
                 r8a66597_mdfy(r8a66597, UACT, RESUME | UACT, dvstctr_reg);
         }
 
diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c
index 53e4fb75b04c..fd2a11473be7 100644
--- a/drivers/usb/host/sl811-hcd.c
+++ b/drivers/usb/host/sl811-hcd.c
@@ -1259,7 +1259,7 @@ sl811h_hub_control(
                         sl811_write(sl811, SL11H_CTLREG1, sl811->ctrl1);
 
                         mod_timer(&sl811->timer, jiffies
-                                        + msecs_to_jiffies(20));
+                                        + msecs_to_jiffies(USB_RESUME_TIMEOUT));
                         break;
                 case USB_PORT_FEAT_POWER:
                         port_power(sl811, 0);
diff --git a/drivers/usb/host/uhci-hub.c b/drivers/usb/host/uhci-hub.c
index a7cc0221e003..ece9e37e89fe 100644
--- a/drivers/usb/host/uhci-hub.c
+++ b/drivers/usb/host/uhci-hub.c
@@ -166,7 +166,7 @@ static void uhci_check_ports(struct uhci_hcd *uhci)
                                 /* Port received a wakeup request */
                                 set_bit(port, &uhci->resuming_ports);
                                 uhci->ports_timeout = jiffies +
-                                                msecs_to_jiffies(25);
+                                        msecs_to_jiffies(USB_RESUME_TIMEOUT);
                                 usb_hcd_start_port_resume(
                                                 &uhci_to_hcd(uhci)->self, port);
 
@@ -338,7 +338,8 @@ static int uhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         uhci_finish_suspend(uhci, port, port_addr);
 
                         /* USB v2.0 7.1.7.5 */
-                        uhci->ports_timeout = jiffies + msecs_to_jiffies(50);
+                        uhci->ports_timeout = jiffies +
+                                msecs_to_jiffies(USB_RESUME_TIMEOUT);
                         break;
                 case USB_PORT_FEAT_POWER:
                         /* UHCI has no power switching */
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index d8fb2cdaf8d8..f5397a517c54 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -1574,7 +1574,7 @@ static void handle_port_status(struct xhci_hcd *xhci,
                 } else {
                         xhci_dbg(xhci, "resume HS port %d\n", port_id);
                         bus_state->resume_done[faked_port_index] = jiffies +
-                                msecs_to_jiffies(20);
+                                msecs_to_jiffies(USB_RESUME_TIMEOUT);
                         set_bit(faked_port_index, &bus_state->resuming_ports);
                         mod_timer(&hcd->rh_timer,
                                   bus_state->resume_done[faked_port_index]);
diff --git a/drivers/usb/isp1760/isp1760-hcd.c b/drivers/usb/isp1760/isp1760-hcd.c
index 9e23153c3c2e..ac31d19cc54b 100644
--- a/drivers/usb/isp1760/isp1760-hcd.c
+++ b/drivers/usb/isp1760/isp1760-hcd.c
@@ -1869,7 +1869,7 @@ static int isp1760_hub_control(struct usb_hcd *hcd, u16 typeReq,
                                 reg_write32(hcd->regs, HC_PORTSC1,
                                                         temp | PORT_RESUME);
                                 priv->reset_done = jiffies +
-                                        msecs_to_jiffies(20);
+                                        msecs_to_jiffies(USB_RESUME_TIMEOUT);
                         }
                         break;
                 case USB_PORT_FEAT_C_SUSPEND:
diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c
index a48b5a9c6c47..3789b08ef67b 100644
--- a/drivers/usb/musb/musb_core.c
+++ b/drivers/usb/musb/musb_core.c
@@ -99,6 +99,7 @@
 #include <linux/platform_device.h>
 #include <linux/io.h>
 #include <linux/dma-mapping.h>
+#include <linux/usb.h>
 
 #include "musb_core.h"
 
@@ -549,7 +550,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                                                 (USB_PORT_STAT_C_SUSPEND << 16)
                                                 | MUSB_PORT_STAT_RESUME;
                                 musb->rh_timer = jiffies
-                                                 + msecs_to_jiffies(20);
+                                        + msecs_to_jiffies(USB_RESUME_TIMEOUT);
                                 musb->need_finish_resume = 1;
 
                                 musb->xceiv->otg->state = OTG_STATE_A_HOST;
@@ -2463,7 +2464,7 @@ static int musb_resume(struct device *dev)
         if (musb->need_finish_resume) {
                 musb->need_finish_resume = 0;
                 schedule_delayed_work(&musb->finish_resume_work,
-                                      msecs_to_jiffies(20));
+                                      msecs_to_jiffies(USB_RESUME_TIMEOUT));
         }
 
         /*
@@ -2506,7 +2507,7 @@ static int musb_runtime_resume(struct device *dev)
         if (musb->need_finish_resume) {
                 musb->need_finish_resume = 0;
                 schedule_delayed_work(&musb->finish_resume_work,
-                                msecs_to_jiffies(20));
+                                msecs_to_jiffies(USB_RESUME_TIMEOUT));
         }
 
         return 0;
diff --git a/drivers/usb/musb/musb_virthub.c b/drivers/usb/musb/musb_virthub.c
index 52ee9a74f6ee..86c4b533e90b 100644
--- a/drivers/usb/musb/musb_virthub.c
+++ b/drivers/usb/musb/musb_virthub.c
@@ -136,7 +136,7 @@ void musb_port_suspend(struct musb *musb, bool do_suspend)
                 /* later, GetPortStatus will stop RESUME signaling */
                 musb->port1_status |= MUSB_PORT_STAT_RESUME;
                 schedule_delayed_work(&musb->finish_resume_work,
-                                      msecs_to_jiffies(20));
+                                      msecs_to_jiffies(USB_RESUME_TIMEOUT));
         }
 }
 
diff --git a/include/linux/usb.h b/include/linux/usb.h
index 7ee1b5c3b4cb..447fe29b55b4 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -205,6 +205,32 @@ void usb_put_intf(struct usb_interface *intf);
 #define USB_MAXINTERFACES       32
 #define USB_MAXIADS             (USB_MAXINTERFACES/2)
 
+/*
+ * USB Resume Timer: Every Host controller driver should drive the resume
+ * signalling on the bus for the amount of time defined by this macro.
+ *
+ * That way we will have a 'stable' behavior among all HCDs supported by Linux.
+ *
+ * Note that the USB Specification states we should drive resume for *at least*
+ * 20 ms, but it doesn't give an upper bound. This creates two possible
+ * situations which we want to avoid:
+ *
+ * (a) sometimes an msleep(20) might expire slightly before 20 ms, which causes
+ * us to fail USB Electrical Tests, thus failing Certification
+ *
+ * (b) Some (many) devices actually need more than 20 ms of resume signalling,
+ * and while we can argue that's against the USB Specification, we don't have
+ * control over which devices a certification laboratory will be using for
+ * certification. If CertLab uses a device which was tested against Windows and
+ * that happens to have relaxed resume signalling rules, we might fall into
+ * situations where we fail interoperability and electrical tests.
+ *
+ * In order to avoid both conditions, we're using a 40 ms resume timeout, which
+ * should cope with both LPJ calibration errors and devices not following every
+ * detail of the USB Specification.
+ */
+#define USB_RESUME_TIMEOUT      40 /* ms */
+
 /**
  * struct usb_interface_cache - long-term representation of a device interface
  * @num_altsetting: number of altsettings defined.