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