2 * Copyright (C) 2001-2004 by David Brownell
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License as published by the
6 * Free Software Foundation; either version 2 of the License, or (at your
7 * option) any later version.
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
11 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software Foundation,
16 * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 /* this file is part of ehci-hcd.c */
21 /*-------------------------------------------------------------------------*/
24 * EHCI Root Hub ... the nonsharable stuff
26 * Registers don't need cpu_to_le32, that happens transparently
29 /*-------------------------------------------------------------------------*/
30 #include <linux/usb/otg.h>
32 #define PORT_WAKE_BITS (PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E)
36 static int ehci_hub_control(
45 static int persist_enabled_on_companion(struct usb_device
*udev
, void *unused
)
47 return !udev
->maxchild
&& udev
->persist_enabled
&&
48 udev
->bus
->root_hub
->speed
< USB_SPEED_HIGH
;
51 /* After a power loss, ports that were owned by the companion must be
52 * reset so that the companion can still own them.
54 static void ehci_handover_companion_ports(struct ehci_hcd
*ehci
)
60 struct usb_hcd
*hcd
= ehci_to_hcd(ehci
);
62 if (!ehci
->owned_ports
)
66 * USB 1.1 devices are mostly HIDs, which don't need to persist across
67 * suspends. If we ensure that none of our companion's devices have
68 * persist_enabled (by looking through all USB 1.1 buses in the system),
69 * we can skip this and avoid slowing resume down. Devices without
70 * persist will just get reenumerated shortly after resume anyway.
72 if (!usb_for_each_dev(NULL
, persist_enabled_on_companion
))
75 /* Make sure the ports are powered */
76 port
= HCS_N_PORTS(ehci
->hcs_params
);
78 if (test_bit(port
, &ehci
->owned_ports
)) {
79 reg
= &ehci
->regs
->port_status
[port
];
80 status
= ehci_readl(ehci
, reg
) & ~PORT_RWC_BITS
;
81 if (!(status
& PORT_POWER
)) {
83 ehci_writel(ehci
, status
, reg
);
88 /* Give the connections some time to appear */
91 spin_lock_irq(&ehci
->lock
);
92 port
= HCS_N_PORTS(ehci
->hcs_params
);
94 if (test_bit(port
, &ehci
->owned_ports
)) {
95 reg
= &ehci
->regs
->port_status
[port
];
96 status
= ehci_readl(ehci
, reg
) & ~PORT_RWC_BITS
;
98 /* Port already owned by companion? */
99 if (status
& PORT_OWNER
)
100 clear_bit(port
, &ehci
->owned_ports
);
101 else if (test_bit(port
, &ehci
->companion_ports
))
102 ehci_writel(ehci
, status
& ~PORT_PE
, reg
);
104 spin_unlock_irq(&ehci
->lock
);
105 ehci_hub_control(hcd
, SetPortFeature
,
106 USB_PORT_FEAT_RESET
, port
+ 1,
108 spin_lock_irq(&ehci
->lock
);
112 spin_unlock_irq(&ehci
->lock
);
114 if (!ehci
->owned_ports
)
116 msleep(90); /* Wait for resets to complete */
118 spin_lock_irq(&ehci
->lock
);
119 port
= HCS_N_PORTS(ehci
->hcs_params
);
121 if (test_bit(port
, &ehci
->owned_ports
)) {
122 spin_unlock_irq(&ehci
->lock
);
123 ehci_hub_control(hcd
, GetPortStatus
,
125 (char *) &buf
, sizeof(buf
));
126 spin_lock_irq(&ehci
->lock
);
128 /* The companion should now own the port,
129 * but if something went wrong the port must not
132 reg
= &ehci
->regs
->port_status
[port
];
133 status
= ehci_readl(ehci
, reg
) & ~PORT_RWC_BITS
;
134 if (status
& PORT_OWNER
)
135 ehci_writel(ehci
, status
| PORT_CSC
, reg
);
137 ehci_dbg(ehci
, "failed handover port %d: %x\n",
139 ehci_writel(ehci
, status
& ~PORT_PE
, reg
);
144 ehci
->owned_ports
= 0;
145 spin_unlock_irq(&ehci
->lock
);
148 static int ehci_port_change(struct ehci_hcd
*ehci
)
150 int i
= HCS_N_PORTS(ehci
->hcs_params
);
152 /* First check if the controller indicates a change event */
154 if (ehci_readl(ehci
, &ehci
->regs
->status
) & STS_PCD
)
158 * Not all controllers appear to update this while going from D3 to D0,
159 * so check the individual port status registers as well
163 if (ehci_readl(ehci
, &ehci
->regs
->port_status
[i
]) & PORT_CSC
)
169 static void ehci_adjust_port_wakeup_flags(struct ehci_hcd
*ehci
,
170 bool suspending
, bool do_wakeup
)
175 /* If remote wakeup is enabled for the root hub but disabled
176 * for the controller, we must adjust all the port wakeup flags
177 * when the controller is suspended or resumed. In all other
178 * cases they don't need to be changed.
180 if (!ehci_to_hcd(ehci
)->self
.root_hub
->do_remote_wakeup
|| do_wakeup
)
183 spin_lock_irq(&ehci
->lock
);
185 /* clear phy low-power mode before changing wakeup flags */
186 if (ehci
->has_hostpc
) {
187 port
= HCS_N_PORTS(ehci
->hcs_params
);
189 u32 __iomem
*hostpc_reg
= &ehci
->regs
->hostpc
[port
];
191 temp
= ehci_readl(ehci
, hostpc_reg
);
192 ehci_writel(ehci
, temp
& ~HOSTPC_PHCD
, hostpc_reg
);
194 spin_unlock_irq(&ehci
->lock
);
196 spin_lock_irq(&ehci
->lock
);
199 port
= HCS_N_PORTS(ehci
->hcs_params
);
201 u32 __iomem
*reg
= &ehci
->regs
->port_status
[port
];
202 u32 t1
= ehci_readl(ehci
, reg
) & ~PORT_RWC_BITS
;
203 u32 t2
= t1
& ~PORT_WAKE_BITS
;
205 /* If we are suspending the controller, clear the flags.
206 * If we are resuming the controller, set the wakeup flags.
209 if (t1
& PORT_CONNECT
)
210 t2
|= PORT_WKOC_E
| PORT_WKDISC_E
;
212 t2
|= PORT_WKOC_E
| PORT_WKCONN_E
;
214 ehci_vdbg(ehci
, "port %d, %08x -> %08x\n",
216 ehci_writel(ehci
, t2
, reg
);
219 /* enter phy low-power mode again */
220 if (ehci
->has_hostpc
) {
221 port
= HCS_N_PORTS(ehci
->hcs_params
);
223 u32 __iomem
*hostpc_reg
= &ehci
->regs
->hostpc
[port
];
225 temp
= ehci_readl(ehci
, hostpc_reg
);
226 ehci_writel(ehci
, temp
| HOSTPC_PHCD
, hostpc_reg
);
230 /* Does the root hub have a port wakeup pending? */
231 if (!suspending
&& ehci_port_change(ehci
))
232 usb_hcd_resume_root_hub(ehci_to_hcd(ehci
));
234 spin_unlock_irq(&ehci
->lock
);
237 static int ehci_bus_suspend (struct usb_hcd
*hcd
)
239 struct ehci_hcd
*ehci
= hcd_to_ehci (hcd
);
244 ehci_dbg(ehci
, "suspend root hub\n");
246 if (time_before (jiffies
, ehci
->next_statechange
))
249 /* stop the schedules */
252 spin_lock_irq (&ehci
->lock
);
253 if (ehci
->rh_state
< EHCI_RH_RUNNING
)
256 /* Once the controller is stopped, port resumes that are already
257 * in progress won't complete. Hence if remote wakeup is enabled
258 * for the root hub and any ports are in the middle of a resume or
259 * remote wakeup, we must fail the suspend.
261 if (hcd
->self
.root_hub
->do_remote_wakeup
) {
262 if (ehci
->resuming_ports
) {
263 spin_unlock_irq(&ehci
->lock
);
264 ehci_dbg(ehci
, "suspend failed because a port is resuming\n");
269 /* Unlike other USB host controller types, EHCI doesn't have
270 * any notion of "global" or bus-wide suspend. The driver has
271 * to manually suspend all the active unsuspended ports, and
272 * then manually resume them in the bus_resume() routine.
274 ehci
->bus_suspended
= 0;
275 ehci
->owned_ports
= 0;
277 port
= HCS_N_PORTS(ehci
->hcs_params
);
279 u32 __iomem
*reg
= &ehci
->regs
->port_status
[port
];
280 u32 t1
= ehci_readl(ehci
, reg
) & ~PORT_RWC_BITS
;
281 u32 t2
= t1
& ~PORT_WAKE_BITS
;
283 /* keep track of which ports we suspend */
285 set_bit(port
, &ehci
->owned_ports
);
286 else if ((t1
& PORT_PE
) && !(t1
& PORT_SUSPEND
)) {
288 set_bit(port
, &ehci
->bus_suspended
);
291 /* enable remote wakeup on all ports, if told to do so */
292 if (hcd
->self
.root_hub
->do_remote_wakeup
) {
293 /* only enable appropriate wake bits, otherwise the
294 * hardware can not go phy low power mode. If a race
295 * condition happens here(connection change during bits
296 * set), the port change detection will finally fix it.
298 if (t1
& PORT_CONNECT
)
299 t2
|= PORT_WKOC_E
| PORT_WKDISC_E
;
301 t2
|= PORT_WKOC_E
| PORT_WKCONN_E
;
305 ehci_vdbg (ehci
, "port %d, %08x -> %08x\n",
307 ehci_writel(ehci
, t2
, reg
);
312 if (changed
&& ehci
->has_hostpc
) {
313 spin_unlock_irq(&ehci
->lock
);
314 msleep(5); /* 5 ms for HCD to enter low-power mode */
315 spin_lock_irq(&ehci
->lock
);
317 port
= HCS_N_PORTS(ehci
->hcs_params
);
319 u32 __iomem
*hostpc_reg
= &ehci
->regs
->hostpc
[port
];
322 t3
= ehci_readl(ehci
, hostpc_reg
);
323 ehci_writel(ehci
, t3
| HOSTPC_PHCD
, hostpc_reg
);
324 t3
= ehci_readl(ehci
, hostpc_reg
);
325 ehci_dbg(ehci
, "Port %d phy low-power mode %s\n",
326 port
, (t3
& HOSTPC_PHCD
) ?
327 "succeeded" : "failed");
330 spin_unlock_irq(&ehci
->lock
);
332 /* Apparently some devices need a >= 1-uframe delay here */
333 if (ehci
->bus_suspended
)
336 /* turn off now-idle HC */
339 spin_lock_irq(&ehci
->lock
);
340 if (ehci
->enabled_hrtimer_events
& BIT(EHCI_HRTIMER_POLL_DEAD
))
341 ehci_handle_controller_death(ehci
);
342 if (ehci
->rh_state
!= EHCI_RH_RUNNING
)
344 ehci
->rh_state
= EHCI_RH_SUSPENDED
;
346 end_unlink_async(ehci
);
347 unlink_empty_async_suspended(ehci
);
348 ehci_handle_intr_unlinks(ehci
);
351 /* allow remote wakeup */
353 if (!hcd
->self
.root_hub
->do_remote_wakeup
)
355 ehci_writel(ehci
, mask
, &ehci
->regs
->intr_enable
);
356 ehci_readl(ehci
, &ehci
->regs
->intr_enable
);
359 ehci
->next_statechange
= jiffies
+ msecs_to_jiffies(10);
360 ehci
->enabled_hrtimer_events
= 0;
361 ehci
->next_hrtimer_event
= EHCI_HRTIMER_NO_EVENT
;
362 spin_unlock_irq (&ehci
->lock
);
364 hrtimer_cancel(&ehci
->hrtimer
);
369 /* caller has locked the root hub, and should reset/reinit on error */
370 static int ehci_bus_resume (struct usb_hcd
*hcd
)
372 struct ehci_hcd
*ehci
= hcd_to_ehci (hcd
);
376 unsigned long resume_needed
= 0;
378 if (time_before (jiffies
, ehci
->next_statechange
))
380 spin_lock_irq (&ehci
->lock
);
381 if (!HCD_HW_ACCESSIBLE(hcd
) || ehci
->shutdown
)
384 if (unlikely(ehci
->debug
)) {
385 if (!dbgp_reset_prep(hcd
))
388 dbgp_external_startup(hcd
);
391 /* Ideally and we've got a real resume here, and no port's power
392 * was lost. (For PCI, that means Vaux was maintained.) But we
393 * could instead be restoring a swsusp snapshot -- so that BIOS was
394 * the last user of the controller, not reset/pm hardware keeping
395 * state we gave to it.
397 power_okay
= ehci_readl(ehci
, &ehci
->regs
->intr_enable
);
398 ehci_dbg(ehci
, "resume root hub%s\n",
399 power_okay
? "" : " after power loss");
401 /* at least some APM implementations will try to deliver
402 * IRQs right away, so delay them until we're ready.
404 ehci_writel(ehci
, 0, &ehci
->regs
->intr_enable
);
406 /* re-init operational registers */
407 ehci_writel(ehci
, 0, &ehci
->regs
->segment
);
408 ehci_writel(ehci
, ehci
->periodic_dma
, &ehci
->regs
->frame_list
);
409 ehci_writel(ehci
, (u32
) ehci
->async
->qh_dma
, &ehci
->regs
->async_next
);
411 /* restore CMD_RUN, framelist size, and irq threshold */
412 ehci
->command
|= CMD_RUN
;
413 ehci_writel(ehci
, ehci
->command
, &ehci
->regs
->command
);
414 ehci
->rh_state
= EHCI_RH_RUNNING
;
417 * According to Bugzilla #8190, the port status for some controllers
418 * will be wrong without a delay. At their wrong status, the port
419 * is enabled, but not suspended neither resumed.
421 i
= HCS_N_PORTS(ehci
->hcs_params
);
423 temp
= ehci_readl(ehci
, &ehci
->regs
->port_status
[i
]);
424 if ((temp
& PORT_PE
) &&
425 !(temp
& (PORT_SUSPEND
| PORT_RESUME
))) {
426 ehci_dbg(ehci
, "Port status(0x%x) is wrong\n", temp
);
427 spin_unlock_irq(&ehci
->lock
);
429 spin_lock_irq(&ehci
->lock
);
437 /* clear phy low-power mode before resume */
438 if (ehci
->bus_suspended
&& ehci
->has_hostpc
) {
439 i
= HCS_N_PORTS(ehci
->hcs_params
);
441 if (test_bit(i
, &ehci
->bus_suspended
)) {
442 u32 __iomem
*hostpc_reg
=
443 &ehci
->regs
->hostpc
[i
];
445 temp
= ehci_readl(ehci
, hostpc_reg
);
446 ehci_writel(ehci
, temp
& ~HOSTPC_PHCD
,
450 spin_unlock_irq(&ehci
->lock
);
452 spin_lock_irq(&ehci
->lock
);
457 /* manually resume the ports we suspended during bus_suspend() */
458 i
= HCS_N_PORTS (ehci
->hcs_params
);
460 temp
= ehci_readl(ehci
, &ehci
->regs
->port_status
[i
]);
461 temp
&= ~(PORT_RWC_BITS
| PORT_WAKE_BITS
);
462 if (test_bit(i
, &ehci
->bus_suspended
) &&
463 (temp
& PORT_SUSPEND
)) {
465 set_bit(i
, &resume_needed
);
467 ehci_writel(ehci
, temp
, &ehci
->regs
->port_status
[i
]);
470 /* msleep for 20ms only if code is trying to resume port */
472 spin_unlock_irq(&ehci
->lock
);
474 spin_lock_irq(&ehci
->lock
);
479 i
= HCS_N_PORTS (ehci
->hcs_params
);
481 temp
= ehci_readl(ehci
, &ehci
->regs
->port_status
[i
]);
482 if (test_bit(i
, &resume_needed
)) {
483 temp
&= ~(PORT_RWC_BITS
| PORT_SUSPEND
| PORT_RESUME
);
484 ehci_writel(ehci
, temp
, &ehci
->regs
->port_status
[i
]);
485 ehci_vdbg (ehci
, "resumed port %d\n", i
+ 1);
489 ehci
->next_statechange
= jiffies
+ msecs_to_jiffies(5);
490 spin_unlock_irq(&ehci
->lock
);
492 ehci_handover_companion_ports(ehci
);
494 /* Now we can safely re-enable irqs */
495 spin_lock_irq(&ehci
->lock
);
498 ehci_writel(ehci
, INTR_MASK
, &ehci
->regs
->intr_enable
);
499 (void) ehci_readl(ehci
, &ehci
->regs
->intr_enable
);
500 spin_unlock_irq(&ehci
->lock
);
505 spin_unlock_irq(&ehci
->lock
);
511 #define ehci_bus_suspend NULL
512 #define ehci_bus_resume NULL
514 #endif /* CONFIG_PM */
516 /*-------------------------------------------------------------------------*/
519 * Sets the owner of a port
521 static void set_owner(struct ehci_hcd
*ehci
, int portnum
, int new_owner
)
523 u32 __iomem
*status_reg
;
527 status_reg
= &ehci
->regs
->port_status
[portnum
];
530 * The controller won't set the OWNER bit if the port is
531 * enabled, so this loop will sometimes require at least two
532 * iterations: one to disable the port and one to set OWNER.
534 for (try = 4; try > 0; --try) {
535 spin_lock_irq(&ehci
->lock
);
536 port_status
= ehci_readl(ehci
, status_reg
);
537 if ((port_status
& PORT_OWNER
) == new_owner
538 || (port_status
& (PORT_OWNER
| PORT_CONNECT
))
542 port_status
^= PORT_OWNER
;
543 port_status
&= ~(PORT_PE
| PORT_RWC_BITS
);
544 ehci_writel(ehci
, port_status
, status_reg
);
546 spin_unlock_irq(&ehci
->lock
);
552 /*-------------------------------------------------------------------------*/
554 static int check_reset_complete (
555 struct ehci_hcd
*ehci
,
557 u32 __iomem
*status_reg
,
560 if (!(port_status
& PORT_CONNECT
))
563 /* if reset finished and it's still not enabled -- handoff */
564 if (!(port_status
& PORT_PE
)) {
566 /* with integrated TT, there's nobody to hand it to! */
567 if (ehci_is_TDI(ehci
)) {
569 "Failed to enable port %d on root hub TT\n",
574 ehci_dbg (ehci
, "port %d full speed --> companion\n",
577 // what happens if HCS_N_CC(params) == 0 ?
578 port_status
|= PORT_OWNER
;
579 port_status
&= ~PORT_RWC_BITS
;
580 ehci_writel(ehci
, port_status
, status_reg
);
582 /* ensure 440EPX ohci controller state is operational */
583 if (ehci
->has_amcc_usb23
)
584 set_ohci_hcfs(ehci
, 1);
586 ehci_dbg(ehci
, "port %d reset complete, port enabled\n",
588 /* ensure 440EPx ohci controller state is suspended */
589 if (ehci
->has_amcc_usb23
)
590 set_ohci_hcfs(ehci
, 0);
596 /*-------------------------------------------------------------------------*/
599 /* build "status change" packet (one or two bytes) from HC registers */
602 ehci_hub_status_data (struct usb_hcd
*hcd
, char *buf
)
604 struct ehci_hcd
*ehci
= hcd_to_ehci (hcd
);
607 int ports
, i
, retval
= 1;
611 /* init status to no-changes */
613 ports
= HCS_N_PORTS (ehci
->hcs_params
);
619 /* Inform the core about resumes-in-progress by returning
620 * a non-zero value even if there are no status changes.
622 status
= ehci
->resuming_ports
;
624 /* Some boards (mostly VIA?) report bogus overcurrent indications,
625 * causing massive log spam unless we completely ignore them. It
626 * may be relevant that VIA VT8235 controllers, where PORT_POWER is
627 * always set, seem to clear PORT_OCC and PORT_CSC when writing to
628 * PORT_POWER; that's surprising, but maybe within-spec.
631 mask
= PORT_CSC
| PORT_PEC
| PORT_OCC
;
633 mask
= PORT_CSC
| PORT_PEC
;
634 // PORT_RESUME from hardware ~= PORT_STAT_C_SUSPEND
636 /* no hub change reports (bit 0) for now (power, ...) */
638 /* port N changes (bit N)? */
639 spin_lock_irqsave (&ehci
->lock
, flags
);
641 /* get per-port change detect bits */
643 ppcd
= ehci_readl(ehci
, &ehci
->regs
->status
) >> 16;
645 for (i
= 0; i
< ports
; i
++) {
646 /* leverage per-port change bits feature */
648 temp
= ehci_readl(ehci
, &ehci
->regs
->port_status
[i
]);
653 * Return status information even for ports with OWNER set.
654 * Otherwise khubd wouldn't see the disconnect event when a
655 * high-speed device is switched over to the companion
656 * controller by the user.
659 if ((temp
& mask
) != 0 || test_bit(i
, &ehci
->port_c_suspend
)
660 || (ehci
->reset_done
[i
] && time_after_eq(
661 jiffies
, ehci
->reset_done
[i
]))) {
663 buf
[0] |= 1 << (i
+ 1);
665 buf
[1] |= 1 << (i
- 7);
670 /* If a resume is in progress, make sure it can finish */
671 if (ehci
->resuming_ports
)
672 mod_timer(&hcd
->rh_timer
, jiffies
+ msecs_to_jiffies(25));
674 spin_unlock_irqrestore (&ehci
->lock
, flags
);
675 return status
? retval
: 0;
678 /*-------------------------------------------------------------------------*/
681 ehci_hub_descriptor (
682 struct ehci_hcd
*ehci
,
683 struct usb_hub_descriptor
*desc
685 int ports
= HCS_N_PORTS (ehci
->hcs_params
);
688 desc
->bDescriptorType
= 0x29;
689 desc
->bPwrOn2PwrGood
= 10; /* ehci 1.0, 2.3.9 says 20ms max */
690 desc
->bHubContrCurrent
= 0;
692 desc
->bNbrPorts
= ports
;
693 temp
= 1 + (ports
/ 8);
694 desc
->bDescLength
= 7 + 2 * temp
;
696 /* two bitmaps: ports removable, and usb 1.0 legacy PortPwrCtrlMask */
697 memset(&desc
->u
.hs
.DeviceRemovable
[0], 0, temp
);
698 memset(&desc
->u
.hs
.DeviceRemovable
[temp
], 0xff, temp
);
700 temp
= 0x0008; /* per-port overcurrent reporting */
701 if (HCS_PPC (ehci
->hcs_params
))
702 temp
|= 0x0001; /* per-port power control */
704 temp
|= 0x0002; /* no power switching */
706 // re-enable when we support USB_PORT_FEAT_INDICATOR below.
707 if (HCS_INDICATOR (ehci
->hcs_params
))
708 temp
|= 0x0080; /* per-port indicators (LEDs) */
710 desc
->wHubCharacteristics
= cpu_to_le16(temp
);
713 /*-------------------------------------------------------------------------*/
715 static int ehci_hub_control (
723 struct ehci_hcd
*ehci
= hcd_to_ehci (hcd
);
724 int ports
= HCS_N_PORTS (ehci
->hcs_params
);
725 u32 __iomem
*status_reg
= &ehci
->regs
->port_status
[
726 (wIndex
& 0xff) - 1];
727 u32 __iomem
*hostpc_reg
= &ehci
->regs
->hostpc
[(wIndex
& 0xff) - 1];
728 u32 temp
, temp1
, status
;
734 * FIXME: support SetPortFeatures USB_PORT_FEAT_INDICATOR.
735 * HCS_INDICATOR may say we can change LEDs to off/amber/green.
736 * (track current state ourselves) ... blink for diagnostics,
737 * power, "this is the one", etc. EHCI spec supports this.
740 spin_lock_irqsave (&ehci
->lock
, flags
);
742 case ClearHubFeature
:
744 case C_HUB_LOCAL_POWER
:
745 case C_HUB_OVER_CURRENT
:
746 /* no hub-wide feature/status flags */
752 case ClearPortFeature
:
753 if (!wIndex
|| wIndex
> ports
)
756 temp
= ehci_readl(ehci
, status_reg
);
757 temp
&= ~PORT_RWC_BITS
;
760 * Even if OWNER is set, so the port is owned by the
761 * companion controller, khubd needs to be able to clear
762 * the port-change status bits (especially
763 * USB_PORT_STAT_C_CONNECTION).
767 case USB_PORT_FEAT_ENABLE
:
768 ehci_writel(ehci
, temp
& ~PORT_PE
, status_reg
);
770 case USB_PORT_FEAT_C_ENABLE
:
771 ehci_writel(ehci
, temp
| PORT_PEC
, status_reg
);
773 case USB_PORT_FEAT_SUSPEND
:
774 if (temp
& PORT_RESET
)
776 if (ehci
->no_selective_suspend
)
778 #ifdef CONFIG_USB_OTG
779 if ((hcd
->self
.otg_port
== (wIndex
+ 1))
780 && hcd
->self
.b_hnp_enable
) {
781 otg_start_hnp(hcd
->phy
->otg
);
785 if (!(temp
& PORT_SUSPEND
))
787 if ((temp
& PORT_PE
) == 0)
790 /* clear phy low-power mode before resume */
791 if (ehci
->has_hostpc
) {
792 temp1
= ehci_readl(ehci
, hostpc_reg
);
793 ehci_writel(ehci
, temp1
& ~HOSTPC_PHCD
,
795 spin_unlock_irqrestore(&ehci
->lock
, flags
);
796 msleep(5);/* wait to leave low-power mode */
797 spin_lock_irqsave(&ehci
->lock
, flags
);
799 /* resume signaling for 20 msec */
800 temp
&= ~PORT_WAKE_BITS
;
801 ehci_writel(ehci
, temp
| PORT_RESUME
, status_reg
);
802 ehci
->reset_done
[wIndex
] = jiffies
803 + msecs_to_jiffies(20);
805 case USB_PORT_FEAT_C_SUSPEND
:
806 clear_bit(wIndex
, &ehci
->port_c_suspend
);
808 case USB_PORT_FEAT_POWER
:
809 if (HCS_PPC (ehci
->hcs_params
))
810 ehci_writel(ehci
, temp
& ~PORT_POWER
,
813 case USB_PORT_FEAT_C_CONNECTION
:
814 ehci_writel(ehci
, temp
| PORT_CSC
, status_reg
);
816 case USB_PORT_FEAT_C_OVER_CURRENT
:
817 ehci_writel(ehci
, temp
| PORT_OCC
, status_reg
);
819 case USB_PORT_FEAT_C_RESET
:
820 /* GetPortStatus clears reset */
825 ehci_readl(ehci
, &ehci
->regs
->command
); /* unblock posted write */
827 case GetHubDescriptor
:
828 ehci_hub_descriptor (ehci
, (struct usb_hub_descriptor
*)
832 /* no hub-wide feature/status flags */
834 //cpu_to_le32s ((u32 *) buf);
837 if (!wIndex
|| wIndex
> ports
)
841 temp
= ehci_readl(ehci
, status_reg
);
845 status
|= USB_PORT_STAT_C_CONNECTION
<< 16;
847 status
|= USB_PORT_STAT_C_ENABLE
<< 16;
849 if ((temp
& PORT_OCC
) && !ignore_oc
){
850 status
|= USB_PORT_STAT_C_OVERCURRENT
<< 16;
853 * Hubs should disable port power on over-current.
854 * However, not all EHCI implementations do this
855 * automatically, even if they _do_ support per-port
856 * power switching; they're allowed to just limit the
857 * current. khubd will turn the power back on.
859 if (((temp
& PORT_OC
) || (ehci
->need_oc_pp_cycle
))
860 && HCS_PPC(ehci
->hcs_params
)) {
862 temp
& ~(PORT_RWC_BITS
| PORT_POWER
),
864 temp
= ehci_readl(ehci
, status_reg
);
868 /* whoever resumes must GetPortStatus to complete it!! */
869 if (temp
& PORT_RESUME
) {
871 /* Remote Wakeup received? */
872 if (!ehci
->reset_done
[wIndex
]) {
873 /* resume signaling for 20 msec */
874 ehci
->reset_done
[wIndex
] = jiffies
875 + msecs_to_jiffies(20);
876 usb_hcd_start_port_resume(&hcd
->self
, wIndex
);
877 /* check the port again */
878 mod_timer(&ehci_to_hcd(ehci
)->rh_timer
,
879 ehci
->reset_done
[wIndex
]);
882 /* resume completed? */
883 else if (time_after_eq(jiffies
,
884 ehci
->reset_done
[wIndex
])) {
885 clear_bit(wIndex
, &ehci
->suspended_ports
);
886 set_bit(wIndex
, &ehci
->port_c_suspend
);
887 ehci
->reset_done
[wIndex
] = 0;
888 usb_hcd_end_port_resume(&hcd
->self
, wIndex
);
890 /* stop resume signaling */
891 temp
&= ~(PORT_RWC_BITS
|
892 PORT_SUSPEND
| PORT_RESUME
);
893 ehci_writel(ehci
, temp
, status_reg
);
894 clear_bit(wIndex
, &ehci
->resuming_ports
);
895 retval
= ehci_handshake(ehci
, status_reg
,
896 PORT_RESUME
, 0, 2000 /* 2msec */);
899 "port %d resume error %d\n",
903 temp
= ehci_readl(ehci
, status_reg
);
907 /* whoever resets must GetPortStatus to complete it!! */
908 if ((temp
& PORT_RESET
)
909 && time_after_eq(jiffies
,
910 ehci
->reset_done
[wIndex
])) {
911 status
|= USB_PORT_STAT_C_RESET
<< 16;
912 ehci
->reset_done
[wIndex
] = 0;
913 clear_bit(wIndex
, &ehci
->resuming_ports
);
915 /* force reset to complete */
916 ehci_writel(ehci
, temp
& ~(PORT_RWC_BITS
| PORT_RESET
),
918 /* REVISIT: some hardware needs 550+ usec to clear
919 * this bit; seems too long to spin routinely...
921 retval
= ehci_handshake(ehci
, status_reg
,
922 PORT_RESET
, 0, 1000);
924 ehci_err (ehci
, "port %d reset error %d\n",
929 /* see what we found out */
930 temp
= check_reset_complete (ehci
, wIndex
, status_reg
,
931 ehci_readl(ehci
, status_reg
));
934 if (!(temp
& (PORT_RESUME
|PORT_RESET
))) {
935 ehci
->reset_done
[wIndex
] = 0;
936 clear_bit(wIndex
, &ehci
->resuming_ports
);
939 /* transfer dedicated ports to the companion hc */
940 if ((temp
& PORT_CONNECT
) &&
941 test_bit(wIndex
, &ehci
->companion_ports
)) {
942 temp
&= ~PORT_RWC_BITS
;
944 ehci_writel(ehci
, temp
, status_reg
);
945 ehci_dbg(ehci
, "port %d --> companion\n", wIndex
+ 1);
946 temp
= ehci_readl(ehci
, status_reg
);
950 * Even if OWNER is set, there's no harm letting khubd
951 * see the wPortStatus values (they should all be 0 except
952 * for PORT_POWER anyway).
955 if (temp
& PORT_CONNECT
) {
956 status
|= USB_PORT_STAT_CONNECTION
;
957 // status may be from integrated TT
958 if (ehci
->has_hostpc
) {
959 temp1
= ehci_readl(ehci
, hostpc_reg
);
960 status
|= ehci_port_speed(ehci
, temp1
);
962 status
|= ehci_port_speed(ehci
, temp
);
965 status
|= USB_PORT_STAT_ENABLE
;
967 /* maybe the port was unsuspended without our knowledge */
968 if (temp
& (PORT_SUSPEND
|PORT_RESUME
)) {
969 status
|= USB_PORT_STAT_SUSPEND
;
970 } else if (test_bit(wIndex
, &ehci
->suspended_ports
)) {
971 clear_bit(wIndex
, &ehci
->suspended_ports
);
972 clear_bit(wIndex
, &ehci
->resuming_ports
);
973 ehci
->reset_done
[wIndex
] = 0;
975 set_bit(wIndex
, &ehci
->port_c_suspend
);
976 usb_hcd_end_port_resume(&hcd
->self
, wIndex
);
980 status
|= USB_PORT_STAT_OVERCURRENT
;
981 if (temp
& PORT_RESET
)
982 status
|= USB_PORT_STAT_RESET
;
983 if (temp
& PORT_POWER
)
984 status
|= USB_PORT_STAT_POWER
;
985 if (test_bit(wIndex
, &ehci
->port_c_suspend
))
986 status
|= USB_PORT_STAT_C_SUSPEND
<< 16;
988 #ifndef VERBOSE_DEBUG
989 if (status
& ~0xffff) /* only if wPortChange is interesting */
991 dbg_port (ehci
, "GetStatus", wIndex
+ 1, temp
);
992 put_unaligned_le32(status
, buf
);
996 case C_HUB_LOCAL_POWER
:
997 case C_HUB_OVER_CURRENT
:
998 /* no hub-wide feature/status flags */
1004 case SetPortFeature
:
1005 selector
= wIndex
>> 8;
1007 if (unlikely(ehci
->debug
)) {
1008 /* If the debug port is active any port
1009 * feature requests should get denied */
1010 if (wIndex
== HCS_DEBUG_PORT(ehci
->hcs_params
) &&
1011 (readl(&ehci
->debug
->control
) & DBGP_ENABLED
)) {
1016 if (!wIndex
|| wIndex
> ports
)
1019 temp
= ehci_readl(ehci
, status_reg
);
1020 if (temp
& PORT_OWNER
)
1023 temp
&= ~PORT_RWC_BITS
;
1025 case USB_PORT_FEAT_SUSPEND
:
1026 if (ehci
->no_selective_suspend
)
1028 if ((temp
& PORT_PE
) == 0
1029 || (temp
& PORT_RESET
) != 0)
1032 /* After above check the port must be connected.
1033 * Set appropriate bit thus could put phy into low power
1034 * mode if we have hostpc feature
1036 temp
&= ~PORT_WKCONN_E
;
1037 temp
|= PORT_WKDISC_E
| PORT_WKOC_E
;
1038 ehci_writel(ehci
, temp
| PORT_SUSPEND
, status_reg
);
1039 if (ehci
->has_hostpc
) {
1040 spin_unlock_irqrestore(&ehci
->lock
, flags
);
1041 msleep(5);/* 5ms for HCD enter low pwr mode */
1042 spin_lock_irqsave(&ehci
->lock
, flags
);
1043 temp1
= ehci_readl(ehci
, hostpc_reg
);
1044 ehci_writel(ehci
, temp1
| HOSTPC_PHCD
,
1046 temp1
= ehci_readl(ehci
, hostpc_reg
);
1047 ehci_dbg(ehci
, "Port%d phy low pwr mode %s\n",
1048 wIndex
, (temp1
& HOSTPC_PHCD
) ?
1049 "succeeded" : "failed");
1051 set_bit(wIndex
, &ehci
->suspended_ports
);
1053 case USB_PORT_FEAT_POWER
:
1054 if (HCS_PPC (ehci
->hcs_params
))
1055 ehci_writel(ehci
, temp
| PORT_POWER
,
1058 case USB_PORT_FEAT_RESET
:
1059 if (temp
& PORT_RESUME
)
1061 /* line status bits may report this as low speed,
1062 * which can be fine if this root hub has a
1063 * transaction translator built in.
1065 if ((temp
& (PORT_PE
|PORT_CONNECT
)) == PORT_CONNECT
1066 && !ehci_is_TDI(ehci
)
1067 && PORT_USB11 (temp
)) {
1069 "port %d low speed --> companion\n",
1073 ehci_vdbg (ehci
, "port %d reset\n", wIndex
+ 1);
1078 * caller must wait, then call GetPortStatus
1079 * usb 2.0 spec says 50 ms resets on root
1081 ehci
->reset_done
[wIndex
] = jiffies
1082 + msecs_to_jiffies (50);
1084 ehci_writel(ehci
, temp
, status_reg
);
1087 /* For downstream facing ports (these): one hub port is put
1088 * into test mode according to USB2 11.24.2.13, then the hub
1089 * must be reset (which for root hub now means rmmod+modprobe,
1090 * or else system reboot). See EHCI 2.3.9 and 4.14 for info
1091 * about the EHCI-specific stuff.
1093 case USB_PORT_FEAT_TEST
:
1094 if (!selector
|| selector
> 5)
1096 spin_unlock_irqrestore(&ehci
->lock
, flags
);
1098 spin_lock_irqsave(&ehci
->lock
, flags
);
1100 /* Put all enabled ports into suspend */
1103 &ehci
->regs
->port_status
[ports
];
1105 temp
= ehci_readl(ehci
, sreg
) & ~PORT_RWC_BITS
;
1107 ehci_writel(ehci
, temp
| PORT_SUSPEND
,
1111 spin_unlock_irqrestore(&ehci
->lock
, flags
);
1113 spin_lock_irqsave(&ehci
->lock
, flags
);
1115 temp
= ehci_readl(ehci
, status_reg
);
1116 temp
|= selector
<< 16;
1117 ehci_writel(ehci
, temp
, status_reg
);
1123 ehci_readl(ehci
, &ehci
->regs
->command
); /* unblock posted writes */
1128 /* "stall" on error */
1132 spin_unlock_irqrestore (&ehci
->lock
, flags
);
1136 static void ehci_relinquish_port(struct usb_hcd
*hcd
, int portnum
)
1138 struct ehci_hcd
*ehci
= hcd_to_ehci(hcd
);
1140 if (ehci_is_TDI(ehci
))
1142 set_owner(ehci
, --portnum
, PORT_OWNER
);
1145 static int ehci_port_handed_over(struct usb_hcd
*hcd
, int portnum
)
1147 struct ehci_hcd
*ehci
= hcd_to_ehci(hcd
);
1150 if (ehci_is_TDI(ehci
))
1152 reg
= &ehci
->regs
->port_status
[portnum
- 1];
1153 return ehci_readl(ehci
, reg
) & PORT_OWNER
;