1 files changed, 71 insertions, 58 deletions

diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index fc9e7cc6ac9b..c7880223738a 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -59,6 +59,7 @@ static void ehci_handover_companion_ports(struct ehci_hcd *ehci)
         /* Give the connections some time to appear */
         msleep(20);
 
+        spin_lock_irq(&ehci->lock);
         port = HCS_N_PORTS(ehci->hcs_params);
         while (port--) {
                 if (test_bit(port, &ehci->owned_ports)) {
@@ -70,23 +71,30 @@ static void ehci_handover_companion_ports(struct ehci_hcd *ehci)
                                 clear_bit(port, &ehci->owned_ports);
                         else if (test_bit(port, &ehci->companion_ports))
                                 ehci_writel(ehci, status & ~PORT_PE, reg);
-                        else
+                        else {
+                                spin_unlock_irq(&ehci->lock);
                                 ehci_hub_control(hcd, SetPortFeature,
                                                 USB_PORT_FEAT_RESET, port + 1,
                                                 NULL, 0);
+                                spin_lock_irq(&ehci->lock);
+                        }
                 }
         }
+        spin_unlock_irq(&ehci->lock);
 
         if (!ehci->owned_ports)
                 return;
         msleep(90);             /* Wait for resets to complete */
 
+        spin_lock_irq(&ehci->lock);
         port = HCS_N_PORTS(ehci->hcs_params);
         while (port--) {
                 if (test_bit(port, &ehci->owned_ports)) {
+                        spin_unlock_irq(&ehci->lock);
                         ehci_hub_control(hcd, GetPortStatus,
                                         0, port + 1,
                                         (char *) &buf, sizeof(buf));
+                        spin_lock_irq(&ehci->lock);
 
                         /* The companion should now own the port,
                          * but if something went wrong the port must not
@@ -105,9 +113,10 @@ static void ehci_handover_companion_ports(struct ehci_hcd *ehci)
         }
 
         ehci->owned_ports = 0;
+        spin_unlock_irq(&ehci->lock);
 }
 
-static int __maybe_unused ehci_port_change(struct ehci_hcd *ehci)
+static int ehci_port_change(struct ehci_hcd *ehci)
 {
         int i = HCS_N_PORTS(ehci->hcs_params);
 
@@ -128,12 +137,11 @@ static int __maybe_unused ehci_port_change(struct ehci_hcd *ehci)
         return 0;
 }
 
-static __maybe_unused void ehci_adjust_port_wakeup_flags(struct ehci_hcd *ehci,
+static void ehci_adjust_port_wakeup_flags(struct ehci_hcd *ehci,
                 bool suspending, bool do_wakeup)
 {
         int             port;
         u32             temp;
-        unsigned long   flags;
 
         /* If remote wakeup is enabled for the root hub but disabled
          * for the controller, we must adjust all the port wakeup flags
@@ -143,22 +151,20 @@ static __maybe_unused void ehci_adjust_port_wakeup_flags(struct ehci_hcd *ehci,
         if (!ehci_to_hcd(ehci)->self.root_hub->do_remote_wakeup || do_wakeup)
                 return;
 
-        spin_lock_irqsave(&ehci->lock, flags);
+        spin_lock_irq(&ehci->lock);
 
         /* clear phy low-power mode before changing wakeup flags */
         if (ehci->has_hostpc) {
                 port = HCS_N_PORTS(ehci->hcs_params);
                 while (port--) {
-                        u32 __iomem     *hostpc_reg;
+                        u32 __iomem     *hostpc_reg = &ehci->regs->hostpc[port];
 
-                        hostpc_reg = (u32 __iomem *)((u8 *) ehci->regs
-                                        + HOSTPC0 + 4 * port);
                         temp = ehci_readl(ehci, hostpc_reg);
                         ehci_writel(ehci, temp & ~HOSTPC_PHCD, hostpc_reg);
                 }
-                spin_unlock_irqrestore(&ehci->lock, flags);
+                spin_unlock_irq(&ehci->lock);
                 msleep(5);
-                spin_lock_irqsave(&ehci->lock, flags);
+                spin_lock_irq(&ehci->lock);
         }
 
         port = HCS_N_PORTS(ehci->hcs_params);
@@ -185,10 +191,8 @@ static __maybe_unused void ehci_adjust_port_wakeup_flags(struct ehci_hcd *ehci,
         if (ehci->has_hostpc) {
                 port = HCS_N_PORTS(ehci->hcs_params);
                 while (port--) {
-                        u32 __iomem     *hostpc_reg;
+                        u32 __iomem     *hostpc_reg = &ehci->regs->hostpc[port];
 
-                        hostpc_reg = (u32 __iomem *)((u8 *) ehci->regs
-                                        + HOSTPC0 + 4 * port);
                         temp = ehci_readl(ehci, hostpc_reg);
                         ehci_writel(ehci, temp | HOSTPC_PHCD, hostpc_reg);
                 }
@@ -198,7 +202,7 @@ static __maybe_unused void ehci_adjust_port_wakeup_flags(struct ehci_hcd *ehci,
         if (!suspending && ehci_port_change(ehci))
                 usb_hcd_resume_root_hub(ehci_to_hcd(ehci));
 
-        spin_unlock_irqrestore(&ehci->lock, flags);
+        spin_unlock_irq(&ehci->lock);
 }
 
 static int ehci_bus_suspend (struct usb_hcd *hcd)
@@ -212,10 +216,13 @@ static int ehci_bus_suspend (struct usb_hcd *hcd)
 
         if (time_before (jiffies, ehci->next_statechange))
                 msleep(5);
-        del_timer_sync(&ehci->watchdog);
-        del_timer_sync(&ehci->iaa_watchdog);
+
+        /* stop the schedules */
+        ehci_quiesce(ehci);
 
         spin_lock_irq (&ehci->lock);
+        if (ehci->rh_state < EHCI_RH_RUNNING)
+                goto done;
 
         /* Once the controller is stopped, port resumes that are already
          * in progress won't complete.  Hence if remote wakeup is enabled
@@ -230,11 +237,6 @@ static int ehci_bus_suspend (struct usb_hcd *hcd)
                 }
         }
 
-        /* stop schedules, clean any completed work */
-        if (ehci->rh_state == EHCI_RH_RUNNING)
-                ehci_quiesce (ehci);
-        ehci_work(ehci);
-
         /* Unlike other USB host controller types, EHCI doesn't have
          * any notion of "global" or bus-wide suspend.  The driver has
          * to manually suspend all the active unsuspended ports, and
@@ -285,11 +287,9 @@ static int ehci_bus_suspend (struct usb_hcd *hcd)
 
                 port = HCS_N_PORTS(ehci->hcs_params);
                 while (port--) {
-                        u32 __iomem     *hostpc_reg;
+                        u32 __iomem     *hostpc_reg = &ehci->regs->hostpc[port];
                         u32             t3;
 
-                        hostpc_reg = (u32 __iomem *)((u8 *) ehci->regs
-                                        + HOSTPC0 + 4 * port);
                         t3 = ehci_readl(ehci, hostpc_reg);
                         ehci_writel(ehci, t3 | HOSTPC_PHCD, hostpc_reg);
                         t3 = ehci_readl(ehci, hostpc_reg);
@@ -298,6 +298,7 @@ static int ehci_bus_suspend (struct usb_hcd *hcd)
                                         "succeeded" : "failed");
                 }
         }
+        spin_unlock_irq(&ehci->lock);
 
         /* Apparently some devices need a >= 1-uframe delay here */
         if (ehci->bus_suspended)
@@ -305,10 +306,18 @@ static int ehci_bus_suspend (struct usb_hcd *hcd)
 
         /* turn off now-idle HC */
         ehci_halt (ehci);
+
+        spin_lock_irq(&ehci->lock);
+        if (ehci->enabled_hrtimer_events & BIT(EHCI_HRTIMER_POLL_DEAD))
+                ehci_handle_controller_death(ehci);
+        if (ehci->rh_state != EHCI_RH_RUNNING)
+                goto done;
         ehci->rh_state = EHCI_RH_SUSPENDED;
 
-        if (ehci->reclaim)
-                end_unlink_async(ehci);
+        end_unlink_async(ehci);
+        unlink_empty_async(ehci);
+        ehci_handle_intr_unlinks(ehci);
+        end_free_itds(ehci);
 
         /* allow remote wakeup */
         mask = INTR_MASK;
@@ -317,13 +326,13 @@ static int ehci_bus_suspend (struct usb_hcd *hcd)
         ehci_writel(ehci, mask, &ehci->regs->intr_enable);
         ehci_readl(ehci, &ehci->regs->intr_enable);
 
+ done:
         ehci->next_statechange = jiffies + msecs_to_jiffies(10);
+        ehci->enabled_hrtimer_events = 0;
+        ehci->next_hrtimer_event = EHCI_HRTIMER_NO_EVENT;
         spin_unlock_irq (&ehci->lock);
 
-        /* ehci_work() may have re-enabled the watchdog timer, which we do not
-         * want, and so we must delete any pending watchdog timer events.
-         */
-        del_timer_sync(&ehci->watchdog);
+        hrtimer_cancel(&ehci->hrtimer);
         return 0;
 }
 
@@ -340,10 +349,8 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
         if (time_before (jiffies, ehci->next_statechange))
                 msleep(5);
         spin_lock_irq (&ehci->lock);
-        if (!HCD_HW_ACCESSIBLE(hcd)) {
-                spin_unlock_irq(&ehci->lock);
-                return -ESHUTDOWN;
-        }
+        if (!HCD_HW_ACCESSIBLE(hcd) || ehci->shutdown)
+                goto shutdown;
 
         if (unlikely(ehci->debug)) {
                 if (!dbgp_reset_prep())
@@ -382,16 +389,17 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
         spin_unlock_irq(&ehci->lock);
         msleep(8);
         spin_lock_irq(&ehci->lock);
+        if (ehci->shutdown)
+                goto shutdown;
 
         /* clear phy low-power mode before resume */
         if (ehci->bus_suspended && ehci->has_hostpc) {
                 i = HCS_N_PORTS(ehci->hcs_params);
                 while (i--) {
                         if (test_bit(i, &ehci->bus_suspended)) {
-                                u32 __iomem     *hostpc_reg;
+                                u32 __iomem     *hostpc_reg =
+                                                        &ehci->regs->hostpc[i];
 
-                                hostpc_reg = (u32 __iomem *)((u8 *) ehci->regs
-                                                + HOSTPC0 + 4 * i);
                                 temp = ehci_readl(ehci, hostpc_reg);
                                 ehci_writel(ehci, temp & ~HOSTPC_PHCD,
                                                 hostpc_reg);
@@ -400,6 +408,8 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
                 spin_unlock_irq(&ehci->lock);
                 msleep(5);
                 spin_lock_irq(&ehci->lock);
+                if (ehci->shutdown)
+                        goto shutdown;
         }
 
         /* manually resume the ports we suspended during bus_suspend() */
@@ -420,6 +430,8 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
                 spin_unlock_irq(&ehci->lock);
                 msleep(20);
                 spin_lock_irq(&ehci->lock);
+                if (ehci->shutdown)
+                        goto shutdown;
         }
 
         i = HCS_N_PORTS (ehci->hcs_params);
@@ -431,27 +443,25 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
                         ehci_vdbg (ehci, "resumed port %d\n", i + 1);
                 }
         }
-        (void) ehci_readl(ehci, &ehci->regs->command);
-
-        /* maybe re-activate the schedule(s) */
-        temp = 0;
-        if (ehci->async->qh_next.qh)
-                temp |= CMD_ASE;
-        if (ehci->periodic_sched)
-                temp |= CMD_PSE;
-        if (temp) {
-                ehci->command |= temp;
-                ehci_writel(ehci, ehci->command, &ehci->regs->command);
-        }
 
         ehci->next_statechange = jiffies + msecs_to_jiffies(5);
+        spin_unlock_irq(&ehci->lock);
+
+        ehci_handover_companion_ports(ehci);
 
         /* Now we can safely re-enable irqs */
+        spin_lock_irq(&ehci->lock);
+        if (ehci->shutdown)
+                goto shutdown;
         ehci_writel(ehci, INTR_MASK, &ehci->regs->intr_enable);
+        (void) ehci_readl(ehci, &ehci->regs->intr_enable);
+        spin_unlock_irq(&ehci->lock);
 
-        spin_unlock_irq (&ehci->lock);
-        ehci_handover_companion_ports(ehci);
         return 0;
+
+ shutdown:
+        spin_unlock_irq(&ehci->lock);
+        return -ESHUTDOWN;
 }
 
 #else
@@ -667,7 +677,7 @@ static int ehci_hub_control (
         int             ports = HCS_N_PORTS (ehci->hcs_params);
         u32 __iomem     *status_reg = &ehci->regs->port_status[
                                 (wIndex & 0xff) - 1];
-        u32 __iomem     *hostpc_reg = NULL;
+        u32 __iomem     *hostpc_reg = &ehci->regs->hostpc[(wIndex & 0xff) - 1];
         u32             temp, temp1, status;
         unsigned long   flags;
         int             retval = 0;
@@ -680,9 +690,6 @@ static int ehci_hub_control (
          * power, "this is the one", etc.  EHCI spec supports this.
          */
 
-        if (ehci->has_hostpc)
-                hostpc_reg = (u32 __iomem *)((u8 *)ehci->regs
-                                + HOSTPC0 + 4 * ((wIndex & 0xff) - 1));
         spin_lock_irqsave (&ehci->lock, flags);
         switch (typeReq) {
         case ClearHubFeature:
@@ -724,7 +731,7 @@ static int ehci_hub_control (
 #ifdef CONFIG_USB_OTG
                         if ((hcd->self.otg_port == (wIndex + 1))
                             && hcd->self.b_hnp_enable) {
-                                otg_start_hnp(ehci->transceiver->otg);
+                                otg_start_hnp(hcd->phy->otg);
                                 break;
                         }
 #endif
@@ -734,7 +741,7 @@ static int ehci_hub_control (
                                 goto error;
 
                         /* clear phy low-power mode before resume */
-                        if (hostpc_reg) {
+                        if (ehci->has_hostpc) {
                                 temp1 = ehci_readl(ehci, hostpc_reg);
                                 ehci_writel(ehci, temp1 & ~HOSTPC_PHCD,
                                                 hostpc_reg);
@@ -984,7 +991,7 @@ static int ehci_hub_control (
                         temp &= ~PORT_WKCONN_E;
                         temp |= PORT_WKDISC_E | PORT_WKOC_E;
                         ehci_writel(ehci, temp | PORT_SUSPEND, status_reg);
-                        if (hostpc_reg) {
+                        if (ehci->has_hostpc) {
                                 spin_unlock_irqrestore(&ehci->lock, flags);
                                 msleep(5);/* 5ms for HCD enter low pwr mode */
                                 spin_lock_irqsave(&ehci->lock, flags);
@@ -1041,7 +1048,9 @@ static int ehci_hub_control (
                 case USB_PORT_FEAT_TEST:
                         if (!selector || selector > 5)
                                 goto error;
+                        spin_unlock_irqrestore(&ehci->lock, flags);
                         ehci_quiesce(ehci);
+                        spin_lock_irqsave(&ehci->lock, flags);
 
                         /* Put all enabled ports into suspend */
                         while (ports--) {
@@ -1053,7 +1062,11 @@ static int ehci_hub_control (
                                         ehci_writel(ehci, temp | PORT_SUSPEND,
                                                         sreg);
                         }
+
+                        spin_unlock_irqrestore(&ehci->lock, flags);
                         ehci_halt(ehci);
+                        spin_lock_irqsave(&ehci->lock, flags);
+
                         temp = ehci_readl(ehci, status_reg);
                         temp |= selector << 16;
                         ehci_writel(ehci, temp, status_reg);