Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6.git] / drivers / usb / core / hcd.c
1 /*
2  * (C) Copyright Linus Torvalds 1999
3  * (C) Copyright Johannes Erdfelt 1999-2001
4  * (C) Copyright Andreas Gal 1999
5  * (C) Copyright Gregory P. Smith 1999
6  * (C) Copyright Deti Fliegl 1999
7  * (C) Copyright Randy Dunlap 2000
8  * (C) Copyright David Brownell 2000-2002
9  * 
10  * This program is free software; you can redistribute it and/or modify it
11  * under the terms of the GNU General Public License as published by the
12  * Free Software Foundation; either version 2 of the License, or (at your
13  * option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful, but
16  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
17  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
18  * for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software Foundation,
22  * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23  */
24
25 #include <linux/module.h>
26 #include <linux/version.h>
27 #include <linux/kernel.h>
28 #include <linux/slab.h>
29 #include <linux/completion.h>
30 #include <linux/utsname.h>
31 #include <linux/mm.h>
32 #include <asm/io.h>
33 #include <linux/device.h>
34 #include <linux/dma-mapping.h>
35 #include <linux/mutex.h>
36 #include <asm/irq.h>
37 #include <asm/byteorder.h>
38 #include <asm/unaligned.h>
39 #include <linux/platform_device.h>
40 #include <linux/workqueue.h>
41 #include <linux/mutex.h>
42 #include <linux/pm_runtime.h>
43
44 #include <linux/usb.h>
45
46 #include "usb.h"
47 #include "hcd.h"
48 #include "hub.h"
49
50
51 /*-------------------------------------------------------------------------*/
52
53 /*
54  * USB Host Controller Driver framework
55  *
56  * Plugs into usbcore (usb_bus) and lets HCDs share code, minimizing
57  * HCD-specific behaviors/bugs.
58  *
59  * This does error checks, tracks devices and urbs, and delegates to a
60  * "hc_driver" only for code (and data) that really needs to know about
61  * hardware differences.  That includes root hub registers, i/o queues,
62  * and so on ... but as little else as possible.
63  *
64  * Shared code includes most of the "root hub" code (these are emulated,
65  * though each HC's hardware works differently) and PCI glue, plus request
66  * tracking overhead.  The HCD code should only block on spinlocks or on
67  * hardware handshaking; blocking on software events (such as other kernel
68  * threads releasing resources, or completing actions) is all generic.
69  *
70  * Happens the USB 2.0 spec says this would be invisible inside the "USBD",
71  * and includes mostly a "HCDI" (HCD Interface) along with some APIs used
72  * only by the hub driver ... and that neither should be seen or used by
73  * usb client device drivers.
74  *
75  * Contributors of ideas or unattributed patches include: David Brownell,
76  * Roman Weissgaerber, Rory Bolt, Greg Kroah-Hartman, ...
77  *
78  * HISTORY:
79  * 2002-02-21   Pull in most of the usb_bus support from usb.c; some
80  *              associated cleanup.  "usb_hcd" still != "usb_bus".
81  * 2001-12-12   Initial patch version for Linux 2.5.1 kernel.
82  */
83
84 /*-------------------------------------------------------------------------*/
85
86 /* Keep track of which host controller drivers are loaded */
87 unsigned long usb_hcds_loaded;
88 EXPORT_SYMBOL_GPL(usb_hcds_loaded);
89
90 /* host controllers we manage */
91 LIST_HEAD (usb_bus_list);
92 EXPORT_SYMBOL_GPL (usb_bus_list);
93
94 /* used when allocating bus numbers */
95 #define USB_MAXBUS              64
96 struct usb_busmap {
97         unsigned long busmap [USB_MAXBUS / (8*sizeof (unsigned long))];
98 };
99 static struct usb_busmap busmap;
100
101 /* used when updating list of hcds */
102 DEFINE_MUTEX(usb_bus_list_lock);        /* exported only for usbfs */
103 EXPORT_SYMBOL_GPL (usb_bus_list_lock);
104
105 /* used for controlling access to virtual root hubs */
106 static DEFINE_SPINLOCK(hcd_root_hub_lock);
107
108 /* used when updating an endpoint's URB list */
109 static DEFINE_SPINLOCK(hcd_urb_list_lock);
110
111 /* used to protect against unlinking URBs after the device is gone */
112 static DEFINE_SPINLOCK(hcd_urb_unlink_lock);
113
114 /* wait queue for synchronous unlinks */
115 DECLARE_WAIT_QUEUE_HEAD(usb_kill_urb_queue);
116
117 static inline int is_root_hub(struct usb_device *udev)
118 {
119         return (udev->parent == NULL);
120 }
121
122 /*-------------------------------------------------------------------------*/
123
124 /*
125  * Sharable chunks of root hub code.
126  */
127
128 /*-------------------------------------------------------------------------*/
129
130 #define KERNEL_REL      ((LINUX_VERSION_CODE >> 16) & 0x0ff)
131 #define KERNEL_VER      ((LINUX_VERSION_CODE >> 8) & 0x0ff)
132
133 /* usb 3.0 root hub device descriptor */
134 static const u8 usb3_rh_dev_descriptor[18] = {
135         0x12,       /*  __u8  bLength; */
136         0x01,       /*  __u8  bDescriptorType; Device */
137         0x00, 0x03, /*  __le16 bcdUSB; v3.0 */
138
139         0x09,       /*  __u8  bDeviceClass; HUB_CLASSCODE */
140         0x00,       /*  __u8  bDeviceSubClass; */
141         0x03,       /*  __u8  bDeviceProtocol; USB 3.0 hub */
142         0x09,       /*  __u8  bMaxPacketSize0; 2^9 = 512 Bytes */
143
144         0x6b, 0x1d, /*  __le16 idVendor; Linux Foundation */
145         0x03, 0x00, /*  __le16 idProduct; device 0x0003 */
146         KERNEL_VER, KERNEL_REL, /*  __le16 bcdDevice */
147
148         0x03,       /*  __u8  iManufacturer; */
149         0x02,       /*  __u8  iProduct; */
150         0x01,       /*  __u8  iSerialNumber; */
151         0x01        /*  __u8  bNumConfigurations; */
152 };
153
154 /* usb 2.0 root hub device descriptor */
155 static const u8 usb2_rh_dev_descriptor [18] = {
156         0x12,       /*  __u8  bLength; */
157         0x01,       /*  __u8  bDescriptorType; Device */
158         0x00, 0x02, /*  __le16 bcdUSB; v2.0 */
159
160         0x09,       /*  __u8  bDeviceClass; HUB_CLASSCODE */
161         0x00,       /*  __u8  bDeviceSubClass; */
162         0x00,       /*  __u8  bDeviceProtocol; [ usb 2.0 no TT ] */
163         0x40,       /*  __u8  bMaxPacketSize0; 64 Bytes */
164
165         0x6b, 0x1d, /*  __le16 idVendor; Linux Foundation */
166         0x02, 0x00, /*  __le16 idProduct; device 0x0002 */
167         KERNEL_VER, KERNEL_REL, /*  __le16 bcdDevice */
168
169         0x03,       /*  __u8  iManufacturer; */
170         0x02,       /*  __u8  iProduct; */
171         0x01,       /*  __u8  iSerialNumber; */
172         0x01        /*  __u8  bNumConfigurations; */
173 };
174
175 /* no usb 2.0 root hub "device qualifier" descriptor: one speed only */
176
177 /* usb 1.1 root hub device descriptor */
178 static const u8 usb11_rh_dev_descriptor [18] = {
179         0x12,       /*  __u8  bLength; */
180         0x01,       /*  __u8  bDescriptorType; Device */
181         0x10, 0x01, /*  __le16 bcdUSB; v1.1 */
182
183         0x09,       /*  __u8  bDeviceClass; HUB_CLASSCODE */
184         0x00,       /*  __u8  bDeviceSubClass; */
185         0x00,       /*  __u8  bDeviceProtocol; [ low/full speeds only ] */
186         0x40,       /*  __u8  bMaxPacketSize0; 64 Bytes */
187
188         0x6b, 0x1d, /*  __le16 idVendor; Linux Foundation */
189         0x01, 0x00, /*  __le16 idProduct; device 0x0001 */
190         KERNEL_VER, KERNEL_REL, /*  __le16 bcdDevice */
191
192         0x03,       /*  __u8  iManufacturer; */
193         0x02,       /*  __u8  iProduct; */
194         0x01,       /*  __u8  iSerialNumber; */
195         0x01        /*  __u8  bNumConfigurations; */
196 };
197
198
199 /*-------------------------------------------------------------------------*/
200
201 /* Configuration descriptors for our root hubs */
202
203 static const u8 fs_rh_config_descriptor [] = {
204
205         /* one configuration */
206         0x09,       /*  __u8  bLength; */
207         0x02,       /*  __u8  bDescriptorType; Configuration */
208         0x19, 0x00, /*  __le16 wTotalLength; */
209         0x01,       /*  __u8  bNumInterfaces; (1) */
210         0x01,       /*  __u8  bConfigurationValue; */
211         0x00,       /*  __u8  iConfiguration; */
212         0xc0,       /*  __u8  bmAttributes; 
213                                  Bit 7: must be set,
214                                      6: Self-powered,
215                                      5: Remote wakeup,
216                                      4..0: resvd */
217         0x00,       /*  __u8  MaxPower; */
218       
219         /* USB 1.1:
220          * USB 2.0, single TT organization (mandatory):
221          *      one interface, protocol 0
222          *
223          * USB 2.0, multiple TT organization (optional):
224          *      two interfaces, protocols 1 (like single TT)
225          *      and 2 (multiple TT mode) ... config is
226          *      sometimes settable
227          *      NOT IMPLEMENTED
228          */
229
230         /* one interface */
231         0x09,       /*  __u8  if_bLength; */
232         0x04,       /*  __u8  if_bDescriptorType; Interface */
233         0x00,       /*  __u8  if_bInterfaceNumber; */
234         0x00,       /*  __u8  if_bAlternateSetting; */
235         0x01,       /*  __u8  if_bNumEndpoints; */
236         0x09,       /*  __u8  if_bInterfaceClass; HUB_CLASSCODE */
237         0x00,       /*  __u8  if_bInterfaceSubClass; */
238         0x00,       /*  __u8  if_bInterfaceProtocol; [usb1.1 or single tt] */
239         0x00,       /*  __u8  if_iInterface; */
240      
241         /* one endpoint (status change endpoint) */
242         0x07,       /*  __u8  ep_bLength; */
243         0x05,       /*  __u8  ep_bDescriptorType; Endpoint */
244         0x81,       /*  __u8  ep_bEndpointAddress; IN Endpoint 1 */
245         0x03,       /*  __u8  ep_bmAttributes; Interrupt */
246         0x02, 0x00, /*  __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8) */
247         0xff        /*  __u8  ep_bInterval; (255ms -- usb 2.0 spec) */
248 };
249
250 static const u8 hs_rh_config_descriptor [] = {
251
252         /* one configuration */
253         0x09,       /*  __u8  bLength; */
254         0x02,       /*  __u8  bDescriptorType; Configuration */
255         0x19, 0x00, /*  __le16 wTotalLength; */
256         0x01,       /*  __u8  bNumInterfaces; (1) */
257         0x01,       /*  __u8  bConfigurationValue; */
258         0x00,       /*  __u8  iConfiguration; */
259         0xc0,       /*  __u8  bmAttributes; 
260                                  Bit 7: must be set,
261                                      6: Self-powered,
262                                      5: Remote wakeup,
263                                      4..0: resvd */
264         0x00,       /*  __u8  MaxPower; */
265       
266         /* USB 1.1:
267          * USB 2.0, single TT organization (mandatory):
268          *      one interface, protocol 0
269          *
270          * USB 2.0, multiple TT organization (optional):
271          *      two interfaces, protocols 1 (like single TT)
272          *      and 2 (multiple TT mode) ... config is
273          *      sometimes settable
274          *      NOT IMPLEMENTED
275          */
276
277         /* one interface */
278         0x09,       /*  __u8  if_bLength; */
279         0x04,       /*  __u8  if_bDescriptorType; Interface */
280         0x00,       /*  __u8  if_bInterfaceNumber; */
281         0x00,       /*  __u8  if_bAlternateSetting; */
282         0x01,       /*  __u8  if_bNumEndpoints; */
283         0x09,       /*  __u8  if_bInterfaceClass; HUB_CLASSCODE */
284         0x00,       /*  __u8  if_bInterfaceSubClass; */
285         0x00,       /*  __u8  if_bInterfaceProtocol; [usb1.1 or single tt] */
286         0x00,       /*  __u8  if_iInterface; */
287      
288         /* one endpoint (status change endpoint) */
289         0x07,       /*  __u8  ep_bLength; */
290         0x05,       /*  __u8  ep_bDescriptorType; Endpoint */
291         0x81,       /*  __u8  ep_bEndpointAddress; IN Endpoint 1 */
292         0x03,       /*  __u8  ep_bmAttributes; Interrupt */
293                     /* __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8)
294                      * see hub.c:hub_configure() for details. */
295         (USB_MAXCHILDREN + 1 + 7) / 8, 0x00,
296         0x0c        /*  __u8  ep_bInterval; (256ms -- usb 2.0 spec) */
297 };
298
299 static const u8 ss_rh_config_descriptor[] = {
300         /* one configuration */
301         0x09,       /*  __u8  bLength; */
302         0x02,       /*  __u8  bDescriptorType; Configuration */
303         0x19, 0x00, /*  __le16 wTotalLength; FIXME */
304         0x01,       /*  __u8  bNumInterfaces; (1) */
305         0x01,       /*  __u8  bConfigurationValue; */
306         0x00,       /*  __u8  iConfiguration; */
307         0xc0,       /*  __u8  bmAttributes;
308                                  Bit 7: must be set,
309                                      6: Self-powered,
310                                      5: Remote wakeup,
311                                      4..0: resvd */
312         0x00,       /*  __u8  MaxPower; */
313
314         /* one interface */
315         0x09,       /*  __u8  if_bLength; */
316         0x04,       /*  __u8  if_bDescriptorType; Interface */
317         0x00,       /*  __u8  if_bInterfaceNumber; */
318         0x00,       /*  __u8  if_bAlternateSetting; */
319         0x01,       /*  __u8  if_bNumEndpoints; */
320         0x09,       /*  __u8  if_bInterfaceClass; HUB_CLASSCODE */
321         0x00,       /*  __u8  if_bInterfaceSubClass; */
322         0x00,       /*  __u8  if_bInterfaceProtocol; */
323         0x00,       /*  __u8  if_iInterface; */
324
325         /* one endpoint (status change endpoint) */
326         0x07,       /*  __u8  ep_bLength; */
327         0x05,       /*  __u8  ep_bDescriptorType; Endpoint */
328         0x81,       /*  __u8  ep_bEndpointAddress; IN Endpoint 1 */
329         0x03,       /*  __u8  ep_bmAttributes; Interrupt */
330                     /* __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8)
331                      * see hub.c:hub_configure() for details. */
332         (USB_MAXCHILDREN + 1 + 7) / 8, 0x00,
333         0x0c        /*  __u8  ep_bInterval; (256ms -- usb 2.0 spec) */
334         /*
335          * All 3.0 hubs should have an endpoint companion descriptor,
336          * but we're ignoring that for now.  FIXME?
337          */
338 };
339
340 /*-------------------------------------------------------------------------*/
341
342 /**
343  * ascii2desc() - Helper routine for producing UTF-16LE string descriptors
344  * @s: Null-terminated ASCII (actually ISO-8859-1) string
345  * @buf: Buffer for USB string descriptor (header + UTF-16LE)
346  * @len: Length (in bytes; may be odd) of descriptor buffer.
347  *
348  * The return value is the number of bytes filled in: 2 + 2*strlen(s) or
349  * buflen, whichever is less.
350  *
351  * USB String descriptors can contain at most 126 characters; input
352  * strings longer than that are truncated.
353  */
354 static unsigned
355 ascii2desc(char const *s, u8 *buf, unsigned len)
356 {
357         unsigned n, t = 2 + 2*strlen(s);
358
359         if (t > 254)
360                 t = 254;        /* Longest possible UTF string descriptor */
361         if (len > t)
362                 len = t;
363
364         t += USB_DT_STRING << 8;        /* Now t is first 16 bits to store */
365
366         n = len;
367         while (n--) {
368                 *buf++ = t;
369                 if (!n--)
370                         break;
371                 *buf++ = t >> 8;
372                 t = (unsigned char)*s++;
373         }
374         return len;
375 }
376
377 /**
378  * rh_string() - provides string descriptors for root hub
379  * @id: the string ID number (0: langids, 1: serial #, 2: product, 3: vendor)
380  * @hcd: the host controller for this root hub
381  * @data: buffer for output packet
382  * @len: length of the provided buffer
383  *
384  * Produces either a manufacturer, product or serial number string for the
385  * virtual root hub device.
386  * Returns the number of bytes filled in: the length of the descriptor or
387  * of the provided buffer, whichever is less.
388  */
389 static unsigned
390 rh_string(int id, struct usb_hcd const *hcd, u8 *data, unsigned len)
391 {
392         char buf[100];
393         char const *s;
394         static char const langids[4] = {4, USB_DT_STRING, 0x09, 0x04};
395
396         // language ids
397         switch (id) {
398         case 0:
399                 /* Array of LANGID codes (0x0409 is MSFT-speak for "en-us") */
400                 /* See http://www.usb.org/developers/docs/USB_LANGIDs.pdf */
401                 if (len > 4)
402                         len = 4;
403                 memcpy(data, langids, len);
404                 return len;
405         case 1:
406                 /* Serial number */
407                 s = hcd->self.bus_name;
408                 break;
409         case 2:
410                 /* Product name */
411                 s = hcd->product_desc;
412                 break;
413         case 3:
414                 /* Manufacturer */
415                 snprintf (buf, sizeof buf, "%s %s %s", init_utsname()->sysname,
416                         init_utsname()->release, hcd->driver->description);
417                 s = buf;
418                 break;
419         default:
420                 /* Can't happen; caller guarantees it */
421                 return 0;
422         }
423
424         return ascii2desc(s, data, len);
425 }
426
427
428 /* Root hub control transfers execute synchronously */
429 static int rh_call_control (struct usb_hcd *hcd, struct urb *urb)
430 {
431         struct usb_ctrlrequest *cmd;
432         u16             typeReq, wValue, wIndex, wLength;
433         u8              *ubuf = urb->transfer_buffer;
434         u8              tbuf [sizeof (struct usb_hub_descriptor)]
435                 __attribute__((aligned(4)));
436         const u8        *bufp = tbuf;
437         unsigned        len = 0;
438         int             status;
439         u8              patch_wakeup = 0;
440         u8              patch_protocol = 0;
441
442         might_sleep();
443
444         spin_lock_irq(&hcd_root_hub_lock);
445         status = usb_hcd_link_urb_to_ep(hcd, urb);
446         spin_unlock_irq(&hcd_root_hub_lock);
447         if (status)
448                 return status;
449         urb->hcpriv = hcd;      /* Indicate it's queued */
450
451         cmd = (struct usb_ctrlrequest *) urb->setup_packet;
452         typeReq  = (cmd->bRequestType << 8) | cmd->bRequest;
453         wValue   = le16_to_cpu (cmd->wValue);
454         wIndex   = le16_to_cpu (cmd->wIndex);
455         wLength  = le16_to_cpu (cmd->wLength);
456
457         if (wLength > urb->transfer_buffer_length)
458                 goto error;
459
460         urb->actual_length = 0;
461         switch (typeReq) {
462
463         /* DEVICE REQUESTS */
464
465         /* The root hub's remote wakeup enable bit is implemented using
466          * driver model wakeup flags.  If this system supports wakeup
467          * through USB, userspace may change the default "allow wakeup"
468          * policy through sysfs or these calls.
469          *
470          * Most root hubs support wakeup from downstream devices, for
471          * runtime power management (disabling USB clocks and reducing
472          * VBUS power usage).  However, not all of them do so; silicon,
473          * board, and BIOS bugs here are not uncommon, so these can't
474          * be treated quite like external hubs.
475          *
476          * Likewise, not all root hubs will pass wakeup events upstream,
477          * to wake up the whole system.  So don't assume root hub and
478          * controller capabilities are identical.
479          */
480
481         case DeviceRequest | USB_REQ_GET_STATUS:
482                 tbuf [0] = (device_may_wakeup(&hcd->self.root_hub->dev)
483                                         << USB_DEVICE_REMOTE_WAKEUP)
484                                 | (1 << USB_DEVICE_SELF_POWERED);
485                 tbuf [1] = 0;
486                 len = 2;
487                 break;
488         case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
489                 if (wValue == USB_DEVICE_REMOTE_WAKEUP)
490                         device_set_wakeup_enable(&hcd->self.root_hub->dev, 0);
491                 else
492                         goto error;
493                 break;
494         case DeviceOutRequest | USB_REQ_SET_FEATURE:
495                 if (device_can_wakeup(&hcd->self.root_hub->dev)
496                                 && wValue == USB_DEVICE_REMOTE_WAKEUP)
497                         device_set_wakeup_enable(&hcd->self.root_hub->dev, 1);
498                 else
499                         goto error;
500                 break;
501         case DeviceRequest | USB_REQ_GET_CONFIGURATION:
502                 tbuf [0] = 1;
503                 len = 1;
504                         /* FALLTHROUGH */
505         case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
506                 break;
507         case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
508                 switch (wValue & 0xff00) {
509                 case USB_DT_DEVICE << 8:
510                         switch (hcd->driver->flags & HCD_MASK) {
511                         case HCD_USB3:
512                                 bufp = usb3_rh_dev_descriptor;
513                                 break;
514                         case HCD_USB2:
515                                 bufp = usb2_rh_dev_descriptor;
516                                 break;
517                         case HCD_USB11:
518                                 bufp = usb11_rh_dev_descriptor;
519                                 break;
520                         default:
521                                 goto error;
522                         }
523                         len = 18;
524                         if (hcd->has_tt)
525                                 patch_protocol = 1;
526                         break;
527                 case USB_DT_CONFIG << 8:
528                         switch (hcd->driver->flags & HCD_MASK) {
529                         case HCD_USB3:
530                                 bufp = ss_rh_config_descriptor;
531                                 len = sizeof ss_rh_config_descriptor;
532                                 break;
533                         case HCD_USB2:
534                                 bufp = hs_rh_config_descriptor;
535                                 len = sizeof hs_rh_config_descriptor;
536                                 break;
537                         case HCD_USB11:
538                                 bufp = fs_rh_config_descriptor;
539                                 len = sizeof fs_rh_config_descriptor;
540                                 break;
541                         default:
542                                 goto error;
543                         }
544                         if (device_can_wakeup(&hcd->self.root_hub->dev))
545                                 patch_wakeup = 1;
546                         break;
547                 case USB_DT_STRING << 8:
548                         if ((wValue & 0xff) < 4)
549                                 urb->actual_length = rh_string(wValue & 0xff,
550                                                 hcd, ubuf, wLength);
551                         else /* unsupported IDs --> "protocol stall" */
552                                 goto error;
553                         break;
554                 default:
555                         goto error;
556                 }
557                 break;
558         case DeviceRequest | USB_REQ_GET_INTERFACE:
559                 tbuf [0] = 0;
560                 len = 1;
561                         /* FALLTHROUGH */
562         case DeviceOutRequest | USB_REQ_SET_INTERFACE:
563                 break;
564         case DeviceOutRequest | USB_REQ_SET_ADDRESS:
565                 // wValue == urb->dev->devaddr
566                 dev_dbg (hcd->self.controller, "root hub device address %d\n",
567                         wValue);
568                 break;
569
570         /* INTERFACE REQUESTS (no defined feature/status flags) */
571
572         /* ENDPOINT REQUESTS */
573
574         case EndpointRequest | USB_REQ_GET_STATUS:
575                 // ENDPOINT_HALT flag
576                 tbuf [0] = 0;
577                 tbuf [1] = 0;
578                 len = 2;
579                         /* FALLTHROUGH */
580         case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
581         case EndpointOutRequest | USB_REQ_SET_FEATURE:
582                 dev_dbg (hcd->self.controller, "no endpoint features yet\n");
583                 break;
584
585         /* CLASS REQUESTS (and errors) */
586
587         default:
588                 /* non-generic request */
589                 switch (typeReq) {
590                 case GetHubStatus:
591                 case GetPortStatus:
592                         len = 4;
593                         break;
594                 case GetHubDescriptor:
595                         len = sizeof (struct usb_hub_descriptor);
596                         break;
597                 }
598                 status = hcd->driver->hub_control (hcd,
599                         typeReq, wValue, wIndex,
600                         tbuf, wLength);
601                 break;
602 error:
603                 /* "protocol stall" on error */
604                 status = -EPIPE;
605         }
606
607         if (status) {
608                 len = 0;
609                 if (status != -EPIPE) {
610                         dev_dbg (hcd->self.controller,
611                                 "CTRL: TypeReq=0x%x val=0x%x "
612                                 "idx=0x%x len=%d ==> %d\n",
613                                 typeReq, wValue, wIndex,
614                                 wLength, status);
615                 }
616         }
617         if (len) {
618                 if (urb->transfer_buffer_length < len)
619                         len = urb->transfer_buffer_length;
620                 urb->actual_length = len;
621                 // always USB_DIR_IN, toward host
622                 memcpy (ubuf, bufp, len);
623
624                 /* report whether RH hardware supports remote wakeup */
625                 if (patch_wakeup &&
626                                 len > offsetof (struct usb_config_descriptor,
627                                                 bmAttributes))
628                         ((struct usb_config_descriptor *)ubuf)->bmAttributes
629                                 |= USB_CONFIG_ATT_WAKEUP;
630
631                 /* report whether RH hardware has an integrated TT */
632                 if (patch_protocol &&
633                                 len > offsetof(struct usb_device_descriptor,
634                                                 bDeviceProtocol))
635                         ((struct usb_device_descriptor *) ubuf)->
636                                         bDeviceProtocol = 1;
637         }
638
639         /* any errors get returned through the urb completion */
640         spin_lock_irq(&hcd_root_hub_lock);
641         usb_hcd_unlink_urb_from_ep(hcd, urb);
642
643         /* This peculiar use of spinlocks echoes what real HC drivers do.
644          * Avoiding calls to local_irq_disable/enable makes the code
645          * RT-friendly.
646          */
647         spin_unlock(&hcd_root_hub_lock);
648         usb_hcd_giveback_urb(hcd, urb, status);
649         spin_lock(&hcd_root_hub_lock);
650
651         spin_unlock_irq(&hcd_root_hub_lock);
652         return 0;
653 }
654
655 /*-------------------------------------------------------------------------*/
656
657 /*
658  * Root Hub interrupt transfers are polled using a timer if the
659  * driver requests it; otherwise the driver is responsible for
660  * calling usb_hcd_poll_rh_status() when an event occurs.
661  *
662  * Completions are called in_interrupt(), but they may or may not
663  * be in_irq().
664  */
665 void usb_hcd_poll_rh_status(struct usb_hcd *hcd)
666 {
667         struct urb      *urb;
668         int             length;
669         unsigned long   flags;
670         char            buffer[6];      /* Any root hubs with > 31 ports? */
671
672         if (unlikely(!hcd->rh_registered))
673                 return;
674         if (!hcd->uses_new_polling && !hcd->status_urb)
675                 return;
676
677         length = hcd->driver->hub_status_data(hcd, buffer);
678         if (length > 0) {
679
680                 /* try to complete the status urb */
681                 spin_lock_irqsave(&hcd_root_hub_lock, flags);
682                 urb = hcd->status_urb;
683                 if (urb) {
684                         hcd->poll_pending = 0;
685                         hcd->status_urb = NULL;
686                         urb->actual_length = length;
687                         memcpy(urb->transfer_buffer, buffer, length);
688
689                         usb_hcd_unlink_urb_from_ep(hcd, urb);
690                         spin_unlock(&hcd_root_hub_lock);
691                         usb_hcd_giveback_urb(hcd, urb, 0);
692                         spin_lock(&hcd_root_hub_lock);
693                 } else {
694                         length = 0;
695                         hcd->poll_pending = 1;
696                 }
697                 spin_unlock_irqrestore(&hcd_root_hub_lock, flags);
698         }
699
700         /* The USB 2.0 spec says 256 ms.  This is close enough and won't
701          * exceed that limit if HZ is 100. The math is more clunky than
702          * maybe expected, this is to make sure that all timers for USB devices
703          * fire at the same time to give the CPU a break inbetween */
704         if (hcd->uses_new_polling ? hcd->poll_rh :
705                         (length == 0 && hcd->status_urb != NULL))
706                 mod_timer (&hcd->rh_timer, (jiffies/(HZ/4) + 1) * (HZ/4));
707 }
708 EXPORT_SYMBOL_GPL(usb_hcd_poll_rh_status);
709
710 /* timer callback */
711 static void rh_timer_func (unsigned long _hcd)
712 {
713         usb_hcd_poll_rh_status((struct usb_hcd *) _hcd);
714 }
715
716 /*-------------------------------------------------------------------------*/
717
718 static int rh_queue_status (struct usb_hcd *hcd, struct urb *urb)
719 {
720         int             retval;
721         unsigned long   flags;
722         unsigned        len = 1 + (urb->dev->maxchild / 8);
723
724         spin_lock_irqsave (&hcd_root_hub_lock, flags);
725         if (hcd->status_urb || urb->transfer_buffer_length < len) {
726                 dev_dbg (hcd->self.controller, "not queuing rh status urb\n");
727                 retval = -EINVAL;
728                 goto done;
729         }
730
731         retval = usb_hcd_link_urb_to_ep(hcd, urb);
732         if (retval)
733                 goto done;
734
735         hcd->status_urb = urb;
736         urb->hcpriv = hcd;      /* indicate it's queued */
737         if (!hcd->uses_new_polling)
738                 mod_timer(&hcd->rh_timer, (jiffies/(HZ/4) + 1) * (HZ/4));
739
740         /* If a status change has already occurred, report it ASAP */
741         else if (hcd->poll_pending)
742                 mod_timer(&hcd->rh_timer, jiffies);
743         retval = 0;
744  done:
745         spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
746         return retval;
747 }
748
749 static int rh_urb_enqueue (struct usb_hcd *hcd, struct urb *urb)
750 {
751         if (usb_endpoint_xfer_int(&urb->ep->desc))
752                 return rh_queue_status (hcd, urb);
753         if (usb_endpoint_xfer_control(&urb->ep->desc))
754                 return rh_call_control (hcd, urb);
755         return -EINVAL;
756 }
757
758 /*-------------------------------------------------------------------------*/
759
760 /* Unlinks of root-hub control URBs are legal, but they don't do anything
761  * since these URBs always execute synchronously.
762  */
763 static int usb_rh_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
764 {
765         unsigned long   flags;
766         int             rc;
767
768         spin_lock_irqsave(&hcd_root_hub_lock, flags);
769         rc = usb_hcd_check_unlink_urb(hcd, urb, status);
770         if (rc)
771                 goto done;
772
773         if (usb_endpoint_num(&urb->ep->desc) == 0) {    /* Control URB */
774                 ;       /* Do nothing */
775
776         } else {                                /* Status URB */
777                 if (!hcd->uses_new_polling)
778                         del_timer (&hcd->rh_timer);
779                 if (urb == hcd->status_urb) {
780                         hcd->status_urb = NULL;
781                         usb_hcd_unlink_urb_from_ep(hcd, urb);
782
783                         spin_unlock(&hcd_root_hub_lock);
784                         usb_hcd_giveback_urb(hcd, urb, status);
785                         spin_lock(&hcd_root_hub_lock);
786                 }
787         }
788  done:
789         spin_unlock_irqrestore(&hcd_root_hub_lock, flags);
790         return rc;
791 }
792
793
794
795 /*
796  * Show & store the current value of authorized_default
797  */
798 static ssize_t usb_host_authorized_default_show(struct device *dev,
799                                                 struct device_attribute *attr,
800                                                 char *buf)
801 {
802         struct usb_device *rh_usb_dev = to_usb_device(dev);
803         struct usb_bus *usb_bus = rh_usb_dev->bus;
804         struct usb_hcd *usb_hcd;
805
806         if (usb_bus == NULL)    /* FIXME: not sure if this case is possible */
807                 return -ENODEV;
808         usb_hcd = bus_to_hcd(usb_bus);
809         return snprintf(buf, PAGE_SIZE, "%u\n", usb_hcd->authorized_default);
810 }
811
812 static ssize_t usb_host_authorized_default_store(struct device *dev,
813                                                  struct device_attribute *attr,
814                                                  const char *buf, size_t size)
815 {
816         ssize_t result;
817         unsigned val;
818         struct usb_device *rh_usb_dev = to_usb_device(dev);
819         struct usb_bus *usb_bus = rh_usb_dev->bus;
820         struct usb_hcd *usb_hcd;
821
822         if (usb_bus == NULL)    /* FIXME: not sure if this case is possible */
823                 return -ENODEV;
824         usb_hcd = bus_to_hcd(usb_bus);
825         result = sscanf(buf, "%u\n", &val);
826         if (result == 1) {
827                 usb_hcd->authorized_default = val? 1 : 0;
828                 result = size;
829         }
830         else
831                 result = -EINVAL;
832         return result;
833 }
834
835 static DEVICE_ATTR(authorized_default, 0644,
836             usb_host_authorized_default_show,
837             usb_host_authorized_default_store);
838
839
840 /* Group all the USB bus attributes */
841 static struct attribute *usb_bus_attrs[] = {
842                 &dev_attr_authorized_default.attr,
843                 NULL,
844 };
845
846 static struct attribute_group usb_bus_attr_group = {
847         .name = NULL,   /* we want them in the same directory */
848         .attrs = usb_bus_attrs,
849 };
850
851
852
853 /*-------------------------------------------------------------------------*/
854
855 /**
856  * usb_bus_init - shared initialization code
857  * @bus: the bus structure being initialized
858  *
859  * This code is used to initialize a usb_bus structure, memory for which is
860  * separately managed.
861  */
862 static void usb_bus_init (struct usb_bus *bus)
863 {
864         memset (&bus->devmap, 0, sizeof(struct usb_devmap));
865
866         bus->devnum_next = 1;
867
868         bus->root_hub = NULL;
869         bus->busnum = -1;
870         bus->bandwidth_allocated = 0;
871         bus->bandwidth_int_reqs  = 0;
872         bus->bandwidth_isoc_reqs = 0;
873
874         INIT_LIST_HEAD (&bus->bus_list);
875 }
876
877 /*-------------------------------------------------------------------------*/
878
879 /**
880  * usb_register_bus - registers the USB host controller with the usb core
881  * @bus: pointer to the bus to register
882  * Context: !in_interrupt()
883  *
884  * Assigns a bus number, and links the controller into usbcore data
885  * structures so that it can be seen by scanning the bus list.
886  */
887 static int usb_register_bus(struct usb_bus *bus)
888 {
889         int result = -E2BIG;
890         int busnum;
891
892         mutex_lock(&usb_bus_list_lock);
893         busnum = find_next_zero_bit (busmap.busmap, USB_MAXBUS, 1);
894         if (busnum >= USB_MAXBUS) {
895                 printk (KERN_ERR "%s: too many buses\n", usbcore_name);
896                 goto error_find_busnum;
897         }
898         set_bit (busnum, busmap.busmap);
899         bus->busnum = busnum;
900
901         /* Add it to the local list of buses */
902         list_add (&bus->bus_list, &usb_bus_list);
903         mutex_unlock(&usb_bus_list_lock);
904
905         usb_notify_add_bus(bus);
906
907         dev_info (bus->controller, "new USB bus registered, assigned bus "
908                   "number %d\n", bus->busnum);
909         return 0;
910
911 error_find_busnum:
912         mutex_unlock(&usb_bus_list_lock);
913         return result;
914 }
915
916 /**
917  * usb_deregister_bus - deregisters the USB host controller
918  * @bus: pointer to the bus to deregister
919  * Context: !in_interrupt()
920  *
921  * Recycles the bus number, and unlinks the controller from usbcore data
922  * structures so that it won't be seen by scanning the bus list.
923  */
924 static void usb_deregister_bus (struct usb_bus *bus)
925 {
926         dev_info (bus->controller, "USB bus %d deregistered\n", bus->busnum);
927
928         /*
929          * NOTE: make sure that all the devices are removed by the
930          * controller code, as well as having it call this when cleaning
931          * itself up
932          */
933         mutex_lock(&usb_bus_list_lock);
934         list_del (&bus->bus_list);
935         mutex_unlock(&usb_bus_list_lock);
936
937         usb_notify_remove_bus(bus);
938
939         clear_bit (bus->busnum, busmap.busmap);
940 }
941
942 /**
943  * register_root_hub - called by usb_add_hcd() to register a root hub
944  * @hcd: host controller for this root hub
945  *
946  * This function registers the root hub with the USB subsystem.  It sets up
947  * the device properly in the device tree and then calls usb_new_device()
948  * to register the usb device.  It also assigns the root hub's USB address
949  * (always 1).
950  */
951 static int register_root_hub(struct usb_hcd *hcd)
952 {
953         struct device *parent_dev = hcd->self.controller;
954         struct usb_device *usb_dev = hcd->self.root_hub;
955         const int devnum = 1;
956         int retval;
957
958         usb_dev->devnum = devnum;
959         usb_dev->bus->devnum_next = devnum + 1;
960         memset (&usb_dev->bus->devmap.devicemap, 0,
961                         sizeof usb_dev->bus->devmap.devicemap);
962         set_bit (devnum, usb_dev->bus->devmap.devicemap);
963         usb_set_device_state(usb_dev, USB_STATE_ADDRESS);
964
965         mutex_lock(&usb_bus_list_lock);
966
967         usb_dev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
968         retval = usb_get_device_descriptor(usb_dev, USB_DT_DEVICE_SIZE);
969         if (retval != sizeof usb_dev->descriptor) {
970                 mutex_unlock(&usb_bus_list_lock);
971                 dev_dbg (parent_dev, "can't read %s device descriptor %d\n",
972                                 dev_name(&usb_dev->dev), retval);
973                 return (retval < 0) ? retval : -EMSGSIZE;
974         }
975
976         retval = usb_new_device (usb_dev);
977         if (retval) {
978                 dev_err (parent_dev, "can't register root hub for %s, %d\n",
979                                 dev_name(&usb_dev->dev), retval);
980         }
981         mutex_unlock(&usb_bus_list_lock);
982
983         if (retval == 0) {
984                 spin_lock_irq (&hcd_root_hub_lock);
985                 hcd->rh_registered = 1;
986                 spin_unlock_irq (&hcd_root_hub_lock);
987
988                 /* Did the HC die before the root hub was registered? */
989                 if (hcd->state == HC_STATE_HALT)
990                         usb_hc_died (hcd);      /* This time clean up */
991         }
992
993         return retval;
994 }
995
996
997 /*-------------------------------------------------------------------------*/
998
999 /**
1000  * usb_calc_bus_time - approximate periodic transaction time in nanoseconds
1001  * @speed: from dev->speed; USB_SPEED_{LOW,FULL,HIGH}
1002  * @is_input: true iff the transaction sends data to the host
1003  * @isoc: true for isochronous transactions, false for interrupt ones
1004  * @bytecount: how many bytes in the transaction.
1005  *
1006  * Returns approximate bus time in nanoseconds for a periodic transaction.
1007  * See USB 2.0 spec section 5.11.3; only periodic transfers need to be
1008  * scheduled in software, this function is only used for such scheduling.
1009  */
1010 long usb_calc_bus_time (int speed, int is_input, int isoc, int bytecount)
1011 {
1012         unsigned long   tmp;
1013
1014         switch (speed) {
1015         case USB_SPEED_LOW:     /* INTR only */
1016                 if (is_input) {
1017                         tmp = (67667L * (31L + 10L * BitTime (bytecount))) / 1000L;
1018                         return (64060L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp);
1019                 } else {
1020                         tmp = (66700L * (31L + 10L * BitTime (bytecount))) / 1000L;
1021                         return (64107L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp);
1022                 }
1023         case USB_SPEED_FULL:    /* ISOC or INTR */
1024                 if (isoc) {
1025                         tmp = (8354L * (31L + 10L * BitTime (bytecount))) / 1000L;
1026                         return (((is_input) ? 7268L : 6265L) + BW_HOST_DELAY + tmp);
1027                 } else {
1028                         tmp = (8354L * (31L + 10L * BitTime (bytecount))) / 1000L;
1029                         return (9107L + BW_HOST_DELAY + tmp);
1030                 }
1031         case USB_SPEED_HIGH:    /* ISOC or INTR */
1032                 // FIXME adjust for input vs output
1033                 if (isoc)
1034                         tmp = HS_NSECS_ISO (bytecount);
1035                 else
1036                         tmp = HS_NSECS (bytecount);
1037                 return tmp;
1038         default:
1039                 pr_debug ("%s: bogus device speed!\n", usbcore_name);
1040                 return -1;
1041         }
1042 }
1043 EXPORT_SYMBOL_GPL(usb_calc_bus_time);
1044
1045
1046 /*-------------------------------------------------------------------------*/
1047
1048 /*
1049  * Generic HC operations.
1050  */
1051
1052 /*-------------------------------------------------------------------------*/
1053
1054 /**
1055  * usb_hcd_link_urb_to_ep - add an URB to its endpoint queue
1056  * @hcd: host controller to which @urb was submitted
1057  * @urb: URB being submitted
1058  *
1059  * Host controller drivers should call this routine in their enqueue()
1060  * method.  The HCD's private spinlock must be held and interrupts must
1061  * be disabled.  The actions carried out here are required for URB
1062  * submission, as well as for endpoint shutdown and for usb_kill_urb.
1063  *
1064  * Returns 0 for no error, otherwise a negative error code (in which case
1065  * the enqueue() method must fail).  If no error occurs but enqueue() fails
1066  * anyway, it must call usb_hcd_unlink_urb_from_ep() before releasing
1067  * the private spinlock and returning.
1068  */
1069 int usb_hcd_link_urb_to_ep(struct usb_hcd *hcd, struct urb *urb)
1070 {
1071         int             rc = 0;
1072
1073         spin_lock(&hcd_urb_list_lock);
1074
1075         /* Check that the URB isn't being killed */
1076         if (unlikely(atomic_read(&urb->reject))) {
1077                 rc = -EPERM;
1078                 goto done;
1079         }
1080
1081         if (unlikely(!urb->ep->enabled)) {
1082                 rc = -ENOENT;
1083                 goto done;
1084         }
1085
1086         if (unlikely(!urb->dev->can_submit)) {
1087                 rc = -EHOSTUNREACH;
1088                 goto done;
1089         }
1090
1091         /*
1092          * Check the host controller's state and add the URB to the
1093          * endpoint's queue.
1094          */
1095         switch (hcd->state) {
1096         case HC_STATE_RUNNING:
1097         case HC_STATE_RESUMING:
1098                 urb->unlinked = 0;
1099                 list_add_tail(&urb->urb_list, &urb->ep->urb_list);
1100                 break;
1101         default:
1102                 rc = -ESHUTDOWN;
1103                 goto done;
1104         }
1105  done:
1106         spin_unlock(&hcd_urb_list_lock);
1107         return rc;
1108 }
1109 EXPORT_SYMBOL_GPL(usb_hcd_link_urb_to_ep);
1110
1111 /**
1112  * usb_hcd_check_unlink_urb - check whether an URB may be unlinked
1113  * @hcd: host controller to which @urb was submitted
1114  * @urb: URB being checked for unlinkability
1115  * @status: error code to store in @urb if the unlink succeeds
1116  *
1117  * Host controller drivers should call this routine in their dequeue()
1118  * method.  The HCD's private spinlock must be held and interrupts must
1119  * be disabled.  The actions carried out here are required for making
1120  * sure than an unlink is valid.
1121  *
1122  * Returns 0 for no error, otherwise a negative error code (in which case
1123  * the dequeue() method must fail).  The possible error codes are:
1124  *
1125  *      -EIDRM: @urb was not submitted or has already completed.
1126  *              The completion function may not have been called yet.
1127  *
1128  *      -EBUSY: @urb has already been unlinked.
1129  */
1130 int usb_hcd_check_unlink_urb(struct usb_hcd *hcd, struct urb *urb,
1131                 int status)
1132 {
1133         struct list_head        *tmp;
1134
1135         /* insist the urb is still queued */
1136         list_for_each(tmp, &urb->ep->urb_list) {
1137                 if (tmp == &urb->urb_list)
1138                         break;
1139         }
1140         if (tmp != &urb->urb_list)
1141                 return -EIDRM;
1142
1143         /* Any status except -EINPROGRESS means something already started to
1144          * unlink this URB from the hardware.  So there's no more work to do.
1145          */
1146         if (urb->unlinked)
1147                 return -EBUSY;
1148         urb->unlinked = status;
1149
1150         /* IRQ setup can easily be broken so that USB controllers
1151          * never get completion IRQs ... maybe even the ones we need to
1152          * finish unlinking the initial failed usb_set_address()
1153          * or device descriptor fetch.
1154          */
1155         if (!test_bit(HCD_FLAG_SAW_IRQ, &hcd->flags) &&
1156                         !is_root_hub(urb->dev)) {
1157                 dev_warn(hcd->self.controller, "Unlink after no-IRQ?  "
1158                         "Controller is probably using the wrong IRQ.\n");
1159                 set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
1160         }
1161
1162         return 0;
1163 }
1164 EXPORT_SYMBOL_GPL(usb_hcd_check_unlink_urb);
1165
1166 /**
1167  * usb_hcd_unlink_urb_from_ep - remove an URB from its endpoint queue
1168  * @hcd: host controller to which @urb was submitted
1169  * @urb: URB being unlinked
1170  *
1171  * Host controller drivers should call this routine before calling
1172  * usb_hcd_giveback_urb().  The HCD's private spinlock must be held and
1173  * interrupts must be disabled.  The actions carried out here are required
1174  * for URB completion.
1175  */
1176 void usb_hcd_unlink_urb_from_ep(struct usb_hcd *hcd, struct urb *urb)
1177 {
1178         /* clear all state linking urb to this dev (and hcd) */
1179         spin_lock(&hcd_urb_list_lock);
1180         list_del_init(&urb->urb_list);
1181         spin_unlock(&hcd_urb_list_lock);
1182 }
1183 EXPORT_SYMBOL_GPL(usb_hcd_unlink_urb_from_ep);
1184
1185 /*
1186  * Some usb host controllers can only perform dma using a small SRAM area.
1187  * The usb core itself is however optimized for host controllers that can dma
1188  * using regular system memory - like pci devices doing bus mastering.
1189  *
1190  * To support host controllers with limited dma capabilites we provide dma
1191  * bounce buffers. This feature can be enabled using the HCD_LOCAL_MEM flag.
1192  * For this to work properly the host controller code must first use the
1193  * function dma_declare_coherent_memory() to point out which memory area
1194  * that should be used for dma allocations.
1195  *
1196  * The HCD_LOCAL_MEM flag then tells the usb code to allocate all data for
1197  * dma using dma_alloc_coherent() which in turn allocates from the memory
1198  * area pointed out with dma_declare_coherent_memory().
1199  *
1200  * So, to summarize...
1201  *
1202  * - We need "local" memory, canonical example being
1203  *   a small SRAM on a discrete controller being the
1204  *   only memory that the controller can read ...
1205  *   (a) "normal" kernel memory is no good, and
1206  *   (b) there's not enough to share
1207  *
1208  * - The only *portable* hook for such stuff in the
1209  *   DMA framework is dma_declare_coherent_memory()
1210  *
1211  * - So we use that, even though the primary requirement
1212  *   is that the memory be "local" (hence addressible
1213  *   by that device), not "coherent".
1214  *
1215  */
1216
1217 static int hcd_alloc_coherent(struct usb_bus *bus,
1218                               gfp_t mem_flags, dma_addr_t *dma_handle,
1219                               void **vaddr_handle, size_t size,
1220                               enum dma_data_direction dir)
1221 {
1222         unsigned char *vaddr;
1223
1224         vaddr = hcd_buffer_alloc(bus, size + sizeof(vaddr),
1225                                  mem_flags, dma_handle);
1226         if (!vaddr)
1227                 return -ENOMEM;
1228
1229         /*
1230          * Store the virtual address of the buffer at the end
1231          * of the allocated dma buffer. The size of the buffer
1232          * may be uneven so use unaligned functions instead
1233          * of just rounding up. It makes sense to optimize for
1234          * memory footprint over access speed since the amount
1235          * of memory available for dma may be limited.
1236          */
1237         put_unaligned((unsigned long)*vaddr_handle,
1238                       (unsigned long *)(vaddr + size));
1239
1240         if (dir == DMA_TO_DEVICE)
1241                 memcpy(vaddr, *vaddr_handle, size);
1242
1243         *vaddr_handle = vaddr;
1244         return 0;
1245 }
1246
1247 static void hcd_free_coherent(struct usb_bus *bus, dma_addr_t *dma_handle,
1248                               void **vaddr_handle, size_t size,
1249                               enum dma_data_direction dir)
1250 {
1251         unsigned char *vaddr = *vaddr_handle;
1252
1253         vaddr = (void *)get_unaligned((unsigned long *)(vaddr + size));
1254
1255         if (dir == DMA_FROM_DEVICE)
1256                 memcpy(vaddr, *vaddr_handle, size);
1257
1258         hcd_buffer_free(bus, size + sizeof(vaddr), *vaddr_handle, *dma_handle);
1259
1260         *vaddr_handle = vaddr;
1261         *dma_handle = 0;
1262 }
1263
1264 static int map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb,
1265                            gfp_t mem_flags)
1266 {
1267         enum dma_data_direction dir;
1268         int ret = 0;
1269
1270         /* Map the URB's buffers for DMA access.
1271          * Lower level HCD code should use *_dma exclusively,
1272          * unless it uses pio or talks to another transport,
1273          * or uses the provided scatter gather list for bulk.
1274          */
1275         if (is_root_hub(urb->dev))
1276                 return 0;
1277
1278         if (usb_endpoint_xfer_control(&urb->ep->desc)
1279             && !(urb->transfer_flags & URB_NO_SETUP_DMA_MAP)) {
1280                 if (hcd->self.uses_dma) {
1281                         urb->setup_dma = dma_map_single(
1282                                         hcd->self.controller,
1283                                         urb->setup_packet,
1284                                         sizeof(struct usb_ctrlrequest),
1285                                         DMA_TO_DEVICE);
1286                         if (dma_mapping_error(hcd->self.controller,
1287                                                 urb->setup_dma))
1288                                 return -EAGAIN;
1289                 } else if (hcd->driver->flags & HCD_LOCAL_MEM)
1290                         ret = hcd_alloc_coherent(
1291                                         urb->dev->bus, mem_flags,
1292                                         &urb->setup_dma,
1293                                         (void **)&urb->setup_packet,
1294                                         sizeof(struct usb_ctrlrequest),
1295                                         DMA_TO_DEVICE);
1296         }
1297
1298         dir = usb_urb_dir_in(urb) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
1299         if (ret == 0 && urb->transfer_buffer_length != 0
1300             && !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)) {
1301                 if (hcd->self.uses_dma) {
1302                         urb->transfer_dma = dma_map_single (
1303                                         hcd->self.controller,
1304                                         urb->transfer_buffer,
1305                                         urb->transfer_buffer_length,
1306                                         dir);
1307                         if (dma_mapping_error(hcd->self.controller,
1308                                                 urb->transfer_dma))
1309                                 return -EAGAIN;
1310                 } else if (hcd->driver->flags & HCD_LOCAL_MEM) {
1311                         ret = hcd_alloc_coherent(
1312                                         urb->dev->bus, mem_flags,
1313                                         &urb->transfer_dma,
1314                                         &urb->transfer_buffer,
1315                                         urb->transfer_buffer_length,
1316                                         dir);
1317
1318                         if (ret && usb_endpoint_xfer_control(&urb->ep->desc)
1319                             && !(urb->transfer_flags & URB_NO_SETUP_DMA_MAP))
1320                                 hcd_free_coherent(urb->dev->bus,
1321                                         &urb->setup_dma,
1322                                         (void **)&urb->setup_packet,
1323                                         sizeof(struct usb_ctrlrequest),
1324                                         DMA_TO_DEVICE);
1325                 }
1326         }
1327         return ret;
1328 }
1329
1330 static void unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
1331 {
1332         enum dma_data_direction dir;
1333
1334         if (is_root_hub(urb->dev))
1335                 return;
1336
1337         if (usb_endpoint_xfer_control(&urb->ep->desc)
1338             && !(urb->transfer_flags & URB_NO_SETUP_DMA_MAP)) {
1339                 if (hcd->self.uses_dma)
1340                         dma_unmap_single(hcd->self.controller, urb->setup_dma,
1341                                         sizeof(struct usb_ctrlrequest),
1342                                         DMA_TO_DEVICE);
1343                 else if (hcd->driver->flags & HCD_LOCAL_MEM)
1344                         hcd_free_coherent(urb->dev->bus, &urb->setup_dma,
1345                                         (void **)&urb->setup_packet,
1346                                         sizeof(struct usb_ctrlrequest),
1347                                         DMA_TO_DEVICE);
1348         }
1349
1350         dir = usb_urb_dir_in(urb) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
1351         if (urb->transfer_buffer_length != 0
1352             && !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)) {
1353                 if (hcd->self.uses_dma)
1354                         dma_unmap_single(hcd->self.controller,
1355                                         urb->transfer_dma,
1356                                         urb->transfer_buffer_length,
1357                                         dir);
1358                 else if (hcd->driver->flags & HCD_LOCAL_MEM)
1359                         hcd_free_coherent(urb->dev->bus, &urb->transfer_dma,
1360                                         &urb->transfer_buffer,
1361                                         urb->transfer_buffer_length,
1362                                         dir);
1363         }
1364 }
1365
1366 /*-------------------------------------------------------------------------*/
1367
1368 /* may be called in any context with a valid urb->dev usecount
1369  * caller surrenders "ownership" of urb
1370  * expects usb_submit_urb() to have sanity checked and conditioned all
1371  * inputs in the urb
1372  */
1373 int usb_hcd_submit_urb (struct urb *urb, gfp_t mem_flags)
1374 {
1375         int                     status;
1376         struct usb_hcd          *hcd = bus_to_hcd(urb->dev->bus);
1377
1378         /* increment urb's reference count as part of giving it to the HCD
1379          * (which will control it).  HCD guarantees that it either returns
1380          * an error or calls giveback(), but not both.
1381          */
1382         usb_get_urb(urb);
1383         atomic_inc(&urb->use_count);
1384         atomic_inc(&urb->dev->urbnum);
1385         usbmon_urb_submit(&hcd->self, urb);
1386
1387         /* NOTE requirements on root-hub callers (usbfs and the hub
1388          * driver, for now):  URBs' urb->transfer_buffer must be
1389          * valid and usb_buffer_{sync,unmap}() not be needed, since
1390          * they could clobber root hub response data.  Also, control
1391          * URBs must be submitted in process context with interrupts
1392          * enabled.
1393          */
1394         status = map_urb_for_dma(hcd, urb, mem_flags);
1395         if (unlikely(status)) {
1396                 usbmon_urb_submit_error(&hcd->self, urb, status);
1397                 goto error;
1398         }
1399
1400         if (is_root_hub(urb->dev))
1401                 status = rh_urb_enqueue(hcd, urb);
1402         else
1403                 status = hcd->driver->urb_enqueue(hcd, urb, mem_flags);
1404
1405         if (unlikely(status)) {
1406                 usbmon_urb_submit_error(&hcd->self, urb, status);
1407                 unmap_urb_for_dma(hcd, urb);
1408  error:
1409                 urb->hcpriv = NULL;
1410                 INIT_LIST_HEAD(&urb->urb_list);
1411                 atomic_dec(&urb->use_count);
1412                 atomic_dec(&urb->dev->urbnum);
1413                 if (atomic_read(&urb->reject))
1414                         wake_up(&usb_kill_urb_queue);
1415                 usb_put_urb(urb);
1416         }
1417         return status;
1418 }
1419
1420 /*-------------------------------------------------------------------------*/
1421
1422 /* this makes the hcd giveback() the urb more quickly, by kicking it
1423  * off hardware queues (which may take a while) and returning it as
1424  * soon as practical.  we've already set up the urb's return status,
1425  * but we can't know if the callback completed already.
1426  */
1427 static int unlink1(struct usb_hcd *hcd, struct urb *urb, int status)
1428 {
1429         int             value;
1430
1431         if (is_root_hub(urb->dev))
1432                 value = usb_rh_urb_dequeue(hcd, urb, status);
1433         else {
1434
1435                 /* The only reason an HCD might fail this call is if
1436                  * it has not yet fully queued the urb to begin with.
1437                  * Such failures should be harmless. */
1438                 value = hcd->driver->urb_dequeue(hcd, urb, status);
1439         }
1440         return value;
1441 }
1442
1443 /*
1444  * called in any context
1445  *
1446  * caller guarantees urb won't be recycled till both unlink()
1447  * and the urb's completion function return
1448  */
1449 int usb_hcd_unlink_urb (struct urb *urb, int status)
1450 {
1451         struct usb_hcd          *hcd;
1452         int                     retval = -EIDRM;
1453         unsigned long           flags;
1454
1455         /* Prevent the device and bus from going away while
1456          * the unlink is carried out.  If they are already gone
1457          * then urb->use_count must be 0, since disconnected
1458          * devices can't have any active URBs.
1459          */
1460         spin_lock_irqsave(&hcd_urb_unlink_lock, flags);
1461         if (atomic_read(&urb->use_count) > 0) {
1462                 retval = 0;
1463                 usb_get_dev(urb->dev);
1464         }
1465         spin_unlock_irqrestore(&hcd_urb_unlink_lock, flags);
1466         if (retval == 0) {
1467                 hcd = bus_to_hcd(urb->dev->bus);
1468                 retval = unlink1(hcd, urb, status);
1469                 usb_put_dev(urb->dev);
1470         }
1471
1472         if (retval == 0)
1473                 retval = -EINPROGRESS;
1474         else if (retval != -EIDRM && retval != -EBUSY)
1475                 dev_dbg(&urb->dev->dev, "hcd_unlink_urb %p fail %d\n",
1476                                 urb, retval);
1477         return retval;
1478 }
1479
1480 /*-------------------------------------------------------------------------*/
1481
1482 /**
1483  * usb_hcd_giveback_urb - return URB from HCD to device driver
1484  * @hcd: host controller returning the URB
1485  * @urb: urb being returned to the USB device driver.
1486  * @status: completion status code for the URB.
1487  * Context: in_interrupt()
1488  *
1489  * This hands the URB from HCD to its USB device driver, using its
1490  * completion function.  The HCD has freed all per-urb resources
1491  * (and is done using urb->hcpriv).  It also released all HCD locks;
1492  * the device driver won't cause problems if it frees, modifies,
1493  * or resubmits this URB.
1494  *
1495  * If @urb was unlinked, the value of @status will be overridden by
1496  * @urb->unlinked.  Erroneous short transfers are detected in case
1497  * the HCD hasn't checked for them.
1498  */
1499 void usb_hcd_giveback_urb(struct usb_hcd *hcd, struct urb *urb, int status)
1500 {
1501         urb->hcpriv = NULL;
1502         if (unlikely(urb->unlinked))
1503                 status = urb->unlinked;
1504         else if (unlikely((urb->transfer_flags & URB_SHORT_NOT_OK) &&
1505                         urb->actual_length < urb->transfer_buffer_length &&
1506                         !status))
1507                 status = -EREMOTEIO;
1508
1509         unmap_urb_for_dma(hcd, urb);
1510         usbmon_urb_complete(&hcd->self, urb, status);
1511         usb_unanchor_urb(urb);
1512
1513         /* pass ownership to the completion handler */
1514         urb->status = status;
1515         urb->complete (urb);
1516         atomic_dec (&urb->use_count);
1517         if (unlikely(atomic_read(&urb->reject)))
1518                 wake_up (&usb_kill_urb_queue);
1519         usb_put_urb (urb);
1520 }
1521 EXPORT_SYMBOL_GPL(usb_hcd_giveback_urb);
1522
1523 /*-------------------------------------------------------------------------*/
1524
1525 /* Cancel all URBs pending on this endpoint and wait for the endpoint's
1526  * queue to drain completely.  The caller must first insure that no more
1527  * URBs can be submitted for this endpoint.
1528  */
1529 void usb_hcd_flush_endpoint(struct usb_device *udev,
1530                 struct usb_host_endpoint *ep)
1531 {
1532         struct usb_hcd          *hcd;
1533         struct urb              *urb;
1534
1535         if (!ep)
1536                 return;
1537         might_sleep();
1538         hcd = bus_to_hcd(udev->bus);
1539
1540         /* No more submits can occur */
1541         spin_lock_irq(&hcd_urb_list_lock);
1542 rescan:
1543         list_for_each_entry (urb, &ep->urb_list, urb_list) {
1544                 int     is_in;
1545
1546                 if (urb->unlinked)
1547                         continue;
1548                 usb_get_urb (urb);
1549                 is_in = usb_urb_dir_in(urb);
1550                 spin_unlock(&hcd_urb_list_lock);
1551
1552                 /* kick hcd */
1553                 unlink1(hcd, urb, -ESHUTDOWN);
1554                 dev_dbg (hcd->self.controller,
1555                         "shutdown urb %p ep%d%s%s\n",
1556                         urb, usb_endpoint_num(&ep->desc),
1557                         is_in ? "in" : "out",
1558                         ({      char *s;
1559
1560                                  switch (usb_endpoint_type(&ep->desc)) {
1561                                  case USB_ENDPOINT_XFER_CONTROL:
1562                                         s = ""; break;
1563                                  case USB_ENDPOINT_XFER_BULK:
1564                                         s = "-bulk"; break;
1565                                  case USB_ENDPOINT_XFER_INT:
1566                                         s = "-intr"; break;
1567                                  default:
1568                                         s = "-iso"; break;
1569                                 };
1570                                 s;
1571                         }));
1572                 usb_put_urb (urb);
1573
1574                 /* list contents may have changed */
1575                 spin_lock(&hcd_urb_list_lock);
1576                 goto rescan;
1577         }
1578         spin_unlock_irq(&hcd_urb_list_lock);
1579
1580         /* Wait until the endpoint queue is completely empty */
1581         while (!list_empty (&ep->urb_list)) {
1582                 spin_lock_irq(&hcd_urb_list_lock);
1583
1584                 /* The list may have changed while we acquired the spinlock */
1585                 urb = NULL;
1586                 if (!list_empty (&ep->urb_list)) {
1587                         urb = list_entry (ep->urb_list.prev, struct urb,
1588                                         urb_list);
1589                         usb_get_urb (urb);
1590                 }
1591                 spin_unlock_irq(&hcd_urb_list_lock);
1592
1593                 if (urb) {
1594                         usb_kill_urb (urb);
1595                         usb_put_urb (urb);
1596                 }
1597         }
1598 }
1599
1600 /**
1601  * usb_hcd_alloc_bandwidth - check whether a new bandwidth setting exceeds
1602  *                              the bus bandwidth
1603  * @udev: target &usb_device
1604  * @new_config: new configuration to install
1605  * @cur_alt: the current alternate interface setting
1606  * @new_alt: alternate interface setting that is being installed
1607  *
1608  * To change configurations, pass in the new configuration in new_config,
1609  * and pass NULL for cur_alt and new_alt.
1610  *
1611  * To reset a device's configuration (put the device in the ADDRESSED state),
1612  * pass in NULL for new_config, cur_alt, and new_alt.
1613  *
1614  * To change alternate interface settings, pass in NULL for new_config,
1615  * pass in the current alternate interface setting in cur_alt,
1616  * and pass in the new alternate interface setting in new_alt.
1617  *
1618  * Returns an error if the requested bandwidth change exceeds the
1619  * bus bandwidth or host controller internal resources.
1620  */
1621 int usb_hcd_alloc_bandwidth(struct usb_device *udev,
1622                 struct usb_host_config *new_config,
1623                 struct usb_host_interface *cur_alt,
1624                 struct usb_host_interface *new_alt)
1625 {
1626         int num_intfs, i, j;
1627         struct usb_host_interface *alt = NULL;
1628         int ret = 0;
1629         struct usb_hcd *hcd;
1630         struct usb_host_endpoint *ep;
1631
1632         hcd = bus_to_hcd(udev->bus);
1633         if (!hcd->driver->check_bandwidth)
1634                 return 0;
1635
1636         /* Configuration is being removed - set configuration 0 */
1637         if (!new_config && !cur_alt) {
1638                 for (i = 1; i < 16; ++i) {
1639                         ep = udev->ep_out[i];
1640                         if (ep)
1641                                 hcd->driver->drop_endpoint(hcd, udev, ep);
1642                         ep = udev->ep_in[i];
1643                         if (ep)
1644                                 hcd->driver->drop_endpoint(hcd, udev, ep);
1645                 }
1646                 hcd->driver->check_bandwidth(hcd, udev);
1647                 return 0;
1648         }
1649         /* Check if the HCD says there's enough bandwidth.  Enable all endpoints
1650          * each interface's alt setting 0 and ask the HCD to check the bandwidth
1651          * of the bus.  There will always be bandwidth for endpoint 0, so it's
1652          * ok to exclude it.
1653          */
1654         if (new_config) {
1655                 num_intfs = new_config->desc.bNumInterfaces;
1656                 /* Remove endpoints (except endpoint 0, which is always on the
1657                  * schedule) from the old config from the schedule
1658                  */
1659                 for (i = 1; i < 16; ++i) {
1660                         ep = udev->ep_out[i];
1661                         if (ep) {
1662                                 ret = hcd->driver->drop_endpoint(hcd, udev, ep);
1663                                 if (ret < 0)
1664                                         goto reset;
1665                         }
1666                         ep = udev->ep_in[i];
1667                         if (ep) {
1668                                 ret = hcd->driver->drop_endpoint(hcd, udev, ep);
1669                                 if (ret < 0)
1670                                         goto reset;
1671                         }
1672                 }
1673                 for (i = 0; i < num_intfs; ++i) {
1674                         struct usb_host_interface *first_alt;
1675                         int iface_num;
1676
1677                         first_alt = &new_config->intf_cache[i]->altsetting[0];
1678                         iface_num = first_alt->desc.bInterfaceNumber;
1679                         /* Set up endpoints for alternate interface setting 0 */
1680                         alt = usb_find_alt_setting(new_config, iface_num, 0);
1681                         if (!alt)
1682                                 /* No alt setting 0? Pick the first setting. */
1683                                 alt = first_alt;
1684
1685                         for (j = 0; j < alt->desc.bNumEndpoints; j++) {
1686                                 ret = hcd->driver->add_endpoint(hcd, udev, &alt->endpoint[j]);
1687                                 if (ret < 0)
1688                                         goto reset;
1689                         }
1690                 }
1691         }
1692         if (cur_alt && new_alt) {
1693                 struct usb_interface *iface = usb_ifnum_to_if(udev,
1694                                 cur_alt->desc.bInterfaceNumber);
1695
1696                 if (iface->resetting_device) {
1697                         /*
1698                          * The USB core just reset the device, so the xHCI host
1699                          * and the device will think alt setting 0 is installed.
1700                          * However, the USB core will pass in the alternate
1701                          * setting installed before the reset as cur_alt.  Dig
1702                          * out the alternate setting 0 structure, or the first
1703                          * alternate setting if a broken device doesn't have alt
1704                          * setting 0.
1705                          */
1706                         cur_alt = usb_altnum_to_altsetting(iface, 0);
1707                         if (!cur_alt)
1708                                 cur_alt = &iface->altsetting[0];
1709                 }
1710
1711                 /* Drop all the endpoints in the current alt setting */
1712                 for (i = 0; i < cur_alt->desc.bNumEndpoints; i++) {
1713                         ret = hcd->driver->drop_endpoint(hcd, udev,
1714                                         &cur_alt->endpoint[i]);
1715                         if (ret < 0)
1716                                 goto reset;
1717                 }
1718                 /* Add all the endpoints in the new alt setting */
1719                 for (i = 0; i < new_alt->desc.bNumEndpoints; i++) {
1720                         ret = hcd->driver->add_endpoint(hcd, udev,
1721                                         &new_alt->endpoint[i]);
1722                         if (ret < 0)
1723                                 goto reset;
1724                 }
1725         }
1726         ret = hcd->driver->check_bandwidth(hcd, udev);
1727 reset:
1728         if (ret < 0)
1729                 hcd->driver->reset_bandwidth(hcd, udev);
1730         return ret;
1731 }
1732
1733 /* Disables the endpoint: synchronizes with the hcd to make sure all
1734  * endpoint state is gone from hardware.  usb_hcd_flush_endpoint() must
1735  * have been called previously.  Use for set_configuration, set_interface,
1736  * driver removal, physical disconnect.
1737  *
1738  * example:  a qh stored in ep->hcpriv, holding state related to endpoint
1739  * type, maxpacket size, toggle, halt status, and scheduling.
1740  */
1741 void usb_hcd_disable_endpoint(struct usb_device *udev,
1742                 struct usb_host_endpoint *ep)
1743 {
1744         struct usb_hcd          *hcd;
1745
1746         might_sleep();
1747         hcd = bus_to_hcd(udev->bus);
1748         if (hcd->driver->endpoint_disable)
1749                 hcd->driver->endpoint_disable(hcd, ep);
1750 }
1751
1752 /**
1753  * usb_hcd_reset_endpoint - reset host endpoint state
1754  * @udev: USB device.
1755  * @ep:   the endpoint to reset.
1756  *
1757  * Resets any host endpoint state such as the toggle bit, sequence
1758  * number and current window.
1759  */
1760 void usb_hcd_reset_endpoint(struct usb_device *udev,
1761                             struct usb_host_endpoint *ep)
1762 {
1763         struct usb_hcd *hcd = bus_to_hcd(udev->bus);
1764
1765         if (hcd->driver->endpoint_reset)
1766                 hcd->driver->endpoint_reset(hcd, ep);
1767         else {
1768                 int epnum = usb_endpoint_num(&ep->desc);
1769                 int is_out = usb_endpoint_dir_out(&ep->desc);
1770                 int is_control = usb_endpoint_xfer_control(&ep->desc);
1771
1772                 usb_settoggle(udev, epnum, is_out, 0);
1773                 if (is_control)
1774                         usb_settoggle(udev, epnum, !is_out, 0);
1775         }
1776 }
1777
1778 /* Protect against drivers that try to unlink URBs after the device
1779  * is gone, by waiting until all unlinks for @udev are finished.
1780  * Since we don't currently track URBs by device, simply wait until
1781  * nothing is running in the locked region of usb_hcd_unlink_urb().
1782  */
1783 void usb_hcd_synchronize_unlinks(struct usb_device *udev)
1784 {
1785         spin_lock_irq(&hcd_urb_unlink_lock);
1786         spin_unlock_irq(&hcd_urb_unlink_lock);
1787 }
1788
1789 /*-------------------------------------------------------------------------*/
1790
1791 /* called in any context */
1792 int usb_hcd_get_frame_number (struct usb_device *udev)
1793 {
1794         struct usb_hcd  *hcd = bus_to_hcd(udev->bus);
1795
1796         if (!HC_IS_RUNNING (hcd->state))
1797                 return -ESHUTDOWN;
1798         return hcd->driver->get_frame_number (hcd);
1799 }
1800
1801 /*-------------------------------------------------------------------------*/
1802
1803 #ifdef  CONFIG_PM
1804
1805 int hcd_bus_suspend(struct usb_device *rhdev, pm_message_t msg)
1806 {
1807         struct usb_hcd  *hcd = container_of(rhdev->bus, struct usb_hcd, self);
1808         int             status;
1809         int             old_state = hcd->state;
1810
1811         dev_dbg(&rhdev->dev, "bus %s%s\n",
1812                         (msg.event & PM_EVENT_AUTO ? "auto-" : ""), "suspend");
1813         if (!hcd->driver->bus_suspend) {
1814                 status = -ENOENT;
1815         } else {
1816                 hcd->state = HC_STATE_QUIESCING;
1817                 status = hcd->driver->bus_suspend(hcd);
1818         }
1819         if (status == 0) {
1820                 usb_set_device_state(rhdev, USB_STATE_SUSPENDED);
1821                 hcd->state = HC_STATE_SUSPENDED;
1822         } else {
1823                 hcd->state = old_state;
1824                 dev_dbg(&rhdev->dev, "bus %s fail, err %d\n",
1825                                 "suspend", status);
1826         }
1827         return status;
1828 }
1829
1830 int hcd_bus_resume(struct usb_device *rhdev, pm_message_t msg)
1831 {
1832         struct usb_hcd  *hcd = container_of(rhdev->bus, struct usb_hcd, self);
1833         int             status;
1834         int             old_state = hcd->state;
1835
1836         dev_dbg(&rhdev->dev, "usb %s%s\n",
1837                         (msg.event & PM_EVENT_AUTO ? "auto-" : ""), "resume");
1838         if (!hcd->driver->bus_resume)
1839                 return -ENOENT;
1840         if (hcd->state == HC_STATE_RUNNING)
1841                 return 0;
1842
1843         hcd->state = HC_STATE_RESUMING;
1844         status = hcd->driver->bus_resume(hcd);
1845         if (status == 0) {
1846                 /* TRSMRCY = 10 msec */
1847                 msleep(10);
1848                 usb_set_device_state(rhdev, rhdev->actconfig
1849                                 ? USB_STATE_CONFIGURED
1850                                 : USB_STATE_ADDRESS);
1851                 hcd->state = HC_STATE_RUNNING;
1852         } else {
1853                 hcd->state = old_state;
1854                 dev_dbg(&rhdev->dev, "bus %s fail, err %d\n",
1855                                 "resume", status);
1856                 if (status != -ESHUTDOWN)
1857                         usb_hc_died(hcd);
1858         }
1859         return status;
1860 }
1861
1862 #endif  /* CONFIG_PM */
1863
1864 #ifdef  CONFIG_USB_SUSPEND
1865
1866 /* Workqueue routine for root-hub remote wakeup */
1867 static void hcd_resume_work(struct work_struct *work)
1868 {
1869         struct usb_hcd *hcd = container_of(work, struct usb_hcd, wakeup_work);
1870         struct usb_device *udev = hcd->self.root_hub;
1871
1872         usb_lock_device(udev);
1873         usb_remote_wakeup(udev);
1874         usb_unlock_device(udev);
1875 }
1876
1877 /**
1878  * usb_hcd_resume_root_hub - called by HCD to resume its root hub 
1879  * @hcd: host controller for this root hub
1880  *
1881  * The USB host controller calls this function when its root hub is
1882  * suspended (with the remote wakeup feature enabled) and a remote
1883  * wakeup request is received.  The routine submits a workqueue request
1884  * to resume the root hub (that is, manage its downstream ports again).
1885  */
1886 void usb_hcd_resume_root_hub (struct usb_hcd *hcd)
1887 {
1888         unsigned long flags;
1889
1890         spin_lock_irqsave (&hcd_root_hub_lock, flags);
1891         if (hcd->rh_registered)
1892                 queue_work(pm_wq, &hcd->wakeup_work);
1893         spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
1894 }
1895 EXPORT_SYMBOL_GPL(usb_hcd_resume_root_hub);
1896
1897 #endif  /* CONFIG_USB_SUSPEND */
1898
1899 /*-------------------------------------------------------------------------*/
1900
1901 #ifdef  CONFIG_USB_OTG
1902
1903 /**
1904  * usb_bus_start_enum - start immediate enumeration (for OTG)
1905  * @bus: the bus (must use hcd framework)
1906  * @port_num: 1-based number of port; usually bus->otg_port
1907  * Context: in_interrupt()
1908  *
1909  * Starts enumeration, with an immediate reset followed later by
1910  * khubd identifying and possibly configuring the device.
1911  * This is needed by OTG controller drivers, where it helps meet
1912  * HNP protocol timing requirements for starting a port reset.
1913  */
1914 int usb_bus_start_enum(struct usb_bus *bus, unsigned port_num)
1915 {
1916         struct usb_hcd          *hcd;
1917         int                     status = -EOPNOTSUPP;
1918
1919         /* NOTE: since HNP can't start by grabbing the bus's address0_sem,
1920          * boards with root hubs hooked up to internal devices (instead of
1921          * just the OTG port) may need more attention to resetting...
1922          */
1923         hcd = container_of (bus, struct usb_hcd, self);
1924         if (port_num && hcd->driver->start_port_reset)
1925                 status = hcd->driver->start_port_reset(hcd, port_num);
1926
1927         /* run khubd shortly after (first) root port reset finishes;
1928          * it may issue others, until at least 50 msecs have passed.
1929          */
1930         if (status == 0)
1931                 mod_timer(&hcd->rh_timer, jiffies + msecs_to_jiffies(10));
1932         return status;
1933 }
1934 EXPORT_SYMBOL_GPL(usb_bus_start_enum);
1935
1936 #endif
1937
1938 /*-------------------------------------------------------------------------*/
1939
1940 /**
1941  * usb_hcd_irq - hook IRQs to HCD framework (bus glue)
1942  * @irq: the IRQ being raised
1943  * @__hcd: pointer to the HCD whose IRQ is being signaled
1944  *
1945  * If the controller isn't HALTed, calls the driver's irq handler.
1946  * Checks whether the controller is now dead.
1947  */
1948 irqreturn_t usb_hcd_irq (int irq, void *__hcd)
1949 {
1950         struct usb_hcd          *hcd = __hcd;
1951         unsigned long           flags;
1952         irqreturn_t             rc;
1953
1954         /* IRQF_DISABLED doesn't work correctly with shared IRQs
1955          * when the first handler doesn't use it.  So let's just
1956          * assume it's never used.
1957          */
1958         local_irq_save(flags);
1959
1960         if (unlikely(hcd->state == HC_STATE_HALT ||
1961                      !test_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags))) {
1962                 rc = IRQ_NONE;
1963         } else if (hcd->driver->irq(hcd) == IRQ_NONE) {
1964                 rc = IRQ_NONE;
1965         } else {
1966                 set_bit(HCD_FLAG_SAW_IRQ, &hcd->flags);
1967
1968                 if (unlikely(hcd->state == HC_STATE_HALT))
1969                         usb_hc_died(hcd);
1970                 rc = IRQ_HANDLED;
1971         }
1972
1973         local_irq_restore(flags);
1974         return rc;
1975 }
1976
1977 /*-------------------------------------------------------------------------*/
1978
1979 /**
1980  * usb_hc_died - report abnormal shutdown of a host controller (bus glue)
1981  * @hcd: pointer to the HCD representing the controller
1982  *
1983  * This is called by bus glue to report a USB host controller that died
1984  * while operations may still have been pending.  It's called automatically
1985  * by the PCI glue, so only glue for non-PCI busses should need to call it. 
1986  */
1987 void usb_hc_died (struct usb_hcd *hcd)
1988 {
1989         unsigned long flags;
1990
1991         dev_err (hcd->self.controller, "HC died; cleaning up\n");
1992
1993         spin_lock_irqsave (&hcd_root_hub_lock, flags);
1994         if (hcd->rh_registered) {
1995                 hcd->poll_rh = 0;
1996
1997                 /* make khubd clean up old urbs and devices */
1998                 usb_set_device_state (hcd->self.root_hub,
1999                                 USB_STATE_NOTATTACHED);
2000                 usb_kick_khubd (hcd->self.root_hub);
2001         }
2002         spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
2003 }
2004 EXPORT_SYMBOL_GPL (usb_hc_died);
2005
2006 /*-------------------------------------------------------------------------*/
2007
2008 /**
2009  * usb_create_hcd - create and initialize an HCD structure
2010  * @driver: HC driver that will use this hcd
2011  * @dev: device for this HC, stored in hcd->self.controller
2012  * @bus_name: value to store in hcd->self.bus_name
2013  * Context: !in_interrupt()
2014  *
2015  * Allocate a struct usb_hcd, with extra space at the end for the
2016  * HC driver's private data.  Initialize the generic members of the
2017  * hcd structure.
2018  *
2019  * If memory is unavailable, returns NULL.
2020  */
2021 struct usb_hcd *usb_create_hcd (const struct hc_driver *driver,
2022                 struct device *dev, const char *bus_name)
2023 {
2024         struct usb_hcd *hcd;
2025
2026         hcd = kzalloc(sizeof(*hcd) + driver->hcd_priv_size, GFP_KERNEL);
2027         if (!hcd) {
2028                 dev_dbg (dev, "hcd alloc failed\n");
2029                 return NULL;
2030         }
2031         dev_set_drvdata(dev, hcd);
2032         kref_init(&hcd->kref);
2033
2034         usb_bus_init(&hcd->self);
2035         hcd->self.controller = dev;
2036         hcd->self.bus_name = bus_name;
2037         hcd->self.uses_dma = (dev->dma_mask != NULL);
2038
2039         init_timer(&hcd->rh_timer);
2040         hcd->rh_timer.function = rh_timer_func;
2041         hcd->rh_timer.data = (unsigned long) hcd;
2042 #ifdef CONFIG_USB_SUSPEND
2043         INIT_WORK(&hcd->wakeup_work, hcd_resume_work);
2044 #endif
2045         mutex_init(&hcd->bandwidth_mutex);
2046
2047         hcd->driver = driver;
2048         hcd->product_desc = (driver->product_desc) ? driver->product_desc :
2049                         "USB Host Controller";
2050         return hcd;
2051 }
2052 EXPORT_SYMBOL_GPL(usb_create_hcd);
2053
2054 static void hcd_release (struct kref *kref)
2055 {
2056         struct usb_hcd *hcd = container_of (kref, struct usb_hcd, kref);
2057
2058         kfree(hcd);
2059 }
2060
2061 struct usb_hcd *usb_get_hcd (struct usb_hcd *hcd)
2062 {
2063         if (hcd)
2064                 kref_get (&hcd->kref);
2065         return hcd;
2066 }
2067 EXPORT_SYMBOL_GPL(usb_get_hcd);
2068
2069 void usb_put_hcd (struct usb_hcd *hcd)
2070 {
2071         if (hcd)
2072                 kref_put (&hcd->kref, hcd_release);
2073 }
2074 EXPORT_SYMBOL_GPL(usb_put_hcd);
2075
2076 /**
2077  * usb_add_hcd - finish generic HCD structure initialization and register
2078  * @hcd: the usb_hcd structure to initialize
2079  * @irqnum: Interrupt line to allocate
2080  * @irqflags: Interrupt type flags
2081  *
2082  * Finish the remaining parts of generic HCD initialization: allocate the
2083  * buffers of consistent memory, register the bus, request the IRQ line,
2084  * and call the driver's reset() and start() routines.
2085  */
2086 int usb_add_hcd(struct usb_hcd *hcd,
2087                 unsigned int irqnum, unsigned long irqflags)
2088 {
2089         int retval;
2090         struct usb_device *rhdev;
2091
2092         dev_info(hcd->self.controller, "%s\n", hcd->product_desc);
2093
2094         hcd->authorized_default = hcd->wireless? 0 : 1;
2095         set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
2096
2097         /* HC is in reset state, but accessible.  Now do the one-time init,
2098          * bottom up so that hcds can customize the root hubs before khubd
2099          * starts talking to them.  (Note, bus id is assigned early too.)
2100          */
2101         if ((retval = hcd_buffer_create(hcd)) != 0) {
2102                 dev_dbg(hcd->self.controller, "pool alloc failed\n");
2103                 return retval;
2104         }
2105
2106         if ((retval = usb_register_bus(&hcd->self)) < 0)
2107                 goto err_register_bus;
2108
2109         if ((rhdev = usb_alloc_dev(NULL, &hcd->self, 0)) == NULL) {
2110                 dev_err(hcd->self.controller, "unable to allocate root hub\n");
2111                 retval = -ENOMEM;
2112                 goto err_allocate_root_hub;
2113         }
2114
2115         switch (hcd->driver->flags & HCD_MASK) {
2116         case HCD_USB11:
2117                 rhdev->speed = USB_SPEED_FULL;
2118                 break;
2119         case HCD_USB2:
2120                 rhdev->speed = USB_SPEED_HIGH;
2121                 break;
2122         case HCD_USB3:
2123                 rhdev->speed = USB_SPEED_SUPER;
2124                 break;
2125         default:
2126                 goto err_allocate_root_hub;
2127         }
2128         hcd->self.root_hub = rhdev;
2129
2130         /* wakeup flag init defaults to "everything works" for root hubs,
2131          * but drivers can override it in reset() if needed, along with
2132          * recording the overall controller's system wakeup capability.
2133          */
2134         device_init_wakeup(&rhdev->dev, 1);
2135
2136         /* "reset" is misnamed; its role is now one-time init. the controller
2137          * should already have been reset (and boot firmware kicked off etc).
2138          */
2139         if (hcd->driver->reset && (retval = hcd->driver->reset(hcd)) < 0) {
2140                 dev_err(hcd->self.controller, "can't setup\n");
2141                 goto err_hcd_driver_setup;
2142         }
2143
2144         /* NOTE: root hub and controller capabilities may not be the same */
2145         if (device_can_wakeup(hcd->self.controller)
2146                         && device_can_wakeup(&hcd->self.root_hub->dev))
2147                 dev_dbg(hcd->self.controller, "supports USB remote wakeup\n");
2148
2149         /* enable irqs just before we start the controller */
2150         if (hcd->driver->irq) {
2151
2152                 /* IRQF_DISABLED doesn't work as advertised when used together
2153                  * with IRQF_SHARED. As usb_hcd_irq() will always disable
2154                  * interrupts we can remove it here.
2155                  */
2156                 if (irqflags & IRQF_SHARED)
2157                         irqflags &= ~IRQF_DISABLED;
2158
2159                 snprintf(hcd->irq_descr, sizeof(hcd->irq_descr), "%s:usb%d",
2160                                 hcd->driver->description, hcd->self.busnum);
2161                 if ((retval = request_irq(irqnum, &usb_hcd_irq, irqflags,
2162                                 hcd->irq_descr, hcd)) != 0) {
2163                         dev_err(hcd->self.controller,
2164                                         "request interrupt %d failed\n", irqnum);
2165                         goto err_request_irq;
2166                 }
2167                 hcd->irq = irqnum;
2168                 dev_info(hcd->self.controller, "irq %d, %s 0x%08llx\n", irqnum,
2169                                 (hcd->driver->flags & HCD_MEMORY) ?
2170                                         "io mem" : "io base",
2171                                         (unsigned long long)hcd->rsrc_start);
2172         } else {
2173                 hcd->irq = -1;
2174                 if (hcd->rsrc_start)
2175                         dev_info(hcd->self.controller, "%s 0x%08llx\n",
2176                                         (hcd->driver->flags & HCD_MEMORY) ?
2177                                         "io mem" : "io base",
2178                                         (unsigned long long)hcd->rsrc_start);
2179         }
2180
2181         if ((retval = hcd->driver->start(hcd)) < 0) {
2182                 dev_err(hcd->self.controller, "startup error %d\n", retval);
2183                 goto err_hcd_driver_start;
2184         }
2185
2186         /* starting here, usbcore will pay attention to this root hub */
2187         rhdev->bus_mA = min(500u, hcd->power_budget);
2188         if ((retval = register_root_hub(hcd)) != 0)
2189                 goto err_register_root_hub;
2190
2191         retval = sysfs_create_group(&rhdev->dev.kobj, &usb_bus_attr_group);
2192         if (retval < 0) {
2193                 printk(KERN_ERR "Cannot register USB bus sysfs attributes: %d\n",
2194                        retval);
2195                 goto error_create_attr_group;
2196         }
2197         if (hcd->uses_new_polling && hcd->poll_rh)
2198                 usb_hcd_poll_rh_status(hcd);
2199         return retval;
2200
2201 error_create_attr_group:
2202         mutex_lock(&usb_bus_list_lock);
2203         usb_disconnect(&hcd->self.root_hub);
2204         mutex_unlock(&usb_bus_list_lock);
2205 err_register_root_hub:
2206         hcd->driver->stop(hcd);
2207 err_hcd_driver_start:
2208         if (hcd->irq >= 0)
2209                 free_irq(irqnum, hcd);
2210 err_request_irq:
2211 err_hcd_driver_setup:
2212         hcd->self.root_hub = NULL;
2213         usb_put_dev(rhdev);
2214 err_allocate_root_hub:
2215         usb_deregister_bus(&hcd->self);
2216 err_register_bus:
2217         hcd_buffer_destroy(hcd);
2218         return retval;
2219
2220 EXPORT_SYMBOL_GPL(usb_add_hcd);
2221
2222 /**
2223  * usb_remove_hcd - shutdown processing for generic HCDs
2224  * @hcd: the usb_hcd structure to remove
2225  * Context: !in_interrupt()
2226  *
2227  * Disconnects the root hub, then reverses the effects of usb_add_hcd(),
2228  * invoking the HCD's stop() method.
2229  */
2230 void usb_remove_hcd(struct usb_hcd *hcd)
2231 {
2232         dev_info(hcd->self.controller, "remove, state %x\n", hcd->state);
2233
2234         if (HC_IS_RUNNING (hcd->state))
2235                 hcd->state = HC_STATE_QUIESCING;
2236
2237         dev_dbg(hcd->self.controller, "roothub graceful disconnect\n");
2238         spin_lock_irq (&hcd_root_hub_lock);
2239         hcd->rh_registered = 0;
2240         spin_unlock_irq (&hcd_root_hub_lock);
2241
2242 #ifdef CONFIG_USB_SUSPEND
2243         cancel_work_sync(&hcd->wakeup_work);
2244 #endif
2245
2246         sysfs_remove_group(&hcd->self.root_hub->dev.kobj, &usb_bus_attr_group);
2247         mutex_lock(&usb_bus_list_lock);
2248         usb_disconnect(&hcd->self.root_hub);
2249         mutex_unlock(&usb_bus_list_lock);
2250
2251         hcd->driver->stop(hcd);
2252         hcd->state = HC_STATE_HALT;
2253
2254         hcd->poll_rh = 0;
2255         del_timer_sync(&hcd->rh_timer);
2256
2257         if (hcd->irq >= 0)
2258                 free_irq(hcd->irq, hcd);
2259         usb_deregister_bus(&hcd->self);
2260         hcd_buffer_destroy(hcd);
2261 }
2262 EXPORT_SYMBOL_GPL(usb_remove_hcd);
2263
2264 void
2265 usb_hcd_platform_shutdown(struct platform_device* dev)
2266 {
2267         struct usb_hcd *hcd = platform_get_drvdata(dev);
2268
2269         if (hcd->driver->shutdown)
2270                 hcd->driver->shutdown(hcd);
2271 }
2272 EXPORT_SYMBOL_GPL(usb_hcd_platform_shutdown);
2273
2274 /*-------------------------------------------------------------------------*/
2275
2276 #if defined(CONFIG_USB_MON) || defined(CONFIG_USB_MON_MODULE)
2277
2278 struct usb_mon_operations *mon_ops;
2279
2280 /*
2281  * The registration is unlocked.
2282  * We do it this way because we do not want to lock in hot paths.
2283  *
2284  * Notice that the code is minimally error-proof. Because usbmon needs
2285  * symbols from usbcore, usbcore gets referenced and cannot be unloaded first.
2286  */
2287  
2288 int usb_mon_register (struct usb_mon_operations *ops)
2289 {
2290
2291         if (mon_ops)
2292                 return -EBUSY;
2293
2294         mon_ops = ops;
2295         mb();
2296         return 0;
2297 }
2298 EXPORT_SYMBOL_GPL (usb_mon_register);
2299
2300 void usb_mon_deregister (void)
2301 {
2302
2303         if (mon_ops == NULL) {
2304                 printk(KERN_ERR "USB: monitor was not registered\n");
2305                 return;
2306         }
2307         mon_ops = NULL;
2308         mb();
2309 }
2310 EXPORT_SYMBOL_GPL (usb_mon_deregister);
2311
2312 #endif /* CONFIG_USB_MON || CONFIG_USB_MON_MODULE */