Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0+
2 : : /*
3 : : * Copyright (C) 2001-2004 by David Brownell
4 : : */
5 : :
6 : : /* this file is part of ehci-hcd.c */
7 : :
8 : : /*-------------------------------------------------------------------------*/
9 : :
10 : : /*
11 : : * EHCI Root Hub ... the nonsharable stuff
12 : : *
13 : : * Registers don't need cpu_to_le32, that happens transparently
14 : : */
15 : :
16 : : /*-------------------------------------------------------------------------*/
17 : : #include <linux/usb/otg.h>
18 : :
19 : : #define PORT_WAKE_BITS (PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E)
20 : :
21 : : #ifdef CONFIG_PM
22 : :
23 : : static void unlink_empty_async_suspended(struct ehci_hcd *ehci);
24 : :
25 : 0 : static int persist_enabled_on_companion(struct usb_device *udev, void *unused)
26 : : {
27 [ # # # # ]: 0 : return !udev->maxchild && udev->persist_enabled &&
28 [ # # ]: 0 : udev->bus->root_hub->speed < USB_SPEED_HIGH;
29 : : }
30 : :
31 : : /* After a power loss, ports that were owned by the companion must be
32 : : * reset so that the companion can still own them.
33 : : */
34 : 0 : static void ehci_handover_companion_ports(struct ehci_hcd *ehci)
35 : : {
36 : 0 : u32 __iomem *reg;
37 : 0 : u32 status;
38 : 0 : int port;
39 : 0 : __le32 buf;
40 [ # # ]: 0 : struct usb_hcd *hcd = ehci_to_hcd(ehci);
41 : :
42 [ # # ]: 0 : if (!ehci->owned_ports)
43 : 0 : return;
44 : :
45 : : /*
46 : : * USB 1.1 devices are mostly HIDs, which don't need to persist across
47 : : * suspends. If we ensure that none of our companion's devices have
48 : : * persist_enabled (by looking through all USB 1.1 buses in the system),
49 : : * we can skip this and avoid slowing resume down. Devices without
50 : : * persist will just get reenumerated shortly after resume anyway.
51 : : */
52 [ # # ]: 0 : if (!usb_for_each_dev(NULL, persist_enabled_on_companion))
53 : : return;
54 : :
55 : : /* Make sure the ports are powered */
56 : 0 : port = HCS_N_PORTS(ehci->hcs_params);
57 [ # # ]: 0 : while (port--) {
58 [ # # ]: 0 : if (test_bit(port, &ehci->owned_ports)) {
59 : 0 : reg = &ehci->regs->port_status[port];
60 : 0 : status = ehci_readl(ehci, reg) & ~PORT_RWC_BITS;
61 [ # # ]: 0 : if (!(status & PORT_POWER))
62 : 0 : ehci_port_power(ehci, port, true);
63 : : }
64 : : }
65 : :
66 : : /* Give the connections some time to appear */
67 : 0 : msleep(20);
68 : :
69 : 0 : spin_lock_irq(&ehci->lock);
70 : 0 : port = HCS_N_PORTS(ehci->hcs_params);
71 [ # # ]: 0 : while (port--) {
72 [ # # ]: 0 : if (test_bit(port, &ehci->owned_ports)) {
73 : 0 : reg = &ehci->regs->port_status[port];
74 : 0 : status = ehci_readl(ehci, reg) & ~PORT_RWC_BITS;
75 : :
76 : : /* Port already owned by companion? */
77 [ # # ]: 0 : if (status & PORT_OWNER)
78 : 0 : clear_bit(port, &ehci->owned_ports);
79 [ # # ]: 0 : else if (test_bit(port, &ehci->companion_ports))
80 [ # # ]: 0 : ehci_writel(ehci, status & ~PORT_PE, reg);
81 : : else {
82 : 0 : spin_unlock_irq(&ehci->lock);
83 : 0 : ehci_hub_control(hcd, SetPortFeature,
84 : 0 : USB_PORT_FEAT_RESET, port + 1,
85 : : NULL, 0);
86 : 0 : spin_lock_irq(&ehci->lock);
87 : : }
88 : : }
89 : : }
90 : 0 : spin_unlock_irq(&ehci->lock);
91 : :
92 [ # # ]: 0 : if (!ehci->owned_ports)
93 : : return;
94 : 0 : msleep(90); /* Wait for resets to complete */
95 : :
96 : 0 : spin_lock_irq(&ehci->lock);
97 : 0 : port = HCS_N_PORTS(ehci->hcs_params);
98 [ # # ]: 0 : while (port--) {
99 [ # # ]: 0 : if (test_bit(port, &ehci->owned_ports)) {
100 : 0 : spin_unlock_irq(&ehci->lock);
101 : 0 : ehci_hub_control(hcd, GetPortStatus,
102 : 0 : 0, port + 1,
103 : : (char *) &buf, sizeof(buf));
104 : 0 : spin_lock_irq(&ehci->lock);
105 : :
106 : : /* The companion should now own the port,
107 : : * but if something went wrong the port must not
108 : : * remain enabled.
109 : : */
110 : 0 : reg = &ehci->regs->port_status[port];
111 : 0 : status = ehci_readl(ehci, reg) & ~PORT_RWC_BITS;
112 [ # # ]: 0 : if (status & PORT_OWNER)
113 [ # # ]: 0 : ehci_writel(ehci, status | PORT_CSC, reg);
114 : : else {
115 : 0 : ehci_dbg(ehci, "failed handover port %d: %x\n",
116 : : port + 1, status);
117 [ # # ]: 0 : ehci_writel(ehci, status & ~PORT_PE, reg);
118 : : }
119 : : }
120 : : }
121 : :
122 : 0 : ehci->owned_ports = 0;
123 : 0 : spin_unlock_irq(&ehci->lock);
124 : : }
125 : :
126 : 0 : static int ehci_port_change(struct ehci_hcd *ehci)
127 : : {
128 : 0 : int i = HCS_N_PORTS(ehci->hcs_params);
129 : :
130 : : /* First check if the controller indicates a change event */
131 : :
132 [ # # ]: 0 : if (ehci_readl(ehci, &ehci->regs->status) & STS_PCD)
133 : : return 1;
134 : :
135 : : /*
136 : : * Not all controllers appear to update this while going from D3 to D0,
137 : : * so check the individual port status registers as well
138 : : */
139 : :
140 [ # # ]: 0 : while (i--)
141 [ # # ]: 0 : if (ehci_readl(ehci, &ehci->regs->port_status[i]) & PORT_CSC)
142 : : return 1;
143 : :
144 : : return 0;
145 : : }
146 : :
147 : 0 : void ehci_adjust_port_wakeup_flags(struct ehci_hcd *ehci,
148 : : bool suspending, bool do_wakeup)
149 : : {
150 : 0 : int port;
151 : 0 : u32 temp;
152 : :
153 : : /* If remote wakeup is enabled for the root hub but disabled
154 : : * for the controller, we must adjust all the port wakeup flags
155 : : * when the controller is suspended or resumed. In all other
156 : : * cases they don't need to be changed.
157 : : */
158 [ # # # # ]: 0 : if (!ehci_to_hcd(ehci)->self.root_hub->do_remote_wakeup || do_wakeup)
159 : : return;
160 : :
161 : 0 : spin_lock_irq(&ehci->lock);
162 : :
163 : : /* clear phy low-power mode before changing wakeup flags */
164 [ # # ]: 0 : if (ehci->has_tdi_phy_lpm) {
165 : 0 : port = HCS_N_PORTS(ehci->hcs_params);
166 [ # # ]: 0 : while (port--) {
167 : 0 : u32 __iomem *hostpc_reg = &ehci->regs->hostpc[port];
168 : :
169 : 0 : temp = ehci_readl(ehci, hostpc_reg);
170 [ # # ]: 0 : ehci_writel(ehci, temp & ~HOSTPC_PHCD, hostpc_reg);
171 : : }
172 : 0 : spin_unlock_irq(&ehci->lock);
173 : 0 : msleep(5);
174 : 0 : spin_lock_irq(&ehci->lock);
175 : : }
176 : :
177 : 0 : port = HCS_N_PORTS(ehci->hcs_params);
178 [ # # ]: 0 : while (port--) {
179 : 0 : u32 __iomem *reg = &ehci->regs->port_status[port];
180 : 0 : u32 t1 = ehci_readl(ehci, reg) & ~PORT_RWC_BITS;
181 : 0 : u32 t2 = t1 & ~PORT_WAKE_BITS;
182 : :
183 : : /* If we are suspending the controller, clear the flags.
184 : : * If we are resuming the controller, set the wakeup flags.
185 : : */
186 [ # # ]: 0 : if (!suspending) {
187 [ # # ]: 0 : if (t1 & PORT_CONNECT)
188 : 0 : t2 |= PORT_WKOC_E | PORT_WKDISC_E;
189 : : else
190 : 0 : t2 |= PORT_WKOC_E | PORT_WKCONN_E;
191 : : }
192 [ # # ]: 0 : ehci_writel(ehci, t2, reg);
193 : : }
194 : :
195 : : /* enter phy low-power mode again */
196 [ # # ]: 0 : if (ehci->has_tdi_phy_lpm) {
197 : 0 : port = HCS_N_PORTS(ehci->hcs_params);
198 [ # # ]: 0 : while (port--) {
199 : 0 : u32 __iomem *hostpc_reg = &ehci->regs->hostpc[port];
200 : :
201 : 0 : temp = ehci_readl(ehci, hostpc_reg);
202 [ # # ]: 0 : ehci_writel(ehci, temp | HOSTPC_PHCD, hostpc_reg);
203 : : }
204 : : }
205 : :
206 : : /* Does the root hub have a port wakeup pending? */
207 [ # # # # ]: 0 : if (!suspending && ehci_port_change(ehci))
208 : 0 : usb_hcd_resume_root_hub(ehci_to_hcd(ehci));
209 : :
210 : 0 : spin_unlock_irq(&ehci->lock);
211 : : }
212 : : EXPORT_SYMBOL_GPL(ehci_adjust_port_wakeup_flags);
213 : :
214 : 0 : static int ehci_bus_suspend (struct usb_hcd *hcd)
215 : : {
216 [ # # ]: 0 : struct ehci_hcd *ehci = hcd_to_ehci (hcd);
217 : 0 : int port;
218 : 0 : int mask;
219 : 0 : int changed;
220 : 0 : bool fs_idle_delay;
221 : :
222 : 0 : ehci_dbg(ehci, "suspend root hub\n");
223 : :
224 [ # # ]: 0 : if (time_before (jiffies, ehci->next_statechange))
225 : 0 : msleep(5);
226 : :
227 : : /* stop the schedules */
228 : 0 : ehci_quiesce(ehci);
229 : :
230 : 0 : spin_lock_irq (&ehci->lock);
231 [ # # ]: 0 : if (ehci->rh_state < EHCI_RH_RUNNING)
232 : 0 : goto done;
233 : :
234 : : /* Once the controller is stopped, port resumes that are already
235 : : * in progress won't complete. Hence if remote wakeup is enabled
236 : : * for the root hub and any ports are in the middle of a resume or
237 : : * remote wakeup, we must fail the suspend.
238 : : */
239 [ # # ]: 0 : if (hcd->self.root_hub->do_remote_wakeup) {
240 [ # # ]: 0 : if (ehci->resuming_ports) {
241 : 0 : spin_unlock_irq(&ehci->lock);
242 : 0 : ehci_dbg(ehci, "suspend failed because a port is resuming\n");
243 : 0 : return -EBUSY;
244 : : }
245 : : }
246 : :
247 : : /* Unlike other USB host controller types, EHCI doesn't have
248 : : * any notion of "global" or bus-wide suspend. The driver has
249 : : * to manually suspend all the active unsuspended ports, and
250 : : * then manually resume them in the bus_resume() routine.
251 : : */
252 : 0 : ehci->bus_suspended = 0;
253 : 0 : ehci->owned_ports = 0;
254 : 0 : changed = 0;
255 : 0 : fs_idle_delay = false;
256 : 0 : port = HCS_N_PORTS(ehci->hcs_params);
257 [ # # ]: 0 : while (port--) {
258 : 0 : u32 __iomem *reg = &ehci->regs->port_status [port];
259 : 0 : u32 t1 = ehci_readl(ehci, reg) & ~PORT_RWC_BITS;
260 : 0 : u32 t2 = t1 & ~PORT_WAKE_BITS;
261 : :
262 : : /* keep track of which ports we suspend */
263 [ # # ]: 0 : if (t1 & PORT_OWNER)
264 : 0 : set_bit(port, &ehci->owned_ports);
265 [ # # ]: 0 : else if ((t1 & PORT_PE) && !(t1 & PORT_SUSPEND)) {
266 : 0 : t2 |= PORT_SUSPEND;
267 : 0 : set_bit(port, &ehci->bus_suspended);
268 : : }
269 : :
270 : : /* enable remote wakeup on all ports, if told to do so */
271 [ # # ]: 0 : if (hcd->self.root_hub->do_remote_wakeup) {
272 : : /* only enable appropriate wake bits, otherwise the
273 : : * hardware can not go phy low power mode. If a race
274 : : * condition happens here(connection change during bits
275 : : * set), the port change detection will finally fix it.
276 : : */
277 [ # # ]: 0 : if (t1 & PORT_CONNECT)
278 : 0 : t2 |= PORT_WKOC_E | PORT_WKDISC_E;
279 : : else
280 : 0 : t2 |= PORT_WKOC_E | PORT_WKCONN_E;
281 : : }
282 : :
283 [ # # ]: 0 : if (t1 != t2) {
284 : : /*
285 : : * On some controllers, Wake-On-Disconnect will
286 : : * generate false wakeup signals until the bus
287 : : * switches over to full-speed idle. For their
288 : : * sake, add a delay if we need one.
289 : : */
290 [ # # ]: 0 : if ((t2 & PORT_WKDISC_E) &&
291 : : ehci_port_speed(ehci, t2) ==
292 : : USB_PORT_STAT_HIGH_SPEED)
293 : 0 : fs_idle_delay = true;
294 [ # # ]: 0 : ehci_writel(ehci, t2, reg);
295 : : changed = 1;
296 : : }
297 : : }
298 : 0 : spin_unlock_irq(&ehci->lock);
299 : :
300 [ # # # # ]: 0 : if (changed && ehci_has_fsl_susp_errata(ehci))
301 : : /*
302 : : * Wait for at least 10 millisecondes to ensure the controller
303 : : * enter the suspend status before initiating a port resume
304 : : * using the Force Port Resume bit (Not-EHCI compatible).
305 : : */
306 : 0 : usleep_range(10000, 20000);
307 : :
308 [ # # # # : 0 : if ((changed && ehci->has_tdi_phy_lpm) || fs_idle_delay) {
# # ]
309 : : /*
310 : : * Wait for HCD to enter low-power mode or for the bus
311 : : * to switch to full-speed idle.
312 : : */
313 : 0 : usleep_range(5000, 5500);
314 : : }
315 : :
316 [ # # # # ]: 0 : if (changed && ehci->has_tdi_phy_lpm) {
317 : 0 : spin_lock_irq(&ehci->lock);
318 : 0 : port = HCS_N_PORTS(ehci->hcs_params);
319 [ # # ]: 0 : while (port--) {
320 : 0 : u32 __iomem *hostpc_reg = &ehci->regs->hostpc[port];
321 : 0 : u32 t3;
322 : :
323 : 0 : t3 = ehci_readl(ehci, hostpc_reg);
324 [ # # ]: 0 : ehci_writel(ehci, t3 | HOSTPC_PHCD, hostpc_reg);
325 : 0 : t3 = ehci_readl(ehci, hostpc_reg);
326 : 0 : ehci_dbg(ehci, "Port %d phy low-power mode %s\n",
327 : : port, (t3 & HOSTPC_PHCD) ?
328 : : "succeeded" : "failed");
329 : : }
330 : 0 : spin_unlock_irq(&ehci->lock);
331 : : }
332 : :
333 : : /* Apparently some devices need a >= 1-uframe delay here */
334 [ # # ]: 0 : if (ehci->bus_suspended)
335 : 0 : udelay(150);
336 : :
337 : : /* turn off now-idle HC */
338 : 0 : ehci_halt (ehci);
339 : :
340 : 0 : spin_lock_irq(&ehci->lock);
341 [ # # ]: 0 : if (ehci->enabled_hrtimer_events & BIT(EHCI_HRTIMER_POLL_DEAD))
342 : 0 : ehci_handle_controller_death(ehci);
343 [ # # ]: 0 : if (ehci->rh_state != EHCI_RH_RUNNING)
344 : 0 : goto done;
345 : 0 : ehci->rh_state = EHCI_RH_SUSPENDED;
346 : :
347 : 0 : unlink_empty_async_suspended(ehci);
348 : :
349 : : /* Any IAA cycle that started before the suspend is now invalid */
350 : 0 : end_iaa_cycle(ehci);
351 : 0 : ehci_handle_start_intr_unlinks(ehci);
352 : 0 : ehci_handle_intr_unlinks(ehci);
353 : 0 : end_free_itds(ehci);
354 : :
355 : : /* allow remote wakeup */
356 : 0 : mask = INTR_MASK;
357 [ # # ]: 0 : if (!hcd->self.root_hub->do_remote_wakeup)
358 : 0 : mask &= ~STS_PCD;
359 [ # # ]: 0 : ehci_writel(ehci, mask, &ehci->regs->intr_enable);
360 : 0 : ehci_readl(ehci, &ehci->regs->intr_enable);
361 : :
362 : 0 : done:
363 : 0 : ehci->next_statechange = jiffies + msecs_to_jiffies(10);
364 : 0 : ehci->enabled_hrtimer_events = 0;
365 : 0 : ehci->next_hrtimer_event = EHCI_HRTIMER_NO_EVENT;
366 : 0 : spin_unlock_irq (&ehci->lock);
367 : :
368 : 0 : hrtimer_cancel(&ehci->hrtimer);
369 : 0 : return 0;
370 : : }
371 : :
372 : :
373 : : /* caller has locked the root hub, and should reset/reinit on error */
374 : 0 : static int ehci_bus_resume (struct usb_hcd *hcd)
375 : : {
376 [ # # ]: 0 : struct ehci_hcd *ehci = hcd_to_ehci (hcd);
377 : 0 : u32 temp;
378 : 0 : u32 power_okay;
379 : 0 : int i;
380 : 0 : unsigned long resume_needed = 0;
381 : :
382 [ # # ]: 0 : if (time_before (jiffies, ehci->next_statechange))
383 : 0 : msleep(5);
384 : 0 : spin_lock_irq (&ehci->lock);
385 [ # # # # ]: 0 : if (!HCD_HW_ACCESSIBLE(hcd) || ehci->shutdown)
386 : 0 : goto shutdown;
387 : :
388 [ # # ]: 0 : if (unlikely(ehci->debug)) {
389 [ # # ]: 0 : if (!dbgp_reset_prep(hcd))
390 : 0 : ehci->debug = NULL;
391 : : else
392 : 0 : dbgp_external_startup(hcd);
393 : : }
394 : :
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.
400 : : */
401 : 0 : power_okay = ehci_readl(ehci, &ehci->regs->intr_enable);
402 : 0 : ehci_dbg(ehci, "resume root hub%s\n",
403 : : power_okay ? "" : " after power loss");
404 : :
405 : : /* at least some APM implementations will try to deliver
406 : : * IRQs right away, so delay them until we're ready.
407 : : */
408 [ # # ]: 0 : ehci_writel(ehci, 0, &ehci->regs->intr_enable);
409 : :
410 : : /* re-init operational registers */
411 [ # # ]: 0 : ehci_writel(ehci, 0, &ehci->regs->segment);
412 [ # # ]: 0 : ehci_writel(ehci, ehci->periodic_dma, &ehci->regs->frame_list);
413 [ # # ]: 0 : ehci_writel(ehci, (u32) ehci->async->qh_dma, &ehci->regs->async_next);
414 : :
415 : : /* restore CMD_RUN, framelist size, and irq threshold */
416 : 0 : ehci->command |= CMD_RUN;
417 [ # # ]: 0 : ehci_writel(ehci, ehci->command, &ehci->regs->command);
418 : 0 : ehci->rh_state = EHCI_RH_RUNNING;
419 : :
420 : : /*
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.
424 : : */
425 : 0 : i = HCS_N_PORTS(ehci->hcs_params);
426 [ # # ]: 0 : while (i--) {
427 : 0 : temp = ehci_readl(ehci, &ehci->regs->port_status[i]);
428 [ # # ]: 0 : if ((temp & PORT_PE) &&
429 : : !(temp & (PORT_SUSPEND | PORT_RESUME))) {
430 : 0 : ehci_dbg(ehci, "Port status(0x%x) is wrong\n", temp);
431 : 0 : spin_unlock_irq(&ehci->lock);
432 : 0 : msleep(8);
433 : 0 : spin_lock_irq(&ehci->lock);
434 : : break;
435 : : }
436 : : }
437 : :
438 [ # # ]: 0 : if (ehci->shutdown)
439 : 0 : goto shutdown;
440 : :
441 : : /* clear phy low-power mode before resume */
442 [ # # # # ]: 0 : if (ehci->bus_suspended && ehci->has_tdi_phy_lpm) {
443 : 0 : i = HCS_N_PORTS(ehci->hcs_params);
444 [ # # ]: 0 : while (i--) {
445 [ # # ]: 0 : if (test_bit(i, &ehci->bus_suspended)) {
446 : 0 : u32 __iomem *hostpc_reg =
447 : 0 : &ehci->regs->hostpc[i];
448 : :
449 : 0 : temp = ehci_readl(ehci, hostpc_reg);
450 [ # # ]: 0 : ehci_writel(ehci, temp & ~HOSTPC_PHCD,
451 : : hostpc_reg);
452 : : }
453 : : }
454 : 0 : spin_unlock_irq(&ehci->lock);
455 : 0 : msleep(5);
456 : 0 : spin_lock_irq(&ehci->lock);
457 [ # # ]: 0 : if (ehci->shutdown)
458 : 0 : goto shutdown;
459 : : }
460 : :
461 : : /* manually resume the ports we suspended during bus_suspend() */
462 : 0 : i = HCS_N_PORTS (ehci->hcs_params);
463 [ # # ]: 0 : while (i--) {
464 : 0 : temp = ehci_readl(ehci, &ehci->regs->port_status [i]);
465 : 0 : temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
466 [ # # ]: 0 : if (test_bit(i, &ehci->bus_suspended) &&
467 [ # # ]: 0 : (temp & PORT_SUSPEND)) {
468 : 0 : temp |= PORT_RESUME;
469 : 0 : set_bit(i, &resume_needed);
470 : : }
471 [ # # ]: 0 : ehci_writel(ehci, temp, &ehci->regs->port_status [i]);
472 : : }
473 : :
474 : : /*
475 : : * msleep for USB_RESUME_TIMEOUT ms only if code is trying to resume
476 : : * port
477 : : */
478 [ # # ]: 0 : if (resume_needed) {
479 : 0 : spin_unlock_irq(&ehci->lock);
480 : 0 : msleep(USB_RESUME_TIMEOUT);
481 : 0 : spin_lock_irq(&ehci->lock);
482 [ # # ]: 0 : if (ehci->shutdown)
483 : 0 : goto shutdown;
484 : : }
485 : :
486 : 0 : i = HCS_N_PORTS (ehci->hcs_params);
487 [ # # ]: 0 : while (i--) {
488 : 0 : temp = ehci_readl(ehci, &ehci->regs->port_status [i]);
489 [ # # ]: 0 : if (test_bit(i, &resume_needed)) {
490 : 0 : temp &= ~(PORT_RWC_BITS | PORT_SUSPEND | PORT_RESUME);
491 [ # # ]: 0 : ehci_writel(ehci, temp, &ehci->regs->port_status [i]);
492 : : }
493 : : }
494 : :
495 : 0 : ehci->next_statechange = jiffies + msecs_to_jiffies(5);
496 : 0 : spin_unlock_irq(&ehci->lock);
497 : :
498 : 0 : ehci_handover_companion_ports(ehci);
499 : :
500 : : /* Now we can safely re-enable irqs */
501 : 0 : spin_lock_irq(&ehci->lock);
502 [ # # ]: 0 : if (ehci->shutdown)
503 : 0 : goto shutdown;
504 [ # # ]: 0 : ehci_writel(ehci, INTR_MASK, &ehci->regs->intr_enable);
505 : 0 : (void) ehci_readl(ehci, &ehci->regs->intr_enable);
506 : 0 : spin_unlock_irq(&ehci->lock);
507 : :
508 : 0 : return 0;
509 : :
510 : 0 : shutdown:
511 : 0 : spin_unlock_irq(&ehci->lock);
512 : 0 : return -ESHUTDOWN;
513 : : }
514 : :
515 : 0 : static unsigned long ehci_get_resuming_ports(struct usb_hcd *hcd)
516 : : {
517 : 0 : struct ehci_hcd *ehci = hcd_to_ehci(hcd);
518 : :
519 : 0 : return ehci->resuming_ports;
520 : : }
521 : :
522 : : #else
523 : :
524 : : #define ehci_bus_suspend NULL
525 : : #define ehci_bus_resume NULL
526 : : #define ehci_get_resuming_ports NULL
527 : :
528 : : #endif /* CONFIG_PM */
529 : :
530 : : /*-------------------------------------------------------------------------*/
531 : :
532 : : /*
533 : : * Sets the owner of a port
534 : : */
535 : 0 : static void set_owner(struct ehci_hcd *ehci, int portnum, int new_owner)
536 : : {
537 : 0 : u32 __iomem *status_reg;
538 : 0 : u32 port_status;
539 : 0 : int try;
540 : :
541 : 0 : status_reg = &ehci->regs->port_status[portnum];
542 : :
543 : : /*
544 : : * The controller won't set the OWNER bit if the port is
545 : : * enabled, so this loop will sometimes require at least two
546 : : * iterations: one to disable the port and one to set OWNER.
547 : : */
548 [ # # ]: 0 : for (try = 4; try > 0; --try) {
549 : 0 : spin_lock_irq(&ehci->lock);
550 : 0 : port_status = ehci_readl(ehci, status_reg);
551 [ # # ]: 0 : if ((port_status & PORT_OWNER) == new_owner
552 [ # # ]: 0 : || (port_status & (PORT_OWNER | PORT_CONNECT))
553 : : == 0)
554 : : try = 0;
555 : : else {
556 : 0 : port_status ^= PORT_OWNER;
557 : 0 : port_status &= ~(PORT_PE | PORT_RWC_BITS);
558 [ # # ]: 0 : ehci_writel(ehci, port_status, status_reg);
559 : : }
560 : 0 : spin_unlock_irq(&ehci->lock);
561 [ # # ]: 0 : if (try > 1)
562 : 0 : msleep(5);
563 : : }
564 : 0 : }
565 : :
566 : : /*-------------------------------------------------------------------------*/
567 : :
568 : 0 : static int check_reset_complete (
569 : : struct ehci_hcd *ehci,
570 : : int index,
571 : : u32 __iomem *status_reg,
572 : : int port_status
573 : : ) {
574 : 0 : if (!(port_status & PORT_CONNECT))
575 : : return port_status;
576 : :
577 : : /* if reset finished and it's still not enabled -- handoff */
578 [ # # ]: 0 : if (!(port_status & PORT_PE)) {
579 : :
580 : : /* with integrated TT, there's nobody to hand it to! */
581 : 0 : if (ehci_is_TDI(ehci)) {
582 : : ehci_dbg (ehci,
583 : : "Failed to enable port %d on root hub TT\n",
584 : : index+1);
585 : : return port_status;
586 : : }
587 : :
588 : 0 : ehci_dbg (ehci, "port %d full speed --> companion\n",
589 : : index + 1);
590 : :
591 : : // what happens if HCS_N_CC(params) == 0 ?
592 : 0 : port_status |= PORT_OWNER;
593 : 0 : port_status &= ~PORT_RWC_BITS;
594 [ # # ]: 0 : ehci_writel(ehci, port_status, status_reg);
595 : :
596 : : /* ensure 440EPX ohci controller state is operational */
597 : : if (ehci->has_amcc_usb23)
598 : : set_ohci_hcfs(ehci, 1);
599 : : } else {
600 : : ehci_dbg(ehci, "port %d reset complete, port enabled\n",
601 : : index + 1);
602 : : /* ensure 440EPx ohci controller state is suspended */
603 : : if (ehci->has_amcc_usb23)
604 : : set_ohci_hcfs(ehci, 0);
605 : : }
606 : :
607 : : return port_status;
608 : : }
609 : :
610 : : /*-------------------------------------------------------------------------*/
611 : :
612 : :
613 : : /* build "status change" packet (one or two bytes) from HC registers */
614 : :
615 : : static int
616 : 0 : ehci_hub_status_data (struct usb_hcd *hcd, char *buf)
617 : : {
618 [ # # ]: 0 : struct ehci_hcd *ehci = hcd_to_ehci (hcd);
619 : 0 : u32 temp, status;
620 : 0 : u32 mask;
621 : 0 : int ports, i, retval = 1;
622 : 0 : unsigned long flags;
623 : 0 : u32 ppcd = ~0;
624 : :
625 : : /* init status to no-changes */
626 : 0 : buf [0] = 0;
627 : 0 : ports = HCS_N_PORTS (ehci->hcs_params);
628 [ # # ]: 0 : if (ports > 7) {
629 : 0 : buf [1] = 0;
630 : 0 : retval++;
631 : : }
632 : :
633 : : /* Inform the core about resumes-in-progress by returning
634 : : * a non-zero value even if there are no status changes.
635 : : */
636 : 0 : status = ehci->resuming_ports;
637 : :
638 : : /* Some boards (mostly VIA?) report bogus overcurrent indications,
639 : : * causing massive log spam unless we completely ignore them. It
640 : : * may be relevant that VIA VT8235 controllers, where PORT_POWER is
641 : : * always set, seem to clear PORT_OCC and PORT_CSC when writing to
642 : : * PORT_POWER; that's surprising, but maybe within-spec.
643 : : */
644 [ # # ]: 0 : if (!ignore_oc)
645 : : mask = PORT_CSC | PORT_PEC | PORT_OCC;
646 : : else
647 : 0 : mask = PORT_CSC | PORT_PEC;
648 : : // PORT_RESUME from hardware ~= PORT_STAT_C_SUSPEND
649 : :
650 : : /* no hub change reports (bit 0) for now (power, ...) */
651 : :
652 : : /* port N changes (bit N)? */
653 : 0 : spin_lock_irqsave (&ehci->lock, flags);
654 : :
655 : : /* get per-port change detect bits */
656 [ # # ]: 0 : if (ehci->has_ppcd)
657 : 0 : ppcd = ehci_readl(ehci, &ehci->regs->status) >> 16;
658 : :
659 [ # # ]: 0 : for (i = 0; i < ports; i++) {
660 : : /* leverage per-port change bits feature */
661 [ # # ]: 0 : if (ppcd & (1 << i))
662 : 0 : temp = ehci_readl(ehci, &ehci->regs->port_status[i]);
663 : : else
664 : : temp = 0;
665 : :
666 : : /*
667 : : * Return status information even for ports with OWNER set.
668 : : * Otherwise hub_wq wouldn't see the disconnect event when a
669 : : * high-speed device is switched over to the companion
670 : : * controller by the user.
671 : : */
672 : :
673 [ # # # # ]: 0 : if ((temp & mask) != 0 || test_bit(i, &ehci->port_c_suspend)
674 [ # # # # ]: 0 : || (ehci->reset_done[i] && time_after_eq(
675 : : jiffies, ehci->reset_done[i]))) {
676 [ # # ]: 0 : if (i < 7)
677 : 0 : buf [0] |= 1 << (i + 1);
678 : : else
679 : 0 : buf [1] |= 1 << (i - 7);
680 : : status = STS_PCD;
681 : : }
682 : : }
683 : :
684 : : /* If a resume is in progress, make sure it can finish */
685 [ # # ]: 0 : if (ehci->resuming_ports)
686 : 0 : mod_timer(&hcd->rh_timer, jiffies + msecs_to_jiffies(25));
687 : :
688 : 0 : spin_unlock_irqrestore (&ehci->lock, flags);
689 [ # # ]: 0 : return status ? retval : 0;
690 : : }
691 : :
692 : : /*-------------------------------------------------------------------------*/
693 : :
694 : : static void
695 : : ehci_hub_descriptor (
696 : : struct ehci_hcd *ehci,
697 : : struct usb_hub_descriptor *desc
698 : : ) {
699 : : int ports = HCS_N_PORTS (ehci->hcs_params);
700 : : u16 temp;
701 : :
702 : : desc->bDescriptorType = USB_DT_HUB;
703 : : desc->bPwrOn2PwrGood = 10; /* ehci 1.0, 2.3.9 says 20ms max */
704 : : desc->bHubContrCurrent = 0;
705 : :
706 : : desc->bNbrPorts = ports;
707 : : temp = 1 + (ports / 8);
708 : : desc->bDescLength = 7 + 2 * temp;
709 : :
710 : : /* two bitmaps: ports removable, and usb 1.0 legacy PortPwrCtrlMask */
711 : : memset(&desc->u.hs.DeviceRemovable[0], 0, temp);
712 : : memset(&desc->u.hs.DeviceRemovable[temp], 0xff, temp);
713 : :
714 : : temp = HUB_CHAR_INDV_PORT_OCPM; /* per-port overcurrent reporting */
715 : : if (HCS_PPC (ehci->hcs_params))
716 : : temp |= HUB_CHAR_INDV_PORT_LPSM; /* per-port power control */
717 : : else
718 : : temp |= HUB_CHAR_NO_LPSM; /* no power switching */
719 : : #if 0
720 : : // re-enable when we support USB_PORT_FEAT_INDICATOR below.
721 : : if (HCS_INDICATOR (ehci->hcs_params))
722 : : temp |= HUB_CHAR_PORTIND; /* per-port indicators (LEDs) */
723 : : #endif
724 : : desc->wHubCharacteristics = cpu_to_le16(temp);
725 : : }
726 : :
727 : : /*-------------------------------------------------------------------------*/
728 : : #ifdef CONFIG_USB_HCD_TEST_MODE
729 : :
730 : : #define EHSET_TEST_SINGLE_STEP_SET_FEATURE 0x06
731 : :
732 : : static void usb_ehset_completion(struct urb *urb)
733 : : {
734 : : struct completion *done = urb->context;
735 : :
736 : : complete(done);
737 : : }
738 : : static int submit_single_step_set_feature(
739 : : struct usb_hcd *hcd,
740 : : struct urb *urb,
741 : : int is_setup
742 : : );
743 : :
744 : : /*
745 : : * Allocate and initialize a control URB. This request will be used by the
746 : : * EHSET SINGLE_STEP_SET_FEATURE test in which the DATA and STATUS stages
747 : : * of the GetDescriptor request are sent 15 seconds after the SETUP stage.
748 : : * Return NULL if failed.
749 : : */
750 : : static struct urb *request_single_step_set_feature_urb(
751 : : struct usb_device *udev,
752 : : void *dr,
753 : : void *buf,
754 : : struct completion *done
755 : : ) {
756 : : struct urb *urb;
757 : : struct usb_hcd *hcd = bus_to_hcd(udev->bus);
758 : : struct usb_host_endpoint *ep;
759 : :
760 : : urb = usb_alloc_urb(0, GFP_KERNEL);
761 : : if (!urb)
762 : : return NULL;
763 : :
764 : : urb->pipe = usb_rcvctrlpipe(udev, 0);
765 : : ep = (usb_pipein(urb->pipe) ? udev->ep_in : udev->ep_out)
766 : : [usb_pipeendpoint(urb->pipe)];
767 : : if (!ep) {
768 : : usb_free_urb(urb);
769 : : return NULL;
770 : : }
771 : :
772 : : urb->ep = ep;
773 : : urb->dev = udev;
774 : : urb->setup_packet = (void *)dr;
775 : : urb->transfer_buffer = buf;
776 : : urb->transfer_buffer_length = USB_DT_DEVICE_SIZE;
777 : : urb->complete = usb_ehset_completion;
778 : : urb->status = -EINPROGRESS;
779 : : urb->actual_length = 0;
780 : : urb->transfer_flags = URB_DIR_IN;
781 : : usb_get_urb(urb);
782 : : atomic_inc(&urb->use_count);
783 : : atomic_inc(&urb->dev->urbnum);
784 : : urb->setup_dma = dma_map_single(
785 : : hcd->self.sysdev,
786 : : urb->setup_packet,
787 : : sizeof(struct usb_ctrlrequest),
788 : : DMA_TO_DEVICE);
789 : : urb->transfer_dma = dma_map_single(
790 : : hcd->self.sysdev,
791 : : urb->transfer_buffer,
792 : : urb->transfer_buffer_length,
793 : : DMA_FROM_DEVICE);
794 : : urb->context = done;
795 : : return urb;
796 : : }
797 : :
798 : : static int ehset_single_step_set_feature(struct usb_hcd *hcd, int port)
799 : : {
800 : : int retval = -ENOMEM;
801 : : struct usb_ctrlrequest *dr;
802 : : struct urb *urb;
803 : : struct usb_device *udev;
804 : : struct ehci_hcd *ehci = hcd_to_ehci(hcd);
805 : : struct usb_device_descriptor *buf;
806 : : DECLARE_COMPLETION_ONSTACK(done);
807 : :
808 : : /* Obtain udev of the rhub's child port */
809 : : udev = usb_hub_find_child(hcd->self.root_hub, port);
810 : : if (!udev) {
811 : : ehci_err(ehci, "No device attached to the RootHub\n");
812 : : return -ENODEV;
813 : : }
814 : : buf = kmalloc(USB_DT_DEVICE_SIZE, GFP_KERNEL);
815 : : if (!buf)
816 : : return -ENOMEM;
817 : :
818 : : dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL);
819 : : if (!dr) {
820 : : kfree(buf);
821 : : return -ENOMEM;
822 : : }
823 : :
824 : : /* Fill Setup packet for GetDescriptor */
825 : : dr->bRequestType = USB_DIR_IN;
826 : : dr->bRequest = USB_REQ_GET_DESCRIPTOR;
827 : : dr->wValue = cpu_to_le16(USB_DT_DEVICE << 8);
828 : : dr->wIndex = 0;
829 : : dr->wLength = cpu_to_le16(USB_DT_DEVICE_SIZE);
830 : : urb = request_single_step_set_feature_urb(udev, dr, buf, &done);
831 : : if (!urb)
832 : : goto cleanup;
833 : :
834 : : /* Submit just the SETUP stage */
835 : : retval = submit_single_step_set_feature(hcd, urb, 1);
836 : : if (retval)
837 : : goto out1;
838 : : if (!wait_for_completion_timeout(&done, msecs_to_jiffies(2000))) {
839 : : usb_kill_urb(urb);
840 : : retval = -ETIMEDOUT;
841 : : ehci_err(ehci, "%s SETUP stage timed out on ep0\n", __func__);
842 : : goto out1;
843 : : }
844 : : msleep(15 * 1000);
845 : :
846 : : /* Complete remaining DATA and STATUS stages using the same URB */
847 : : urb->status = -EINPROGRESS;
848 : : usb_get_urb(urb);
849 : : atomic_inc(&urb->use_count);
850 : : atomic_inc(&urb->dev->urbnum);
851 : : retval = submit_single_step_set_feature(hcd, urb, 0);
852 : : if (!retval && !wait_for_completion_timeout(&done,
853 : : msecs_to_jiffies(2000))) {
854 : : usb_kill_urb(urb);
855 : : retval = -ETIMEDOUT;
856 : : ehci_err(ehci, "%s IN stage timed out on ep0\n", __func__);
857 : : }
858 : : out1:
859 : : usb_free_urb(urb);
860 : : cleanup:
861 : : kfree(dr);
862 : : kfree(buf);
863 : : return retval;
864 : : }
865 : : #endif /* CONFIG_USB_HCD_TEST_MODE */
866 : : /*-------------------------------------------------------------------------*/
867 : :
868 : 0 : int ehci_hub_control(
869 : : struct usb_hcd *hcd,
870 : : u16 typeReq,
871 : : u16 wValue,
872 : : u16 wIndex,
873 : : char *buf,
874 : : u16 wLength
875 : : ) {
876 : 0 : struct ehci_hcd *ehci = hcd_to_ehci (hcd);
877 : 0 : int ports = HCS_N_PORTS (ehci->hcs_params);
878 : 0 : u32 __iomem *status_reg, *hostpc_reg;
879 : 0 : u32 temp, temp1, status;
880 : 0 : unsigned long flags;
881 : 0 : int retval = 0;
882 : 0 : unsigned selector;
883 : :
884 : : /*
885 : : * Avoid underflow while calculating (wIndex & 0xff) - 1.
886 : : * The compiler might deduce that wIndex can never be 0 and then
887 : : * optimize away the tests for !wIndex below.
888 : : */
889 : 0 : temp = wIndex & 0xff;
890 : 0 : temp -= (temp > 0);
891 : 0 : status_reg = &ehci->regs->port_status[temp];
892 : 0 : hostpc_reg = &ehci->regs->hostpc[temp];
893 : :
894 : : /*
895 : : * FIXME: support SetPortFeatures USB_PORT_FEAT_INDICATOR.
896 : : * HCS_INDICATOR may say we can change LEDs to off/amber/green.
897 : : * (track current state ourselves) ... blink for diagnostics,
898 : : * power, "this is the one", etc. EHCI spec supports this.
899 : : */
900 : :
901 : 0 : spin_lock_irqsave (&ehci->lock, flags);
902 [ # # # # : 0 : switch (typeReq) {
# # # # ]
903 : 0 : case ClearHubFeature:
904 [ # # ]: 0 : switch (wValue) {
905 : : case C_HUB_LOCAL_POWER:
906 : : case C_HUB_OVER_CURRENT:
907 : : /* no hub-wide feature/status flags */
908 : : break;
909 : 0 : default:
910 : 0 : goto error;
911 : : }
912 : : break;
913 : 0 : case ClearPortFeature:
914 [ # # # # ]: 0 : if (!wIndex || wIndex > ports)
915 : 0 : goto error;
916 : 0 : wIndex--;
917 : 0 : temp = ehci_readl(ehci, status_reg);
918 : 0 : temp &= ~PORT_RWC_BITS;
919 : :
920 : : /*
921 : : * Even if OWNER is set, so the port is owned by the
922 : : * companion controller, hub_wq needs to be able to clear
923 : : * the port-change status bits (especially
924 : : * USB_PORT_STAT_C_CONNECTION).
925 : : */
926 : :
927 [ # # # # : 0 : switch (wValue) {
# # # #
# ]
928 : 0 : case USB_PORT_FEAT_ENABLE:
929 [ # # ]: 0 : ehci_writel(ehci, temp & ~PORT_PE, status_reg);
930 : : break;
931 : 0 : case USB_PORT_FEAT_C_ENABLE:
932 [ # # ]: 0 : ehci_writel(ehci, temp | PORT_PEC, status_reg);
933 : : break;
934 : 0 : case USB_PORT_FEAT_SUSPEND:
935 [ # # ]: 0 : if (temp & PORT_RESET)
936 : 0 : goto error;
937 [ # # ]: 0 : if (ehci->no_selective_suspend)
938 : : break;
939 : : #ifdef CONFIG_USB_OTG
940 : : if ((hcd->self.otg_port == (wIndex + 1))
941 : : && hcd->self.b_hnp_enable) {
942 : : otg_start_hnp(hcd->usb_phy->otg);
943 : : break;
944 : : }
945 : : #endif
946 [ # # ]: 0 : if (!(temp & PORT_SUSPEND))
947 : : break;
948 [ # # ]: 0 : if ((temp & PORT_PE) == 0)
949 : 0 : goto error;
950 : :
951 : : /* clear phy low-power mode before resume */
952 [ # # ]: 0 : if (ehci->has_tdi_phy_lpm) {
953 : 0 : temp1 = ehci_readl(ehci, hostpc_reg);
954 [ # # ]: 0 : ehci_writel(ehci, temp1 & ~HOSTPC_PHCD,
955 : : hostpc_reg);
956 : 0 : spin_unlock_irqrestore(&ehci->lock, flags);
957 : 0 : msleep(5);/* wait to leave low-power mode */
958 : 0 : spin_lock_irqsave(&ehci->lock, flags);
959 : : }
960 : : /* resume signaling for 20 msec */
961 : 0 : temp &= ~PORT_WAKE_BITS;
962 [ # # ]: 0 : ehci_writel(ehci, temp | PORT_RESUME, status_reg);
963 : 0 : ehci->reset_done[wIndex] = jiffies
964 : 0 : + msecs_to_jiffies(USB_RESUME_TIMEOUT);
965 : 0 : set_bit(wIndex, &ehci->resuming_ports);
966 : 0 : usb_hcd_start_port_resume(&hcd->self, wIndex);
967 : 0 : break;
968 : 0 : case USB_PORT_FEAT_C_SUSPEND:
969 : 0 : clear_bit(wIndex, &ehci->port_c_suspend);
970 : 0 : break;
971 : 0 : case USB_PORT_FEAT_POWER:
972 [ # # ]: 0 : if (HCS_PPC(ehci->hcs_params)) {
973 : 0 : spin_unlock_irqrestore(&ehci->lock, flags);
974 : 0 : ehci_port_power(ehci, wIndex, false);
975 : 0 : spin_lock_irqsave(&ehci->lock, flags);
976 : : }
977 : : break;
978 : 0 : case USB_PORT_FEAT_C_CONNECTION:
979 [ # # ]: 0 : ehci_writel(ehci, temp | PORT_CSC, status_reg);
980 : : break;
981 : 0 : case USB_PORT_FEAT_C_OVER_CURRENT:
982 [ # # ]: 0 : ehci_writel(ehci, temp | PORT_OCC, status_reg);
983 : : break;
984 : : case USB_PORT_FEAT_C_RESET:
985 : : /* GetPortStatus clears reset */
986 : : break;
987 : 0 : default:
988 : 0 : goto error;
989 : : }
990 : 0 : ehci_readl(ehci, &ehci->regs->command); /* unblock posted write */
991 : : break;
992 : 0 : case GetHubDescriptor:
993 : 0 : ehci_hub_descriptor (ehci, (struct usb_hub_descriptor *)
994 : : buf);
995 : 0 : break;
996 : 0 : case GetHubStatus:
997 : : /* no hub-wide feature/status flags */
998 : 0 : memset (buf, 0, 4);
999 : : //cpu_to_le32s ((u32 *) buf);
1000 : 0 : break;
1001 : 0 : case GetPortStatus:
1002 [ # # # # ]: 0 : if (!wIndex || wIndex > ports)
1003 : 0 : goto error;
1004 : 0 : wIndex--;
1005 : 0 : status = 0;
1006 : 0 : temp = ehci_readl(ehci, status_reg);
1007 : :
1008 : : // wPortChange bits
1009 [ # # ]: 0 : if (temp & PORT_CSC)
1010 : 0 : status |= USB_PORT_STAT_C_CONNECTION << 16;
1011 [ # # ]: 0 : if (temp & PORT_PEC)
1012 : 0 : status |= USB_PORT_STAT_C_ENABLE << 16;
1013 : :
1014 [ # # # # ]: 0 : if ((temp & PORT_OCC) && !ignore_oc){
1015 : 0 : status |= USB_PORT_STAT_C_OVERCURRENT << 16;
1016 : :
1017 : : /*
1018 : : * Hubs should disable port power on over-current.
1019 : : * However, not all EHCI implementations do this
1020 : : * automatically, even if they _do_ support per-port
1021 : : * power switching; they're allowed to just limit the
1022 : : * current. hub_wq will turn the power back on.
1023 : : */
1024 [ # # # # ]: 0 : if (((temp & PORT_OC) || (ehci->need_oc_pp_cycle))
1025 [ # # ]: 0 : && HCS_PPC(ehci->hcs_params)) {
1026 : 0 : spin_unlock_irqrestore(&ehci->lock, flags);
1027 : 0 : ehci_port_power(ehci, wIndex, false);
1028 : 0 : spin_lock_irqsave(&ehci->lock, flags);
1029 : 0 : temp = ehci_readl(ehci, status_reg);
1030 : : }
1031 : : }
1032 : :
1033 : : /* no reset or resume pending */
1034 [ # # ]: 0 : if (!ehci->reset_done[wIndex]) {
1035 : :
1036 : : /* Remote Wakeup received? */
1037 [ # # ]: 0 : if (temp & PORT_RESUME) {
1038 : : /* resume signaling for 20 msec */
1039 : 0 : ehci->reset_done[wIndex] = jiffies
1040 : 0 : + msecs_to_jiffies(20);
1041 : 0 : usb_hcd_start_port_resume(&hcd->self, wIndex);
1042 : 0 : set_bit(wIndex, &ehci->resuming_ports);
1043 : : /* check the port again */
1044 : 0 : mod_timer(&ehci_to_hcd(ehci)->rh_timer,
1045 : : ehci->reset_done[wIndex]);
1046 : : }
1047 : :
1048 : : /* reset or resume not yet complete */
1049 [ # # ]: 0 : } else if (!time_after_eq(jiffies, ehci->reset_done[wIndex])) {
1050 : : ; /* wait until it is complete */
1051 : :
1052 : : /* resume completed */
1053 [ # # ]: 0 : } else if (test_bit(wIndex, &ehci->resuming_ports)) {
1054 : 0 : clear_bit(wIndex, &ehci->suspended_ports);
1055 : 0 : set_bit(wIndex, &ehci->port_c_suspend);
1056 : 0 : ehci->reset_done[wIndex] = 0;
1057 : 0 : usb_hcd_end_port_resume(&hcd->self, wIndex);
1058 : :
1059 : : /* stop resume signaling */
1060 : 0 : temp &= ~(PORT_RWC_BITS | PORT_SUSPEND | PORT_RESUME);
1061 [ # # ]: 0 : ehci_writel(ehci, temp, status_reg);
1062 : 0 : clear_bit(wIndex, &ehci->resuming_ports);
1063 : 0 : retval = ehci_handshake(ehci, status_reg,
1064 : : PORT_RESUME, 0, 2000 /* 2msec */);
1065 [ # # ]: 0 : if (retval != 0) {
1066 : 0 : ehci_err(ehci, "port %d resume error %d\n",
1067 : : wIndex + 1, retval);
1068 : 0 : goto error;
1069 : : }
1070 : 0 : temp = ehci_readl(ehci, status_reg);
1071 : :
1072 : : /* whoever resets must GetPortStatus to complete it!! */
1073 : : } else {
1074 : 0 : status |= USB_PORT_STAT_C_RESET << 16;
1075 : 0 : ehci->reset_done [wIndex] = 0;
1076 : :
1077 : : /* force reset to complete */
1078 [ # # ]: 0 : ehci_writel(ehci, temp & ~(PORT_RWC_BITS | PORT_RESET),
1079 : : status_reg);
1080 : : /* REVISIT: some hardware needs 550+ usec to clear
1081 : : * this bit; seems too long to spin routinely...
1082 : : */
1083 : : retval = ehci_handshake(ehci, status_reg,
1084 : : PORT_RESET, 0, 1000);
1085 [ # # ]: 0 : if (retval != 0) {
1086 : 0 : ehci_err (ehci, "port %d reset error %d\n",
1087 : : wIndex + 1, retval);
1088 : 0 : goto error;
1089 : : }
1090 : :
1091 : : /* see what we found out */
1092 [ # # ]: 0 : temp = check_reset_complete (ehci, wIndex, status_reg,
1093 : : ehci_readl(ehci, status_reg));
1094 : : }
1095 : :
1096 : : /* transfer dedicated ports to the companion hc */
1097 [ # # # # ]: 0 : if ((temp & PORT_CONNECT) &&
1098 : 0 : test_bit(wIndex, &ehci->companion_ports)) {
1099 : 0 : temp &= ~PORT_RWC_BITS;
1100 : 0 : temp |= PORT_OWNER;
1101 [ # # ]: 0 : ehci_writel(ehci, temp, status_reg);
1102 : 0 : ehci_dbg(ehci, "port %d --> companion\n", wIndex + 1);
1103 : 0 : temp = ehci_readl(ehci, status_reg);
1104 : : }
1105 : :
1106 : : /*
1107 : : * Even if OWNER is set, there's no harm letting hub_wq
1108 : : * see the wPortStatus values (they should all be 0 except
1109 : : * for PORT_POWER anyway).
1110 : : */
1111 : :
1112 [ # # ]: 0 : if (temp & PORT_CONNECT) {
1113 : 0 : status |= USB_PORT_STAT_CONNECTION;
1114 : : // status may be from integrated TT
1115 [ # # ]: 0 : if (ehci->has_hostpc) {
1116 : 0 : temp1 = ehci_readl(ehci, hostpc_reg);
1117 : 0 : status |= ehci_port_speed(ehci, temp1);
1118 : : } else
1119 : 0 : status |= ehci_port_speed(ehci, temp);
1120 : : }
1121 [ # # ]: 0 : if (temp & PORT_PE)
1122 : 0 : status |= USB_PORT_STAT_ENABLE;
1123 : :
1124 : : /* maybe the port was unsuspended without our knowledge */
1125 [ # # ]: 0 : if (temp & (PORT_SUSPEND|PORT_RESUME)) {
1126 : 0 : status |= USB_PORT_STAT_SUSPEND;
1127 [ # # ]: 0 : } else if (test_bit(wIndex, &ehci->suspended_ports)) {
1128 : 0 : clear_bit(wIndex, &ehci->suspended_ports);
1129 : 0 : clear_bit(wIndex, &ehci->resuming_ports);
1130 : 0 : ehci->reset_done[wIndex] = 0;
1131 [ # # ]: 0 : if (temp & PORT_PE)
1132 : 0 : set_bit(wIndex, &ehci->port_c_suspend);
1133 : 0 : usb_hcd_end_port_resume(&hcd->self, wIndex);
1134 : : }
1135 : :
1136 [ # # ]: 0 : if (temp & PORT_OC)
1137 : 0 : status |= USB_PORT_STAT_OVERCURRENT;
1138 [ # # ]: 0 : if (temp & PORT_RESET)
1139 : 0 : status |= USB_PORT_STAT_RESET;
1140 [ # # ]: 0 : if (temp & PORT_POWER)
1141 : 0 : status |= USB_PORT_STAT_POWER;
1142 [ # # ]: 0 : if (test_bit(wIndex, &ehci->port_c_suspend))
1143 : 0 : status |= USB_PORT_STAT_C_SUSPEND << 16;
1144 : :
1145 : 0 : if (status & ~0xffff) /* only if wPortChange is interesting */
1146 : : dbg_port(ehci, "GetStatus", wIndex + 1, temp);
1147 : 0 : put_unaligned_le32(status, buf);
1148 : : break;
1149 : 0 : case SetHubFeature:
1150 [ # # ]: 0 : switch (wValue) {
1151 : : case C_HUB_LOCAL_POWER:
1152 : : case C_HUB_OVER_CURRENT:
1153 : : /* no hub-wide feature/status flags */
1154 : : break;
1155 : 0 : default:
1156 : 0 : goto error;
1157 : : }
1158 : : break;
1159 : 0 : case SetPortFeature:
1160 : 0 : selector = wIndex >> 8;
1161 : 0 : wIndex &= 0xff;
1162 [ # # ]: 0 : if (unlikely(ehci->debug)) {
1163 : : /* If the debug port is active any port
1164 : : * feature requests should get denied */
1165 [ # # ]: 0 : if (wIndex == HCS_DEBUG_PORT(ehci->hcs_params) &&
1166 [ # # ]: 0 : (readl(&ehci->debug->control) & DBGP_ENABLED)) {
1167 : 0 : retval = -ENODEV;
1168 : 0 : goto error_exit;
1169 : : }
1170 : : }
1171 [ # # # # ]: 0 : if (!wIndex || wIndex > ports)
1172 : 0 : goto error;
1173 : 0 : wIndex--;
1174 : 0 : temp = ehci_readl(ehci, status_reg);
1175 [ # # ]: 0 : if (temp & PORT_OWNER)
1176 : : break;
1177 : :
1178 : 0 : temp &= ~PORT_RWC_BITS;
1179 [ # # # # : 0 : switch (wValue) {
# ]
1180 : 0 : case USB_PORT_FEAT_SUSPEND:
1181 [ # # ]: 0 : if (ehci->no_selective_suspend)
1182 : : break;
1183 : 0 : if ((temp & PORT_PE) == 0
1184 [ # # ]: 0 : || (temp & PORT_RESET) != 0)
1185 : 0 : goto error;
1186 : :
1187 : : /* After above check the port must be connected.
1188 : : * Set appropriate bit thus could put phy into low power
1189 : : * mode if we have tdi_phy_lpm feature
1190 : : */
1191 : 0 : temp &= ~PORT_WKCONN_E;
1192 : 0 : temp |= PORT_WKDISC_E | PORT_WKOC_E;
1193 [ # # ]: 0 : ehci_writel(ehci, temp | PORT_SUSPEND, status_reg);
1194 [ # # ]: 0 : if (ehci->has_tdi_phy_lpm) {
1195 : 0 : spin_unlock_irqrestore(&ehci->lock, flags);
1196 : 0 : msleep(5);/* 5ms for HCD enter low pwr mode */
1197 : 0 : spin_lock_irqsave(&ehci->lock, flags);
1198 : 0 : temp1 = ehci_readl(ehci, hostpc_reg);
1199 [ # # ]: 0 : ehci_writel(ehci, temp1 | HOSTPC_PHCD,
1200 : : hostpc_reg);
1201 : 0 : temp1 = ehci_readl(ehci, hostpc_reg);
1202 : 0 : ehci_dbg(ehci, "Port%d phy low pwr mode %s\n",
1203 : : wIndex, (temp1 & HOSTPC_PHCD) ?
1204 : : "succeeded" : "failed");
1205 : : }
1206 [ # # ]: 0 : if (ehci_has_fsl_susp_errata(ehci)) {
1207 : : /* 10ms for HCD enter suspend */
1208 : 0 : spin_unlock_irqrestore(&ehci->lock, flags);
1209 : 0 : usleep_range(10000, 20000);
1210 : 0 : spin_lock_irqsave(&ehci->lock, flags);
1211 : : }
1212 : 0 : set_bit(wIndex, &ehci->suspended_ports);
1213 : 0 : break;
1214 : 0 : case USB_PORT_FEAT_POWER:
1215 [ # # ]: 0 : if (HCS_PPC(ehci->hcs_params)) {
1216 : 0 : spin_unlock_irqrestore(&ehci->lock, flags);
1217 : 0 : ehci_port_power(ehci, wIndex, true);
1218 : 0 : spin_lock_irqsave(&ehci->lock, flags);
1219 : : }
1220 : : break;
1221 : 0 : case USB_PORT_FEAT_RESET:
1222 [ # # ]: 0 : if (temp & (PORT_SUSPEND|PORT_RESUME))
1223 : 0 : goto error;
1224 : : /* line status bits may report this as low speed,
1225 : : * which can be fine if this root hub has a
1226 : : * transaction translator built in.
1227 : : */
1228 : 0 : if ((temp & (PORT_PE|PORT_CONNECT)) == PORT_CONNECT
1229 : : && !ehci_is_TDI(ehci)
1230 [ # # ]: 0 : && PORT_USB11 (temp)) {
1231 : 0 : ehci_dbg (ehci,
1232 : : "port %d low speed --> companion\n",
1233 : : wIndex + 1);
1234 : 0 : temp |= PORT_OWNER;
1235 : : } else {
1236 : 0 : temp |= PORT_RESET;
1237 : 0 : temp &= ~PORT_PE;
1238 : :
1239 : : /*
1240 : : * caller must wait, then call GetPortStatus
1241 : : * usb 2.0 spec says 50 ms resets on root
1242 : : */
1243 : 0 : ehci->reset_done [wIndex] = jiffies
1244 : 0 : + msecs_to_jiffies (50);
1245 : :
1246 : : /*
1247 : : * Force full-speed connect for FSL high-speed
1248 : : * erratum; disable HS Chirp by setting PFSC bit
1249 : : */
1250 : 0 : if (ehci_has_fsl_hs_errata(ehci))
1251 : : temp |= (1 << PORTSC_FSL_PFSC);
1252 : : }
1253 [ # # ]: 0 : ehci_writel(ehci, temp, status_reg);
1254 : : break;
1255 : :
1256 : : /* For downstream facing ports (these): one hub port is put
1257 : : * into test mode according to USB2 11.24.2.13, then the hub
1258 : : * must be reset (which for root hub now means rmmod+modprobe,
1259 : : * or else system reboot). See EHCI 2.3.9 and 4.14 for info
1260 : : * about the EHCI-specific stuff.
1261 : : */
1262 : 0 : case USB_PORT_FEAT_TEST:
1263 : : #ifdef CONFIG_USB_HCD_TEST_MODE
1264 : : if (selector == EHSET_TEST_SINGLE_STEP_SET_FEATURE) {
1265 : : spin_unlock_irqrestore(&ehci->lock, flags);
1266 : : retval = ehset_single_step_set_feature(hcd,
1267 : : wIndex + 1);
1268 : : spin_lock_irqsave(&ehci->lock, flags);
1269 : : break;
1270 : : }
1271 : : #endif
1272 [ # # ]: 0 : if (!selector || selector > 5)
1273 : 0 : goto error;
1274 : 0 : spin_unlock_irqrestore(&ehci->lock, flags);
1275 : 0 : ehci_quiesce(ehci);
1276 : 0 : spin_lock_irqsave(&ehci->lock, flags);
1277 : :
1278 : : /* Put all enabled ports into suspend */
1279 [ # # ]: 0 : while (ports--) {
1280 : 0 : u32 __iomem *sreg =
1281 : 0 : &ehci->regs->port_status[ports];
1282 : :
1283 : 0 : temp = ehci_readl(ehci, sreg) & ~PORT_RWC_BITS;
1284 [ # # ]: 0 : if (temp & PORT_PE)
1285 [ # # ]: 0 : ehci_writel(ehci, temp | PORT_SUSPEND,
1286 : : sreg);
1287 : : }
1288 : :
1289 : 0 : spin_unlock_irqrestore(&ehci->lock, flags);
1290 : 0 : ehci_halt(ehci);
1291 : 0 : spin_lock_irqsave(&ehci->lock, flags);
1292 : :
1293 : 0 : temp = ehci_readl(ehci, status_reg);
1294 : 0 : temp |= selector << 16;
1295 [ # # ]: 0 : ehci_writel(ehci, temp, status_reg);
1296 : : break;
1297 : :
1298 : 0 : default:
1299 : 0 : goto error;
1300 : : }
1301 : 0 : ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */
1302 : : break;
1303 : :
1304 : : default:
1305 : : error:
1306 : : /* "stall" on error */
1307 : : retval = -EPIPE;
1308 : : }
1309 : 0 : error_exit:
1310 : 0 : spin_unlock_irqrestore (&ehci->lock, flags);
1311 : 0 : return retval;
1312 : : }
1313 : : EXPORT_SYMBOL_GPL(ehci_hub_control);
1314 : :
1315 : 0 : static void ehci_relinquish_port(struct usb_hcd *hcd, int portnum)
1316 : : {
1317 : 0 : struct ehci_hcd *ehci = hcd_to_ehci(hcd);
1318 : :
1319 : 0 : if (ehci_is_TDI(ehci))
1320 : : return;
1321 : 0 : set_owner(ehci, --portnum, PORT_OWNER);
1322 : : }
1323 : :
1324 : 0 : static int ehci_port_handed_over(struct usb_hcd *hcd, int portnum)
1325 : : {
1326 : 0 : struct ehci_hcd *ehci = hcd_to_ehci(hcd);
1327 : 0 : u32 __iomem *reg;
1328 : :
1329 : 0 : if (ehci_is_TDI(ehci))
1330 : : return 0;
1331 : 0 : reg = &ehci->regs->port_status[portnum - 1];
1332 : 0 : return ehci_readl(ehci, reg) & PORT_OWNER;
1333 : : }
1334 : :
1335 : 0 : static int ehci_port_power(struct ehci_hcd *ehci, int portnum, bool enable)
1336 : : {
1337 : 0 : struct usb_hcd *hcd = ehci_to_hcd(ehci);
1338 : 0 : u32 __iomem *status_reg = &ehci->regs->port_status[portnum];
1339 : 0 : u32 temp = ehci_readl(ehci, status_reg) & ~PORT_RWC_BITS;
1340 : :
1341 [ # # ]: 0 : if (enable)
1342 [ # # ]: 0 : ehci_writel(ehci, temp | PORT_POWER, status_reg);
1343 : : else
1344 [ # # ]: 0 : ehci_writel(ehci, temp & ~PORT_POWER, status_reg);
1345 : :
1346 [ # # ]: 0 : if (hcd->driver->port_power)
1347 : 0 : hcd->driver->port_power(hcd, portnum, enable);
1348 : :
1349 : 0 : return 0;
1350 : : }
|
