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 persist_enabled_on_companion(struct usb_device
*udev
, void *unused
)
38 return !udev
->maxchild
&& udev
->persist_enabled
&&
39 udev
->bus
->root_hub
->speed
< USB_SPEED_HIGH
;
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
)
57 * USB 1.1 devices are mostly HIDs, which don't need to persist across
58 * suspends. If we ensure that none of our companion's devices have
59 * persist_enabled (by looking through all USB 1.1 buses in the system),
60 * we can skip this and avoid slowing resume down. Devices without
61 * persist will just get reenumerated shortly after resume anyway.
63 if (!usb_for_each_dev(NULL
, persist_enabled_on_companion
))
66 /* Make sure the ports are powered */
67 port
= HCS_N_PORTS(ehci
->hcs_params
);
69 if (test_bit(port
, &ehci
->owned_ports
)) {
70 reg
= &ehci
->regs
->port_status
[port
];
71 status
= ehci_readl(ehci
, reg
) & ~PORT_RWC_BITS
;
72 if (!(status
& PORT_POWER
))
73 ehci_port_power(ehci
, port
, true);
77 /* Give the connections some time to appear */
80 spin_lock_irq(&ehci
->lock
);
81 port
= HCS_N_PORTS(ehci
->hcs_params
);
83 if (test_bit(port
, &ehci
->owned_ports
)) {
84 reg
= &ehci
->regs
->port_status
[port
];
85 status
= ehci_readl(ehci
, reg
) & ~PORT_RWC_BITS
;
87 /* Port already owned by companion? */
88 if (status
& PORT_OWNER
)
89 clear_bit(port
, &ehci
->owned_ports
);
90 else if (test_bit(port
, &ehci
->companion_ports
))
91 ehci_writel(ehci
, status
& ~PORT_PE
, reg
);
93 spin_unlock_irq(&ehci
->lock
);
94 ehci_hub_control(hcd
, SetPortFeature
,
95 USB_PORT_FEAT_RESET
, port
+ 1,
97 spin_lock_irq(&ehci
->lock
);
101 spin_unlock_irq(&ehci
->lock
);
103 if (!ehci
->owned_ports
)
105 msleep(90); /* Wait for resets to complete */
107 spin_lock_irq(&ehci
->lock
);
108 port
= HCS_N_PORTS(ehci
->hcs_params
);
110 if (test_bit(port
, &ehci
->owned_ports
)) {
111 spin_unlock_irq(&ehci
->lock
);
112 ehci_hub_control(hcd
, GetPortStatus
,
114 (char *) &buf
, sizeof(buf
));
115 spin_lock_irq(&ehci
->lock
);
117 /* The companion should now own the port,
118 * but if something went wrong the port must not
121 reg
= &ehci
->regs
->port_status
[port
];
122 status
= ehci_readl(ehci
, reg
) & ~PORT_RWC_BITS
;
123 if (status
& PORT_OWNER
)
124 ehci_writel(ehci
, status
| PORT_CSC
, reg
);
126 ehci_dbg(ehci
, "failed handover port %d: %x\n",
128 ehci_writel(ehci
, status
& ~PORT_PE
, reg
);
133 ehci
->owned_ports
= 0;
134 spin_unlock_irq(&ehci
->lock
);
137 static int ehci_port_change(struct ehci_hcd
*ehci
)
139 int i
= HCS_N_PORTS(ehci
->hcs_params
);
141 /* First check if the controller indicates a change event */
143 if (ehci_readl(ehci
, &ehci
->regs
->status
) & STS_PCD
)
147 * Not all controllers appear to update this while going from D3 to D0,
148 * so check the individual port status registers as well
152 if (ehci_readl(ehci
, &ehci
->regs
->port_status
[i
]) & PORT_CSC
)
158 static void ehci_adjust_port_wakeup_flags(struct ehci_hcd
*ehci
,
159 bool suspending
, bool do_wakeup
)
164 /* If remote wakeup is enabled for the root hub but disabled
165 * for the controller, we must adjust all the port wakeup flags
166 * when the controller is suspended or resumed. In all other
167 * cases they don't need to be changed.
169 if (!ehci_to_hcd(ehci
)->self
.root_hub
->do_remote_wakeup
|| do_wakeup
)
172 spin_lock_irq(&ehci
->lock
);
174 /* clear phy low-power mode before changing wakeup flags */
175 if (ehci
->has_tdi_phy_lpm
) {
176 port
= HCS_N_PORTS(ehci
->hcs_params
);
178 u32 __iomem
*hostpc_reg
= &ehci
->regs
->hostpc
[port
];
180 temp
= ehci_readl(ehci
, hostpc_reg
);
181 ehci_writel(ehci
, temp
& ~HOSTPC_PHCD
, hostpc_reg
);
183 spin_unlock_irq(&ehci
->lock
);
185 spin_lock_irq(&ehci
->lock
);
188 port
= HCS_N_PORTS(ehci
->hcs_params
);
190 u32 __iomem
*reg
= &ehci
->regs
->port_status
[port
];
191 u32 t1
= ehci_readl(ehci
, reg
) & ~PORT_RWC_BITS
;
192 u32 t2
= t1
& ~PORT_WAKE_BITS
;
194 /* If we are suspending the controller, clear the flags.
195 * If we are resuming the controller, set the wakeup flags.
198 if (t1
& PORT_CONNECT
)
199 t2
|= PORT_WKOC_E
| PORT_WKDISC_E
;
201 t2
|= PORT_WKOC_E
| PORT_WKCONN_E
;
203 ehci_writel(ehci
, t2
, reg
);
206 /* enter phy low-power mode again */
207 if (ehci
->has_tdi_phy_lpm
) {
208 port
= HCS_N_PORTS(ehci
->hcs_params
);
210 u32 __iomem
*hostpc_reg
= &ehci
->regs
->hostpc
[port
];
212 temp
= ehci_readl(ehci
, hostpc_reg
);
213 ehci_writel(ehci
, temp
| HOSTPC_PHCD
, hostpc_reg
);
217 /* Does the root hub have a port wakeup pending? */
218 if (!suspending
&& ehci_port_change(ehci
))
219 usb_hcd_resume_root_hub(ehci_to_hcd(ehci
));
221 spin_unlock_irq(&ehci
->lock
);
224 static int ehci_bus_suspend (struct usb_hcd
*hcd
)
226 struct ehci_hcd
*ehci
= hcd_to_ehci (hcd
);
232 ehci_dbg(ehci
, "suspend root hub\n");
234 if (time_before (jiffies
, ehci
->next_statechange
))
237 /* stop the schedules */
240 spin_lock_irq (&ehci
->lock
);
241 if (ehci
->rh_state
< EHCI_RH_RUNNING
)
244 /* Once the controller is stopped, port resumes that are already
245 * in progress won't complete. Hence if remote wakeup is enabled
246 * for the root hub and any ports are in the middle of a resume or
247 * remote wakeup, we must fail the suspend.
249 if (hcd
->self
.root_hub
->do_remote_wakeup
) {
250 if (ehci
->resuming_ports
) {
251 spin_unlock_irq(&ehci
->lock
);
252 ehci_dbg(ehci
, "suspend failed because a port is resuming\n");
257 /* Unlike other USB host controller types, EHCI doesn't have
258 * any notion of "global" or bus-wide suspend. The driver has
259 * to manually suspend all the active unsuspended ports, and
260 * then manually resume them in the bus_resume() routine.
262 ehci
->bus_suspended
= 0;
263 ehci
->owned_ports
= 0;
265 fs_idle_delay
= false;
266 port
= HCS_N_PORTS(ehci
->hcs_params
);
268 u32 __iomem
*reg
= &ehci
->regs
->port_status
[port
];
269 u32 t1
= ehci_readl(ehci
, reg
) & ~PORT_RWC_BITS
;
270 u32 t2
= t1
& ~PORT_WAKE_BITS
;
272 /* keep track of which ports we suspend */
274 set_bit(port
, &ehci
->owned_ports
);
275 else if ((t1
& PORT_PE
) && !(t1
& PORT_SUSPEND
)) {
277 set_bit(port
, &ehci
->bus_suspended
);
280 /* enable remote wakeup on all ports, if told to do so */
281 if (hcd
->self
.root_hub
->do_remote_wakeup
) {
282 /* only enable appropriate wake bits, otherwise the
283 * hardware can not go phy low power mode. If a race
284 * condition happens here(connection change during bits
285 * set), the port change detection will finally fix it.
287 if (t1
& PORT_CONNECT
)
288 t2
|= PORT_WKOC_E
| PORT_WKDISC_E
;
290 t2
|= PORT_WKOC_E
| PORT_WKCONN_E
;
295 * On some controllers, Wake-On-Disconnect will
296 * generate false wakeup signals until the bus
297 * switches over to full-speed idle. For their
298 * sake, add a delay if we need one.
300 if ((t2
& PORT_WKDISC_E
) &&
301 ehci_port_speed(ehci
, t2
) ==
302 USB_PORT_STAT_HIGH_SPEED
)
303 fs_idle_delay
= true;
304 ehci_writel(ehci
, t2
, reg
);
308 spin_unlock_irq(&ehci
->lock
);
310 if ((changed
&& ehci
->has_tdi_phy_lpm
) || fs_idle_delay
) {
312 * Wait for HCD to enter low-power mode or for the bus
313 * to switch to full-speed idle.
315 usleep_range(5000, 5500);
318 if (changed
&& ehci
->has_tdi_phy_lpm
) {
319 spin_lock_irq(&ehci
->lock
);
320 port
= HCS_N_PORTS(ehci
->hcs_params
);
322 u32 __iomem
*hostpc_reg
= &ehci
->regs
->hostpc
[port
];
325 t3
= ehci_readl(ehci
, hostpc_reg
);
326 ehci_writel(ehci
, t3
| HOSTPC_PHCD
, hostpc_reg
);
327 t3
= ehci_readl(ehci
, hostpc_reg
);
328 ehci_dbg(ehci
, "Port %d phy low-power mode %s\n",
329 port
, (t3
& HOSTPC_PHCD
) ?
330 "succeeded" : "failed");
332 spin_unlock_irq(&ehci
->lock
);
335 /* Apparently some devices need a >= 1-uframe delay here */
336 if (ehci
->bus_suspended
)
339 /* turn off now-idle HC */
342 spin_lock_irq(&ehci
->lock
);
343 if (ehci
->enabled_hrtimer_events
& BIT(EHCI_HRTIMER_POLL_DEAD
))
344 ehci_handle_controller_death(ehci
);
345 if (ehci
->rh_state
!= EHCI_RH_RUNNING
)
347 ehci
->rh_state
= EHCI_RH_SUSPENDED
;
349 end_unlink_async(ehci
);
350 unlink_empty_async_suspended(ehci
);
351 ehci_handle_start_intr_unlinks(ehci
);
352 ehci_handle_intr_unlinks(ehci
);
355 /* allow remote wakeup */
357 if (!hcd
->self
.root_hub
->do_remote_wakeup
)
359 ehci_writel(ehci
, mask
, &ehci
->regs
->intr_enable
);
360 ehci_readl(ehci
, &ehci
->regs
->intr_enable
);
363 ehci
->next_statechange
= jiffies
+ msecs_to_jiffies(10);
364 ehci
->enabled_hrtimer_events
= 0;
365 ehci
->next_hrtimer_event
= EHCI_HRTIMER_NO_EVENT
;
366 spin_unlock_irq (&ehci
->lock
);
368 hrtimer_cancel(&ehci
->hrtimer
);
373 /* caller has locked the root hub, and should reset/reinit on error */
374 static int ehci_bus_resume (struct usb_hcd
*hcd
)
376 struct ehci_hcd
*ehci
= hcd_to_ehci (hcd
);
380 unsigned long resume_needed
= 0;
382 if (time_before (jiffies
, ehci
->next_statechange
))
384 spin_lock_irq (&ehci
->lock
);
385 if (!HCD_HW_ACCESSIBLE(hcd
) || ehci
->shutdown
)
388 if (unlikely(ehci
->debug
)) {
389 if (!dbgp_reset_prep(hcd
))
392 dbgp_external_startup(hcd
);
395 /* Ideally and we've got a real resume here, and no port's power
396 * was lost. (For PCI, that means Vaux was maintained.) But we
397 * could instead be restoring a swsusp snapshot -- so that BIOS was
398 * the last user of the controller, not reset/pm hardware keeping
399 * state we gave to it.
401 power_okay
= ehci_readl(ehci
, &ehci
->regs
->intr_enable
);
402 ehci_dbg(ehci
, "resume root hub%s\n",
403 power_okay
? "" : " after power loss");
405 /* at least some APM implementations will try to deliver
406 * IRQs right away, so delay them until we're ready.
408 ehci_writel(ehci
, 0, &ehci
->regs
->intr_enable
);
410 /* re-init operational registers */
411 ehci_writel(ehci
, 0, &ehci
->regs
->segment
);
412 ehci_writel(ehci
, ehci
->periodic_dma
, &ehci
->regs
->frame_list
);
413 ehci_writel(ehci
, (u32
) ehci
->async
->qh_dma
, &ehci
->regs
->async_next
);
415 /* restore CMD_RUN, framelist size, and irq threshold */
416 ehci
->command
|= CMD_RUN
;
417 ehci_writel(ehci
, ehci
->command
, &ehci
->regs
->command
);
418 ehci
->rh_state
= EHCI_RH_RUNNING
;
421 * According to Bugzilla #8190, the port status for some controllers
422 * will be wrong without a delay. At their wrong status, the port
423 * is enabled, but not suspended neither resumed.
425 i
= HCS_N_PORTS(ehci
->hcs_params
);
427 temp
= ehci_readl(ehci
, &ehci
->regs
->port_status
[i
]);
428 if ((temp
& PORT_PE
) &&
429 !(temp
& (PORT_SUSPEND
| PORT_RESUME
))) {
430 ehci_dbg(ehci
, "Port status(0x%x) is wrong\n", temp
);
431 spin_unlock_irq(&ehci
->lock
);
433 spin_lock_irq(&ehci
->lock
);
441 /* clear phy low-power mode before resume */
442 if (ehci
->bus_suspended
&& ehci
->has_tdi_phy_lpm
) {
443 i
= HCS_N_PORTS(ehci
->hcs_params
);
445 if (test_bit(i
, &ehci
->bus_suspended
)) {
446 u32 __iomem
*hostpc_reg
=
447 &ehci
->regs
->hostpc
[i
];
449 temp
= ehci_readl(ehci
, hostpc_reg
);
450 ehci_writel(ehci
, temp
& ~HOSTPC_PHCD
,
454 spin_unlock_irq(&ehci
->lock
);
456 spin_lock_irq(&ehci
->lock
);
461 /* manually resume the ports we suspended during bus_suspend() */
462 i
= HCS_N_PORTS (ehci
->hcs_params
);
464 temp
= ehci_readl(ehci
, &ehci
->regs
->port_status
[i
]);
465 temp
&= ~(PORT_RWC_BITS
| PORT_WAKE_BITS
);
466 if (test_bit(i
, &ehci
->bus_suspended
) &&
467 (temp
& PORT_SUSPEND
)) {
469 set_bit(i
, &resume_needed
);
471 ehci_writel(ehci
, temp
, &ehci
->regs
->port_status
[i
]);
475 * msleep for USB_RESUME_TIMEOUT ms only if code is trying to resume
479 spin_unlock_irq(&ehci
->lock
);
480 msleep(USB_RESUME_TIMEOUT
);
481 spin_lock_irq(&ehci
->lock
);
486 i
= HCS_N_PORTS (ehci
->hcs_params
);
488 temp
= ehci_readl(ehci
, &ehci
->regs
->port_status
[i
]);
489 if (test_bit(i
, &resume_needed
)) {
490 temp
&= ~(PORT_RWC_BITS
| PORT_SUSPEND
| PORT_RESUME
);
491 ehci_writel(ehci
, temp
, &ehci
->regs
->port_status
[i
]);
495 ehci
->next_statechange
= jiffies
+ msecs_to_jiffies(5);
496 spin_unlock_irq(&ehci
->lock
);
498 ehci_handover_companion_ports(ehci
);
500 /* Now we can safely re-enable irqs */
501 spin_lock_irq(&ehci
->lock
);
504 ehci_writel(ehci
, INTR_MASK
, &ehci
->regs
->intr_enable
);
505 (void) ehci_readl(ehci
, &ehci
->regs
->intr_enable
);
506 spin_unlock_irq(&ehci
->lock
);
511 spin_unlock_irq(&ehci
->lock
);
517 #define ehci_bus_suspend NULL
518 #define ehci_bus_resume NULL
520 #endif /* CONFIG_PM */
522 /*-------------------------------------------------------------------------*/
525 * Sets the owner of a port
527 static void set_owner(struct ehci_hcd
*ehci
, int portnum
, int new_owner
)
529 u32 __iomem
*status_reg
;
533 status_reg
= &ehci
->regs
->port_status
[portnum
];
536 * The controller won't set the OWNER bit if the port is
537 * enabled, so this loop will sometimes require at least two
538 * iterations: one to disable the port and one to set OWNER.
540 for (try = 4; try > 0; --try) {
541 spin_lock_irq(&ehci
->lock
);
542 port_status
= ehci_readl(ehci
, status_reg
);
543 if ((port_status
& PORT_OWNER
) == new_owner
544 || (port_status
& (PORT_OWNER
| PORT_CONNECT
))
548 port_status
^= PORT_OWNER
;
549 port_status
&= ~(PORT_PE
| PORT_RWC_BITS
);
550 ehci_writel(ehci
, port_status
, status_reg
);
552 spin_unlock_irq(&ehci
->lock
);
558 /*-------------------------------------------------------------------------*/
560 static int check_reset_complete (
561 struct ehci_hcd
*ehci
,
563 u32 __iomem
*status_reg
,
566 if (!(port_status
& PORT_CONNECT
))
569 /* if reset finished and it's still not enabled -- handoff */
570 if (!(port_status
& PORT_PE
)) {
572 /* with integrated TT, there's nobody to hand it to! */
573 if (ehci_is_TDI(ehci
)) {
575 "Failed to enable port %d on root hub TT\n",
580 ehci_dbg (ehci
, "port %d full speed --> companion\n",
583 // what happens if HCS_N_CC(params) == 0 ?
584 port_status
|= PORT_OWNER
;
585 port_status
&= ~PORT_RWC_BITS
;
586 ehci_writel(ehci
, port_status
, status_reg
);
588 /* ensure 440EPX ohci controller state is operational */
589 if (ehci
->has_amcc_usb23
)
590 set_ohci_hcfs(ehci
, 1);
592 ehci_dbg(ehci
, "port %d reset complete, port enabled\n",
594 /* ensure 440EPx ohci controller state is suspended */
595 if (ehci
->has_amcc_usb23
)
596 set_ohci_hcfs(ehci
, 0);
602 /*-------------------------------------------------------------------------*/
605 /* build "status change" packet (one or two bytes) from HC registers */
608 ehci_hub_status_data (struct usb_hcd
*hcd
, char *buf
)
610 struct ehci_hcd
*ehci
= hcd_to_ehci (hcd
);
613 int ports
, i
, retval
= 1;
617 /* init status to no-changes */
619 ports
= HCS_N_PORTS (ehci
->hcs_params
);
625 /* Inform the core about resumes-in-progress by returning
626 * a non-zero value even if there are no status changes.
628 status
= ehci
->resuming_ports
;
630 /* Some boards (mostly VIA?) report bogus overcurrent indications,
631 * causing massive log spam unless we completely ignore them. It
632 * may be relevant that VIA VT8235 controllers, where PORT_POWER is
633 * always set, seem to clear PORT_OCC and PORT_CSC when writing to
634 * PORT_POWER; that's surprising, but maybe within-spec.
637 mask
= PORT_CSC
| PORT_PEC
| PORT_OCC
;
639 mask
= PORT_CSC
| PORT_PEC
;
640 // PORT_RESUME from hardware ~= PORT_STAT_C_SUSPEND
642 /* no hub change reports (bit 0) for now (power, ...) */
644 /* port N changes (bit N)? */
645 spin_lock_irqsave (&ehci
->lock
, flags
);
647 /* get per-port change detect bits */
649 ppcd
= ehci_readl(ehci
, &ehci
->regs
->status
) >> 16;
651 for (i
= 0; i
< ports
; i
++) {
652 /* leverage per-port change bits feature */
654 temp
= ehci_readl(ehci
, &ehci
->regs
->port_status
[i
]);
659 * Return status information even for ports with OWNER set.
660 * Otherwise hub_wq wouldn't see the disconnect event when a
661 * high-speed device is switched over to the companion
662 * controller by the user.
665 if ((temp
& mask
) != 0 || test_bit(i
, &ehci
->port_c_suspend
)
666 || (ehci
->reset_done
[i
] && time_after_eq(
667 jiffies
, ehci
->reset_done
[i
]))) {
669 buf
[0] |= 1 << (i
+ 1);
671 buf
[1] |= 1 << (i
- 7);
676 /* If a resume is in progress, make sure it can finish */
677 if (ehci
->resuming_ports
)
678 mod_timer(&hcd
->rh_timer
, jiffies
+ msecs_to_jiffies(25));
680 spin_unlock_irqrestore (&ehci
->lock
, flags
);
681 return status
? retval
: 0;
684 /*-------------------------------------------------------------------------*/
687 ehci_hub_descriptor (
688 struct ehci_hcd
*ehci
,
689 struct usb_hub_descriptor
*desc
691 int ports
= HCS_N_PORTS (ehci
->hcs_params
);
694 desc
->bDescriptorType
= USB_DT_HUB
;
695 desc
->bPwrOn2PwrGood
= 10; /* ehci 1.0, 2.3.9 says 20ms max */
696 desc
->bHubContrCurrent
= 0;
698 desc
->bNbrPorts
= ports
;
699 temp
= 1 + (ports
/ 8);
700 desc
->bDescLength
= 7 + 2 * temp
;
702 /* two bitmaps: ports removable, and usb 1.0 legacy PortPwrCtrlMask */
703 memset(&desc
->u
.hs
.DeviceRemovable
[0], 0, temp
);
704 memset(&desc
->u
.hs
.DeviceRemovable
[temp
], 0xff, temp
);
706 temp
= HUB_CHAR_INDV_PORT_OCPM
; /* per-port overcurrent reporting */
707 if (HCS_PPC (ehci
->hcs_params
))
708 temp
|= HUB_CHAR_INDV_PORT_LPSM
; /* per-port power control */
710 temp
|= HUB_CHAR_NO_LPSM
; /* no power switching */
712 // re-enable when we support USB_PORT_FEAT_INDICATOR below.
713 if (HCS_INDICATOR (ehci
->hcs_params
))
714 temp
|= HUB_CHAR_PORTIND
; /* per-port indicators (LEDs) */
716 desc
->wHubCharacteristics
= cpu_to_le16(temp
);
719 /*-------------------------------------------------------------------------*/
720 #ifdef CONFIG_USB_HCD_TEST_MODE
722 #define EHSET_TEST_SINGLE_STEP_SET_FEATURE 0x06
724 static void usb_ehset_completion(struct urb
*urb
)
726 struct completion
*done
= urb
->context
;
730 static int submit_single_step_set_feature(
737 * Allocate and initialize a control URB. This request will be used by the
738 * EHSET SINGLE_STEP_SET_FEATURE test in which the DATA and STATUS stages
739 * of the GetDescriptor request are sent 15 seconds after the SETUP stage.
740 * Return NULL if failed.
742 static struct urb
*request_single_step_set_feature_urb(
743 struct usb_device
*udev
,
746 struct completion
*done
749 struct usb_hcd
*hcd
= bus_to_hcd(udev
->bus
);
750 struct usb_host_endpoint
*ep
;
752 urb
= usb_alloc_urb(0, GFP_KERNEL
);
756 urb
->pipe
= usb_rcvctrlpipe(udev
, 0);
757 ep
= (usb_pipein(urb
->pipe
) ? udev
->ep_in
: udev
->ep_out
)
758 [usb_pipeendpoint(urb
->pipe
)];
766 urb
->setup_packet
= (void *)dr
;
767 urb
->transfer_buffer
= buf
;
768 urb
->transfer_buffer_length
= USB_DT_DEVICE_SIZE
;
769 urb
->complete
= usb_ehset_completion
;
770 urb
->status
= -EINPROGRESS
;
771 urb
->actual_length
= 0;
772 urb
->transfer_flags
= URB_DIR_IN
;
774 atomic_inc(&urb
->use_count
);
775 atomic_inc(&urb
->dev
->urbnum
);
776 urb
->setup_dma
= dma_map_single(
777 hcd
->self
.controller
,
779 sizeof(struct usb_ctrlrequest
),
781 urb
->transfer_dma
= dma_map_single(
782 hcd
->self
.controller
,
783 urb
->transfer_buffer
,
784 urb
->transfer_buffer_length
,
790 static int ehset_single_step_set_feature(struct usb_hcd
*hcd
, int port
)
792 int retval
= -ENOMEM
;
793 struct usb_ctrlrequest
*dr
;
795 struct usb_device
*udev
;
796 struct ehci_hcd
*ehci
= hcd_to_ehci(hcd
);
797 struct usb_device_descriptor
*buf
;
798 DECLARE_COMPLETION_ONSTACK(done
);
800 /* Obtain udev of the rhub's child port */
801 udev
= usb_hub_find_child(hcd
->self
.root_hub
, port
);
803 ehci_err(ehci
, "No device attached to the RootHub\n");
806 buf
= kmalloc(USB_DT_DEVICE_SIZE
, GFP_KERNEL
);
810 dr
= kmalloc(sizeof(struct usb_ctrlrequest
), GFP_KERNEL
);
816 /* Fill Setup packet for GetDescriptor */
817 dr
->bRequestType
= USB_DIR_IN
;
818 dr
->bRequest
= USB_REQ_GET_DESCRIPTOR
;
819 dr
->wValue
= cpu_to_le16(USB_DT_DEVICE
<< 8);
821 dr
->wLength
= cpu_to_le16(USB_DT_DEVICE_SIZE
);
822 urb
= request_single_step_set_feature_urb(udev
, dr
, buf
, &done
);
826 /* Submit just the SETUP stage */
827 retval
= submit_single_step_set_feature(hcd
, urb
, 1);
830 if (!wait_for_completion_timeout(&done
, msecs_to_jiffies(2000))) {
833 ehci_err(ehci
, "%s SETUP stage timed out on ep0\n", __func__
);
838 /* Complete remaining DATA and STATUS stages using the same URB */
839 urb
->status
= -EINPROGRESS
;
841 atomic_inc(&urb
->use_count
);
842 atomic_inc(&urb
->dev
->urbnum
);
843 retval
= submit_single_step_set_feature(hcd
, urb
, 0);
844 if (!retval
&& !wait_for_completion_timeout(&done
,
845 msecs_to_jiffies(2000))) {
848 ehci_err(ehci
, "%s IN stage timed out on ep0\n", __func__
);
857 #endif /* CONFIG_USB_HCD_TEST_MODE */
858 /*-------------------------------------------------------------------------*/
860 int ehci_hub_control(
868 struct ehci_hcd
*ehci
= hcd_to_ehci (hcd
);
869 int ports
= HCS_N_PORTS (ehci
->hcs_params
);
870 u32 __iomem
*status_reg
= &ehci
->regs
->port_status
[
871 (wIndex
& 0xff) - 1];
872 u32 __iomem
*hostpc_reg
= &ehci
->regs
->hostpc
[(wIndex
& 0xff) - 1];
873 u32 temp
, temp1
, status
;
879 * FIXME: support SetPortFeatures USB_PORT_FEAT_INDICATOR.
880 * HCS_INDICATOR may say we can change LEDs to off/amber/green.
881 * (track current state ourselves) ... blink for diagnostics,
882 * power, "this is the one", etc. EHCI spec supports this.
885 spin_lock_irqsave (&ehci
->lock
, flags
);
887 case ClearHubFeature
:
889 case C_HUB_LOCAL_POWER
:
890 case C_HUB_OVER_CURRENT
:
891 /* no hub-wide feature/status flags */
897 case ClearPortFeature
:
898 if (!wIndex
|| wIndex
> ports
)
901 temp
= ehci_readl(ehci
, status_reg
);
902 temp
&= ~PORT_RWC_BITS
;
905 * Even if OWNER is set, so the port is owned by the
906 * companion controller, hub_wq needs to be able to clear
907 * the port-change status bits (especially
908 * USB_PORT_STAT_C_CONNECTION).
912 case USB_PORT_FEAT_ENABLE
:
913 ehci_writel(ehci
, temp
& ~PORT_PE
, status_reg
);
915 case USB_PORT_FEAT_C_ENABLE
:
916 ehci_writel(ehci
, temp
| PORT_PEC
, status_reg
);
918 case USB_PORT_FEAT_SUSPEND
:
919 if (temp
& PORT_RESET
)
921 if (ehci
->no_selective_suspend
)
923 #ifdef CONFIG_USB_OTG
924 if ((hcd
->self
.otg_port
== (wIndex
+ 1))
925 && hcd
->self
.b_hnp_enable
) {
926 otg_start_hnp(hcd
->usb_phy
->otg
);
930 if (!(temp
& PORT_SUSPEND
))
932 if ((temp
& PORT_PE
) == 0)
935 /* clear phy low-power mode before resume */
936 if (ehci
->has_tdi_phy_lpm
) {
937 temp1
= ehci_readl(ehci
, hostpc_reg
);
938 ehci_writel(ehci
, temp1
& ~HOSTPC_PHCD
,
940 spin_unlock_irqrestore(&ehci
->lock
, flags
);
941 msleep(5);/* wait to leave low-power mode */
942 spin_lock_irqsave(&ehci
->lock
, flags
);
944 /* resume signaling for 20 msec */
945 temp
&= ~PORT_WAKE_BITS
;
946 ehci_writel(ehci
, temp
| PORT_RESUME
, status_reg
);
947 ehci
->reset_done
[wIndex
] = jiffies
948 + msecs_to_jiffies(USB_RESUME_TIMEOUT
);
949 set_bit(wIndex
, &ehci
->resuming_ports
);
950 usb_hcd_start_port_resume(&hcd
->self
, wIndex
);
952 case USB_PORT_FEAT_C_SUSPEND
:
953 clear_bit(wIndex
, &ehci
->port_c_suspend
);
955 case USB_PORT_FEAT_POWER
:
956 if (HCS_PPC(ehci
->hcs_params
)) {
957 spin_unlock_irqrestore(&ehci
->lock
, flags
);
958 ehci_port_power(ehci
, wIndex
, false);
959 spin_lock_irqsave(&ehci
->lock
, flags
);
962 case USB_PORT_FEAT_C_CONNECTION
:
963 ehci_writel(ehci
, temp
| PORT_CSC
, status_reg
);
965 case USB_PORT_FEAT_C_OVER_CURRENT
:
966 ehci_writel(ehci
, temp
| PORT_OCC
, status_reg
);
968 case USB_PORT_FEAT_C_RESET
:
969 /* GetPortStatus clears reset */
974 ehci_readl(ehci
, &ehci
->regs
->command
); /* unblock posted write */
976 case GetHubDescriptor
:
977 ehci_hub_descriptor (ehci
, (struct usb_hub_descriptor
*)
981 /* no hub-wide feature/status flags */
983 //cpu_to_le32s ((u32 *) buf);
986 if (!wIndex
|| wIndex
> ports
)
990 temp
= ehci_readl(ehci
, status_reg
);
994 status
|= USB_PORT_STAT_C_CONNECTION
<< 16;
996 status
|= USB_PORT_STAT_C_ENABLE
<< 16;
998 if ((temp
& PORT_OCC
) && !ignore_oc
){
999 status
|= USB_PORT_STAT_C_OVERCURRENT
<< 16;
1002 * Hubs should disable port power on over-current.
1003 * However, not all EHCI implementations do this
1004 * automatically, even if they _do_ support per-port
1005 * power switching; they're allowed to just limit the
1006 * current. hub_wq will turn the power back on.
1008 if (((temp
& PORT_OC
) || (ehci
->need_oc_pp_cycle
))
1009 && HCS_PPC(ehci
->hcs_params
)) {
1010 spin_unlock_irqrestore(&ehci
->lock
, flags
);
1011 ehci_port_power(ehci
, wIndex
, false);
1012 spin_lock_irqsave(&ehci
->lock
, flags
);
1013 temp
= ehci_readl(ehci
, status_reg
);
1017 /* no reset or resume pending */
1018 if (!ehci
->reset_done
[wIndex
]) {
1020 /* Remote Wakeup received? */
1021 if (temp
& PORT_RESUME
) {
1022 /* resume signaling for 20 msec */
1023 ehci
->reset_done
[wIndex
] = jiffies
1024 + msecs_to_jiffies(20);
1025 usb_hcd_start_port_resume(&hcd
->self
, wIndex
);
1026 set_bit(wIndex
, &ehci
->resuming_ports
);
1027 /* check the port again */
1028 mod_timer(&ehci_to_hcd(ehci
)->rh_timer
,
1029 ehci
->reset_done
[wIndex
]);
1032 /* reset or resume not yet complete */
1033 } else if (!time_after_eq(jiffies
, ehci
->reset_done
[wIndex
])) {
1034 ; /* wait until it is complete */
1036 /* resume completed */
1037 } else if (test_bit(wIndex
, &ehci
->resuming_ports
)) {
1038 clear_bit(wIndex
, &ehci
->suspended_ports
);
1039 set_bit(wIndex
, &ehci
->port_c_suspend
);
1040 ehci
->reset_done
[wIndex
] = 0;
1041 usb_hcd_end_port_resume(&hcd
->self
, wIndex
);
1043 /* stop resume signaling */
1044 temp
&= ~(PORT_RWC_BITS
| PORT_SUSPEND
| PORT_RESUME
);
1045 ehci_writel(ehci
, temp
, status_reg
);
1046 clear_bit(wIndex
, &ehci
->resuming_ports
);
1047 retval
= ehci_handshake(ehci
, status_reg
,
1048 PORT_RESUME
, 0, 2000 /* 2msec */);
1050 ehci_err(ehci
, "port %d resume error %d\n",
1051 wIndex
+ 1, retval
);
1054 temp
= ehci_readl(ehci
, status_reg
);
1056 /* whoever resets must GetPortStatus to complete it!! */
1058 status
|= USB_PORT_STAT_C_RESET
<< 16;
1059 ehci
->reset_done
[wIndex
] = 0;
1061 /* force reset to complete */
1062 ehci_writel(ehci
, temp
& ~(PORT_RWC_BITS
| PORT_RESET
),
1064 /* REVISIT: some hardware needs 550+ usec to clear
1065 * this bit; seems too long to spin routinely...
1067 retval
= ehci_handshake(ehci
, status_reg
,
1068 PORT_RESET
, 0, 1000);
1070 ehci_err (ehci
, "port %d reset error %d\n",
1071 wIndex
+ 1, retval
);
1075 /* see what we found out */
1076 temp
= check_reset_complete (ehci
, wIndex
, status_reg
,
1077 ehci_readl(ehci
, status_reg
));
1080 /* transfer dedicated ports to the companion hc */
1081 if ((temp
& PORT_CONNECT
) &&
1082 test_bit(wIndex
, &ehci
->companion_ports
)) {
1083 temp
&= ~PORT_RWC_BITS
;
1085 ehci_writel(ehci
, temp
, status_reg
);
1086 ehci_dbg(ehci
, "port %d --> companion\n", wIndex
+ 1);
1087 temp
= ehci_readl(ehci
, status_reg
);
1091 * Even if OWNER is set, there's no harm letting hub_wq
1092 * see the wPortStatus values (they should all be 0 except
1093 * for PORT_POWER anyway).
1096 if (temp
& PORT_CONNECT
) {
1097 status
|= USB_PORT_STAT_CONNECTION
;
1098 // status may be from integrated TT
1099 if (ehci
->has_hostpc
) {
1100 temp1
= ehci_readl(ehci
, hostpc_reg
);
1101 status
|= ehci_port_speed(ehci
, temp1
);
1103 status
|= ehci_port_speed(ehci
, temp
);
1106 status
|= USB_PORT_STAT_ENABLE
;
1108 /* maybe the port was unsuspended without our knowledge */
1109 if (temp
& (PORT_SUSPEND
|PORT_RESUME
)) {
1110 status
|= USB_PORT_STAT_SUSPEND
;
1111 } else if (test_bit(wIndex
, &ehci
->suspended_ports
)) {
1112 clear_bit(wIndex
, &ehci
->suspended_ports
);
1113 clear_bit(wIndex
, &ehci
->resuming_ports
);
1114 ehci
->reset_done
[wIndex
] = 0;
1116 set_bit(wIndex
, &ehci
->port_c_suspend
);
1117 usb_hcd_end_port_resume(&hcd
->self
, wIndex
);
1121 status
|= USB_PORT_STAT_OVERCURRENT
;
1122 if (temp
& PORT_RESET
)
1123 status
|= USB_PORT_STAT_RESET
;
1124 if (temp
& PORT_POWER
)
1125 status
|= USB_PORT_STAT_POWER
;
1126 if (test_bit(wIndex
, &ehci
->port_c_suspend
))
1127 status
|= USB_PORT_STAT_C_SUSPEND
<< 16;
1129 if (status
& ~0xffff) /* only if wPortChange is interesting */
1130 dbg_port(ehci
, "GetStatus", wIndex
+ 1, temp
);
1131 put_unaligned_le32(status
, buf
);
1135 case C_HUB_LOCAL_POWER
:
1136 case C_HUB_OVER_CURRENT
:
1137 /* no hub-wide feature/status flags */
1143 case SetPortFeature
:
1144 selector
= wIndex
>> 8;
1146 if (unlikely(ehci
->debug
)) {
1147 /* If the debug port is active any port
1148 * feature requests should get denied */
1149 if (wIndex
== HCS_DEBUG_PORT(ehci
->hcs_params
) &&
1150 (readl(&ehci
->debug
->control
) & DBGP_ENABLED
)) {
1155 if (!wIndex
|| wIndex
> ports
)
1158 temp
= ehci_readl(ehci
, status_reg
);
1159 if (temp
& PORT_OWNER
)
1162 temp
&= ~PORT_RWC_BITS
;
1164 case USB_PORT_FEAT_SUSPEND
:
1165 if (ehci
->no_selective_suspend
)
1167 if ((temp
& PORT_PE
) == 0
1168 || (temp
& PORT_RESET
) != 0)
1171 /* After above check the port must be connected.
1172 * Set appropriate bit thus could put phy into low power
1173 * mode if we have tdi_phy_lpm feature
1175 temp
&= ~PORT_WKCONN_E
;
1176 temp
|= PORT_WKDISC_E
| PORT_WKOC_E
;
1177 ehci_writel(ehci
, temp
| PORT_SUSPEND
, status_reg
);
1178 if (ehci
->has_tdi_phy_lpm
) {
1179 spin_unlock_irqrestore(&ehci
->lock
, flags
);
1180 msleep(5);/* 5ms for HCD enter low pwr mode */
1181 spin_lock_irqsave(&ehci
->lock
, flags
);
1182 temp1
= ehci_readl(ehci
, hostpc_reg
);
1183 ehci_writel(ehci
, temp1
| HOSTPC_PHCD
,
1185 temp1
= ehci_readl(ehci
, hostpc_reg
);
1186 ehci_dbg(ehci
, "Port%d phy low pwr mode %s\n",
1187 wIndex
, (temp1
& HOSTPC_PHCD
) ?
1188 "succeeded" : "failed");
1190 set_bit(wIndex
, &ehci
->suspended_ports
);
1192 case USB_PORT_FEAT_POWER
:
1193 if (HCS_PPC(ehci
->hcs_params
)) {
1194 spin_unlock_irqrestore(&ehci
->lock
, flags
);
1195 ehci_port_power(ehci
, wIndex
, true);
1196 spin_lock_irqsave(&ehci
->lock
, flags
);
1199 case USB_PORT_FEAT_RESET
:
1200 if (temp
& (PORT_SUSPEND
|PORT_RESUME
))
1202 /* line status bits may report this as low speed,
1203 * which can be fine if this root hub has a
1204 * transaction translator built in.
1206 if ((temp
& (PORT_PE
|PORT_CONNECT
)) == PORT_CONNECT
1207 && !ehci_is_TDI(ehci
)
1208 && PORT_USB11 (temp
)) {
1210 "port %d low speed --> companion\n",
1218 * caller must wait, then call GetPortStatus
1219 * usb 2.0 spec says 50 ms resets on root
1221 ehci
->reset_done
[wIndex
] = jiffies
1222 + msecs_to_jiffies (50);
1224 ehci_writel(ehci
, temp
, status_reg
);
1227 /* For downstream facing ports (these): one hub port is put
1228 * into test mode according to USB2 11.24.2.13, then the hub
1229 * must be reset (which for root hub now means rmmod+modprobe,
1230 * or else system reboot). See EHCI 2.3.9 and 4.14 for info
1231 * about the EHCI-specific stuff.
1233 case USB_PORT_FEAT_TEST
:
1234 #ifdef CONFIG_USB_HCD_TEST_MODE
1235 if (selector
== EHSET_TEST_SINGLE_STEP_SET_FEATURE
) {
1236 spin_unlock_irqrestore(&ehci
->lock
, flags
);
1237 retval
= ehset_single_step_set_feature(hcd
,
1239 spin_lock_irqsave(&ehci
->lock
, flags
);
1243 if (!selector
|| selector
> 5)
1245 spin_unlock_irqrestore(&ehci
->lock
, flags
);
1247 spin_lock_irqsave(&ehci
->lock
, flags
);
1249 /* Put all enabled ports into suspend */
1252 &ehci
->regs
->port_status
[ports
];
1254 temp
= ehci_readl(ehci
, sreg
) & ~PORT_RWC_BITS
;
1256 ehci_writel(ehci
, temp
| PORT_SUSPEND
,
1260 spin_unlock_irqrestore(&ehci
->lock
, flags
);
1262 spin_lock_irqsave(&ehci
->lock
, flags
);
1264 temp
= ehci_readl(ehci
, status_reg
);
1265 temp
|= selector
<< 16;
1266 ehci_writel(ehci
, temp
, status_reg
);
1272 ehci_readl(ehci
, &ehci
->regs
->command
); /* unblock posted writes */
1277 /* "stall" on error */
1281 spin_unlock_irqrestore (&ehci
->lock
, flags
);
1284 EXPORT_SYMBOL_GPL(ehci_hub_control
);
1286 static void ehci_relinquish_port(struct usb_hcd
*hcd
, int portnum
)
1288 struct ehci_hcd
*ehci
= hcd_to_ehci(hcd
);
1290 if (ehci_is_TDI(ehci
))
1292 set_owner(ehci
, --portnum
, PORT_OWNER
);
1295 static int ehci_port_handed_over(struct usb_hcd
*hcd
, int portnum
)
1297 struct ehci_hcd
*ehci
= hcd_to_ehci(hcd
);
1300 if (ehci_is_TDI(ehci
))
1302 reg
= &ehci
->regs
->port_status
[portnum
- 1];
1303 return ehci_readl(ehci
, reg
) & PORT_OWNER
;
1306 static int ehci_port_power(struct ehci_hcd
*ehci
, int portnum
, bool enable
)
1308 struct usb_hcd
*hcd
= ehci_to_hcd(ehci
);
1309 u32 __iomem
*status_reg
= &ehci
->regs
->port_status
[portnum
];
1310 u32 temp
= ehci_readl(ehci
, status_reg
) & ~PORT_RWC_BITS
;
1313 ehci_writel(ehci
, temp
| PORT_POWER
, status_reg
);
1315 ehci_writel(ehci
, temp
& ~PORT_POWER
, status_reg
);
1317 if (hcd
->driver
->port_power
)
1318 hcd
->driver
->port_power(hcd
, portnum
, enable
);