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