?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
iwmc3200wifi: Set WEP key from connect
[linux/fpc-iii.git] / drivers / usb / host / ehci-hub.c
blobf46ad27c9a90e2cda2e8bbb8b9b45c861af765c5
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.controller,
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.controller,
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 /* ensure 440EPX ohci controller state is operational */
438 if (ehci->has_amcc_usb23)
439 set_ohci_hcfs(ehci, 1);
440 } else {
441 ehci_dbg (ehci, "port %d high speed\n", index + 1);
442 /* ensure 440EPx ohci controller state is suspended */
443 if (ehci->has_amcc_usb23)
444 set_ohci_hcfs(ehci, 0);
445 }
446
447 return port_status;
448 }
449
450 /*-------------------------------------------------------------------------*/
451
452
453 /* build "status change" packet (one or two bytes) from HC registers */
454
455 static int
456 ehci_hub_status_data (struct usb_hcd *hcd, char *buf)
457 {
458 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
459 u32 temp, status = 0;
460 u32 mask;
461 int ports, i, retval = 1;
462 unsigned long flags;
463
464 /* if !USB_SUSPEND, root hub timers won't get shut down ... */
465 if (!HC_IS_RUNNING(hcd->state))
466 return 0;
467
468 /* init status to no-changes */
469 buf [0] = 0;
470 ports = HCS_N_PORTS (ehci->hcs_params);
471 if (ports > 7) {
472 buf [1] = 0;
473 retval++;
474 }
475
476 /* Some boards (mostly VIA?) report bogus overcurrent indications,
477 * causing massive log spam unless we completely ignore them. It
478 * may be relevant that VIA VT8235 controllers, where PORT_POWER is
479 * always set, seem to clear PORT_OCC and PORT_CSC when writing to
480 * PORT_POWER; that's surprising, but maybe within-spec.
481 */
482 if (!ignore_oc)
483 mask = PORT_CSC | PORT_PEC | PORT_OCC;
484 else
485 mask = PORT_CSC | PORT_PEC;
486 // PORT_RESUME from hardware ~= PORT_STAT_C_SUSPEND
487
488 /* no hub change reports (bit 0) for now (power, ...) */
489
490 /* port N changes (bit N)? */
491 spin_lock_irqsave (&ehci->lock, flags);
492 for (i = 0; i < ports; i++) {
493 temp = ehci_readl(ehci, &ehci->regs->port_status [i]);
494
495 /*
496 * Return status information even for ports with OWNER set.
497 * Otherwise khubd wouldn't see the disconnect event when a
498 * high-speed device is switched over to the companion
499 * controller by the user.
500 */
501
502 if ((temp & mask) != 0 || test_bit(i, &ehci->port_c_suspend)
503 || (ehci->reset_done[i] && time_after_eq(
504 jiffies, ehci->reset_done[i]))) {
505 if (i < 7)
506 buf [0] |= 1 << (i + 1);
507 else
508 buf [1] |= 1 << (i - 7);
509 status = STS_PCD;
510 }
511 }
512 /* FIXME autosuspend idle root hubs */
513 spin_unlock_irqrestore (&ehci->lock, flags);
514 return status ? retval : 0;
515 }
516
517 /*-------------------------------------------------------------------------*/
518
519 static void
520 ehci_hub_descriptor (
521 struct ehci_hcd *ehci,
522 struct usb_hub_descriptor *desc
523 ) {
524 int ports = HCS_N_PORTS (ehci->hcs_params);
525 u16 temp;
526
527 desc->bDescriptorType = 0x29;
528 desc->bPwrOn2PwrGood = 10; /* ehci 1.0, 2.3.9 says 20ms max */
529 desc->bHubContrCurrent = 0;
530
531 desc->bNbrPorts = ports;
532 temp = 1 + (ports / 8);
533 desc->bDescLength = 7 + 2 * temp;
534
535 /* two bitmaps: ports removable, and usb 1.0 legacy PortPwrCtrlMask */
536 memset (&desc->bitmap [0], 0, temp);
537 memset (&desc->bitmap [temp], 0xff, temp);
538
539 temp = 0x0008; /* per-port overcurrent reporting */
540 if (HCS_PPC (ehci->hcs_params))
541 temp |= 0x0001; /* per-port power control */
542 else
543 temp |= 0x0002; /* no power switching */
544 #if 0
545 // re-enable when we support USB_PORT_FEAT_INDICATOR below.
546 if (HCS_INDICATOR (ehci->hcs_params))
547 temp |= 0x0080; /* per-port indicators (LEDs) */
548 #endif
549 desc->wHubCharacteristics = cpu_to_le16(temp);
550 }
551
552 /*-------------------------------------------------------------------------*/
553
554 static int ehci_hub_control (
555 struct usb_hcd *hcd,
556 u16 typeReq,
557 u16 wValue,
558 u16 wIndex,
559 char *buf,
560 u16 wLength
561 ) {
562 struct ehci_hcd *ehci = hcd_to_ehci (hcd);
563 int ports = HCS_N_PORTS (ehci->hcs_params);
564 u32 __iomem *status_reg = &ehci->regs->port_status[
565 (wIndex & 0xff) - 1];
566 u32 temp, status;
567 unsigned long flags;
568 int retval = 0;
569 unsigned selector;
570
571 /*
572 * FIXME: support SetPortFeatures USB_PORT_FEAT_INDICATOR.
573 * HCS_INDICATOR may say we can change LEDs to off/amber/green.
574 * (track current state ourselves) ... blink for diagnostics,
575 * power, "this is the one", etc. EHCI spec supports this.
576 */
577
578 spin_lock_irqsave (&ehci->lock, flags);
579 switch (typeReq) {
580 case ClearHubFeature:
581 switch (wValue) {
582 case C_HUB_LOCAL_POWER:
583 case C_HUB_OVER_CURRENT:
584 /* no hub-wide feature/status flags */
585 break;
586 default:
587 goto error;
588 }
589 break;
590 case ClearPortFeature:
591 if (!wIndex || wIndex > ports)
592 goto error;
593 wIndex--;
594 temp = ehci_readl(ehci, status_reg);
595
596 /*
597 * Even if OWNER is set, so the port is owned by the
598 * companion controller, khubd needs to be able to clear
599 * the port-change status bits (especially
600 * USB_PORT_FEAT_C_CONNECTION).
601 */
602
603 switch (wValue) {
604 case USB_PORT_FEAT_ENABLE:
605 ehci_writel(ehci, temp & ~PORT_PE, status_reg);
606 break;
607 case USB_PORT_FEAT_C_ENABLE:
608 ehci_writel(ehci, (temp & ~PORT_RWC_BITS) | PORT_PEC,
609 status_reg);
610 break;
611 case USB_PORT_FEAT_SUSPEND:
612 if (temp & PORT_RESET)
613 goto error;
614 if (ehci->no_selective_suspend)
615 break;
616 if (temp & PORT_SUSPEND) {
617 if ((temp & PORT_PE) == 0)
618 goto error;
619 /* resume signaling for 20 msec */
620 temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
621 ehci_writel(ehci, temp | PORT_RESUME,
622 status_reg);
623 ehci->reset_done [wIndex] = jiffies
624 + msecs_to_jiffies (20);
625 }
626 break;
627 case USB_PORT_FEAT_C_SUSPEND:
628 clear_bit(wIndex, &ehci->port_c_suspend);
629 break;
630 case USB_PORT_FEAT_POWER:
631 if (HCS_PPC (ehci->hcs_params))
632 ehci_writel(ehci,
633 temp & ~(PORT_RWC_BITS | PORT_POWER),
634 status_reg);
635 break;
636 case USB_PORT_FEAT_C_CONNECTION:
637 ehci_writel(ehci, (temp & ~PORT_RWC_BITS) | PORT_CSC,
638 status_reg);
639 break;
640 case USB_PORT_FEAT_C_OVER_CURRENT:
641 ehci_writel(ehci, (temp & ~PORT_RWC_BITS) | PORT_OCC,
642 status_reg);
643 break;
644 case USB_PORT_FEAT_C_RESET:
645 /* GetPortStatus clears reset */
646 break;
647 default:
648 goto error;
649 }
650 ehci_readl(ehci, &ehci->regs->command); /* unblock posted write */
651 break;
652 case GetHubDescriptor:
653 ehci_hub_descriptor (ehci, (struct usb_hub_descriptor *)
654 buf);
655 break;
656 case GetHubStatus:
657 /* no hub-wide feature/status flags */
658 memset (buf, 0, 4);
659 //cpu_to_le32s ((u32 *) buf);
660 break;
661 case GetPortStatus:
662 if (!wIndex || wIndex > ports)
663 goto error;
664 wIndex--;
665 status = 0;
666 temp = ehci_readl(ehci, status_reg);
667
668 // wPortChange bits
669 if (temp & PORT_CSC)
670 status |= 1 << USB_PORT_FEAT_C_CONNECTION;
671 if (temp & PORT_PEC)
672 status |= 1 << USB_PORT_FEAT_C_ENABLE;
673
674 if ((temp & PORT_OCC) && !ignore_oc){
675 status |= 1 << USB_PORT_FEAT_C_OVER_CURRENT;
676
677 /*
678 * Hubs should disable port power on over-current.
679 * However, not all EHCI implementations do this
680 * automatically, even if they _do_ support per-port
681 * power switching; they're allowed to just limit the
682 * current. khubd will turn the power back on.
683 */
684 if (HCS_PPC (ehci->hcs_params)){
685 ehci_writel(ehci,
686 temp & ~(PORT_RWC_BITS | PORT_POWER),
687 status_reg);
688 }
689 }
690
691 /* whoever resumes must GetPortStatus to complete it!! */
692 if (temp & PORT_RESUME) {
693
694 /* Remote Wakeup received? */
695 if (!ehci->reset_done[wIndex]) {
696 /* resume signaling for 20 msec */
697 ehci->reset_done[wIndex] = jiffies
698 + msecs_to_jiffies(20);
699 /* check the port again */
700 mod_timer(&ehci_to_hcd(ehci)->rh_timer,
701 ehci->reset_done[wIndex]);
702 }
703
704 /* resume completed? */
705 else if (time_after_eq(jiffies,
706 ehci->reset_done[wIndex])) {
707 clear_bit(wIndex, &ehci->suspended_ports);
708 set_bit(wIndex, &ehci->port_c_suspend);
709 ehci->reset_done[wIndex] = 0;
710
711 /* stop resume signaling */
712 temp = ehci_readl(ehci, status_reg);
713 ehci_writel(ehci,
714 temp & ~(PORT_RWC_BITS | PORT_RESUME),
715 status_reg);
716 retval = handshake(ehci, status_reg,
717 PORT_RESUME, 0, 2000 /* 2msec */);
718 if (retval != 0) {
719 ehci_err(ehci,
720 "port %d resume error %d\n",
721 wIndex + 1, retval);
722 goto error;
723 }
724 temp &= ~(PORT_SUSPEND|PORT_RESUME|(3<<10));
725 }
726 }
727
728 /* whoever resets must GetPortStatus to complete it!! */
729 if ((temp & PORT_RESET)
730 && time_after_eq(jiffies,
731 ehci->reset_done[wIndex])) {
732 status |= 1 << USB_PORT_FEAT_C_RESET;
733 ehci->reset_done [wIndex] = 0;
734
735 /* force reset to complete */
736 ehci_writel(ehci, temp & ~(PORT_RWC_BITS | PORT_RESET),
737 status_reg);
738 /* REVISIT: some hardware needs 550+ usec to clear
739 * this bit; seems too long to spin routinely...
740 */
741 retval = handshake(ehci, status_reg,
742 PORT_RESET, 0, 750);
743 if (retval != 0) {
744 ehci_err (ehci, "port %d reset error %d\n",
745 wIndex + 1, retval);
746 goto error;
747 }
748
749 /* see what we found out */
750 temp = check_reset_complete (ehci, wIndex, status_reg,
751 ehci_readl(ehci, status_reg));
752 }
753
754 if (!(temp & (PORT_RESUME|PORT_RESET)))
755 ehci->reset_done[wIndex] = 0;
756
757 /* transfer dedicated ports to the companion hc */
758 if ((temp & PORT_CONNECT) &&
759 test_bit(wIndex, &ehci->companion_ports)) {
760 temp &= ~PORT_RWC_BITS;
761 temp |= PORT_OWNER;
762 ehci_writel(ehci, temp, status_reg);
763 ehci_dbg(ehci, "port %d --> companion\n", wIndex + 1);
764 temp = ehci_readl(ehci, status_reg);
765 }
766
767 /*
768 * Even if OWNER is set, there's no harm letting khubd
769 * see the wPortStatus values (they should all be 0 except
770 * for PORT_POWER anyway).
771 */
772
773 if (temp & PORT_CONNECT) {
774 status |= 1 << USB_PORT_FEAT_CONNECTION;
775 // status may be from integrated TT
776 status |= ehci_port_speed(ehci, temp);
777 }
778 if (temp & PORT_PE)
779 status |= 1 << USB_PORT_FEAT_ENABLE;
780
781 /* maybe the port was unsuspended without our knowledge */
782 if (temp & (PORT_SUSPEND|PORT_RESUME)) {
783 status |= 1 << USB_PORT_FEAT_SUSPEND;
784 } else if (test_bit(wIndex, &ehci->suspended_ports)) {
785 clear_bit(wIndex, &ehci->suspended_ports);
786 ehci->reset_done[wIndex] = 0;
787 if (temp & PORT_PE)
788 set_bit(wIndex, &ehci->port_c_suspend);
789 }
790
791 if (temp & PORT_OC)
792 status |= 1 << USB_PORT_FEAT_OVER_CURRENT;
793 if (temp & PORT_RESET)
794 status |= 1 << USB_PORT_FEAT_RESET;
795 if (temp & PORT_POWER)
796 status |= 1 << USB_PORT_FEAT_POWER;
797 if (test_bit(wIndex, &ehci->port_c_suspend))
798 status |= 1 << USB_PORT_FEAT_C_SUSPEND;
799
800 #ifndef VERBOSE_DEBUG
801 if (status & ~0xffff) /* only if wPortChange is interesting */
802 #endif
803 dbg_port (ehci, "GetStatus", wIndex + 1, temp);
804 put_unaligned_le32(status, buf);
805 break;
806 case SetHubFeature:
807 switch (wValue) {
808 case C_HUB_LOCAL_POWER:
809 case C_HUB_OVER_CURRENT:
810 /* no hub-wide feature/status flags */
811 break;
812 default:
813 goto error;
814 }
815 break;
816 case SetPortFeature:
817 selector = wIndex >> 8;
818 wIndex &= 0xff;
819 if (!wIndex || wIndex > ports)
820 goto error;
821 wIndex--;
822 temp = ehci_readl(ehci, status_reg);
823 if (temp & PORT_OWNER)
824 break;
825
826 temp &= ~PORT_RWC_BITS;
827 switch (wValue) {
828 case USB_PORT_FEAT_SUSPEND:
829 if (ehci->no_selective_suspend)
830 break;
831 if ((temp & PORT_PE) == 0
832 || (temp & PORT_RESET) != 0)
833 goto error;
834 ehci_writel(ehci, temp | PORT_SUSPEND, status_reg);
835 set_bit(wIndex, &ehci->suspended_ports);
836 break;
837 case USB_PORT_FEAT_POWER:
838 if (HCS_PPC (ehci->hcs_params))
839 ehci_writel(ehci, temp | PORT_POWER,
840 status_reg);
841 break;
842 case USB_PORT_FEAT_RESET:
843 if (temp & PORT_RESUME)
844 goto error;
845 /* line status bits may report this as low speed,
846 * which can be fine if this root hub has a
847 * transaction translator built in.
848 */
849 if ((temp & (PORT_PE|PORT_CONNECT)) == PORT_CONNECT
850 && !ehci_is_TDI(ehci)
851 && PORT_USB11 (temp)) {
852 ehci_dbg (ehci,
853 "port %d low speed --> companion\n",
854 wIndex + 1);
855 temp |= PORT_OWNER;
856 } else {
857 ehci_vdbg (ehci, "port %d reset\n", wIndex + 1);
858 temp |= PORT_RESET;
859 temp &= ~PORT_PE;
860
861 /*
862 * caller must wait, then call GetPortStatus
863 * usb 2.0 spec says 50 ms resets on root
864 */
865 ehci->reset_done [wIndex] = jiffies
866 + msecs_to_jiffies (50);
867 }
868 ehci_writel(ehci, temp, status_reg);
869 break;
870
871 /* For downstream facing ports (these): one hub port is put
872 * into test mode according to USB2 11.24.2.13, then the hub
873 * must be reset (which for root hub now means rmmod+modprobe,
874 * or else system reboot). See EHCI 2.3.9 and 4.14 for info
875 * about the EHCI-specific stuff.
876 */
877 case USB_PORT_FEAT_TEST:
878 if (!selector || selector > 5)
879 goto error;
880 ehci_quiesce(ehci);
881 ehci_halt(ehci);
882 temp |= selector << 16;
883 ehci_writel(ehci, temp, status_reg);
884 break;
885
886 default:
887 goto error;
888 }
889 ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */
890 break;
891
892 default:
893 error:
894 /* "stall" on error */
895 retval = -EPIPE;
896 }
897 spin_unlock_irqrestore (&ehci->lock, flags);
898 return retval;
899 }
900
901 static void ehci_relinquish_port(struct usb_hcd *hcd, int portnum)
902 {
903 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
904
905 if (ehci_is_TDI(ehci))
906 return;
907 set_owner(ehci, --portnum, PORT_OWNER);
908 }
909
910 static int ehci_port_handed_over(struct usb_hcd *hcd, int portnum)
911 {
912 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
913 u32 __iomem *reg;
914
915 if (ehci_is_TDI(ehci))
916 return 0;
917 reg = &ehci->regs->port_status[portnum - 1];
918 return ehci_readl(ehci, reg) & PORT_OWNER;
919 }
Linux with added FPC-III support