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