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