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 /*-------------------------------------------------------------------------*/
31 #ifdef CONFIG_USB_PERSIST
33 static int ehci_hub_control(
42 /* After a power loss, ports that were owned by the companion must be
43 * reset so that the companion can still own them.
45 static void ehci_handover_companion_ports(struct ehci_hcd
*ehci
)
51 struct usb_hcd
*hcd
= ehci_to_hcd(ehci
);
53 if (!ehci
->owned_ports
)
56 /* Give the connections some time to appear */
59 port
= HCS_N_PORTS(ehci
->hcs_params
);
61 if (test_bit(port
, &ehci
->owned_ports
)) {
62 reg
= &ehci
->regs
->port_status
[port
];
63 status
= ehci_readl(ehci
, reg
) & ~PORT_RWC_BITS
;
65 /* Port already owned by companion? */
66 if (status
& PORT_OWNER
)
67 clear_bit(port
, &ehci
->owned_ports
);
68 else if (test_bit(port
, &ehci
->companion_ports
))
69 ehci_writel(ehci
, status
& ~PORT_PE
, reg
);
71 ehci_hub_control(hcd
, SetPortFeature
,
72 USB_PORT_FEAT_RESET
, port
+ 1,
77 if (!ehci
->owned_ports
)
79 msleep(90); /* Wait for resets to complete */
81 port
= HCS_N_PORTS(ehci
->hcs_params
);
83 if (test_bit(port
, &ehci
->owned_ports
)) {
84 ehci_hub_control(hcd
, GetPortStatus
,
86 (char *) &buf
, sizeof(buf
));
88 /* The companion should now own the port,
89 * but if something went wrong the port must not
92 reg
= &ehci
->regs
->port_status
[port
];
93 status
= ehci_readl(ehci
, reg
) & ~PORT_RWC_BITS
;
94 if (status
& PORT_OWNER
)
95 ehci_writel(ehci
, status
| PORT_CSC
, reg
);
97 ehci_dbg(ehci
, "failed handover port %d: %x\n",
99 ehci_writel(ehci
, status
& ~PORT_PE
, reg
);
104 ehci
->owned_ports
= 0;
107 #else /* CONFIG_USB_PERSIST */
109 static inline void ehci_handover_companion_ports(struct ehci_hcd
*ehci
)
116 static int ehci_bus_suspend (struct usb_hcd
*hcd
)
118 struct ehci_hcd
*ehci
= hcd_to_ehci (hcd
);
122 ehci_dbg(ehci
, "suspend root hub\n");
124 if (time_before (jiffies
, ehci
->next_statechange
))
126 del_timer_sync(&ehci
->watchdog
);
127 del_timer_sync(&ehci
->iaa_watchdog
);
129 port
= HCS_N_PORTS (ehci
->hcs_params
);
130 spin_lock_irq (&ehci
->lock
);
132 /* stop schedules, clean any completed work */
133 if (HC_IS_RUNNING(hcd
->state
)) {
135 hcd
->state
= HC_STATE_QUIESCING
;
137 ehci
->command
= ehci_readl(ehci
, &ehci
->regs
->command
);
140 /* Unlike other USB host controller types, EHCI doesn't have
141 * any notion of "global" or bus-wide suspend. The driver has
142 * to manually suspend all the active unsuspended ports, and
143 * then manually resume them in the bus_resume() routine.
145 ehci
->bus_suspended
= 0;
146 ehci
->owned_ports
= 0;
148 u32 __iomem
*reg
= &ehci
->regs
->port_status
[port
];
149 u32 t1
= ehci_readl(ehci
, reg
) & ~PORT_RWC_BITS
;
152 /* keep track of which ports we suspend */
154 set_bit(port
, &ehci
->owned_ports
);
155 else if ((t1
& PORT_PE
) && !(t1
& PORT_SUSPEND
)) {
157 set_bit(port
, &ehci
->bus_suspended
);
160 /* enable remote wakeup on all ports */
161 if (device_may_wakeup(&hcd
->self
.root_hub
->dev
))
162 t2
|= PORT_WKOC_E
|PORT_WKDISC_E
|PORT_WKCONN_E
;
164 t2
&= ~(PORT_WKOC_E
|PORT_WKDISC_E
|PORT_WKCONN_E
);
167 ehci_vdbg (ehci
, "port %d, %08x -> %08x\n",
169 ehci_writel(ehci
, t2
, reg
);
173 /* Apparently some devices need a >= 1-uframe delay here */
174 if (ehci
->bus_suspended
)
177 /* turn off now-idle HC */
179 hcd
->state
= HC_STATE_SUSPENDED
;
182 end_unlink_async(ehci
);
184 /* allow remote wakeup */
186 if (!device_may_wakeup(&hcd
->self
.root_hub
->dev
))
188 ehci_writel(ehci
, mask
, &ehci
->regs
->intr_enable
);
189 ehci_readl(ehci
, &ehci
->regs
->intr_enable
);
191 ehci
->next_statechange
= jiffies
+ msecs_to_jiffies(10);
192 spin_unlock_irq (&ehci
->lock
);
197 /* caller has locked the root hub, and should reset/reinit on error */
198 static int ehci_bus_resume (struct usb_hcd
*hcd
)
200 struct ehci_hcd
*ehci
= hcd_to_ehci (hcd
);
205 if (time_before (jiffies
, ehci
->next_statechange
))
207 spin_lock_irq (&ehci
->lock
);
208 if (!test_bit(HCD_FLAG_HW_ACCESSIBLE
, &hcd
->flags
)) {
209 spin_unlock_irq(&ehci
->lock
);
213 /* Ideally and we've got a real resume here, and no port's power
214 * was lost. (For PCI, that means Vaux was maintained.) But we
215 * could instead be restoring a swsusp snapshot -- so that BIOS was
216 * the last user of the controller, not reset/pm hardware keeping
217 * state we gave to it.
219 power_okay
= ehci_readl(ehci
, &ehci
->regs
->intr_enable
);
220 ehci_dbg(ehci
, "resume root hub%s\n",
221 power_okay
? "" : " after power loss");
223 /* at least some APM implementations will try to deliver
224 * IRQs right away, so delay them until we're ready.
226 ehci_writel(ehci
, 0, &ehci
->regs
->intr_enable
);
228 /* re-init operational registers */
229 ehci_writel(ehci
, 0, &ehci
->regs
->segment
);
230 ehci_writel(ehci
, ehci
->periodic_dma
, &ehci
->regs
->frame_list
);
231 ehci_writel(ehci
, (u32
) ehci
->async
->qh_dma
, &ehci
->regs
->async_next
);
233 /* restore CMD_RUN, framelist size, and irq threshold */
234 ehci_writel(ehci
, ehci
->command
, &ehci
->regs
->command
);
236 /* Some controller/firmware combinations need a delay during which
237 * they set up the port statuses. See Bugzilla #8190. */
240 /* manually resume the ports we suspended during bus_suspend() */
241 i
= HCS_N_PORTS (ehci
->hcs_params
);
243 temp
= ehci_readl(ehci
, &ehci
->regs
->port_status
[i
]);
244 temp
&= ~(PORT_RWC_BITS
245 | PORT_WKOC_E
| PORT_WKDISC_E
| PORT_WKCONN_E
);
246 if (test_bit(i
, &ehci
->bus_suspended
) &&
247 (temp
& PORT_SUSPEND
)) {
248 ehci
->reset_done
[i
] = jiffies
+ msecs_to_jiffies (20);
251 ehci_writel(ehci
, temp
, &ehci
->regs
->port_status
[i
]);
253 i
= HCS_N_PORTS (ehci
->hcs_params
);
256 temp
= ehci_readl(ehci
, &ehci
->regs
->port_status
[i
]);
257 if (test_bit(i
, &ehci
->bus_suspended
) &&
258 (temp
& PORT_SUSPEND
)) {
259 temp
&= ~(PORT_RWC_BITS
| PORT_RESUME
);
260 ehci_writel(ehci
, temp
, &ehci
->regs
->port_status
[i
]);
261 ehci_vdbg (ehci
, "resumed port %d\n", i
+ 1);
264 (void) ehci_readl(ehci
, &ehci
->regs
->command
);
266 /* maybe re-activate the schedule(s) */
268 if (ehci
->async
->qh_next
.qh
)
270 if (ehci
->periodic_sched
)
273 ehci
->command
|= temp
;
274 ehci_writel(ehci
, ehci
->command
, &ehci
->regs
->command
);
277 ehci
->next_statechange
= jiffies
+ msecs_to_jiffies(5);
278 hcd
->state
= HC_STATE_RUNNING
;
280 /* Now we can safely re-enable irqs */
281 ehci_writel(ehci
, INTR_MASK
, &ehci
->regs
->intr_enable
);
283 spin_unlock_irq (&ehci
->lock
);
286 ehci_handover_companion_ports(ehci
);
292 #define ehci_bus_suspend NULL
293 #define ehci_bus_resume NULL
295 #endif /* CONFIG_PM */
297 /*-------------------------------------------------------------------------*/
299 /* Display the ports dedicated to the companion controller */
300 static ssize_t
show_companion(struct device
*dev
,
301 struct device_attribute
*attr
,
304 struct ehci_hcd
*ehci
;
305 int nports
, index
, n
;
306 int count
= PAGE_SIZE
;
309 ehci
= hcd_to_ehci(bus_to_hcd(dev_get_drvdata(dev
)));
310 nports
= HCS_N_PORTS(ehci
->hcs_params
);
312 for (index
= 0; index
< nports
; ++index
) {
313 if (test_bit(index
, &ehci
->companion_ports
)) {
314 n
= scnprintf(ptr
, count
, "%d\n", index
+ 1);
323 * Sets the owner of a port
325 static void set_owner(struct ehci_hcd
*ehci
, int portnum
, int new_owner
)
327 u32 __iomem
*status_reg
;
331 status_reg
= &ehci
->regs
->port_status
[portnum
];
334 * The controller won't set the OWNER bit if the port is
335 * enabled, so this loop will sometimes require at least two
336 * iterations: one to disable the port and one to set OWNER.
338 for (try = 4; try > 0; --try) {
339 spin_lock_irq(&ehci
->lock
);
340 port_status
= ehci_readl(ehci
, status_reg
);
341 if ((port_status
& PORT_OWNER
) == new_owner
342 || (port_status
& (PORT_OWNER
| PORT_CONNECT
))
346 port_status
^= PORT_OWNER
;
347 port_status
&= ~(PORT_PE
| PORT_RWC_BITS
);
348 ehci_writel(ehci
, port_status
, status_reg
);
350 spin_unlock_irq(&ehci
->lock
);
357 * Dedicate or undedicate a port to the companion controller.
358 * Syntax is "[-]portnum", where a leading '-' sign means
359 * return control of the port to the EHCI controller.
361 static ssize_t
store_companion(struct device
*dev
,
362 struct device_attribute
*attr
,
363 const char *buf
, size_t count
)
365 struct ehci_hcd
*ehci
;
366 int portnum
, new_owner
;
368 ehci
= hcd_to_ehci(bus_to_hcd(dev_get_drvdata(dev
)));
369 new_owner
= PORT_OWNER
; /* Owned by companion */
370 if (sscanf(buf
, "%d", &portnum
) != 1)
374 new_owner
= 0; /* Owned by EHCI */
376 if (portnum
<= 0 || portnum
> HCS_N_PORTS(ehci
->hcs_params
))
380 set_bit(portnum
, &ehci
->companion_ports
);
382 clear_bit(portnum
, &ehci
->companion_ports
);
383 set_owner(ehci
, portnum
, new_owner
);
386 static DEVICE_ATTR(companion
, 0644, show_companion
, store_companion
);
388 static inline void create_companion_file(struct ehci_hcd
*ehci
)
392 /* with integrated TT there is no companion! */
393 if (!ehci_is_TDI(ehci
))
394 i
= device_create_file(ehci_to_hcd(ehci
)->self
.dev
,
395 &dev_attr_companion
);
398 static inline void remove_companion_file(struct ehci_hcd
*ehci
)
400 /* with integrated TT there is no companion! */
401 if (!ehci_is_TDI(ehci
))
402 device_remove_file(ehci_to_hcd(ehci
)->self
.dev
,
403 &dev_attr_companion
);
407 /*-------------------------------------------------------------------------*/
409 static int check_reset_complete (
410 struct ehci_hcd
*ehci
,
412 u32 __iomem
*status_reg
,
415 if (!(port_status
& PORT_CONNECT
))
418 /* if reset finished and it's still not enabled -- handoff */
419 if (!(port_status
& PORT_PE
)) {
421 /* with integrated TT, there's nobody to hand it to! */
422 if (ehci_is_TDI(ehci
)) {
424 "Failed to enable port %d on root hub TT\n",
429 ehci_dbg (ehci
, "port %d full speed --> companion\n",
432 // what happens if HCS_N_CC(params) == 0 ?
433 port_status
|= PORT_OWNER
;
434 port_status
&= ~PORT_RWC_BITS
;
435 ehci_writel(ehci
, port_status
, status_reg
);
438 ehci_dbg (ehci
, "port %d high speed\n", index
+ 1);
443 /*-------------------------------------------------------------------------*/
446 /* build "status change" packet (one or two bytes) from HC registers */
449 ehci_hub_status_data (struct usb_hcd
*hcd
, char *buf
)
451 struct ehci_hcd
*ehci
= hcd_to_ehci (hcd
);
452 u32 temp
, status
= 0;
454 int ports
, i
, retval
= 1;
457 /* if !USB_SUSPEND, root hub timers won't get shut down ... */
458 if (!HC_IS_RUNNING(hcd
->state
))
461 /* init status to no-changes */
463 ports
= HCS_N_PORTS (ehci
->hcs_params
);
469 /* Some boards (mostly VIA?) report bogus overcurrent indications,
470 * causing massive log spam unless we completely ignore them. It
471 * may be relevant that VIA VT8235 controllers, where PORT_POWER is
472 * always set, seem to clear PORT_OCC and PORT_CSC when writing to
473 * PORT_POWER; that's surprising, but maybe within-spec.
476 mask
= PORT_CSC
| PORT_PEC
| PORT_OCC
;
478 mask
= PORT_CSC
| PORT_PEC
;
479 // PORT_RESUME from hardware ~= PORT_STAT_C_SUSPEND
481 /* no hub change reports (bit 0) for now (power, ...) */
483 /* port N changes (bit N)? */
484 spin_lock_irqsave (&ehci
->lock
, flags
);
485 for (i
= 0; i
< ports
; i
++) {
486 temp
= ehci_readl(ehci
, &ehci
->regs
->port_status
[i
]);
489 * Return status information even for ports with OWNER set.
490 * Otherwise khubd wouldn't see the disconnect event when a
491 * high-speed device is switched over to the companion
492 * controller by the user.
495 if ((temp
& mask
) != 0
496 || ((temp
& PORT_RESUME
) != 0
497 && time_after_eq(jiffies
,
498 ehci
->reset_done
[i
]))) {
500 buf
[0] |= 1 << (i
+ 1);
502 buf
[1] |= 1 << (i
- 7);
506 /* FIXME autosuspend idle root hubs */
507 spin_unlock_irqrestore (&ehci
->lock
, flags
);
508 return status
? retval
: 0;
511 /*-------------------------------------------------------------------------*/
514 ehci_hub_descriptor (
515 struct ehci_hcd
*ehci
,
516 struct usb_hub_descriptor
*desc
518 int ports
= HCS_N_PORTS (ehci
->hcs_params
);
521 desc
->bDescriptorType
= 0x29;
522 desc
->bPwrOn2PwrGood
= 10; /* ehci 1.0, 2.3.9 says 20ms max */
523 desc
->bHubContrCurrent
= 0;
525 desc
->bNbrPorts
= ports
;
526 temp
= 1 + (ports
/ 8);
527 desc
->bDescLength
= 7 + 2 * temp
;
529 /* two bitmaps: ports removable, and usb 1.0 legacy PortPwrCtrlMask */
530 memset (&desc
->bitmap
[0], 0, temp
);
531 memset (&desc
->bitmap
[temp
], 0xff, temp
);
533 temp
= 0x0008; /* per-port overcurrent reporting */
534 if (HCS_PPC (ehci
->hcs_params
))
535 temp
|= 0x0001; /* per-port power control */
537 temp
|= 0x0002; /* no power switching */
539 // re-enable when we support USB_PORT_FEAT_INDICATOR below.
540 if (HCS_INDICATOR (ehci
->hcs_params
))
541 temp
|= 0x0080; /* per-port indicators (LEDs) */
543 desc
->wHubCharacteristics
= (__force __u16
)cpu_to_le16 (temp
);
546 /*-------------------------------------------------------------------------*/
548 #define PORT_WAKE_BITS (PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E)
550 static int ehci_hub_control (
558 struct ehci_hcd
*ehci
= hcd_to_ehci (hcd
);
559 int ports
= HCS_N_PORTS (ehci
->hcs_params
);
560 u32 __iomem
*status_reg
= &ehci
->regs
->port_status
[
561 (wIndex
& 0xff) - 1];
568 * FIXME: support SetPortFeatures USB_PORT_FEAT_INDICATOR.
569 * HCS_INDICATOR may say we can change LEDs to off/amber/green.
570 * (track current state ourselves) ... blink for diagnostics,
571 * power, "this is the one", etc. EHCI spec supports this.
574 spin_lock_irqsave (&ehci
->lock
, flags
);
576 case ClearHubFeature
:
578 case C_HUB_LOCAL_POWER
:
579 case C_HUB_OVER_CURRENT
:
580 /* no hub-wide feature/status flags */
586 case ClearPortFeature
:
587 if (!wIndex
|| wIndex
> ports
)
590 temp
= ehci_readl(ehci
, status_reg
);
593 * Even if OWNER is set, so the port is owned by the
594 * companion controller, khubd needs to be able to clear
595 * the port-change status bits (especially
596 * USB_PORT_FEAT_C_CONNECTION).
600 case USB_PORT_FEAT_ENABLE
:
601 ehci_writel(ehci
, temp
& ~PORT_PE
, status_reg
);
603 case USB_PORT_FEAT_C_ENABLE
:
604 ehci_writel(ehci
, (temp
& ~PORT_RWC_BITS
) | PORT_PEC
,
607 case USB_PORT_FEAT_SUSPEND
:
608 if (temp
& PORT_RESET
)
610 if (ehci
->no_selective_suspend
)
612 if (temp
& PORT_SUSPEND
) {
613 if ((temp
& PORT_PE
) == 0)
615 /* resume signaling for 20 msec */
616 temp
&= ~(PORT_RWC_BITS
| PORT_WAKE_BITS
);
617 ehci_writel(ehci
, temp
| PORT_RESUME
,
619 ehci
->reset_done
[wIndex
] = jiffies
620 + msecs_to_jiffies (20);
623 case USB_PORT_FEAT_C_SUSPEND
:
624 /* we auto-clear this feature */
626 case USB_PORT_FEAT_POWER
:
627 if (HCS_PPC (ehci
->hcs_params
))
629 temp
& ~(PORT_RWC_BITS
| PORT_POWER
),
632 case USB_PORT_FEAT_C_CONNECTION
:
633 ehci_writel(ehci
, (temp
& ~PORT_RWC_BITS
) | PORT_CSC
,
636 case USB_PORT_FEAT_C_OVER_CURRENT
:
637 ehci_writel(ehci
, (temp
& ~PORT_RWC_BITS
) | PORT_OCC
,
640 case USB_PORT_FEAT_C_RESET
:
641 /* GetPortStatus clears reset */
646 ehci_readl(ehci
, &ehci
->regs
->command
); /* unblock posted write */
648 case GetHubDescriptor
:
649 ehci_hub_descriptor (ehci
, (struct usb_hub_descriptor
*)
653 /* no hub-wide feature/status flags */
655 //cpu_to_le32s ((u32 *) buf);
658 if (!wIndex
|| wIndex
> ports
)
662 temp
= ehci_readl(ehci
, status_reg
);
666 status
|= 1 << USB_PORT_FEAT_C_CONNECTION
;
668 status
|= 1 << USB_PORT_FEAT_C_ENABLE
;
670 if ((temp
& PORT_OCC
) && !ignore_oc
){
671 status
|= 1 << USB_PORT_FEAT_C_OVER_CURRENT
;
674 * Hubs should disable port power on over-current.
675 * However, not all EHCI implementations do this
676 * automatically, even if they _do_ support per-port
677 * power switching; they're allowed to just limit the
678 * current. khubd will turn the power back on.
680 if (HCS_PPC (ehci
->hcs_params
)){
682 temp
& ~(PORT_RWC_BITS
| PORT_POWER
),
687 /* whoever resumes must GetPortStatus to complete it!! */
688 if (temp
& PORT_RESUME
) {
690 /* Remote Wakeup received? */
691 if (!ehci
->reset_done
[wIndex
]) {
692 /* resume signaling for 20 msec */
693 ehci
->reset_done
[wIndex
] = jiffies
694 + msecs_to_jiffies(20);
695 /* check the port again */
696 mod_timer(&ehci_to_hcd(ehci
)->rh_timer
,
697 ehci
->reset_done
[wIndex
]);
700 /* resume completed? */
701 else if (time_after_eq(jiffies
,
702 ehci
->reset_done
[wIndex
])) {
703 status
|= 1 << USB_PORT_FEAT_C_SUSPEND
;
704 ehci
->reset_done
[wIndex
] = 0;
706 /* stop resume signaling */
707 temp
= ehci_readl(ehci
, status_reg
);
709 temp
& ~(PORT_RWC_BITS
| PORT_RESUME
),
711 retval
= handshake(ehci
, status_reg
,
712 PORT_RESUME
, 0, 2000 /* 2msec */);
715 "port %d resume error %d\n",
719 temp
&= ~(PORT_SUSPEND
|PORT_RESUME
|(3<<10));
723 /* whoever resets must GetPortStatus to complete it!! */
724 if ((temp
& PORT_RESET
)
725 && time_after_eq(jiffies
,
726 ehci
->reset_done
[wIndex
])) {
727 status
|= 1 << USB_PORT_FEAT_C_RESET
;
728 ehci
->reset_done
[wIndex
] = 0;
730 /* force reset to complete */
731 ehci_writel(ehci
, temp
& ~(PORT_RWC_BITS
| PORT_RESET
),
733 /* REVISIT: some hardware needs 550+ usec to clear
734 * this bit; seems too long to spin routinely...
736 retval
= handshake(ehci
, status_reg
,
739 ehci_err (ehci
, "port %d reset error %d\n",
744 /* see what we found out */
745 temp
= check_reset_complete (ehci
, wIndex
, status_reg
,
746 ehci_readl(ehci
, status_reg
));
749 /* transfer dedicated ports to the companion hc */
750 if ((temp
& PORT_CONNECT
) &&
751 test_bit(wIndex
, &ehci
->companion_ports
)) {
752 temp
&= ~PORT_RWC_BITS
;
754 ehci_writel(ehci
, temp
, status_reg
);
755 ehci_dbg(ehci
, "port %d --> companion\n", wIndex
+ 1);
756 temp
= ehci_readl(ehci
, status_reg
);
760 * Even if OWNER is set, there's no harm letting khubd
761 * see the wPortStatus values (they should all be 0 except
762 * for PORT_POWER anyway).
765 if (temp
& PORT_CONNECT
) {
766 status
|= 1 << USB_PORT_FEAT_CONNECTION
;
767 // status may be from integrated TT
768 status
|= ehci_port_speed(ehci
, temp
);
771 status
|= 1 << USB_PORT_FEAT_ENABLE
;
772 if (temp
& (PORT_SUSPEND
|PORT_RESUME
))
773 status
|= 1 << USB_PORT_FEAT_SUSPEND
;
775 status
|= 1 << USB_PORT_FEAT_OVER_CURRENT
;
776 if (temp
& PORT_RESET
)
777 status
|= 1 << USB_PORT_FEAT_RESET
;
778 if (temp
& PORT_POWER
)
779 status
|= 1 << USB_PORT_FEAT_POWER
;
781 #ifndef EHCI_VERBOSE_DEBUG
782 if (status
& ~0xffff) /* only if wPortChange is interesting */
784 dbg_port (ehci
, "GetStatus", wIndex
+ 1, temp
);
785 put_unaligned(cpu_to_le32 (status
), (__le32
*) buf
);
789 case C_HUB_LOCAL_POWER
:
790 case C_HUB_OVER_CURRENT
:
791 /* no hub-wide feature/status flags */
798 selector
= wIndex
>> 8;
800 if (!wIndex
|| wIndex
> ports
)
803 temp
= ehci_readl(ehci
, status_reg
);
804 if (temp
& PORT_OWNER
)
807 temp
&= ~PORT_RWC_BITS
;
809 case USB_PORT_FEAT_SUSPEND
:
810 if (ehci
->no_selective_suspend
)
812 if ((temp
& PORT_PE
) == 0
813 || (temp
& PORT_RESET
) != 0)
815 if (device_may_wakeup(&hcd
->self
.root_hub
->dev
))
816 temp
|= PORT_WAKE_BITS
;
817 ehci_writel(ehci
, temp
| PORT_SUSPEND
, status_reg
);
819 case USB_PORT_FEAT_POWER
:
820 if (HCS_PPC (ehci
->hcs_params
))
821 ehci_writel(ehci
, temp
| PORT_POWER
,
824 case USB_PORT_FEAT_RESET
:
825 if (temp
& PORT_RESUME
)
827 /* line status bits may report this as low speed,
828 * which can be fine if this root hub has a
829 * transaction translator built in.
831 if ((temp
& (PORT_PE
|PORT_CONNECT
)) == PORT_CONNECT
832 && !ehci_is_TDI(ehci
)
833 && PORT_USB11 (temp
)) {
835 "port %d low speed --> companion\n",
839 ehci_vdbg (ehci
, "port %d reset\n", wIndex
+ 1);
844 * caller must wait, then call GetPortStatus
845 * usb 2.0 spec says 50 ms resets on root
847 ehci
->reset_done
[wIndex
] = jiffies
848 + msecs_to_jiffies (50);
850 ehci_writel(ehci
, temp
, status_reg
);
853 /* For downstream facing ports (these): one hub port is put
854 * into test mode according to USB2 11.24.2.13, then the hub
855 * must be reset (which for root hub now means rmmod+modprobe,
856 * or else system reboot). See EHCI 2.3.9 and 4.14 for info
857 * about the EHCI-specific stuff.
859 case USB_PORT_FEAT_TEST
:
860 if (!selector
|| selector
> 5)
864 temp
|= selector
<< 16;
865 ehci_writel(ehci
, temp
, status_reg
);
871 ehci_readl(ehci
, &ehci
->regs
->command
); /* unblock posted writes */
876 /* "stall" on error */
879 spin_unlock_irqrestore (&ehci
->lock
, flags
);
883 static void ehci_relinquish_port(struct usb_hcd
*hcd
, int portnum
)
885 struct ehci_hcd
*ehci
= hcd_to_ehci(hcd
);
887 if (ehci_is_TDI(ehci
))
889 set_owner(ehci
, --portnum
, PORT_OWNER
);