Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
hcd.c
Go to the documentation of this file.
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/bcd.h>
26 #include <linux/module.h>
27 #include <linux/version.h>
28 #include <linux/kernel.h>
29 #include <linux/slab.h>
30 #include <linux/completion.h>
31 #include <linux/utsname.h>
32 #include <linux/mm.h>
33 #include <asm/io.h>
34 #include <linux/device.h>
35 #include <linux/dma-mapping.h>
36 #include <linux/mutex.h>
37 #include <asm/irq.h>
38 #include <asm/byteorder.h>
39 #include <asm/unaligned.h>
40 #include <linux/platform_device.h>
41 #include <linux/workqueue.h>
42 
43 #include <linux/usb.h>
44 #include <linux/usb/hcd.h>
45 
46 #include "usb.h"
47 
48 
49 /*-------------------------------------------------------------------------*/
50 
51 /*
52  * USB Host Controller Driver framework
53  *
54  * Plugs into usbcore (usb_bus) and lets HCDs share code, minimizing
55  * HCD-specific behaviors/bugs.
56  *
57  * This does error checks, tracks devices and urbs, and delegates to a
58  * "hc_driver" only for code (and data) that really needs to know about
59  * hardware differences. That includes root hub registers, i/o queues,
60  * and so on ... but as little else as possible.
61  *
62  * Shared code includes most of the "root hub" code (these are emulated,
63  * though each HC's hardware works differently) and PCI glue, plus request
64  * tracking overhead. The HCD code should only block on spinlocks or on
65  * hardware handshaking; blocking on software events (such as other kernel
66  * threads releasing resources, or completing actions) is all generic.
67  *
68  * Happens the USB 2.0 spec says this would be invisible inside the "USBD",
69  * and includes mostly a "HCDI" (HCD Interface) along with some APIs used
70  * only by the hub driver ... and that neither should be seen or used by
71  * usb client device drivers.
72  *
73  * Contributors of ideas or unattributed patches include: David Brownell,
74  * Roman Weissgaerber, Rory Bolt, Greg Kroah-Hartman, ...
75  *
76  * HISTORY:
77  * 2002-02-21 Pull in most of the usb_bus support from usb.c; some
78  * associated cleanup. "usb_hcd" still != "usb_bus".
79  * 2001-12-12 Initial patch version for Linux 2.5.1 kernel.
80  */
81 
82 /*-------------------------------------------------------------------------*/
83 
84 /* Keep track of which host controller drivers are loaded */
85 unsigned long usb_hcds_loaded;
86 EXPORT_SYMBOL_GPL(usb_hcds_loaded);
87 
88 /* host controllers we manage */
89 LIST_HEAD (usb_bus_list);
90 EXPORT_SYMBOL_GPL (usb_bus_list);
91 
92 /* used when allocating bus numbers */
93 #define USB_MAXBUS 64
94 struct usb_busmap {
95  unsigned long busmap [USB_MAXBUS / (8*sizeof (unsigned long))];
96 };
97 static struct usb_busmap busmap;
98 
99 /* used when updating list of hcds */
100 DEFINE_MUTEX(usb_bus_list_lock); /* exported only for usbfs */
101 EXPORT_SYMBOL_GPL (usb_bus_list_lock);
102 
103 /* used for controlling access to virtual root hubs */
104 static DEFINE_SPINLOCK(hcd_root_hub_lock);
105 
106 /* used when updating an endpoint's URB list */
107 static DEFINE_SPINLOCK(hcd_urb_list_lock);
108 
109 /* used to protect against unlinking URBs after the device is gone */
110 static DEFINE_SPINLOCK(hcd_urb_unlink_lock);
111 
112 /* wait queue for synchronous unlinks */
113 DECLARE_WAIT_QUEUE_HEAD(usb_kill_urb_queue);
114 
115 static inline int is_root_hub(struct usb_device *udev)
116 {
117  return (udev->parent == NULL);
118 }
119 
120 /*-------------------------------------------------------------------------*/
121 
122 /*
123  * Sharable chunks of root hub code.
124  */
125 
126 /*-------------------------------------------------------------------------*/
127 #define KERNEL_REL bin2bcd(((LINUX_VERSION_CODE >> 16) & 0x0ff))
128 #define KERNEL_VER bin2bcd(((LINUX_VERSION_CODE >> 8) & 0x0ff))
129 
130 /* usb 3.0 root hub device descriptor */
131 static const u8 usb3_rh_dev_descriptor[18] = {
132  0x12, /* __u8 bLength; */
133  0x01, /* __u8 bDescriptorType; Device */
134  0x00, 0x03, /* __le16 bcdUSB; v3.0 */
135 
136  0x09, /* __u8 bDeviceClass; HUB_CLASSCODE */
137  0x00, /* __u8 bDeviceSubClass; */
138  0x03, /* __u8 bDeviceProtocol; USB 3.0 hub */
139  0x09, /* __u8 bMaxPacketSize0; 2^9 = 512 Bytes */
140 
141  0x6b, 0x1d, /* __le16 idVendor; Linux Foundation 0x1d6b */
142  0x03, 0x00, /* __le16 idProduct; device 0x0003 */
143  KERNEL_VER, KERNEL_REL, /* __le16 bcdDevice */
144 
145  0x03, /* __u8 iManufacturer; */
146  0x02, /* __u8 iProduct; */
147  0x01, /* __u8 iSerialNumber; */
148  0x01 /* __u8 bNumConfigurations; */
149 };
150 
151 /* usb 2.0 root hub device descriptor */
152 static const u8 usb2_rh_dev_descriptor [18] = {
153  0x12, /* __u8 bLength; */
154  0x01, /* __u8 bDescriptorType; Device */
155  0x00, 0x02, /* __le16 bcdUSB; v2.0 */
156 
157  0x09, /* __u8 bDeviceClass; HUB_CLASSCODE */
158  0x00, /* __u8 bDeviceSubClass; */
159  0x00, /* __u8 bDeviceProtocol; [ usb 2.0 no TT ] */
160  0x40, /* __u8 bMaxPacketSize0; 64 Bytes */
161 
162  0x6b, 0x1d, /* __le16 idVendor; Linux Foundation 0x1d6b */
163  0x02, 0x00, /* __le16 idProduct; device 0x0002 */
164  KERNEL_VER, KERNEL_REL, /* __le16 bcdDevice */
165 
166  0x03, /* __u8 iManufacturer; */
167  0x02, /* __u8 iProduct; */
168  0x01, /* __u8 iSerialNumber; */
169  0x01 /* __u8 bNumConfigurations; */
170 };
171 
172 /* no usb 2.0 root hub "device qualifier" descriptor: one speed only */
173 
174 /* usb 1.1 root hub device descriptor */
175 static const u8 usb11_rh_dev_descriptor [18] = {
176  0x12, /* __u8 bLength; */
177  0x01, /* __u8 bDescriptorType; Device */
178  0x10, 0x01, /* __le16 bcdUSB; v1.1 */
179 
180  0x09, /* __u8 bDeviceClass; HUB_CLASSCODE */
181  0x00, /* __u8 bDeviceSubClass; */
182  0x00, /* __u8 bDeviceProtocol; [ low/full speeds only ] */
183  0x40, /* __u8 bMaxPacketSize0; 64 Bytes */
184 
185  0x6b, 0x1d, /* __le16 idVendor; Linux Foundation 0x1d6b */
186  0x01, 0x00, /* __le16 idProduct; device 0x0001 */
187  KERNEL_VER, KERNEL_REL, /* __le16 bcdDevice */
188 
189  0x03, /* __u8 iManufacturer; */
190  0x02, /* __u8 iProduct; */
191  0x01, /* __u8 iSerialNumber; */
192  0x01 /* __u8 bNumConfigurations; */
193 };
194 
195 
196 /*-------------------------------------------------------------------------*/
197 
198 /* Configuration descriptors for our root hubs */
199 
200 static const u8 fs_rh_config_descriptor [] = {
201 
202  /* one configuration */
203  0x09, /* __u8 bLength; */
204  0x02, /* __u8 bDescriptorType; Configuration */
205  0x19, 0x00, /* __le16 wTotalLength; */
206  0x01, /* __u8 bNumInterfaces; (1) */
207  0x01, /* __u8 bConfigurationValue; */
208  0x00, /* __u8 iConfiguration; */
209  0xc0, /* __u8 bmAttributes;
210  Bit 7: must be set,
211  6: Self-powered,
212  5: Remote wakeup,
213  4..0: resvd */
214  0x00, /* __u8 MaxPower; */
215 
216  /* USB 1.1:
217  * USB 2.0, single TT organization (mandatory):
218  * one interface, protocol 0
219  *
220  * USB 2.0, multiple TT organization (optional):
221  * two interfaces, protocols 1 (like single TT)
222  * and 2 (multiple TT mode) ... config is
223  * sometimes settable
224  * NOT IMPLEMENTED
225  */
226 
227  /* one interface */
228  0x09, /* __u8 if_bLength; */
229  0x04, /* __u8 if_bDescriptorType; Interface */
230  0x00, /* __u8 if_bInterfaceNumber; */
231  0x00, /* __u8 if_bAlternateSetting; */
232  0x01, /* __u8 if_bNumEndpoints; */
233  0x09, /* __u8 if_bInterfaceClass; HUB_CLASSCODE */
234  0x00, /* __u8 if_bInterfaceSubClass; */
235  0x00, /* __u8 if_bInterfaceProtocol; [usb1.1 or single tt] */
236  0x00, /* __u8 if_iInterface; */
237 
238  /* one endpoint (status change endpoint) */
239  0x07, /* __u8 ep_bLength; */
240  0x05, /* __u8 ep_bDescriptorType; Endpoint */
241  0x81, /* __u8 ep_bEndpointAddress; IN Endpoint 1 */
242  0x03, /* __u8 ep_bmAttributes; Interrupt */
243  0x02, 0x00, /* __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8) */
244  0xff /* __u8 ep_bInterval; (255ms -- usb 2.0 spec) */
245 };
246 
247 static const u8 hs_rh_config_descriptor [] = {
248 
249  /* one configuration */
250  0x09, /* __u8 bLength; */
251  0x02, /* __u8 bDescriptorType; Configuration */
252  0x19, 0x00, /* __le16 wTotalLength; */
253  0x01, /* __u8 bNumInterfaces; (1) */
254  0x01, /* __u8 bConfigurationValue; */
255  0x00, /* __u8 iConfiguration; */
256  0xc0, /* __u8 bmAttributes;
257  Bit 7: must be set,
258  6: Self-powered,
259  5: Remote wakeup,
260  4..0: resvd */
261  0x00, /* __u8 MaxPower; */
262 
263  /* USB 1.1:
264  * USB 2.0, single TT organization (mandatory):
265  * one interface, protocol 0
266  *
267  * USB 2.0, multiple TT organization (optional):
268  * two interfaces, protocols 1 (like single TT)
269  * and 2 (multiple TT mode) ... config is
270  * sometimes settable
271  * NOT IMPLEMENTED
272  */
273 
274  /* one interface */
275  0x09, /* __u8 if_bLength; */
276  0x04, /* __u8 if_bDescriptorType; Interface */
277  0x00, /* __u8 if_bInterfaceNumber; */
278  0x00, /* __u8 if_bAlternateSetting; */
279  0x01, /* __u8 if_bNumEndpoints; */
280  0x09, /* __u8 if_bInterfaceClass; HUB_CLASSCODE */
281  0x00, /* __u8 if_bInterfaceSubClass; */
282  0x00, /* __u8 if_bInterfaceProtocol; [usb1.1 or single tt] */
283  0x00, /* __u8 if_iInterface; */
284 
285  /* one endpoint (status change endpoint) */
286  0x07, /* __u8 ep_bLength; */
287  0x05, /* __u8 ep_bDescriptorType; Endpoint */
288  0x81, /* __u8 ep_bEndpointAddress; IN Endpoint 1 */
289  0x03, /* __u8 ep_bmAttributes; Interrupt */
290  /* __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8)
291  * see hub.c:hub_configure() for details. */
292  (USB_MAXCHILDREN + 1 + 7) / 8, 0x00,
293  0x0c /* __u8 ep_bInterval; (256ms -- usb 2.0 spec) */
294 };
295 
296 static const u8 ss_rh_config_descriptor[] = {
297  /* one configuration */
298  0x09, /* __u8 bLength; */
299  0x02, /* __u8 bDescriptorType; Configuration */
300  0x1f, 0x00, /* __le16 wTotalLength; */
301  0x01, /* __u8 bNumInterfaces; (1) */
302  0x01, /* __u8 bConfigurationValue; */
303  0x00, /* __u8 iConfiguration; */
304  0xc0, /* __u8 bmAttributes;
305  Bit 7: must be set,
306  6: Self-powered,
307  5: Remote wakeup,
308  4..0: resvd */
309  0x00, /* __u8 MaxPower; */
310 
311  /* one interface */
312  0x09, /* __u8 if_bLength; */
313  0x04, /* __u8 if_bDescriptorType; Interface */
314  0x00, /* __u8 if_bInterfaceNumber; */
315  0x00, /* __u8 if_bAlternateSetting; */
316  0x01, /* __u8 if_bNumEndpoints; */
317  0x09, /* __u8 if_bInterfaceClass; HUB_CLASSCODE */
318  0x00, /* __u8 if_bInterfaceSubClass; */
319  0x00, /* __u8 if_bInterfaceProtocol; */
320  0x00, /* __u8 if_iInterface; */
321 
322  /* one endpoint (status change endpoint) */
323  0x07, /* __u8 ep_bLength; */
324  0x05, /* __u8 ep_bDescriptorType; Endpoint */
325  0x81, /* __u8 ep_bEndpointAddress; IN Endpoint 1 */
326  0x03, /* __u8 ep_bmAttributes; Interrupt */
327  /* __le16 ep_wMaxPacketSize; 1 + (MAX_ROOT_PORTS / 8)
328  * see hub.c:hub_configure() for details. */
329  (USB_MAXCHILDREN + 1 + 7) / 8, 0x00,
330  0x0c, /* __u8 ep_bInterval; (256ms -- usb 2.0 spec) */
331 
332  /* one SuperSpeed endpoint companion descriptor */
333  0x06, /* __u8 ss_bLength */
334  0x30, /* __u8 ss_bDescriptorType; SuperSpeed EP Companion */
335  0x00, /* __u8 ss_bMaxBurst; allows 1 TX between ACKs */
336  0x00, /* __u8 ss_bmAttributes; 1 packet per service interval */
337  0x02, 0x00 /* __le16 ss_wBytesPerInterval; 15 bits for max 15 ports */
338 };
339 
340 /* authorized_default behaviour:
341  * -1 is authorized for all devices except wireless (old behaviour)
342  * 0 is unauthorized for all devices
343  * 1 is authorized for all devices
344  */
345 static int authorized_default = -1;
346 module_param(authorized_default, int, S_IRUGO|S_IWUSR);
347 MODULE_PARM_DESC(authorized_default,
348  "Default USB device authorization: 0 is not authorized, 1 is "
349  "authorized, -1 is authorized except for wireless USB (default, "
350  "old behaviour");
351 /*-------------------------------------------------------------------------*/
352 
365 static unsigned
366 ascii2desc(char const *s, u8 *buf, unsigned len)
367 {
368  unsigned n, t = 2 + 2*strlen(s);
369 
370  if (t > 254)
371  t = 254; /* Longest possible UTF string descriptor */
372  if (len > t)
373  len = t;
374 
375  t += USB_DT_STRING << 8; /* Now t is first 16 bits to store */
376 
377  n = len;
378  while (n--) {
379  *buf++ = t;
380  if (!n--)
381  break;
382  *buf++ = t >> 8;
383  t = (unsigned char)*s++;
384  }
385  return len;
386 }
387 
400 static unsigned
401 rh_string(int id, struct usb_hcd const *hcd, u8 *data, unsigned len)
402 {
403  char buf[100];
404  char const *s;
405  static char const langids[4] = {4, USB_DT_STRING, 0x09, 0x04};
406 
407  // language ids
408  switch (id) {
409  case 0:
410  /* Array of LANGID codes (0x0409 is MSFT-speak for "en-us") */
411  /* See http://www.usb.org/developers/docs/USB_LANGIDs.pdf */
412  if (len > 4)
413  len = 4;
414  memcpy(data, langids, len);
415  return len;
416  case 1:
417  /* Serial number */
418  s = hcd->self.bus_name;
419  break;
420  case 2:
421  /* Product name */
422  s = hcd->product_desc;
423  break;
424  case 3:
425  /* Manufacturer */
426  snprintf (buf, sizeof buf, "%s %s %s", init_utsname()->sysname,
427  init_utsname()->release, hcd->driver->description);
428  s = buf;
429  break;
430  default:
431  /* Can't happen; caller guarantees it */
432  return 0;
433  }
434 
435  return ascii2desc(s, data, len);
436 }
437 
438 
439 /* Root hub control transfers execute synchronously */
440 static int rh_call_control (struct usb_hcd *hcd, struct urb *urb)
441 {
442  struct usb_ctrlrequest *cmd;
443  u16 typeReq, wValue, wIndex, wLength;
444  u8 *ubuf = urb->transfer_buffer;
445  /*
446  * tbuf should be as big as the BOS descriptor and
447  * the USB hub descriptor.
448  */
449  u8 tbuf[USB_DT_BOS_SIZE + USB_DT_USB_SS_CAP_SIZE]
450  __attribute__((aligned(4)));
451  const u8 *bufp = tbuf;
452  unsigned len = 0;
453  int status;
454  u8 patch_wakeup = 0;
455  u8 patch_protocol = 0;
456 
457  might_sleep();
458 
459  spin_lock_irq(&hcd_root_hub_lock);
460  status = usb_hcd_link_urb_to_ep(hcd, urb);
461  spin_unlock_irq(&hcd_root_hub_lock);
462  if (status)
463  return status;
464  urb->hcpriv = hcd; /* Indicate it's queued */
465 
466  cmd = (struct usb_ctrlrequest *) urb->setup_packet;
467  typeReq = (cmd->bRequestType << 8) | cmd->bRequest;
468  wValue = le16_to_cpu (cmd->wValue);
469  wIndex = le16_to_cpu (cmd->wIndex);
470  wLength = le16_to_cpu (cmd->wLength);
471 
472  if (wLength > urb->transfer_buffer_length)
473  goto error;
474 
475  urb->actual_length = 0;
476  switch (typeReq) {
477 
478  /* DEVICE REQUESTS */
479 
480  /* The root hub's remote wakeup enable bit is implemented using
481  * driver model wakeup flags. If this system supports wakeup
482  * through USB, userspace may change the default "allow wakeup"
483  * policy through sysfs or these calls.
484  *
485  * Most root hubs support wakeup from downstream devices, for
486  * runtime power management (disabling USB clocks and reducing
487  * VBUS power usage). However, not all of them do so; silicon,
488  * board, and BIOS bugs here are not uncommon, so these can't
489  * be treated quite like external hubs.
490  *
491  * Likewise, not all root hubs will pass wakeup events upstream,
492  * to wake up the whole system. So don't assume root hub and
493  * controller capabilities are identical.
494  */
495 
496  case DeviceRequest | USB_REQ_GET_STATUS:
497  tbuf [0] = (device_may_wakeup(&hcd->self.root_hub->dev)
498  << USB_DEVICE_REMOTE_WAKEUP)
499  | (1 << USB_DEVICE_SELF_POWERED);
500  tbuf [1] = 0;
501  len = 2;
502  break;
503  case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
504  if (wValue == USB_DEVICE_REMOTE_WAKEUP)
505  device_set_wakeup_enable(&hcd->self.root_hub->dev, 0);
506  else
507  goto error;
508  break;
509  case DeviceOutRequest | USB_REQ_SET_FEATURE:
510  if (device_can_wakeup(&hcd->self.root_hub->dev)
511  && wValue == USB_DEVICE_REMOTE_WAKEUP)
512  device_set_wakeup_enable(&hcd->self.root_hub->dev, 1);
513  else
514  goto error;
515  break;
516  case DeviceRequest | USB_REQ_GET_CONFIGURATION:
517  tbuf [0] = 1;
518  len = 1;
519  /* FALLTHROUGH */
520  case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
521  break;
522  case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
523  switch (wValue & 0xff00) {
524  case USB_DT_DEVICE << 8:
525  switch (hcd->speed) {
526  case HCD_USB3:
527  bufp = usb3_rh_dev_descriptor;
528  break;
529  case HCD_USB2:
530  bufp = usb2_rh_dev_descriptor;
531  break;
532  case HCD_USB11:
533  bufp = usb11_rh_dev_descriptor;
534  break;
535  default:
536  goto error;
537  }
538  len = 18;
539  if (hcd->has_tt)
540  patch_protocol = 1;
541  break;
542  case USB_DT_CONFIG << 8:
543  switch (hcd->speed) {
544  case HCD_USB3:
545  bufp = ss_rh_config_descriptor;
546  len = sizeof ss_rh_config_descriptor;
547  break;
548  case HCD_USB2:
549  bufp = hs_rh_config_descriptor;
550  len = sizeof hs_rh_config_descriptor;
551  break;
552  case HCD_USB11:
553  bufp = fs_rh_config_descriptor;
554  len = sizeof fs_rh_config_descriptor;
555  break;
556  default:
557  goto error;
558  }
559  if (device_can_wakeup(&hcd->self.root_hub->dev))
560  patch_wakeup = 1;
561  break;
562  case USB_DT_STRING << 8:
563  if ((wValue & 0xff) < 4)
564  urb->actual_length = rh_string(wValue & 0xff,
565  hcd, ubuf, wLength);
566  else /* unsupported IDs --> "protocol stall" */
567  goto error;
568  break;
569  case USB_DT_BOS << 8:
570  goto nongeneric;
571  default:
572  goto error;
573  }
574  break;
575  case DeviceRequest | USB_REQ_GET_INTERFACE:
576  tbuf [0] = 0;
577  len = 1;
578  /* FALLTHROUGH */
579  case DeviceOutRequest | USB_REQ_SET_INTERFACE:
580  break;
581  case DeviceOutRequest | USB_REQ_SET_ADDRESS:
582  // wValue == urb->dev->devaddr
583  dev_dbg (hcd->self.controller, "root hub device address %d\n",
584  wValue);
585  break;
586 
587  /* INTERFACE REQUESTS (no defined feature/status flags) */
588 
589  /* ENDPOINT REQUESTS */
590 
591  case EndpointRequest | USB_REQ_GET_STATUS:
592  // ENDPOINT_HALT flag
593  tbuf [0] = 0;
594  tbuf [1] = 0;
595  len = 2;
596  /* FALLTHROUGH */
597  case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
598  case EndpointOutRequest | USB_REQ_SET_FEATURE:
599  dev_dbg (hcd->self.controller, "no endpoint features yet\n");
600  break;
601 
602  /* CLASS REQUESTS (and errors) */
603 
604  default:
605 nongeneric:
606  /* non-generic request */
607  switch (typeReq) {
608  case GetHubStatus:
609  case GetPortStatus:
610  len = 4;
611  break;
612  case GetHubDescriptor:
613  len = sizeof (struct usb_hub_descriptor);
614  break;
615  case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
616  /* len is returned by hub_control */
617  break;
618  }
619  status = hcd->driver->hub_control (hcd,
620  typeReq, wValue, wIndex,
621  tbuf, wLength);
622  break;
623 error:
624  /* "protocol stall" on error */
625  status = -EPIPE;
626  }
627 
628  if (status < 0) {
629  len = 0;
630  if (status != -EPIPE) {
631  dev_dbg (hcd->self.controller,
632  "CTRL: TypeReq=0x%x val=0x%x "
633  "idx=0x%x len=%d ==> %d\n",
634  typeReq, wValue, wIndex,
635  wLength, status);
636  }
637  } else if (status > 0) {
638  /* hub_control may return the length of data copied. */
639  len = status;
640  status = 0;
641  }
642  if (len) {
643  if (urb->transfer_buffer_length < len)
644  len = urb->transfer_buffer_length;
645  urb->actual_length = len;
646  // always USB_DIR_IN, toward host
647  memcpy (ubuf, bufp, len);
648 
649  /* report whether RH hardware supports remote wakeup */
650  if (patch_wakeup &&
651  len > offsetof (struct usb_config_descriptor,
652  bmAttributes))
653  ((struct usb_config_descriptor *)ubuf)->bmAttributes
654  |= USB_CONFIG_ATT_WAKEUP;
655 
656  /* report whether RH hardware has an integrated TT */
657  if (patch_protocol &&
658  len > offsetof(struct usb_device_descriptor,
659  bDeviceProtocol))
660  ((struct usb_device_descriptor *) ubuf)->
661  bDeviceProtocol = USB_HUB_PR_HS_SINGLE_TT;
662  }
663 
664  /* any errors get returned through the urb completion */
665  spin_lock_irq(&hcd_root_hub_lock);
666  usb_hcd_unlink_urb_from_ep(hcd, urb);
667 
668  /* This peculiar use of spinlocks echoes what real HC drivers do.
669  * Avoiding calls to local_irq_disable/enable makes the code
670  * RT-friendly.
671  */
672  spin_unlock(&hcd_root_hub_lock);
673  usb_hcd_giveback_urb(hcd, urb, status);
674  spin_lock(&hcd_root_hub_lock);
675 
676  spin_unlock_irq(&hcd_root_hub_lock);
677  return 0;
678 }
679 
680 /*-------------------------------------------------------------------------*/
681 
682 /*
683  * Root Hub interrupt transfers are polled using a timer if the
684  * driver requests it; otherwise the driver is responsible for
685  * calling usb_hcd_poll_rh_status() when an event occurs.
686  *
687  * Completions are called in_interrupt(), but they may or may not
688  * be in_irq().
689  */
690 void usb_hcd_poll_rh_status(struct usb_hcd *hcd)
691 {
692  struct urb *urb;
693  int length;
694  unsigned long flags;
695  char buffer[6]; /* Any root hubs with > 31 ports? */
696 
697  if (unlikely(!hcd->rh_pollable))
698  return;
699  if (!hcd->uses_new_polling && !hcd->status_urb)
700  return;
701 
702  length = hcd->driver->hub_status_data(hcd, buffer);
703  if (length > 0) {
704 
705  /* try to complete the status urb */
706  spin_lock_irqsave(&hcd_root_hub_lock, flags);
707  urb = hcd->status_urb;
708  if (urb) {
709  clear_bit(HCD_FLAG_POLL_PENDING, &hcd->flags);
710  hcd->status_urb = NULL;
711  urb->actual_length = length;
712  memcpy(urb->transfer_buffer, buffer, length);
713 
714  usb_hcd_unlink_urb_from_ep(hcd, urb);
715  spin_unlock(&hcd_root_hub_lock);
716  usb_hcd_giveback_urb(hcd, urb, 0);
717  spin_lock(&hcd_root_hub_lock);
718  } else {
719  length = 0;
720  set_bit(HCD_FLAG_POLL_PENDING, &hcd->flags);
721  }
722  spin_unlock_irqrestore(&hcd_root_hub_lock, flags);
723  }
724 
725  /* The USB 2.0 spec says 256 ms. This is close enough and won't
726  * exceed that limit if HZ is 100. The math is more clunky than
727  * maybe expected, this is to make sure that all timers for USB devices
728  * fire at the same time to give the CPU a break in between */
729  if (hcd->uses_new_polling ? HCD_POLL_RH(hcd) :
730  (length == 0 && hcd->status_urb != NULL))
731  mod_timer (&hcd->rh_timer, (jiffies/(HZ/4) + 1) * (HZ/4));
732 }
733 EXPORT_SYMBOL_GPL(usb_hcd_poll_rh_status);
734 
735 /* timer callback */
736 static void rh_timer_func (unsigned long _hcd)
737 {
738  usb_hcd_poll_rh_status((struct usb_hcd *) _hcd);
739 }
740 
741 /*-------------------------------------------------------------------------*/
742 
743 static int rh_queue_status (struct usb_hcd *hcd, struct urb *urb)
744 {
745  int retval;
746  unsigned long flags;
747  unsigned len = 1 + (urb->dev->maxchild / 8);
748 
749  spin_lock_irqsave (&hcd_root_hub_lock, flags);
750  if (hcd->status_urb || urb->transfer_buffer_length < len) {
751  dev_dbg (hcd->self.controller, "not queuing rh status urb\n");
752  retval = -EINVAL;
753  goto done;
754  }
755 
756  retval = usb_hcd_link_urb_to_ep(hcd, urb);
757  if (retval)
758  goto done;
759 
760  hcd->status_urb = urb;
761  urb->hcpriv = hcd; /* indicate it's queued */
762  if (!hcd->uses_new_polling)
763  mod_timer(&hcd->rh_timer, (jiffies/(HZ/4) + 1) * (HZ/4));
764 
765  /* If a status change has already occurred, report it ASAP */
766  else if (HCD_POLL_PENDING(hcd))
767  mod_timer(&hcd->rh_timer, jiffies);
768  retval = 0;
769  done:
770  spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
771  return retval;
772 }
773 
774 static int rh_urb_enqueue (struct usb_hcd *hcd, struct urb *urb)
775 {
776  if (usb_endpoint_xfer_int(&urb->ep->desc))
777  return rh_queue_status (hcd, urb);
778  if (usb_endpoint_xfer_control(&urb->ep->desc))
779  return rh_call_control (hcd, urb);
780  return -EINVAL;
781 }
782 
783 /*-------------------------------------------------------------------------*/
784 
785 /* Unlinks of root-hub control URBs are legal, but they don't do anything
786  * since these URBs always execute synchronously.
787  */
788 static int usb_rh_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
789 {
790  unsigned long flags;
791  int rc;
792 
793  spin_lock_irqsave(&hcd_root_hub_lock, flags);
794  rc = usb_hcd_check_unlink_urb(hcd, urb, status);
795  if (rc)
796  goto done;
797 
798  if (usb_endpoint_num(&urb->ep->desc) == 0) { /* Control URB */
799  ; /* Do nothing */
800 
801  } else { /* Status URB */
802  if (!hcd->uses_new_polling)
803  del_timer (&hcd->rh_timer);
804  if (urb == hcd->status_urb) {
805  hcd->status_urb = NULL;
806  usb_hcd_unlink_urb_from_ep(hcd, urb);
807 
808  spin_unlock(&hcd_root_hub_lock);
809  usb_hcd_giveback_urb(hcd, urb, status);
810  spin_lock(&hcd_root_hub_lock);
811  }
812  }
813  done:
814  spin_unlock_irqrestore(&hcd_root_hub_lock, flags);
815  return rc;
816 }
817 
818 
819 
820 /*
821  * Show & store the current value of authorized_default
822  */
823 static ssize_t usb_host_authorized_default_show(struct device *dev,
824  struct device_attribute *attr,
825  char *buf)
826 {
827  struct usb_device *rh_usb_dev = to_usb_device(dev);
828  struct usb_bus *usb_bus = rh_usb_dev->bus;
829  struct usb_hcd *usb_hcd;
830 
831  if (usb_bus == NULL) /* FIXME: not sure if this case is possible */
832  return -ENODEV;
833  usb_hcd = bus_to_hcd(usb_bus);
834  return snprintf(buf, PAGE_SIZE, "%u\n", usb_hcd->authorized_default);
835 }
836 
837 static ssize_t usb_host_authorized_default_store(struct device *dev,
838  struct device_attribute *attr,
839  const char *buf, size_t size)
840 {
841  ssize_t result;
842  unsigned val;
843  struct usb_device *rh_usb_dev = to_usb_device(dev);
844  struct usb_bus *usb_bus = rh_usb_dev->bus;
845  struct usb_hcd *usb_hcd;
846 
847  if (usb_bus == NULL) /* FIXME: not sure if this case is possible */
848  return -ENODEV;
849  usb_hcd = bus_to_hcd(usb_bus);
850  result = sscanf(buf, "%u\n", &val);
851  if (result == 1) {
852  usb_hcd->authorized_default = val? 1 : 0;
853  result = size;
854  }
855  else
856  result = -EINVAL;
857  return result;
858 }
859 
860 static DEVICE_ATTR(authorized_default, 0644,
861  usb_host_authorized_default_show,
862  usb_host_authorized_default_store);
863 
864 
865 /* Group all the USB bus attributes */
866 static struct attribute *usb_bus_attrs[] = {
867  &dev_attr_authorized_default.attr,
868  NULL,
869 };
870 
871 static struct attribute_group usb_bus_attr_group = {
872  .name = NULL, /* we want them in the same directory */
873  .attrs = usb_bus_attrs,
874 };
875 
876 
877 
878 /*-------------------------------------------------------------------------*/
879 
887 static void usb_bus_init (struct usb_bus *bus)
888 {
889  memset (&bus->devmap, 0, sizeof(struct usb_devmap));
890 
891  bus->devnum_next = 1;
892 
893  bus->root_hub = NULL;
894  bus->busnum = -1;
895  bus->bandwidth_allocated = 0;
896  bus->bandwidth_int_reqs = 0;
897  bus->bandwidth_isoc_reqs = 0;
898 
899  INIT_LIST_HEAD (&bus->bus_list);
900 }
901 
902 /*-------------------------------------------------------------------------*/
903 
912 static int usb_register_bus(struct usb_bus *bus)
913 {
914  int result = -E2BIG;
915  int busnum;
916 
917  mutex_lock(&usb_bus_list_lock);
918  busnum = find_next_zero_bit (busmap.busmap, USB_MAXBUS, 1);
919  if (busnum >= USB_MAXBUS) {
920  printk (KERN_ERR "%s: too many buses\n", usbcore_name);
921  goto error_find_busnum;
922  }
923  set_bit (busnum, busmap.busmap);
924  bus->busnum = busnum;
925 
926  /* Add it to the local list of buses */
927  list_add (&bus->bus_list, &usb_bus_list);
928  mutex_unlock(&usb_bus_list_lock);
929 
930  usb_notify_add_bus(bus);
931 
932  dev_info (bus->controller, "new USB bus registered, assigned bus "
933  "number %d\n", bus->busnum);
934  return 0;
935 
936 error_find_busnum:
937  mutex_unlock(&usb_bus_list_lock);
938  return result;
939 }
940 
949 static void usb_deregister_bus (struct usb_bus *bus)
950 {
951  dev_info (bus->controller, "USB bus %d deregistered\n", bus->busnum);
952 
953  /*
954  * NOTE: make sure that all the devices are removed by the
955  * controller code, as well as having it call this when cleaning
956  * itself up
957  */
958  mutex_lock(&usb_bus_list_lock);
959  list_del (&bus->bus_list);
960  mutex_unlock(&usb_bus_list_lock);
961 
962  usb_notify_remove_bus(bus);
963 
964  clear_bit (bus->busnum, busmap.busmap);
965 }
966 
976 static int register_root_hub(struct usb_hcd *hcd)
977 {
978  struct device *parent_dev = hcd->self.controller;
979  struct usb_device *usb_dev = hcd->self.root_hub;
980  const int devnum = 1;
981  int retval;
982 
983  usb_dev->devnum = devnum;
984  usb_dev->bus->devnum_next = devnum + 1;
985  memset (&usb_dev->bus->devmap.devicemap, 0,
986  sizeof usb_dev->bus->devmap.devicemap);
987  set_bit (devnum, usb_dev->bus->devmap.devicemap);
988  usb_set_device_state(usb_dev, USB_STATE_ADDRESS);
989 
990  mutex_lock(&usb_bus_list_lock);
991 
992  usb_dev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
993  retval = usb_get_device_descriptor(usb_dev, USB_DT_DEVICE_SIZE);
994  if (retval != sizeof usb_dev->descriptor) {
995  mutex_unlock(&usb_bus_list_lock);
996  dev_dbg (parent_dev, "can't read %s device descriptor %d\n",
997  dev_name(&usb_dev->dev), retval);
998  return (retval < 0) ? retval : -EMSGSIZE;
999  }
1000  if (usb_dev->speed == USB_SPEED_SUPER) {
1001  retval = usb_get_bos_descriptor(usb_dev);
1002  if (retval < 0) {
1003  mutex_unlock(&usb_bus_list_lock);
1004  dev_dbg(parent_dev, "can't read %s bos descriptor %d\n",
1005  dev_name(&usb_dev->dev), retval);
1006  return retval;
1007  }
1008  }
1009 
1010  retval = usb_new_device (usb_dev);
1011  if (retval) {
1012  dev_err (parent_dev, "can't register root hub for %s, %d\n",
1013  dev_name(&usb_dev->dev), retval);
1014  } else {
1015  spin_lock_irq (&hcd_root_hub_lock);
1016  hcd->rh_registered = 1;
1017  spin_unlock_irq (&hcd_root_hub_lock);
1018 
1019  /* Did the HC die before the root hub was registered? */
1020  if (HCD_DEAD(hcd))
1021  usb_hc_died (hcd); /* This time clean up */
1022  }
1023  mutex_unlock(&usb_bus_list_lock);
1024 
1025  return retval;
1026 }
1027 
1028 
1029 /*-------------------------------------------------------------------------*/
1030 
1042 long usb_calc_bus_time (int speed, int is_input, int isoc, int bytecount)
1043 {
1044  unsigned long tmp;
1045 
1046  switch (speed) {
1047  case USB_SPEED_LOW: /* INTR only */
1048  if (is_input) {
1049  tmp = (67667L * (31L + 10L * BitTime (bytecount))) / 1000L;
1050  return (64060L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp);
1051  } else {
1052  tmp = (66700L * (31L + 10L * BitTime (bytecount))) / 1000L;
1053  return (64107L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp);
1054  }
1055  case USB_SPEED_FULL: /* ISOC or INTR */
1056  if (isoc) {
1057  tmp = (8354L * (31L + 10L * BitTime (bytecount))) / 1000L;
1058  return (((is_input) ? 7268L : 6265L) + BW_HOST_DELAY + tmp);
1059  } else {
1060  tmp = (8354L * (31L + 10L * BitTime (bytecount))) / 1000L;
1061  return (9107L + BW_HOST_DELAY + tmp);
1062  }
1063  case USB_SPEED_HIGH: /* ISOC or INTR */
1064  // FIXME adjust for input vs output
1065  if (isoc)
1066  tmp = HS_NSECS_ISO (bytecount);
1067  else
1068  tmp = HS_NSECS (bytecount);
1069  return tmp;
1070  default:
1071  pr_debug ("%s: bogus device speed!\n", usbcore_name);
1072  return -1;
1073  }
1074 }
1075 EXPORT_SYMBOL_GPL(usb_calc_bus_time);
1076 
1077 
1078 /*-------------------------------------------------------------------------*/
1079 
1080 /*
1081  * Generic HC operations.
1082  */
1083 
1084 /*-------------------------------------------------------------------------*/
1085 
1101 int usb_hcd_link_urb_to_ep(struct usb_hcd *hcd, struct urb *urb)
1102 {
1103  int rc = 0;
1104 
1105  spin_lock(&hcd_urb_list_lock);
1106 
1107  /* Check that the URB isn't being killed */
1108  if (unlikely(atomic_read(&urb->reject))) {
1109  rc = -EPERM;
1110  goto done;
1111  }
1112 
1113  if (unlikely(!urb->ep->enabled)) {
1114  rc = -ENOENT;
1115  goto done;
1116  }
1117 
1118  if (unlikely(!urb->dev->can_submit)) {
1119  rc = -EHOSTUNREACH;
1120  goto done;
1121  }
1122 
1123  /*
1124  * Check the host controller's state and add the URB to the
1125  * endpoint's queue.
1126  */
1127  if (HCD_RH_RUNNING(hcd)) {
1128  urb->unlinked = 0;
1129  list_add_tail(&urb->urb_list, &urb->ep->urb_list);
1130  } else {
1131  rc = -ESHUTDOWN;
1132  goto done;
1133  }
1134  done:
1135  spin_unlock(&hcd_urb_list_lock);
1136  return rc;
1137 }
1138 EXPORT_SYMBOL_GPL(usb_hcd_link_urb_to_ep);
1139 
1159 int usb_hcd_check_unlink_urb(struct usb_hcd *hcd, struct urb *urb,
1160  int status)
1161 {
1162  struct list_head *tmp;
1163 
1164  /* insist the urb is still queued */
1165  list_for_each(tmp, &urb->ep->urb_list) {
1166  if (tmp == &urb->urb_list)
1167  break;
1168  }
1169  if (tmp != &urb->urb_list)
1170  return -EIDRM;
1171 
1172  /* Any status except -EINPROGRESS means something already started to
1173  * unlink this URB from the hardware. So there's no more work to do.
1174  */
1175  if (urb->unlinked)
1176  return -EBUSY;
1177  urb->unlinked = status;
1178  return 0;
1179 }
1180 EXPORT_SYMBOL_GPL(usb_hcd_check_unlink_urb);
1181 
1192 void usb_hcd_unlink_urb_from_ep(struct usb_hcd *hcd, struct urb *urb)
1193 {
1194  /* clear all state linking urb to this dev (and hcd) */
1195  spin_lock(&hcd_urb_list_lock);
1196  list_del_init(&urb->urb_list);
1197  spin_unlock(&hcd_urb_list_lock);
1198 }
1199 EXPORT_SYMBOL_GPL(usb_hcd_unlink_urb_from_ep);
1200 
1201 /*
1202  * Some usb host controllers can only perform dma using a small SRAM area.
1203  * The usb core itself is however optimized for host controllers that can dma
1204  * using regular system memory - like pci devices doing bus mastering.
1205  *
1206  * To support host controllers with limited dma capabilites we provide dma
1207  * bounce buffers. This feature can be enabled using the HCD_LOCAL_MEM flag.
1208  * For this to work properly the host controller code must first use the
1209  * function dma_declare_coherent_memory() to point out which memory area
1210  * that should be used for dma allocations.
1211  *
1212  * The HCD_LOCAL_MEM flag then tells the usb code to allocate all data for
1213  * dma using dma_alloc_coherent() which in turn allocates from the memory
1214  * area pointed out with dma_declare_coherent_memory().
1215  *
1216  * So, to summarize...
1217  *
1218  * - We need "local" memory, canonical example being
1219  * a small SRAM on a discrete controller being the
1220  * only memory that the controller can read ...
1221  * (a) "normal" kernel memory is no good, and
1222  * (b) there's not enough to share
1223  *
1224  * - The only *portable* hook for such stuff in the
1225  * DMA framework is dma_declare_coherent_memory()
1226  *
1227  * - So we use that, even though the primary requirement
1228  * is that the memory be "local" (hence addressible
1229  * by that device), not "coherent".
1230  *
1231  */
1232 
1233 static int hcd_alloc_coherent(struct usb_bus *bus,
1234  gfp_t mem_flags, dma_addr_t *dma_handle,
1235  void **vaddr_handle, size_t size,
1236  enum dma_data_direction dir)
1237 {
1238  unsigned char *vaddr;
1239 
1240  if (*vaddr_handle == NULL) {
1241  WARN_ON_ONCE(1);
1242  return -EFAULT;
1243  }
1244 
1245  vaddr = hcd_buffer_alloc(bus, size + sizeof(vaddr),
1246  mem_flags, dma_handle);
1247  if (!vaddr)
1248  return -ENOMEM;
1249 
1250  /*
1251  * Store the virtual address of the buffer at the end
1252  * of the allocated dma buffer. The size of the buffer
1253  * may be uneven so use unaligned functions instead
1254  * of just rounding up. It makes sense to optimize for
1255  * memory footprint over access speed since the amount
1256  * of memory available for dma may be limited.
1257  */
1258  put_unaligned((unsigned long)*vaddr_handle,
1259  (unsigned long *)(vaddr + size));
1260 
1261  if (dir == DMA_TO_DEVICE)
1262  memcpy(vaddr, *vaddr_handle, size);
1263 
1264  *vaddr_handle = vaddr;
1265  return 0;
1266 }
1267 
1268 static void hcd_free_coherent(struct usb_bus *bus, dma_addr_t *dma_handle,
1269  void **vaddr_handle, size_t size,
1270  enum dma_data_direction dir)
1271 {
1272  unsigned char *vaddr = *vaddr_handle;
1273 
1274  vaddr = (void *)get_unaligned((unsigned long *)(vaddr + size));
1275 
1276  if (dir == DMA_FROM_DEVICE)
1277  memcpy(vaddr, *vaddr_handle, size);
1278 
1279  hcd_buffer_free(bus, size + sizeof(vaddr), *vaddr_handle, *dma_handle);
1280 
1281  *vaddr_handle = vaddr;
1282  *dma_handle = 0;
1283 }
1284 
1285 void usb_hcd_unmap_urb_setup_for_dma(struct usb_hcd *hcd, struct urb *urb)
1286 {
1287  if (urb->transfer_flags & URB_SETUP_MAP_SINGLE)
1288  dma_unmap_single(hcd->self.controller,
1289  urb->setup_dma,
1290  sizeof(struct usb_ctrlrequest),
1291  DMA_TO_DEVICE);
1292  else if (urb->transfer_flags & URB_SETUP_MAP_LOCAL)
1293  hcd_free_coherent(urb->dev->bus,
1294  &urb->setup_dma,
1295  (void **) &urb->setup_packet,
1296  sizeof(struct usb_ctrlrequest),
1297  DMA_TO_DEVICE);
1298 
1299  /* Make it safe to call this routine more than once */
1300  urb->transfer_flags &= ~(URB_SETUP_MAP_SINGLE | URB_SETUP_MAP_LOCAL);
1301 }
1302 EXPORT_SYMBOL_GPL(usb_hcd_unmap_urb_setup_for_dma);
1303 
1304 static void unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
1305 {
1306  if (hcd->driver->unmap_urb_for_dma)
1307  hcd->driver->unmap_urb_for_dma(hcd, urb);
1308  else
1309  usb_hcd_unmap_urb_for_dma(hcd, urb);
1310 }
1311 
1312 void usb_hcd_unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
1313 {
1314  enum dma_data_direction dir;
1315 
1316  usb_hcd_unmap_urb_setup_for_dma(hcd, urb);
1317 
1318  dir = usb_urb_dir_in(urb) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
1319  if (urb->transfer_flags & URB_DMA_MAP_SG)
1320  dma_unmap_sg(hcd->self.controller,
1321  urb->sg,
1322  urb->num_sgs,
1323  dir);
1324  else if (urb->transfer_flags & URB_DMA_MAP_PAGE)
1325  dma_unmap_page(hcd->self.controller,
1326  urb->transfer_dma,
1327  urb->transfer_buffer_length,
1328  dir);
1329  else if (urb->transfer_flags & URB_DMA_MAP_SINGLE)
1330  dma_unmap_single(hcd->self.controller,
1331  urb->transfer_dma,
1332  urb->transfer_buffer_length,
1333  dir);
1334  else if (urb->transfer_flags & URB_MAP_LOCAL)
1335  hcd_free_coherent(urb->dev->bus,
1336  &urb->transfer_dma,
1337  &urb->transfer_buffer,
1338  urb->transfer_buffer_length,
1339  dir);
1340 
1341  /* Make it safe to call this routine more than once */
1342  urb->transfer_flags &= ~(URB_DMA_MAP_SG | URB_DMA_MAP_PAGE |
1343  URB_DMA_MAP_SINGLE | URB_MAP_LOCAL);
1344 }
1345 EXPORT_SYMBOL_GPL(usb_hcd_unmap_urb_for_dma);
1346 
1347 static int map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb,
1348  gfp_t mem_flags)
1349 {
1350  if (hcd->driver->map_urb_for_dma)
1351  return hcd->driver->map_urb_for_dma(hcd, urb, mem_flags);
1352  else
1353  return usb_hcd_map_urb_for_dma(hcd, urb, mem_flags);
1354 }
1355 
1356 int usb_hcd_map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb,
1357  gfp_t mem_flags)
1358 {
1359  enum dma_data_direction dir;
1360  int ret = 0;
1361 
1362  /* Map the URB's buffers for DMA access.
1363  * Lower level HCD code should use *_dma exclusively,
1364  * unless it uses pio or talks to another transport,
1365  * or uses the provided scatter gather list for bulk.
1366  */
1367 
1368  if (usb_endpoint_xfer_control(&urb->ep->desc)) {
1369  if (hcd->self.uses_pio_for_control)
1370  return ret;
1371  if (hcd->self.uses_dma) {
1372  urb->setup_dma = dma_map_single(
1373  hcd->self.controller,
1374  urb->setup_packet,
1375  sizeof(struct usb_ctrlrequest),
1376  DMA_TO_DEVICE);
1377  if (dma_mapping_error(hcd->self.controller,
1378  urb->setup_dma))
1379  return -EAGAIN;
1380  urb->transfer_flags |= URB_SETUP_MAP_SINGLE;
1381  } else if (hcd->driver->flags & HCD_LOCAL_MEM) {
1382  ret = hcd_alloc_coherent(
1383  urb->dev->bus, mem_flags,
1384  &urb->setup_dma,
1385  (void **)&urb->setup_packet,
1386  sizeof(struct usb_ctrlrequest),
1387  DMA_TO_DEVICE);
1388  if (ret)
1389  return ret;
1390  urb->transfer_flags |= URB_SETUP_MAP_LOCAL;
1391  }
1392  }
1393 
1394  dir = usb_urb_dir_in(urb) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
1395  if (urb->transfer_buffer_length != 0
1396  && !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)) {
1397  if (hcd->self.uses_dma) {
1398  if (urb->num_sgs) {
1399  int n;
1400 
1401  /* We don't support sg for isoc transfers ! */
1402  if (usb_endpoint_xfer_isoc(&urb->ep->desc)) {
1403  WARN_ON(1);
1404  return -EINVAL;
1405  }
1406 
1407  n = dma_map_sg(
1408  hcd->self.controller,
1409  urb->sg,
1410  urb->num_sgs,
1411  dir);
1412  if (n <= 0)
1413  ret = -EAGAIN;
1414  else
1415  urb->transfer_flags |= URB_DMA_MAP_SG;
1416  urb->num_mapped_sgs = n;
1417  if (n != urb->num_sgs)
1418  urb->transfer_flags |=
1419  URB_DMA_SG_COMBINED;
1420  } else if (urb->sg) {
1421  struct scatterlist *sg = urb->sg;
1422  urb->transfer_dma = dma_map_page(
1423  hcd->self.controller,
1424  sg_page(sg),
1425  sg->offset,
1426  urb->transfer_buffer_length,
1427  dir);
1428  if (dma_mapping_error(hcd->self.controller,
1429  urb->transfer_dma))
1430  ret = -EAGAIN;
1431  else
1432  urb->transfer_flags |= URB_DMA_MAP_PAGE;
1433  } else {
1434  urb->transfer_dma = dma_map_single(
1435  hcd->self.controller,
1436  urb->transfer_buffer,
1437  urb->transfer_buffer_length,
1438  dir);
1439  if (dma_mapping_error(hcd->self.controller,
1440  urb->transfer_dma))
1441  ret = -EAGAIN;
1442  else
1443  urb->transfer_flags |= URB_DMA_MAP_SINGLE;
1444  }
1445  } else if (hcd->driver->flags & HCD_LOCAL_MEM) {
1446  ret = hcd_alloc_coherent(
1447  urb->dev->bus, mem_flags,
1448  &urb->transfer_dma,
1449  &urb->transfer_buffer,
1450  urb->transfer_buffer_length,
1451  dir);
1452  if (ret == 0)
1453  urb->transfer_flags |= URB_MAP_LOCAL;
1454  }
1455  if (ret && (urb->transfer_flags & (URB_SETUP_MAP_SINGLE |
1456  URB_SETUP_MAP_LOCAL)))
1457  usb_hcd_unmap_urb_for_dma(hcd, urb);
1458  }
1459  return ret;
1460 }
1461 EXPORT_SYMBOL_GPL(usb_hcd_map_urb_for_dma);
1462 
1463 /*-------------------------------------------------------------------------*/
1464 
1465 /* may be called in any context with a valid urb->dev usecount
1466  * caller surrenders "ownership" of urb
1467  * expects usb_submit_urb() to have sanity checked and conditioned all
1468  * inputs in the urb
1469  */
1470 int usb_hcd_submit_urb (struct urb *urb, gfp_t mem_flags)
1471 {
1472  int status;
1473  struct usb_hcd *hcd = bus_to_hcd(urb->dev->bus);
1474 
1475  /* increment urb's reference count as part of giving it to the HCD
1476  * (which will control it). HCD guarantees that it either returns
1477  * an error or calls giveback(), but not both.
1478  */
1479  usb_get_urb(urb);
1480  atomic_inc(&urb->use_count);
1481  atomic_inc(&urb->dev->urbnum);
1482  usbmon_urb_submit(&hcd->self, urb);
1483 
1484  /* NOTE requirements on root-hub callers (usbfs and the hub
1485  * driver, for now): URBs' urb->transfer_buffer must be
1486  * valid and usb_buffer_{sync,unmap}() not be needed, since
1487  * they could clobber root hub response data. Also, control
1488  * URBs must be submitted in process context with interrupts
1489  * enabled.
1490  */
1491 
1492  if (is_root_hub(urb->dev)) {
1493  status = rh_urb_enqueue(hcd, urb);
1494  } else {
1495  status = map_urb_for_dma(hcd, urb, mem_flags);
1496  if (likely(status == 0)) {
1497  status = hcd->driver->urb_enqueue(hcd, urb, mem_flags);
1498  if (unlikely(status))
1499  unmap_urb_for_dma(hcd, urb);
1500  }
1501  }
1502 
1503  if (unlikely(status)) {
1504  usbmon_urb_submit_error(&hcd->self, urb, status);
1505  urb->hcpriv = NULL;
1506  INIT_LIST_HEAD(&urb->urb_list);
1507  atomic_dec(&urb->use_count);
1508  atomic_dec(&urb->dev->urbnum);
1509  if (atomic_read(&urb->reject))
1510  wake_up(&usb_kill_urb_queue);
1511  usb_put_urb(urb);
1512  }
1513  return status;
1514 }
1515 
1516 /*-------------------------------------------------------------------------*/
1517 
1518 /* this makes the hcd giveback() the urb more quickly, by kicking it
1519  * off hardware queues (which may take a while) and returning it as
1520  * soon as practical. we've already set up the urb's return status,
1521  * but we can't know if the callback completed already.
1522  */
1523 static int unlink1(struct usb_hcd *hcd, struct urb *urb, int status)
1524 {
1525  int value;
1526 
1527  if (is_root_hub(urb->dev))
1528  value = usb_rh_urb_dequeue(hcd, urb, status);
1529  else {
1530 
1531  /* The only reason an HCD might fail this call is if
1532  * it has not yet fully queued the urb to begin with.
1533  * Such failures should be harmless. */
1534  value = hcd->driver->urb_dequeue(hcd, urb, status);
1535  }
1536  return value;
1537 }
1538 
1539 /*
1540  * called in any context
1541  *
1542  * caller guarantees urb won't be recycled till both unlink()
1543  * and the urb's completion function return
1544  */
1545 int usb_hcd_unlink_urb (struct urb *urb, int status)
1546 {
1547  struct usb_hcd *hcd;
1548  int retval = -EIDRM;
1549  unsigned long flags;
1550 
1551  /* Prevent the device and bus from going away while
1552  * the unlink is carried out. If they are already gone
1553  * then urb->use_count must be 0, since disconnected
1554  * devices can't have any active URBs.
1555  */
1556  spin_lock_irqsave(&hcd_urb_unlink_lock, flags);
1557  if (atomic_read(&urb->use_count) > 0) {
1558  retval = 0;
1559  usb_get_dev(urb->dev);
1560  }
1561  spin_unlock_irqrestore(&hcd_urb_unlink_lock, flags);
1562  if (retval == 0) {
1563  hcd = bus_to_hcd(urb->dev->bus);
1564  retval = unlink1(hcd, urb, status);
1565  usb_put_dev(urb->dev);
1566  }
1567 
1568  if (retval == 0)
1569  retval = -EINPROGRESS;
1570  else if (retval != -EIDRM && retval != -EBUSY)
1571  dev_dbg(&urb->dev->dev, "hcd_unlink_urb %p fail %d\n",
1572  urb, retval);
1573  return retval;
1574 }
1575 
1576 /*-------------------------------------------------------------------------*/
1577 
1595 void usb_hcd_giveback_urb(struct usb_hcd *hcd, struct urb *urb, int status)
1596 {
1597  urb->hcpriv = NULL;
1598  if (unlikely(urb->unlinked))
1599  status = urb->unlinked;
1600  else if (unlikely((urb->transfer_flags & URB_SHORT_NOT_OK) &&
1601  urb->actual_length < urb->transfer_buffer_length &&
1602  !status))
1603  status = -EREMOTEIO;
1604 
1605  unmap_urb_for_dma(hcd, urb);
1606  usbmon_urb_complete(&hcd->self, urb, status);
1607  usb_unanchor_urb(urb);
1608 
1609  /* pass ownership to the completion handler */
1610  urb->status = status;
1611  urb->complete (urb);
1612  atomic_dec (&urb->use_count);
1613  if (unlikely(atomic_read(&urb->reject)))
1614  wake_up (&usb_kill_urb_queue);
1615  usb_put_urb (urb);
1616 }
1617 EXPORT_SYMBOL_GPL(usb_hcd_giveback_urb);
1618 
1619 /*-------------------------------------------------------------------------*/
1620 
1621 /* Cancel all URBs pending on this endpoint and wait for the endpoint's
1622  * queue to drain completely. The caller must first insure that no more
1623  * URBs can be submitted for this endpoint.
1624  */
1625 void usb_hcd_flush_endpoint(struct usb_device *udev,
1626  struct usb_host_endpoint *ep)
1627 {
1628  struct usb_hcd *hcd;
1629  struct urb *urb;
1630 
1631  if (!ep)
1632  return;
1633  might_sleep();
1634  hcd = bus_to_hcd(udev->bus);
1635 
1636  /* No more submits can occur */
1637  spin_lock_irq(&hcd_urb_list_lock);
1638 rescan:
1639  list_for_each_entry (urb, &ep->urb_list, urb_list) {
1640  int is_in;
1641 
1642  if (urb->unlinked)
1643  continue;
1644  usb_get_urb (urb);
1645  is_in = usb_urb_dir_in(urb);
1646  spin_unlock(&hcd_urb_list_lock);
1647 
1648  /* kick hcd */
1649  unlink1(hcd, urb, -ESHUTDOWN);
1650  dev_dbg (hcd->self.controller,
1651  "shutdown urb %p ep%d%s%s\n",
1652  urb, usb_endpoint_num(&ep->desc),
1653  is_in ? "in" : "out",
1654  ({ char *s;
1655 
1656  switch (usb_endpoint_type(&ep->desc)) {
1657  case USB_ENDPOINT_XFER_CONTROL:
1658  s = ""; break;
1659  case USB_ENDPOINT_XFER_BULK:
1660  s = "-bulk"; break;
1661  case USB_ENDPOINT_XFER_INT:
1662  s = "-intr"; break;
1663  default:
1664  s = "-iso"; break;
1665  };
1666  s;
1667  }));
1668  usb_put_urb (urb);
1669 
1670  /* list contents may have changed */
1671  spin_lock(&hcd_urb_list_lock);
1672  goto rescan;
1673  }
1674  spin_unlock_irq(&hcd_urb_list_lock);
1675 
1676  /* Wait until the endpoint queue is completely empty */
1677  while (!list_empty (&ep->urb_list)) {
1678  spin_lock_irq(&hcd_urb_list_lock);
1679 
1680  /* The list may have changed while we acquired the spinlock */
1681  urb = NULL;
1682  if (!list_empty (&ep->urb_list)) {
1683  urb = list_entry (ep->urb_list.prev, struct urb,
1684  urb_list);
1685  usb_get_urb (urb);
1686  }
1687  spin_unlock_irq(&hcd_urb_list_lock);
1688 
1689  if (urb) {
1690  usb_kill_urb (urb);
1691  usb_put_urb (urb);
1692  }
1693  }
1694 }
1695 
1717 int usb_hcd_alloc_bandwidth(struct usb_device *udev,
1718  struct usb_host_config *new_config,
1719  struct usb_host_interface *cur_alt,
1720  struct usb_host_interface *new_alt)
1721 {
1722  int num_intfs, i, j;
1723  struct usb_host_interface *alt = NULL;
1724  int ret = 0;
1725  struct usb_hcd *hcd;
1726  struct usb_host_endpoint *ep;
1727 
1728  hcd = bus_to_hcd(udev->bus);
1729  if (!hcd->driver->check_bandwidth)
1730  return 0;
1731 
1732  /* Configuration is being removed - set configuration 0 */
1733  if (!new_config && !cur_alt) {
1734  for (i = 1; i < 16; ++i) {
1735  ep = udev->ep_out[i];
1736  if (ep)
1737  hcd->driver->drop_endpoint(hcd, udev, ep);
1738  ep = udev->ep_in[i];
1739  if (ep)
1740  hcd->driver->drop_endpoint(hcd, udev, ep);
1741  }
1742  hcd->driver->check_bandwidth(hcd, udev);
1743  return 0;
1744  }
1745  /* Check if the HCD says there's enough bandwidth. Enable all endpoints
1746  * each interface's alt setting 0 and ask the HCD to check the bandwidth
1747  * of the bus. There will always be bandwidth for endpoint 0, so it's
1748  * ok to exclude it.
1749  */
1750  if (new_config) {
1751  num_intfs = new_config->desc.bNumInterfaces;
1752  /* Remove endpoints (except endpoint 0, which is always on the
1753  * schedule) from the old config from the schedule
1754  */
1755  for (i = 1; i < 16; ++i) {
1756  ep = udev->ep_out[i];
1757  if (ep) {
1758  ret = hcd->driver->drop_endpoint(hcd, udev, ep);
1759  if (ret < 0)
1760  goto reset;
1761  }
1762  ep = udev->ep_in[i];
1763  if (ep) {
1764  ret = hcd->driver->drop_endpoint(hcd, udev, ep);
1765  if (ret < 0)
1766  goto reset;
1767  }
1768  }
1769  for (i = 0; i < num_intfs; ++i) {
1770  struct usb_host_interface *first_alt;
1771  int iface_num;
1772 
1773  first_alt = &new_config->intf_cache[i]->altsetting[0];
1774  iface_num = first_alt->desc.bInterfaceNumber;
1775  /* Set up endpoints for alternate interface setting 0 */
1776  alt = usb_find_alt_setting(new_config, iface_num, 0);
1777  if (!alt)
1778  /* No alt setting 0? Pick the first setting. */
1779  alt = first_alt;
1780 
1781  for (j = 0; j < alt->desc.bNumEndpoints; j++) {
1782  ret = hcd->driver->add_endpoint(hcd, udev, &alt->endpoint[j]);
1783  if (ret < 0)
1784  goto reset;
1785  }
1786  }
1787  }
1788  if (cur_alt && new_alt) {
1789  struct usb_interface *iface = usb_ifnum_to_if(udev,
1790  cur_alt->desc.bInterfaceNumber);
1791 
1792  if (!iface)
1793  return -EINVAL;
1794  if (iface->resetting_device) {
1795  /*
1796  * The USB core just reset the device, so the xHCI host
1797  * and the device will think alt setting 0 is installed.
1798  * However, the USB core will pass in the alternate
1799  * setting installed before the reset as cur_alt. Dig
1800  * out the alternate setting 0 structure, or the first
1801  * alternate setting if a broken device doesn't have alt
1802  * setting 0.
1803  */
1804  cur_alt = usb_altnum_to_altsetting(iface, 0);
1805  if (!cur_alt)
1806  cur_alt = &iface->altsetting[0];
1807  }
1808 
1809  /* Drop all the endpoints in the current alt setting */
1810  for (i = 0; i < cur_alt->desc.bNumEndpoints; i++) {
1811  ret = hcd->driver->drop_endpoint(hcd, udev,
1812  &cur_alt->endpoint[i]);
1813  if (ret < 0)
1814  goto reset;
1815  }
1816  /* Add all the endpoints in the new alt setting */
1817  for (i = 0; i < new_alt->desc.bNumEndpoints; i++) {
1818  ret = hcd->driver->add_endpoint(hcd, udev,
1819  &new_alt->endpoint[i]);
1820  if (ret < 0)
1821  goto reset;
1822  }
1823  }
1824  ret = hcd->driver->check_bandwidth(hcd, udev);
1825 reset:
1826  if (ret < 0)
1827  hcd->driver->reset_bandwidth(hcd, udev);
1828  return ret;
1829 }
1830 
1831 /* Disables the endpoint: synchronizes with the hcd to make sure all
1832  * endpoint state is gone from hardware. usb_hcd_flush_endpoint() must
1833  * have been called previously. Use for set_configuration, set_interface,
1834  * driver removal, physical disconnect.
1835  *
1836  * example: a qh stored in ep->hcpriv, holding state related to endpoint
1837  * type, maxpacket size, toggle, halt status, and scheduling.
1838  */
1839 void usb_hcd_disable_endpoint(struct usb_device *udev,
1840  struct usb_host_endpoint *ep)
1841 {
1842  struct usb_hcd *hcd;
1843 
1844  might_sleep();
1845  hcd = bus_to_hcd(udev->bus);
1846  if (hcd->driver->endpoint_disable)
1847  hcd->driver->endpoint_disable(hcd, ep);
1848 }
1849 
1858 void usb_hcd_reset_endpoint(struct usb_device *udev,
1859  struct usb_host_endpoint *ep)
1860 {
1861  struct usb_hcd *hcd = bus_to_hcd(udev->bus);
1862 
1863  if (hcd->driver->endpoint_reset)
1864  hcd->driver->endpoint_reset(hcd, ep);
1865  else {
1866  int epnum = usb_endpoint_num(&ep->desc);
1867  int is_out = usb_endpoint_dir_out(&ep->desc);
1868  int is_control = usb_endpoint_xfer_control(&ep->desc);
1869 
1870  usb_settoggle(udev, epnum, is_out, 0);
1871  if (is_control)
1872  usb_settoggle(udev, epnum, !is_out, 0);
1873  }
1874 }
1875 
1888 int usb_alloc_streams(struct usb_interface *interface,
1889  struct usb_host_endpoint **eps, unsigned int num_eps,
1890  unsigned int num_streams, gfp_t mem_flags)
1891 {
1892  struct usb_hcd *hcd;
1893  struct usb_device *dev;
1894  int i;
1895 
1896  dev = interface_to_usbdev(interface);
1897  hcd = bus_to_hcd(dev->bus);
1898  if (!hcd->driver->alloc_streams || !hcd->driver->free_streams)
1899  return -EINVAL;
1900  if (dev->speed != USB_SPEED_SUPER)
1901  return -EINVAL;
1902 
1903  /* Streams only apply to bulk endpoints. */
1904  for (i = 0; i < num_eps; i++)
1905  if (!usb_endpoint_xfer_bulk(&eps[i]->desc))
1906  return -EINVAL;
1907 
1908  return hcd->driver->alloc_streams(hcd, dev, eps, num_eps,
1909  num_streams, mem_flags);
1910 }
1911 EXPORT_SYMBOL_GPL(usb_alloc_streams);
1912 
1923 void usb_free_streams(struct usb_interface *interface,
1924  struct usb_host_endpoint **eps, unsigned int num_eps,
1925  gfp_t mem_flags)
1926 {
1927  struct usb_hcd *hcd;
1928  struct usb_device *dev;
1929  int i;
1930 
1931  dev = interface_to_usbdev(interface);
1932  hcd = bus_to_hcd(dev->bus);
1933  if (dev->speed != USB_SPEED_SUPER)
1934  return;
1935 
1936  /* Streams only apply to bulk endpoints. */
1937  for (i = 0; i < num_eps; i++)
1938  if (!eps[i] || !usb_endpoint_xfer_bulk(&eps[i]->desc))
1939  return;
1940 
1941  hcd->driver->free_streams(hcd, dev, eps, num_eps, mem_flags);
1942 }
1943 EXPORT_SYMBOL_GPL(usb_free_streams);
1944 
1945 /* Protect against drivers that try to unlink URBs after the device
1946  * is gone, by waiting until all unlinks for @udev are finished.
1947  * Since we don't currently track URBs by device, simply wait until
1948  * nothing is running in the locked region of usb_hcd_unlink_urb().
1949  */
1950 void usb_hcd_synchronize_unlinks(struct usb_device *udev)
1951 {
1952  spin_lock_irq(&hcd_urb_unlink_lock);
1953  spin_unlock_irq(&hcd_urb_unlink_lock);
1954 }
1955 
1956 /*-------------------------------------------------------------------------*/
1957 
1958 /* called in any context */
1959 int usb_hcd_get_frame_number (struct usb_device *udev)
1960 {
1961  struct usb_hcd *hcd = bus_to_hcd(udev->bus);
1962 
1963  if (!HCD_RH_RUNNING(hcd))
1964  return -ESHUTDOWN;
1965  return hcd->driver->get_frame_number (hcd);
1966 }
1967 
1968 /*-------------------------------------------------------------------------*/
1969 
1970 #ifdef CONFIG_PM
1971 
1972 int hcd_bus_suspend(struct usb_device *rhdev, pm_message_t msg)
1973 {
1974  struct usb_hcd *hcd = container_of(rhdev->bus, struct usb_hcd, self);
1975  int status;
1976  int old_state = hcd->state;
1977 
1978  dev_dbg(&rhdev->dev, "bus %ssuspend, wakeup %d\n",
1979  (PMSG_IS_AUTO(msg) ? "auto-" : ""),
1980  rhdev->do_remote_wakeup);
1981  if (HCD_DEAD(hcd)) {
1982  dev_dbg(&rhdev->dev, "skipped %s of dead bus\n", "suspend");
1983  return 0;
1984  }
1985 
1986  if (!hcd->driver->bus_suspend) {
1987  status = -ENOENT;
1988  } else {
1989  clear_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);
1990  hcd->state = HC_STATE_QUIESCING;
1991  status = hcd->driver->bus_suspend(hcd);
1992  }
1993  if (status == 0) {
1994  usb_set_device_state(rhdev, USB_STATE_SUSPENDED);
1995  hcd->state = HC_STATE_SUSPENDED;
1996 
1997  /* Did we race with a root-hub wakeup event? */
1998  if (rhdev->do_remote_wakeup) {
1999  char buffer[6];
2000 
2001  status = hcd->driver->hub_status_data(hcd, buffer);
2002  if (status != 0) {
2003  dev_dbg(&rhdev->dev, "suspend raced with wakeup event\n");
2004  hcd_bus_resume(rhdev, PMSG_AUTO_RESUME);
2005  status = -EBUSY;
2006  }
2007  }
2008  } else {
2009  spin_lock_irq(&hcd_root_hub_lock);
2010  if (!HCD_DEAD(hcd)) {
2011  set_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);
2012  hcd->state = old_state;
2013  }
2014  spin_unlock_irq(&hcd_root_hub_lock);
2015  dev_dbg(&rhdev->dev, "bus %s fail, err %d\n",
2016  "suspend", status);
2017  }
2018  return status;
2019 }
2020 
2021 int hcd_bus_resume(struct usb_device *rhdev, pm_message_t msg)
2022 {
2023  struct usb_hcd *hcd = container_of(rhdev->bus, struct usb_hcd, self);
2024  int status;
2025  int old_state = hcd->state;
2026 
2027  dev_dbg(&rhdev->dev, "usb %sresume\n",
2028  (PMSG_IS_AUTO(msg) ? "auto-" : ""));
2029  if (HCD_DEAD(hcd)) {
2030  dev_dbg(&rhdev->dev, "skipped %s of dead bus\n", "resume");
2031  return 0;
2032  }
2033  if (!hcd->driver->bus_resume)
2034  return -ENOENT;
2035  if (HCD_RH_RUNNING(hcd))
2036  return 0;
2037 
2038  hcd->state = HC_STATE_RESUMING;
2039  status = hcd->driver->bus_resume(hcd);
2040  clear_bit(HCD_FLAG_WAKEUP_PENDING, &hcd->flags);
2041  if (status == 0) {
2042  /* TRSMRCY = 10 msec */
2043  msleep(10);
2044  spin_lock_irq(&hcd_root_hub_lock);
2045  if (!HCD_DEAD(hcd)) {
2046  usb_set_device_state(rhdev, rhdev->actconfig
2047  ? USB_STATE_CONFIGURED
2048  : USB_STATE_ADDRESS);
2049  set_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);
2050  hcd->state = HC_STATE_RUNNING;
2051  }
2052  spin_unlock_irq(&hcd_root_hub_lock);
2053  } else {
2054  hcd->state = old_state;
2055  dev_dbg(&rhdev->dev, "bus %s fail, err %d\n",
2056  "resume", status);
2057  if (status != -ESHUTDOWN)
2058  usb_hc_died(hcd);
2059  }
2060  return status;
2061 }
2062 
2063 #endif /* CONFIG_PM */
2064 
2065 #ifdef CONFIG_USB_SUSPEND
2066 
2067 /* Workqueue routine for root-hub remote wakeup */
2068 static void hcd_resume_work(struct work_struct *work)
2069 {
2070  struct usb_hcd *hcd = container_of(work, struct usb_hcd, wakeup_work);
2071  struct usb_device *udev = hcd->self.root_hub;
2072 
2073  usb_lock_device(udev);
2074  usb_remote_wakeup(udev);
2075  usb_unlock_device(udev);
2076 }
2077 
2087 void usb_hcd_resume_root_hub (struct usb_hcd *hcd)
2088 {
2089  unsigned long flags;
2090 
2091  spin_lock_irqsave (&hcd_root_hub_lock, flags);
2092  if (hcd->rh_registered) {
2093  set_bit(HCD_FLAG_WAKEUP_PENDING, &hcd->flags);
2094  queue_work(pm_wq, &hcd->wakeup_work);
2095  }
2096  spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
2097 }
2098 EXPORT_SYMBOL_GPL(usb_hcd_resume_root_hub);
2099 
2100 #endif /* CONFIG_USB_SUSPEND */
2101 
2102 /*-------------------------------------------------------------------------*/
2103 
2104 #ifdef CONFIG_USB_OTG
2105 
2117 int usb_bus_start_enum(struct usb_bus *bus, unsigned port_num)
2118 {
2119  struct usb_hcd *hcd;
2120  int status = -EOPNOTSUPP;
2121 
2122  /* NOTE: since HNP can't start by grabbing the bus's address0_sem,
2123  * boards with root hubs hooked up to internal devices (instead of
2124  * just the OTG port) may need more attention to resetting...
2125  */
2126  hcd = container_of (bus, struct usb_hcd, self);
2127  if (port_num && hcd->driver->start_port_reset)
2128  status = hcd->driver->start_port_reset(hcd, port_num);
2129 
2130  /* run khubd shortly after (first) root port reset finishes;
2131  * it may issue others, until at least 50 msecs have passed.
2132  */
2133  if (status == 0)
2134  mod_timer(&hcd->rh_timer, jiffies + msecs_to_jiffies(10));
2135  return status;
2136 }
2137 EXPORT_SYMBOL_GPL(usb_bus_start_enum);
2138 
2139 #endif
2140 
2141 /*-------------------------------------------------------------------------*/
2142 
2151 irqreturn_t usb_hcd_irq (int irq, void *__hcd)
2152 {
2153  struct usb_hcd *hcd = __hcd;
2154  unsigned long flags;
2155  irqreturn_t rc;
2156 
2157  /* IRQF_DISABLED doesn't work correctly with shared IRQs
2158  * when the first handler doesn't use it. So let's just
2159  * assume it's never used.
2160  */
2161  local_irq_save(flags);
2162 
2163  if (unlikely(HCD_DEAD(hcd) || !HCD_HW_ACCESSIBLE(hcd)))
2164  rc = IRQ_NONE;
2165  else if (hcd->driver->irq(hcd) == IRQ_NONE)
2166  rc = IRQ_NONE;
2167  else
2168  rc = IRQ_HANDLED;
2169 
2170  local_irq_restore(flags);
2171  return rc;
2172 }
2173 EXPORT_SYMBOL_GPL(usb_hcd_irq);
2174 
2175 /*-------------------------------------------------------------------------*/
2176 
2187 void usb_hc_died (struct usb_hcd *hcd)
2188 {
2189  unsigned long flags;
2190 
2191  dev_err (hcd->self.controller, "HC died; cleaning up\n");
2192 
2193  spin_lock_irqsave (&hcd_root_hub_lock, flags);
2194  clear_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);
2195  set_bit(HCD_FLAG_DEAD, &hcd->flags);
2196  if (hcd->rh_registered) {
2197  clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
2198 
2199  /* make khubd clean up old urbs and devices */
2200  usb_set_device_state (hcd->self.root_hub,
2201  USB_STATE_NOTATTACHED);
2202  usb_kick_khubd (hcd->self.root_hub);
2203  }
2204  if (usb_hcd_is_primary_hcd(hcd) && hcd->shared_hcd) {
2205  hcd = hcd->shared_hcd;
2206  if (hcd->rh_registered) {
2207  clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
2208 
2209  /* make khubd clean up old urbs and devices */
2210  usb_set_device_state(hcd->self.root_hub,
2211  USB_STATE_NOTATTACHED);
2212  usb_kick_khubd(hcd->self.root_hub);
2213  }
2214  }
2215  spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
2216  /* Make sure that the other roothub is also deallocated. */
2217 }
2218 EXPORT_SYMBOL_GPL (usb_hc_died);
2219 
2220 /*-------------------------------------------------------------------------*/
2221 
2237 struct usb_hcd *usb_create_shared_hcd(const struct hc_driver *driver,
2238  struct device *dev, const char *bus_name,
2239  struct usb_hcd *primary_hcd)
2240 {
2241  struct usb_hcd *hcd;
2242 
2243  hcd = kzalloc(sizeof(*hcd) + driver->hcd_priv_size, GFP_KERNEL);
2244  if (!hcd) {
2245  dev_dbg (dev, "hcd alloc failed\n");
2246  return NULL;
2247  }
2248  if (primary_hcd == NULL) {
2249  hcd->bandwidth_mutex = kmalloc(sizeof(*hcd->bandwidth_mutex),
2250  GFP_KERNEL);
2251  if (!hcd->bandwidth_mutex) {
2252  kfree(hcd);
2253  dev_dbg(dev, "hcd bandwidth mutex alloc failed\n");
2254  return NULL;
2255  }
2256  mutex_init(hcd->bandwidth_mutex);
2257  dev_set_drvdata(dev, hcd);
2258  } else {
2259  hcd->bandwidth_mutex = primary_hcd->bandwidth_mutex;
2260  hcd->primary_hcd = primary_hcd;
2261  primary_hcd->primary_hcd = primary_hcd;
2262  hcd->shared_hcd = primary_hcd;
2263  primary_hcd->shared_hcd = hcd;
2264  }
2265 
2266  kref_init(&hcd->kref);
2267 
2268  usb_bus_init(&hcd->self);
2269  hcd->self.controller = dev;
2270  hcd->self.bus_name = bus_name;
2271  hcd->self.uses_dma = (dev->dma_mask != NULL);
2272 
2273  init_timer(&hcd->rh_timer);
2274  hcd->rh_timer.function = rh_timer_func;
2275  hcd->rh_timer.data = (unsigned long) hcd;
2276 #ifdef CONFIG_USB_SUSPEND
2277  INIT_WORK(&hcd->wakeup_work, hcd_resume_work);
2278 #endif
2279 
2280  hcd->driver = driver;
2281  hcd->speed = driver->flags & HCD_MASK;
2282  hcd->product_desc = (driver->product_desc) ? driver->product_desc :
2283  "USB Host Controller";
2284  return hcd;
2285 }
2286 EXPORT_SYMBOL_GPL(usb_create_shared_hcd);
2287 
2301 struct usb_hcd *usb_create_hcd(const struct hc_driver *driver,
2302  struct device *dev, const char *bus_name)
2303 {
2304  return usb_create_shared_hcd(driver, dev, bus_name, NULL);
2305 }
2306 EXPORT_SYMBOL_GPL(usb_create_hcd);
2307 
2308 /*
2309  * Roothubs that share one PCI device must also share the bandwidth mutex.
2310  * Don't deallocate the bandwidth_mutex until the last shared usb_hcd is
2311  * deallocated.
2312  *
2313  * Make sure to only deallocate the bandwidth_mutex when the primary HCD is
2314  * freed. When hcd_release() is called for the non-primary HCD, set the
2315  * primary_hcd's shared_hcd pointer to null (since the non-primary HCD will be
2316  * freed shortly).
2317  */
2318 static void hcd_release (struct kref *kref)
2319 {
2320  struct usb_hcd *hcd = container_of (kref, struct usb_hcd, kref);
2321 
2322  if (usb_hcd_is_primary_hcd(hcd))
2323  kfree(hcd->bandwidth_mutex);
2324  else
2325  hcd->shared_hcd->shared_hcd = NULL;
2326  kfree(hcd);
2327 }
2328 
2329 struct usb_hcd *usb_get_hcd (struct usb_hcd *hcd)
2330 {
2331  if (hcd)
2332  kref_get (&hcd->kref);
2333  return hcd;
2334 }
2335 EXPORT_SYMBOL_GPL(usb_get_hcd);
2336 
2337 void usb_put_hcd (struct usb_hcd *hcd)
2338 {
2339  if (hcd)
2340  kref_put (&hcd->kref, hcd_release);
2341 }
2342 EXPORT_SYMBOL_GPL(usb_put_hcd);
2343 
2344 int usb_hcd_is_primary_hcd(struct usb_hcd *hcd)
2345 {
2346  if (!hcd->primary_hcd)
2347  return 1;
2348  return hcd == hcd->primary_hcd;
2349 }
2350 EXPORT_SYMBOL_GPL(usb_hcd_is_primary_hcd);
2351 
2352 static int usb_hcd_request_irqs(struct usb_hcd *hcd,
2353  unsigned int irqnum, unsigned long irqflags)
2354 {
2355  int retval;
2356 
2357  if (hcd->driver->irq) {
2358 
2359  /* IRQF_DISABLED doesn't work as advertised when used together
2360  * with IRQF_SHARED. As usb_hcd_irq() will always disable
2361  * interrupts we can remove it here.
2362  */
2363  if (irqflags & IRQF_SHARED)
2364  irqflags &= ~IRQF_DISABLED;
2365 
2366  snprintf(hcd->irq_descr, sizeof(hcd->irq_descr), "%s:usb%d",
2367  hcd->driver->description, hcd->self.busnum);
2368  retval = request_irq(irqnum, &usb_hcd_irq, irqflags,
2369  hcd->irq_descr, hcd);
2370  if (retval != 0) {
2371  dev_err(hcd->self.controller,
2372  "request interrupt %d failed\n",
2373  irqnum);
2374  return retval;
2375  }
2376  hcd->irq = irqnum;
2377  dev_info(hcd->self.controller, "irq %d, %s 0x%08llx\n", irqnum,
2378  (hcd->driver->flags & HCD_MEMORY) ?
2379  "io mem" : "io base",
2380  (unsigned long long)hcd->rsrc_start);
2381  } else {
2382  hcd->irq = 0;
2383  if (hcd->rsrc_start)
2384  dev_info(hcd->self.controller, "%s 0x%08llx\n",
2385  (hcd->driver->flags & HCD_MEMORY) ?
2386  "io mem" : "io base",
2387  (unsigned long long)hcd->rsrc_start);
2388  }
2389  return 0;
2390 }
2391 
2402 int usb_add_hcd(struct usb_hcd *hcd,
2403  unsigned int irqnum, unsigned long irqflags)
2404 {
2405  int retval;
2406  struct usb_device *rhdev;
2407 
2408  dev_info(hcd->self.controller, "%s\n", hcd->product_desc);
2409 
2410  /* Keep old behaviour if authorized_default is not in [0, 1]. */
2411  if (authorized_default < 0 || authorized_default > 1)
2412  hcd->authorized_default = hcd->wireless? 0 : 1;
2413  else
2414  hcd->authorized_default = authorized_default;
2415  set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
2416 
2417  /* HC is in reset state, but accessible. Now do the one-time init,
2418  * bottom up so that hcds can customize the root hubs before khubd
2419  * starts talking to them. (Note, bus id is assigned early too.)
2420  */
2421  if ((retval = hcd_buffer_create(hcd)) != 0) {
2422  dev_dbg(hcd->self.controller, "pool alloc failed\n");
2423  return retval;
2424  }
2425 
2426  if ((retval = usb_register_bus(&hcd->self)) < 0)
2427  goto err_register_bus;
2428 
2429  if ((rhdev = usb_alloc_dev(NULL, &hcd->self, 0)) == NULL) {
2430  dev_err(hcd->self.controller, "unable to allocate root hub\n");
2431  retval = -ENOMEM;
2432  goto err_allocate_root_hub;
2433  }
2434  hcd->self.root_hub = rhdev;
2435 
2436  switch (hcd->speed) {
2437  case HCD_USB11:
2438  rhdev->speed = USB_SPEED_FULL;
2439  break;
2440  case HCD_USB2:
2441  rhdev->speed = USB_SPEED_HIGH;
2442  break;
2443  case HCD_USB3:
2444  rhdev->speed = USB_SPEED_SUPER;
2445  break;
2446  default:
2447  retval = -EINVAL;
2448  goto err_set_rh_speed;
2449  }
2450 
2451  /* wakeup flag init defaults to "everything works" for root hubs,
2452  * but drivers can override it in reset() if needed, along with
2453  * recording the overall controller's system wakeup capability.
2454  */
2455  device_set_wakeup_capable(&rhdev->dev, 1);
2456 
2457  /* HCD_FLAG_RH_RUNNING doesn't matter until the root hub is
2458  * registered. But since the controller can die at any time,
2459  * let's initialize the flag before touching the hardware.
2460  */
2461  set_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);
2462 
2463  /* "reset" is misnamed; its role is now one-time init. the controller
2464  * should already have been reset (and boot firmware kicked off etc).
2465  */
2466  if (hcd->driver->reset && (retval = hcd->driver->reset(hcd)) < 0) {
2467  dev_err(hcd->self.controller, "can't setup\n");
2468  goto err_hcd_driver_setup;
2469  }
2470  hcd->rh_pollable = 1;
2471 
2472  /* NOTE: root hub and controller capabilities may not be the same */
2473  if (device_can_wakeup(hcd->self.controller)
2474  && device_can_wakeup(&hcd->self.root_hub->dev))
2475  dev_dbg(hcd->self.controller, "supports USB remote wakeup\n");
2476 
2477  /* enable irqs just before we start the controller,
2478  * if the BIOS provides legacy PCI irqs.
2479  */
2480  if (usb_hcd_is_primary_hcd(hcd) && irqnum) {
2481  retval = usb_hcd_request_irqs(hcd, irqnum, irqflags);
2482  if (retval)
2483  goto err_request_irq;
2484  }
2485 
2486  hcd->state = HC_STATE_RUNNING;
2487  retval = hcd->driver->start(hcd);
2488  if (retval < 0) {
2489  dev_err(hcd->self.controller, "startup error %d\n", retval);
2490  goto err_hcd_driver_start;
2491  }
2492 
2493  /* starting here, usbcore will pay attention to this root hub */
2494  rhdev->bus_mA = min(500u, hcd->power_budget);
2495  if ((retval = register_root_hub(hcd)) != 0)
2496  goto err_register_root_hub;
2497 
2498  retval = sysfs_create_group(&rhdev->dev.kobj, &usb_bus_attr_group);
2499  if (retval < 0) {
2500  printk(KERN_ERR "Cannot register USB bus sysfs attributes: %d\n",
2501  retval);
2502  goto error_create_attr_group;
2503  }
2504  if (hcd->uses_new_polling && HCD_POLL_RH(hcd))
2505  usb_hcd_poll_rh_status(hcd);
2506 
2507  /*
2508  * Host controllers don't generate their own wakeup requests;
2509  * they only forward requests from the root hub. Therefore
2510  * controllers should always be enabled for remote wakeup.
2511  */
2512  device_wakeup_enable(hcd->self.controller);
2513  return retval;
2514 
2515 error_create_attr_group:
2516  clear_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);
2517  if (HC_IS_RUNNING(hcd->state))
2518  hcd->state = HC_STATE_QUIESCING;
2519  spin_lock_irq(&hcd_root_hub_lock);
2520  hcd->rh_registered = 0;
2521  spin_unlock_irq(&hcd_root_hub_lock);
2522 
2523 #ifdef CONFIG_USB_SUSPEND
2524  cancel_work_sync(&hcd->wakeup_work);
2525 #endif
2526  mutex_lock(&usb_bus_list_lock);
2527  usb_disconnect(&rhdev); /* Sets rhdev to NULL */
2528  mutex_unlock(&usb_bus_list_lock);
2529 err_register_root_hub:
2530  hcd->rh_pollable = 0;
2531  clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
2532  del_timer_sync(&hcd->rh_timer);
2533  hcd->driver->stop(hcd);
2534  hcd->state = HC_STATE_HALT;
2535  clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
2536  del_timer_sync(&hcd->rh_timer);
2537 err_hcd_driver_start:
2538  if (usb_hcd_is_primary_hcd(hcd) && hcd->irq > 0)
2539  free_irq(irqnum, hcd);
2540 err_request_irq:
2541 err_hcd_driver_setup:
2542 err_set_rh_speed:
2543  usb_put_dev(hcd->self.root_hub);
2544 err_allocate_root_hub:
2545  usb_deregister_bus(&hcd->self);
2546 err_register_bus:
2547  hcd_buffer_destroy(hcd);
2548  return retval;
2549 }
2550 EXPORT_SYMBOL_GPL(usb_add_hcd);
2551 
2560 void usb_remove_hcd(struct usb_hcd *hcd)
2561 {
2562  struct usb_device *rhdev = hcd->self.root_hub;
2563 
2564  dev_info(hcd->self.controller, "remove, state %x\n", hcd->state);
2565 
2566  usb_get_dev(rhdev);
2567  sysfs_remove_group(&rhdev->dev.kobj, &usb_bus_attr_group);
2568 
2569  clear_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);
2570  if (HC_IS_RUNNING (hcd->state))
2571  hcd->state = HC_STATE_QUIESCING;
2572 
2573  dev_dbg(hcd->self.controller, "roothub graceful disconnect\n");
2574  spin_lock_irq (&hcd_root_hub_lock);
2575  hcd->rh_registered = 0;
2576  spin_unlock_irq (&hcd_root_hub_lock);
2577 
2578 #ifdef CONFIG_USB_SUSPEND
2579  cancel_work_sync(&hcd->wakeup_work);
2580 #endif
2581 
2582  mutex_lock(&usb_bus_list_lock);
2583  usb_disconnect(&rhdev); /* Sets rhdev to NULL */
2584  mutex_unlock(&usb_bus_list_lock);
2585 
2586  /* Prevent any more root-hub status calls from the timer.
2587  * The HCD might still restart the timer (if a port status change
2588  * interrupt occurs), but usb_hcd_poll_rh_status() won't invoke
2589  * the hub_status_data() callback.
2590  */
2591  hcd->rh_pollable = 0;
2592  clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
2593  del_timer_sync(&hcd->rh_timer);
2594 
2595  hcd->driver->stop(hcd);
2596  hcd->state = HC_STATE_HALT;
2597 
2598  /* In case the HCD restarted the timer, stop it again. */
2599  clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
2600  del_timer_sync(&hcd->rh_timer);
2601 
2602  if (usb_hcd_is_primary_hcd(hcd)) {
2603  if (hcd->irq > 0)
2604  free_irq(hcd->irq, hcd);
2605  }
2606 
2607  usb_put_dev(hcd->self.root_hub);
2608  usb_deregister_bus(&hcd->self);
2609  hcd_buffer_destroy(hcd);
2610 }
2611 EXPORT_SYMBOL_GPL(usb_remove_hcd);
2612 
2613 void
2614 usb_hcd_platform_shutdown(struct platform_device* dev)
2615 {
2616  struct usb_hcd *hcd = platform_get_drvdata(dev);
2617 
2618  if (hcd->driver->shutdown)
2619  hcd->driver->shutdown(hcd);
2620 }
2621 EXPORT_SYMBOL_GPL(usb_hcd_platform_shutdown);
2622 
2623 /*-------------------------------------------------------------------------*/
2624 
2625 #if defined(CONFIG_USB_MON) || defined(CONFIG_USB_MON_MODULE)
2626 
2627 struct usb_mon_operations *mon_ops;
2628 
2629 /*
2630  * The registration is unlocked.
2631  * We do it this way because we do not want to lock in hot paths.
2632  *
2633  * Notice that the code is minimally error-proof. Because usbmon needs
2634  * symbols from usbcore, usbcore gets referenced and cannot be unloaded first.
2635  */
2636 
2637 int usb_mon_register (struct usb_mon_operations *ops)
2638 {
2639 
2640  if (mon_ops)
2641  return -EBUSY;
2642 
2643  mon_ops = ops;
2644  mb();
2645  return 0;
2646 }
2647 EXPORT_SYMBOL_GPL (usb_mon_register);
2648 
2649 void usb_mon_deregister (void)
2650 {
2651 
2652  if (mon_ops == NULL) {
2653  printk(KERN_ERR "USB: monitor was not registered\n");
2654  return;
2655  }
2656  mon_ops = NULL;
2657  mb();
2658 }
2659 EXPORT_SYMBOL_GPL (usb_mon_deregister);
2660 
2661 #endif /* CONFIG_USB_MON || CONFIG_USB_MON_MODULE */
Generated on Thu Jan 10 2013 14:35:49 for Linux Kernel by   doxygen 1.8.2