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