v2.4.2.1 -> v2.4.2.2
[opensuse:kernel.git] / drivers / usb / usb.c
1 /*
2  * drivers/usb/usb.c
3  *
4  * (C) Copyright Linus Torvalds 1999
5  * (C) Copyright Johannes Erdfelt 1999
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 (kernel hotplug, usb_device_id)
11  * (C) Copyright Yggdrasil Computing, Inc. 2000
12  *     (usb_device_id matching changes by Adam J. Richter)
13  *
14  * NOTE! This is not actually a driver at all, rather this is
15  * just a collection of helper routines that implement the
16  * generic USB things that the real drivers can use..
17  *
18  * Think of this as a "USB library" rather than anything else.
19  * It should be considered a slave, with no callbacks. Callbacks
20  * are evil.
21  *
22  * $Id: usb.c,v 1.53 2000/01/14 16:19:09 acher Exp $
23  */
24
25 #include <linux/config.h>
26 #include <linux/module.h>
27 #include <linux/string.h>
28 #include <linux/bitops.h>
29 #include <linux/slab.h>
30 #include <linux/interrupt.h>  /* for in_interrupt() */
31 #include <linux/kmod.h>
32 #include <linux/init.h>
33 #include <linux/devfs_fs_kernel.h>
34
35 #ifdef CONFIG_USB_DEBUG
36         #define DEBUG
37 #else
38         #undef DEBUG
39 #endif
40 #include <linux/usb.h>
41
42 #define DEVNUM_ROUND_ROBIN      /***** OPTION *****/
43 #ifdef DEVNUM_ROUND_ROBIN
44 static int devnum_next = 1;
45 #endif
46
47 static const int usb_bandwidth_option =
48 #ifdef CONFIG_USB_BANDWIDTH
49                                 1;
50 #else
51                                 0;
52 #endif
53
54 extern int  usb_hub_init(void);
55 extern void usb_hub_cleanup(void);
56
57 /*
58  * Prototypes for the device driver probing/loading functions
59  */
60 static void usb_find_drivers(struct usb_device *);
61 static int  usb_find_interface_driver(struct usb_device *, unsigned int);
62 static void usb_check_support(struct usb_device *);
63
64 /*
65  * We have a per-interface "registered driver" list.
66  */
67 LIST_HEAD(usb_driver_list);
68 LIST_HEAD(usb_bus_list);
69
70 devfs_handle_t usb_devfs_handle;        /* /dev/usb dir. */
71
72 static struct usb_busmap busmap;
73
74 static struct usb_driver *usb_minors[16];
75
76 /**
77  *      usb_register - register a USB driver
78  *      @new_driver: USB operations for the driver
79  *
80  *      Registers a USB driver with the USB core.  The list of unattached
81  *      interfaces will be rescanned whenever a new driver is added, allowing
82  *      the new driver to attach to any recognized devices.
83  *      Returns a negative error code on failure and 0 on success.
84  */
85 int usb_register(struct usb_driver *new_driver)
86 {
87         if (new_driver->fops != NULL) {
88                 if (usb_minors[new_driver->minor/16]) {
89                          err("error registering %s driver", new_driver->name);
90                         return -EINVAL;
91                 }
92                 usb_minors[new_driver->minor/16] = new_driver;
93         }
94
95         info("registered new driver %s", new_driver->name);
96
97         init_MUTEX(&new_driver->serialize);
98
99         /* Add it to the list of known drivers */
100         list_add_tail(&new_driver->driver_list, &usb_driver_list);
101
102         usb_scan_devices();
103
104         return 0;
105 }
106
107 /**
108  *      usb_scan_devices - scans all unclaimed USB interfaces
109  *
110  *      Goes through all unclaimed USB interfaces, and offers them to all
111  *      registered USB drivers through the 'probe' function.
112  *      This will automatically be called after usb_register is called.
113  *      It is called by some of the USB subsystems after one of their subdrivers
114  *      are registered.
115  */
116 void usb_scan_devices(void)
117 {
118         struct list_head *tmp;
119
120         tmp = usb_bus_list.next;
121         while (tmp != &usb_bus_list) {
122                 struct usb_bus *bus = list_entry(tmp,struct usb_bus, bus_list);
123
124                 tmp = tmp->next;
125                 usb_check_support(bus->root_hub);
126         }
127 }
128
129 /*
130  * This function is part of a depth-first search down the device tree,
131  * removing any instances of a device driver.
132  */
133 static void usb_drivers_purge(struct usb_driver *driver,struct usb_device *dev)
134 {
135         int i;
136
137         if (!dev) {
138                 err("null device being purged!!!");
139                 return;
140         }
141
142         for (i=0; i<USB_MAXCHILDREN; i++)
143                 if (dev->children[i])
144                         usb_drivers_purge(driver, dev->children[i]);
145
146         if (!dev->actconfig)
147                 return;
148                         
149         for (i = 0; i < dev->actconfig->bNumInterfaces; i++) {
150                 struct usb_interface *interface = &dev->actconfig->interface[i];
151                 
152                 if (interface->driver == driver) {
153                         down(&driver->serialize);
154                         driver->disconnect(dev, interface->private_data);
155                         up(&driver->serialize);
156                         /* if driver->disconnect didn't release the interface */
157                         if (interface->driver)
158                                 usb_driver_release_interface(driver, interface);
159                         /*
160                          * This will go through the list looking for another
161                          * driver that can handle the device
162                          */
163                         usb_find_interface_driver(dev, i);
164                 }
165         }
166 }
167
168 /**
169  *      usb_deregister - unregister a USB driver
170  *      @driver: USB operations of the driver to unregister
171  *
172  *      Unlinks the specified driver from the internal USB driver list.
173  */
174 void usb_deregister(struct usb_driver *driver)
175 {
176         struct list_head *tmp;
177
178         info("deregistering driver %s", driver->name);
179         if (driver->fops != NULL)
180                 usb_minors[driver->minor/16] = NULL;
181
182         /*
183          * first we remove the driver, to be sure it doesn't get used by
184          * another thread while we are stepping through removing entries
185          */
186         list_del(&driver->driver_list);
187
188         tmp = usb_bus_list.next;
189         while (tmp != &usb_bus_list) {
190                 struct usb_bus *bus = list_entry(tmp,struct usb_bus,bus_list);
191
192                 tmp = tmp->next;
193                 usb_drivers_purge(driver, bus->root_hub);
194         }
195 }
196
197 struct usb_interface *usb_ifnum_to_if(struct usb_device *dev, unsigned ifnum)
198 {
199         int i;
200
201         for (i = 0; i < dev->actconfig->bNumInterfaces; i++)
202                 if (dev->actconfig->interface[i].altsetting[0].bInterfaceNumber == ifnum)
203                         return &dev->actconfig->interface[i];
204
205         return NULL;
206 }
207
208 struct usb_endpoint_descriptor *usb_epnum_to_ep_desc(struct usb_device *dev, unsigned epnum)
209 {
210         int i, j, k;
211
212         for (i = 0; i < dev->actconfig->bNumInterfaces; i++)
213                 for (j = 0; j < dev->actconfig->interface[i].num_altsetting; j++)
214                         for (k = 0; k < dev->actconfig->interface[i].altsetting[j].bNumEndpoints; k++)
215                                 if (epnum == dev->actconfig->interface[i].altsetting[j].endpoint[k].bEndpointAddress)
216                                         return &dev->actconfig->interface[i].altsetting[j].endpoint[k];
217
218         return NULL;
219 }
220
221 /*
222  * usb_calc_bus_time:
223  *
224  * returns (approximate) USB bus time in nanoseconds for a USB transaction.
225  */
226 static long usb_calc_bus_time (int low_speed, int input_dir, int isoc, int bytecount)
227 {
228         unsigned long   tmp;
229
230         if (low_speed)          /* no isoc. here */
231         {
232                 if (input_dir)
233                 {
234                         tmp = (67667L * (31L + 10L * BitTime (bytecount))) / 1000L;
235                         return (64060L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp);
236                 }
237                 else
238                 {
239                         tmp = (66700L * (31L + 10L * BitTime (bytecount))) / 1000L;
240                         return (64107L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp);
241                 }
242         }
243
244         /* for full-speed: */
245
246         if (!isoc)              /* Input or Output */
247         {
248                 tmp = (8354L * (31L + 10L * BitTime (bytecount))) / 1000L;
249                 return (9107L + BW_HOST_DELAY + tmp);
250         } /* end not Isoc */
251
252         /* for isoc: */
253
254         tmp = (8354L * (31L + 10L * BitTime (bytecount))) / 1000L;
255         return (((input_dir) ? 7268L : 6265L) + BW_HOST_DELAY + tmp);
256 }
257
258 /*
259  * usb_check_bandwidth():
260  *
261  * old_alloc is from host_controller->bandwidth_allocated in microseconds;
262  * bustime is from calc_bus_time(), but converted to microseconds.
263  *
264  * returns <bustime in us> if successful,
265  * or USB_ST_BANDWIDTH_ERROR if bandwidth request fails.
266  *
267  * FIXME:
268  * This initial implementation does not use Endpoint.bInterval
269  * in managing bandwidth allocation.
270  * It probably needs to be expanded to use Endpoint.bInterval.
271  * This can be done as a later enhancement (correction).
272  * This will also probably require some kind of
273  * frame allocation tracking...meaning, for example,
274  * that if multiple drivers request interrupts every 10 USB frames,
275  * they don't all have to be allocated at
276  * frame numbers N, N+10, N+20, etc.  Some of them could be at
277  * N+11, N+21, N+31, etc., and others at
278  * N+12, N+22, N+32, etc.
279  * However, this first cut at USB bandwidth allocation does not
280  * contain any frame allocation tracking.
281  */
282 int usb_check_bandwidth (struct usb_device *dev, struct urb *urb)
283 {
284         int             new_alloc;
285         int             old_alloc = dev->bus->bandwidth_allocated;
286         unsigned int    pipe = urb->pipe;
287         long            bustime;
288
289         bustime = usb_calc_bus_time (usb_pipeslow(pipe), usb_pipein(pipe),
290                         usb_pipeisoc(pipe), usb_maxpacket(dev, pipe, usb_pipeout(pipe)));
291         if (usb_pipeisoc(pipe))
292                 bustime = NS_TO_US(bustime) / urb->number_of_packets;
293         else
294                 bustime = NS_TO_US(bustime);
295
296         new_alloc = old_alloc + (int)bustime;
297                 /* what new total allocated bus time would be */
298
299         if (new_alloc > FRAME_TIME_MAX_USECS_ALLOC)
300                 dbg("usb-check-bandwidth %sFAILED: was %u, would be %u, bustime = %ld us",
301                         usb_bandwidth_option ? "" : "would have ",
302                         old_alloc, new_alloc, bustime);
303
304         if (!usb_bandwidth_option)      /* don't enforce it */
305                 return (bustime);
306         return (new_alloc <= FRAME_TIME_MAX_USECS_ALLOC) ? bustime : USB_ST_BANDWIDTH_ERROR;
307 }
308
309 void usb_claim_bandwidth (struct usb_device *dev, struct urb *urb, int bustime, int isoc)
310 {
311         dev->bus->bandwidth_allocated += bustime;
312         if (isoc)
313                 dev->bus->bandwidth_isoc_reqs++;
314         else
315                 dev->bus->bandwidth_int_reqs++;
316         urb->bandwidth = bustime;
317
318 #ifdef USB_BANDWIDTH_MESSAGES
319         dbg("bandwidth alloc increased by %d to %d for %d requesters",
320                 bustime,
321                 dev->bus->bandwidth_allocated,
322                 dev->bus->bandwidth_int_reqs + dev->bus->bandwidth_isoc_reqs);
323 #endif
324 }
325
326 /*
327  * usb_release_bandwidth():
328  *
329  * called to release a pipe's bandwidth (in microseconds)
330  */
331 void usb_release_bandwidth(struct usb_device *dev, struct urb *urb, int isoc)
332 {
333         dev->bus->bandwidth_allocated -= urb->bandwidth;
334         if (isoc)
335                 dev->bus->bandwidth_isoc_reqs--;
336         else
337                 dev->bus->bandwidth_int_reqs--;
338
339 #ifdef USB_BANDWIDTH_MESSAGES
340         dbg("bandwidth alloc reduced by %d to %d for %d requesters",
341                 urb->bandwidth,
342                 dev->bus->bandwidth_allocated,
343                 dev->bus->bandwidth_int_reqs + dev->bus->bandwidth_isoc_reqs);
344 #endif
345         urb->bandwidth = 0;
346 }
347
348 /**
349  *      usb_alloc_bus - creates a new USB host controller structure
350  *      @op: pointer to a struct usb_operations that this bus structure should use
351  *
352  *      Creates a USB host controller bus structure with the specified 
353  *      usb_operations and initializes all the necessary internal objects.
354  *      (For use only by USB Host Controller Drivers.)
355  *
356  *      If no memory is available, NULL is returned.
357  *
358  *      The caller should call usb_free_bus() when it is finished with the structure.
359  */
360 struct usb_bus *usb_alloc_bus(struct usb_operations *op)
361 {
362         struct usb_bus *bus;
363
364         bus = kmalloc(sizeof(*bus), GFP_KERNEL);
365         if (!bus)
366                 return NULL;
367
368         memset(&bus->devmap, 0, sizeof(struct usb_devmap));
369
370         bus->op = op;
371         bus->root_hub = NULL;
372         bus->hcpriv = NULL;
373         bus->busnum = -1;
374         bus->bandwidth_allocated = 0;
375         bus->bandwidth_int_reqs  = 0;
376         bus->bandwidth_isoc_reqs = 0;
377
378         INIT_LIST_HEAD(&bus->bus_list);
379         INIT_LIST_HEAD(&bus->inodes);
380
381         return bus;
382 }
383
384 /**
385  *      usb_free_bus - frees the memory used by a bus structure
386  *      @bus: pointer to the bus to free
387  *
388  *      (For use only by USB Host Controller Drivers.)
389  */
390 void usb_free_bus(struct usb_bus *bus)
391 {
392         if (!bus)
393                 return;
394
395         kfree(bus);
396 }
397
398 /**
399  *      usb_register_bus - registers the USB host controller with the usb core
400  *      @bus: pointer to the bus to register
401  *
402  *      (For use only by USB Host Controller Drivers.)
403  */
404 void usb_register_bus(struct usb_bus *bus)
405 {
406         int busnum;
407
408         busnum = find_next_zero_bit(busmap.busmap, USB_MAXBUS, 1);
409         if (busnum < USB_MAXBUS) {
410                 set_bit(busnum, busmap.busmap);
411                 bus->busnum = busnum;
412         } else
413                 warn("too many buses");
414
415         /* Add it to the list of buses */
416         list_add(&bus->bus_list, &usb_bus_list);
417
418         usbdevfs_add_bus(bus);
419
420         info("new USB bus registered, assigned bus number %d", bus->busnum);
421 }
422
423 /**
424  *      usb_deregister_bus - deregisters the USB host controller
425  *      @bus: pointer to the bus to deregister
426  *
427  *      (For use only by USB Host Controller Drivers.)
428  */
429 void usb_deregister_bus(struct usb_bus *bus)
430 {
431         info("USB bus %d deregistered", bus->busnum);
432
433         /*
434          * NOTE: make sure that all the devices are removed by the
435          * controller code, as well as having it call this when cleaning
436          * itself up
437          */
438         list_del(&bus->bus_list);
439
440         usbdevfs_remove_bus(bus);
441
442         clear_bit(bus->busnum, busmap.busmap);
443 }
444
445 /*
446  * This function is for doing a depth-first search for devices which
447  * have support, for dynamic loading of driver modules.
448  */
449 static void usb_check_support(struct usb_device *dev)
450 {
451         int i;
452
453         if (!dev) {
454                 err("null device being checked!!!");
455                 return;
456         }
457
458         for (i=0; i<USB_MAXCHILDREN; i++)
459                 if (dev->children[i])
460                         usb_check_support(dev->children[i]);
461
462         if (!dev->actconfig)
463                 return;
464
465         /* now we check this device */
466         if (dev->devnum > 0)
467                 for (i = 0; i < dev->actconfig->bNumInterfaces; i++)
468                         usb_find_interface_driver(dev, i);
469 }
470
471
472 /*
473  * This is intended to be used by usb device drivers that need to
474  * claim more than one interface on a device at once when probing
475  * (audio and acm are good examples).  No device driver should have
476  * to mess with the internal usb_interface or usb_device structure
477  * members.
478  */
479 void usb_driver_claim_interface(struct usb_driver *driver, struct usb_interface *iface, void* priv)
480 {
481         if (!iface || !driver)
482                 return;
483
484         dbg("%s driver claimed interface %p", driver->name, iface);
485
486         iface->driver = driver;
487         iface->private_data = priv;
488 } /* usb_driver_claim_interface() */
489
490 /*
491  * This should be used by drivers to check other interfaces to see if
492  * they are available or not.
493  */
494 int usb_interface_claimed(struct usb_interface *iface)
495 {
496         if (!iface)
497                 return 0;
498
499         return (iface->driver != NULL);
500 } /* usb_interface_claimed() */
501
502 /*
503  * This should be used by drivers to release their claimed interfaces
504  */
505 void usb_driver_release_interface(struct usb_driver *driver, struct usb_interface *iface)
506 {
507         /* this should never happen, don't release something that's not ours */
508         if (!iface || iface->driver != driver)
509                 return;
510
511         iface->driver = NULL;
512         iface->private_data = NULL;
513 }
514
515
516 /**
517  * usb_match_id - find first usb_device_id matching device or interface
518  * @dev: the device whose descriptors are considered when matching
519  * @interface: the interface of interest
520  * @id: array of usb_device_id structures, terminated by zero entry
521  *
522  * usb_match_id searches an array of usb_device_id's and returns
523  * the first one matching the device or interface, or null.
524  * This is used when binding (or rebinding) a driver to an interface.
525  * Most USB device drivers will use this indirectly, through the usb core,
526  * but some layered driver frameworks use it directly.
527  * These device tables are exported with MODULE_DEVICE_TABLE, through
528  * modutils and "modules.usbmap", to support the driver loading
529  * functionality of USB hotplugging.
530  *
531  * What Matches:
532  *
533  * The "match_flags" element in a usb_device_id controls which
534  * members are used.  If the corresponding bit is set, the
535  * value in the device_id must match its corresponding member
536  * in the device or interface descriptor, or else the device_id
537  * does not match.
538  *
539  * "driver_info" is normally used only by device drivers,
540  * but you can create a wildcard "matches anything" usb_device_id
541  * as a driver's "modules.usbmap" entry if you provide an id with
542  * only a nonzero "driver_info" field.  If you do this, the USB device
543  * driver's probe() routine should use additional intelligence to
544  * decide whether to bind to the specified interface.
545  * 
546  * What Makes Good usb_device_id Tables:
547  *
548  * The match algorithm is very simple, so that intelligence in
549  * driver selection must come from smart driver id records.
550  * Unless you have good reasons to use another selection policy,
551  * provide match elements only in related groups, and order match
552  * specifiers from specific to general.  Use the macros provided
553  * for that purpose if you can.
554  *
555  * The most specific match specifiers use device descriptor
556  * data.  These are commonly used with product-specific matches;
557  * the USB_DEVICE macro lets you provide vendor and product IDs,
558  * and you can also matche against ranges of product revisions.
559  * These are widely used for devices with application or vendor
560  * specific bDeviceClass values.
561  *
562  * Matches based on device class/subclass/protocol specifications
563  * are slightly more general; use the USB_DEVICE_INFO macro, or
564  * its siblings.  These are used with single-function devices
565  * where bDeviceClass doesn't specify that each interface has
566  * its own class. 
567  *
568  * Matches based on interface class/subclass/protocol are the
569  * most general; they let drivers bind to any interface on a
570  * multiple-function device.  Use the USB_INTERFACE_INFO
571  * macro, or its siblings, to match class-per-interface style 
572  * devices (as recorded in bDeviceClass).
573  *  
574  * Within those groups, remember that not all combinations are
575  * meaningful.  For example, don't give a product version range
576  * without vendor and product IDs; or specify a protocol without
577  * its associated class and subclass.
578  */   
579 const struct usb_device_id *
580 usb_match_id(struct usb_device *dev, struct usb_interface *interface,
581              const struct usb_device_id *id)
582 {
583         struct usb_interface_descriptor *intf = 0;
584
585         /* proc_connectinfo in devio.c may call us with id == NULL. */
586         if (id == NULL)
587                 return NULL;
588
589         /* It is important to check that id->driver_info is nonzero,
590            since an entry that is all zeroes except for a nonzero
591            id->driver_info is the way to create an entry that
592            indicates that the driver want to examine every
593            device and interface. */
594         for (; id->idVendor || id->bDeviceClass || id->bInterfaceClass ||
595                id->driver_info; id++) {
596
597                 if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
598                     id->idVendor != dev->descriptor.idVendor)
599                         continue;
600
601                 if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) &&
602                     id->idProduct != dev->descriptor.idProduct)
603                         continue;
604
605                 /* No need to test id->bcdDevice_lo != 0, since 0 is never
606                    greater than any unsigned number. */
607                 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) &&
608                     (id->bcdDevice_lo > dev->descriptor.bcdDevice))
609                         continue;
610
611                 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) &&
612                     (id->bcdDevice_hi < dev->descriptor.bcdDevice))
613                         continue;
614
615                 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) &&
616                     (id->bDeviceClass != dev->descriptor.bDeviceClass))
617                         continue;
618
619                 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) &&
620                     (id->bDeviceSubClass!= dev->descriptor.bDeviceSubClass))
621                         continue;
622
623                 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) &&
624                     (id->bDeviceProtocol != dev->descriptor.bDeviceProtocol))
625                         continue;
626
627                 intf = &interface->altsetting [interface->act_altsetting];
628
629                 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&
630                     (id->bInterfaceClass != intf->bInterfaceClass))
631                         continue;
632
633                 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) &&
634                     (id->bInterfaceSubClass != intf->bInterfaceSubClass))
635                     continue;
636
637                 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) &&
638                     (id->bInterfaceProtocol != intf->bInterfaceProtocol))
639                     continue;
640
641                 return id;
642         }
643
644         return NULL;
645 }
646
647 /*
648  * This entrypoint gets called for each new device.
649  *
650  * We now walk the list of registered USB drivers,
651  * looking for one that will accept this interface.
652  *
653  * "New Style" drivers use a table describing the devices and interfaces
654  * they handle.  Those tables are available to user mode tools deciding
655  * whether to load driver modules for a new device.
656  *
657  * The probe return value is changed to be a private pointer.  This way
658  * the drivers don't have to dig around in our structures to set the
659  * private pointer if they only need one interface. 
660  *
661  * Returns: 0 if a driver accepted the interface, -1 otherwise
662  */
663 static int usb_find_interface_driver(struct usb_device *dev, unsigned ifnum)
664 {
665         struct list_head *tmp;
666         struct usb_interface *interface;
667         void *private;
668         const struct usb_device_id *id;
669         struct usb_driver *driver;
670         int i;
671         
672         if ((!dev) || (ifnum >= dev->actconfig->bNumInterfaces)) {
673                 err("bad find_interface_driver params");
674                 return -1;
675         }
676
677         interface = dev->actconfig->interface + ifnum;
678
679         if (usb_interface_claimed(interface))
680                 return -1;
681
682         private = NULL;
683         for (tmp = usb_driver_list.next; tmp != &usb_driver_list;) {
684
685                 driver = list_entry(tmp, struct usb_driver, driver_list);
686                 tmp = tmp->next;
687
688                 down(&driver->serialize);
689                 id = driver->id_table;
690                 /* new style driver? */
691                 if (id) {
692                         for (i = 0; i < interface->num_altsetting; i++) {
693                                 interface->act_altsetting = i;
694                                 id = usb_match_id(dev, interface, id);
695                                 if (id) {
696                                         private = driver->probe(dev,ifnum,id);
697                                         if (private != NULL)
698                                                 break;
699                                 }
700                         }
701                         /* if driver not bound, leave defaults unchanged */
702                         if (private == NULL)
703                                 interface->act_altsetting = 0;
704                 }
705                 else /* "old style" driver */
706                         private = driver->probe(dev, ifnum, NULL);
707
708                 up(&driver->serialize);
709                 if (private) {
710                         usb_driver_claim_interface(driver, interface, private);
711                         return 0;
712                 }
713         }
714
715         return -1;
716 }
717
718
719 #ifdef  CONFIG_HOTPLUG
720
721 /*
722  * USB hotplugging invokes what /proc/sys/kernel/hotplug says
723  * (normally /sbin/hotplug) when USB devices get added or removed.
724  *
725  * This invokes a user mode policy agent, typically helping to load driver
726  * or other modules, configure the device, and more.  Drivers can provide
727  * a MODULE_DEVICE_TABLE to help with module loading subtasks.
728  *
729  * Some synchronization is important: removes can't start processing
730  * before the add-device processing completes, and vice versa.  That keeps
731  * a stack of USB-related identifiers stable while they're in use.  If we
732  * know that agents won't complete after they return (such as by forking
733  * a process that completes later), it's enough to just waitpid() for the
734  * agent -- as is currently done.
735  *
736  * The reason: we know we're called either from khubd (the typical case)
737  * or from root hub initialization (init, kapmd, modprobe, etc).  In both
738  * cases, we know no other thread can recycle our address, since we must
739  * already have been serialized enough to prevent that.
740  */
741 static void call_policy (char *verb, struct usb_device *dev)
742 {
743         char *argv [3], **envp, *buf, *scratch;
744         int i = 0, value;
745
746         if (!hotplug_path [0])
747                 return;
748         if (in_interrupt ()) {
749                 dbg ("In_interrupt");
750                 return;
751         }
752         if (!current->fs->root) {
753                 /* statically linked USB is initted rather early */
754                 dbg ("call_policy %s, num %d -- no FS yet", verb, dev->devnum);
755                 return;
756         }
757         if (dev->devnum < 0) {
758                 dbg ("device already deleted ??");
759                 return;
760         }
761         if (!(envp = (char **) kmalloc (20 * sizeof (char *), GFP_KERNEL))) {
762                 dbg ("enomem");
763                 return;
764         }
765         if (!(buf = kmalloc (256, GFP_KERNEL))) {
766                 kfree (envp);
767                 dbg ("enomem2");
768                 return;
769         }
770
771         /* only one standardized param to hotplug command: type */
772         argv [0] = hotplug_path;
773         argv [1] = "usb";
774         argv [2] = 0;
775
776         /* minimal command environment */
777         envp [i++] = "HOME=/";
778         envp [i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
779
780 #ifdef  DEBUG
781         /* hint that policy agent should enter no-stdout debug mode */
782         envp [i++] = "DEBUG=kernel";
783 #endif
784         /* extensible set of named bus-specific parameters,
785          * supporting multiple driver selection algorithms.
786          */
787         scratch = buf;
788
789         /* action:  add, remove */
790         envp [i++] = scratch;
791         scratch += sprintf (scratch, "ACTION=%s", verb) + 1;
792
793 #ifdef  CONFIG_USB_DEVICEFS
794         /* If this is available, userspace programs can directly read
795          * all the device descriptors we don't tell them about.  Or
796          * even act as usermode drivers.
797          *
798          * FIXME reduce hardwired intelligence here
799          */
800         envp [i++] = "DEVFS=/proc/bus/usb";
801         envp [i++] = scratch;
802         scratch += sprintf (scratch, "DEVICE=/proc/bus/usb/%03d/%03d",
803                 dev->bus->busnum, dev->devnum) + 1;
804 #endif
805
806         /* per-device configuration hacks are common */
807         envp [i++] = scratch;
808         scratch += sprintf (scratch, "PRODUCT=%x/%x/%x",
809                 dev->descriptor.idVendor,
810                 dev->descriptor.idProduct,
811                 dev->descriptor.bcdDevice) + 1;
812
813         /* class-based driver binding models */
814         envp [i++] = scratch;
815         scratch += sprintf (scratch, "TYPE=%d/%d/%d",
816                             dev->descriptor.bDeviceClass,
817                             dev->descriptor.bDeviceSubClass,
818                             dev->descriptor.bDeviceProtocol) + 1;
819         if (dev->descriptor.bDeviceClass == 0) {
820                 int alt = dev->actconfig->interface [0].act_altsetting;
821
822                 /* a simple/common case: one config, one interface, one driver
823                  * with current altsetting being a reasonable setting.
824                  * everything needs a smart agent and usbdevfs; or can rely on
825                  * device-specific binding policies.
826                  */
827                 envp [i++] = scratch;
828                 scratch += sprintf (scratch, "INTERFACE=%d/%d/%d",
829                         dev->actconfig->interface [0].altsetting [alt].bInterfaceClass,
830                         dev->actconfig->interface [0].altsetting [alt].bInterfaceSubClass,
831                         dev->actconfig->interface [0].altsetting [alt].bInterfaceProtocol)
832                         + 1;
833                 /* INTERFACE-0, INTERFACE-1, ... ? */
834         }
835         envp [i++] = 0;
836         /* assert: (scratch - buf) < sizeof buf */
837
838         /* NOTE: user mode daemons can call the agents too */
839
840         dbg ("kusbd: %s %s %d", argv [0], verb, dev->devnum);
841         value = call_usermodehelper (argv [0], argv, envp);
842         kfree (buf);
843         kfree (envp);
844         if (value != 0)
845                 dbg ("kusbd policy returned 0x%x", value);
846 }
847
848 #else
849
850 static inline void
851 call_policy (char *verb, struct usb_device *dev)
852 { } 
853
854 #endif  /* CONFIG_HOTPLUG */
855
856
857 /*
858  * This entrypoint gets called for each new device.
859  *
860  * All interfaces are scanned for matching drivers.
861  */
862 static void usb_find_drivers(struct usb_device *dev)
863 {
864         unsigned ifnum;
865         unsigned rejected = 0;
866         unsigned claimed = 0;
867
868         for (ifnum = 0; ifnum < dev->actconfig->bNumInterfaces; ifnum++) {
869                 /* if this interface hasn't already been claimed */
870                 if (!usb_interface_claimed(dev->actconfig->interface + ifnum)) {
871                         if (usb_find_interface_driver(dev, ifnum))
872                                 rejected++;
873                         else
874                                 claimed++;
875                 }
876         }
877  
878         if (rejected)
879                 dbg("unhandled interfaces on device");
880
881         if (!claimed) {
882                 warn("USB device %d (vend/prod 0x%x/0x%x) is not claimed by any active driver.",
883                         dev->devnum,
884                         dev->descriptor.idVendor,
885                         dev->descriptor.idProduct);
886 #ifdef DEBUG
887                 usb_show_device(dev);
888 #endif
889         }
890 }
891
892 /*
893  * Only HC's should call usb_alloc_dev and usb_free_dev directly
894  * Anybody may use usb_inc_dev_use or usb_dec_dev_use
895  */
896 struct usb_device *usb_alloc_dev(struct usb_device *parent, struct usb_bus *bus)
897 {
898         struct usb_device *dev;
899
900         dev = kmalloc(sizeof(*dev), GFP_KERNEL);
901         if (!dev)
902                 return NULL;
903
904         memset(dev, 0, sizeof(*dev));
905
906         dev->bus = bus;
907         dev->parent = parent;
908         atomic_set(&dev->refcnt, 1);
909         INIT_LIST_HEAD(&dev->inodes);
910         INIT_LIST_HEAD(&dev->filelist);
911
912         dev->bus->op->allocate(dev);
913
914         return dev;
915 }
916
917 void usb_free_dev(struct usb_device *dev)
918 {
919         if (atomic_dec_and_test(&dev->refcnt)) {
920                 dev->bus->op->deallocate(dev);
921                 usb_destroy_configuration(dev);
922                 kfree(dev);
923         }
924 }
925
926 void usb_inc_dev_use(struct usb_device *dev)
927 {
928         atomic_inc(&dev->refcnt);
929 }
930
931 /* ------------------------------------------------------------------------------------- 
932  * New USB Core Functions
933  * -------------------------------------------------------------------------------------*/
934
935 /**
936  *      usb_alloc_urb - creates a new urb for a USB driver to use
937  *      @iso_packets: number of iso packets for this urb
938  *
939  *      Creates an urb for the USB driver to use and returns a pointer to it.
940  *      If no memory is available, NULL is returned.
941  *
942  *      If the driver want to use this urb for interrupt, control, or bulk
943  *      endpoints, pass '0' as the number of iso packets.
944  *
945  *      The driver should call usb_free_urb() when it is finished with the urb.
946  */
947 urb_t *usb_alloc_urb(int iso_packets)
948 {
949         urb_t *urb;
950
951         urb = (urb_t *)kmalloc(sizeof(urb_t) + iso_packets * sizeof(iso_packet_descriptor_t),
952               in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
953         if (!urb) {
954                 err("alloc_urb: kmalloc failed");
955                 return NULL;
956         }
957
958         memset(urb, 0, sizeof(*urb));
959
960         spin_lock_init(&urb->lock);
961
962         return urb;
963 }
964
965 /**
966  *      usb_free_urb - frees the memory used by a urb
967  *      @urb: pointer to the urb to free
968  *
969  *      If an urb is created with a call to usb_create_urb() it should be
970  *      cleaned up with a call to usb_free_urb() when the driver is finished
971  *      with it.
972  */
973 void usb_free_urb(urb_t* urb)
974 {
975         if (urb)
976                 kfree(urb);
977 }
978 /*-------------------------------------------------------------------*/
979 int usb_submit_urb(urb_t *urb)
980 {
981         if (urb && urb->dev)
982                 return urb->dev->bus->op->submit_urb(urb);
983         else
984                 return -ENODEV;
985 }
986
987 /*-------------------------------------------------------------------*/
988 int usb_unlink_urb(urb_t *urb)
989 {
990         if (urb && urb->dev)
991                 return urb->dev->bus->op->unlink_urb(urb);
992         else
993                 return -ENODEV;
994 }
995 /*-------------------------------------------------------------------*
996  *                     COMPLETION HANDLERS                           *
997  *-------------------------------------------------------------------*/
998
999 /*-------------------------------------------------------------------*
1000  * completion handler for compatibility wrappers (sync control/bulk) *
1001  *-------------------------------------------------------------------*/
1002 static void usb_api_blocking_completion(urb_t *urb)
1003 {
1004         api_wrapper_data *awd = (api_wrapper_data *)urb->context;
1005
1006         if (waitqueue_active(awd->wakeup))
1007                 wake_up(awd->wakeup);
1008 #if 0
1009         else
1010                 dbg("(blocking_completion): waitqueue empty!"); 
1011                 // even occurs if urb was unlinked by timeout...
1012 #endif
1013 }
1014
1015 /*-------------------------------------------------------------------*
1016  *                         COMPATIBILITY STUFF                       *
1017  *-------------------------------------------------------------------*/
1018
1019 // Starts urb and waits for completion or timeout
1020 static int usb_start_wait_urb(urb_t *urb, int timeout, int* actual_length)
1021
1022         DECLARE_WAITQUEUE(wait, current);
1023         DECLARE_WAIT_QUEUE_HEAD(wqh);
1024         api_wrapper_data awd;
1025         int status;
1026   
1027         awd.wakeup = &wqh;
1028         init_waitqueue_head(&wqh);      
1029         current->state = TASK_INTERRUPTIBLE;
1030         add_wait_queue(&wqh, &wait);
1031         urb->context = &awd;
1032         status = usb_submit_urb(urb);
1033         if (status) {
1034                 // something went wrong
1035                 usb_free_urb(urb);
1036                 current->state = TASK_RUNNING;
1037                 remove_wait_queue(&wqh, &wait);
1038                 return status;
1039         }
1040
1041         if (urb->status == -EINPROGRESS) {
1042                 while (timeout && urb->status == -EINPROGRESS)
1043                         status = timeout = schedule_timeout(timeout);
1044         } else
1045                 status = 1;
1046
1047         current->state = TASK_RUNNING;
1048         remove_wait_queue(&wqh, &wait);
1049
1050         if (!status) {
1051                 // timeout
1052                 printk("usb_control/bulk_msg: timeout\n");
1053                 usb_unlink_urb(urb);  // remove urb safely
1054                 status = -ETIMEDOUT;
1055         } else
1056                 status = urb->status;
1057
1058         if (actual_length)
1059                 *actual_length = urb->actual_length;
1060
1061         usb_free_urb(urb);
1062         return status;
1063 }
1064
1065 /*-------------------------------------------------------------------*/
1066 // returns status (negative) or length (positive)
1067 int usb_internal_control_msg(struct usb_device *usb_dev, unsigned int pipe, 
1068                             devrequest *cmd,  void *data, int len, int timeout)
1069 {
1070         urb_t *urb;
1071         int retv;
1072         int length;
1073
1074         urb = usb_alloc_urb(0);
1075         if (!urb)
1076                 return -ENOMEM;
1077   
1078         FILL_CONTROL_URB(urb, usb_dev, pipe, (unsigned char*)cmd, data, len,    /* build urb */  
1079                    (usb_complete_t)usb_api_blocking_completion,0);
1080
1081         retv = usb_start_wait_urb(urb, timeout, &length);
1082         if (retv < 0)
1083                 return retv;
1084         else
1085                 return length;
1086         
1087 }
1088
1089 /**
1090  *      usb_control_msg - Builds a control urb, sends it off and waits for completion
1091  *      @dev: pointer to the usb device to send the message to
1092  *      @pipe: endpoint "pipe" to send the message to
1093  *      @request: USB message request value
1094  *      @requesttype: USB message request type value
1095  *      @value: USB message value
1096  *      @index: USB message index value
1097  *      @data: pointer to the data to send
1098  *      @size: length in bytes of the data to send
1099  *      @timeout: time to wait for the message to complete before timing out (if 0 the wait is forever)
1100  *
1101  *      This function sends a simple control message to a specified endpoint
1102  *      and waits for the message to complete, or timeout.
1103  *      
1104  *      If successful, it returns 0, othwise a negative error number.
1105  *
1106  *      Don't use this function from within an interrupt context, like a
1107  *      bottom half handler.  If you need a asyncronous message, or need to send
1108  *      a message from within interrupt context, use usb_submit_urb()
1109  */
1110 int usb_control_msg(struct usb_device *dev, unsigned int pipe, __u8 request, __u8 requesttype,
1111                          __u16 value, __u16 index, void *data, __u16 size, int timeout)
1112 {
1113         devrequest *dr = kmalloc(sizeof(devrequest), GFP_KERNEL);
1114         int ret;
1115         
1116         if (!dr)
1117                 return -ENOMEM;
1118
1119         dr->requesttype = requesttype;
1120         dr->request = request;
1121         dr->value = cpu_to_le16p(&value);
1122         dr->index = cpu_to_le16p(&index);
1123         dr->length = cpu_to_le16p(&size);
1124
1125         //dbg("usb_control_msg");       
1126
1127         ret = usb_internal_control_msg(dev, pipe, dr, data, size, timeout);
1128
1129         kfree(dr);
1130
1131         return ret;
1132 }
1133
1134
1135 /**
1136  *      usb_bulk_msg - Builds a bulk urb, sends it off and waits for completion
1137  *      @usb_dev: pointer to the usb device to send the message to
1138  *      @pipe: endpoint "pipe" to send the message to
1139  *      @data: pointer to the data to send
1140  *      @len: length in bytes of the data to send
1141  *      @actual_length: pointer to a location to put the actual length transfered in bytes
1142  *      @timeout: time to wait for the message to complete before timing out (if 0 the wait is forever)
1143  *
1144  *      This function sends a simple bulk message to a specified endpoint
1145  *      and waits for the message to complete, or timeout.
1146  *      
1147  *      If successful, it returns 0, othwise a negative error number.
1148  *      The number of actual bytes transferred will be plaed in the 
1149  *      actual_timeout paramater.
1150  *
1151  *      Don't use this function from within an interrupt context, like a
1152  *      bottom half handler.  If you need a asyncronous message, or need to
1153  *      send a message from within interrupt context, use usb_submit_urb()
1154  */
1155 int usb_bulk_msg(struct usb_device *usb_dev, unsigned int pipe, 
1156                         void *data, int len, int *actual_length, int timeout)
1157 {
1158         urb_t *urb;
1159
1160         if (len < 0)
1161                 return -EINVAL;
1162
1163         urb=usb_alloc_urb(0);
1164         if (!urb)
1165                 return -ENOMEM;
1166
1167         FILL_BULK_URB(urb,usb_dev,pipe,(unsigned char*)data,len,   /* build urb */
1168                         (usb_complete_t)usb_api_blocking_completion,0);
1169
1170         return usb_start_wait_urb(urb,timeout,actual_length);
1171 }
1172
1173 /*
1174  * usb_get_current_frame_number()
1175  *
1176  * returns the current frame number for the parent USB bus/controller
1177  * of the given USB device.
1178  */
1179 int usb_get_current_frame_number(struct usb_device *usb_dev)
1180 {
1181         return usb_dev->bus->op->get_frame_number (usb_dev);
1182 }
1183 /*-------------------------------------------------------------------*/
1184
1185 static int usb_parse_endpoint(struct usb_device *dev, struct usb_endpoint_descriptor *endpoint, unsigned char *buffer, int size)
1186 {
1187         struct usb_descriptor_header *header;
1188         unsigned char *begin;
1189         int parsed = 0, len, numskipped;
1190
1191         header = (struct usb_descriptor_header *)buffer;
1192
1193         /* Everything should be fine being passed into here, but we sanity */
1194         /*  check JIC */
1195         if (header->bLength > size) {
1196                 err("ran out of descriptors parsing");
1197                 return -1;
1198         }
1199                 
1200         if (header->bDescriptorType != USB_DT_ENDPOINT) {
1201                 warn("unexpected descriptor 0x%X, expecting endpoint descriptor, type 0x%X",
1202                         endpoint->bDescriptorType, USB_DT_ENDPOINT);
1203                 return parsed;
1204         }
1205
1206         if (header->bLength == USB_DT_ENDPOINT_AUDIO_SIZE)
1207                 memcpy(endpoint, buffer, USB_DT_ENDPOINT_AUDIO_SIZE);
1208         else
1209                 memcpy(endpoint, buffer, USB_DT_ENDPOINT_SIZE);
1210         
1211         le16_to_cpus(&endpoint->wMaxPacketSize);
1212
1213         buffer += header->bLength;
1214         size -= header->bLength;
1215         parsed += header->bLength;
1216
1217         /* Skip over the rest of the Class Specific or Vendor Specific */
1218         /*  descriptors */
1219         begin = buffer;
1220         numskipped = 0;
1221         while (size >= sizeof(struct usb_descriptor_header)) {
1222                 header = (struct usb_descriptor_header *)buffer;
1223
1224                 if (header->bLength < 2) {
1225                         err("invalid descriptor length of %d", header->bLength);
1226                         return -1;
1227                 }
1228
1229                 /* If we find another descriptor which is at or below us */
1230                 /*  in the descriptor heirarchy then we're done  */
1231                 if ((header->bDescriptorType == USB_DT_ENDPOINT) ||
1232                     (header->bDescriptorType == USB_DT_INTERFACE) ||
1233                     (header->bDescriptorType == USB_DT_CONFIG) ||
1234                     (header->bDescriptorType == USB_DT_DEVICE))
1235                         break;
1236
1237                 dbg("skipping descriptor 0x%X",
1238                         header->bDescriptorType);
1239                 numskipped++;
1240
1241                 buffer += header->bLength;
1242                 size -= header->bLength;
1243                 parsed += header->bLength;
1244         }
1245         if (numskipped)
1246                 dbg("skipped %d class/vendor specific endpoint descriptors", numskipped);
1247
1248         /* Copy any unknown descriptors into a storage area for drivers */
1249         /*  to later parse */
1250         len = (int)(buffer - begin);
1251         if (!len) {
1252                 endpoint->extra = NULL;
1253                 endpoint->extralen = 0;
1254                 return parsed;
1255         }
1256
1257         endpoint->extra = kmalloc(len, GFP_KERNEL);
1258
1259         if (!endpoint->extra) {
1260                 err("couldn't allocate memory for endpoint extra descriptors");
1261                 endpoint->extralen = 0;
1262                 return parsed;
1263         }
1264
1265         memcpy(endpoint->extra, begin, len);
1266         endpoint->extralen = len;
1267
1268         return parsed;
1269 }
1270
1271 static int usb_parse_interface(struct usb_device *dev, struct usb_interface *interface, unsigned char *buffer, int size)
1272 {
1273         int i, len, numskipped, retval, parsed = 0;
1274         struct usb_descriptor_header *header;
1275         struct usb_interface_descriptor *ifp;
1276         unsigned char *begin;
1277
1278         interface->act_altsetting = 0;
1279         interface->num_altsetting = 0;
1280         interface->max_altsetting = USB_ALTSETTINGALLOC;
1281
1282         interface->altsetting = kmalloc(sizeof(struct usb_interface_descriptor) * interface->max_altsetting, GFP_KERNEL);
1283         
1284         if (!interface->altsetting) {
1285                 err("couldn't kmalloc interface->altsetting");
1286                 return -1;
1287         }
1288
1289         while (size > 0) {
1290                 if (interface->num_altsetting >= interface->max_altsetting) {
1291                         void *ptr;
1292                         int oldmas;
1293
1294                         oldmas = interface->max_altsetting;
1295                         interface->max_altsetting += USB_ALTSETTINGALLOC;
1296                         if (interface->max_altsetting > USB_MAXALTSETTING) {
1297                                 warn("too many alternate settings (max %d)",
1298                                         USB_MAXALTSETTING);
1299                                 return -1;
1300                         }
1301
1302                         ptr = interface->altsetting;
1303                         interface->altsetting = kmalloc(sizeof(struct usb_interface_descriptor) * interface->max_altsetting, GFP_KERNEL);
1304                         if (!interface->altsetting) {
1305                                 err("couldn't kmalloc interface->altsetting");
1306                                 interface->altsetting = ptr;
1307                                 return -1;
1308                         }
1309                         memcpy(interface->altsetting, ptr, sizeof(struct usb_interface_descriptor) * oldmas);
1310
1311                         kfree(ptr);
1312                 }
1313
1314                 ifp = interface->altsetting + interface->num_altsetting;
1315                 interface->num_altsetting++;
1316
1317                 memcpy(ifp, buffer, USB_DT_INTERFACE_SIZE);
1318
1319                 /* Skip over the interface */
1320                 buffer += ifp->bLength;
1321                 parsed += ifp->bLength;
1322                 size -= ifp->bLength;
1323
1324                 begin = buffer;
1325                 numskipped = 0;
1326
1327                 /* Skip over any interface, class or vendor descriptors */
1328                 while (size >= sizeof(struct usb_descriptor_header)) {
1329                         header = (struct usb_descriptor_header *)buffer;
1330
1331                         if (header->bLength < 2) {
1332                                 err("invalid descriptor length of %d", header->bLength);
1333                                 return -1;
1334                         }
1335
1336                         /* If we find another descriptor which is at or below */
1337                         /*  us in the descriptor heirarchy then return */
1338                         if ((header->bDescriptorType == USB_DT_INTERFACE) ||
1339                             (header->bDescriptorType == USB_DT_ENDPOINT) ||
1340                             (header->bDescriptorType == USB_DT_CONFIG) ||
1341                             (header->bDescriptorType == USB_DT_DEVICE))
1342                                 break;
1343
1344                         numskipped++;
1345
1346                         buffer += header->bLength;
1347                         parsed += header->bLength;
1348                         size -= header->bLength;
1349                 }
1350
1351                 if (numskipped)
1352                         dbg("skipped %d class/vendor specific interface descriptors", numskipped);
1353
1354                 /* Copy any unknown descriptors into a storage area for */
1355                 /*  drivers to later parse */
1356                 len = (int)(buffer - begin);
1357                 if (!len) {
1358                         ifp->extra = NULL;
1359                         ifp->extralen = 0;
1360                 } else {
1361                         ifp->extra = kmalloc(len, GFP_KERNEL);
1362
1363                         if (!ifp->extra) {
1364                                 err("couldn't allocate memory for interface extra descriptors");
1365                                 ifp->extralen = 0;
1366                                 return -1;
1367                         }
1368                         memcpy(ifp->extra, begin, len);
1369                         ifp->extralen = len;
1370                 }
1371
1372                 /* Did we hit an unexpected descriptor? */
1373                 header = (struct usb_descriptor_header *)buffer;
1374                 if ((size >= sizeof(struct usb_descriptor_header)) &&
1375                     ((header->bDescriptorType == USB_DT_CONFIG) ||
1376                      (header->bDescriptorType == USB_DT_DEVICE)))
1377                         return parsed;
1378
1379                 if (ifp->bNumEndpoints > USB_MAXENDPOINTS) {
1380                         warn("too many endpoints");
1381                         return -1;
1382                 }
1383
1384                 ifp->endpoint = (struct usb_endpoint_descriptor *)
1385                         kmalloc(ifp->bNumEndpoints *
1386                         sizeof(struct usb_endpoint_descriptor), GFP_KERNEL);
1387                 if (!ifp->endpoint) {
1388                         err("out of memory");
1389                         return -1;      
1390                 }
1391
1392                 memset(ifp->endpoint, 0, ifp->bNumEndpoints *
1393                         sizeof(struct usb_endpoint_descriptor));
1394         
1395                 for (i = 0; i < ifp->bNumEndpoints; i++) {
1396                         header = (struct usb_descriptor_header *)buffer;
1397
1398                         if (header->bLength > size) {
1399                                 err("ran out of descriptors parsing");
1400                                 return -1;
1401                         }
1402                 
1403                         retval = usb_parse_endpoint(dev, ifp->endpoint + i, buffer, size);
1404                         if (retval < 0)
1405                                 return retval;
1406
1407                         buffer += retval;
1408                         parsed += retval;
1409                         size -= retval;
1410                 }
1411
1412                 /* We check to see if it's an alternate to this one */
1413                 ifp = (struct usb_interface_descriptor *)buffer;
1414                 if (size < USB_DT_INTERFACE_SIZE ||
1415                     ifp->bDescriptorType != USB_DT_INTERFACE ||
1416                     !ifp->bAlternateSetting)
1417                         return parsed;
1418         }
1419
1420         return parsed;
1421 }
1422
1423 int usb_parse_configuration(struct usb_device *dev, struct usb_config_descriptor *config, char *buffer)
1424 {
1425         int i, retval, size;
1426         struct usb_descriptor_header *header;
1427
1428         memcpy(config, buffer, USB_DT_CONFIG_SIZE);
1429         le16_to_cpus(&config->wTotalLength);
1430         size = config->wTotalLength;
1431
1432         if (config->bNumInterfaces > USB_MAXINTERFACES) {
1433                 warn("too many interfaces");
1434                 return -1;
1435         }
1436
1437         config->interface = (struct usb_interface *)
1438                 kmalloc(config->bNumInterfaces *
1439                 sizeof(struct usb_interface), GFP_KERNEL);
1440         dbg("kmalloc IF %p, numif %i", config->interface, config->bNumInterfaces);
1441         if (!config->interface) {
1442                 err("out of memory");
1443                 return -1;      
1444         }
1445
1446         memset(config->interface, 0,
1447                config->bNumInterfaces * sizeof(struct usb_interface));
1448
1449         buffer += config->bLength;
1450         size -= config->bLength;
1451         
1452         for (i = 0; i < config->bNumInterfaces; i++) {
1453                 int numskipped, len;
1454                 char *begin;
1455
1456                 /* Skip over the rest of the Class Specific or Vendor */
1457                 /*  Specific descriptors */
1458                 begin = buffer;
1459                 numskipped = 0;
1460                 while (size >= sizeof(struct usb_descriptor_header)) {
1461                         header = (struct usb_descriptor_header *)buffer;
1462
1463                         if ((header->bLength > size) || (header->bLength < 2)) {
1464                                 err("invalid descriptor length of %d", header->bLength);
1465                                 return -1;
1466                         }
1467
1468                         /* If we find another descriptor which is at or below */
1469                         /*  us in the descriptor heirarchy then we're done  */
1470                         if ((header->bDescriptorType == USB_DT_ENDPOINT) ||
1471                             (header->bDescriptorType == USB_DT_INTERFACE) ||
1472                             (header->bDescriptorType == USB_DT_CONFIG) ||
1473                             (header->bDescriptorType == USB_DT_DEVICE))
1474                                 break;
1475
1476                         dbg("skipping descriptor 0x%X", header->bDescriptorType);
1477                         numskipped++;
1478
1479                         buffer += header->bLength;
1480                         size -= header->bLength;
1481                 }
1482                 if (numskipped)
1483                         dbg("skipped %d class/vendor specific endpoint descriptors", numskipped);
1484
1485                 /* Copy any unknown descriptors into a storage area for */
1486                 /*  drivers to later parse */
1487                 len = (int)(buffer - begin);
1488                 if (!len) {
1489                         config->extra = NULL;
1490                         config->extralen = 0;
1491                 } else {
1492                         config->extra = kmalloc(len, GFP_KERNEL);
1493                         if (!config->extra) {
1494                                 err("couldn't allocate memory for config extra descriptors");
1495                                 config->extralen = 0;
1496                                 return -1;
1497                         }
1498
1499                         memcpy(config->extra, begin, len);
1500                         config->extralen = len;
1501                 }
1502
1503                 retval = usb_parse_interface(dev, config->interface + i, buffer, size);
1504                 if (retval < 0)
1505                         return retval;
1506
1507                 buffer += retval;
1508                 size -= retval;
1509         }
1510
1511         return size;
1512 }
1513
1514 void usb_destroy_configuration(struct usb_device *dev)
1515 {
1516         int c, i, j, k;
1517         
1518         if (!dev->config)
1519                 return;
1520
1521         if (dev->rawdescriptors) {
1522                 for (i = 0; i < dev->descriptor.bNumConfigurations; i++)
1523                         kfree(dev->rawdescriptors[i]);
1524
1525                 kfree(dev->rawdescriptors);
1526         }
1527
1528         for (c = 0; c < dev->descriptor.bNumConfigurations; c++) {
1529                 struct usb_config_descriptor *cf = &dev->config[c];
1530
1531                 if (!cf->interface)
1532                         break;
1533
1534                 for (i = 0; i < cf->bNumInterfaces; i++) {
1535                         struct usb_interface *ifp =
1536                                 &cf->interface[i];
1537                                 
1538                         if (!ifp->altsetting)
1539                                 break;
1540
1541                         for (j = 0; j < ifp->num_altsetting; j++) {
1542                                 struct usb_interface_descriptor *as =
1543                                         &ifp->altsetting[j];
1544                                         
1545                                 if(as->extra) {
1546                                         kfree(as->extra);
1547                                 }
1548
1549                                 if (!as->endpoint)
1550                                         break;
1551                                         
1552                                 for(k = 0; k < as->bNumEndpoints; k++) {
1553                                         if(as->endpoint[k].extra) {
1554                                                 kfree(as->endpoint[k].extra);
1555                                         }
1556                                 }       
1557                                 kfree(as->endpoint);
1558                         }
1559
1560                         kfree(ifp->altsetting);
1561                 }
1562                 kfree(cf->interface);
1563         }
1564         kfree(dev->config);
1565 }
1566
1567 /* for returning string descriptors in UTF-16LE */
1568 static int ascii2utf (char *ascii, __u8 *utf, int utfmax)
1569 {
1570         int retval;
1571
1572         for (retval = 0; *ascii && utfmax > 1; utfmax -= 2, retval += 2) {
1573                 *utf++ = *ascii++ & 0x7f;
1574                 *utf++ = 0;
1575         }
1576         return retval;
1577 }
1578
1579 /*
1580  * root_hub_string is used by each host controller's root hub code,
1581  * so that they're identified consistently throughout the system.
1582  */
1583 int usb_root_hub_string (int id, int serial, char *type, __u8 *data, int len)
1584 {
1585         char buf [30];
1586
1587         // assert (len > (2 * (sizeof (buf) + 1)));
1588         // assert (strlen (type) <= 8);
1589
1590         // language ids
1591         if (id == 0) {
1592                 *data++ = 4; *data++ = 3;       /* 4 bytes data */
1593                 *data++ = 0; *data++ = 0;       /* some language id */
1594                 return 4;
1595
1596         // serial number
1597         } else if (id == 1) {
1598                 sprintf (buf, "%x", serial);
1599
1600         // product description
1601         } else if (id == 2) {
1602                 sprintf (buf, "USB %s Root Hub", type);
1603
1604         // id 3 == vendor description
1605
1606         // unsupported IDs --> "stall"
1607         } else
1608             return 0;
1609
1610         data [0] = 2 + ascii2utf (buf, data + 2, len - 2);
1611         data [1] = 3;
1612         return data [0];
1613 }
1614
1615 /*
1616  * __usb_get_extra_descriptor() finds a descriptor of specific type in the
1617  * extra field of the interface and endpoint descriptor structs.
1618  */
1619
1620 int __usb_get_extra_descriptor(char *buffer, unsigned size, unsigned char type, void **ptr)
1621 {
1622         struct usb_descriptor_header *header;
1623
1624         while (size >= sizeof(struct usb_descriptor_header)) {
1625                 header = (struct usb_descriptor_header *)buffer;
1626
1627                 if (header->bLength < 2) {
1628                         err("invalid descriptor length of %d", header->bLength);
1629                         return -1;
1630                 }
1631
1632                 if (header->bDescriptorType == type) {
1633                         *ptr = header;
1634                         return 0;
1635                 }
1636
1637                 buffer += header->bLength;
1638                 size -= header->bLength;
1639         }
1640         return -1;
1641 }
1642
1643 /*
1644  * Something got disconnected. Get rid of it, and all of its children.
1645  */
1646 void usb_disconnect(struct usb_device **pdev)
1647 {
1648         struct usb_device * dev = *pdev;
1649         int i;
1650
1651         if (!dev)
1652                 return;
1653
1654         *pdev = NULL;
1655
1656         info("USB disconnect on device %d", dev->devnum);
1657
1658         if (dev->actconfig) {
1659                 for (i = 0; i < dev->actconfig->bNumInterfaces; i++) {
1660                         struct usb_interface *interface = &dev->actconfig->interface[i];
1661                         struct usb_driver *driver = interface->driver;
1662                         if (driver) {
1663                                 down(&driver->serialize);
1664                                 driver->disconnect(dev, interface->private_data);
1665                                 up(&driver->serialize);
1666                                 /* if driver->disconnect didn't release the interface */
1667                                 if (interface->driver)
1668                                         usb_driver_release_interface(driver, interface);
1669                         }
1670                 }
1671         }
1672
1673         /* Free up all the children.. */
1674         for (i = 0; i < USB_MAXCHILDREN; i++) {
1675                 struct usb_device **child = dev->children + i;
1676                 if (*child)
1677                         usb_disconnect(child);
1678         }
1679
1680         /* Let policy agent unload modules etc */
1681         call_policy ("remove", dev);
1682
1683         /* Free the device number and remove the /proc/bus/usb entry */
1684         if (dev->devnum > 0) {
1685                 clear_bit(dev->devnum, &dev->bus->devmap.devicemap);
1686                 usbdevfs_remove_device(dev);
1687         }
1688
1689         /* Free up the device itself */
1690         usb_free_dev(dev);
1691 }
1692
1693 /*
1694  * Connect a new USB device. This basically just initializes
1695  * the USB device information and sets up the topology - it's
1696  * up to the low-level driver to reset the port and actually
1697  * do the setup (the upper levels don't know how to do that).
1698  */
1699 void usb_connect(struct usb_device *dev)
1700 {
1701         int devnum;
1702         // FIXME needs locking for SMP!!
1703         /* why? this is called only from the hub thread, 
1704          * which hopefully doesn't run on multiple CPU's simultaneously 8-)
1705          */
1706         dev->descriptor.bMaxPacketSize0 = 8;  /* Start off at 8 bytes  */
1707 #ifndef DEVNUM_ROUND_ROBIN
1708         devnum = find_next_zero_bit(dev->bus->devmap.devicemap, 128, 1);
1709 #else   /* round_robin alloc of devnums */
1710         /* Try to allocate the next devnum beginning at devnum_next. */
1711         devnum = find_next_zero_bit(dev->bus->devmap.devicemap, 128, devnum_next);
1712         if (devnum >= 128)
1713                 devnum = find_next_zero_bit(dev->bus->devmap.devicemap, 128, 1);
1714
1715         devnum_next = devnum + 1;
1716         if (devnum_next >= 128)
1717                 devnum_next = 1;
1718 #endif  /* round_robin alloc of devnums */
1719
1720         if (devnum < 128) {
1721                 set_bit(devnum, dev->bus->devmap.devicemap);
1722                 dev->devnum = devnum;
1723         }
1724 }
1725
1726 /*
1727  * These are the actual routines to send
1728  * and receive control messages.
1729  */
1730
1731 #define GET_TIMEOUT 3
1732 #define SET_TIMEOUT 3
1733
1734 int usb_set_address(struct usb_device *dev)
1735 {
1736         return usb_control_msg(dev, usb_snddefctrl(dev), USB_REQ_SET_ADDRESS,
1737                 0, dev->devnum, 0, NULL, 0, HZ * GET_TIMEOUT);
1738 }
1739
1740 int usb_get_descriptor(struct usb_device *dev, unsigned char type, unsigned char index, void *buf, int size)
1741 {
1742         int i = 5;
1743         int result;
1744         
1745         memset(buf,0,size);     // Make sure we parse really received data
1746
1747         while (i--) {
1748                 if ((result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
1749                         USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
1750                         (type << 8) + index, 0, buf, size, HZ * GET_TIMEOUT)) > 0 ||
1751                      result == -EPIPE)
1752                         break;  /* retry if the returned length was 0; flaky device */
1753         }
1754         return result;
1755 }
1756
1757 int usb_get_class_descriptor(struct usb_device *dev, int ifnum,
1758                 unsigned char type, unsigned char id, void *buf, int size)
1759 {
1760         return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
1761                 USB_REQ_GET_DESCRIPTOR, USB_RECIP_INTERFACE | USB_DIR_IN,
1762                 (type << 8) + id, ifnum, buf, size, HZ * GET_TIMEOUT);
1763 }
1764
1765 int usb_get_string(struct usb_device *dev, unsigned short langid, unsigned char index, void *buf, int size)
1766 {
1767         return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
1768                 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
1769                 (USB_DT_STRING << 8) + index, langid, buf, size, HZ * GET_TIMEOUT);
1770 }
1771
1772 int usb_get_device_descriptor(struct usb_device *dev)
1773 {
1774         int ret = usb_get_descriptor(dev, USB_DT_DEVICE, 0, &dev->descriptor,
1775                                      sizeof(dev->descriptor));
1776         if (ret >= 0) {
1777                 le16_to_cpus(&dev->descriptor.bcdUSB);
1778                 le16_to_cpus(&dev->descriptor.idVendor);
1779                 le16_to_cpus(&dev->descriptor.idProduct);
1780                 le16_to_cpus(&dev->descriptor.bcdDevice);
1781         }
1782         return ret;
1783 }
1784
1785 int usb_get_status(struct usb_device *dev, int type, int target, void *data)
1786 {
1787         return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
1788                 USB_REQ_GET_STATUS, USB_DIR_IN | type, 0, target, data, 2, HZ * GET_TIMEOUT);
1789 }
1790
1791 int usb_get_protocol(struct usb_device *dev, int ifnum)
1792 {
1793         unsigned char type;
1794         int ret;
1795
1796         if ((ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
1797             USB_REQ_GET_PROTOCOL, USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1798             0, ifnum, &type, 1, HZ * GET_TIMEOUT)) < 0)
1799                 return ret;
1800
1801         return type;
1802 }
1803
1804 int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol)
1805 {
1806         return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1807                 USB_REQ_SET_PROTOCOL, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1808                 protocol, ifnum, NULL, 0, HZ * SET_TIMEOUT);
1809 }
1810
1811 int usb_set_idle(struct usb_device *dev, int ifnum, int duration, int report_id)
1812 {
1813         return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1814                 USB_REQ_SET_IDLE, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1815                 (duration << 8) | report_id, ifnum, NULL, 0, HZ * SET_TIMEOUT);
1816 }
1817
1818 void usb_set_maxpacket(struct usb_device *dev)
1819 {
1820         int i, b;
1821
1822         for (i=0; i<dev->actconfig->bNumInterfaces; i++) {
1823                 struct usb_interface *ifp = dev->actconfig->interface + i;
1824                 struct usb_interface_descriptor *as = ifp->altsetting + ifp->act_altsetting;
1825                 struct usb_endpoint_descriptor *ep = as->endpoint;
1826                 int e;
1827
1828                 for (e=0; e<as->bNumEndpoints; e++) {
1829                         b = ep[e].bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
1830                         if ((ep[e].bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
1831                                 USB_ENDPOINT_XFER_CONTROL) {    /* Control => bidirectional */
1832                                 dev->epmaxpacketout[b] = ep[e].wMaxPacketSize;
1833                                 dev->epmaxpacketin [b] = ep[e].wMaxPacketSize;
1834                                 }
1835                         else if (usb_endpoint_out(ep[e].bEndpointAddress)) {
1836                                 if (ep[e].wMaxPacketSize > dev->epmaxpacketout[b])
1837                                         dev->epmaxpacketout[b] = ep[e].wMaxPacketSize;
1838                         }
1839                         else {
1840                                 if (ep[e].wMaxPacketSize > dev->epmaxpacketin [b])
1841                                         dev->epmaxpacketin [b] = ep[e].wMaxPacketSize;
1842                         }
1843                 }
1844         }
1845 }
1846
1847 /*
1848  * endp: endpoint number in bits 0-3;
1849  *      direction flag in bit 7 (1 = IN, 0 = OUT)
1850  */
1851 int usb_clear_halt(struct usb_device *dev, int pipe)
1852 {
1853         int result;
1854         __u16 status;
1855         int endp=usb_pipeendpoint(pipe)|(usb_pipein(pipe)<<7);
1856
1857 /*
1858         if (!usb_endpoint_halted(dev, endp & 0x0f, usb_endpoint_out(endp)))
1859                 return 0;
1860 */
1861
1862         result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1863                 USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT, 0, endp, NULL, 0, HZ * SET_TIMEOUT);
1864
1865         /* don't clear if failed */
1866         if (result < 0)
1867                 return result;
1868
1869         result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
1870                 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RECIP_ENDPOINT, 0, endp,
1871                 &status, sizeof(status), HZ * SET_TIMEOUT);
1872         if (result < 0)
1873                 return result;
1874
1875         if (le16_to_cpu(status) & 1)
1876                 return -EPIPE;          /* still halted */
1877
1878         usb_endpoint_running(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe));
1879
1880         /* toggle is reset on clear */
1881
1882         usb_settoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe), 0);
1883
1884         return 0;
1885 }
1886
1887 int usb_set_interface(struct usb_device *dev, int interface, int alternate)
1888 {
1889         struct usb_interface *iface;
1890         int ret;
1891
1892         iface = usb_ifnum_to_if(dev, interface);
1893         if (!iface) {
1894                 warn("selecting invalid interface %d", interface);
1895                 return -EINVAL;
1896         }
1897
1898         if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1899             USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE, alternate,
1900             interface, NULL, 0, HZ * 5)) < 0)
1901                 return ret;
1902
1903         iface->act_altsetting = alternate;
1904         dev->toggle[0] = 0;     /* 9.1.1.5 says to do this */
1905         dev->toggle[1] = 0;
1906         usb_set_maxpacket(dev);
1907         return 0;
1908 }
1909
1910 int usb_set_configuration(struct usb_device *dev, int configuration)
1911 {
1912         int i, ret;
1913         struct usb_config_descriptor *cp = NULL;
1914         
1915         for (i=0; i<dev->descriptor.bNumConfigurations; i++) {
1916                 if (dev->config[i].bConfigurationValue == configuration) {
1917                         cp = &dev->config[i];
1918                         break;
1919                 }
1920         }
1921         if (!cp) {
1922                 warn("selecting invalid configuration %d", configuration);
1923                 return -EINVAL;
1924         }
1925
1926         if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1927             USB_REQ_SET_CONFIGURATION, 0, configuration, 0, NULL, 0, HZ * SET_TIMEOUT)) < 0)
1928                 return ret;
1929
1930         dev->actconfig = cp;
1931         dev->toggle[0] = 0;
1932         dev->toggle[1] = 0;
1933         usb_set_maxpacket(dev);
1934
1935         return 0;
1936 }
1937
1938 int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type, unsigned char id, void *buf, int size)
1939 {
1940         return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
1941                 USB_REQ_GET_REPORT, USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1942                 (type << 8) + id, ifnum, buf, size, HZ * GET_TIMEOUT);
1943 }
1944
1945 int usb_set_report(struct usb_device *dev, int ifnum, unsigned char type, unsigned char id, void *buf, int size)
1946 {
1947         return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1948                 USB_REQ_SET_REPORT, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1949                 (type << 8) + id, ifnum, buf, size, HZ);
1950 }
1951
1952 int usb_get_configuration(struct usb_device *dev)
1953 {
1954         int result;
1955         unsigned int cfgno, length;
1956         unsigned char buffer[8];
1957         unsigned char *bigbuffer;
1958         struct usb_config_descriptor *desc =
1959                 (struct usb_config_descriptor *)buffer;
1960
1961         if (dev->descriptor.bNumConfigurations > USB_MAXCONFIG) {
1962                 warn("too many configurations");
1963                 return -EINVAL;
1964         }
1965
1966         if (dev->descriptor.bNumConfigurations < 1) {
1967                 warn("not enough configurations");
1968                 return -EINVAL;
1969         }
1970
1971         dev->config = (struct usb_config_descriptor *)
1972                 kmalloc(dev->descriptor.bNumConfigurations *
1973                 sizeof(struct usb_config_descriptor), GFP_KERNEL);
1974         if (!dev->config) {
1975                 err("out of memory");
1976                 return -ENOMEM; 
1977         }
1978         memset(dev->config, 0, dev->descriptor.bNumConfigurations *
1979                 sizeof(struct usb_config_descriptor));
1980
1981         dev->rawdescriptors = (char **)kmalloc(sizeof(char *) *
1982                 dev->descriptor.bNumConfigurations, GFP_KERNEL);
1983         if (!dev->rawdescriptors) {
1984                 err("out of memory");
1985                 return -ENOMEM;
1986         }
1987
1988         for (cfgno = 0; cfgno < dev->descriptor.bNumConfigurations; cfgno++) {
1989                 /* We grab the first 8 bytes so we know how long the whole */
1990                 /*  configuration is */
1991                 result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, 8);
1992                 if (result < 8) {
1993                         if (result < 0)
1994                                 err("unable to get descriptor");
1995                         else {
1996                                 err("config descriptor too short (expected %i, got %i)", 8, result);
1997                                 result = -EINVAL;
1998                         }
1999                         goto err;
2000                 }
2001
2002                 /* Get the full buffer */
2003                 length = le16_to_cpu(desc->wTotalLength);
2004
2005                 bigbuffer = kmalloc(length, GFP_KERNEL);
2006                 if (!bigbuffer) {
2007                         err("unable to allocate memory for configuration descriptors");
2008                         result = -ENOMEM;
2009                         goto err;
2010                 }
2011
2012                 /* Now that we know the length, get the whole thing */
2013                 result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, bigbuffer, length);
2014                 if (result < 0) {
2015                         err("couldn't get all of config descriptors");
2016                         kfree(bigbuffer);
2017                         goto err;
2018                 }       
2019         
2020                 if (result < length) {
2021                         err("config descriptor too short (expected %i, got %i)", length, result);
2022                         result = -EINVAL;
2023                         kfree(bigbuffer);
2024                         goto err;
2025                 }
2026
2027                 dev->rawdescriptors[cfgno] = bigbuffer;
2028
2029                 result = usb_parse_configuration(dev, &dev->config[cfgno], bigbuffer);
2030                 if (result > 0)
2031                         dbg("descriptor data left");
2032                 else if (result < 0) {
2033                         result = -EINVAL;
2034                         goto err;
2035                 }
2036         }
2037
2038         return 0;
2039 err:
2040         dev->descriptor.bNumConfigurations = cfgno;
2041         return result;
2042 }
2043
2044 /*
2045  * usb_string:
2046  *      returns string length (> 0) or error (< 0)
2047  */
2048 int usb_string(struct usb_device *dev, int index, char *buf, size_t size)
2049 {
2050         unsigned char *tbuf;
2051         int err;
2052         unsigned int u, idx;
2053
2054         if (size <= 0 || !buf || !index)
2055                 return -EINVAL;
2056         buf[0] = 0;
2057         tbuf = kmalloc(256, GFP_KERNEL);
2058         if (!tbuf)
2059                 return -ENOMEM;
2060
2061         /* get langid for strings if it's not yet known */
2062         if (!dev->have_langid) {
2063                 err = usb_get_string(dev, 0, 0, tbuf, 4);
2064                 if (err < 0) {
2065                         err("error getting string descriptor 0 (error=%d)", err);
2066                         goto errout;
2067                 } else if (tbuf[0] < 4) {
2068                         err("string descriptor 0 too short");
2069                         err = -EINVAL;
2070                         goto errout;
2071                 } else {
2072                         dev->have_langid = -1;
2073                         dev->string_langid = tbuf[2] | (tbuf[3]<< 8);
2074                                 /* always use the first langid listed */
2075                         dbg("USB device number %d default language ID 0x%x",
2076                                 dev->devnum, dev->string_langid);
2077                 }
2078         }
2079
2080         /*
2081          * Just ask for a maximum length string and then take the length
2082          * that was returned.
2083          */
2084         err = usb_get_string(dev, dev->string_langid, index, tbuf, 255);
2085         if (err < 0)
2086                 goto errout;
2087
2088         size--;         /* leave room for trailing NULL char in output buffer */
2089         for (idx = 0, u = 2; u < err; u += 2) {
2090                 if (idx >= size)
2091                         break;
2092                 if (tbuf[u+1])                  /* high byte */
2093                         buf[idx++] = '?';  /* non-ASCII character */
2094                 else
2095                         buf[idx++] = tbuf[u];
2096         }
2097         buf[idx] = 0;
2098         err = idx;
2099
2100  errout:
2101         kfree(tbuf);
2102         return err;
2103 }
2104
2105 /*
2106  * By the time we get here, the device has gotten a new device ID
2107  * and is in the default state. We need to identify the thing and
2108  * get the ball rolling..
2109  *
2110  * Returns 0 for success, != 0 for error.
2111  */
2112 int usb_new_device(struct usb_device *dev)
2113 {
2114         int err;
2115
2116         /* USB v1.1 5.5.3 */
2117         /* We read the first 8 bytes from the device descriptor to get to */
2118         /*  the bMaxPacketSize0 field. Then we set the maximum packet size */
2119         /*  for the control pipe, and retrieve the rest */
2120         dev->epmaxpacketin [0] = 8;
2121         dev->epmaxpacketout[0] = 8;
2122
2123         err = usb_set_address(dev);
2124         if (err < 0) {
2125                 err("USB device not accepting new address=%d (error=%d)",
2126                         dev->devnum, err);
2127                 clear_bit(dev->devnum, &dev->bus->devmap.devicemap);
2128                 dev->devnum = -1;
2129                 return 1;
2130         }
2131
2132         wait_ms(10);    /* Let the SET_ADDRESS settle */
2133
2134         err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, &dev->descriptor, 8);
2135         if (err < 8) {
2136                 if (err < 0)
2137                         err("USB device not responding, giving up (error=%d)", err);
2138                 else
2139                         err("USB device descriptor short read (expected %i, got %i)", 8, err);
2140                 clear_bit(dev->devnum, &dev->bus->devmap.devicemap);
2141                 dev->devnum = -1;
2142                 return 1;
2143         }
2144         dev->epmaxpacketin [0] = dev->descriptor.bMaxPacketSize0;
2145         dev->epmaxpacketout[0] = dev->descriptor.bMaxPacketSize0;
2146
2147         err = usb_get_device_descriptor(dev);
2148         if (err < sizeof(dev->descriptor)) {
2149                 if (err < 0)
2150                         err("unable to get device descriptor (error=%d)", err);
2151                 else
2152                         err("USB device descriptor short read (expected %i, got %i)",
2153                                 sizeof(dev->descriptor), err);
2154         
2155                 clear_bit(dev->devnum, &dev->bus->devmap.devicemap);
2156                 dev->devnum = -1;
2157                 return 1;
2158         }
2159
2160         err = usb_get_configuration(dev);
2161         if (err < 0) {
2162                 err("unable to get device %d configuration (error=%d)",
2163                         dev->devnum, err);
2164                 clear_bit(dev->devnum, &dev->bus->devmap.devicemap);
2165                 dev->devnum = -1;
2166                 usb_free_dev(dev);
2167                 return 1;
2168         }
2169
2170         /* we set the default configuration here */
2171         err = usb_set_configuration(dev, dev->config[0].bConfigurationValue);
2172         if (err) {
2173                 err("failed to set device %d default configuration (error=%d)",
2174                         dev->devnum, err);
2175                 clear_bit(dev->devnum, &dev->bus->devmap.devicemap);
2176                 dev->devnum = -1;
2177                 return 1;
2178         }
2179
2180         dbg("new device strings: Mfr=%d, Product=%d, SerialNumber=%d",
2181                 dev->descriptor.iManufacturer, dev->descriptor.iProduct, dev->descriptor.iSerialNumber);
2182 #ifdef DEBUG
2183         if (dev->descriptor.iManufacturer)
2184                 usb_show_string(dev, "Manufacturer", dev->descriptor.iManufacturer);
2185         if (dev->descriptor.iProduct)
2186                 usb_show_string(dev, "Product", dev->descriptor.iProduct);
2187         if (dev->descriptor.iSerialNumber)
2188                 usb_show_string(dev, "SerialNumber", dev->descriptor.iSerialNumber);
2189 #endif
2190
2191         /* now that the basic setup is over, add a /proc/bus/usb entry */
2192         usbdevfs_add_device(dev);
2193
2194         /* find drivers willing to handle this device */
2195         usb_find_drivers(dev);
2196
2197         /* userspace may load modules and/or configure further */
2198         call_policy ("add", dev);
2199
2200         return 0;
2201 }
2202
2203 static int usb_open(struct inode * inode, struct file * file)
2204 {
2205         int minor = MINOR(inode->i_rdev);
2206         struct usb_driver *c = usb_minors[minor/16];
2207         int err = -ENODEV;
2208         struct file_operations *old_fops, *new_fops = NULL;
2209
2210         /*
2211          * No load-on-demand? Randy, could you ACK that it's really not
2212          * supposed to be done?                                 -- AV
2213          */
2214         if (!c || !(new_fops = fops_get(c->fops)))
2215                 return err;
2216         old_fops = file->f_op;
2217         file->f_op = new_fops;
2218         /* Curiouser and curiouser... NULL ->open() as "no device" ? */
2219         if (file->f_op->open)
2220                 err = file->f_op->open(inode,file);
2221         if (err) {
2222                 fops_put(file->f_op);
2223                 file->f_op = fops_get(old_fops);
2224         }
2225         fops_put(old_fops);
2226         return err;
2227 }
2228
2229 static struct file_operations usb_fops = {
2230         owner:          THIS_MODULE,
2231         open:           usb_open,
2232 };
2233
2234 int usb_major_init(void)
2235 {
2236         if (devfs_register_chrdev(USB_MAJOR, "usb", &usb_fops)) {
2237                 err("unable to get major %d for usb devices", USB_MAJOR);
2238                 return -EBUSY;
2239         }
2240
2241         usb_devfs_handle = devfs_mk_dir(NULL, "usb", NULL);
2242
2243         return 0;
2244 }
2245
2246 void usb_major_cleanup(void)
2247 {
2248         devfs_unregister(usb_devfs_handle);
2249         devfs_unregister_chrdev(USB_MAJOR, "usb");
2250 }
2251
2252
2253 #ifdef CONFIG_PROC_FS
2254 struct list_head *usb_driver_get_list(void)
2255 {
2256         return &usb_driver_list;
2257 }
2258
2259 struct list_head *usb_bus_get_list(void)
2260 {
2261         return &usb_bus_list;
2262 }
2263 #endif
2264
2265
2266 /*
2267  * Init
2268  */
2269 static int __init usb_init(void)
2270 {
2271         usb_major_init();
2272         usbdevfs_init();
2273         usb_hub_init();
2274
2275         return 0;
2276 }
2277
2278 /*
2279  * Cleanup
2280  */
2281 static void __exit usb_exit(void)
2282 {
2283         usb_major_cleanup();
2284         usbdevfs_cleanup();
2285         usb_hub_cleanup();
2286 }
2287
2288 module_init(usb_init);
2289 module_exit(usb_exit);
2290
2291 /*
2292  * USB may be built into the kernel or be built as modules.
2293  * If the USB core [and maybe a host controller driver] is built
2294  * into the kernel, and other device drivers are built as modules,
2295  * then these symbols need to be exported for the modules to use.
2296  */
2297 EXPORT_SYMBOL(usb_ifnum_to_if);
2298 EXPORT_SYMBOL(usb_epnum_to_ep_desc);
2299
2300 EXPORT_SYMBOL(usb_register);
2301 EXPORT_SYMBOL(usb_deregister);
2302 EXPORT_SYMBOL(usb_scan_devices);
2303 EXPORT_SYMBOL(usb_alloc_bus);
2304 EXPORT_SYMBOL(usb_free_bus);
2305 EXPORT_SYMBOL(usb_register_bus);
2306 EXPORT_SYMBOL(usb_deregister_bus);
2307 EXPORT_SYMBOL(usb_alloc_dev);
2308 EXPORT_SYMBOL(usb_free_dev);
2309 EXPORT_SYMBOL(usb_inc_dev_use);
2310
2311 EXPORT_SYMBOL(usb_driver_claim_interface);
2312 EXPORT_SYMBOL(usb_interface_claimed);
2313 EXPORT_SYMBOL(usb_driver_release_interface);
2314 EXPORT_SYMBOL(usb_match_id);
2315
2316 EXPORT_SYMBOL(usb_root_hub_string);
2317 EXPORT_SYMBOL(usb_new_device);
2318 EXPORT_SYMBOL(usb_reset_device);
2319 EXPORT_SYMBOL(usb_connect);
2320 EXPORT_SYMBOL(usb_disconnect);
2321
2322 EXPORT_SYMBOL(usb_check_bandwidth);
2323 EXPORT_SYMBOL(usb_claim_bandwidth);
2324 EXPORT_SYMBOL(usb_release_bandwidth);
2325
2326 EXPORT_SYMBOL(usb_set_address);
2327 EXPORT_SYMBOL(usb_get_descriptor);
2328 EXPORT_SYMBOL(usb_get_class_descriptor);
2329 EXPORT_SYMBOL(__usb_get_extra_descriptor);
2330 EXPORT_SYMBOL(usb_get_device_descriptor);
2331 EXPORT_SYMBOL(usb_get_string);
2332 EXPORT_SYMBOL(usb_string);
2333 EXPORT_SYMBOL(usb_get_protocol);
2334 EXPORT_SYMBOL(usb_set_protocol);
2335 EXPORT_SYMBOL(usb_get_report);
2336 EXPORT_SYMBOL(usb_set_report);
2337 EXPORT_SYMBOL(usb_set_idle);
2338 EXPORT_SYMBOL(usb_clear_halt);
2339 EXPORT_SYMBOL(usb_set_interface);
2340 EXPORT_SYMBOL(usb_get_configuration);
2341 EXPORT_SYMBOL(usb_set_configuration);
2342
2343 EXPORT_SYMBOL(usb_get_current_frame_number);
2344
2345 EXPORT_SYMBOL(usb_alloc_urb);
2346 EXPORT_SYMBOL(usb_free_urb);
2347 EXPORT_SYMBOL(usb_submit_urb);
2348 EXPORT_SYMBOL(usb_unlink_urb);
2349
2350 EXPORT_SYMBOL(usb_control_msg);
2351 EXPORT_SYMBOL(usb_bulk_msg);
2352
2353 EXPORT_SYMBOL(usb_devfs_handle);