linux/drivers/usb/core/usb.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * drivers/usb/core/usb.c
   4 *
   5 * (C) Copyright Linus Torvalds 1999
   6 * (C) Copyright Johannes Erdfelt 1999-2001
   7 * (C) Copyright Andreas Gal 1999
   8 * (C) Copyright Gregory P. Smith 1999
   9 * (C) Copyright Deti Fliegl 1999 (new USB architecture)
  10 * (C) Copyright Randy Dunlap 2000
  11 * (C) Copyright David Brownell 2000-2004
  12 * (C) Copyright Yggdrasil Computing, Inc. 2000
  13 *     (usb_device_id matching changes by Adam J. Richter)
  14 * (C) Copyright Greg Kroah-Hartman 2002-2003
  15 *
  16 * Released under the GPLv2 only.
  17 *
  18 * NOTE! This is not actually a driver at all, rather this is
  19 * just a collection of helper routines that implement the
  20 * generic USB things that the real drivers can use..
  21 *
  22 * Think of this as a "USB library" rather than anything else,
  23 * with no callbacks.  Callbacks are evil.
  24 */
  25
  26#include <linux/module.h>
  27#include <linux/moduleparam.h>
  28#include <linux/string.h>
  29#include <linux/bitops.h>
  30#include <linux/slab.h>
  31#include <linux/kmod.h>
  32#include <linux/init.h>
  33#include <linux/spinlock.h>
  34#include <linux/errno.h>
  35#include <linux/usb.h>
  36#include <linux/usb/hcd.h>
  37#include <linux/mutex.h>
  38#include <linux/workqueue.h>
  39#include <linux/debugfs.h>
  40#include <linux/usb/of.h>
  41
  42#include <asm/io.h>
  43#include <linux/scatterlist.h>
  44#include <linux/mm.h>
  45#include <linux/dma-mapping.h>
  46
  47#include "hub.h"
  48
  49const char *usbcore_name = "usbcore";
  50
  51static bool nousb;      /* Disable USB when built into kernel image */
  52
  53module_param(nousb, bool, 0444);
  54
  55/*
  56 * for external read access to <nousb>
  57 */
  58int usb_disabled(void)
  59{
  60        return nousb;
  61}
  62EXPORT_SYMBOL_GPL(usb_disabled);
  63
  64#ifdef  CONFIG_PM
  65/* Default delay value, in seconds */
  66static int usb_autosuspend_delay = CONFIG_USB_AUTOSUSPEND_DELAY;
  67module_param_named(autosuspend, usb_autosuspend_delay, int, 0644);
  68MODULE_PARM_DESC(autosuspend, "default autosuspend delay");
  69
  70#else
  71#define usb_autosuspend_delay           0
  72#endif
  73
  74static bool match_endpoint(struct usb_endpoint_descriptor *epd,
  75                struct usb_endpoint_descriptor **bulk_in,
  76                struct usb_endpoint_descriptor **bulk_out,
  77                struct usb_endpoint_descriptor **int_in,
  78                struct usb_endpoint_descriptor **int_out)
  79{
  80        switch (usb_endpoint_type(epd)) {
  81        case USB_ENDPOINT_XFER_BULK:
  82                if (usb_endpoint_dir_in(epd)) {
  83                        if (bulk_in && !*bulk_in) {
  84                                *bulk_in = epd;
  85                                break;
  86                        }
  87                } else {
  88                        if (bulk_out && !*bulk_out) {
  89                                *bulk_out = epd;
  90                                break;
  91                        }
  92                }
  93
  94                return false;
  95        case USB_ENDPOINT_XFER_INT:
  96                if (usb_endpoint_dir_in(epd)) {
  97                        if (int_in && !*int_in) {
  98                                *int_in = epd;
  99                                break;
 100                        }
 101                } else {
 102                        if (int_out && !*int_out) {
 103                                *int_out = epd;
 104                                break;
 105                        }
 106                }
 107
 108                return false;
 109        default:
 110                return false;
 111        }
 112
 113        return (!bulk_in || *bulk_in) && (!bulk_out || *bulk_out) &&
 114                        (!int_in || *int_in) && (!int_out || *int_out);
 115}
 116
 117/**
 118 * usb_find_common_endpoints() -- look up common endpoint descriptors
 119 * @alt:        alternate setting to search
 120 * @bulk_in:    pointer to descriptor pointer, or NULL
 121 * @bulk_out:   pointer to descriptor pointer, or NULL
 122 * @int_in:     pointer to descriptor pointer, or NULL
 123 * @int_out:    pointer to descriptor pointer, or NULL
 124 *
 125 * Search the alternate setting's endpoint descriptors for the first bulk-in,
 126 * bulk-out, interrupt-in and interrupt-out endpoints and return them in the
 127 * provided pointers (unless they are NULL).
 128 *
 129 * If a requested endpoint is not found, the corresponding pointer is set to
 130 * NULL.
 131 *
 132 * Return: Zero if all requested descriptors were found, or -ENXIO otherwise.
 133 */
 134int usb_find_common_endpoints(struct usb_host_interface *alt,
 135                struct usb_endpoint_descriptor **bulk_in,
 136                struct usb_endpoint_descriptor **bulk_out,
 137                struct usb_endpoint_descriptor **int_in,
 138                struct usb_endpoint_descriptor **int_out)
 139{
 140        struct usb_endpoint_descriptor *epd;
 141        int i;
 142
 143        if (bulk_in)
 144                *bulk_in = NULL;
 145        if (bulk_out)
 146                *bulk_out = NULL;
 147        if (int_in)
 148                *int_in = NULL;
 149        if (int_out)
 150                *int_out = NULL;
 151
 152        for (i = 0; i < alt->desc.bNumEndpoints; ++i) {
 153                epd = &alt->endpoint[i].desc;
 154
 155                if (match_endpoint(epd, bulk_in, bulk_out, int_in, int_out))
 156                        return 0;
 157        }
 158
 159        return -ENXIO;
 160}
 161EXPORT_SYMBOL_GPL(usb_find_common_endpoints);
 162
 163/**
 164 * usb_find_common_endpoints_reverse() -- look up common endpoint descriptors
 165 * @alt:        alternate setting to search
 166 * @bulk_in:    pointer to descriptor pointer, or NULL
 167 * @bulk_out:   pointer to descriptor pointer, or NULL
 168 * @int_in:     pointer to descriptor pointer, or NULL
 169 * @int_out:    pointer to descriptor pointer, or NULL
 170 *
 171 * Search the alternate setting's endpoint descriptors for the last bulk-in,
 172 * bulk-out, interrupt-in and interrupt-out endpoints and return them in the
 173 * provided pointers (unless they are NULL).
 174 *
 175 * If a requested endpoint is not found, the corresponding pointer is set to
 176 * NULL.
 177 *
 178 * Return: Zero if all requested descriptors were found, or -ENXIO otherwise.
 179 */
 180int usb_find_common_endpoints_reverse(struct usb_host_interface *alt,
 181                struct usb_endpoint_descriptor **bulk_in,
 182                struct usb_endpoint_descriptor **bulk_out,
 183                struct usb_endpoint_descriptor **int_in,
 184                struct usb_endpoint_descriptor **int_out)
 185{
 186        struct usb_endpoint_descriptor *epd;
 187        int i;
 188
 189        if (bulk_in)
 190                *bulk_in = NULL;
 191        if (bulk_out)
 192                *bulk_out = NULL;
 193        if (int_in)
 194                *int_in = NULL;
 195        if (int_out)
 196                *int_out = NULL;
 197
 198        for (i = alt->desc.bNumEndpoints - 1; i >= 0; --i) {
 199                epd = &alt->endpoint[i].desc;
 200
 201                if (match_endpoint(epd, bulk_in, bulk_out, int_in, int_out))
 202                        return 0;
 203        }
 204
 205        return -ENXIO;
 206}
 207EXPORT_SYMBOL_GPL(usb_find_common_endpoints_reverse);
 208
 209/**
 210 * usb_find_alt_setting() - Given a configuration, find the alternate setting
 211 * for the given interface.
 212 * @config: the configuration to search (not necessarily the current config).
 213 * @iface_num: interface number to search in
 214 * @alt_num: alternate interface setting number to search for.
 215 *
 216 * Search the configuration's interface cache for the given alt setting.
 217 *
 218 * Return: The alternate setting, if found. %NULL otherwise.
 219 */
 220struct usb_host_interface *usb_find_alt_setting(
 221                struct usb_host_config *config,
 222                unsigned int iface_num,
 223                unsigned int alt_num)
 224{
 225        struct usb_interface_cache *intf_cache = NULL;
 226        int i;
 227
 228        if (!config)
 229                return NULL;
 230        for (i = 0; i < config->desc.bNumInterfaces; i++) {
 231                if (config->intf_cache[i]->altsetting[0].desc.bInterfaceNumber
 232                                == iface_num) {
 233                        intf_cache = config->intf_cache[i];
 234                        break;
 235                }
 236        }
 237        if (!intf_cache)
 238                return NULL;
 239        for (i = 0; i < intf_cache->num_altsetting; i++)
 240                if (intf_cache->altsetting[i].desc.bAlternateSetting == alt_num)
 241                        return &intf_cache->altsetting[i];
 242
 243        printk(KERN_DEBUG "Did not find alt setting %u for intf %u, "
 244                        "config %u\n", alt_num, iface_num,
 245                        config->desc.bConfigurationValue);
 246        return NULL;
 247}
 248EXPORT_SYMBOL_GPL(usb_find_alt_setting);
 249
 250/**
 251 * usb_ifnum_to_if - get the interface object with a given interface number
 252 * @dev: the device whose current configuration is considered
 253 * @ifnum: the desired interface
 254 *
 255 * This walks the device descriptor for the currently active configuration
 256 * to find the interface object with the particular interface number.
 257 *
 258 * Note that configuration descriptors are not required to assign interface
 259 * numbers sequentially, so that it would be incorrect to assume that
 260 * the first interface in that descriptor corresponds to interface zero.
 261 * This routine helps device drivers avoid such mistakes.
 262 * However, you should make sure that you do the right thing with any
 263 * alternate settings available for this interfaces.
 264 *
 265 * Don't call this function unless you are bound to one of the interfaces
 266 * on this device or you have locked the device!
 267 *
 268 * Return: A pointer to the interface that has @ifnum as interface number,
 269 * if found. %NULL otherwise.
 270 */
 271struct usb_interface *usb_ifnum_to_if(const struct usb_device *dev,
 272                                      unsigned ifnum)
 273{
 274        struct usb_host_config *config = dev->actconfig;
 275        int i;
 276
 277        if (!config)
 278                return NULL;
 279        for (i = 0; i < config->desc.bNumInterfaces; i++)
 280                if (config->interface[i]->altsetting[0]
 281                                .desc.bInterfaceNumber == ifnum)
 282                        return config->interface[i];
 283
 284        return NULL;
 285}
 286EXPORT_SYMBOL_GPL(usb_ifnum_to_if);
 287
 288/**
 289 * usb_altnum_to_altsetting - get the altsetting structure with a given alternate setting number.
 290 * @intf: the interface containing the altsetting in question
 291 * @altnum: the desired alternate setting number
 292 *
 293 * This searches the altsetting array of the specified interface for
 294 * an entry with the correct bAlternateSetting value.
 295 *
 296 * Note that altsettings need not be stored sequentially by number, so
 297 * it would be incorrect to assume that the first altsetting entry in
 298 * the array corresponds to altsetting zero.  This routine helps device
 299 * drivers avoid such mistakes.
 300 *
 301 * Don't call this function unless you are bound to the intf interface
 302 * or you have locked the device!
 303 *
 304 * Return: A pointer to the entry of the altsetting array of @intf that
 305 * has @altnum as the alternate setting number. %NULL if not found.
 306 */
 307struct usb_host_interface *usb_altnum_to_altsetting(
 308                                        const struct usb_interface *intf,
 309                                        unsigned int altnum)
 310{
 311        int i;
 312
 313        for (i = 0; i < intf->num_altsetting; i++) {
 314                if (intf->altsetting[i].desc.bAlternateSetting == altnum)
 315                        return &intf->altsetting[i];
 316        }
 317        return NULL;
 318}
 319EXPORT_SYMBOL_GPL(usb_altnum_to_altsetting);
 320
 321struct find_interface_arg {
 322        int minor;
 323        struct device_driver *drv;
 324};
 325
 326static int __find_interface(struct device *dev, const void *data)
 327{
 328        const struct find_interface_arg *arg = data;
 329        struct usb_interface *intf;
 330
 331        if (!is_usb_interface(dev))
 332                return 0;
 333
 334        if (dev->driver != arg->drv)
 335                return 0;
 336        intf = to_usb_interface(dev);
 337        return intf->minor == arg->minor;
 338}
 339
 340/**
 341 * usb_find_interface - find usb_interface pointer for driver and device
 342 * @drv: the driver whose current configuration is considered
 343 * @minor: the minor number of the desired device
 344 *
 345 * This walks the bus device list and returns a pointer to the interface
 346 * with the matching minor and driver.  Note, this only works for devices
 347 * that share the USB major number.
 348 *
 349 * Return: A pointer to the interface with the matching major and @minor.
 350 */
 351struct usb_interface *usb_find_interface(struct usb_driver *drv, int minor)
 352{
 353        struct find_interface_arg argb;
 354        struct device *dev;
 355
 356        argb.minor = minor;
 357        argb.drv = &drv->drvwrap.driver;
 358
 359        dev = bus_find_device(&usb_bus_type, NULL, &argb, __find_interface);
 360
 361        /* Drop reference count from bus_find_device */
 362        put_device(dev);
 363
 364        return dev ? to_usb_interface(dev) : NULL;
 365}
 366EXPORT_SYMBOL_GPL(usb_find_interface);
 367
 368struct each_dev_arg {
 369        void *data;
 370        int (*fn)(struct usb_device *, void *);
 371};
 372
 373static int __each_dev(struct device *dev, void *data)
 374{
 375        struct each_dev_arg *arg = (struct each_dev_arg *)data;
 376
 377        /* There are struct usb_interface on the same bus, filter them out */
 378        if (!is_usb_device(dev))
 379                return 0;
 380
 381        return arg->fn(to_usb_device(dev), arg->data);
 382}
 383
 384/**
 385 * usb_for_each_dev - iterate over all USB devices in the system
 386 * @data: data pointer that will be handed to the callback function
 387 * @fn: callback function to be called for each USB device
 388 *
 389 * Iterate over all USB devices and call @fn for each, passing it @data. If it
 390 * returns anything other than 0, we break the iteration prematurely and return
 391 * that value.
 392 */
 393int usb_for_each_dev(void *data, int (*fn)(struct usb_device *, void *))
 394{
 395        struct each_dev_arg arg = {data, fn};
 396
 397        return bus_for_each_dev(&usb_bus_type, NULL, &arg, __each_dev);
 398}
 399EXPORT_SYMBOL_GPL(usb_for_each_dev);
 400
 401struct each_hub_arg {
 402        void *data;
 403        int (*fn)(struct device *, void *);
 404};
 405
 406static int __each_hub(struct usb_device *hdev, void *data)
 407{
 408        struct each_hub_arg *arg = (struct each_hub_arg *)data;
 409        struct usb_hub *hub;
 410        int ret = 0;
 411        int i;
 412
 413        hub = usb_hub_to_struct_hub(hdev);
 414        if (!hub)
 415                return 0;
 416
 417        mutex_lock(&usb_port_peer_mutex);
 418
 419        for (i = 0; i < hdev->maxchild; i++) {
 420                ret = arg->fn(&hub->ports[i]->dev, arg->data);
 421                if (ret)
 422                        break;
 423        }
 424
 425        mutex_unlock(&usb_port_peer_mutex);
 426
 427        return ret;
 428}
 429
 430/**
 431 * usb_for_each_port - interate over all USB ports in the system
 432 * @data: data pointer that will be handed to the callback function
 433 * @fn: callback function to be called for each USB port
 434 *
 435 * Iterate over all USB ports and call @fn for each, passing it @data. If it
 436 * returns anything other than 0, we break the iteration prematurely and return
 437 * that value.
 438 */
 439int usb_for_each_port(void *data, int (*fn)(struct device *, void *))
 440{
 441        struct each_hub_arg arg = {data, fn};
 442
 443        return usb_for_each_dev(&arg, __each_hub);
 444}
 445EXPORT_SYMBOL_GPL(usb_for_each_port);
 446
 447/**
 448 * usb_release_dev - free a usb device structure when all users of it are finished.
 449 * @dev: device that's been disconnected
 450 *
 451 * Will be called only by the device core when all users of this usb device are
 452 * done.
 453 */
 454static void usb_release_dev(struct device *dev)
 455{
 456        struct usb_device *udev;
 457        struct usb_hcd *hcd;
 458
 459        udev = to_usb_device(dev);
 460        hcd = bus_to_hcd(udev->bus);
 461
 462        usb_destroy_configuration(udev);
 463        usb_release_bos_descriptor(udev);
 464        of_node_put(dev->of_node);
 465        usb_put_hcd(hcd);
 466        kfree(udev->product);
 467        kfree(udev->manufacturer);
 468        kfree(udev->serial);
 469        kfree(udev);
 470}
 471
 472static int usb_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
 473{
 474        struct usb_device *usb_dev;
 475
 476        usb_dev = to_usb_device(dev);
 477
 478        if (add_uevent_var(env, "BUSNUM=%03d", usb_dev->bus->busnum))
 479                return -ENOMEM;
 480
 481        if (add_uevent_var(env, "DEVNUM=%03d", usb_dev->devnum))
 482                return -ENOMEM;
 483
 484        return 0;
 485}
 486
 487#ifdef  CONFIG_PM
 488
 489/* USB device Power-Management thunks.
 490 * There's no need to distinguish here between quiescing a USB device
 491 * and powering it down; the generic_suspend() routine takes care of
 492 * it by skipping the usb_port_suspend() call for a quiesce.  And for
 493 * USB interfaces there's no difference at all.
 494 */
 495
 496static int usb_dev_prepare(struct device *dev)
 497{
 498        return 0;               /* Implement eventually? */
 499}
 500
 501static void usb_dev_complete(struct device *dev)
 502{
 503        /* Currently used only for rebinding interfaces */
 504        usb_resume_complete(dev);
 505}
 506
 507static int usb_dev_suspend(struct device *dev)
 508{
 509        return usb_suspend(dev, PMSG_SUSPEND);
 510}
 511
 512static int usb_dev_resume(struct device *dev)
 513{
 514        return usb_resume(dev, PMSG_RESUME);
 515}
 516
 517static int usb_dev_freeze(struct device *dev)
 518{
 519        return usb_suspend(dev, PMSG_FREEZE);
 520}
 521
 522static int usb_dev_thaw(struct device *dev)
 523{
 524        return usb_resume(dev, PMSG_THAW);
 525}
 526
 527static int usb_dev_poweroff(struct device *dev)
 528{
 529        return usb_suspend(dev, PMSG_HIBERNATE);
 530}
 531
 532static int usb_dev_restore(struct device *dev)
 533{
 534        return usb_resume(dev, PMSG_RESTORE);
 535}
 536
 537static const struct dev_pm_ops usb_device_pm_ops = {
 538        .prepare =      usb_dev_prepare,
 539        .complete =     usb_dev_complete,
 540        .suspend =      usb_dev_suspend,
 541        .resume =       usb_dev_resume,
 542        .freeze =       usb_dev_freeze,
 543        .thaw =         usb_dev_thaw,
 544        .poweroff =     usb_dev_poweroff,
 545        .restore =      usb_dev_restore,
 546        .runtime_suspend =      usb_runtime_suspend,
 547        .runtime_resume =       usb_runtime_resume,
 548        .runtime_idle =         usb_runtime_idle,
 549};
 550
 551#endif  /* CONFIG_PM */
 552
 553
 554static char *usb_devnode(struct device *dev,
 555                         umode_t *mode, kuid_t *uid, kgid_t *gid)
 556{
 557        struct usb_device *usb_dev;
 558
 559        usb_dev = to_usb_device(dev);
 560        return kasprintf(GFP_KERNEL, "bus/usb/%03d/%03d",
 561                         usb_dev->bus->busnum, usb_dev->devnum);
 562}
 563
 564struct device_type usb_device_type = {
 565        .name =         "usb_device",
 566        .release =      usb_release_dev,
 567        .uevent =       usb_dev_uevent,
 568        .devnode =      usb_devnode,
 569#ifdef CONFIG_PM
 570        .pm =           &usb_device_pm_ops,
 571#endif
 572};
 573
 574
 575/* Returns 1 if @usb_bus is WUSB, 0 otherwise */
 576static unsigned usb_bus_is_wusb(struct usb_bus *bus)
 577{
 578        struct usb_hcd *hcd = bus_to_hcd(bus);
 579        return hcd->wireless;
 580}
 581
 582static bool usb_dev_authorized(struct usb_device *dev, struct usb_hcd *hcd)
 583{
 584        struct usb_hub *hub;
 585
 586        if (!dev->parent)
 587                return true; /* Root hub always ok [and always wired] */
 588
 589        switch (hcd->dev_policy) {
 590        case USB_DEVICE_AUTHORIZE_NONE:
 591        default:
 592                return false;
 593
 594        case USB_DEVICE_AUTHORIZE_ALL:
 595                return true;
 596
 597        case USB_DEVICE_AUTHORIZE_INTERNAL:
 598                hub = usb_hub_to_struct_hub(dev->parent);
 599                return hub->ports[dev->portnum - 1]->connect_type ==
 600                                USB_PORT_CONNECT_TYPE_HARD_WIRED;
 601        }
 602}
 603
 604/**
 605 * usb_alloc_dev - usb device constructor (usbcore-internal)
 606 * @parent: hub to which device is connected; null to allocate a root hub
 607 * @bus: bus used to access the device
 608 * @port1: one-based index of port; ignored for root hubs
 609 *
 610 * Context: task context, might sleep.
 611 *
 612 * Only hub drivers (including virtual root hub drivers for host
 613 * controllers) should ever call this.
 614 *
 615 * This call may not be used in a non-sleeping context.
 616 *
 617 * Return: On success, a pointer to the allocated usb device. %NULL on
 618 * failure.
 619 */
 620struct usb_device *usb_alloc_dev(struct usb_device *parent,
 621                                 struct usb_bus *bus, unsigned port1)
 622{
 623        struct usb_device *dev;
 624        struct usb_hcd *usb_hcd = bus_to_hcd(bus);
 625        unsigned root_hub = 0;
 626        unsigned raw_port = port1;
 627
 628        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 629        if (!dev)
 630                return NULL;
 631
 632        if (!usb_get_hcd(usb_hcd)) {
 633                kfree(dev);
 634                return NULL;
 635        }
 636        /* Root hubs aren't true devices, so don't allocate HCD resources */
 637        if (usb_hcd->driver->alloc_dev && parent &&
 638                !usb_hcd->driver->alloc_dev(usb_hcd, dev)) {
 639                usb_put_hcd(bus_to_hcd(bus));
 640                kfree(dev);
 641                return NULL;
 642        }
 643
 644        device_initialize(&dev->dev);
 645        dev->dev.bus = &usb_bus_type;
 646        dev->dev.type = &usb_device_type;
 647        dev->dev.groups = usb_device_groups;
 648        set_dev_node(&dev->dev, dev_to_node(bus->sysdev));
 649        dev->state = USB_STATE_ATTACHED;
 650        dev->lpm_disable_count = 1;
 651        atomic_set(&dev->urbnum, 0);
 652
 653        INIT_LIST_HEAD(&dev->ep0.urb_list);
 654        dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE;
 655        dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT;
 656        /* ep0 maxpacket comes later, from device descriptor */
 657        usb_enable_endpoint(dev, &dev->ep0, false);
 658        dev->can_submit = 1;
 659
 660        /* Save readable and stable topology id, distinguishing devices
 661         * by location for diagnostics, tools, driver model, etc.  The
 662         * string is a path along hub ports, from the root.  Each device's
 663         * dev->devpath will be stable until USB is re-cabled, and hubs
 664         * are often labeled with these port numbers.  The name isn't
 665         * as stable:  bus->busnum changes easily from modprobe order,
 666         * cardbus or pci hotplugging, and so on.
 667         */
 668        if (unlikely(!parent)) {
 669                dev->devpath[0] = '0';
 670                dev->route = 0;
 671
 672                dev->dev.parent = bus->controller;
 673                device_set_of_node_from_dev(&dev->dev, bus->sysdev);
 674                dev_set_name(&dev->dev, "usb%d", bus->busnum);
 675                root_hub = 1;
 676        } else {
 677                /* match any labeling on the hubs; it's one-based */
 678                if (parent->devpath[0] == '0') {
 679                        snprintf(dev->devpath, sizeof dev->devpath,
 680                                "%d", port1);
 681                        /* Root ports are not counted in route string */
 682                        dev->route = 0;
 683                } else {
 684                        snprintf(dev->devpath, sizeof dev->devpath,
 685                                "%s.%d", parent->devpath, port1);
 686                        /* Route string assumes hubs have less than 16 ports */
 687                        if (port1 < 15)
 688                                dev->route = parent->route +
 689                                        (port1 << ((parent->level - 1)*4));
 690                        else
 691                                dev->route = parent->route +
 692                                        (15 << ((parent->level - 1)*4));
 693                }
 694
 695                dev->dev.parent = &parent->dev;
 696                dev_set_name(&dev->dev, "%d-%s", bus->busnum, dev->devpath);
 697
 698                if (!parent->parent) {
 699                        /* device under root hub's port */
 700                        raw_port = usb_hcd_find_raw_port_number(usb_hcd,
 701                                port1);
 702                }
 703                dev->dev.of_node = usb_of_get_device_node(parent, raw_port);
 704
 705                /* hub driver sets up TT records */
 706        }
 707
 708        dev->portnum = port1;
 709        dev->bus = bus;
 710        dev->parent = parent;
 711        INIT_LIST_HEAD(&dev->filelist);
 712
 713#ifdef  CONFIG_PM
 714        pm_runtime_set_autosuspend_delay(&dev->dev,
 715                        usb_autosuspend_delay * 1000);
 716        dev->connect_time = jiffies;
 717        dev->active_duration = -jiffies;
 718#endif
 719
 720        dev->authorized = usb_dev_authorized(dev, usb_hcd);
 721        if (!root_hub)
 722                dev->wusb = usb_bus_is_wusb(bus) ? 1 : 0;
 723
 724        return dev;
 725}
 726EXPORT_SYMBOL_GPL(usb_alloc_dev);
 727
 728/**
 729 * usb_get_dev - increments the reference count of the usb device structure
 730 * @dev: the device being referenced
 731 *
 732 * Each live reference to a device should be refcounted.
 733 *
 734 * Drivers for USB interfaces should normally record such references in
 735 * their probe() methods, when they bind to an interface, and release
 736 * them by calling usb_put_dev(), in their disconnect() methods.
 737 *
 738 * Return: A pointer to the device with the incremented reference counter.
 739 */
 740struct usb_device *usb_get_dev(struct usb_device *dev)
 741{
 742        if (dev)
 743                get_device(&dev->dev);
 744        return dev;
 745}
 746EXPORT_SYMBOL_GPL(usb_get_dev);
 747
 748/**
 749 * usb_put_dev - release a use of the usb device structure
 750 * @dev: device that's been disconnected
 751 *
 752 * Must be called when a user of a device is finished with it.  When the last
 753 * user of the device calls this function, the memory of the device is freed.
 754 */
 755void usb_put_dev(struct usb_device *dev)
 756{
 757        if (dev)
 758                put_device(&dev->dev);
 759}
 760EXPORT_SYMBOL_GPL(usb_put_dev);
 761
 762/**
 763 * usb_get_intf - increments the reference count of the usb interface structure
 764 * @intf: the interface being referenced
 765 *
 766 * Each live reference to a interface must be refcounted.
 767 *
 768 * Drivers for USB interfaces should normally record such references in
 769 * their probe() methods, when they bind to an interface, and release
 770 * them by calling usb_put_intf(), in their disconnect() methods.
 771 *
 772 * Return: A pointer to the interface with the incremented reference counter.
 773 */
 774struct usb_interface *usb_get_intf(struct usb_interface *intf)
 775{
 776        if (intf)
 777                get_device(&intf->dev);
 778        return intf;
 779}
 780EXPORT_SYMBOL_GPL(usb_get_intf);
 781
 782/**
 783 * usb_put_intf - release a use of the usb interface structure
 784 * @intf: interface that's been decremented
 785 *
 786 * Must be called when a user of an interface is finished with it.  When the
 787 * last user of the interface calls this function, the memory of the interface
 788 * is freed.
 789 */
 790void usb_put_intf(struct usb_interface *intf)
 791{
 792        if (intf)
 793                put_device(&intf->dev);
 794}
 795EXPORT_SYMBOL_GPL(usb_put_intf);
 796
 797/**
 798 * usb_intf_get_dma_device - acquire a reference on the usb interface's DMA endpoint
 799 * @intf: the usb interface
 800 *
 801 * While a USB device cannot perform DMA operations by itself, many USB
 802 * controllers can. A call to usb_intf_get_dma_device() returns the DMA endpoint
 803 * for the given USB interface, if any. The returned device structure must be
 804 * released with put_device().
 805 *
 806 * See also usb_get_dma_device().
 807 *
 808 * Returns: A reference to the usb interface's DMA endpoint; or NULL if none
 809 *          exists.
 810 */
 811struct device *usb_intf_get_dma_device(struct usb_interface *intf)
 812{
 813        struct usb_device *udev = interface_to_usbdev(intf);
 814        struct device *dmadev;
 815
 816        if (!udev->bus)
 817                return NULL;
 818
 819        dmadev = get_device(udev->bus->sysdev);
 820        if (!dmadev || !dmadev->dma_mask) {
 821                put_device(dmadev);
 822                return NULL;
 823        }
 824
 825        return dmadev;
 826}
 827EXPORT_SYMBOL_GPL(usb_intf_get_dma_device);
 828
 829/*                      USB device locking
 830 *
 831 * USB devices and interfaces are locked using the semaphore in their
 832 * embedded struct device.  The hub driver guarantees that whenever a
 833 * device is connected or disconnected, drivers are called with the
 834 * USB device locked as well as their particular interface.
 835 *
 836 * Complications arise when several devices are to be locked at the same
 837 * time.  Only hub-aware drivers that are part of usbcore ever have to
 838 * do this; nobody else needs to worry about it.  The rule for locking
 839 * is simple:
 840 *
 841 *      When locking both a device and its parent, always lock the
 842 *      the parent first.
 843 */
 844
 845/**
 846 * usb_lock_device_for_reset - cautiously acquire the lock for a usb device structure
 847 * @udev: device that's being locked
 848 * @iface: interface bound to the driver making the request (optional)
 849 *
 850 * Attempts to acquire the device lock, but fails if the device is
 851 * NOTATTACHED or SUSPENDED, or if iface is specified and the interface
 852 * is neither BINDING nor BOUND.  Rather than sleeping to wait for the
 853 * lock, the routine polls repeatedly.  This is to prevent deadlock with
 854 * disconnect; in some drivers (such as usb-storage) the disconnect()
 855 * or suspend() method will block waiting for a device reset to complete.
 856 *
 857 * Return: A negative error code for failure, otherwise 0.
 858 */
 859int usb_lock_device_for_reset(struct usb_device *udev,
 860                              const struct usb_interface *iface)
 861{
 862        unsigned long jiffies_expire = jiffies + HZ;
 863
 864        if (udev->state == USB_STATE_NOTATTACHED)
 865                return -ENODEV;
 866        if (udev->state == USB_STATE_SUSPENDED)
 867                return -EHOSTUNREACH;
 868        if (iface && (iface->condition == USB_INTERFACE_UNBINDING ||
 869                        iface->condition == USB_INTERFACE_UNBOUND))
 870                return -EINTR;
 871
 872        while (!usb_trylock_device(udev)) {
 873
 874                /* If we can't acquire the lock after waiting one second,
 875                 * we're probably deadlocked */
 876                if (time_after(jiffies, jiffies_expire))
 877                        return -EBUSY;
 878
 879                msleep(15);
 880                if (udev->state == USB_STATE_NOTATTACHED)
 881                        return -ENODEV;
 882                if (udev->state == USB_STATE_SUSPENDED)
 883                        return -EHOSTUNREACH;
 884                if (iface && (iface->condition == USB_INTERFACE_UNBINDING ||
 885                                iface->condition == USB_INTERFACE_UNBOUND))
 886                        return -EINTR;
 887        }
 888        return 0;
 889}
 890EXPORT_SYMBOL_GPL(usb_lock_device_for_reset);
 891
 892/**
 893 * usb_get_current_frame_number - return current bus frame number
 894 * @dev: the device whose bus is being queried
 895 *
 896 * Return: The current frame number for the USB host controller used
 897 * with the given USB device. This can be used when scheduling
 898 * isochronous requests.
 899 *
 900 * Note: Different kinds of host controller have different "scheduling
 901 * horizons". While one type might support scheduling only 32 frames
 902 * into the future, others could support scheduling up to 1024 frames
 903 * into the future.
 904 *
 905 */
 906int usb_get_current_frame_number(struct usb_device *dev)
 907{
 908        return usb_hcd_get_frame_number(dev);
 909}
 910EXPORT_SYMBOL_GPL(usb_get_current_frame_number);
 911
 912/*-------------------------------------------------------------------*/
 913/*
 914 * __usb_get_extra_descriptor() finds a descriptor of specific type in the
 915 * extra field of the interface and endpoint descriptor structs.
 916 */
 917
 918int __usb_get_extra_descriptor(char *buffer, unsigned size,
 919                               unsigned char type, void **ptr, size_t minsize)
 920{
 921        struct usb_descriptor_header *header;
 922
 923        while (size >= sizeof(struct usb_descriptor_header)) {
 924                header = (struct usb_descriptor_header *)buffer;
 925
 926                if (header->bLength < 2 || header->bLength > size) {
 927                        printk(KERN_ERR
 928                                "%s: bogus descriptor, type %d length %d\n",
 929                                usbcore_name,
 930                                header->bDescriptorType,
 931                                header->bLength);
 932                        return -1;
 933                }
 934
 935                if (header->bDescriptorType == type && header->bLength >= minsize) {
 936                        *ptr = header;
 937                        return 0;
 938                }
 939
 940                buffer += header->bLength;
 941                size -= header->bLength;
 942        }
 943        return -1;
 944}
 945EXPORT_SYMBOL_GPL(__usb_get_extra_descriptor);
 946
 947/**
 948 * usb_alloc_coherent - allocate dma-consistent buffer for URB_NO_xxx_DMA_MAP
 949 * @dev: device the buffer will be used with
 950 * @size: requested buffer size
 951 * @mem_flags: affect whether allocation may block
 952 * @dma: used to return DMA address of buffer
 953 *
 954 * Return: Either null (indicating no buffer could be allocated), or the
 955 * cpu-space pointer to a buffer that may be used to perform DMA to the
 956 * specified device.  Such cpu-space buffers are returned along with the DMA
 957 * address (through the pointer provided).
 958 *
 959 * Note:
 960 * These buffers are used with URB_NO_xxx_DMA_MAP set in urb->transfer_flags
 961 * to avoid behaviors like using "DMA bounce buffers", or thrashing IOMMU
 962 * hardware during URB completion/resubmit.  The implementation varies between
 963 * platforms, depending on details of how DMA will work to this device.
 964 * Using these buffers also eliminates cacheline sharing problems on
 965 * architectures where CPU caches are not DMA-coherent.  On systems without
 966 * bus-snooping caches, these buffers are uncached.
 967 *
 968 * When the buffer is no longer used, free it with usb_free_coherent().
 969 */
 970void *usb_alloc_coherent(struct usb_device *dev, size_t size, gfp_t mem_flags,
 971                         dma_addr_t *dma)
 972{
 973        if (!dev || !dev->bus)
 974                return NULL;
 975        return hcd_buffer_alloc(dev->bus, size, mem_flags, dma);
 976}
 977EXPORT_SYMBOL_GPL(usb_alloc_coherent);
 978
 979/**
 980 * usb_free_coherent - free memory allocated with usb_alloc_coherent()
 981 * @dev: device the buffer was used with
 982 * @size: requested buffer size
 983 * @addr: CPU address of buffer
 984 * @dma: DMA address of buffer
 985 *
 986 * This reclaims an I/O buffer, letting it be reused.  The memory must have
 987 * been allocated using usb_alloc_coherent(), and the parameters must match
 988 * those provided in that allocation request.
 989 */
 990void usb_free_coherent(struct usb_device *dev, size_t size, void *addr,
 991                       dma_addr_t dma)
 992{
 993        if (!dev || !dev->bus)
 994                return;
 995        if (!addr)
 996                return;
 997        hcd_buffer_free(dev->bus, size, addr, dma);
 998}
 999EXPORT_SYMBOL_GPL(usb_free_coherent);
