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
);
139 end_unlink_async(ehci
);
142 /* Unlike other USB host controller types, EHCI doesn't have
143 * any notion of "global" or bus-wide suspend. The driver has
144 * to manually suspend all the active unsuspended ports, and
145 * then manually resume them in the bus_resume() routine.
147 ehci
->bus_suspended
= 0;
148 ehci
->owned_ports
= 0;
150 u32 __iomem
*reg
= &ehci
->regs
->port_status
[port
];
151 u32 t1
= ehci_readl(ehci
, reg
) & ~PORT_RWC_BITS
;
154 /* keep track of which ports we suspend */
156 set_bit(port
, &ehci
->owned_ports
);
157 else if ((t1
& PORT_PE
) && !(t1
& PORT_SUSPEND
)) {
159 set_bit(port
, &ehci
->bus_suspended
);
162 /* enable remote wakeup on all ports */
163 if (device_may_wakeup(&hcd
->self
.root_hub
->dev
))
164 t2
|= PORT_WKOC_E
|PORT_WKDISC_E
|PORT_WKCONN_E
;
166 t2
&= ~(PORT_WKOC_E
|PORT_WKDISC_E
|PORT_WKCONN_E
);
169 ehci_vdbg (ehci
, "port %d, %08x -> %08x\n",
171 ehci_writel(ehci
, t2
, reg
);
175 /* turn off now-idle HC */
177 hcd
->state
= HC_STATE_SUSPENDED
;
179 /* allow remote wakeup */
181 if (!device_may_wakeup(&hcd
->self
.root_hub
->dev
))
183 ehci_writel(ehci
, mask
, &ehci
->regs
->intr_enable
);
184 ehci_readl(ehci
, &ehci
->regs
->intr_enable
);
186 ehci
->next_statechange
= jiffies
+ msecs_to_jiffies(10);
187 spin_unlock_irq (&ehci
->lock
);
192 /* caller has locked the root hub, and should reset/reinit on error */
193 static int ehci_bus_resume (struct usb_hcd
*hcd
)
195 struct ehci_hcd
*ehci
= hcd_to_ehci (hcd
);
200 if (time_before (jiffies
, ehci
->next_statechange
))
202 spin_lock_irq (&ehci
->lock
);
203 if (!test_bit(HCD_FLAG_HW_ACCESSIBLE
, &hcd
->flags
)) {
204 spin_unlock_irq(&ehci
->lock
);
208 /* Ideally and we've got a real resume here, and no port's power
209 * was lost. (For PCI, that means Vaux was maintained.) But we
210 * could instead be restoring a swsusp snapshot -- so that BIOS was
211 * the last user of the controller, not reset/pm hardware keeping
212 * state we gave to it.
214 power_okay
= ehci_readl(ehci
, &ehci
->regs
->intr_enable
);
215 ehci_dbg(ehci
, "resume root hub%s\n",
216 power_okay
? "" : " after power loss");
218 /* at least some APM implementations will try to deliver
219 * IRQs right away, so delay them until we're ready.
221 ehci_writel(ehci
, 0, &ehci
->regs
->intr_enable
);
223 /* re-init operational registers */
224 ehci_writel(ehci
, 0, &ehci
->regs
->segment
);
225 ehci_writel(ehci
, ehci
->periodic_dma
, &ehci
->regs
->frame_list
);
226 ehci_writel(ehci
, (u32
) ehci
->async
->qh_dma
, &ehci
->regs
->async_next
);
228 /* restore CMD_RUN, framelist size, and irq threshold */
229 ehci_writel(ehci
, ehci
->command
, &ehci
->regs
->command
);
231 /* Some controller/firmware combinations need a delay during which
232 * they set up the port statuses. See Bugzilla #8190. */
235 /* manually resume the ports we suspended during bus_suspend() */
236 i
= HCS_N_PORTS (ehci
->hcs_params
);
238 temp
= ehci_readl(ehci
, &ehci
->regs
->port_status
[i
]);
239 temp
&= ~(PORT_RWC_BITS
240 | PORT_WKOC_E
| PORT_WKDISC_E
| PORT_WKCONN_E
);
241 if (test_bit(i
, &ehci
->bus_suspended
) &&
242 (temp
& PORT_SUSPEND
)) {
243 ehci
->reset_done
[i
] = jiffies
+ msecs_to_jiffies (20);
246 ehci_writel(ehci
, temp
, &ehci
->regs
->port_status
[i
]);
248 i
= HCS_N_PORTS (ehci
->hcs_params
);
251 temp
= ehci_readl(ehci
, &ehci
->regs
->port_status
[i
]);
252 if (test_bit(i
, &ehci
->bus_suspended
) &&
253 (temp
& PORT_SUSPEND
)) {
254 temp
&= ~(PORT_RWC_BITS
| PORT_RESUME
);
255 ehci_writel(ehci
, temp
, &ehci
->regs
->port_status
[i
]);
256 ehci_vdbg (ehci
, "resumed port %d\n", i
+ 1);
259 (void) ehci_readl(ehci
, &ehci
->regs
->command
);
261 /* maybe re-activate the schedule(s) */
263 if (ehci
->async
->qh_next
.qh
)
265 if (ehci
->periodic_sched
)
268 ehci
->command
|= temp
;
269 ehci_writel(ehci
, ehci
->command
, &ehci
->regs
->command
);
272 ehci
->next_statechange
= jiffies
+ msecs_to_jiffies(5);
273 hcd
->state
= HC_STATE_RUNNING
;
275 /* Now we can safely re-enable irqs */
276 ehci_writel(ehci
, INTR_MASK
, &ehci
->regs
->intr_enable
);
278 spin_unlock_irq (&ehci
->lock
);
281 ehci_handover_companion_ports(ehci
);
287 #define ehci_bus_suspend NULL
288 #define ehci_bus_resume NULL
290 #endif /* CONFIG_PM */
292 /*-------------------------------------------------------------------------*/
294 /* Display the ports dedicated to the companion controller */
295 static ssize_t
show_companion(struct device
*dev
,
296 struct device_attribute
*attr
,
299 struct ehci_hcd
*ehci
;
300 int nports
, index
, n
;
301 int count
= PAGE_SIZE
;
304 ehci
= hcd_to_ehci(bus_to_hcd(dev_get_drvdata(dev
)));
305 nports
= HCS_N_PORTS(ehci
->hcs_params
);
307 for (index
= 0; index
< nports
; ++index
) {
308 if (test_bit(index
, &ehci
->companion_ports
)) {
309 n
= scnprintf(ptr
, count
, "%d\n", index
+ 1);
318 * Sets the owner of a port
320 static void set_owner(struct ehci_hcd
*ehci
, int portnum
, int new_owner
)
322 u32 __iomem
*status_reg
;
326 status_reg
= &ehci
->regs
->port_status
[portnum
];
329 * The controller won't set the OWNER bit if the port is
330 * enabled, so this loop will sometimes require at least two
331 * iterations: one to disable the port and one to set OWNER.
333 for (try = 4; try > 0; --try) {
334 spin_lock_irq(&ehci
->lock
);
335 port_status
= ehci_readl(ehci
, status_reg
);
336 if ((port_status
& PORT_OWNER
) == new_owner
337 || (port_status
& (PORT_OWNER
| PORT_CONNECT
))
341 port_status
^= PORT_OWNER
;
342 port_status
&= ~(PORT_PE
| PORT_RWC_BITS
);
343 ehci_writel(ehci
, port_status
, status_reg
);
345 spin_unlock_irq(&ehci
->lock
);
352 * Dedicate or undedicate a port to the companion controller.
353 * Syntax is "[-]portnum", where a leading '-' sign means
354 * return control of the port to the EHCI controller.
356 static ssize_t
store_companion(struct device
*dev
,
357 struct device_attribute
*attr
,
358 const char *buf
, size_t count
)
360 struct ehci_hcd
*ehci
;
361 int portnum
, new_owner
;
363 ehci
= hcd_to_ehci(bus_to_hcd(dev_get_drvdata(dev
)));
364 new_owner
= PORT_OWNER
; /* Owned by companion */
365 if (sscanf(buf
, "%d", &portnum
) != 1)
369 new_owner
= 0; /* Owned by EHCI */
371 if (portnum
<= 0 || portnum
> HCS_N_PORTS(ehci
->hcs_params
))
375 set_bit(portnum
, &ehci
->companion_ports
);
377 clear_bit(portnum
, &ehci
->companion_ports
);
378 set_owner(ehci
, portnum
, new_owner
);
381 static DEVICE_ATTR(companion
, 0644, show_companion
, store_companion
);
383 static inline void create_companion_file(struct ehci_hcd
*ehci
)
387 /* with integrated TT there is no companion! */
388 if (!ehci_is_TDI(ehci
))
389 i
= device_create_file(ehci_to_hcd(ehci
)->self
.dev
,
390 &dev_attr_companion
);
393 static inline void remove_companion_file(struct ehci_hcd
*ehci
)
395 /* with integrated TT there is no companion! */
396 if (!ehci_is_TDI(ehci
))
397 device_remove_file(ehci_to_hcd(ehci
)->self
.dev
,
398 &dev_attr_companion
);
402 /*-------------------------------------------------------------------------*/
404 static int check_reset_complete (
405 struct ehci_hcd
*ehci
,
407 u32 __iomem
*status_reg
,
410 if (!(port_status
& PORT_CONNECT
)) {
411 ehci
->reset_done
[index
] = 0;
415 /* if reset finished and it's still not enabled -- handoff */
416 if (!(port_status
& PORT_PE
)) {
418 /* with integrated TT, there's nobody to hand it to! */
419 if (ehci_is_TDI(ehci
)) {
421 "Failed to enable port %d on root hub TT\n",
426 ehci_dbg (ehci
, "port %d full speed --> companion\n",
429 // what happens if HCS_N_CC(params) == 0 ?
430 port_status
|= PORT_OWNER
;
431 port_status
&= ~PORT_RWC_BITS
;
432 ehci_writel(ehci
, port_status
, status_reg
);
435 ehci_dbg (ehci
, "port %d high speed\n", index
+ 1);
440 /*-------------------------------------------------------------------------*/
443 /* build "status change" packet (one or two bytes) from HC registers */
446 ehci_hub_status_data (struct usb_hcd
*hcd
, char *buf
)
448 struct ehci_hcd
*ehci
= hcd_to_ehci (hcd
);
449 u32 temp
, status
= 0;
451 int ports
, i
, retval
= 1;
454 /* if !USB_SUSPEND, root hub timers won't get shut down ... */
455 if (!HC_IS_RUNNING(hcd
->state
))
458 /* init status to no-changes */
460 ports
= HCS_N_PORTS (ehci
->hcs_params
);
466 /* Some boards (mostly VIA?) report bogus overcurrent indications,
467 * causing massive log spam unless we completely ignore them. It
468 * may be relevant that VIA VT8235 controllers, where PORT_POWER is
469 * always set, seem to clear PORT_OCC and PORT_CSC when writing to
470 * PORT_POWER; that's surprising, but maybe within-spec.
473 mask
= PORT_CSC
| PORT_PEC
| PORT_OCC
;
475 mask
= PORT_CSC
| PORT_PEC
;
476 // PORT_RESUME from hardware ~= PORT_STAT_C_SUSPEND
478 /* no hub change reports (bit 0) for now (power, ...) */
480 /* port N changes (bit N)? */
481 spin_lock_irqsave (&ehci
->lock
, flags
);
482 for (i
= 0; i
< ports
; i
++) {
483 temp
= ehci_readl(ehci
, &ehci
->regs
->port_status
[i
]);
486 * Return status information even for ports with OWNER set.
487 * Otherwise khubd wouldn't see the disconnect event when a
488 * high-speed device is switched over to the companion
489 * controller by the user.
492 if (!(temp
& PORT_CONNECT
))
493 ehci
->reset_done
[i
] = 0;
494 if ((temp
& mask
) != 0
495 || ((temp
& PORT_RESUME
) != 0
496 && time_after_eq(jiffies
,
497 ehci
->reset_done
[i
]))) {
499 buf
[0] |= 1 << (i
+ 1);
501 buf
[1] |= 1 << (i
- 7);
505 /* FIXME autosuspend idle root hubs */
506 spin_unlock_irqrestore (&ehci
->lock
, flags
);
507 return status
? retval
: 0;
510 /*-------------------------------------------------------------------------*/
513 ehci_hub_descriptor (
514 struct ehci_hcd
*ehci
,
515 struct usb_hub_descriptor
*desc
517 int ports
= HCS_N_PORTS (ehci
->hcs_params
);
520 desc
->bDescriptorType
= 0x29;
521 desc
->bPwrOn2PwrGood
= 10; /* ehci 1.0, 2.3.9 says 20ms max */
522 desc
->bHubContrCurrent
= 0;
524 desc
->bNbrPorts
= ports
;
525 temp
= 1 + (ports
/ 8);
526 desc
->bDescLength
= 7 + 2 * temp
;
528 /* two bitmaps: ports removable, and usb 1.0 legacy PortPwrCtrlMask */
529 memset (&desc
->bitmap
[0], 0, temp
);
530 memset (&desc
->bitmap
[temp
], 0xff, temp
);
532 temp
= 0x0008; /* per-port overcurrent reporting */
533 if (HCS_PPC (ehci
->hcs_params
))
534 temp
|= 0x0001; /* per-port power control */
536 temp
|= 0x0002; /* no power switching */
538 // re-enable when we support USB_PORT_FEAT_INDICATOR below.
539 if (HCS_INDICATOR (ehci
->hcs_params
))
540 temp
|= 0x0080; /* per-port indicators (LEDs) */
542 desc
->wHubCharacteristics
= (__force __u16
)cpu_to_le16 (temp
);
545 /*-------------------------------------------------------------------------*/
547 #define PORT_WAKE_BITS (PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E)
549 static int ehci_hub_control (
557 struct ehci_hcd
*ehci
= hcd_to_ehci (hcd
);
558 int ports
= HCS_N_PORTS (ehci
->hcs_params
);
559 u32 __iomem
*status_reg
= &ehci
->regs
->port_status
[
560 (wIndex
& 0xff) - 1];
567 * FIXME: support SetPortFeatures USB_PORT_FEAT_INDICATOR.
568 * HCS_INDICATOR may say we can change LEDs to off/amber/green.
569 * (track current state ourselves) ... blink for diagnostics,
570 * power, "this is the one", etc. EHCI spec supports this.
573 spin_lock_irqsave (&ehci
->lock
, flags
);
575 case ClearHubFeature
:
577 case C_HUB_LOCAL_POWER
:
578 case C_HUB_OVER_CURRENT
:
579 /* no hub-wide feature/status flags */
585 case ClearPortFeature
:
586 if (!wIndex
|| wIndex
> ports
)
589 temp
= ehci_readl(ehci
, status_reg
);
592 * Even if OWNER is set, so the port is owned by the
593 * companion controller, khubd needs to be able to clear
594 * the port-change status bits (especially
595 * USB_PORT_FEAT_C_CONNECTION).
599 case USB_PORT_FEAT_ENABLE
:
600 ehci_writel(ehci
, temp
& ~PORT_PE
, status_reg
);
602 case USB_PORT_FEAT_C_ENABLE
:
603 ehci_writel(ehci
, (temp
& ~PORT_RWC_BITS
) | PORT_PEC
,
606 case USB_PORT_FEAT_SUSPEND
:
607 if (temp
& PORT_RESET
)
609 if (ehci
->no_selective_suspend
)
611 if (temp
& PORT_SUSPEND
) {
612 if ((temp
& PORT_PE
) == 0)
614 /* resume signaling for 20 msec */
615 temp
&= ~(PORT_RWC_BITS
| PORT_WAKE_BITS
);
616 ehci_writel(ehci
, temp
| PORT_RESUME
,
618 ehci
->reset_done
[wIndex
] = jiffies
619 + msecs_to_jiffies (20);
622 case USB_PORT_FEAT_C_SUSPEND
:
623 /* we auto-clear this feature */
625 case USB_PORT_FEAT_POWER
:
626 if (HCS_PPC (ehci
->hcs_params
))
628 temp
& ~(PORT_RWC_BITS
| PORT_POWER
),
631 case USB_PORT_FEAT_C_CONNECTION
:
632 ehci_writel(ehci
, (temp
& ~PORT_RWC_BITS
) | PORT_CSC
,
635 case USB_PORT_FEAT_C_OVER_CURRENT
:
636 ehci_writel(ehci
, (temp
& ~PORT_RWC_BITS
) | PORT_OCC
,
639 case USB_PORT_FEAT_C_RESET
:
640 /* GetPortStatus clears reset */
645 ehci_readl(ehci
, &ehci
->regs
->command
); /* unblock posted write */
647 case GetHubDescriptor
:
648 ehci_hub_descriptor (ehci
, (struct usb_hub_descriptor
*)
652 /* no hub-wide feature/status flags */
654 //cpu_to_le32s ((u32 *) buf);
657 if (!wIndex
|| wIndex
> ports
)
661 temp
= ehci_readl(ehci
, status_reg
);
665 status
|= 1 << USB_PORT_FEAT_C_CONNECTION
;
667 status
|= 1 << USB_PORT_FEAT_C_ENABLE
;
669 if ((temp
& PORT_OCC
) && !ignore_oc
){
670 status
|= 1 << USB_PORT_FEAT_C_OVER_CURRENT
;
673 * Hubs should disable port power on over-current.
674 * However, not all EHCI implementations do this
675 * automatically, even if they _do_ support per-port
676 * power switching; they're allowed to just limit the
677 * current. khubd will turn the power back on.
679 if (HCS_PPC (ehci
->hcs_params
)){
681 temp
& ~(PORT_RWC_BITS
| PORT_POWER
),
686 /* whoever resumes must GetPortStatus to complete it!! */
687 if (temp
& PORT_RESUME
) {
689 /* Remote Wakeup received? */
690 if (!ehci
->reset_done
[wIndex
]) {
691 /* resume signaling for 20 msec */
692 ehci
->reset_done
[wIndex
] = jiffies
693 + msecs_to_jiffies(20);
694 /* check the port again */
695 mod_timer(&ehci_to_hcd(ehci
)->rh_timer
,
696 ehci
->reset_done
[wIndex
]);
699 /* resume completed? */
700 else if (time_after_eq(jiffies
,
701 ehci
->reset_done
[wIndex
])) {
702 status
|= 1 << USB_PORT_FEAT_C_SUSPEND
;
703 ehci
->reset_done
[wIndex
] = 0;
705 /* stop resume signaling */
706 temp
= ehci_readl(ehci
, status_reg
);
708 temp
& ~(PORT_RWC_BITS
| PORT_RESUME
),
710 retval
= handshake(ehci
, status_reg
,
711 PORT_RESUME
, 0, 2000 /* 2msec */);
714 "port %d resume error %d\n",
718 temp
&= ~(PORT_SUSPEND
|PORT_RESUME
|(3<<10));
722 /* whoever resets must GetPortStatus to complete it!! */
723 if ((temp
& PORT_RESET
)
724 && time_after_eq(jiffies
,
725 ehci
->reset_done
[wIndex
])) {
726 status
|= 1 << USB_PORT_FEAT_C_RESET
;
727 ehci
->reset_done
[wIndex
] = 0;
729 /* force reset to complete */
730 ehci_writel(ehci
, temp
& ~(PORT_RWC_BITS
| PORT_RESET
),
732 /* REVISIT: some hardware needs 550+ usec to clear
733 * this bit; seems too long to spin routinely...
735 retval
= handshake(ehci
, status_reg
,
738 ehci_err (ehci
, "port %d reset error %d\n",
743 /* see what we found out */
744 temp
= check_reset_complete (ehci
, wIndex
, status_reg
,
745 ehci_readl(ehci
, status_reg
));
748 /* transfer dedicated ports to the companion hc */
749 if ((temp
& PORT_CONNECT
) &&
750 test_bit(wIndex
, &ehci
->companion_ports
)) {
751 temp
&= ~PORT_RWC_BITS
;
753 ehci_writel(ehci
, temp
, status_reg
);
754 ehci_dbg(ehci
, "port %d --> companion\n", wIndex
+ 1);
755 temp
= ehci_readl(ehci
, status_reg
);
759 * Even if OWNER is set, there's no harm letting khubd
760 * see the wPortStatus values (they should all be 0 except
761 * for PORT_POWER anyway).
764 if (temp
& PORT_CONNECT
) {
765 status
|= 1 << USB_PORT_FEAT_CONNECTION
;
766 // status may be from integrated TT
767 status
|= ehci_port_speed(ehci
, temp
);
770 status
|= 1 << USB_PORT_FEAT_ENABLE
;
771 if (temp
& (PORT_SUSPEND
|PORT_RESUME
))
772 status
|= 1 << USB_PORT_FEAT_SUSPEND
;
774 status
|= 1 << USB_PORT_FEAT_OVER_CURRENT
;
775 if (temp
& PORT_RESET
)
776 status
|= 1 << USB_PORT_FEAT_RESET
;
777 if (temp
& PORT_POWER
)
778 status
|= 1 << USB_PORT_FEAT_POWER
;
780 #ifndef EHCI_VERBOSE_DEBUG
781 if (status
& ~0xffff) /* only if wPortChange is interesting */
783 dbg_port (ehci
, "GetStatus", wIndex
+ 1, temp
);
784 put_unaligned(cpu_to_le32 (status
), (__le32
*) buf
);
788 case C_HUB_LOCAL_POWER
:
789 case C_HUB_OVER_CURRENT
:
790 /* no hub-wide feature/status flags */
797 selector
= wIndex
>> 8;
799 if (!wIndex
|| wIndex
> ports
)
802 temp
= ehci_readl(ehci
, status_reg
);
803 if (temp
& PORT_OWNER
)
806 temp
&= ~PORT_RWC_BITS
;
808 case USB_PORT_FEAT_SUSPEND
:
809 if (ehci
->no_selective_suspend
)
811 if ((temp
& PORT_PE
) == 0
812 || (temp
& PORT_RESET
) != 0)
814 if (device_may_wakeup(&hcd
->self
.root_hub
->dev
))
815 temp
|= PORT_WAKE_BITS
;
816 ehci_writel(ehci
, temp
| PORT_SUSPEND
, status_reg
);
818 case USB_PORT_FEAT_POWER
:
819 if (HCS_PPC (ehci
->hcs_params
))
820 ehci_writel(ehci
, temp
| PORT_POWER
,
823 case USB_PORT_FEAT_RESET
:
824 if (temp
& PORT_RESUME
)
826 /* line status bits may report this as low speed,
827 * which can be fine if this root hub has a
828 * transaction translator built in.
830 if ((temp
& (PORT_PE
|PORT_CONNECT
)) == PORT_CONNECT
831 && !ehci_is_TDI(ehci
)
832 && PORT_USB11 (temp
)) {
834 "port %d low speed --> companion\n",
838 ehci_vdbg (ehci
, "port %d reset\n", wIndex
+ 1);
843 * caller must wait, then call GetPortStatus
844 * usb 2.0 spec says 50 ms resets on root
846 ehci
->reset_done
[wIndex
] = jiffies
847 + msecs_to_jiffies (50);
849 ehci_writel(ehci
, temp
, status_reg
);
852 /* For downstream facing ports (these): one hub port is put
853 * into test mode according to USB2 11.24.2.13, then the hub
854 * must be reset (which for root hub now means rmmod+modprobe,
855 * or else system reboot). See EHCI 2.3.9 and 4.14 for info
856 * about the EHCI-specific stuff.
858 case USB_PORT_FEAT_TEST
:
859 if (!selector
|| selector
> 5)
863 temp
|= selector
<< 16;
864 ehci_writel(ehci
, temp
, status_reg
);
870 ehci_readl(ehci
, &ehci
->regs
->command
); /* unblock posted writes */
875 /* "stall" on error */
878 spin_unlock_irqrestore (&ehci
->lock
, flags
);
882 static void ehci_relinquish_port(struct usb_hcd
*hcd
, int portnum
)
884 struct ehci_hcd
*ehci
= hcd_to_ehci(hcd
);
886 if (ehci_is_TDI(ehci
))
888 set_owner(ehci
, --portnum
, PORT_OWNER
);