Merge branch 'upstream-linus' of master.kernel.org:/pub/scm/linux/kernel/git/jgarzik...
[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 #ifdef  CONFIG_PM
32
33 static int ehci_bus_suspend (struct usb_hcd *hcd)
34 {
35         struct ehci_hcd         *ehci = hcd_to_ehci (hcd);
36         int                     port;
37         int                     mask;
38
39         ehci_dbg(ehci, "suspend root hub\n");
40
41         if (time_before (jiffies, ehci->next_statechange))
42                 msleep(5);
43
44         port = HCS_N_PORTS (ehci->hcs_params);
45         spin_lock_irq (&ehci->lock);
46
47         /* stop schedules, clean any completed work */
48         if (HC_IS_RUNNING(hcd->state)) {
49                 ehci_quiesce (ehci);
50                 hcd->state = HC_STATE_QUIESCING;
51         }
52         ehci->command = ehci_readl(ehci, &ehci->regs->command);
53         if (ehci->reclaim)
54                 ehci->reclaim_ready = 1;
55         ehci_work(ehci);
56
57         /* Unlike other USB host controller types, EHCI doesn't have
58          * any notion of "global" or bus-wide suspend.  The driver has
59          * to manually suspend all the active unsuspended ports, and
60          * then manually resume them in the bus_resume() routine.
61          */
62         ehci->bus_suspended = 0;
63         while (port--) {
64                 u32 __iomem     *reg = &ehci->regs->port_status [port];
65                 u32             t1 = ehci_readl(ehci, reg) & ~PORT_RWC_BITS;
66                 u32             t2 = t1;
67
68                 /* keep track of which ports we suspend */
69                 if ((t1 & PORT_PE) && !(t1 & PORT_OWNER) &&
70                                 !(t1 & PORT_SUSPEND)) {
71                         t2 |= PORT_SUSPEND;
72                         set_bit(port, &ehci->bus_suspended);
73                 }
74
75                 /* enable remote wakeup on all ports */
76                 if (device_may_wakeup(&hcd->self.root_hub->dev))
77                         t2 |= PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E;
78                 else
79                         t2 &= ~(PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E);
80
81                 if (t1 != t2) {
82                         ehci_vdbg (ehci, "port %d, %08x -> %08x\n",
83                                 port + 1, t1, t2);
84                         ehci_writel(ehci, t2, reg);
85                 }
86         }
87
88         /* turn off now-idle HC */
89         del_timer_sync (&ehci->watchdog);
90         ehci_halt (ehci);
91         hcd->state = HC_STATE_SUSPENDED;
92
93         /* allow remote wakeup */
94         mask = INTR_MASK;
95         if (!device_may_wakeup(&hcd->self.root_hub->dev))
96                 mask &= ~STS_PCD;
97         ehci_writel(ehci, mask, &ehci->regs->intr_enable);
98         ehci_readl(ehci, &ehci->regs->intr_enable);
99
100         ehci->next_statechange = jiffies + msecs_to_jiffies(10);
101         spin_unlock_irq (&ehci->lock);
102         return 0;
103 }
104
105
106 /* caller has locked the root hub, and should reset/reinit on error */
107 static int ehci_bus_resume (struct usb_hcd *hcd)
108 {
109         struct ehci_hcd         *ehci = hcd_to_ehci (hcd);
110         u32                     temp;
111         int                     i;
112
113         if (time_before (jiffies, ehci->next_statechange))
114                 msleep(5);
115         spin_lock_irq (&ehci->lock);
116
117         /* Ideally and we've got a real resume here, and no port's power
118          * was lost.  (For PCI, that means Vaux was maintained.)  But we
119          * could instead be restoring a swsusp snapshot -- so that BIOS was
120          * the last user of the controller, not reset/pm hardware keeping
121          * state we gave to it.
122          */
123         temp = ehci_readl(ehci, &ehci->regs->intr_enable);
124         ehci_dbg(ehci, "resume root hub%s\n", temp ? "" : " after power loss");
125
126         /* at least some APM implementations will try to deliver
127          * IRQs right away, so delay them until we're ready.
128          */
129         ehci_writel(ehci, 0, &ehci->regs->intr_enable);
130
131         /* re-init operational registers */
132         ehci_writel(ehci, 0, &ehci->regs->segment);
133         ehci_writel(ehci, ehci->periodic_dma, &ehci->regs->frame_list);
134         ehci_writel(ehci, (u32) ehci->async->qh_dma, &ehci->regs->async_next);
135
136         /* restore CMD_RUN, framelist size, and irq threshold */
137         ehci_writel(ehci, ehci->command, &ehci->regs->command);
138
139         /* manually resume the ports we suspended during bus_suspend() */
140         i = HCS_N_PORTS (ehci->hcs_params);
141         while (i--) {
142                 temp = ehci_readl(ehci, &ehci->regs->port_status [i]);
143                 temp &= ~(PORT_RWC_BITS
144                         | PORT_WKOC_E | PORT_WKDISC_E | PORT_WKCONN_E);
145                 if (test_bit(i, &ehci->bus_suspended) &&
146                                 (temp & PORT_SUSPEND)) {
147                         ehci->reset_done [i] = jiffies + msecs_to_jiffies (20);
148                         temp |= PORT_RESUME;
149                 }
150                 ehci_writel(ehci, temp, &ehci->regs->port_status [i]);
151         }
152         i = HCS_N_PORTS (ehci->hcs_params);
153         mdelay (20);
154         while (i--) {
155                 temp = ehci_readl(ehci, &ehci->regs->port_status [i]);
156                 if (test_bit(i, &ehci->bus_suspended) &&
157                                 (temp & PORT_SUSPEND)) {
158                         temp &= ~(PORT_RWC_BITS | PORT_RESUME);
159                         ehci_writel(ehci, temp, &ehci->regs->port_status [i]);
160                         ehci_vdbg (ehci, "resumed port %d\n", i + 1);
161                 }
162         }
163         (void) ehci_readl(ehci, &ehci->regs->command);
164
165         /* maybe re-activate the schedule(s) */
166         temp = 0;
167         if (ehci->async->qh_next.qh)
168                 temp |= CMD_ASE;
169         if (ehci->periodic_sched)
170                 temp |= CMD_PSE;
171         if (temp) {
172                 ehci->command |= temp;
173                 ehci_writel(ehci, ehci->command, &ehci->regs->command);
174         }
175
176         ehci->next_statechange = jiffies + msecs_to_jiffies(5);
177         hcd->state = HC_STATE_RUNNING;
178
179         /* Now we can safely re-enable irqs */
180         ehci_writel(ehci, INTR_MASK, &ehci->regs->intr_enable);
181
182         spin_unlock_irq (&ehci->lock);
183         return 0;
184 }
185
186 #else
187
188 #define ehci_bus_suspend        NULL
189 #define ehci_bus_resume         NULL
190
191 #endif  /* CONFIG_PM */
192
193 /*-------------------------------------------------------------------------*/
194
195 /* Display the ports dedicated to the companion controller */
196 static ssize_t show_companion(struct class_device *class_dev, char *buf)
197 {
198         struct ehci_hcd         *ehci;
199         int                     nports, index, n;
200         int                     count = PAGE_SIZE;
201         char                    *ptr = buf;
202
203         ehci = hcd_to_ehci(bus_to_hcd(class_get_devdata(class_dev)));
204         nports = HCS_N_PORTS(ehci->hcs_params);
205
206         for (index = 0; index < nports; ++index) {
207                 if (test_bit(index, &ehci->companion_ports)) {
208                         n = scnprintf(ptr, count, "%d\n", index + 1);
209                         ptr += n;
210                         count -= n;
211                 }
212         }
213         return ptr - buf;
214 }
215
216 /*
217  * Dedicate or undedicate a port to the companion controller.
218  * Syntax is "[-]portnum", where a leading '-' sign means
219  * return control of the port to the EHCI controller.
220  */
221 static ssize_t store_companion(struct class_device *class_dev,
222                 const char *buf, size_t count)
223 {
224         struct ehci_hcd         *ehci;
225         int                     portnum, new_owner, try;
226         u32 __iomem             *status_reg;
227         u32                     port_status;
228
229         ehci = hcd_to_ehci(bus_to_hcd(class_get_devdata(class_dev)));
230         new_owner = PORT_OWNER;         /* Owned by companion */
231         if (sscanf(buf, "%d", &portnum) != 1)
232                 return -EINVAL;
233         if (portnum < 0) {
234                 portnum = - portnum;
235                 new_owner = 0;          /* Owned by EHCI */
236         }
237         if (portnum <= 0 || portnum > HCS_N_PORTS(ehci->hcs_params))
238                 return -ENOENT;
239         status_reg = &ehci->regs->port_status[--portnum];
240         if (new_owner)
241                 set_bit(portnum, &ehci->companion_ports);
242         else
243                 clear_bit(portnum, &ehci->companion_ports);
244
245         /*
246          * The controller won't set the OWNER bit if the port is
247          * enabled, so this loop will sometimes require at least two
248          * iterations: one to disable the port and one to set OWNER.
249          */
250
251         for (try = 4; try > 0; --try) {
252                 spin_lock_irq(&ehci->lock);
253                 port_status = ehci_readl(ehci, status_reg);
254                 if ((port_status & PORT_OWNER) == new_owner
255                                 || (port_status & (PORT_OWNER | PORT_CONNECT))
256                                         == 0)
257                         try = 0;
258                 else {
259                         port_status ^= PORT_OWNER;
260                         port_status &= ~(PORT_PE | PORT_RWC_BITS);
261                         ehci_writel(ehci, port_status, status_reg);
262                 }
263                 spin_unlock_irq(&ehci->lock);
264                 if (try > 1)
265                         msleep(5);
266         }
267         return count;
268 }
269 static CLASS_DEVICE_ATTR(companion, 0644, show_companion, store_companion);
270
271 static inline void create_companion_file(struct ehci_hcd *ehci)
272 {
273         int     i;
274
275         /* with integrated TT there is no companion! */
276         if (!ehci_is_TDI(ehci))
277                 i = class_device_create_file(ehci_to_hcd(ehci)->self.class_dev,
278                                 &class_device_attr_companion);
279 }
280
281 static inline void remove_companion_file(struct ehci_hcd *ehci)
282 {
283         /* with integrated TT there is no companion! */
284         if (!ehci_is_TDI(ehci))
285                 class_device_remove_file(ehci_to_hcd(ehci)->self.class_dev,
286                                 &class_device_attr_companion);
287 }
288
289
290 /*-------------------------------------------------------------------------*/
291
292 static int check_reset_complete (
293         struct ehci_hcd *ehci,
294         int             index,
295         u32 __iomem     *status_reg,
296         int             port_status
297 ) {
298         if (!(port_status & PORT_CONNECT)) {
299                 ehci->reset_done [index] = 0;
300                 return port_status;
301         }
302
303         /* if reset finished and it's still not enabled -- handoff */
304         if (!(port_status & PORT_PE)) {
305
306                 /* with integrated TT, there's nobody to hand it to! */
307                 if (ehci_is_TDI(ehci)) {
308                         ehci_dbg (ehci,
309                                 "Failed to enable port %d on root hub TT\n",
310                                 index+1);
311                         return port_status;
312                 }
313
314                 ehci_dbg (ehci, "port %d full speed --> companion\n",
315                         index + 1);
316
317                 // what happens if HCS_N_CC(params) == 0 ?
318                 port_status |= PORT_OWNER;
319                 port_status &= ~PORT_RWC_BITS;
320                 ehci_writel(ehci, port_status, status_reg);
321
322         } else
323                 ehci_dbg (ehci, "port %d high speed\n", index + 1);
324
325         return port_status;
326 }
327
328 /*-------------------------------------------------------------------------*/
329
330
331 /* build "status change" packet (one or two bytes) from HC registers */
332
333 static int
334 ehci_hub_status_data (struct usb_hcd *hcd, char *buf)
335 {
336         struct ehci_hcd *ehci = hcd_to_ehci (hcd);
337         u32             temp, status = 0;
338         u32             mask;
339         int             ports, i, retval = 1;
340         unsigned long   flags;
341
342         /* if !USB_SUSPEND, root hub timers won't get shut down ... */
343         if (!HC_IS_RUNNING(hcd->state))
344                 return 0;
345
346         /* init status to no-changes */
347         buf [0] = 0;
348         ports = HCS_N_PORTS (ehci->hcs_params);
349         if (ports > 7) {
350                 buf [1] = 0;
351                 retval++;
352         }
353
354         /* Some boards (mostly VIA?) report bogus overcurrent indications,
355          * causing massive log spam unless we completely ignore them.  It
356          * may be relevant that VIA VT8235 controlers, where PORT_POWER is
357          * always set, seem to clear PORT_OCC and PORT_CSC when writing to
358          * PORT_POWER; that's surprising, but maybe within-spec.
359          */
360         if (!ignore_oc)
361                 mask = PORT_CSC | PORT_PEC | PORT_OCC;
362         else
363                 mask = PORT_CSC | PORT_PEC;
364         // PORT_RESUME from hardware ~= PORT_STAT_C_SUSPEND
365
366         /* no hub change reports (bit 0) for now (power, ...) */
367
368         /* port N changes (bit N)? */
369         spin_lock_irqsave (&ehci->lock, flags);
370         for (i = 0; i < ports; i++) {
371                 temp = ehci_readl(ehci, &ehci->regs->port_status [i]);
372
373                 /*
374                  * Return status information even for ports with OWNER set.
375                  * Otherwise khubd wouldn't see the disconnect event when a
376                  * high-speed device is switched over to the companion
377                  * controller by the user.
378                  */
379
380                 if (!(temp & PORT_CONNECT))
381                         ehci->reset_done [i] = 0;
382                 if ((temp & mask) != 0
383                                 || ((temp & PORT_RESUME) != 0
384                                         && time_after_eq(jiffies,
385                                                 ehci->reset_done[i]))) {
386                         if (i < 7)
387                             buf [0] |= 1 << (i + 1);
388                         else
389                             buf [1] |= 1 << (i - 7);
390                         status = STS_PCD;
391                 }
392         }
393         /* FIXME autosuspend idle root hubs */
394         spin_unlock_irqrestore (&ehci->lock, flags);
395         return status ? retval : 0;
396 }
397
398 /*-------------------------------------------------------------------------*/
399
400 static void
401 ehci_hub_descriptor (
402         struct ehci_hcd                 *ehci,
403         struct usb_hub_descriptor       *desc
404 ) {
405         int             ports = HCS_N_PORTS (ehci->hcs_params);
406         u16             temp;
407
408         desc->bDescriptorType = 0x29;
409         desc->bPwrOn2PwrGood = 10;      /* ehci 1.0, 2.3.9 says 20ms max */
410         desc->bHubContrCurrent = 0;
411
412         desc->bNbrPorts = ports;
413         temp = 1 + (ports / 8);
414         desc->bDescLength = 7 + 2 * temp;
415
416         /* two bitmaps:  ports removable, and usb 1.0 legacy PortPwrCtrlMask */
417         memset (&desc->bitmap [0], 0, temp);
418         memset (&desc->bitmap [temp], 0xff, temp);
419
420         temp = 0x0008;                  /* per-port overcurrent reporting */
421         if (HCS_PPC (ehci->hcs_params))
422                 temp |= 0x0001;         /* per-port power control */
423         else
424                 temp |= 0x0002;         /* no power switching */
425 #if 0
426 // re-enable when we support USB_PORT_FEAT_INDICATOR below.
427         if (HCS_INDICATOR (ehci->hcs_params))
428                 temp |= 0x0080;         /* per-port indicators (LEDs) */
429 #endif
430         desc->wHubCharacteristics = (__force __u16)cpu_to_le16 (temp);
431 }
432
433 /*-------------------------------------------------------------------------*/
434
435 #define PORT_WAKE_BITS  (PORT_WKOC_E|PORT_WKDISC_E|PORT_WKCONN_E)
436
437 static int ehci_hub_control (
438         struct usb_hcd  *hcd,
439         u16             typeReq,
440         u16             wValue,
441         u16             wIndex,
442         char            *buf,
443         u16             wLength
444 ) {
445         struct ehci_hcd *ehci = hcd_to_ehci (hcd);
446         int             ports = HCS_N_PORTS (ehci->hcs_params);
447         u32 __iomem     *status_reg = &ehci->regs->port_status[wIndex - 1];
448         u32             temp, status;
449         unsigned long   flags;
450         int             retval = 0;
451         unsigned        selector;
452
453         /*
454          * FIXME:  support SetPortFeatures USB_PORT_FEAT_INDICATOR.
455          * HCS_INDICATOR may say we can change LEDs to off/amber/green.
456          * (track current state ourselves) ... blink for diagnostics,
457          * power, "this is the one", etc.  EHCI spec supports this.
458          */
459
460         spin_lock_irqsave (&ehci->lock, flags);
461         switch (typeReq) {
462         case ClearHubFeature:
463                 switch (wValue) {
464                 case C_HUB_LOCAL_POWER:
465                 case C_HUB_OVER_CURRENT:
466                         /* no hub-wide feature/status flags */
467                         break;
468                 default:
469                         goto error;
470                 }
471                 break;
472         case ClearPortFeature:
473                 if (!wIndex || wIndex > ports)
474                         goto error;
475                 wIndex--;
476                 temp = ehci_readl(ehci, status_reg);
477
478                 /*
479                  * Even if OWNER is set, so the port is owned by the
480                  * companion controller, khubd needs to be able to clear
481                  * the port-change status bits (especially
482                  * USB_PORT_FEAT_C_CONNECTION).
483                  */
484
485                 switch (wValue) {
486                 case USB_PORT_FEAT_ENABLE:
487                         ehci_writel(ehci, temp & ~PORT_PE, status_reg);
488                         break;
489                 case USB_PORT_FEAT_C_ENABLE:
490                         ehci_writel(ehci, (temp & ~PORT_RWC_BITS) | PORT_PEC,
491                                         status_reg);
492                         break;
493                 case USB_PORT_FEAT_SUSPEND:
494                         if (temp & PORT_RESET)
495                                 goto error;
496                         if (ehci->no_selective_suspend)
497                                 break;
498                         if (temp & PORT_SUSPEND) {
499                                 if ((temp & PORT_PE) == 0)
500                                         goto error;
501                                 /* resume signaling for 20 msec */
502                                 temp &= ~(PORT_RWC_BITS | PORT_WAKE_BITS);
503                                 ehci_writel(ehci, temp | PORT_RESUME,
504                                                 status_reg);
505                                 ehci->reset_done [wIndex] = jiffies
506                                                 + msecs_to_jiffies (20);
507                         }
508                         break;
509                 case USB_PORT_FEAT_C_SUSPEND:
510                         /* we auto-clear this feature */
511                         break;
512                 case USB_PORT_FEAT_POWER:
513                         if (HCS_PPC (ehci->hcs_params))
514                                 ehci_writel(ehci,
515                                           temp & ~(PORT_RWC_BITS | PORT_POWER),
516                                           status_reg);
517                         break;
518                 case USB_PORT_FEAT_C_CONNECTION:
519                         ehci_writel(ehci, (temp & ~PORT_RWC_BITS) | PORT_CSC,
520                                         status_reg);
521                         break;
522                 case USB_PORT_FEAT_C_OVER_CURRENT:
523                         ehci_writel(ehci, (temp & ~PORT_RWC_BITS) | PORT_OCC,
524                                         status_reg);
525                         break;
526                 case USB_PORT_FEAT_C_RESET:
527                         /* GetPortStatus clears reset */
528                         break;
529                 default:
530                         goto error;
531                 }
532                 ehci_readl(ehci, &ehci->regs->command); /* unblock posted write */
533                 break;
534         case GetHubDescriptor:
535                 ehci_hub_descriptor (ehci, (struct usb_hub_descriptor *)
536                         buf);
537                 break;
538         case GetHubStatus:
539                 /* no hub-wide feature/status flags */
540                 memset (buf, 0, 4);
541                 //cpu_to_le32s ((u32 *) buf);
542                 break;
543         case GetPortStatus:
544                 if (!wIndex || wIndex > ports)
545                         goto error;
546                 wIndex--;
547                 status = 0;
548                 temp = ehci_readl(ehci, status_reg);
549
550                 // wPortChange bits
551                 if (temp & PORT_CSC)
552                         status |= 1 << USB_PORT_FEAT_C_CONNECTION;
553                 if (temp & PORT_PEC)
554                         status |= 1 << USB_PORT_FEAT_C_ENABLE;
555                 if ((temp & PORT_OCC) && !ignore_oc)
556                         status |= 1 << USB_PORT_FEAT_C_OVER_CURRENT;
557
558                 /* whoever resumes must GetPortStatus to complete it!! */
559                 if (temp & PORT_RESUME) {
560
561                         /* Remote Wakeup received? */
562                         if (!ehci->reset_done[wIndex]) {
563                                 /* resume signaling for 20 msec */
564                                 ehci->reset_done[wIndex] = jiffies
565                                                 + msecs_to_jiffies(20);
566                                 /* check the port again */
567                                 mod_timer(&ehci_to_hcd(ehci)->rh_timer,
568                                                 ehci->reset_done[wIndex]);
569                         }
570
571                         /* resume completed? */
572                         else if (time_after_eq(jiffies,
573                                         ehci->reset_done[wIndex])) {
574                                 status |= 1 << USB_PORT_FEAT_C_SUSPEND;
575                                 ehci->reset_done[wIndex] = 0;
576
577                                 /* stop resume signaling */
578                                 temp = ehci_readl(ehci, status_reg);
579                                 ehci_writel(ehci,
580                                         temp & ~(PORT_RWC_BITS | PORT_RESUME),
581                                         status_reg);
582                                 retval = handshake(ehci, status_reg,
583                                            PORT_RESUME, 0, 2000 /* 2msec */);
584                                 if (retval != 0) {
585                                         ehci_err(ehci,
586                                                 "port %d resume error %d\n",
587                                                 wIndex + 1, retval);
588                                         goto error;
589                                 }
590                                 temp &= ~(PORT_SUSPEND|PORT_RESUME|(3<<10));
591                         }
592                 }
593
594                 /* whoever resets must GetPortStatus to complete it!! */
595                 if ((temp & PORT_RESET)
596                                 && time_after_eq(jiffies,
597                                         ehci->reset_done[wIndex])) {
598                         status |= 1 << USB_PORT_FEAT_C_RESET;
599                         ehci->reset_done [wIndex] = 0;
600
601                         /* force reset to complete */
602                         ehci_writel(ehci, temp & ~(PORT_RWC_BITS | PORT_RESET),
603                                         status_reg);
604                         /* REVISIT:  some hardware needs 550+ usec to clear
605                          * this bit; seems too long to spin routinely...
606                          */
607                         retval = handshake(ehci, status_reg,
608                                         PORT_RESET, 0, 750);
609                         if (retval != 0) {
610                                 ehci_err (ehci, "port %d reset error %d\n",
611                                         wIndex + 1, retval);
612                                 goto error;
613                         }
614
615                         /* see what we found out */
616                         temp = check_reset_complete (ehci, wIndex, status_reg,
617                                         ehci_readl(ehci, status_reg));
618                 }
619
620                 /* transfer dedicated ports to the companion hc */
621                 if ((temp & PORT_CONNECT) &&
622                                 test_bit(wIndex, &ehci->companion_ports)) {
623                         temp &= ~PORT_RWC_BITS;
624                         temp |= PORT_OWNER;
625                         ehci_writel(ehci, temp, status_reg);
626                         ehci_dbg(ehci, "port %d --> companion\n", wIndex + 1);
627                         temp = ehci_readl(ehci, status_reg);
628                 }
629
630                 /*
631                  * Even if OWNER is set, there's no harm letting khubd
632                  * see the wPortStatus values (they should all be 0 except
633                  * for PORT_POWER anyway).
634                  */
635
636                 if (temp & PORT_CONNECT) {
637                         status |= 1 << USB_PORT_FEAT_CONNECTION;
638                         // status may be from integrated TT
639                         status |= ehci_port_speed(ehci, temp);
640                 }
641                 if (temp & PORT_PE)
642                         status |= 1 << USB_PORT_FEAT_ENABLE;
643                 if (temp & (PORT_SUSPEND|PORT_RESUME))
644                         status |= 1 << USB_PORT_FEAT_SUSPEND;
645                 if (temp & PORT_OC)
646                         status |= 1 << USB_PORT_FEAT_OVER_CURRENT;
647                 if (temp & PORT_RESET)
648                         status |= 1 << USB_PORT_FEAT_RESET;
649                 if (temp & PORT_POWER)
650                         status |= 1 << USB_PORT_FEAT_POWER;
651
652 #ifndef EHCI_VERBOSE_DEBUG
653         if (status & ~0xffff)   /* only if wPortChange is interesting */
654 #endif
655                 dbg_port (ehci, "GetStatus", wIndex + 1, temp);
656                 // we "know" this alignment is good, caller used kmalloc()...
657                 *((__le32 *) buf) = cpu_to_le32 (status);
658                 break;
659         case SetHubFeature:
660                 switch (wValue) {
661                 case C_HUB_LOCAL_POWER:
662                 case C_HUB_OVER_CURRENT:
663                         /* no hub-wide feature/status flags */
664                         break;
665                 default:
666                         goto error;
667                 }
668                 break;
669         case SetPortFeature:
670                 selector = wIndex >> 8;
671                 wIndex &= 0xff;
672                 if (!wIndex || wIndex > ports)
673                         goto error;
674                 wIndex--;
675                 temp = ehci_readl(ehci, status_reg);
676                 if (temp & PORT_OWNER)
677                         break;
678
679                 temp &= ~PORT_RWC_BITS;
680                 switch (wValue) {
681                 case USB_PORT_FEAT_SUSPEND:
682                         if (ehci->no_selective_suspend)
683                                 break;
684                         if ((temp & PORT_PE) == 0
685                                         || (temp & PORT_RESET) != 0)
686                                 goto error;
687                         if (device_may_wakeup(&hcd->self.root_hub->dev))
688                                 temp |= PORT_WAKE_BITS;
689                         ehci_writel(ehci, temp | PORT_SUSPEND, status_reg);
690                         break;
691                 case USB_PORT_FEAT_POWER:
692                         if (HCS_PPC (ehci->hcs_params))
693                                 ehci_writel(ehci, temp | PORT_POWER,
694                                                 status_reg);
695                         break;
696                 case USB_PORT_FEAT_RESET:
697                         if (temp & PORT_RESUME)
698                                 goto error;
699                         /* line status bits may report this as low speed,
700                          * which can be fine if this root hub has a
701                          * transaction translator built in.
702                          */
703                         if ((temp & (PORT_PE|PORT_CONNECT)) == PORT_CONNECT
704                                         && !ehci_is_TDI(ehci)
705                                         && PORT_USB11 (temp)) {
706                                 ehci_dbg (ehci,
707                                         "port %d low speed --> companion\n",
708                                         wIndex + 1);
709                                 temp |= PORT_OWNER;
710                         } else {
711                                 ehci_vdbg (ehci, "port %d reset\n", wIndex + 1);
712                                 temp |= PORT_RESET;
713                                 temp &= ~PORT_PE;
714
715                                 /*
716                                  * caller must wait, then call GetPortStatus
717                                  * usb 2.0 spec says 50 ms resets on root
718                                  */
719                                 ehci->reset_done [wIndex] = jiffies
720                                                 + msecs_to_jiffies (50);
721                         }
722                         ehci_writel(ehci, temp, status_reg);
723                         break;
724
725                 /* For downstream facing ports (these):  one hub port is put
726                  * into test mode according to USB2 11.24.2.13, then the hub
727                  * must be reset (which for root hub now means rmmod+modprobe,
728                  * or else system reboot).  See EHCI 2.3.9 and 4.14 for info
729                  * about the EHCI-specific stuff.
730                  */
731                 case USB_PORT_FEAT_TEST:
732                         if (!selector || selector > 5)
733                                 goto error;
734                         ehci_quiesce(ehci);
735                         ehci_halt(ehci);
736                         temp |= selector << 16;
737                         ehci_writel(ehci, temp, status_reg);
738                         break;
739
740                 default:
741                         goto error;
742                 }
743                 ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */
744                 break;
745
746         default:
747 error:
748                 /* "stall" on error */
749                 retval = -EPIPE;
750         }
751         spin_unlock_irqrestore (&ehci->lock, flags);
752         return retval;
753 }