Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[linux-2.6] / drivers / usb / core / usb.c
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/mutex.h>
36 #include <linux/workqueue.h>
37
38 #include <asm/io.h>
39 #include <asm/scatterlist.h>
40 #include <linux/mm.h>
41 #include <linux/dma-mapping.h>
42
43 #include "hcd.h"
44 #include "usb.h"
45
46
47 const char *usbcore_name = "usbcore";
48
49 static int nousb;       /* Disable USB when built into kernel image */
50
51 /* Workqueue for autosuspend and for remote wakeup of root hubs */
52 struct workqueue_struct *ksuspend_usb_wq;
53
54 #ifdef  CONFIG_USB_SUSPEND
55 static int usb_autosuspend_delay = 2;           /* Default delay value,
56                                                  * in seconds */
57 module_param_named(autosuspend, usb_autosuspend_delay, int, 0644);
58 MODULE_PARM_DESC(autosuspend, "default autosuspend delay");
59
60 #else
61 #define usb_autosuspend_delay           0
62 #endif
63
64
65 /**
66  * usb_ifnum_to_if - get the interface object with a given interface number
67  * @dev: the device whose current configuration is considered
68  * @ifnum: the desired interface
69  *
70  * This walks the device descriptor for the currently active configuration
71  * and returns a pointer to the interface with that particular interface
72  * number, or null.
73  *
74  * Note that configuration descriptors are not required to assign interface
75  * numbers sequentially, so that it would be incorrect to assume that
76  * the first interface in that descriptor corresponds to interface zero.
77  * This routine helps device drivers avoid such mistakes.
78  * However, you should make sure that you do the right thing with any
79  * alternate settings available for this interfaces.
80  *
81  * Don't call this function unless you are bound to one of the interfaces
82  * on this device or you have locked the device!
83  */
84 struct usb_interface *usb_ifnum_to_if(const struct usb_device *dev,
85                                       unsigned ifnum)
86 {
87         struct usb_host_config *config = dev->actconfig;
88         int i;
89
90         if (!config)
91                 return NULL;
92         for (i = 0; i < config->desc.bNumInterfaces; i++)
93                 if (config->interface[i]->altsetting[0]
94                                 .desc.bInterfaceNumber == ifnum)
95                         return config->interface[i];
96
97         return NULL;
98 }
99
100 /**
101  * usb_altnum_to_altsetting - get the altsetting structure with a given
102  *      alternate setting number.
103  * @intf: the interface containing the altsetting in question
104  * @altnum: the desired alternate setting number
105  *
106  * This searches the altsetting array of the specified interface for
107  * an entry with the correct bAlternateSetting value and returns a pointer
108  * to that entry, or null.
109  *
110  * Note that altsettings need not be stored sequentially by number, so
111  * it would be incorrect to assume that the first altsetting entry in
112  * the array corresponds to altsetting zero.  This routine helps device
113  * drivers avoid such mistakes.
114  *
115  * Don't call this function unless you are bound to the intf interface
116  * or you have locked the device!
117  */
118 struct usb_host_interface *usb_altnum_to_altsetting(const struct usb_interface *intf,
119                                                     unsigned int altnum)
120 {
121         int i;
122
123         for (i = 0; i < intf->num_altsetting; i++) {
124                 if (intf->altsetting[i].desc.bAlternateSetting == altnum)
125                         return &intf->altsetting[i];
126         }
127         return NULL;
128 }
129
130 struct find_interface_arg {
131         int minor;
132         struct usb_interface *interface;
133 };
134
135 static int __find_interface(struct device * dev, void * data)
136 {
137         struct find_interface_arg *arg = data;
138         struct usb_interface *intf;
139
140         /* can't look at usb devices, only interfaces */
141         if (is_usb_device(dev))
142                 return 0;
143
144         intf = to_usb_interface(dev);
145         if (intf->minor != -1 && intf->minor == arg->minor) {
146                 arg->interface = intf;
147                 return 1;
148         }
149         return 0;
150 }
151
152 /**
153  * usb_find_interface - find usb_interface pointer for driver and device
154  * @drv: the driver whose current configuration is considered
155  * @minor: the minor number of the desired device
156  *
157  * This walks the driver device list and returns a pointer to the interface 
158  * with the matching minor.  Note, this only works for devices that share the
159  * USB major number.
160  */
161 struct usb_interface *usb_find_interface(struct usb_driver *drv, int minor)
162 {
163         struct find_interface_arg argb;
164         int retval;
165
166         argb.minor = minor;
167         argb.interface = NULL;
168         /* eat the error, it will be in argb.interface */
169         retval = driver_for_each_device(&drv->drvwrap.driver, NULL, &argb,
170                                         __find_interface);
171         return argb.interface;
172 }
173
174 /**
175  * usb_release_dev - free a usb device structure when all users of it are finished.
176  * @dev: device that's been disconnected
177  *
178  * Will be called only by the device core when all users of this usb device are
179  * done.
180  */
181 static void usb_release_dev(struct device *dev)
182 {
183         struct usb_device *udev;
184
185         udev = to_usb_device(dev);
186
187 #ifdef  CONFIG_USB_SUSPEND
188         cancel_delayed_work(&udev->autosuspend);
189         flush_workqueue(ksuspend_usb_wq);
190 #endif
191         usb_destroy_configuration(udev);
192         usb_put_hcd(bus_to_hcd(udev->bus));
193         kfree(udev->product);
194         kfree(udev->manufacturer);
195         kfree(udev->serial);
196         kfree(udev);
197 }
198
199 struct device_type usb_device_type = {
200         .name =         "usb_device",
201         .release =      usb_release_dev,
202 };
203
204 #ifdef  CONFIG_PM
205
206 static int ksuspend_usb_init(void)
207 {
208         ksuspend_usb_wq = create_singlethread_workqueue("ksuspend_usbd");
209         if (!ksuspend_usb_wq)
210                 return -ENOMEM;
211         return 0;
212 }
213
214 static void ksuspend_usb_cleanup(void)
215 {
216         destroy_workqueue(ksuspend_usb_wq);
217 }
218
219 #else
220
221 #define ksuspend_usb_init()     0
222 #define ksuspend_usb_cleanup()  do {} while (0)
223
224 #endif  /* CONFIG_PM */
225
226 /**
227  * usb_alloc_dev - usb device constructor (usbcore-internal)
228  * @parent: hub to which device is connected; null to allocate a root hub
229  * @bus: bus used to access the device
230  * @port1: one-based index of port; ignored for root hubs
231  * Context: !in_interrupt()
232  *
233  * Only hub drivers (including virtual root hub drivers for host
234  * controllers) should ever call this.
235  *
236  * This call may not be used in a non-sleeping context.
237  */
238 struct usb_device *
239 usb_alloc_dev(struct usb_device *parent, struct usb_bus *bus, unsigned port1)
240 {
241         struct usb_device *dev;
242
243         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
244         if (!dev)
245                 return NULL;
246
247         if (!usb_get_hcd(bus_to_hcd(bus))) {
248                 kfree(dev);
249                 return NULL;
250         }
251
252         device_initialize(&dev->dev);
253         dev->dev.bus = &usb_bus_type;
254         dev->dev.type = &usb_device_type;
255         dev->dev.dma_mask = bus->controller->dma_mask;
256         dev->state = USB_STATE_ATTACHED;
257
258         INIT_LIST_HEAD(&dev->ep0.urb_list);
259         dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE;
260         dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT;
261         /* ep0 maxpacket comes later, from device descriptor */
262         dev->ep_in[0] = dev->ep_out[0] = &dev->ep0;
263
264         /* Save readable and stable topology id, distinguishing devices
265          * by location for diagnostics, tools, driver model, etc.  The
266          * string is a path along hub ports, from the root.  Each device's
267          * dev->devpath will be stable until USB is re-cabled, and hubs
268          * are often labeled with these port numbers.  The bus_id isn't
269          * as stable:  bus->busnum changes easily from modprobe order,
270          * cardbus or pci hotplugging, and so on.
271          */
272         if (unlikely(!parent)) {
273                 dev->devpath[0] = '0';
274
275                 dev->dev.parent = bus->controller;
276                 sprintf(&dev->dev.bus_id[0], "usb%d", bus->busnum);
277         } else {
278                 /* match any labeling on the hubs; it's one-based */
279                 if (parent->devpath[0] == '0')
280                         snprintf(dev->devpath, sizeof dev->devpath,
281                                 "%d", port1);
282                 else
283                         snprintf(dev->devpath, sizeof dev->devpath,
284                                 "%s.%d", parent->devpath, port1);
285
286                 dev->dev.parent = &parent->dev;
287                 sprintf(&dev->dev.bus_id[0], "%d-%s",
288                         bus->busnum, dev->devpath);
289
290                 /* hub driver sets up TT records */
291         }
292
293         dev->portnum = port1;
294         dev->bus = bus;
295         dev->parent = parent;
296         INIT_LIST_HEAD(&dev->filelist);
297
298 #ifdef  CONFIG_PM
299         mutex_init(&dev->pm_mutex);
300         INIT_DELAYED_WORK(&dev->autosuspend, usb_autosuspend_work);
301         dev->autosuspend_delay = usb_autosuspend_delay * HZ;
302 #endif
303         return dev;
304 }
305
306 /**
307  * usb_get_dev - increments the reference count of the usb device structure
308  * @dev: the device being referenced
309  *
310  * Each live reference to a device should be refcounted.
311  *
312  * Drivers for USB interfaces should normally record such references in
313  * their probe() methods, when they bind to an interface, and release
314  * them by calling usb_put_dev(), in their disconnect() methods.
315  *
316  * A pointer to the device with the incremented reference counter is returned.
317  */
318 struct usb_device *usb_get_dev(struct usb_device *dev)
319 {
320         if (dev)
321                 get_device(&dev->dev);
322         return dev;
323 }
324
325 /**
326  * usb_put_dev - release a use of the usb device structure
327  * @dev: device that's been disconnected
328  *
329  * Must be called when a user of a device is finished with it.  When the last
330  * user of the device calls this function, the memory of the device is freed.
331  */
332 void usb_put_dev(struct usb_device *dev)
333 {
334         if (dev)
335                 put_device(&dev->dev);
336 }
337
338 /**
339  * usb_get_intf - increments the reference count of the usb interface structure
340  * @intf: the interface being referenced
341  *
342  * Each live reference to a interface must be refcounted.
343  *
344  * Drivers for USB interfaces should normally record such references in
345  * their probe() methods, when they bind to an interface, and release
346  * them by calling usb_put_intf(), in their disconnect() methods.
347  *
348  * A pointer to the interface with the incremented reference counter is
349  * returned.
350  */
351 struct usb_interface *usb_get_intf(struct usb_interface *intf)
352 {
353         if (intf)
354                 get_device(&intf->dev);
355         return intf;
356 }
357
358 /**
359  * usb_put_intf - release a use of the usb interface structure
360  * @intf: interface that's been decremented
361  *
362  * Must be called when a user of an interface is finished with it.  When the
363  * last user of the interface calls this function, the memory of the interface
364  * is freed.
365  */
366 void usb_put_intf(struct usb_interface *intf)
367 {
368         if (intf)
369                 put_device(&intf->dev);
370 }
371
372
373 /*                      USB device locking
374  *
375  * USB devices and interfaces are locked using the semaphore in their
376  * embedded struct device.  The hub driver guarantees that whenever a
377  * device is connected or disconnected, drivers are called with the
378  * USB device locked as well as their particular interface.
379  *
380  * Complications arise when several devices are to be locked at the same
381  * time.  Only hub-aware drivers that are part of usbcore ever have to
382  * do this; nobody else needs to worry about it.  The rule for locking
383  * is simple:
384  *
385  *      When locking both a device and its parent, always lock the
386  *      the parent first.
387  */
388
389 /**
390  * usb_lock_device_for_reset - cautiously acquire the lock for a
391  *      usb device structure
392  * @udev: device that's being locked
393  * @iface: interface bound to the driver making the request (optional)
394  *
395  * Attempts to acquire the device lock, but fails if the device is
396  * NOTATTACHED or SUSPENDED, or if iface is specified and the interface
397  * is neither BINDING nor BOUND.  Rather than sleeping to wait for the
398  * lock, the routine polls repeatedly.  This is to prevent deadlock with
399  * disconnect; in some drivers (such as usb-storage) the disconnect()
400  * or suspend() method will block waiting for a device reset to complete.
401  *
402  * Returns a negative error code for failure, otherwise 1 or 0 to indicate
403  * that the device will or will not have to be unlocked.  (0 can be
404  * returned when an interface is given and is BINDING, because in that
405  * case the driver already owns the device lock.)
406  */
407 int usb_lock_device_for_reset(struct usb_device *udev,
408                               const struct usb_interface *iface)
409 {
410         unsigned long jiffies_expire = jiffies + HZ;
411
412         if (udev->state == USB_STATE_NOTATTACHED)
413                 return -ENODEV;
414         if (udev->state == USB_STATE_SUSPENDED)
415                 return -EHOSTUNREACH;
416         if (iface) {
417                 switch (iface->condition) {
418                   case USB_INTERFACE_BINDING:
419                         return 0;
420                   case USB_INTERFACE_BOUND:
421                         break;
422                   default:
423                         return -EINTR;
424                 }
425         }
426
427         while (usb_trylock_device(udev) != 0) {
428
429                 /* If we can't acquire the lock after waiting one second,
430                  * we're probably deadlocked */
431                 if (time_after(jiffies, jiffies_expire))
432                         return -EBUSY;
433
434                 msleep(15);
435                 if (udev->state == USB_STATE_NOTATTACHED)
436                         return -ENODEV;
437                 if (udev->state == USB_STATE_SUSPENDED)
438                         return -EHOSTUNREACH;
439                 if (iface && iface->condition != USB_INTERFACE_BOUND)
440                         return -EINTR;
441         }
442         return 1;
443 }
444
445
446 static struct usb_device *match_device(struct usb_device *dev,
447                                        u16 vendor_id, u16 product_id)
448 {
449         struct usb_device *ret_dev = NULL;
450         int child;
451
452         dev_dbg(&dev->dev, "check for vendor %04x, product %04x ...\n",
453             le16_to_cpu(dev->descriptor.idVendor),
454             le16_to_cpu(dev->descriptor.idProduct));
455
456         /* see if this device matches */
457         if ((vendor_id == le16_to_cpu(dev->descriptor.idVendor)) &&
458             (product_id == le16_to_cpu(dev->descriptor.idProduct))) {
459                 dev_dbg(&dev->dev, "matched this device!\n");
460                 ret_dev = usb_get_dev(dev);
461                 goto exit;
462         }
463
464         /* look through all of the children of this device */
465         for (child = 0; child < dev->maxchild; ++child) {
466                 if (dev->children[child]) {
467                         usb_lock_device(dev->children[child]);
468                         ret_dev = match_device(dev->children[child],
469                                                vendor_id, product_id);
470                         usb_unlock_device(dev->children[child]);
471                         if (ret_dev)
472                                 goto exit;
473                 }
474         }
475 exit:
476         return ret_dev;
477 }
478
479 /**
480  * usb_find_device - find a specific usb device in the system
481  * @vendor_id: the vendor id of the device to find
482  * @product_id: the product id of the device to find
483  *
484  * Returns a pointer to a struct usb_device if such a specified usb
485  * device is present in the system currently.  The usage count of the
486  * device will be incremented if a device is found.  Make sure to call
487  * usb_put_dev() when the caller is finished with the device.
488  *
489  * If a device with the specified vendor and product id is not found,
490  * NULL is returned.
491  */
492 struct usb_device *usb_find_device(u16 vendor_id, u16 product_id)
493 {
494         struct list_head *buslist;
495         struct usb_bus *bus;
496         struct usb_device *dev = NULL;
497         
498         mutex_lock(&usb_bus_list_lock);
499         for (buslist = usb_bus_list.next;
500              buslist != &usb_bus_list; 
501              buslist = buslist->next) {
502                 bus = container_of(buslist, struct usb_bus, bus_list);
503                 if (!bus->root_hub)
504                         continue;
505                 usb_lock_device(bus->root_hub);
506                 dev = match_device(bus->root_hub, vendor_id, product_id);
507                 usb_unlock_device(bus->root_hub);
508                 if (dev)
509                         goto exit;
510         }
511 exit:
512         mutex_unlock(&usb_bus_list_lock);
513         return dev;
514 }
515
516 /**
517  * usb_get_current_frame_number - return current bus frame number
518  * @dev: the device whose bus is being queried
519  *
520  * Returns the current frame number for the USB host controller
521  * used with the given USB device.  This can be used when scheduling
522  * isochronous requests.
523  *
524  * Note that different kinds of host controller have different
525  * "scheduling horizons".  While one type might support scheduling only
526  * 32 frames into the future, others could support scheduling up to
527  * 1024 frames into the future.
528  */
529 int usb_get_current_frame_number(struct usb_device *dev)
530 {
531         return usb_hcd_get_frame_number(dev);
532 }
533
534 /*-------------------------------------------------------------------*/
535 /*
536  * __usb_get_extra_descriptor() finds a descriptor of specific type in the
537  * extra field of the interface and endpoint descriptor structs.
538  */
539
540 int __usb_get_extra_descriptor(char *buffer, unsigned size,
541         unsigned char type, void **ptr)
542 {
543         struct usb_descriptor_header *header;
544
545         while (size >= sizeof(struct usb_descriptor_header)) {
546                 header = (struct usb_descriptor_header *)buffer;
547
548                 if (header->bLength < 2) {
549                         printk(KERN_ERR
550                                 "%s: bogus descriptor, type %d length %d\n",
551                                 usbcore_name,
552                                 header->bDescriptorType, 
553                                 header->bLength);
554                         return -1;
555                 }
556
557                 if (header->bDescriptorType == type) {
558                         *ptr = header;
559                         return 0;
560                 }
561
562                 buffer += header->bLength;
563                 size -= header->bLength;
564         }
565         return -1;
566 }
567
568 /**
569  * usb_buffer_alloc - allocate dma-consistent buffer for URB_NO_xxx_DMA_MAP
570  * @dev: device the buffer will be used with
571  * @size: requested buffer size
572  * @mem_flags: affect whether allocation may block
573  * @dma: used to return DMA address of buffer
574  *
575  * Return value is either null (indicating no buffer could be allocated), or
576  * the cpu-space pointer to a buffer that may be used to perform DMA to the
577  * specified device.  Such cpu-space buffers are returned along with the DMA
578  * address (through the pointer provided).
579  *
580  * These buffers are used with URB_NO_xxx_DMA_MAP set in urb->transfer_flags
581  * to avoid behaviors like using "DMA bounce buffers", or tying down I/O
582  * mapping hardware for long idle periods.  The implementation varies between
583  * platforms, depending on details of how DMA will work to this device.
584  * Using these buffers also helps prevent cacheline sharing problems on
585  * architectures where CPU caches are not DMA-coherent.
586  *
587  * When the buffer is no longer used, free it with usb_buffer_free().
588  */
589 void *usb_buffer_alloc(
590         struct usb_device *dev,
591         size_t size,
592         gfp_t mem_flags,
593         dma_addr_t *dma
594 )
595 {
596         if (!dev || !dev->bus)
597                 return NULL;
598         return hcd_buffer_alloc(dev->bus, size, mem_flags, dma);
599 }
600
601 /**
602  * usb_buffer_free - free memory allocated with usb_buffer_alloc()
603  * @dev: device the buffer was used with
604  * @size: requested buffer size
605  * @addr: CPU address of buffer
606  * @dma: DMA address of buffer
607  *
608  * This reclaims an I/O buffer, letting it be reused.  The memory must have
609  * been allocated using usb_buffer_alloc(), and the parameters must match
610  * those provided in that allocation request. 
611  */
612 void usb_buffer_free(
613         struct usb_device *dev,
614         size_t size,
615         void *addr,
616         dma_addr_t dma
617 )
618 {
619         if (!dev || !dev->bus)
620                 return;
621         if (!addr)
622                 return;
623         hcd_buffer_free(dev->bus, size, addr, dma);
624 }
625
626 /**
627  * usb_buffer_map - create DMA mapping(s) for an urb
628  * @urb: urb whose transfer_buffer/setup_packet will be mapped
629  *
630  * Return value is either null (indicating no buffer could be mapped), or
631  * the parameter.  URB_NO_TRANSFER_DMA_MAP and URB_NO_SETUP_DMA_MAP are
632  * added to urb->transfer_flags if the operation succeeds.  If the device
633  * is connected to this system through a non-DMA controller, this operation
634  * always succeeds.
635  *
636  * This call would normally be used for an urb which is reused, perhaps
637  * as the target of a large periodic transfer, with usb_buffer_dmasync()
638  * calls to synchronize memory and dma state.
639  *
640  * Reverse the effect of this call with usb_buffer_unmap().
641  */
642 #if 0
643 struct urb *usb_buffer_map(struct urb *urb)
644 {
645         struct usb_bus          *bus;
646         struct device           *controller;
647
648         if (!urb
649                         || !urb->dev
650                         || !(bus = urb->dev->bus)
651                         || !(controller = bus->controller))
652                 return NULL;
653
654         if (controller->dma_mask) {
655                 urb->transfer_dma = dma_map_single(controller,
656                         urb->transfer_buffer, urb->transfer_buffer_length,
657                         usb_pipein(urb->pipe)
658                                 ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
659                 if (usb_pipecontrol(urb->pipe))
660                         urb->setup_dma = dma_map_single(controller,
661                                         urb->setup_packet,
662                                         sizeof(struct usb_ctrlrequest),
663                                         DMA_TO_DEVICE);
664         // FIXME generic api broken like pci, can't report errors
665         // if (urb->transfer_dma == DMA_ADDR_INVALID) return 0;
666         } else
667                 urb->transfer_dma = ~0;
668         urb->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP
669                                 | URB_NO_SETUP_DMA_MAP);
670         return urb;
671 }
672 #endif  /*  0  */
673
674 /* XXX DISABLED, no users currently.  If you wish to re-enable this
675  * XXX please determine whether the sync is to transfer ownership of
676  * XXX the buffer from device to cpu or vice verse, and thusly use the
677  * XXX appropriate _for_{cpu,device}() method.  -DaveM
678  */
679 #if 0
680
681 /**
682  * usb_buffer_dmasync - synchronize DMA and CPU view of buffer(s)
683  * @urb: urb whose transfer_buffer/setup_packet will be synchronized
684  */
685 void usb_buffer_dmasync(struct urb *urb)
686 {
687         struct usb_bus          *bus;
688         struct device           *controller;
689
690         if (!urb
691                         || !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
692                         || !urb->dev
693                         || !(bus = urb->dev->bus)
694                         || !(controller = bus->controller))
695                 return;
696
697         if (controller->dma_mask) {
698                 dma_sync_single(controller,
699                         urb->transfer_dma, urb->transfer_buffer_length,
700                         usb_pipein(urb->pipe)
701                                 ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
702                 if (usb_pipecontrol(urb->pipe))
703                         dma_sync_single(controller,
704                                         urb->setup_dma,
705                                         sizeof(struct usb_ctrlrequest),
706                                         DMA_TO_DEVICE);
707         }
708 }
709 #endif
710
711 /**
712  * usb_buffer_unmap - free DMA mapping(s) for an urb
713  * @urb: urb whose transfer_buffer will be unmapped
714  *
715  * Reverses the effect of usb_buffer_map().
716  */
717 #if 0
718 void usb_buffer_unmap(struct urb *urb)
719 {
720         struct usb_bus          *bus;
721         struct device           *controller;
722
723         if (!urb
724                         || !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
725                         || !urb->dev
726                         || !(bus = urb->dev->bus)
727                         || !(controller = bus->controller))
728                 return;
729
730         if (controller->dma_mask) {
731                 dma_unmap_single(controller,
732                         urb->transfer_dma, urb->transfer_buffer_length,
733                         usb_pipein(urb->pipe)
734                                 ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
735                 if (usb_pipecontrol(urb->pipe))
736                         dma_unmap_single(controller,
737                                         urb->setup_dma,
738                                         sizeof(struct usb_ctrlrequest),
739                                         DMA_TO_DEVICE);
740         }
741         urb->transfer_flags &= ~(URB_NO_TRANSFER_DMA_MAP
742                                 | URB_NO_SETUP_DMA_MAP);
743 }
744 #endif  /*  0  */
745
746 /**
747  * usb_buffer_map_sg - create scatterlist DMA mapping(s) for an endpoint
748  * @dev: device to which the scatterlist will be mapped
749  * @pipe: endpoint defining the mapping direction
750  * @sg: the scatterlist to map
751  * @nents: the number of entries in the scatterlist
752  *
753  * Return value is either < 0 (indicating no buffers could be mapped), or
754  * the number of DMA mapping array entries in the scatterlist.
755  *
756  * The caller is responsible for placing the resulting DMA addresses from
757  * the scatterlist into URB transfer buffer pointers, and for setting the
758  * URB_NO_TRANSFER_DMA_MAP transfer flag in each of those URBs.
759  *
760  * Top I/O rates come from queuing URBs, instead of waiting for each one
761  * to complete before starting the next I/O.   This is particularly easy
762  * to do with scatterlists.  Just allocate and submit one URB for each DMA
763  * mapping entry returned, stopping on the first error or when all succeed.
764  * Better yet, use the usb_sg_*() calls, which do that (and more) for you.
765  *
766  * This call would normally be used when translating scatterlist requests,
767  * rather than usb_buffer_map(), since on some hardware (with IOMMUs) it
768  * may be able to coalesce mappings for improved I/O efficiency.
769  *
770  * Reverse the effect of this call with usb_buffer_unmap_sg().
771  */
772 int usb_buffer_map_sg(const struct usb_device *dev, unsigned pipe,
773                       struct scatterlist *sg, int nents)
774 {
775         struct usb_bus          *bus;
776         struct device           *controller;
777
778         if (!dev
779                         || usb_pipecontrol(pipe)
780                         || !(bus = dev->bus)
781                         || !(controller = bus->controller)
782                         || !controller->dma_mask)
783                 return -1;
784
785         // FIXME generic api broken like pci, can't report errors
786         return dma_map_sg(controller, sg, nents,
787                         usb_pipein(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
788 }
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_sg - synchronize DMA and CPU view of scatterlist buffer(s)
799  * @dev: device to which the scatterlist will be mapped
800  * @pipe: endpoint defining the mapping direction
801  * @sg: the scatterlist to synchronize
802  * @n_hw_ents: the positive return value from usb_buffer_map_sg
803  *
804  * Use this when you are re-using a scatterlist's data buffers for
805  * another USB request.
806  */
807 void usb_buffer_dmasync_sg(const struct usb_device *dev, unsigned pipe,
808                            struct scatterlist *sg, int n_hw_ents)
809 {
810         struct usb_bus          *bus;
811         struct device           *controller;
812
813         if (!dev
814                         || !(bus = dev->bus)
815                         || !(controller = bus->controller)
816                         || !controller->dma_mask)
817                 return;
818
819         dma_sync_sg(controller, sg, n_hw_ents,
820                         usb_pipein(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
821 }
822 #endif
823
824 /**
825  * usb_buffer_unmap_sg - free DMA mapping(s) for a scatterlist
826  * @dev: device to which the scatterlist will be mapped
827  * @pipe: endpoint defining the mapping direction
828  * @sg: the scatterlist to unmap
829  * @n_hw_ents: the positive return value from usb_buffer_map_sg
830  *
831  * Reverses the effect of usb_buffer_map_sg().
832  */
833 void usb_buffer_unmap_sg(const struct usb_device *dev, unsigned pipe,
834                          struct scatterlist *sg, int n_hw_ents)
835 {
836         struct usb_bus          *bus;
837         struct device           *controller;
838
839         if (!dev
840                         || !(bus = dev->bus)
841                         || !(controller = bus->controller)
842                         || !controller->dma_mask)
843                 return;
844
845         dma_unmap_sg(controller, sg, n_hw_ents,
846                         usb_pipein(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
847 }
848
849 /* format to disable USB on kernel command line is: nousb */
850 __module_param_call("", nousb, param_set_bool, param_get_bool, &nousb, 0444);
851
852 /*
853  * for external read access to <nousb>
854  */
855 int usb_disabled(void)
856 {
857         return nousb;
858 }
859
860 /*
861  * Init
862  */
863 static int __init usb_init(void)
864 {
865         int retval;
866         if (nousb) {
867                 pr_info("%s: USB support disabled\n", usbcore_name);
868                 return 0;
869         }
870
871         retval = ksuspend_usb_init();
872         if (retval)
873                 goto out;
874         retval = bus_register(&usb_bus_type);
875         if (retval) 
876                 goto bus_register_failed;
877         retval = usb_host_init();
878         if (retval)
879                 goto host_init_failed;
880         retval = usb_major_init();
881         if (retval)
882                 goto major_init_failed;
883         retval = usb_register(&usbfs_driver);
884         if (retval)
885                 goto driver_register_failed;
886         retval = usb_devio_init();
887         if (retval)
888                 goto usb_devio_init_failed;
889         retval = usbfs_init();
890         if (retval)
891                 goto fs_init_failed;
892         retval = usb_hub_init();
893         if (retval)
894                 goto hub_init_failed;
895         retval = usb_register_device_driver(&usb_generic_driver, THIS_MODULE);
896         if (!retval)
897                 goto out;
898
899         usb_hub_cleanup();
900 hub_init_failed:
901         usbfs_cleanup();
902 fs_init_failed:
903         usb_devio_cleanup();
904 usb_devio_init_failed:
905         usb_deregister(&usbfs_driver);
906 driver_register_failed:
907         usb_major_cleanup();
908 major_init_failed:
909         usb_host_cleanup();
910 host_init_failed:
911         bus_unregister(&usb_bus_type);
912 bus_register_failed:
913         ksuspend_usb_cleanup();
914 out:
915         return retval;
916 }
917
918 /*
919  * Cleanup
920  */
921 static void __exit usb_exit(void)
922 {
923         /* This will matter if shutdown/reboot does exitcalls. */
924         if (nousb)
925                 return;
926
927         usb_deregister_device_driver(&usb_generic_driver);
928         usb_major_cleanup();
929         usbfs_cleanup();
930         usb_deregister(&usbfs_driver);
931         usb_devio_cleanup();
932         usb_hub_cleanup();
933         usb_host_cleanup();
934         bus_unregister(&usb_bus_type);
935         ksuspend_usb_cleanup();
936 }
937
938 subsys_initcall(usb_init);
939 module_exit(usb_exit);
940
941 /*
942  * USB may be built into the kernel or be built as modules.
943  * These symbols are exported for device (or host controller)
944  * driver modules to use.
945  */
946
947 EXPORT_SYMBOL(usb_disabled);
948
949 EXPORT_SYMBOL_GPL(usb_get_intf);
950 EXPORT_SYMBOL_GPL(usb_put_intf);
951
952 EXPORT_SYMBOL(usb_put_dev);
953 EXPORT_SYMBOL(usb_get_dev);
954 EXPORT_SYMBOL(usb_hub_tt_clear_buffer);
955
956 EXPORT_SYMBOL(usb_lock_device_for_reset);
957
958 EXPORT_SYMBOL(usb_find_interface);
959 EXPORT_SYMBOL(usb_ifnum_to_if);
960 EXPORT_SYMBOL(usb_altnum_to_altsetting);
961
962 EXPORT_SYMBOL(__usb_get_extra_descriptor);
963
964 EXPORT_SYMBOL(usb_find_device);
965 EXPORT_SYMBOL(usb_get_current_frame_number);
966
967 EXPORT_SYMBOL(usb_buffer_alloc);
968 EXPORT_SYMBOL(usb_buffer_free);
969
970 #if 0
971 EXPORT_SYMBOL(usb_buffer_map);
972 EXPORT_SYMBOL(usb_buffer_dmasync);
973 EXPORT_SYMBOL(usb_buffer_unmap);
974 #endif
975
976 EXPORT_SYMBOL(usb_buffer_map_sg);
977 #if 0
978 EXPORT_SYMBOL(usb_buffer_dmasync_sg);
979 #endif
980 EXPORT_SYMBOL(usb_buffer_unmap_sg);
981
982 MODULE_LICENSE("GPL");