projects / deliverable / linux.git / blob
? search:


0dcb4164dc8368a9187b670c2a303c39cfdfa109
[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 #ifdef CONFIG_USB_PERSIST
32
33 static int ehci_hub_control(
34 struct usb_hcd *hcd,
35 u16 typeReq,
36 u16 wValue,
37 u16 wIndex,
38 char *buf,
39 u16 wLength
40 );
41
42 /* After a power loss, ports that were owned by the companion must be
43 * reset so that the companion can still own them.
44 */
45 static void ehci_handover_companion_ports(struct ehci_hcd *ehci)
46 {
47 u32 __iomem *reg;
48 u32 status;
49 int port;
50 __le32 buf;
51 struct usb_hcd *hcd = ehci_to_hcd(ehci);
52
53 if (!ehci->owned_ports)
54 return;
55
56 /* Give the connections some time to appear */
57 msleep(20);
58
59 port = HCS_N_PORTS(ehci->hcs_params);
60 while (port--) {
61 if (test_bit(port, &ehci->owned_ports)) {
62 reg = &ehci->regs->port_status[port];
63 status = ehci_readl(ehci, reg) & ~PORT_RWC_BITS;
64
65 /* Port already owned by companion? */
66 if (status & PORT_OWNER)
67 clear_bit(port, &ehci->owned_ports);
68 else if (test_bit(port, &ehci->companion_ports))
69 ehci_writel(ehci, status & ~PORT_PE, reg);
70 else
71 ehci_hub_control(hcd, SetPortFeature,
72 USB_PORT_FEAT_RESET, port + 1,
73 NULL, 0);
74 }
75 }
76
77 if (!ehci->owned_ports)
78 return;
79 msleep(90); /* Wait for resets to complete */
80
81 port = HCS_N_PORTS(ehci->hcs_params);
82 while (port--) {
83 if (test_bit(port, &ehci->owned_ports)) {
84 ehci_hub_control(hcd, GetPortStatus,
85 0, port + 1,
86 (char *) &buf, sizeof(buf));
87
88 /* The companion should now own the port,
89 * but if something went wrong the port must not
90 * remain enabled.
91 */
92 reg = &ehci->regs->port_status[port];
93 status = ehci_readl(ehci, reg) & ~PORT_RWC_BITS;
94 if (status & PORT_OWNER)
95 ehci_writel(ehci, status | PORT_CSC, reg);
96 else {
97 ehci_dbg(ehci, "failed handover port %d: %x\n",
98 port + 1, status);
99 ehci_writel(ehci, status & ~PORT_PE, reg);
100 }
101 }
102 }
103
104 ehci->owned_ports = 0;
105 }
106
107 #else /* CONFIG_USB_PERSIST */
108
109 static inline void ehci_handover_companion_ports(struct ehci_hcd *ehci)
110 { }
111
112 #endif
113
114 #ifdef CONFIG_PM
115
116 static int ehci_bus_suspend (struct usb_hcd *hcd)
117 {
118 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
119 int port;
120 int mask;
121
122 ehci_dbg(ehci, "suspend root hub\n");
123
124 if (time_before (jiffies, ehci->next_statechange))
125 msleep(5);
126
127 port = HCS_N_PORTS (ehci->hcs_params);
128 spin_lock_irq (&ehci->lock);
129
130 /* stop schedules, clean any completed work */
131 if (HC_IS_RUNNING(hcd->state)) {
132 ehci_quiesce (ehci);
133 hcd->state = HC_STATE_QUIESCING;
134 }
135 ehci->command = ehci_readl(ehci, &ehci->regs->command);
136 if (ehci->reclaim)
137 ehci->reclaim_ready = 1;
138 ehci_work(ehci);
139
140 /* Unlike other USB host controller types, EHCI doesn't have
141 * any notion of "global" or bus-wide suspend. The driver has
142 * to manually suspend all the active unsuspended ports, and
143 * then manually resume them in the bus_resume() routine.
144 */
145 ehci->bus_suspended = 0;
146 ehci->owned_ports = 0;
147 while (port--) {
148 u32 __iomem *reg = &ehci->regs->port_status [port];
149 u32 t1 = ehci_readl(ehci, reg) & ~PORT_RWC_BITS;
150 u32 t2 = t1;
151
152 /* keep track of which ports we suspend */
153 if (t1 & PORT_OWNER)
154 set_bit(port, &ehci->owned_ports);
155 else if ((t1 & PORT_PE) && !(t1 & PORT_SUSPEND)) {
156 t2 |= PORT_SUSPEND;
157 set_bit(port, &ehci->bus_suspended);
158 }
159
160 /* enable remote wakeup on all ports */
161 if (device_may_wakeup(&hcd->self.root_hub->dev))
162 t2 |= PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E;
163 else
164 t2 &= ~(PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E);
165
166 if (t1 != t2) {
167 ehci_vdbg (ehci, "port %d, %08x -> %08x\n",
168 port + 1, t1, t2);
169 ehci_writel(ehci, t2, reg);
170 }
171 }
172
173 /* turn off now-idle HC */
174 del_timer_sync (&ehci->watchdog);
175 ehci_halt (ehci);
176 hcd->state = HC_STATE_SUSPENDED;
177
178 /* allow remote wakeup */
179 mask = INTR_MASK;
180 if (!device_may_wakeup(&hcd->self.root_hub->dev))
181 mask &= ~STS_PCD;
182 ehci_writel(ehci, mask, &ehci->regs->intr_enable);
183 ehci_readl(ehci, &ehci->regs->intr_enable);
184
185 ehci->next_statechange = jiffies + msecs_to_jiffies(10);
186 spin_unlock_irq (&ehci->lock);
187 return 0;
188 }
189
190
191 /* caller has locked the root hub, and should reset/reinit on error */
192 static int ehci_bus_resume (struct usb_hcd *hcd)
193 {
194 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
195 u32 temp;
196 u32 power_okay;
197 int i;
198
199 if (time_before (jiffies, ehci->next_statechange))
200 msleep(5);
201 spin_lock_irq (&ehci->lock);
202 if (!test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags)) {
203 spin_unlock_irq(&ehci->lock);
204 return -ESHUTDOWN;
205 }
206
207 /* Ideally and we've got a real resume here, and no port's power
208 * was lost. (For PCI, that means Vaux was maintained.) But we
209 * could instead be restoring a swsusp snapshot -- so that BIOS was
210 * the last user of the controller, not reset/pm hardware keeping
211 * state we gave to it.
212 */
213 power_okay = ehci_readl(ehci, &ehci->regs->intr_enable);
214 ehci_dbg(ehci, "resume root hub%s\n",
215 power_okay ? "" : " after power loss");
216
217 /* at least some APM implementations will try to deliver
218 * IRQs right away, so delay them until we're ready.
219 */
220 ehci_writel(ehci, 0, &ehci->regs->intr_enable);
221
222 /* re-init operational registers */
223 ehci_writel(ehci, 0, &ehci->regs->segment);
224 ehci_writel(ehci, ehci->periodic_dma, &ehci->regs->frame_list);
225 ehci_writel(ehci, (u32) ehci->async->qh_dma, &ehci->regs->async_next);
226
227 /* restore CMD_RUN, framelist size, and irq threshold */
228 ehci_writel(ehci, ehci->command, &ehci->regs->command);
229
230 /* Some controller/firmware combinations need a delay during which
231 * they set up the port statuses. See Bugzilla #8190. */
232 mdelay(8);
233
234 /* manually resume the ports we suspended during bus_suspend() */
235 i = HCS_N_PORTS (ehci->hcs_params);
236 while (i--) {
237 temp = ehci_readl(ehci, &ehci->regs->port_status [i]);
238 temp &= ~(PORT_RWC_BITS
239 | PORT_WKOC_E | PORT_WKDISC_E | PORT_WKCONN_E);
240 if (test_bit(i, &ehci->bus_suspended) &&
241 (temp & PORT_SUSPEND)) {
242 ehci->reset_done [i] = jiffies + msecs_to_jiffies (20);
243 temp |= PORT_RESUME;
244 }
245 ehci_writel(ehci, temp, &ehci->regs->port_status [i]);
246 }
247 i = HCS_N_PORTS (ehci->hcs_params);
248 mdelay (20);
249 while (i--) {
250 temp = ehci_readl(ehci, &ehci->regs->port_status [i]);
251 if (test_bit(i, &ehci->bus_suspended) &&
252 (temp & PORT_SUSPEND)) {
253 temp &= ~(PORT_RWC_BITS | PORT_RESUME);
254 ehci_writel(ehci, temp, &ehci->regs->port_status [i]);
255 ehci_vdbg (ehci, "resumed port %d\n", i + 1);
256 }
257 }
258 (void) ehci_readl(ehci, &ehci->regs->command);
259
260 /* maybe re-activate the schedule(s) */
261 temp = 0;
262 if (ehci->async->qh_next.qh)
263 temp |= CMD_ASE;
264 if (ehci->periodic_sched)
265 temp |= CMD_PSE;
266 if (temp) {
267 ehci->command |= temp;
268 ehci_writel(ehci, ehci->command, &ehci->regs->command);
269 }
270
271 ehci->next_statechange = jiffies + msecs_to_jiffies(5);
272 hcd->state = HC_STATE_RUNNING;
273
274 /* Now we can safely re-enable irqs */
275 ehci_writel(ehci, INTR_MASK, &ehci->regs->intr_enable);
276
277 spin_unlock_irq (&ehci->lock);
278
279 if (!power_okay)
280 ehci_handover_companion_ports(ehci);
281 return 0;
282 }
283
284 #else
285
286 #define ehci_bus_suspend NULL
287 #define ehci_bus_resume NULL
288
289 #endif /* CONFIG_PM */
290
291 /*-------------------------------------------------------------------------*/
292
293 /* Display the ports dedicated to the companion controller */
294 static ssize_t show_companion(struct class_device *class_dev, char *buf)
295 {
296 struct ehci_hcd *ehci;
297 int nports, index, n;
298 int count = PAGE_SIZE;
299 char *ptr = buf;
300
301 ehci = hcd_to_ehci(bus_to_hcd(class_get_devdata(class_dev)));
302 nports = HCS_N_PORTS(ehci->hcs_params);
303
304 for (index = 0; index < nports; ++index) {
305 if (test_bit(index, &ehci->companion_ports)) {
306 n = scnprintf(ptr, count, "%d\n", index + 1);
307 ptr += n;
308 count -= n;
309 }
310 }
311 return ptr - buf;
312 }
313
314 /*
315 * Dedicate or undedicate a port to the companion controller.
316 * Syntax is "[-]portnum", where a leading '-' sign means
317 * return control of the port to the EHCI controller.
318 */
319 static ssize_t store_companion(struct class_device *class_dev,
320 const char *buf, size_t count)
321 {
322 struct ehci_hcd *ehci;
323 int portnum, new_owner, try;
324 u32 __iomem *status_reg;
325 u32 port_status;
326
327 ehci = hcd_to_ehci(bus_to_hcd(class_get_devdata(class_dev)));
328 new_owner = PORT_OWNER; /* Owned by companion */
329 if (sscanf(buf, "%d", &portnum) != 1)
330 return -EINVAL;
331 if (portnum < 0) {
332 portnum = - portnum;
333 new_owner = 0; /* Owned by EHCI */
334 }
335 if (portnum <= 0 || portnum > HCS_N_PORTS(ehci->hcs_params))
336 return -ENOENT;
337 status_reg = &ehci->regs->port_status[--portnum];
338 if (new_owner)
339 set_bit(portnum, &ehci->companion_ports);
340 else
341 clear_bit(portnum, &ehci->companion_ports);
342
343 /*
344 * The controller won't set the OWNER bit if the port is
345 * enabled, so this loop will sometimes require at least two
346 * iterations: one to disable the port and one to set OWNER.
347 */
348
349 for (try = 4; try > 0; --try) {
350 spin_lock_irq(&ehci->lock);
351 port_status = ehci_readl(ehci, status_reg);
352 if ((port_status & PORT_OWNER) == new_owner
353 || (port_status & (PORT_OWNER | PORT_CONNECT))
354 == 0)
355 try = 0;
356 else {
357 port_status ^= PORT_OWNER;
358 port_status &= ~(PORT_PE | PORT_RWC_BITS);
359 ehci_writel(ehci, port_status, status_reg);
360 }
361 spin_unlock_irq(&ehci->lock);
362 if (try > 1)
363 msleep(5);
364 }
365 return count;
366 }
367 static CLASS_DEVICE_ATTR(companion, 0644, show_companion, store_companion);
368
369 static inline void create_companion_file(struct ehci_hcd *ehci)
370 {
371 int i;
372
373 /* with integrated TT there is no companion! */
374 if (!ehci_is_TDI(ehci))
375 i = class_device_create_file(ehci_to_hcd(ehci)->self.class_dev,
376 &class_device_attr_companion);
377 }
378
379 static inline void remove_companion_file(struct ehci_hcd *ehci)
380 {
381 /* with integrated TT there is no companion! */
382 if (!ehci_is_TDI(ehci))
383 class_device_remove_file(ehci_to_hcd(ehci)->self.class_dev,
384 &class_device_attr_companion);
385 }
386
387
388 /*-------------------------------------------------------------------------*/
389
390 static int check_reset_complete (
391 struct ehci_hcd *ehci,
392 int index,
393 u32 __iomem *status_reg,
394 int port_status
395 ) {
396 if (!(port_status & PORT_CONNECT)) {
397 ehci->reset_done [index] = 0;
398 return port_status;
399 }
400
401 /* if reset finished and it's still not enabled -- handoff */
402 if (!(port_status & PORT_PE)) {
403
404 /* with integrated TT, there's nobody to hand it to! */
405 if (ehci_is_TDI(ehci)) {
406 ehci_dbg (ehci,
407 "Failed to enable port %d on root hub TT\n",
408 index+1);
409 return port_status;
410 }
411
412 ehci_dbg (ehci, "port %d full speed --> companion\n",
413 index + 1);
414
415 // what happens if HCS_N_CC(params) == 0 ?
416 port_status |= PORT_OWNER;
417 port_status &= ~PORT_RWC_BITS;
418 ehci_writel(ehci, port_status, status_reg);
419
420 } else
421 ehci_dbg (ehci, "port %d high speed\n", index + 1);
422
423 return port_status;
424 }
425
426 /*-------------------------------------------------------------------------*/
427
428
429 /* build "status change" packet (one or two bytes) from HC registers */
430
431 static int
432 ehci_hub_status_data (struct usb_hcd *hcd, char *buf)
433 {
434 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
435 u32 temp, status = 0;
436 u32 mask;
437 int ports, i, retval = 1;
438 unsigned long flags;
439
440 /* if !USB_SUSPEND, root hub timers won't get shut down ... */
441 if (!HC_IS_RUNNING(hcd->state))
442 return 0;
443
444 /* init status to no-changes */
445 buf [0] = 0;
446 ports = HCS_N_PORTS (ehci->hcs_params);
447 if (ports > 7) {
448 buf [1] = 0;
449 retval++;
450 }
451
452 /* Some boards (mostly VIA?) report bogus overcurrent indications,
453 * causing massive log spam unless we completely ignore them. It
454 * may be relevant that VIA VT8235 controlers, where PORT_POWER is
455 * always set, seem to clear PORT_OCC and PORT_CSC when writing to
456 * PORT_POWER; that's surprising, but maybe within-spec.
457 */
458 if (!ignore_oc)
459 mask = PORT_CSC | PORT_PEC | PORT_OCC;
460 else
461 mask = PORT_CSC | PORT_PEC;
462 // PORT_RESUME from hardware ~= PORT_STAT_C_SUSPEND
463
464 /* no hub change reports (bit 0) for now (power, ...) */
465
466 /* port N changes (bit N)? */
467 spin_lock_irqsave (&ehci->lock, flags);
468 for (i = 0; i < ports; i++) {
469 temp = ehci_readl(ehci, &ehci->regs->port_status [i]);
470
471 /*
472 * Return status information even for ports with OWNER set.
473 * Otherwise khubd wouldn't see the disconnect event when a
474 * high-speed device is switched over to the companion
475 * controller by the user.
476 */
477
478 if (!(temp & PORT_CONNECT))
479 ehci->reset_done [i] = 0;
480 if ((temp & mask) != 0
481 || ((temp & PORT_RESUME) != 0
482 && time_after_eq(jiffies,
483 ehci->reset_done[i]))) {
484 if (i < 7)
485 buf [0] |= 1 << (i + 1);
486 else
487 buf [1] |= 1 << (i - 7);
488 status = STS_PCD;
489 }
490 }
491 /* FIXME autosuspend idle root hubs */
492 spin_unlock_irqrestore (&ehci->lock, flags);
493 return status ? retval : 0;
494 }
495
496 /*-------------------------------------------------------------------------*/
497
498 static void
499 ehci_hub_descriptor (
500 struct ehci_hcd *ehci,
501 struct usb_hub_descriptor *desc
502 ) {
503 int ports = HCS_N_PORTS (ehci->hcs_params);
504 u16 temp;
505
506 desc->bDescriptorType = 0x29;
507 desc->bPwrOn2PwrGood = 10; /* ehci 1.0, 2.3.9 says 20ms max */
508 desc->bHubContrCurrent = 0;
509
510 desc->bNbrPorts = ports;
511 temp = 1 + (ports / 8);
512 desc->bDescLength = 7 + 2 * temp;
513
514 /* two bitmaps: ports removable, and usb 1.0 legacy PortPwrCtrlMask */
515 memset (&desc->bitmap [0], 0, temp);
516 memset (&desc->bitmap [temp], 0xff, temp);
517
518 temp = 0x0008; /* per-port overcurrent reporting */
519 if (HCS_PPC (ehci->hcs_params))
520 temp |= 0x0001; /* per-port power control */
521 else
522 temp |= 0x0002; /* no power switching */
523 #if 0
524 // re-enable when we support USB_PORT_FEAT_INDICATOR below.
525 if (HCS_INDICATOR (ehci->hcs_params))
526 temp |= 0x0080; /* per-port indicators (LEDs) */
527 #endif
528 desc->wHubCharacteristics = (__force __u16)cpu_to_le16 (temp);
529 }
530
531 /*-------------------------------------------------------------------------*/
532
533 #define PORT_WAKE_BITS (PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E)
534
535 static int ehci_hub_control (
536 struct usb_hcd *hcd,
537 u16 typeReq,
538 u16 wValue,
539 u16 wIndex,
540 char *buf,
541 u16 wLength
542 ) {
543 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
544 int ports = HCS_N_PORTS (ehci->hcs_params);
545 u32 __iomem *status_reg = &ehci->regs->port_status[
546 (wIndex & 0xff) - 1];
547 u32 temp, status;
548 unsigned long flags;
549 int retval = 0;
550 unsigned selector;
551
552 /*
553 * FIXME: support SetPortFeatures USB_PORT_FEAT_INDICATOR.
554 * HCS_INDICATOR may say we can change LEDs to off/amber/green.
555 * (track current state ourselves) ... blink for diagnostics,
556 * power, "this is the one", etc. EHCI spec supports this.
557 */
558
559 spin_lock_irqsave (&ehci->lock, flags);
560 switch (typeReq) {
561 case ClearHubFeature:
562 switch (wValue) {
563 case C_HUB_LOCAL_POWER:
564 case C_HUB_OVER_CURRENT:
565 /* no hub-wide feature/status flags */
566 break;
567 default:
568 goto error;
569 }
570 break;
571 case ClearPortFeature:
572 if (!wIndex || wIndex > ports)
573 goto error;
574 wIndex--;
575 temp = ehci_readl(ehci, status_reg);
576
577 /*
578 * Even if OWNER is set, so the port is owned by the
579 * companion controller, khubd needs to be able to clear
580 * the port-change status bits (especially
581 * USB_PORT_FEAT_C_CONNECTION).
582 */
583
584 switch (wValue) {
585 case USB_PORT_FEAT_ENABLE:
586 ehci_writel(ehci, temp & ~PORT_PE, status_reg);
587 break;
588 case USB_PORT_FEAT_C_ENABLE:
589 ehci_writel(ehci, (temp & ~PORT_RWC_BITS) | PORT_PEC,
590 status_reg);
591 break;
592 case USB_PORT_FEAT_SUSPEND:
593 if (temp & PORT_RESET)
594 goto error;
595 if (ehci->no_selective_suspend)
596 break;
597 if (temp & PORT_SUSPEND) {
598 if ((temp & PORT_PE) == 0)
599 goto error;
600 /* resume signaling for 20 msec */
601 temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
602 ehci_writel(ehci, temp | PORT_RESUME,
603 status_reg);
604 ehci->reset_done [wIndex] = jiffies
605 + msecs_to_jiffies (20);
606 }
607 break;
608 case USB_PORT_FEAT_C_SUSPEND:
609 /* we auto-clear this feature */
610 break;
611 case USB_PORT_FEAT_POWER:
612 if (HCS_PPC (ehci->hcs_params))
613 ehci_writel(ehci,
614 temp & ~(PORT_RWC_BITS | PORT_POWER),
615 status_reg);
616 break;
617 case USB_PORT_FEAT_C_CONNECTION:
618 ehci_writel(ehci, (temp & ~PORT_RWC_BITS) | PORT_CSC,
619 status_reg);
620 break;
621 case USB_PORT_FEAT_C_OVER_CURRENT:
622 ehci_writel(ehci, (temp & ~PORT_RWC_BITS) | PORT_OCC,
623 status_reg);
624 break;
625 case USB_PORT_FEAT_C_RESET:
626 /* GetPortStatus clears reset */
627 break;
628 default:
629 goto error;
630 }
631 ehci_readl(ehci, &ehci->regs->command); /* unblock posted write */
632 break;
633 case GetHubDescriptor:
634 ehci_hub_descriptor (ehci, (struct usb_hub_descriptor *)
635 buf);
636 break;
637 case GetHubStatus:
638 /* no hub-wide feature/status flags */
639 memset (buf, 0, 4);
640 //cpu_to_le32s ((u32 *) buf);
641 break;
642 case GetPortStatus:
643 if (!wIndex || wIndex > ports)
644 goto error;
645 wIndex--;
646 status = 0;
647 temp = ehci_readl(ehci, status_reg);
648
649 // wPortChange bits
650 if (temp & PORT_CSC)
651 status |= 1 << USB_PORT_FEAT_C_CONNECTION;
652 if (temp & PORT_PEC)
653 status |= 1 << USB_PORT_FEAT_C_ENABLE;
654
655 if ((temp & PORT_OCC) && !ignore_oc){
656 status |= 1 << USB_PORT_FEAT_C_OVER_CURRENT;
657
658 /*
659 * Hubs should disable port power on over-current.
660 * However, not all EHCI implementations do this
661 * automatically, even if they _do_ support per-port
662 * power switching; they're allowed to just limit the
663 * current. khubd will turn the power back on.
664 */
665 if (HCS_PPC (ehci->hcs_params)){
666 ehci_writel(ehci,
667 temp & ~(PORT_RWC_BITS | PORT_POWER),
668 status_reg);
669 }
670 }
671
672 /* whoever resumes must GetPortStatus to complete it!! */
673 if (temp & PORT_RESUME) {
674
675 /* Remote Wakeup received? */
676 if (!ehci->reset_done[wIndex]) {
677 /* resume signaling for 20 msec */
678 ehci->reset_done[wIndex] = jiffies
679 + msecs_to_jiffies(20);
680 /* check the port again */
681 mod_timer(&ehci_to_hcd(ehci)->rh_timer,
682 ehci->reset_done[wIndex]);
683 }
684
685 /* resume completed? */
686 else if (time_after_eq(jiffies,
687 ehci->reset_done[wIndex])) {
688 status |= 1 << USB_PORT_FEAT_C_SUSPEND;
689 ehci->reset_done[wIndex] = 0;
690
691 /* stop resume signaling */
692 temp = ehci_readl(ehci, status_reg);
693 ehci_writel(ehci,
694 temp & ~(PORT_RWC_BITS | PORT_RESUME),
695 status_reg);
696 retval = handshake(ehci, status_reg,
697 PORT_RESUME, 0, 2000 /* 2msec */);
698 if (retval != 0) {
699 ehci_err(ehci,
700 "port %d resume error %d\n",
701 wIndex + 1, retval);
702 goto error;
703 }
704 temp &= ~(PORT_SUSPEND|PORT_RESUME|(3<<10));
705 }
706 }
707
708 /* whoever resets must GetPortStatus to complete it!! */
709 if ((temp & PORT_RESET)
710 && time_after_eq(jiffies,
711 ehci->reset_done[wIndex])) {
712 status |= 1 << USB_PORT_FEAT_C_RESET;
713 ehci->reset_done [wIndex] = 0;
714
715 /* force reset to complete */
716 ehci_writel(ehci, temp & ~(PORT_RWC_BITS | PORT_RESET),
717 status_reg);
718 /* REVISIT: some hardware needs 550+ usec to clear
719 * this bit; seems too long to spin routinely...
720 */
721 retval = handshake(ehci, status_reg,
722 PORT_RESET, 0, 750);
723 if (retval != 0) {
724 ehci_err (ehci, "port %d reset error %d\n",
725 wIndex + 1, retval);
726 goto error;
727 }
728
729 /* see what we found out */
730 temp = check_reset_complete (ehci, wIndex, status_reg,
731 ehci_readl(ehci, status_reg));
732 }
733
734 /* transfer dedicated ports to the companion hc */
735 if ((temp & PORT_CONNECT) &&
736 test_bit(wIndex, &ehci->companion_ports)) {
737 temp &= ~PORT_RWC_BITS;
738 temp |= PORT_OWNER;
739 ehci_writel(ehci, temp, status_reg);
740 ehci_dbg(ehci, "port %d --> companion\n", wIndex + 1);
741 temp = ehci_readl(ehci, status_reg);
742 }
743
744 /*
745 * Even if OWNER is set, there's no harm letting khubd
746 * see the wPortStatus values (they should all be 0 except
747 * for PORT_POWER anyway).
748 */
749
750 if (temp & PORT_CONNECT) {
751 status |= 1 << USB_PORT_FEAT_CONNECTION;
752 // status may be from integrated TT
753 status |= ehci_port_speed(ehci, temp);
754 }
755 if (temp & PORT_PE)
756 status |= 1 << USB_PORT_FEAT_ENABLE;
757 if (temp & (PORT_SUSPEND|PORT_RESUME))
758 status |= 1 << USB_PORT_FEAT_SUSPEND;
759 if (temp & PORT_OC)
760 status |= 1 << USB_PORT_FEAT_OVER_CURRENT;
761 if (temp & PORT_RESET)
762 status |= 1 << USB_PORT_FEAT_RESET;
763 if (temp & PORT_POWER)
764 status |= 1 << USB_PORT_FEAT_POWER;
765
766 #ifndef EHCI_VERBOSE_DEBUG
767 if (status & ~0xffff) /* only if wPortChange is interesting */
768 #endif
769 dbg_port (ehci, "GetStatus", wIndex + 1, temp);
770 put_unaligned(cpu_to_le32 (status), (__le32 *) buf);
771 break;
772 case SetHubFeature:
773 switch (wValue) {
774 case C_HUB_LOCAL_POWER:
775 case C_HUB_OVER_CURRENT:
776 /* no hub-wide feature/status flags */
777 break;
778 default:
779 goto error;
780 }
781 break;
782 case SetPortFeature:
783 selector = wIndex >> 8;
784 wIndex &= 0xff;
785 if (!wIndex || wIndex > ports)
786 goto error;
787 wIndex--;
788 temp = ehci_readl(ehci, status_reg);
789 if (temp & PORT_OWNER)
790 break;
791
792 temp &= ~PORT_RWC_BITS;
793 switch (wValue) {
794 case USB_PORT_FEAT_SUSPEND:
795 if (ehci->no_selective_suspend)
796 break;
797 if ((temp & PORT_PE) == 0
798 || (temp & PORT_RESET) != 0)
799 goto error;
800 if (device_may_wakeup(&hcd->self.root_hub->dev))
801 temp |= PORT_WAKE_BITS;
802 ehci_writel(ehci, temp | PORT_SUSPEND, status_reg);
803 break;
804 case USB_PORT_FEAT_POWER:
805 if (HCS_PPC (ehci->hcs_params))
806 ehci_writel(ehci, temp | PORT_POWER,
807 status_reg);
808 break;
809 case USB_PORT_FEAT_RESET:
810 if (temp & PORT_RESUME)
811 goto error;
812 /* line status bits may report this as low speed,
813 * which can be fine if this root hub has a
814 * transaction translator built in.
815 */
816 if ((temp & (PORT_PE|PORT_CONNECT)) == PORT_CONNECT
817 && !ehci_is_TDI(ehci)
818 && PORT_USB11 (temp)) {
819 ehci_dbg (ehci,
820 "port %d low speed --> companion\n",
821 wIndex + 1);
822 temp |= PORT_OWNER;
823 } else {
824 ehci_vdbg (ehci, "port %d reset\n", wIndex + 1);
825 temp |= PORT_RESET;
826 temp &= ~PORT_PE;
827
828 /*
829 * caller must wait, then call GetPortStatus
830 * usb 2.0 spec says 50 ms resets on root
831 */
832 ehci->reset_done [wIndex] = jiffies
833 + msecs_to_jiffies (50);
834 }
835 ehci_writel(ehci, temp, status_reg);
836 break;
837
838 /* For downstream facing ports (these): one hub port is put
839 * into test mode according to USB2 11.24.2.13, then the hub
840 * must be reset (which for root hub now means rmmod+modprobe,
841 * or else system reboot). See EHCI 2.3.9 and 4.14 for info
842 * about the EHCI-specific stuff.
843 */
844 case USB_PORT_FEAT_TEST:
845 if (!selector || selector > 5)
846 goto error;
847 ehci_quiesce(ehci);
848 ehci_halt(ehci);
849 temp |= selector << 16;
850 ehci_writel(ehci, temp, status_reg);
851 break;
852
853 default:
854 goto error;
855 }
856 ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */
857 break;
858
859 default:
860 error:
861 /* "stall" on error */
862 retval = -EPIPE;
863 }
864 spin_unlock_irqrestore (&ehci->lock, flags);
865 return retval;
866 }
Linux kernel - Deliverables
This page took 0.276299 seconds and 5 git commands to generate.