2 * drivers/usb/core/usb.c
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
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..
19 * Think of this as a "USB library" rather than anything else.
20 * It should be considered a slave, with no callbacks. Callbacks
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/mutex.h>
36 #include <linux/workqueue.h>
37 #include <linux/debugfs.h>
40 #include <linux/scatterlist.h>
42 #include <linux/dma-mapping.h>
48 const char *usbcore_name
= "usbcore";
50 static int nousb
; /* Disable USB when built into kernel image */
52 /* Workqueue for autosuspend and for remote wakeup of root hubs */
53 struct workqueue_struct
*ksuspend_usb_wq
;
55 #ifdef CONFIG_USB_SUSPEND
56 static int usb_autosuspend_delay
= 2; /* Default delay value,
58 module_param_named(autosuspend
, usb_autosuspend_delay
, int, 0644);
59 MODULE_PARM_DESC(autosuspend
, "default autosuspend delay");
62 #define usb_autosuspend_delay 0
67 * usb_find_alt_setting() - Given a configuration, find the alternate setting
68 * for the given interface.
69 * @config: the configuration to search (not necessarily the current config).
70 * @iface_num: interface number to search in
71 * @alt_num: alternate interface setting number to search for.
73 * Search the configuration's interface cache for the given alt setting.
75 struct usb_host_interface
*usb_find_alt_setting(
76 struct usb_host_config
*config
,
77 unsigned int iface_num
,
80 struct usb_interface_cache
*intf_cache
= NULL
;
83 for (i
= 0; i
< config
->desc
.bNumInterfaces
; i
++) {
84 if (config
->intf_cache
[i
]->altsetting
[0].desc
.bInterfaceNumber
86 intf_cache
= config
->intf_cache
[i
];
92 for (i
= 0; i
< intf_cache
->num_altsetting
; i
++)
93 if (intf_cache
->altsetting
[i
].desc
.bAlternateSetting
== alt_num
)
94 return &intf_cache
->altsetting
[i
];
96 printk(KERN_DEBUG
"Did not find alt setting %u for intf %u, "
97 "config %u\n", alt_num
, iface_num
,
98 config
->desc
.bConfigurationValue
);
101 EXPORT_SYMBOL_GPL(usb_find_alt_setting
);
104 * usb_ifnum_to_if - get the interface object with a given interface number
105 * @dev: the device whose current configuration is considered
106 * @ifnum: the desired interface
108 * This walks the device descriptor for the currently active configuration
109 * and returns a pointer to the interface with that particular interface
112 * Note that configuration descriptors are not required to assign interface
113 * numbers sequentially, so that it would be incorrect to assume that
114 * the first interface in that descriptor corresponds to interface zero.
115 * This routine helps device drivers avoid such mistakes.
116 * However, you should make sure that you do the right thing with any
117 * alternate settings available for this interfaces.
119 * Don't call this function unless you are bound to one of the interfaces
120 * on this device or you have locked the device!
122 struct usb_interface
*usb_ifnum_to_if(const struct usb_device
*dev
,
125 struct usb_host_config
*config
= dev
->actconfig
;
130 for (i
= 0; i
< config
->desc
.bNumInterfaces
; i
++)
131 if (config
->interface
[i
]->altsetting
[0]
132 .desc
.bInterfaceNumber
== ifnum
)
133 return config
->interface
[i
];
137 EXPORT_SYMBOL_GPL(usb_ifnum_to_if
);
140 * usb_altnum_to_altsetting - get the altsetting structure with a given alternate setting number.
141 * @intf: the interface containing the altsetting in question
142 * @altnum: the desired alternate setting number
144 * This searches the altsetting array of the specified interface for
145 * an entry with the correct bAlternateSetting value and returns a pointer
146 * to that entry, or null.
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.
153 * Don't call this function unless you are bound to the intf interface
154 * or you have locked the device!
156 struct usb_host_interface
*usb_altnum_to_altsetting(
157 const struct usb_interface
*intf
,
162 for (i
= 0; i
< intf
->num_altsetting
; i
++) {
163 if (intf
->altsetting
[i
].desc
.bAlternateSetting
== altnum
)
164 return &intf
->altsetting
[i
];
168 EXPORT_SYMBOL_GPL(usb_altnum_to_altsetting
);
170 struct find_interface_arg
{
172 struct device_driver
*drv
;
175 static int __find_interface(struct device
*dev
, void *data
)
177 struct find_interface_arg
*arg
= data
;
178 struct usb_interface
*intf
;
180 if (!is_usb_interface(dev
))
183 if (dev
->driver
!= arg
->drv
)
185 intf
= to_usb_interface(dev
);
186 return intf
->minor
== arg
->minor
;
190 * usb_find_interface - find usb_interface pointer for driver and device
191 * @drv: the driver whose current configuration is considered
192 * @minor: the minor number of the desired device
194 * This walks the bus device list and returns a pointer to the interface
195 * with the matching minor and driver. Note, this only works for devices
196 * that share the USB major number.
198 struct usb_interface
*usb_find_interface(struct usb_driver
*drv
, int minor
)
200 struct find_interface_arg argb
;
204 argb
.drv
= &drv
->drvwrap
.driver
;
206 dev
= bus_find_device(&usb_bus_type
, NULL
, &argb
, __find_interface
);
208 /* Drop reference count from bus_find_device */
211 return dev
? to_usb_interface(dev
) : NULL
;
213 EXPORT_SYMBOL_GPL(usb_find_interface
);
216 * usb_release_dev - free a usb device structure when all users of it are finished.
217 * @dev: device that's been disconnected
219 * Will be called only by the device core when all users of this usb device are
222 static void usb_release_dev(struct device
*dev
)
224 struct usb_device
*udev
;
227 udev
= to_usb_device(dev
);
228 hcd
= bus_to_hcd(udev
->bus
);
230 usb_destroy_configuration(udev
);
231 /* Root hubs aren't real devices, so don't free HCD resources */
232 if (hcd
->driver
->free_dev
&& udev
->parent
)
233 hcd
->driver
->free_dev(hcd
, udev
);
235 kfree(udev
->product
);
236 kfree(udev
->manufacturer
);
241 #ifdef CONFIG_HOTPLUG
242 static int usb_dev_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
244 struct usb_device
*usb_dev
;
246 usb_dev
= to_usb_device(dev
);
248 if (add_uevent_var(env
, "BUSNUM=%03d", usb_dev
->bus
->busnum
))
251 if (add_uevent_var(env
, "DEVNUM=%03d", usb_dev
->devnum
))
259 static int usb_dev_uevent(struct device
*dev
, struct kobj_uevent_env
*env
)
263 #endif /* CONFIG_HOTPLUG */
267 static int ksuspend_usb_init(void)
269 /* This workqueue is supposed to be both freezable and
270 * singlethreaded. Its job doesn't justify running on more
273 ksuspend_usb_wq
= create_freezeable_workqueue("ksuspend_usbd");
274 if (!ksuspend_usb_wq
)
279 static void ksuspend_usb_cleanup(void)
281 destroy_workqueue(ksuspend_usb_wq
);
284 /* USB device Power-Management thunks.
285 * There's no need to distinguish here between quiescing a USB device
286 * and powering it down; the generic_suspend() routine takes care of
287 * it by skipping the usb_port_suspend() call for a quiesce. And for
288 * USB interfaces there's no difference at all.
291 static int usb_dev_prepare(struct device
*dev
)
293 return 0; /* Implement eventually? */
296 static void usb_dev_complete(struct device
*dev
)
298 /* Currently used only for rebinding interfaces */
299 usb_resume(dev
, PMSG_RESUME
); /* Message event is meaningless */
302 static int usb_dev_suspend(struct device
*dev
)
304 return usb_suspend(dev
, PMSG_SUSPEND
);
307 static int usb_dev_resume(struct device
*dev
)
309 return usb_resume(dev
, PMSG_RESUME
);
312 static int usb_dev_freeze(struct device
*dev
)
314 return usb_suspend(dev
, PMSG_FREEZE
);
317 static int usb_dev_thaw(struct device
*dev
)
319 return usb_resume(dev
, PMSG_THAW
);
322 static int usb_dev_poweroff(struct device
*dev
)
324 return usb_suspend(dev
, PMSG_HIBERNATE
);
327 static int usb_dev_restore(struct device
*dev
)
329 return usb_resume(dev
, PMSG_RESTORE
);
332 static const struct dev_pm_ops usb_device_pm_ops
= {
333 .prepare
= usb_dev_prepare
,
334 .complete
= usb_dev_complete
,
335 .suspend
= usb_dev_suspend
,
336 .resume
= usb_dev_resume
,
337 .freeze
= usb_dev_freeze
,
338 .thaw
= usb_dev_thaw
,
339 .poweroff
= usb_dev_poweroff
,
340 .restore
= usb_dev_restore
,
345 #define ksuspend_usb_init() 0
346 #define ksuspend_usb_cleanup() do {} while (0)
347 #define usb_device_pm_ops (*(struct dev_pm_ops *)0)
349 #endif /* CONFIG_PM */
352 static char *usb_devnode(struct device
*dev
, mode_t
*mode
)
354 struct usb_device
*usb_dev
;
356 usb_dev
= to_usb_device(dev
);
357 return kasprintf(GFP_KERNEL
, "bus/usb/%03d/%03d",
358 usb_dev
->bus
->busnum
, usb_dev
->devnum
);
361 struct device_type usb_device_type
= {
362 .name
= "usb_device",
363 .release
= usb_release_dev
,
364 .uevent
= usb_dev_uevent
,
365 .devnode
= usb_devnode
,
366 .pm
= &usb_device_pm_ops
,
370 /* Returns 1 if @usb_bus is WUSB, 0 otherwise */
371 static unsigned usb_bus_is_wusb(struct usb_bus
*bus
)
373 struct usb_hcd
*hcd
= container_of(bus
, struct usb_hcd
, self
);
374 return hcd
->wireless
;
379 * usb_alloc_dev - usb device constructor (usbcore-internal)
380 * @parent: hub to which device is connected; null to allocate a root hub
381 * @bus: bus used to access the device
382 * @port1: one-based index of port; ignored for root hubs
383 * Context: !in_interrupt()
385 * Only hub drivers (including virtual root hub drivers for host
386 * controllers) should ever call this.
388 * This call may not be used in a non-sleeping context.
390 struct usb_device
*usb_alloc_dev(struct usb_device
*parent
,
391 struct usb_bus
*bus
, unsigned port1
)
393 struct usb_device
*dev
;
394 struct usb_hcd
*usb_hcd
= container_of(bus
, struct usb_hcd
, self
);
395 unsigned root_hub
= 0;
397 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
401 if (!usb_get_hcd(bus_to_hcd(bus
))) {
405 /* Root hubs aren't true devices, so don't allocate HCD resources */
406 if (usb_hcd
->driver
->alloc_dev
&& parent
&&
407 !usb_hcd
->driver
->alloc_dev(usb_hcd
, dev
)) {
408 usb_put_hcd(bus_to_hcd(bus
));
413 device_initialize(&dev
->dev
);
414 dev
->dev
.bus
= &usb_bus_type
;
415 dev
->dev
.type
= &usb_device_type
;
416 dev
->dev
.groups
= usb_device_groups
;
417 dev
->dev
.dma_mask
= bus
->controller
->dma_mask
;
418 set_dev_node(&dev
->dev
, dev_to_node(bus
->controller
));
419 dev
->state
= USB_STATE_ATTACHED
;
420 atomic_set(&dev
->urbnum
, 0);
422 INIT_LIST_HEAD(&dev
->ep0
.urb_list
);
423 dev
->ep0
.desc
.bLength
= USB_DT_ENDPOINT_SIZE
;
424 dev
->ep0
.desc
.bDescriptorType
= USB_DT_ENDPOINT
;
425 /* ep0 maxpacket comes later, from device descriptor */
426 usb_enable_endpoint(dev
, &dev
->ep0
, false);
429 /* Save readable and stable topology id, distinguishing devices
430 * by location for diagnostics, tools, driver model, etc. The
431 * string is a path along hub ports, from the root. Each device's
432 * dev->devpath will be stable until USB is re-cabled, and hubs
433 * are often labeled with these port numbers. The name isn't
434 * as stable: bus->busnum changes easily from modprobe order,
435 * cardbus or pci hotplugging, and so on.
437 if (unlikely(!parent
)) {
438 dev
->devpath
[0] = '0';
441 dev
->dev
.parent
= bus
->controller
;
442 dev_set_name(&dev
->dev
, "usb%d", bus
->busnum
);
445 /* match any labeling on the hubs; it's one-based */
446 if (parent
->devpath
[0] == '0') {
447 snprintf(dev
->devpath
, sizeof dev
->devpath
,
449 /* Root ports are not counted in route string */
452 snprintf(dev
->devpath
, sizeof dev
->devpath
,
453 "%s.%d", parent
->devpath
, port1
);
454 /* Route string assumes hubs have less than 16 ports */
456 dev
->route
= parent
->route
+
457 (port1
<< ((parent
->level
- 1)*4));
459 dev
->route
= parent
->route
+
460 (15 << ((parent
->level
- 1)*4));
463 dev
->dev
.parent
= &parent
->dev
;
464 dev_set_name(&dev
->dev
, "%d-%s", bus
->busnum
, dev
->devpath
);
466 /* hub driver sets up TT records */
469 dev
->portnum
= port1
;
471 dev
->parent
= parent
;
472 INIT_LIST_HEAD(&dev
->filelist
);
475 mutex_init(&dev
->pm_mutex
);
476 INIT_DELAYED_WORK(&dev
->autosuspend
, usb_autosuspend_work
);
477 INIT_WORK(&dev
->autoresume
, usb_autoresume_work
);
478 dev
->autosuspend_delay
= usb_autosuspend_delay
* HZ
;
479 dev
->connect_time
= jiffies
;
480 dev
->active_duration
= -jiffies
;
482 if (root_hub
) /* Root hub always ok [and always wired] */
485 dev
->authorized
= usb_hcd
->authorized_default
;
486 dev
->wusb
= usb_bus_is_wusb(bus
)? 1 : 0;
492 * usb_get_dev - increments the reference count of the usb device structure
493 * @dev: the device being referenced
495 * Each live reference to a device should be refcounted.
497 * Drivers for USB interfaces should normally record such references in
498 * their probe() methods, when they bind to an interface, and release
499 * them by calling usb_put_dev(), in their disconnect() methods.
501 * A pointer to the device with the incremented reference counter is returned.
503 struct usb_device
*usb_get_dev(struct usb_device
*dev
)
506 get_device(&dev
->dev
);
509 EXPORT_SYMBOL_GPL(usb_get_dev
);
512 * usb_put_dev - release a use of the usb device structure
513 * @dev: device that's been disconnected
515 * Must be called when a user of a device is finished with it. When the last
516 * user of the device calls this function, the memory of the device is freed.
518 void usb_put_dev(struct usb_device
*dev
)
521 put_device(&dev
->dev
);
523 EXPORT_SYMBOL_GPL(usb_put_dev
);
526 * usb_get_intf - increments the reference count of the usb interface structure
527 * @intf: the interface being referenced
529 * Each live reference to a interface must be refcounted.
531 * Drivers for USB interfaces should normally record such references in
532 * their probe() methods, when they bind to an interface, and release
533 * them by calling usb_put_intf(), in their disconnect() methods.
535 * A pointer to the interface with the incremented reference counter is
538 struct usb_interface
*usb_get_intf(struct usb_interface
*intf
)
541 get_device(&intf
->dev
);
544 EXPORT_SYMBOL_GPL(usb_get_intf
);
547 * usb_put_intf - release a use of the usb interface structure
548 * @intf: interface that's been decremented
550 * Must be called when a user of an interface is finished with it. When the
551 * last user of the interface calls this function, the memory of the interface
554 void usb_put_intf(struct usb_interface
*intf
)
557 put_device(&intf
->dev
);
559 EXPORT_SYMBOL_GPL(usb_put_intf
);
561 /* USB device locking
563 * USB devices and interfaces are locked using the semaphore in their
564 * embedded struct device. The hub driver guarantees that whenever a
565 * device is connected or disconnected, drivers are called with the
566 * USB device locked as well as their particular interface.
568 * Complications arise when several devices are to be locked at the same
569 * time. Only hub-aware drivers that are part of usbcore ever have to
570 * do this; nobody else needs to worry about it. The rule for locking
573 * When locking both a device and its parent, always lock the
578 * usb_lock_device_for_reset - cautiously acquire the lock for a usb device structure
579 * @udev: device that's being locked
580 * @iface: interface bound to the driver making the request (optional)
582 * Attempts to acquire the device lock, but fails if the device is
583 * NOTATTACHED or SUSPENDED, or if iface is specified and the interface
584 * is neither BINDING nor BOUND. Rather than sleeping to wait for the
585 * lock, the routine polls repeatedly. This is to prevent deadlock with
586 * disconnect; in some drivers (such as usb-storage) the disconnect()
587 * or suspend() method will block waiting for a device reset to complete.
589 * Returns a negative error code for failure, otherwise 0.
591 int usb_lock_device_for_reset(struct usb_device
*udev
,
592 const struct usb_interface
*iface
)
594 unsigned long jiffies_expire
= jiffies
+ HZ
;
596 if (udev
->state
== USB_STATE_NOTATTACHED
)
598 if (udev
->state
== USB_STATE_SUSPENDED
)
599 return -EHOSTUNREACH
;
600 if (iface
&& (iface
->condition
== USB_INTERFACE_UNBINDING
||
601 iface
->condition
== USB_INTERFACE_UNBOUND
))
604 while (usb_trylock_device(udev
) != 0) {
606 /* If we can't acquire the lock after waiting one second,
607 * we're probably deadlocked */
608 if (time_after(jiffies
, jiffies_expire
))
612 if (udev
->state
== USB_STATE_NOTATTACHED
)
614 if (udev
->state
== USB_STATE_SUSPENDED
)
615 return -EHOSTUNREACH
;
616 if (iface
&& (iface
->condition
== USB_INTERFACE_UNBINDING
||
617 iface
->condition
== USB_INTERFACE_UNBOUND
))
622 EXPORT_SYMBOL_GPL(usb_lock_device_for_reset
);
624 static struct usb_device
*match_device(struct usb_device
*dev
,
625 u16 vendor_id
, u16 product_id
)
627 struct usb_device
*ret_dev
= NULL
;
630 dev_dbg(&dev
->dev
, "check for vendor %04x, product %04x ...\n",
631 le16_to_cpu(dev
->descriptor
.idVendor
),
632 le16_to_cpu(dev
->descriptor
.idProduct
));
634 /* see if this device matches */
635 if ((vendor_id
== le16_to_cpu(dev
->descriptor
.idVendor
)) &&
636 (product_id
== le16_to_cpu(dev
->descriptor
.idProduct
))) {
637 dev_dbg(&dev
->dev
, "matched this device!\n");
638 ret_dev
= usb_get_dev(dev
);
642 /* look through all of the children of this device */
643 for (child
= 0; child
< dev
->maxchild
; ++child
) {
644 if (dev
->children
[child
]) {
645 usb_lock_device(dev
->children
[child
]);
646 ret_dev
= match_device(dev
->children
[child
],
647 vendor_id
, product_id
);
648 usb_unlock_device(dev
->children
[child
]);
658 * usb_find_device - find a specific usb device in the system
659 * @vendor_id: the vendor id of the device to find
660 * @product_id: the product id of the device to find
662 * Returns a pointer to a struct usb_device if such a specified usb
663 * device is present in the system currently. The usage count of the
664 * device will be incremented if a device is found. Make sure to call
665 * usb_put_dev() when the caller is finished with the device.
667 * If a device with the specified vendor and product id is not found,
670 struct usb_device
*usb_find_device(u16 vendor_id
, u16 product_id
)
672 struct list_head
*buslist
;
674 struct usb_device
*dev
= NULL
;
676 mutex_lock(&usb_bus_list_lock
);
677 for (buslist
= usb_bus_list
.next
;
678 buslist
!= &usb_bus_list
;
679 buslist
= buslist
->next
) {
680 bus
= container_of(buslist
, struct usb_bus
, bus_list
);
683 usb_lock_device(bus
->root_hub
);
684 dev
= match_device(bus
->root_hub
, vendor_id
, product_id
);
685 usb_unlock_device(bus
->root_hub
);
690 mutex_unlock(&usb_bus_list_lock
);
695 * usb_get_current_frame_number - return current bus frame number
696 * @dev: the device whose bus is being queried
698 * Returns the current frame number for the USB host controller
699 * used with the given USB device. This can be used when scheduling
700 * isochronous requests.
702 * Note that different kinds of host controller have different
703 * "scheduling horizons". While one type might support scheduling only
704 * 32 frames into the future, others could support scheduling up to
705 * 1024 frames into the future.
707 int usb_get_current_frame_number(struct usb_device
*dev
)
709 return usb_hcd_get_frame_number(dev
);
711 EXPORT_SYMBOL_GPL(usb_get_current_frame_number
);
713 /*-------------------------------------------------------------------*/
715 * __usb_get_extra_descriptor() finds a descriptor of specific type in the
716 * extra field of the interface and endpoint descriptor structs.
719 int __usb_get_extra_descriptor(char *buffer
, unsigned size
,
720 unsigned char type
, void **ptr
)
722 struct usb_descriptor_header
*header
;
724 while (size
>= sizeof(struct usb_descriptor_header
)) {
725 header
= (struct usb_descriptor_header
*)buffer
;
727 if (header
->bLength
< 2) {
729 "%s: bogus descriptor, type %d length %d\n",
731 header
->bDescriptorType
,
736 if (header
->bDescriptorType
== type
) {
741 buffer
+= header
->bLength
;
742 size
-= header
->bLength
;
746 EXPORT_SYMBOL_GPL(__usb_get_extra_descriptor
);
749 * usb_buffer_alloc - allocate dma-consistent buffer for URB_NO_xxx_DMA_MAP
750 * @dev: device the buffer will be used with
751 * @size: requested buffer size
752 * @mem_flags: affect whether allocation may block
753 * @dma: used to return DMA address of buffer
755 * Return value is either null (indicating no buffer could be allocated), or
756 * the cpu-space pointer to a buffer that may be used to perform DMA to the
757 * specified device. Such cpu-space buffers are returned along with the DMA
758 * address (through the pointer provided).
760 * These buffers are used with URB_NO_xxx_DMA_MAP set in urb->transfer_flags
761 * to avoid behaviors like using "DMA bounce buffers", or thrashing IOMMU
762 * hardware during URB completion/resubmit. The implementation varies between
763 * platforms, depending on details of how DMA will work to this device.
764 * Using these buffers also eliminates cacheline sharing problems on
765 * architectures where CPU caches are not DMA-coherent. On systems without
766 * bus-snooping caches, these buffers are uncached.
768 * When the buffer is no longer used, free it with usb_buffer_free().
770 void *usb_buffer_alloc(struct usb_device
*dev
, size_t size
, gfp_t mem_flags
,
773 if (!dev
|| !dev
->bus
)
775 return hcd_buffer_alloc(dev
->bus
, size
, mem_flags
, dma
);
777 EXPORT_SYMBOL_GPL(usb_buffer_alloc
);
780 * usb_buffer_free - free memory allocated with usb_buffer_alloc()
781 * @dev: device the buffer was used with
782 * @size: requested buffer size
783 * @addr: CPU address of buffer
784 * @dma: DMA address of buffer
786 * This reclaims an I/O buffer, letting it be reused. The memory must have
787 * been allocated using usb_buffer_alloc(), and the parameters must match
788 * those provided in that allocation request.
790 void usb_buffer_free(struct usb_device
*dev
, size_t size
, void *addr
,
793 if (!dev
|| !dev
->bus
)
797 hcd_buffer_free(dev
->bus
, size
, addr
, dma
);
799 EXPORT_SYMBOL_GPL(usb_buffer_free
);
802 * usb_buffer_map - create DMA mapping(s) for an urb
803 * @urb: urb whose transfer_buffer/setup_packet will be mapped
805 * Return value is either null (indicating no buffer could be mapped), or
806 * the parameter. URB_NO_TRANSFER_DMA_MAP and URB_NO_SETUP_DMA_MAP are
807 * added to urb->transfer_flags if the operation succeeds. If the device
808 * is connected to this system through a non-DMA controller, this operation
811 * This call would normally be used for an urb which is reused, perhaps
812 * as the target of a large periodic transfer, with usb_buffer_dmasync()
813 * calls to synchronize memory and dma state.
815 * Reverse the effect of this call with usb_buffer_unmap().
818 struct urb
*usb_buffer_map(struct urb
*urb
)
821 struct device
*controller
;
825 || !(bus
= urb
->dev
->bus
)
826 || !(controller
= bus
->controller
))
829 if (controller
->dma_mask
) {
830 urb
->transfer_dma
= dma_map_single(controller
,
831 urb
->transfer_buffer
, urb
->transfer_buffer_length
,
832 usb_pipein(urb
->pipe
)
833 ? DMA_FROM_DEVICE
: DMA_TO_DEVICE
);
834 if (usb_pipecontrol(urb
->pipe
))
835 urb
->setup_dma
= dma_map_single(controller
,
837 sizeof(struct usb_ctrlrequest
),
839 /* FIXME generic api broken like pci, can't report errors */
840 /* if (urb->transfer_dma == DMA_ADDR_INVALID) return 0; */
842 urb
->transfer_dma
= ~0;
843 urb
->transfer_flags
|= (URB_NO_TRANSFER_DMA_MAP
844 | URB_NO_SETUP_DMA_MAP
);
847 EXPORT_SYMBOL_GPL(usb_buffer_map
);
850 /* XXX DISABLED, no users currently. If you wish to re-enable this
851 * XXX please determine whether the sync is to transfer ownership of
852 * XXX the buffer from device to cpu or vice verse, and thusly use the
853 * XXX appropriate _for_{cpu,device}() method. -DaveM
858 * usb_buffer_dmasync - synchronize DMA and CPU view of buffer(s)
859 * @urb: urb whose transfer_buffer/setup_packet will be synchronized
861 void usb_buffer_dmasync(struct urb
*urb
)
864 struct device
*controller
;
867 || !(urb
->transfer_flags
& URB_NO_TRANSFER_DMA_MAP
)
869 || !(bus
= urb
->dev
->bus
)
870 || !(controller
= bus
->controller
))
873 if (controller
->dma_mask
) {
874 dma_sync_single_for_cpu(controller
,
875 urb
->transfer_dma
, urb
->transfer_buffer_length
,
876 usb_pipein(urb
->pipe
)
877 ? DMA_FROM_DEVICE
: DMA_TO_DEVICE
);
878 if (usb_pipecontrol(urb
->pipe
))
879 dma_sync_single_for_cpu(controller
,
881 sizeof(struct usb_ctrlrequest
),
885 EXPORT_SYMBOL_GPL(usb_buffer_dmasync
);
889 * usb_buffer_unmap - free DMA mapping(s) for an urb
890 * @urb: urb whose transfer_buffer will be unmapped
892 * Reverses the effect of usb_buffer_map().
895 void usb_buffer_unmap(struct urb
*urb
)
898 struct device
*controller
;
901 || !(urb
->transfer_flags
& URB_NO_TRANSFER_DMA_MAP
)
903 || !(bus
= urb
->dev
->bus
)
904 || !(controller
= bus
->controller
))
907 if (controller
->dma_mask
) {
908 dma_unmap_single(controller
,
909 urb
->transfer_dma
, urb
->transfer_buffer_length
,
910 usb_pipein(urb
->pipe
)
911 ? DMA_FROM_DEVICE
: DMA_TO_DEVICE
);
912 if (usb_pipecontrol(urb
->pipe
))
913 dma_unmap_single(controller
,
915 sizeof(struct usb_ctrlrequest
),
918 urb
->transfer_flags
&= ~(URB_NO_TRANSFER_DMA_MAP
919 | URB_NO_SETUP_DMA_MAP
);
921 EXPORT_SYMBOL_GPL(usb_buffer_unmap
);
925 * usb_buffer_map_sg - create scatterlist DMA mapping(s) for an endpoint
926 * @dev: device to which the scatterlist will be mapped
927 * @is_in: mapping transfer direction
928 * @sg: the scatterlist to map
929 * @nents: the number of entries in the scatterlist
931 * Return value is either < 0 (indicating no buffers could be mapped), or
932 * the number of DMA mapping array entries in the scatterlist.
934 * The caller is responsible for placing the resulting DMA addresses from
935 * the scatterlist into URB transfer buffer pointers, and for setting the
936 * URB_NO_TRANSFER_DMA_MAP transfer flag in each of those URBs.
938 * Top I/O rates come from queuing URBs, instead of waiting for each one
939 * to complete before starting the next I/O. This is particularly easy
940 * to do with scatterlists. Just allocate and submit one URB for each DMA
941 * mapping entry returned, stopping on the first error or when all succeed.
942 * Better yet, use the usb_sg_*() calls, which do that (and more) for you.
944 * This call would normally be used when translating scatterlist requests,
945 * rather than usb_buffer_map(), since on some hardware (with IOMMUs) it
946 * may be able to coalesce mappings for improved I/O efficiency.
948 * Reverse the effect of this call with usb_buffer_unmap_sg().
950 int usb_buffer_map_sg(const struct usb_device
*dev
, int is_in
,
951 struct scatterlist
*sg
, int nents
)
954 struct device
*controller
;
958 || !(controller
= bus
->controller
)
959 || !controller
->dma_mask
)
962 /* FIXME generic api broken like pci, can't report errors */
963 return dma_map_sg(controller
, sg
, nents
,
964 is_in
? DMA_FROM_DEVICE
: DMA_TO_DEVICE
) ? : -ENOMEM
;
966 EXPORT_SYMBOL_GPL(usb_buffer_map_sg
);
968 /* XXX DISABLED, no users currently. If you wish to re-enable this
969 * XXX please determine whether the sync is to transfer ownership of
970 * XXX the buffer from device to cpu or vice verse, and thusly use the
971 * XXX appropriate _for_{cpu,device}() method. -DaveM
976 * usb_buffer_dmasync_sg - synchronize DMA and CPU view of scatterlist buffer(s)
977 * @dev: device to which the scatterlist will be mapped
978 * @is_in: mapping transfer direction
979 * @sg: the scatterlist to synchronize
980 * @n_hw_ents: the positive return value from usb_buffer_map_sg
982 * Use this when you are re-using a scatterlist's data buffers for
983 * another USB request.
985 void usb_buffer_dmasync_sg(const struct usb_device
*dev
, int is_in
,
986 struct scatterlist
*sg
, int n_hw_ents
)
989 struct device
*controller
;
993 || !(controller
= bus
->controller
)
994 || !controller
->dma_mask
)
997 dma_sync_sg_for_cpu(controller
, sg
, n_hw_ents
,
998 is_in
? DMA_FROM_DEVICE
: DMA_TO_DEVICE
);
1000 EXPORT_SYMBOL_GPL(usb_buffer_dmasync_sg
);
1004 * usb_buffer_unmap_sg - free DMA mapping(s) for a scatterlist
1005 * @dev: device to which the scatterlist will be mapped
1006 * @is_in: mapping transfer direction
1007 * @sg: the scatterlist to unmap
1008 * @n_hw_ents: the positive return value from usb_buffer_map_sg
1010 * Reverses the effect of usb_buffer_map_sg().
1012 void usb_buffer_unmap_sg(const struct usb_device
*dev
, int is_in
,
1013 struct scatterlist
*sg
, int n_hw_ents
)
1015 struct usb_bus
*bus
;
1016 struct device
*controller
;
1019 || !(bus
= dev
->bus
)
1020 || !(controller
= bus
->controller
)
1021 || !controller
->dma_mask
)
1024 dma_unmap_sg(controller
, sg
, n_hw_ents
,
1025 is_in
? DMA_FROM_DEVICE
: DMA_TO_DEVICE
);
1027 EXPORT_SYMBOL_GPL(usb_buffer_unmap_sg
);
1029 /* To disable USB, kernel command line is 'nousb' not 'usbcore.nousb' */
1031 module_param(nousb
, bool, 0444);
1033 core_param(nousb
, nousb
, bool, 0444);
1037 * for external read access to <nousb>
1039 int usb_disabled(void)
1043 EXPORT_SYMBOL_GPL(usb_disabled
);
1046 * Notifications of device and interface registration
1048 static int usb_bus_notify(struct notifier_block
*nb
, unsigned long action
,
1051 struct device
*dev
= data
;
1054 case BUS_NOTIFY_ADD_DEVICE
:
1055 if (dev
->type
== &usb_device_type
)
1056 (void) usb_create_sysfs_dev_files(to_usb_device(dev
));
1057 else if (dev
->type
== &usb_if_device_type
)
1058 (void) usb_create_sysfs_intf_files(
1059 to_usb_interface(dev
));
1062 case BUS_NOTIFY_DEL_DEVICE
:
1063 if (dev
->type
== &usb_device_type
)
1064 usb_remove_sysfs_dev_files(to_usb_device(dev
));
1065 else if (dev
->type
== &usb_if_device_type
)
1066 usb_remove_sysfs_intf_files(to_usb_interface(dev
));
1072 static struct notifier_block usb_bus_nb
= {
1073 .notifier_call
= usb_bus_notify
,
1076 struct dentry
*usb_debug_root
;
1077 EXPORT_SYMBOL_GPL(usb_debug_root
);
1079 static struct dentry
*usb_debug_devices
;
1081 static int usb_debugfs_init(void)
1083 usb_debug_root
= debugfs_create_dir("usb", NULL
);
1084 if (!usb_debug_root
)
1087 usb_debug_devices
= debugfs_create_file("devices", 0444,
1088 usb_debug_root
, NULL
,
1089 &usbfs_devices_fops
);
1090 if (!usb_debug_devices
) {
1091 debugfs_remove(usb_debug_root
);
1092 usb_debug_root
= NULL
;
1099 static void usb_debugfs_cleanup(void)
1101 debugfs_remove(usb_debug_devices
);
1102 debugfs_remove(usb_debug_root
);
1108 static int __init
usb_init(void)
1112 pr_info("%s: USB support disabled\n", usbcore_name
);
1116 retval
= usb_debugfs_init();
1120 retval
= ksuspend_usb_init();
1123 retval
= bus_register(&usb_bus_type
);
1125 goto bus_register_failed
;
1126 retval
= bus_register_notifier(&usb_bus_type
, &usb_bus_nb
);
1128 goto bus_notifier_failed
;
1129 retval
= usb_major_init();
1131 goto major_init_failed
;
1132 retval
= usb_register(&usbfs_driver
);
1134 goto driver_register_failed
;
1135 retval
= usb_devio_init();
1137 goto usb_devio_init_failed
;
1138 retval
= usbfs_init();
1140 goto fs_init_failed
;
1141 retval
= usb_hub_init();
1143 goto hub_init_failed
;
1144 retval
= usb_register_device_driver(&usb_generic_driver
, THIS_MODULE
);
1152 usb_devio_cleanup();
1153 usb_devio_init_failed
:
1154 usb_deregister(&usbfs_driver
);
1155 driver_register_failed
:
1156 usb_major_cleanup();
1158 bus_unregister_notifier(&usb_bus_type
, &usb_bus_nb
);
1159 bus_notifier_failed
:
1160 bus_unregister(&usb_bus_type
);
1161 bus_register_failed
:
1162 ksuspend_usb_cleanup();
1170 static void __exit
usb_exit(void)
1172 /* This will matter if shutdown/reboot does exitcalls. */
1176 usb_deregister_device_driver(&usb_generic_driver
);
1177 usb_major_cleanup();
1179 usb_deregister(&usbfs_driver
);
1180 usb_devio_cleanup();
1182 bus_unregister_notifier(&usb_bus_type
, &usb_bus_nb
);
1183 bus_unregister(&usb_bus_type
);
1184 ksuspend_usb_cleanup();
1185 usb_debugfs_cleanup();
1188 subsys_initcall(usb_init
);
1189 module_exit(usb_exit
);
1190 MODULE_LICENSE("GPL");