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