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