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