projects/linux·blob master · refs

1294 lines · 36.6 KiB

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