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