?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
USB: Avoid 20ms delay in EHCI resume
[linux-2.6/mini2440.git] / drivers / usb / host / ehci-hub.c
blob38650707dfe02c01c554cd48e64f44d28e862686
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 int ehci_bus_suspend (struct usb_hcd *hcd)
110 {
111 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
112 int port;
113 int mask;
114
115 ehci_dbg(ehci, "suspend root hub\n");
116
117 if (time_before (jiffies, ehci->next_statechange))
118 msleep(5);
119 del_timer_sync(&ehci->watchdog);
120 del_timer_sync(&ehci->iaa_watchdog);
121
122 port = HCS_N_PORTS (ehci->hcs_params);
123 spin_lock_irq (&ehci->lock);
124
125 /* stop schedules, clean any completed work */
126 if (HC_IS_RUNNING(hcd->state)) {
127 ehci_quiesce (ehci);
128 hcd->state = HC_STATE_QUIESCING;
129 }
130 ehci->command = ehci_readl(ehci, &ehci->regs->command);
131 ehci_work(ehci);
132
133 /* Unlike other USB host controller types, EHCI doesn't have
134 * any notion of "global" or bus-wide suspend. The driver has
135 * to manually suspend all the active unsuspended ports, and
136 * then manually resume them in the bus_resume() routine.
137 */
138 ehci->bus_suspended = 0;
139 ehci->owned_ports = 0;
140 while (port--) {
141 u32 __iomem *reg = &ehci->regs->port_status [port];
142 u32 t1 = ehci_readl(ehci, reg) & ~PORT_RWC_BITS;
143 u32 t2 = t1;
144
145 /* keep track of which ports we suspend */
146 if (t1 & PORT_OWNER)
147 set_bit(port, &ehci->owned_ports);
148 else if ((t1 & PORT_PE) && !(t1 & PORT_SUSPEND)) {
149 t2 |= PORT_SUSPEND;
150 set_bit(port, &ehci->bus_suspended);
151 }
152
153 /* enable remote wakeup on all ports */
154 if (hcd->self.root_hub->do_remote_wakeup)
155 t2 |= PORT_WAKE_BITS;
156 else
157 t2 &= ~PORT_WAKE_BITS;
158
159 if (t1 != t2) {
160 ehci_vdbg (ehci, "port %d, %08x -> %08x\n",
161 port + 1, t1, t2);
162 ehci_writel(ehci, t2, reg);
163 }
164 }
165
166 /* Apparently some devices need a >= 1-uframe delay here */
167 if (ehci->bus_suspended)
168 udelay(150);
169
170 /* turn off now-idle HC */
171 ehci_halt (ehci);
172 hcd->state = HC_STATE_SUSPENDED;
173
174 if (ehci->reclaim)
175 end_unlink_async(ehci);
176
177 /* allow remote wakeup */
178 mask = INTR_MASK;
179 if (!hcd->self.root_hub->do_remote_wakeup)
180 mask &= ~STS_PCD;
181 ehci_writel(ehci, mask, &ehci->regs->intr_enable);
182 ehci_readl(ehci, &ehci->regs->intr_enable);
183
184 ehci->next_statechange = jiffies + msecs_to_jiffies(10);
185 spin_unlock_irq (&ehci->lock);
186 return 0;
187 }
188
189
190 /* caller has locked the root hub, and should reset/reinit on error */
191 static int ehci_bus_resume (struct usb_hcd *hcd)
192 {
193 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
194 u32 temp;
195 u32 power_okay;
196 int i;
197 u8 resume_needed = 0;
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 spin_unlock_irq(&ehci->lock);
233 msleep(8);
234 spin_lock_irq(&ehci->lock);
235
236 /* manually resume the ports we suspended during bus_suspend() */
237 i = HCS_N_PORTS (ehci->hcs_params);
238 while (i--) {
239 temp = ehci_readl(ehci, &ehci->regs->port_status [i]);
240 temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
241 if (test_bit(i, &ehci->bus_suspended) &&
242 (temp & PORT_SUSPEND)) {
243 temp |= PORT_RESUME;
244 resume_needed = 1;
245 }
246 ehci_writel(ehci, temp, &ehci->regs->port_status [i]);
247 }
248
249 /* msleep for 20ms only if code is trying to resume port */
250 if (resume_needed) {
251 spin_unlock_irq(&ehci->lock);
252 msleep(20);
253 spin_lock_irq(&ehci->lock);
254 }
255
256 i = HCS_N_PORTS (ehci->hcs_params);
257 while (i--) {
258 temp = ehci_readl(ehci, &ehci->regs->port_status [i]);
259 if (test_bit(i, &ehci->bus_suspended) &&
260 (temp & PORT_SUSPEND)) {
261 temp &= ~(PORT_RWC_BITS | PORT_RESUME);
262 ehci_writel(ehci, temp, &ehci->regs->port_status [i]);
263 ehci_vdbg (ehci, "resumed port %d\n", i + 1);
264 }
265 }
266 (void) ehci_readl(ehci, &ehci->regs->command);
267
268 /* maybe re-activate the schedule(s) */
269 temp = 0;
270 if (ehci->async->qh_next.qh)
271 temp |= CMD_ASE;
272 if (ehci->periodic_sched)
273 temp |= CMD_PSE;
274 if (temp) {
275 ehci->command |= temp;
276 ehci_writel(ehci, ehci->command, &ehci->regs->command);
277 }
278
279 ehci->next_statechange = jiffies + msecs_to_jiffies(5);
280 hcd->state = HC_STATE_RUNNING;
281
282 /* Now we can safely re-enable irqs */
283 ehci_writel(ehci, INTR_MASK, &ehci->regs->intr_enable);
284
285 spin_unlock_irq (&ehci->lock);
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 || test_bit(i, &ehci->port_c_suspend)
496 || (ehci->reset_done[i] && time_after_eq(
497 jiffies, ehci->reset_done[i]))) {
498 if (i < 7)
499 buf [0] |= 1 << (i + 1);
500 else
501 buf [1] |= 1 << (i - 7);
502 status = STS_PCD;
503 }
504 }
505 /* FIXME autosuspend idle root hubs */
506 spin_unlock_irqrestore (&ehci->lock, flags);
507 return status ? retval : 0;
508 }
509
510 /*-------------------------------------------------------------------------*/
511
512 static void
513 ehci_hub_descriptor (
514 struct ehci_hcd *ehci,
515 struct usb_hub_descriptor *desc
516 ) {
517 int ports = HCS_N_PORTS (ehci->hcs_params);
518 u16 temp;
519
520 desc->bDescriptorType = 0x29;
521 desc->bPwrOn2PwrGood = 10; /* ehci 1.0, 2.3.9 says 20ms max */
522 desc->bHubContrCurrent = 0;
523
524 desc->bNbrPorts = ports;
525 temp = 1 + (ports / 8);
526 desc->bDescLength = 7 + 2 * temp;
527
528 /* two bitmaps: ports removable, and usb 1.0 legacy PortPwrCtrlMask */
529 memset (&desc->bitmap [0], 0, temp);
530 memset (&desc->bitmap [temp], 0xff, temp);
531
532 temp = 0x0008; /* per-port overcurrent reporting */
533 if (HCS_PPC (ehci->hcs_params))
534 temp |= 0x0001; /* per-port power control */
535 else
536 temp |= 0x0002; /* no power switching */
537 #if 0
538 // re-enable when we support USB_PORT_FEAT_INDICATOR below.
539 if (HCS_INDICATOR (ehci->hcs_params))
540 temp |= 0x0080; /* per-port indicators (LEDs) */
541 #endif
542 desc->wHubCharacteristics = cpu_to_le16(temp);
543 }
544
545 /*-------------------------------------------------------------------------*/
546
547 static int ehci_hub_control (
548 struct usb_hcd *hcd,
549 u16 typeReq,
550 u16 wValue,
551 u16 wIndex,
552 char *buf,
553 u16 wLength
554 ) {
555 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
556 int ports = HCS_N_PORTS (ehci->hcs_params);
557 u32 __iomem *status_reg = &ehci->regs->port_status[
558 (wIndex & 0xff) - 1];
559 u32 temp, status;
560 unsigned long flags;
561 int retval = 0;
562 unsigned selector;
563
564 /*
565 * FIXME: support SetPortFeatures USB_PORT_FEAT_INDICATOR.
566 * HCS_INDICATOR may say we can change LEDs to off/amber/green.
567 * (track current state ourselves) ... blink for diagnostics,
568 * power, "this is the one", etc. EHCI spec supports this.
569 */
570
571 spin_lock_irqsave (&ehci->lock, flags);
572 switch (typeReq) {
573 case ClearHubFeature:
574 switch (wValue) {
575 case C_HUB_LOCAL_POWER:
576 case C_HUB_OVER_CURRENT:
577 /* no hub-wide feature/status flags */
578 break;
579 default:
580 goto error;
581 }
582 break;
583 case ClearPortFeature:
584 if (!wIndex || wIndex > ports)
585 goto error;
586 wIndex--;
587 temp = ehci_readl(ehci, status_reg);
588
589 /*
590 * Even if OWNER is set, so the port is owned by the
591 * companion controller, khubd needs to be able to clear
592 * the port-change status bits (especially
593 * USB_PORT_FEAT_C_CONNECTION).
594 */
595
596 switch (wValue) {
597 case USB_PORT_FEAT_ENABLE:
598 ehci_writel(ehci, temp & ~PORT_PE, status_reg);
599 break;
600 case USB_PORT_FEAT_C_ENABLE:
601 ehci_writel(ehci, (temp & ~PORT_RWC_BITS) | PORT_PEC,
602 status_reg);
603 break;
604 case USB_PORT_FEAT_SUSPEND:
605 if (temp & PORT_RESET)
606 goto error;
607 if (ehci->no_selective_suspend)
608 break;
609 if (temp & PORT_SUSPEND) {
610 if ((temp & PORT_PE) == 0)
611 goto error;
612 /* resume signaling for 20 msec */
613 temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
614 ehci_writel(ehci, temp | PORT_RESUME,
615 status_reg);
616 ehci->reset_done [wIndex] = jiffies
617 + msecs_to_jiffies (20);
618 }
619 break;
620 case USB_PORT_FEAT_C_SUSPEND:
621 clear_bit(wIndex, &ehci->port_c_suspend);
622 break;
623 case USB_PORT_FEAT_POWER:
624 if (HCS_PPC (ehci->hcs_params))
625 ehci_writel(ehci,
626 temp & ~(PORT_RWC_BITS | PORT_POWER),
627 status_reg);
628 break;
629 case USB_PORT_FEAT_C_CONNECTION:
630 ehci_writel(ehci, (temp & ~PORT_RWC_BITS) | PORT_CSC,
631 status_reg);
632 break;
633 case USB_PORT_FEAT_C_OVER_CURRENT:
634 ehci_writel(ehci, (temp & ~PORT_RWC_BITS) | PORT_OCC,
635 status_reg);
636 break;
637 case USB_PORT_FEAT_C_RESET:
638 /* GetPortStatus clears reset */
639 break;
640 default:
641 goto error;
642 }
643 ehci_readl(ehci, &ehci->regs->command); /* unblock posted write */
644 break;
645 case GetHubDescriptor:
646 ehci_hub_descriptor (ehci, (struct usb_hub_descriptor *)
647 buf);
648 break;
649 case GetHubStatus:
650 /* no hub-wide feature/status flags */
651 memset (buf, 0, 4);
652 //cpu_to_le32s ((u32 *) buf);
653 break;
654 case GetPortStatus:
655 if (!wIndex || wIndex > ports)
656 goto error;
657 wIndex--;
658 status = 0;
659 temp = ehci_readl(ehci, status_reg);
660
661 // wPortChange bits
662 if (temp & PORT_CSC)
663 status |= 1 << USB_PORT_FEAT_C_CONNECTION;
664 if (temp & PORT_PEC)
665 status |= 1 << USB_PORT_FEAT_C_ENABLE;
666
667 if ((temp & PORT_OCC) && !ignore_oc){
668 status |= 1 << USB_PORT_FEAT_C_OVER_CURRENT;
669
670 /*
671 * Hubs should disable port power on over-current.
672 * However, not all EHCI implementations do this
673 * automatically, even if they _do_ support per-port
674 * power switching; they're allowed to just limit the
675 * current. khubd will turn the power back on.
676 */
677 if (HCS_PPC (ehci->hcs_params)){
678 ehci_writel(ehci,
679 temp & ~(PORT_RWC_BITS | PORT_POWER),
680 status_reg);
681 }
682 }
683
684 /* whoever resumes must GetPortStatus to complete it!! */
685 if (temp & PORT_RESUME) {
686
687 /* Remote Wakeup received? */
688 if (!ehci->reset_done[wIndex]) {
689 /* resume signaling for 20 msec */
690 ehci->reset_done[wIndex] = jiffies
691 + msecs_to_jiffies(20);
692 /* check the port again */
693 mod_timer(&ehci_to_hcd(ehci)->rh_timer,
694 ehci->reset_done[wIndex]);
695 }
696
697 /* resume completed? */
698 else if (time_after_eq(jiffies,
699 ehci->reset_done[wIndex])) {
700 clear_bit(wIndex, &ehci->suspended_ports);
701 set_bit(wIndex, &ehci->port_c_suspend);
702 ehci->reset_done[wIndex] = 0;
703
704 /* stop resume signaling */
705 temp = ehci_readl(ehci, status_reg);
706 ehci_writel(ehci,
707 temp & ~(PORT_RWC_BITS | PORT_RESUME),
708 status_reg);
709 retval = handshake(ehci, status_reg,
710 PORT_RESUME, 0, 2000 /* 2msec */);
711 if (retval != 0) {
712 ehci_err(ehci,
713 "port %d resume error %d\n",
714 wIndex + 1, retval);
715 goto error;
716 }
717 temp &= ~(PORT_SUSPEND|PORT_RESUME|(3<<10));
718 }
719 }
720
721 /* whoever resets must GetPortStatus to complete it!! */
722 if ((temp & PORT_RESET)
723 && time_after_eq(jiffies,
724 ehci->reset_done[wIndex])) {
725 status |= 1 << USB_PORT_FEAT_C_RESET;
726 ehci->reset_done [wIndex] = 0;
727
728 /* force reset to complete */
729 ehci_writel(ehci, temp & ~(PORT_RWC_BITS | PORT_RESET),
730 status_reg);
731 /* REVISIT: some hardware needs 550+ usec to clear
732 * this bit; seems too long to spin routinely...
733 */
734 retval = handshake(ehci, status_reg,
735 PORT_RESET, 0, 750);
736 if (retval != 0) {
737 ehci_err (ehci, "port %d reset error %d\n",
738 wIndex + 1, retval);
739 goto error;
740 }
741
742 /* see what we found out */
743 temp = check_reset_complete (ehci, wIndex, status_reg,
744 ehci_readl(ehci, status_reg));
745 }
746
747 if (!(temp & (PORT_RESUME|PORT_RESET)))
748 ehci->reset_done[wIndex] = 0;
749
750 /* transfer dedicated ports to the companion hc */
751 if ((temp & PORT_CONNECT) &&
752 test_bit(wIndex, &ehci->companion_ports)) {
753 temp &= ~PORT_RWC_BITS;
754 temp |= PORT_OWNER;
755 ehci_writel(ehci, temp, status_reg);
756 ehci_dbg(ehci, "port %d --> companion\n", wIndex + 1);
757 temp = ehci_readl(ehci, status_reg);
758 }
759
760 /*
761 * Even if OWNER is set, there's no harm letting khubd
762 * see the wPortStatus values (they should all be 0 except
763 * for PORT_POWER anyway).
764 */
765
766 if (temp & PORT_CONNECT) {
767 status |= 1 << USB_PORT_FEAT_CONNECTION;
768 // status may be from integrated TT
769 status |= ehci_port_speed(ehci, temp);
770 }
771 if (temp & PORT_PE)
772 status |= 1 << USB_PORT_FEAT_ENABLE;
773
774 /* maybe the port was unsuspended without our knowledge */
775 if (temp & (PORT_SUSPEND|PORT_RESUME)) {
776 status |= 1 << USB_PORT_FEAT_SUSPEND;
777 } else if (test_bit(wIndex, &ehci->suspended_ports)) {
778 clear_bit(wIndex, &ehci->suspended_ports);
779 ehci->reset_done[wIndex] = 0;
780 if (temp & PORT_PE)
781 set_bit(wIndex, &ehci->port_c_suspend);
782 }
783
784 if (temp & PORT_OC)
785 status |= 1 << USB_PORT_FEAT_OVER_CURRENT;
786 if (temp & PORT_RESET)
787 status |= 1 << USB_PORT_FEAT_RESET;
788 if (temp & PORT_POWER)
789 status |= 1 << USB_PORT_FEAT_POWER;
790 if (test_bit(wIndex, &ehci->port_c_suspend))
791 status |= 1 << USB_PORT_FEAT_C_SUSPEND;
792
793 #ifndef VERBOSE_DEBUG
794 if (status & ~0xffff) /* only if wPortChange is interesting */
795 #endif
796 dbg_port (ehci, "GetStatus", wIndex + 1, temp);
797 put_unaligned_le32(status, buf);
798 break;
799 case SetHubFeature:
800 switch (wValue) {
801 case C_HUB_LOCAL_POWER:
802 case C_HUB_OVER_CURRENT:
803 /* no hub-wide feature/status flags */
804 break;
805 default:
806 goto error;
807 }
808 break;
809 case SetPortFeature:
810 selector = wIndex >> 8;
811 wIndex &= 0xff;
812 if (!wIndex || wIndex > ports)
813 goto error;
814 wIndex--;
815 temp = ehci_readl(ehci, status_reg);
816 if (temp & PORT_OWNER)
817 break;
818
819 temp &= ~PORT_RWC_BITS;
820 switch (wValue) {
821 case USB_PORT_FEAT_SUSPEND:
822 if (ehci->no_selective_suspend)
823 break;
824 if ((temp & PORT_PE) == 0
825 || (temp & PORT_RESET) != 0)
826 goto error;
827 ehci_writel(ehci, temp | PORT_SUSPEND, status_reg);
828 set_bit(wIndex, &ehci->suspended_ports);
829 break;
830 case USB_PORT_FEAT_POWER:
831 if (HCS_PPC (ehci->hcs_params))
832 ehci_writel(ehci, temp | PORT_POWER,
833 status_reg);
834 break;
835 case USB_PORT_FEAT_RESET:
836 if (temp & PORT_RESUME)
837 goto error;
838 /* line status bits may report this as low speed,
839 * which can be fine if this root hub has a
840 * transaction translator built in.
841 */
842 if ((temp & (PORT_PE|PORT_CONNECT)) == PORT_CONNECT
843 && !ehci_is_TDI(ehci)
844 && PORT_USB11 (temp)) {
845 ehci_dbg (ehci,
846 "port %d low speed --> companion\n",
847 wIndex + 1);
848 temp |= PORT_OWNER;
849 } else {
850 ehci_vdbg (ehci, "port %d reset\n", wIndex + 1);
851 temp |= PORT_RESET;
852 temp &= ~PORT_PE;
853
854 /*
855 * caller must wait, then call GetPortStatus
856 * usb 2.0 spec says 50 ms resets on root
857 */
858 ehci->reset_done [wIndex] = jiffies
859 + msecs_to_jiffies (50);
860 }
861 ehci_writel(ehci, temp, status_reg);
862 break;
863
864 /* For downstream facing ports (these): one hub port is put
865 * into test mode according to USB2 11.24.2.13, then the hub
866 * must be reset (which for root hub now means rmmod+modprobe,
867 * or else system reboot). See EHCI 2.3.9 and 4.14 for info
868 * about the EHCI-specific stuff.
869 */
870 case USB_PORT_FEAT_TEST:
871 if (!selector || selector > 5)
872 goto error;
873 ehci_quiesce(ehci);
874 ehci_halt(ehci);
875 temp |= selector << 16;
876 ehci_writel(ehci, temp, status_reg);
877 break;
878
879 default:
880 goto error;
881 }
882 ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */
883 break;
884
885 default:
886 error:
887 /* "stall" on error */
888 retval = -EPIPE;
889 }
890 spin_unlock_irqrestore (&ehci->lock, flags);
891 return retval;
892 }
893
894 static void ehci_relinquish_port(struct usb_hcd *hcd, int portnum)
895 {
896 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
897
898 if (ehci_is_TDI(ehci))
899 return;
900 set_owner(ehci, --portnum, PORT_OWNER);
901 }
902
903 static int ehci_port_handed_over(struct usb_hcd *hcd, int portnum)
904 {
905 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
906 u32 __iomem *reg;
907
908 if (ehci_is_TDI(ehci))
909 return 0;
910 reg = &ehci->regs->port_status[portnum - 1];
911 return ehci_readl(ehci, reg) & PORT_OWNER;
912 }
Support for the Chinese Samsung S3C2440 based development boards