1000
1001/*
1002 * Notifications of device and interface registration
1003 */
1004static int usb_bus_notify(struct notifier_block *nb, unsigned long action,
1005                void *data)
1006{
1007        struct device *dev = data;
1008
1009        switch (action) {
1010        case BUS_NOTIFY_ADD_DEVICE:
1011                if (dev->type == &usb_device_type)
1012                        (void) usb_create_sysfs_dev_files(to_usb_device(dev));
1013                else if (dev->type == &usb_if_device_type)
1014                        usb_create_sysfs_intf_files(to_usb_interface(dev));
1015                break;
1016
1017        case BUS_NOTIFY_DEL_DEVICE:
1018                if (dev->type == &usb_device_type)
1019                        usb_remove_sysfs_dev_files(to_usb_device(dev));
1020                else if (dev->type == &usb_if_device_type)
1021                        usb_remove_sysfs_intf_files(to_usb_interface(dev));
1022                break;
1023        }
1024        return 0;
1025}
1026
1027static struct notifier_block usb_bus_nb = {
1028        .notifier_call = usb_bus_notify,
1029};
1030
1031static void usb_debugfs_init(void)
1032{
1033        debugfs_create_file("devices", 0444, usb_debug_root, NULL,
1034                            &usbfs_devices_fops);
1035}
1036
1037static void usb_debugfs_cleanup(void)
1038{
1039        debugfs_remove(debugfs_lookup("devices", usb_debug_root));
1040}
1041
1042/*
1043 * Init
1044 */
1045static int __init usb_init(void)
1046{
1047        int retval;
1048        if (usb_disabled()) {
1049                pr_info("%s: USB support disabled\n", usbcore_name);
1050                return 0;
1051        }
1052        usb_init_pool_max();
1053
1054        usb_debugfs_init();
1055
1056        usb_acpi_register();
1057        retval = bus_register(&usb_bus_type);
1058        if (retval)
1059                goto bus_register_failed;
1060        retval = bus_register_notifier(&usb_bus_type, &usb_bus_nb);
1061        if (retval)
1062                goto bus_notifier_failed;
1063        retval = usb_major_init();
1064        if (retval)
1065                goto major_init_failed;
1066        retval = usb_register(&usbfs_driver);
1067        if (retval)
1068                goto driver_register_failed;
1069        retval = usb_devio_init();
1070        if (retval)
1071                goto usb_devio_init_failed;
1072        retval = usb_hub_init();
1073        if (retval)
1074                goto hub_init_failed;
1075        retval = usb_register_device_driver(&usb_generic_driver, THIS_MODULE);
1076        if (!retval)
1077                goto out;
1078
1079        usb_hub_cleanup();
1080hub_init_failed:
1081        usb_devio_cleanup();
1082usb_devio_init_failed:
1083        usb_deregister(&usbfs_driver);
1084driver_register_failed:
1085        usb_major_cleanup();
1086major_init_failed:
1087        bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);
1088bus_notifier_failed:
1089        bus_unregister(&usb_bus_type);
1090bus_register_failed:
1091        usb_acpi_unregister();
1092        usb_debugfs_cleanup();
1093out:
1094        return retval;
1095}
1096
1097/*
1098 * Cleanup
1099 */
1100static void __exit usb_exit(void)
1101{
1102        /* This will matter if shutdown/reboot does exitcalls. */
1103        if (usb_disabled())
1104                return;
1105
1106        usb_release_quirk_list();
1107        usb_deregister_device_driver(&usb_generic_driver);
1108        usb_major_cleanup();
1109        usb_deregister(&usbfs_driver);
1110        usb_devio_cleanup();
1111        usb_hub_cleanup();
1112        bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);
1113        bus_unregister(&usb_bus_type);
1114        usb_acpi_unregister();
1115        usb_debugfs_cleanup();
1116        idr_destroy(&usb_bus_idr);
1117}
1118
1119subsys_initcall(usb_init);
1120module_exit(usb_exit);
1121MODULE_LICENSE("GPL");
1122