Merge commit 'v2.6.29' into timers/core
[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         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                 /* 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 }