13d1d367f7f1ed6e80a386a69bf1fed4d5f4d3de
[linux-2.6.git] / drivers / usb / core / usb.c
1 /*
2  * drivers/usb/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/config.h>
25 #include <linux/module.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/smp_lock.h>
35 #include <linux/usb.h>
36
37 #include <asm/io.h>
38 #include <asm/scatterlist.h>
39 #include <linux/mm.h>
40 #include <linux/dma-mapping.h>
41
42 #include "hcd.h"
43 #include "usb.h"
44
45
46 const char *usbcore_name = "usbcore";
47
48 static int nousb;       /* Disable USB when built into kernel image */
49
50
51 /**
52  * usb_ifnum_to_if - get the interface object with a given interface number
53  * @dev: the device whose current configuration is considered
54  * @ifnum: the desired interface
55  *
56  * This walks the device descriptor for the currently active configuration
57  * and returns a pointer to the interface with that particular interface
58  * number, or null.
59  *
60  * Note that configuration descriptors are not required to assign interface
61  * numbers sequentially, so that it would be incorrect to assume that
62  * the first interface in that descriptor corresponds to interface zero.
63  * This routine helps device drivers avoid such mistakes.
64  * However, you should make sure that you do the right thing with any
65  * alternate settings available for this interfaces.
66  *
67  * Don't call this function unless you are bound to one of the interfaces
68  * on this device or you have locked the device!
69  */
70 struct usb_interface *usb_ifnum_to_if(struct usb_device *dev, unsigned ifnum)
71 {
72         struct usb_host_config *config = dev->actconfig;
73         int i;
74
75         if (!config)
76                 return NULL;
77         for (i = 0; i < config->desc.bNumInterfaces; i++)
78                 if (config->interface[i]->altsetting[0]
79                                 .desc.bInterfaceNumber == ifnum)
80                         return config->interface[i];
81
82         return NULL;
83 }
84
85 /**
86  * usb_altnum_to_altsetting - get the altsetting structure with a given
87  *      alternate setting number.
88  * @intf: the interface containing the altsetting in question
89  * @altnum: the desired alternate setting number
90  *
91  * This searches the altsetting array of the specified interface for
92  * an entry with the correct bAlternateSetting value and returns a pointer
93  * to that entry, or null.
94  *
95  * Note that altsettings need not be stored sequentially by number, so
96  * it would be incorrect to assume that the first altsetting entry in
97  * the array corresponds to altsetting zero.  This routine helps device
98  * drivers avoid such mistakes.
99  *
100  * Don't call this function unless you are bound to the intf interface
101  * or you have locked the device!
102  */
103 struct usb_host_interface *usb_altnum_to_altsetting(struct usb_interface *intf,
104                 unsigned int altnum)
105 {
106         int i;
107
108         for (i = 0; i < intf->num_altsetting; i++) {
109                 if (intf->altsetting[i].desc.bAlternateSetting == altnum)
110                         return &intf->altsetting[i];
111         }
112         return NULL;
113 }
114
115 /**
116  * usb_driver_claim_interface - bind a driver to an interface
117  * @driver: the driver to be bound
118  * @iface: the interface to which it will be bound; must be in the
119  *      usb device's active configuration
120  * @priv: driver data associated with that interface
121  *
122  * This is used by usb device drivers that need to claim more than one
123  * interface on a device when probing (audio and acm are current examples).
124  * No device driver should directly modify internal usb_interface or
125  * usb_device structure members.
126  *
127  * Few drivers should need to use this routine, since the most natural
128  * way to bind to an interface is to return the private data from
129  * the driver's probe() method.
130  *
131  * Callers must own the device lock and the driver model's usb_bus_type.subsys
132  * writelock.  So driver probe() entries don't need extra locking,
133  * but other call contexts may need to explicitly claim those locks.
134  */
135 int usb_driver_claim_interface(struct usb_driver *driver,
136                                 struct usb_interface *iface, void* priv)
137 {
138         struct device *dev = &iface->dev;
139
140         if (dev->driver)
141                 return -EBUSY;
142
143         dev->driver = &driver->driver;
144         usb_set_intfdata(iface, priv);
145         iface->condition = USB_INTERFACE_BOUND;
146         mark_active(iface);
147
148         /* if interface was already added, bind now; else let
149          * the future device_add() bind it, bypassing probe()
150          */
151         if (device_is_registered(dev))
152                 device_bind_driver(dev);
153
154         return 0;
155 }
156
157 /**
158  * usb_driver_release_interface - unbind a driver from an interface
159  * @driver: the driver to be unbound
160  * @iface: the interface from which it will be unbound
161  *
162  * This can be used by drivers to release an interface without waiting
163  * for their disconnect() methods to be called.  In typical cases this
164  * also causes the driver disconnect() method to be called.
165  *
166  * This call is synchronous, and may not be used in an interrupt context.
167  * Callers must own the device lock and the driver model's usb_bus_type.subsys
168  * writelock.  So driver disconnect() entries don't need extra locking,
169  * but other call contexts may need to explicitly claim those locks.
170  */
171 void usb_driver_release_interface(struct usb_driver *driver,
172                                         struct usb_interface *iface)
173 {
174         struct device *dev = &iface->dev;
175
176         /* this should never happen, don't release something that's not ours */
177         if (!dev->driver || dev->driver != &driver->driver)
178                 return;
179
180         /* don't release from within disconnect() */
181         if (iface->condition != USB_INTERFACE_BOUND)
182                 return;
183
184         /* don't release if the interface hasn't been added yet */
185         if (device_is_registered(dev)) {
186                 iface->condition = USB_INTERFACE_UNBINDING;
187                 device_release_driver(dev);
188         }
189
190         dev->driver = NULL;
191         usb_set_intfdata(iface, NULL);
192         iface->condition = USB_INTERFACE_UNBOUND;
193         mark_quiesced(iface);
194 }
195
196 struct find_interface_arg {
197         int minor;
198         struct usb_interface *interface;
199 };
200
201 static int __find_interface(struct device * dev, void * data)
202 {
203         struct find_interface_arg *arg = data;
204         struct usb_interface *intf;
205
206         /* can't look at usb devices, only interfaces */
207         if (dev->driver == &usb_generic_driver)
208                 return 0;
209
210         intf = to_usb_interface(dev);
211         if (intf->minor != -1 && intf->minor == arg->minor) {
212                 arg->interface = intf;
213                 return 1;
214         }
215         return 0;
216 }
217
218 /**
219  * usb_find_interface - find usb_interface pointer for driver and device
220  * @drv: the driver whose current configuration is considered
221  * @minor: the minor number of the desired device
222  *
223  * This walks the driver device list and returns a pointer to the interface 
224  * with the matching minor.  Note, this only works for devices that share the
225  * USB major number.
226  */
227 struct usb_interface *usb_find_interface(struct usb_driver *drv, int minor)
228 {
229         struct find_interface_arg argb;
230
231         argb.minor = minor;
232         argb.interface = NULL;
233         driver_for_each_device(&drv->driver, NULL, &argb, __find_interface);
234         return argb.interface;
235 }
236
237 #ifdef  CONFIG_HOTPLUG
238
239 /*
240  * This sends an uevent to userspace, typically helping to load driver
241  * or other modules, configure the device, and more.  Drivers can provide
242  * a MODULE_DEVICE_TABLE to help with module loading subtasks.
243  *
244  * We're called either from khubd (the typical case) or from root hub
245  * (init, kapmd, modprobe, rmmod, etc), but the agents need to handle
246  * delays in event delivery.  Use sysfs (and DEVPATH) to make sure the
247  * device (and this configuration!) are still present.
248  */
249 static int usb_uevent(struct device *dev, char **envp, int num_envp,
250                       char *buffer, int buffer_size)
251 {
252         struct usb_interface *intf;
253         struct usb_device *usb_dev;
254         struct usb_host_interface *alt;
255         int i = 0;
256         int length = 0;
257
258         if (!dev)
259                 return -ENODEV;
260
261         /* driver is often null here; dev_dbg() would oops */
262         pr_debug ("usb %s: uevent\n", dev->bus_id);
263
264         /* Must check driver_data here, as on remove driver is always NULL */
265         if ((dev->driver == &usb_generic_driver) || 
266             (dev->driver_data == &usb_generic_driver_data))
267                 return 0;
268
269         intf = to_usb_interface(dev);
270         usb_dev = interface_to_usbdev (intf);
271         alt = intf->cur_altsetting;
272
273         if (usb_dev->devnum < 0) {
274                 pr_debug ("usb %s: already deleted?\n", dev->bus_id);
275                 return -ENODEV;
276         }
277         if (!usb_dev->bus) {
278                 pr_debug ("usb %s: bus removed?\n", dev->bus_id);
279                 return -ENODEV;
280         }
281
282 #ifdef  CONFIG_USB_DEVICEFS
283         /* If this is available, userspace programs can directly read
284          * all the device descriptors we don't tell them about.  Or
285          * even act as usermode drivers.
286          *
287          * FIXME reduce hardwired intelligence here
288          */
289         if (add_uevent_var(envp, num_envp, &i,
290                            buffer, buffer_size, &length,
291                            "DEVICE=/proc/bus/usb/%03d/%03d",
292                            usb_dev->bus->busnum, usb_dev->devnum))
293                 return -ENOMEM;
294 #endif
295
296         /* per-device configurations are common */
297         if (add_uevent_var(envp, num_envp, &i,
298                            buffer, buffer_size, &length,
299                            "PRODUCT=%x/%x/%x",
300                            le16_to_cpu(usb_dev->descriptor.idVendor),
301                            le16_to_cpu(usb_dev->descriptor.idProduct),
302                            le16_to_cpu(usb_dev->descriptor.bcdDevice)))
303                 return -ENOMEM;
304
305         /* class-based driver binding models */
306         if (add_uevent_var(envp, num_envp, &i,
307                            buffer, buffer_size, &length,
308                            "TYPE=%d/%d/%d",
309                            usb_dev->descriptor.bDeviceClass,
310                            usb_dev->descriptor.bDeviceSubClass,
311                            usb_dev->descriptor.bDeviceProtocol))
312                 return -ENOMEM;
313
314         if (add_uevent_var(envp, num_envp, &i,
315                            buffer, buffer_size, &length,
316                            "INTERFACE=%d/%d/%d",
317                            alt->desc.bInterfaceClass,
318                            alt->desc.bInterfaceSubClass,
319                            alt->desc.bInterfaceProtocol))
320                 return -ENOMEM;
321
322         if (add_uevent_var(envp, num_envp, &i,
323                            buffer, buffer_size, &length,
324                            "MODALIAS=usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02Xic%02Xisc%02Xip%02X",
325                            le16_to_cpu(usb_dev->descriptor.idVendor),
326                            le16_to_cpu(usb_dev->descriptor.idProduct),
327                            le16_to_cpu(usb_dev->descriptor.bcdDevice),
328                            usb_dev->descriptor.bDeviceClass,
329                            usb_dev->descriptor.bDeviceSubClass,
330                            usb_dev->descriptor.bDeviceProtocol,
331                            alt->desc.bInterfaceClass,
332                            alt->desc.bInterfaceSubClass,
333                            alt->desc.bInterfaceProtocol))
334                 return -ENOMEM;
335
336         envp[i] = NULL;
337
338         return 0;
339 }
340
341 #else
342
343 static int usb_uevent(struct device *dev, char **envp,
344                         int num_envp, char *buffer, int buffer_size)
345 {
346         return -ENODEV;
347 }
348
349 #endif  /* CONFIG_HOTPLUG */
350
351 /**
352  * usb_release_dev - free a usb device structure when all users of it are finished.
353  * @dev: device that's been disconnected
354  *
355  * Will be called only by the device core when all users of this usb device are
356  * done.
357  */
358 static void usb_release_dev(struct device *dev)
359 {
360         struct usb_device *udev;
361
362         udev = to_usb_device(dev);
363
364         usb_destroy_configuration(udev);
365         usb_bus_put(udev->bus);
366         kfree(udev->product);
367         kfree(udev->manufacturer);
368         kfree(udev->serial);
369         kfree(udev);
370 }
371
372 /**
373  * usb_alloc_dev - usb device constructor (usbcore-internal)
374  * @parent: hub to which device is connected; null to allocate a root hub
375  * @bus: bus used to access the device
376  * @port1: one-based index of port; ignored for root hubs
377  * Context: !in_interrupt ()
378  *
379  * Only hub drivers (including virtual root hub drivers for host
380  * controllers) should ever call this.
381  *
382  * This call may not be used in a non-sleeping context.
383  */
384 struct usb_device *
385 usb_alloc_dev(struct usb_device *parent, struct usb_bus *bus, unsigned port1)
386 {
387         struct usb_device *dev;
388
389         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
390         if (!dev)
391                 return NULL;
392
393         bus = usb_bus_get(bus);
394         if (!bus) {
395                 kfree(dev);
396                 return NULL;
397         }
398
399         device_initialize(&dev->dev);
400         dev->dev.bus = &usb_bus_type;
401         dev->dev.dma_mask = bus->controller->dma_mask;
402         dev->dev.driver_data = &usb_generic_driver_data;
403         dev->dev.driver = &usb_generic_driver;
404         dev->dev.release = usb_release_dev;
405         dev->state = USB_STATE_ATTACHED;
406
407         INIT_LIST_HEAD(&dev->ep0.urb_list);
408         dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE;
409         dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT;
410         /* ep0 maxpacket comes later, from device descriptor */
411         dev->ep_in[0] = dev->ep_out[0] = &dev->ep0;
412
413         /* Save readable and stable topology id, distinguishing devices
414          * by location for diagnostics, tools, driver model, etc.  The
415          * string is a path along hub ports, from the root.  Each device's
416          * dev->devpath will be stable until USB is re-cabled, and hubs
417          * are often labeled with these port numbers.  The bus_id isn't
418          * as stable:  bus->busnum changes easily from modprobe order,
419          * cardbus or pci hotplugging, and so on.
420          */
421         if (unlikely (!parent)) {
422                 dev->devpath [0] = '0';
423
424                 dev->dev.parent = bus->controller;
425                 sprintf (&dev->dev.bus_id[0], "usb%d", bus->busnum);
426         } else {
427                 /* match any labeling on the hubs; it's one-based */
428                 if (parent->devpath [0] == '0')
429                         snprintf (dev->devpath, sizeof dev->devpath,
430                                 "%d", port1);
431                 else
432                         snprintf (dev->devpath, sizeof dev->devpath,
433                                 "%s.%d", parent->devpath, port1);
434
435                 dev->dev.parent = &parent->dev;
436                 sprintf (&dev->dev.bus_id[0], "%d-%s",
437                         bus->busnum, dev->devpath);
438
439                 /* hub driver sets up TT records */
440         }
441
442         dev->portnum = port1;
443         dev->bus = bus;
444         dev->parent = parent;
445         INIT_LIST_HEAD(&dev->filelist);
446
447         return dev;
448 }
449
450 /**
451  * usb_get_dev - increments the reference count of the usb device structure
452  * @dev: the device being referenced
453  *
454  * Each live reference to a device should be refcounted.
455  *
456  * Drivers for USB interfaces should normally record such references in
457  * their probe() methods, when they bind to an interface, and release
458  * them by calling usb_put_dev(), in their disconnect() methods.
459  *
460  * A pointer to the device with the incremented reference counter is returned.
461  */
462 struct usb_device *usb_get_dev(struct usb_device *dev)
463 {
464         if (dev)
465                 get_device(&dev->dev);
466         return dev;
467 }
468
469 /**
470  * usb_put_dev - release a use of the usb device structure
471  * @dev: device that's been disconnected
472  *
473  * Must be called when a user of a device is finished with it.  When the last
474  * user of the device calls this function, the memory of the device is freed.
475  */
476 void usb_put_dev(struct usb_device *dev)
477 {
478         if (dev)
479                 put_device(&dev->dev);
480 }
481
482 /**
483  * usb_get_intf - increments the reference count of the usb interface structure
484  * @intf: the interface being referenced
485  *
486  * Each live reference to a interface must be refcounted.
487  *
488  * Drivers for USB interfaces should normally record such references in
489  * their probe() methods, when they bind to an interface, and release
490  * them by calling usb_put_intf(), in their disconnect() methods.
491  *
492  * A pointer to the interface with the incremented reference counter is
493  * returned.
494  */
495 struct usb_interface *usb_get_intf(struct usb_interface *intf)
496 {
497         if (intf)
498                 get_device(&intf->dev);
499         return intf;
500 }
501
502 /**
503  * usb_put_intf - release a use of the usb interface structure
504  * @intf: interface that's been decremented
505  *
506  * Must be called when a user of an interface is finished with it.  When the
507  * last user of the interface calls this function, the memory of the interface
508  * is freed.
509  */
510 void usb_put_intf(struct usb_interface *intf)
511 {
512         if (intf)
513                 put_device(&intf->dev);
514 }
515
516
517 /*                      USB device locking
518  *
519  * USB devices and interfaces are locked using the semaphore in their
520  * embedded struct device.  The hub driver guarantees that whenever a
521  * device is connected or disconnected, drivers are called with the
522  * USB device locked as well as their particular interface.
523  *
524  * Complications arise when several devices are to be locked at the same
525  * time.  Only hub-aware drivers that are part of usbcore ever have to
526  * do this; nobody else needs to worry about it.  The rule for locking
527  * is simple:
528  *
529  *      When locking both a device and its parent, always lock the
530  *      the parent first.
531  */
532
533 /**
534  * usb_lock_device_for_reset - cautiously acquire the lock for a
535  *      usb device structure
536  * @udev: device that's being locked
537  * @iface: interface bound to the driver making the request (optional)
538  *
539  * Attempts to acquire the device lock, but fails if the device is
540  * NOTATTACHED or SUSPENDED, or if iface is specified and the interface
541  * is neither BINDING nor BOUND.  Rather than sleeping to wait for the
542  * lock, the routine polls repeatedly.  This is to prevent deadlock with
543  * disconnect; in some drivers (such as usb-storage) the disconnect()
544  * or suspend() method will block waiting for a device reset to complete.
545  *
546  * Returns a negative error code for failure, otherwise 1 or 0 to indicate
547  * that the device will or will not have to be unlocked.  (0 can be
548  * returned when an interface is given and is BINDING, because in that
549  * case the driver already owns the device lock.)
550  */
551 int usb_lock_device_for_reset(struct usb_device *udev,
552                 struct usb_interface *iface)
553 {
554         unsigned long jiffies_expire = jiffies + HZ;
555
556         if (udev->state == USB_STATE_NOTATTACHED)
557                 return -ENODEV;
558         if (udev->state == USB_STATE_SUSPENDED)
559                 return -EHOSTUNREACH;
560         if (iface) {
561                 switch (iface->condition) {
562                   case USB_INTERFACE_BINDING:
563                         return 0;
564                   case USB_INTERFACE_BOUND:
565                         break;
566                   default:
567                         return -EINTR;
568                 }
569         }
570
571         while (usb_trylock_device(udev) != 0) {
572
573                 /* If we can't acquire the lock after waiting one second,
574                  * we're probably deadlocked */
575                 if (time_after(jiffies, jiffies_expire))
576                         return -EBUSY;
577
578                 msleep(15);
579                 if (udev->state == USB_STATE_NOTATTACHED)
580                         return -ENODEV;
581                 if (udev->state == USB_STATE_SUSPENDED)
582                         return -EHOSTUNREACH;
583                 if (iface && iface->condition != USB_INTERFACE_BOUND)
584                         return -EINTR;
585         }
586         return 1;
587 }
588
589
590 static struct usb_device *match_device(struct usb_device *dev,
591                                        u16 vendor_id, u16 product_id)
592 {
593         struct usb_device *ret_dev = NULL;
594         int child;
595
596         dev_dbg(&dev->dev, "check for vendor %04x, product %04x ...\n",
597             le16_to_cpu(dev->descriptor.idVendor),
598             le16_to_cpu(dev->descriptor.idProduct));
599
600         /* see if this device matches */
601         if ((vendor_id == le16_to_cpu(dev->descriptor.idVendor)) &&
602             (product_id == le16_to_cpu(dev->descriptor.idProduct))) {
603                 dev_dbg (&dev->dev, "matched this device!\n");
604                 ret_dev = usb_get_dev(dev);
605                 goto exit;
606         }
607
608         /* look through all of the children of this device */
609         for (child = 0; child < dev->maxchild; ++child) {
610                 if (dev->children[child]) {
611                         usb_lock_device(dev->children[child]);
612                         ret_dev = match_device(dev->children[child],
613                                                vendor_id, product_id);
614                         usb_unlock_device(dev->children[child]);
615                         if (ret_dev)
616                                 goto exit;
617                 }
618         }
619 exit:
620         return ret_dev;
621 }
622
623 /**
624  * usb_find_device - find a specific usb device in the system
625  * @vendor_id: the vendor id of the device to find
626  * @product_id: the product id of the device to find
627  *
628  * Returns a pointer to a struct usb_device if such a specified usb
629  * device is present in the system currently.  The usage count of the
630  * device will be incremented if a device is found.  Make sure to call
631  * usb_put_dev() when the caller is finished with the device.
632  *
633  * If a device with the specified vendor and product id is not found,
634  * NULL is returned.
635  */
636 struct usb_device *usb_find_device(u16 vendor_id, u16 product_id)
637 {
638         struct list_head *buslist;
639         struct usb_bus *bus;
640         struct usb_device *dev = NULL;
641         
642         down(&usb_bus_list_lock);
643         for (buslist = usb_bus_list.next;
644              buslist != &usb_bus_list; 
645              buslist = buslist->next) {
646                 bus = container_of(buslist, struct usb_bus, bus_list);
647                 if (!bus->root_hub)
648                         continue;
649                 usb_lock_device(bus->root_hub);
650                 dev = match_device(bus->root_hub, vendor_id, product_id);
651                 usb_unlock_device(bus->root_hub);
652                 if (dev)
653                         goto exit;
654         }
655 exit:
656         up(&usb_bus_list_lock);
657         return dev;
658 }
659
660 /**
661  * usb_get_current_frame_number - return current bus frame number
662  * @dev: the device whose bus is being queried
663  *
664  * Returns the current frame number for the USB host controller
665  * used with the given USB device.  This can be used when scheduling
666  * isochronous requests.
667  *
668  * Note that different kinds of host controller have different
669  * "scheduling horizons".  While one type might support scheduling only
670  * 32 frames into the future, others could support scheduling up to
671  * 1024 frames into the future.
672  */
673 int usb_get_current_frame_number(struct usb_device *dev)
674 {
675         return dev->bus->op->get_frame_number (dev);
676 }
677
678 /*-------------------------------------------------------------------*/
679 /*
680  * __usb_get_extra_descriptor() finds a descriptor of specific type in the
681  * extra field of the interface and endpoint descriptor structs.
682  */
683
684 int __usb_get_extra_descriptor(char *buffer, unsigned size,
685         unsigned char type, void **ptr)
686 {
687         struct usb_descriptor_header *header;
688
689         while (size >= sizeof(struct usb_descriptor_header)) {
690                 header = (struct usb_descriptor_header *)buffer;
691
692                 if (header->bLength < 2) {
693                         printk(KERN_ERR
694                                 "%s: bogus descriptor, type %d length %d\n",
695                                 usbcore_name,
696                                 header->bDescriptorType, 
697                                 header->bLength);
698                         return -1;
699                 }
700
701                 if (header->bDescriptorType == type) {
702                         *ptr = header;
703                         return 0;
704                 }
705
706                 buffer += header->bLength;
707                 size -= header->bLength;
708         }
709         return -1;
710 }
711
712 /**
713  * usb_buffer_alloc - allocate dma-consistent buffer for URB_NO_xxx_DMA_MAP
714  * @dev: device the buffer will be used with
715  * @size: requested buffer size
716  * @mem_flags: affect whether allocation may block
717  * @dma: used to return DMA address of buffer
718  *
719  * Return value is either null (indicating no buffer could be allocated), or
720  * the cpu-space pointer to a buffer that may be used to perform DMA to the
721  * specified device.  Such cpu-space buffers are returned along with the DMA
722  * address (through the pointer provided).
723  *
724  * These buffers are used with URB_NO_xxx_DMA_MAP set in urb->transfer_flags
725  * to avoid behaviors like using "DMA bounce buffers", or tying down I/O
726  * mapping hardware for long idle periods.  The implementation varies between
727  * platforms, depending on details of how DMA will work to this device.
728  * Using these buffers also helps prevent cacheline sharing problems on
729  * architectures where CPU caches are not DMA-coherent.
730  *
731  * When the buffer is no longer used, free it with usb_buffer_free().
732  */
733 void *usb_buffer_alloc (
734         struct usb_device *dev,
735         size_t size,
736         gfp_t mem_flags,
737         dma_addr_t *dma
738 )
739 {
740         if (!dev || !dev->bus || !dev->bus->op || !dev->bus->op->buffer_alloc)
741                 return NULL;
742         return dev->bus->op->buffer_alloc (dev->bus, size, mem_flags, dma);
743 }
744
745 /**
746  * usb_buffer_free - free memory allocated with usb_buffer_alloc()
747  * @dev: device the buffer was used with
748  * @size: requested buffer size
749  * @addr: CPU address of buffer
750  * @dma: DMA address of buffer
751  *
752  * This reclaims an I/O buffer, letting it be reused.  The memory must have
753  * been allocated using usb_buffer_alloc(), and the parameters must match
754  * those provided in that allocation request. 
755  */
756 void usb_buffer_free (
757         struct usb_device *dev,
758         size_t size,
759         void *addr,
760         dma_addr_t dma
761 )
762 {
763         if (!dev || !dev->bus || !dev->bus->op || !dev->bus->op->buffer_free)
764                 return;
765         dev->bus->op->buffer_free (dev->bus, size, addr, dma);
766 }
767
768 /**
769  * usb_buffer_map - create DMA mapping(s) for an urb
770  * @urb: urb whose transfer_buffer/setup_packet will be mapped
771  *
772  * Return value is either null (indicating no buffer could be mapped), or
773  * the parameter.  URB_NO_TRANSFER_DMA_MAP and URB_NO_SETUP_DMA_MAP are
774  * added to urb->transfer_flags if the operation succeeds.  If the device
775  * is connected to this system through a non-DMA controller, this operation
776  * always succeeds.
777  *
778  * This call would normally be used for an urb which is reused, perhaps
779  * as the target of a large periodic transfer, with usb_buffer_dmasync()
780  * calls to synchronize memory and dma state.
781  *
782  * Reverse the effect of this call with usb_buffer_unmap().
783  */
784 #if 0
785 struct urb *usb_buffer_map (struct urb *urb)
786 {
787         struct usb_bus          *bus;
788         struct device           *controller;
789
790         if (!urb
791                         || !urb->dev
792                         || !(bus = urb->dev->bus)
793                         || !(controller = bus->controller))
794                 return NULL;
795
796         if (controller->dma_mask) {
797                 urb->transfer_dma = dma_map_single (controller,
798                         urb->transfer_buffer, urb->transfer_buffer_length,
799                         usb_pipein (urb->pipe)
800                                 ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
801                 if (usb_pipecontrol (urb->pipe))
802                         urb->setup_dma = dma_map_single (controller,
803                                         urb->setup_packet,
804                                         sizeof (struct usb_ctrlrequest),
805                                         DMA_TO_DEVICE);
806         // FIXME generic api broken like pci, can't report errors
807         // if (urb->transfer_dma == DMA_ADDR_INVALID) return 0;
808         } else
809                 urb->transfer_dma = ~0;
810         urb->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP
811                                 | URB_NO_SETUP_DMA_MAP);
812         return urb;
813 }
814 #endif  /*  0  */
815
816 /* XXX DISABLED, no users currently.  If you wish to re-enable this
817  * XXX please determine whether the sync is to transfer ownership of
818  * XXX the buffer from device to cpu or vice verse, and thusly use the
819  * XXX appropriate _for_{cpu,device}() method.  -DaveM
820  */
821 #if 0
822
823 /**
824  * usb_buffer_dmasync - synchronize DMA and CPU view of buffer(s)
825  * @urb: urb whose transfer_buffer/setup_packet will be synchronized
826  */
827 void usb_buffer_dmasync (struct urb *urb)
828 {
829         struct usb_bus          *bus;
830         struct device           *controller;
831
832         if (!urb
833                         || !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
834                         || !urb->dev
835                         || !(bus = urb->dev->bus)
836                         || !(controller = bus->controller))
837                 return;
838
839         if (controller->dma_mask) {
840                 dma_sync_single (controller,
841                         urb->transfer_dma, urb->transfer_buffer_length,
842                         usb_pipein (urb->pipe)
843                                 ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
844                 if (usb_pipecontrol (urb->pipe))
845                         dma_sync_single (controller,
846                                         urb->setup_dma,
847                                         sizeof (struct usb_ctrlrequest),
848                                         DMA_TO_DEVICE);
849         }
850 }
851 #endif
852
853 /**
854  * usb_buffer_unmap - free DMA mapping(s) for an urb
855  * @urb: urb whose transfer_buffer will be unmapped
856  *
857  * Reverses the effect of usb_buffer_map().
858  */
859 #if 0
860 void usb_buffer_unmap (struct urb *urb)
861 {
862         struct usb_bus          *bus;
863         struct device           *controller;
864
865         if (!urb
866                         || !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
867                         || !urb->dev
868                         || !(bus = urb->dev->bus)
869                         || !(controller = bus->controller))
870                 return;
871
872         if (controller->dma_mask) {
873                 dma_unmap_single (controller,
874                         urb->transfer_dma, urb->transfer_buffer_length,
875                         usb_pipein (urb->pipe)
876                                 ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
877                 if (usb_pipecontrol (urb->pipe))
878                         dma_unmap_single (controller,
879                                         urb->setup_dma,
880                                         sizeof (struct usb_ctrlrequest),
881                                         DMA_TO_DEVICE);
882         }
883         urb->transfer_flags &= ~(URB_NO_TRANSFER_DMA_MAP
884                                 | URB_NO_SETUP_DMA_MAP);
885 }
886 #endif  /*  0  */
887
888 /**
889  * usb_buffer_map_sg - create scatterlist DMA mapping(s) for an endpoint
890  * @dev: device to which the scatterlist will be mapped
891  * @pipe: endpoint defining the mapping direction
892  * @sg: the scatterlist to map
893  * @nents: the number of entries in the scatterlist
894  *
895  * Return value is either < 0 (indicating no buffers could be mapped), or
896  * the number of DMA mapping array entries in the scatterlist.
897  *
898  * The caller is responsible for placing the resulting DMA addresses from
899  * the scatterlist into URB transfer buffer pointers, and for setting the
900  * URB_NO_TRANSFER_DMA_MAP transfer flag in each of those URBs.
901  *
902  * Top I/O rates come from queuing URBs, instead of waiting for each one
903  * to complete before starting the next I/O.   This is particularly easy
904  * to do with scatterlists.  Just allocate and submit one URB for each DMA
905  * mapping entry returned, stopping on the first error or when all succeed.
906  * Better yet, use the usb_sg_*() calls, which do that (and more) for you.
907  *
908  * This call would normally be used when translating scatterlist requests,
909  * rather than usb_buffer_map(), since on some hardware (with IOMMUs) it
910  * may be able to coalesce mappings for improved I/O efficiency.
911  *
912  * Reverse the effect of this call with usb_buffer_unmap_sg().
913  */
914 int usb_buffer_map_sg (struct usb_device *dev, unsigned pipe,
915                 struct scatterlist *sg, int nents)
916 {
917         struct usb_bus          *bus;
918         struct device           *controller;
919
920         if (!dev
921                         || usb_pipecontrol (pipe)
922                         || !(bus = dev->bus)
923                         || !(controller = bus->controller)
924                         || !controller->dma_mask)
925                 return -1;
926
927         // FIXME generic api broken like pci, can't report errors
928         return dma_map_sg (controller, sg, nents,
929                         usb_pipein (pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
930 }
931
932 /* XXX DISABLED, no users currently.  If you wish to re-enable this
933  * XXX please determine whether the sync is to transfer ownership of
934  * XXX the buffer from device to cpu or vice verse, and thusly use the
935  * XXX appropriate _for_{cpu,device}() method.  -DaveM
936  */
937 #if 0
938
939 /**
940  * usb_buffer_dmasync_sg - synchronize DMA and CPU view of scatterlist buffer(s)
941  * @dev: device to which the scatterlist will be mapped
942  * @pipe: endpoint defining the mapping direction
943  * @sg: the scatterlist to synchronize
944  * @n_hw_ents: the positive return value from usb_buffer_map_sg
945  *
946  * Use this when you are re-using a scatterlist's data buffers for
947  * another USB request.
948  */
949 void usb_buffer_dmasync_sg (struct usb_device *dev, unsigned pipe,
950                 struct scatterlist *sg, int n_hw_ents)
951 {
952         struct usb_bus          *bus;
953         struct device           *controller;
954
955         if (!dev
956                         || !(bus = dev->bus)
957                         || !(controller = bus->controller)
958                         || !controller->dma_mask)
959                 return;
960
961         dma_sync_sg (controller, sg, n_hw_ents,
962                         usb_pipein (pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
963 }
964 #endif
965
966 /**
967  * usb_buffer_unmap_sg - free DMA mapping(s) for a scatterlist
968  * @dev: device to which the scatterlist will be mapped
969  * @pipe: endpoint defining the mapping direction
970  * @sg: the scatterlist to unmap
971  * @n_hw_ents: the positive return value from usb_buffer_map_sg
972  *
973  * Reverses the effect of usb_buffer_map_sg().
974  */
975 void usb_buffer_unmap_sg (struct usb_device *dev, unsigned pipe,
976                 struct scatterlist *sg, int n_hw_ents)
977 {
978         struct usb_bus          *bus;
979         struct device           *controller;
980
981         if (!dev
982                         || !(bus = dev->bus)
983                         || !(controller = bus->controller)
984                         || !controller->dma_mask)
985                 return;
986
987         dma_unmap_sg (controller, sg, n_hw_ents,
988                         usb_pipein (pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
989 }
990
991 static int verify_suspended(struct device *dev, void *unused)
992 {
993         return (dev->power.power_state.event == PM_EVENT_ON) ? -EBUSY : 0;
994 }
995
996 static int usb_generic_suspend(struct device *dev, pm_message_t message)
997 {
998         struct usb_interface    *intf;
999         struct usb_driver       *driver;
1000         int                     status;
1001
1002         /* USB devices enter SUSPEND state through their hubs, but can be
1003          * marked for FREEZE as soon as their children are already idled.
1004          * But those semantics are useless, so we equate the two (sigh).
1005          */
1006         if (dev->driver == &usb_generic_driver) {
1007                 if (dev->power.power_state.event == message.event)
1008                         return 0;
1009                 /* we need to rule out bogus requests through sysfs */
1010                 status = device_for_each_child(dev, NULL, verify_suspended);
1011                 if (status)
1012                         return status;
1013                 return usb_suspend_device (to_usb_device(dev));
1014         }
1015
1016         if ((dev->driver == NULL) ||
1017             (dev->driver_data == &usb_generic_driver_data))
1018                 return 0;
1019
1020         intf = to_usb_interface(dev);
1021         driver = to_usb_driver(dev->driver);
1022
1023         /* with no hardware, USB interfaces only use FREEZE and ON states */
1024         if (!is_active(intf))
1025                 return 0;
1026
1027         if (driver->suspend && driver->resume) {
1028                 status = driver->suspend(intf, message);
1029                 if (status)
1030                         dev_err(dev, "%s error %d\n", "suspend", status);
1031                 else
1032                         mark_quiesced(intf);
1033         } else {
1034                 // FIXME else if there's no suspend method, disconnect...
1035                 dev_warn(dev, "no suspend for driver %s?\n", driver->name);
1036                 mark_quiesced(intf);
1037                 status = 0;
1038         }
1039         return status;
1040 }
1041
1042 static int usb_generic_resume(struct device *dev)
1043 {
1044         struct usb_interface    *intf;
1045         struct usb_driver       *driver;
1046         struct usb_device       *udev;
1047         int                     status;
1048
1049         if (dev->power.power_state.event == PM_EVENT_ON)
1050                 return 0;
1051
1052         /* mark things as "on" immediately, no matter what errors crop up */
1053         dev->power.power_state.event = PM_EVENT_ON;
1054
1055         /* devices resume through their hubs */
1056         if (dev->driver == &usb_generic_driver) {
1057                 udev = to_usb_device(dev);
1058                 if (udev->state == USB_STATE_NOTATTACHED)
1059                         return 0;
1060                 return usb_resume_device (to_usb_device(dev));
1061         }
1062
1063         if ((dev->driver == NULL) ||
1064             (dev->driver_data == &usb_generic_driver_data)) {
1065                 dev->power.power_state.event = PM_EVENT_FREEZE;
1066                 return 0;
1067         }
1068
1069         intf = to_usb_interface(dev);
1070         driver = to_usb_driver(dev->driver);
1071
1072         udev = interface_to_usbdev(intf);
1073         if (udev->state == USB_STATE_NOTATTACHED)
1074                 return 0;
1075
1076         /* if driver was suspended, it has a resume method;
1077          * however, sysfs can wrongly mark things as suspended
1078          * (on the "no suspend method" FIXME path above)
1079          */
1080         if (driver->resume) {
1081                 status = driver->resume(intf);
1082                 if (status) {
1083                         dev_err(dev, "%s error %d\n", "resume", status);
1084                         mark_quiesced(intf);
1085                 }
1086         } else
1087                 dev_warn(dev, "no resume for driver %s?\n", driver->name);
1088         return 0;
1089 }
1090
1091 struct bus_type usb_bus_type = {
1092         .name =         "usb",
1093         .match =        usb_device_match,
1094         .uevent =       usb_uevent,
1095         .suspend =      usb_generic_suspend,
1096         .resume =       usb_generic_resume,
1097 };
1098
1099 /* format to disable USB on kernel command line is: nousb */
1100 __module_param_call("", nousb, param_set_bool, param_get_bool, &nousb, 0444);
1101
1102 /*
1103  * for external read access to <nousb>
1104  */
1105 int usb_disabled(void)
1106 {
1107         return nousb;
1108 }
1109
1110 /*
1111  * Init
1112  */
1113 static int __init usb_init(void)
1114 {
1115         int retval;
1116         if (nousb) {
1117                 pr_info ("%s: USB support disabled\n", usbcore_name);
1118                 return 0;
1119         }
1120
1121         retval = bus_register(&usb_bus_type);
1122         if (retval) 
1123                 goto out;
1124         retval = usb_host_init();
1125         if (retval)
1126                 goto host_init_failed;
1127         retval = usb_major_init();
1128         if (retval)
1129                 goto major_init_failed;
1130         retval = usb_register(&usbfs_driver);
1131         if (retval)
1132                 goto driver_register_failed;
1133         retval = usbdev_init();
1134         if (retval)
1135                 goto usbdevice_init_failed;
1136         retval = usbfs_init();
1137         if (retval)
1138                 goto fs_init_failed;
1139         retval = usb_hub_init();
1140         if (retval)
1141                 goto hub_init_failed;
1142         retval = driver_register(&usb_generic_driver);
1143         if (!retval)
1144                 goto out;
1145
1146         usb_hub_cleanup();
1147 hub_init_failed:
1148         usbfs_cleanup();
1149 fs_init_failed:
1150         usbdev_cleanup();
1151 usbdevice_init_failed:
1152         usb_deregister(&usbfs_driver);
1153 driver_register_failed:
1154         usb_major_cleanup();
1155 major_init_failed:
1156         usb_host_cleanup();
1157 host_init_failed:
1158         bus_unregister(&usb_bus_type);
1159 out:
1160         return retval;
1161 }
1162
1163 /*
1164  * Cleanup
1165  */
1166 static void __exit usb_exit(void)
1167 {
1168         /* This will matter if shutdown/reboot does exitcalls. */
1169         if (nousb)
1170                 return;
1171
1172         driver_unregister(&usb_generic_driver);
1173         usb_major_cleanup();
1174         usbfs_cleanup();
1175         usb_deregister(&usbfs_driver);
1176         usbdev_cleanup();
1177         usb_hub_cleanup();
1178         usb_host_cleanup();
1179         bus_unregister(&usb_bus_type);
1180 }
1181
1182 subsys_initcall(usb_init);
1183 module_exit(usb_exit);
1184
1185 /*
1186  * USB may be built into the kernel or be built as modules.
1187  * These symbols are exported for device (or host controller)
1188  * driver modules to use.
1189  */
1190
1191 EXPORT_SYMBOL(usb_disabled);
1192
1193 EXPORT_SYMBOL_GPL(usb_get_intf);
1194 EXPORT_SYMBOL_GPL(usb_put_intf);
1195
1196 EXPORT_SYMBOL(usb_alloc_dev);
1197 EXPORT_SYMBOL(usb_put_dev);
1198 EXPORT_SYMBOL(usb_get_dev);
1199 EXPORT_SYMBOL(usb_hub_tt_clear_buffer);
1200
1201 EXPORT_SYMBOL(usb_lock_device_for_reset);
1202
1203 EXPORT_SYMBOL(usb_driver_claim_interface);
1204 EXPORT_SYMBOL(usb_driver_release_interface);
1205 EXPORT_SYMBOL(usb_find_interface);
1206 EXPORT_SYMBOL(usb_ifnum_to_if);
1207 EXPORT_SYMBOL(usb_altnum_to_altsetting);
1208
1209 EXPORT_SYMBOL(usb_reset_device);
1210 EXPORT_SYMBOL(usb_disconnect);
1211
1212 EXPORT_SYMBOL(__usb_get_extra_descriptor);
1213
1214 EXPORT_SYMBOL(usb_find_device);
1215 EXPORT_SYMBOL(usb_get_current_frame_number);
1216
1217 EXPORT_SYMBOL (usb_buffer_alloc);
1218 EXPORT_SYMBOL (usb_buffer_free);
1219
1220 #if 0
1221 EXPORT_SYMBOL (usb_buffer_map);
1222 EXPORT_SYMBOL (usb_buffer_dmasync);
1223 EXPORT_SYMBOL (usb_buffer_unmap);
1224 #endif
1225
1226 EXPORT_SYMBOL (usb_buffer_map_sg);
1227 #if 0
1228 EXPORT_SYMBOL (usb_buffer_dmasync_sg);
1229 #endif
1230 EXPORT_SYMBOL (usb_buffer_unmap_sg);
1231
1232 MODULE_LICENSE("GPL");