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