?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge with Linux 2.4.0-test5-pre3.
[linux-2.6/linux-mips.git] / drivers / usb / usb.c
blobbfac6098beae819b998c48aaf1e11df0857c25ac
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 *
11 * NOTE! This is not actually a driver at all, rather this is
12 * just a collection of helper routines that implement the
13 * generic USB things that the real drivers can use..
14 *
15 * Think of this as a "USB library" rather than anything else.
16 * It should be considered a slave, with no callbacks. Callbacks
17 * are evil.
18 *
19 * $Id: usb.c,v 1.53 2000/01/14 16:19:09 acher Exp $
20 */
21
22 #include <linux/config.h>
23 #include <linux/module.h>
24 #include <linux/string.h>
25 #include <linux/bitops.h>
26 #include <linux/malloc.h>
27 #include <linux/interrupt.h> /* for in_interrupt() */
28 #ifdef CONFIG_USB_DEBUG
29 #define DEBUG
30 #else
31 #undef DEBUG
32 #endif
33 #include <linux/usb.h>
34
35 static const int usb_bandwidth_option =
36 #ifdef CONFIG_USB_BANDWIDTH
37 1;
38 #else
39 0;
40 #endif
41
42 /*
43 * Prototypes for the device driver probing/loading functions
44 */
45 static void usb_find_drivers(struct usb_device *);
46 static int usb_find_interface_driver(struct usb_device *, unsigned int);
47 static void usb_check_support(struct usb_device *);
48
49 /*
50 * We have a per-interface "registered driver" list.
51 */
52 LIST_HEAD(usb_driver_list);
53 LIST_HEAD(usb_bus_list);
54
55 static struct usb_busmap busmap;
56
57 static struct usb_driver *usb_minors[16];
58
59 int usb_register(struct usb_driver *new_driver)
60 {
61 if (new_driver->fops != NULL) {
62 if (usb_minors[new_driver->minor/16]) {
63 err("error registering %s driver", new_driver->name);
64 return -EINVAL;
65 }
66 usb_minors[new_driver->minor/16] = new_driver;
67 }
68
69 info("registered new driver %s", new_driver->name);
70
71 init_MUTEX(&new_driver->serialize);
72
73 /* Add it to the list of known drivers */
74 list_add(&new_driver->driver_list, &usb_driver_list);
75
76 usb_scan_devices();
77
78 return 0;
79 }
80
81 /*
82 * We go through all existing devices, and see if any of them would
83 * be acceptable to the new driver.. This is done using a depth-first
84 * search for devices without a registered driver already, then
85 * running 'probe' with each of the drivers registered on every one
86 * of these.
87 */
88 void usb_scan_devices(void)
89 {
90 struct list_head *tmp;
91
92 tmp = usb_bus_list.next;
93 while (tmp != &usb_bus_list) {
94 struct usb_bus *bus = list_entry(tmp,struct usb_bus, bus_list);
95
96 tmp = tmp->next;
97 usb_check_support(bus->root_hub);
98 }
99 }
100
101 /*
102 * This function is part of a depth-first search down the device tree,
103 * removing any instances of a device driver.
104 */
105 static void usb_drivers_purge(struct usb_driver *driver,struct usb_device *dev)
106 {
107 int i;
108
109 if (!dev) {
110 err("null device being purged!!!");
111 return;
112 }
113
114 for (i=0; i<USB_MAXCHILDREN; i++)
115 if (dev->children[i])
116 usb_drivers_purge(driver, dev->children[i]);
117
118 if (!dev->actconfig)
119 return;
120
121 for (i = 0; i < dev->actconfig->bNumInterfaces; i++) {
122 struct usb_interface *interface = &dev->actconfig->interface[i];
123
124 if (interface->driver == driver) {
125 down(&driver->serialize);
126 driver->disconnect(dev, interface->private_data);
127 up(&driver->serialize);
128 usb_driver_release_interface(driver, interface);
129 /*
130 * This will go through the list looking for another
131 * driver that can handle the device
132 */
133 usb_find_interface_driver(dev, i);
134 }
135 }
136 }
137
138 /*
139 * Unlink a driver from the driver list when it is unloaded
140 */
141 void usb_deregister(struct usb_driver *driver)
142 {
143 struct list_head *tmp;
144
145 info("deregistering driver %s", driver->name);
146 if (driver->fops != NULL)
147 usb_minors[driver->minor/16] = NULL;
148
149 /*
150 * first we remove the driver, to be sure it doesn't get used by
151 * another thread while we are stepping through removing entries
152 */
153 list_del(&driver->driver_list);
154
155 tmp = usb_bus_list.next;
156 while (tmp != &usb_bus_list) {
157 struct usb_bus *bus = list_entry(tmp,struct usb_bus,bus_list);
158
159 tmp = tmp->next;
160 usb_drivers_purge(driver, bus->root_hub);
161 }
162 }
163
164 struct usb_interface *usb_ifnum_to_if(struct usb_device *dev, unsigned ifnum)
165 {
166 int i;
167
168 for (i = 0; i < dev->actconfig->bNumInterfaces; i++)
169 if (dev->actconfig->interface[i].altsetting[0].bInterfaceNumber == ifnum)
170 return &dev->actconfig->interface[i];
171
172 return NULL;
173 }
174
175 /*
176 * usb_calc_bus_time:
177 *
178 * returns (approximate) USB bus time in nanoseconds for a USB transaction.
179 */
180 static long usb_calc_bus_time (int low_speed, int input_dir, int isoc, int bytecount)
181 {
182 unsigned long tmp;
183
184 if (low_speed) /* no isoc. here */
185 {
186 if (input_dir)
187 {
188 tmp = (67667L * (31L + 10L * BitTime (bytecount))) / 1000L;
189 return (64060L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp);
190 }
191 else
192 {
193 tmp = (66700L * (31L + 10L * BitTime (bytecount))) / 1000L;
194 return (64107L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp);
195 }
196 }
197
198 /* for full-speed: */
199
200 if (!isoc) /* Input or Output */
201 {
202 tmp = (8354L * (31L + 10L * BitTime (bytecount))) / 1000L;
203 return (9107L + BW_HOST_DELAY + tmp);
204 } /* end not Isoc */
205
206 /* for isoc: */
207
208 tmp = (8354L * (31L + 10L * BitTime (bytecount))) / 1000L;
209 return (((input_dir) ? 7268L : 6265L) + BW_HOST_DELAY + tmp);
210 }
211
212 /*
213 * usb_check_bandwidth():
214 *
215 * old_alloc is from host_controller->bandwidth_allocated in microseconds;
216 * bustime is from calc_bus_time(), but converted to microseconds.
217 *
218 * returns <bustime in us> if successful,
219 * or USB_ST_BANDWIDTH_ERROR if bandwidth request fails.
220 *
221 * FIXME:
222 * This initial implementation does not use Endpoint.bInterval
223 * in managing bandwidth allocation.
224 * It probably needs to be expanded to use Endpoint.bInterval.
225 * This can be done as a later enhancement (correction).
226 * This will also probably require some kind of
227 * frame allocation tracking...meaning, for example,
228 * that if multiple drivers request interrupts every 10 USB frames,
229 * they don't all have to be allocated at
230 * frame numbers N, N+10, N+20, etc. Some of them could be at
231 * N+11, N+21, N+31, etc., and others at
232 * N+12, N+22, N+32, etc.
233 * However, this first cut at USB bandwidth allocation does not
234 * contain any frame allocation tracking.
235 */
236 int usb_check_bandwidth (struct usb_device *dev, struct urb *urb)
237 {
238 int new_alloc;
239 int old_alloc = dev->bus->bandwidth_allocated;
240 unsigned int pipe = urb->pipe;
241 long bustime;
242
243 bustime = usb_calc_bus_time (usb_pipeslow(pipe), usb_pipein(pipe),
244 usb_pipeisoc(pipe), usb_maxpacket(dev, pipe, usb_pipeout(pipe)));
245 if (usb_pipeisoc(pipe))
246 bustime = NS_TO_US(bustime) / urb->number_of_packets;
247 else
248 bustime = NS_TO_US(bustime);
249
250 new_alloc = old_alloc + (int)bustime;
251 /* what new total allocated bus time would be */
252
253 if (new_alloc > FRAME_TIME_MAX_USECS_ALLOC)
254 dbg("usb-check-bandwidth %sFAILED: was %u, would be %u, bustime = %ld us",
255 usb_bandwidth_option ? "" : "would have ",
256 old_alloc, new_alloc, bustime);
257
258 if (!usb_bandwidth_option) /* don't enforce it */
259 return (bustime);
260 return (new_alloc <= FRAME_TIME_MAX_USECS_ALLOC) ? bustime : USB_ST_BANDWIDTH_ERROR;
261 }
262
263 void usb_claim_bandwidth (struct usb_device *dev, struct urb *urb, int bustime, int isoc)
264 {
265 dev->bus->bandwidth_allocated += bustime;
266 if (isoc)
267 dev->bus->bandwidth_isoc_reqs++;
268 else
269 dev->bus->bandwidth_int_reqs++;
270 urb->bandwidth = bustime;
271
272 dbg("bw_alloc increased by %d to %d for %d requesters",
273 bustime,
274 dev->bus->bandwidth_allocated,
275 dev->bus->bandwidth_int_reqs + dev->bus->bandwidth_isoc_reqs);
276 }
277
278 /*
279 * usb_release_bandwidth():
280 *
281 * called to release a pipe's bandwidth (in microseconds)
282 */
283 void usb_release_bandwidth(struct usb_device *dev, struct urb *urb, int isoc)
284 {
285 dev->bus->bandwidth_allocated -= urb->bandwidth;
286 if (isoc)
287 dev->bus->bandwidth_isoc_reqs--;
288 else
289 dev->bus->bandwidth_int_reqs--;
290
291 dbg("bw_alloc reduced by %d to %d for %d requesters",
292 urb->bandwidth,
293 dev->bus->bandwidth_allocated,
294 dev->bus->bandwidth_int_reqs + dev->bus->bandwidth_isoc_reqs);
295 urb->bandwidth = 0;
296 }
297
298 /*
299 * New functions for (de)registering a controller
300 */
301 struct usb_bus *usb_alloc_bus(struct usb_operations *op)
302 {
303 struct usb_bus *bus;
304
305 bus = kmalloc(sizeof(*bus), GFP_KERNEL);
306 if (!bus)
307 return NULL;
308
309 memset(&bus->devmap, 0, sizeof(struct usb_devmap));
310
311 bus->op = op;
312 bus->root_hub = NULL;
313 bus->hcpriv = NULL;
314 bus->busnum = -1;
315 bus->bandwidth_allocated = 0;
316 bus->bandwidth_int_reqs = 0;
317 bus->bandwidth_isoc_reqs = 0;
318
319 INIT_LIST_HEAD(&bus->bus_list);
320 INIT_LIST_HEAD(&bus->inodes);
321
322 return bus;
323 }
324
325 void usb_free_bus(struct usb_bus *bus)
326 {
327 if (!bus)
328 return;
329
330 kfree(bus);
331 }
332
333 void usb_register_bus(struct usb_bus *bus)
334 {
335 int busnum;
336
337 busnum = find_next_zero_bit(busmap.busmap, USB_MAXBUS, 1);
338 if (busnum < USB_MAXBUS) {
339 set_bit(busnum, busmap.busmap);
340 bus->busnum = busnum;
341 } else
342 warn("too many buses");
343
344 /* Add it to the list of buses */
345 list_add(&bus->bus_list, &usb_bus_list);
346
347 usbdevfs_add_bus(bus);
348
349 info("new USB bus registered, assigned bus number %d", bus->busnum);
350 }
351
352 void usb_deregister_bus(struct usb_bus *bus)
353 {
354 info("USB bus %d deregistered", bus->busnum);
355
356 /*
357 * NOTE: make sure that all the devices are removed by the
358 * controller code, as well as having it call this when cleaning
359 * itself up
360 */
361 list_del(&bus->bus_list);
362
363 usbdevfs_remove_bus(bus);
364
365 clear_bit(bus->busnum, busmap.busmap);
366 }
367
368 /*
369 * This function is for doing a depth-first search for devices which
370 * have support, for dynamic loading of driver modules.
371 */
372 static void usb_check_support(struct usb_device *dev)
373 {
374 int i;
375
376 if (!dev) {
377 err("null device being checked!!!");
378 return;
379 }
380
381 for (i=0; i<USB_MAXCHILDREN; i++)
382 if (dev->children[i])
383 usb_check_support(dev->children[i]);
384
385 if (!dev->actconfig)
386 return;
387
388 /* now we check this device */
389 if (dev->devnum > 0)
390 for (i = 0; i < dev->actconfig->bNumInterfaces; i++)
391 usb_find_interface_driver(dev, i);
392 }
393
394
395 /*
396 * This is intended to be used by usb device drivers that need to
397 * claim more than one interface on a device at once when probing
398 * (audio and acm are good examples). No device driver should have
399 * to mess with the internal usb_interface or usb_device structure
400 * members.
401 */
402 void usb_driver_claim_interface(struct usb_driver *driver, struct usb_interface *iface, void* priv)
403 {
404 if (!iface || !driver)
405 return;
406
407 dbg("%s driver claimed interface %p", driver->name, iface);
408
409 iface->driver = driver;
410 iface->private_data = priv;
411 } /* usb_driver_claim_interface() */
412
413 /*
414 * This should be used by drivers to check other interfaces to see if
415 * they are available or not.
416 */
417 int usb_interface_claimed(struct usb_interface *iface)
418 {
419 if (!iface)
420 return 0;
421
422 return (iface->driver != NULL);
423 } /* usb_interface_claimed() */
424
425 /*
426 * This should be used by drivers to release their claimed interfaces
427 */
428 void usb_driver_release_interface(struct usb_driver *driver, struct usb_interface *iface)
429 {
430 /* this should never happen, don't release something that's not ours */
431 if (!iface || iface->driver != driver)
432 return;
433
434 iface->driver = NULL;
435 iface->private_data = NULL;
436 }
437
438 /*
439 * This entrypoint gets called for each new device.
440 *
441 * We now walk the list of registered USB drivers,
442 * looking for one that will accept this interface.
443 *
444 * The probe return value is changed to be a private pointer. This way
445 * the drivers don't have to dig around in our structures to set the
446 * private pointer if they only need one interface.
447 *
448 * Returns: 0 if a driver accepted the interface, -1 otherwise
449 */
450 static int usb_find_interface_driver(struct usb_device *dev, unsigned ifnum)
451 {
452 struct list_head *tmp = usb_driver_list.next;
453 struct usb_interface *interface;
454
455 if ((!dev) || (ifnum >= dev->actconfig->bNumInterfaces)) {
456 err("bad find_interface_driver params");
457 return -1;
458 }
459
460 interface = dev->actconfig->interface + ifnum;
461
462 if (usb_interface_claimed(interface))
463 return -1;
464
465 while (tmp != &usb_driver_list) {
466 void *private;
467 struct usb_driver *driver = list_entry(tmp, struct usb_driver,
468 driver_list);
469
470 tmp = tmp->next;
471 down(&driver->serialize);
472 private = driver->probe(dev, ifnum);
473 up(&driver->serialize);
474 if (!private)
475 continue;
476 usb_driver_claim_interface(driver, interface, private);
477
478 return 0;
479 }
480
481 return -1;
482 }
483
484 /*
485 * This entrypoint gets called for each new device.
486 *
487 * All interfaces are scanned for matching drivers.
488 */
489 static void usb_find_drivers(struct usb_device *dev)
490 {
491 unsigned ifnum;
492 unsigned rejected = 0;
493 unsigned claimed = 0;
494
495 for (ifnum = 0; ifnum < dev->actconfig->bNumInterfaces; ifnum++) {
496 /* if this interface hasn't already been claimed */
497 if (!usb_interface_claimed(dev->actconfig->interface + ifnum)) {
498 if (usb_find_interface_driver(dev, ifnum))
499 rejected++;
500 else
501 claimed++;
502 }
503 }
504
505 if (rejected)
506 dbg("unhandled interfaces on device");
507
508 if (!claimed) {
509 warn("This device is not recognized by any installed USB driver.");
510 #ifdef DEBUG
511 usb_show_device(dev);
512 #endif
513 }
514 }
515
516 /*
517 * Only HC's should call usb_alloc_dev and usb_free_dev directly
518 * Anybody may use usb_inc_dev_use or usb_dec_dev_use
519 */
520 struct usb_device *usb_alloc_dev(struct usb_device *parent, struct usb_bus *bus)
521 {
522 struct usb_device *dev;
523
524 dev = kmalloc(sizeof(*dev), GFP_KERNEL);
525 if (!dev)
526 return NULL;
527
528 memset(dev, 0, sizeof(*dev));
529
530 dev->bus = bus;
531 dev->parent = parent;
532 atomic_set(&dev->refcnt, 1);
533 INIT_LIST_HEAD(&dev->inodes);
534 INIT_LIST_HEAD(&dev->filelist);
535
536 dev->bus->op->allocate(dev);
537
538 return dev;
539 }
540
541 void usb_free_dev(struct usb_device *dev)
542 {
543 if (atomic_dec_and_test(&dev->refcnt)) {
544 usb_destroy_configuration(dev);
545 dev->bus->op->deallocate(dev);
546 kfree(dev);
547 }
548 }
549
550 void usb_inc_dev_use(struct usb_device *dev)
551 {
552 atomic_inc(&dev->refcnt);
553 }
554 /* -------------------------------------------------------------------------------------
555 * New USB Core Functions
556 * -------------------------------------------------------------------------------------*/
557
558 urb_t *usb_alloc_urb(int iso_packets)
559 {
560 urb_t *urb;
561
562 urb = (urb_t *)kmalloc(sizeof(urb_t) + iso_packets * sizeof(iso_packet_descriptor_t),
563 in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
564 if (!urb) {
565 err("alloc_urb: kmalloc failed");
566 return NULL;
567 }
568
569 memset(urb, 0, sizeof(*urb));
570
571 spin_lock_init(&urb->lock);
572
573 return urb;
574 }
575
576 /*-------------------------------------------------------------------*/
577 void usb_free_urb(urb_t* urb)
578 {
579 if (urb)
580 kfree(urb);
581 }
582 /*-------------------------------------------------------------------*/
583 int usb_submit_urb(urb_t *urb)
584 {
585 if (urb && urb->dev)
586 return urb->dev->bus->op->submit_urb(urb);
587 else
588 return -1;
589 }
590
591 /*-------------------------------------------------------------------*/
592 int usb_unlink_urb(urb_t *urb)
593 {
594 if (urb && urb->dev)
595 return urb->dev->bus->op->unlink_urb(urb);
596 else
597 return -1;
598 }
599 /*-------------------------------------------------------------------*
600 * COMPLETION HANDLERS *
601 *-------------------------------------------------------------------*/
602
603 /*-------------------------------------------------------------------*
604 * completion handler for compatibility wrappers (sync control/bulk) *
605 *-------------------------------------------------------------------*/
606 static void usb_api_blocking_completion(urb_t *urb)
607 {
608 api_wrapper_data *awd = (api_wrapper_data *)urb->context;
609
610 if (waitqueue_active(awd->wakeup))
611 wake_up(awd->wakeup);
612 #if 0
613 else
614 dbg("(blocking_completion): waitqueue empty!");
615 // even occurs if urb was unlinked by timeout...
616 #endif
617 }
618
619 /*-------------------------------------------------------------------*
620 * COMPATIBILITY STUFF *
621 *-------------------------------------------------------------------*/
622
623 // Starts urb and waits for completion or timeout
624 static int usb_start_wait_urb(urb_t *urb, int timeout, int* actual_length)
625 {
626 DECLARE_WAITQUEUE(wait, current);
627 DECLARE_WAIT_QUEUE_HEAD(wqh);
628 api_wrapper_data awd;
629 int status;
630
631 awd.wakeup = &wqh;
632 awd.handler = 0;
633 init_waitqueue_head(&wqh);
634 current->state = TASK_INTERRUPTIBLE;
635 add_wait_queue(&wqh, &wait);
636 urb->context = &awd;
637 status = usb_submit_urb(urb);
638 if (status) {
639 // something went wrong
640 usb_free_urb(urb);
641 remove_wait_queue(&wqh, &wait);
642 return status;
643 }
644
645 if (urb->status == -EINPROGRESS) {
646 while (timeout && urb->status == -EINPROGRESS)
647 status = timeout = schedule_timeout(timeout);
648 } else
649 status = 1;
650
651 remove_wait_queue(&wqh, &wait);
652
653 if (!status) {
654 // timeout
655 printk("usb_control/bulk_msg: timeout\n");
656 usb_unlink_urb(urb); // remove urb safely
657 status = -ETIMEDOUT;
658 } else
659 status = urb->status;
660
661 if (actual_length)
662 *actual_length = urb->actual_length;
663
664 usb_free_urb(urb);
665 return status;
666 }
667
668 /*-------------------------------------------------------------------*/
669 // returns status (negative) or length (positive)
670 int usb_internal_control_msg(struct usb_device *usb_dev, unsigned int pipe,
671 devrequest *cmd, void *data, int len, int timeout)
672 {
673 urb_t *urb;
674 int retv;
675 int length;
676
677 urb = usb_alloc_urb(0);
678 if (!urb)
679 return -ENOMEM;
680
681 FILL_CONTROL_URB(urb, usb_dev, pipe, (unsigned char*)cmd, data, len, /* build urb */
682 (usb_complete_t)usb_api_blocking_completion,0);
683
684 retv = usb_start_wait_urb(urb, timeout, &length);
685 if (retv < 0)
686 return retv;
687 else
688 return length;
689
690 }
691
692 /*-------------------------------------------------------------------*/
693 int usb_control_msg(struct usb_device *dev, unsigned int pipe, __u8 request, __u8 requesttype,
694 __u16 value, __u16 index, void *data, __u16 size, int timeout)
695 {
696 devrequest *dr = kmalloc(sizeof(devrequest), GFP_KERNEL);
697 int ret;
698
699 if (!dr)
700 return -ENOMEM;
701
702 dr->requesttype = requesttype;
703 dr->request = request;
704 dr->value = cpu_to_le16p(&value);
705 dr->index = cpu_to_le16p(&index);
706 dr->length = cpu_to_le16p(&size);
707
708 //dbg("usb_control_msg");
709
710 ret = usb_internal_control_msg(dev, pipe, dr, data, size, timeout);
711
712 kfree(dr);
713
714 return ret;
715 }
716
717 /*-------------------------------------------------------------------*/
718 /* compatibility wrapper, builds bulk urb, and waits for completion */
719 /* synchronous behavior */
720
721 int usb_bulk_msg(struct usb_device *usb_dev, unsigned int pipe,
722 void *data, int len, int *actual_length, int timeout)
723 {
724 urb_t *urb;
725
726 if (len < 0)
727 return -EINVAL;
728
729 urb=usb_alloc_urb(0);
730 if (!urb)
731 return -ENOMEM;
732
733 FILL_BULK_URB(urb,usb_dev,pipe,(unsigned char*)data,len, /* build urb */
734 (usb_complete_t)usb_api_blocking_completion,0);
735
736 return usb_start_wait_urb(urb,timeout,actual_length);
737 }
738
739 /*
740 * usb_get_current_frame_number()
741 *
742 * returns the current frame number for the parent USB bus/controller
743 * of the given USB device.
744 */
745 int usb_get_current_frame_number(struct usb_device *usb_dev)
746 {
747 return usb_dev->bus->op->get_frame_number (usb_dev);
748 }
749 /*-------------------------------------------------------------------*/
750
751 static int usb_parse_endpoint(struct usb_device *dev, struct usb_endpoint_descriptor *endpoint, unsigned char *buffer, int size)
752 {
753 struct usb_descriptor_header *header;
754 unsigned char *begin;
755 int parsed = 0, len, numskipped;
756
757 header = (struct usb_descriptor_header *)buffer;
758
759 /* Everything should be fine being passed into here, but we sanity */
760 /* check JIC */
761 if (header->bLength > size) {
762 err("ran out of descriptors parsing");
763 return -1;
764 }
765
766 if (header->bDescriptorType != USB_DT_ENDPOINT) {
767 warn("unexpected descriptor 0x%X, expecting endpoint descriptor, type 0x%X",
768 endpoint->bDescriptorType, USB_DT_ENDPOINT);
769 return parsed;
770 }
771
772 if (header->bLength == USB_DT_ENDPOINT_AUDIO_SIZE)
773 memcpy(endpoint, buffer, USB_DT_ENDPOINT_AUDIO_SIZE);
774 else
775 memcpy(endpoint, buffer, USB_DT_ENDPOINT_SIZE);
776
777 le16_to_cpus(&endpoint->wMaxPacketSize);
778
779 buffer += header->bLength;
780 size -= header->bLength;
781 parsed += header->bLength;
782
783 /* Skip over the rest of the Class Specific or Vendor Specific */
784 /* descriptors */
785 begin = buffer;
786 numskipped = 0;
787 while (size >= sizeof(struct usb_descriptor_header)) {
788 header = (struct usb_descriptor_header *)buffer;
789
790 if (header->bLength < 2) {
791 err("invalid descriptor length of %d", header->bLength);
792 return -1;
793 }
794
795 /* If we find another descriptor which is at or below us */
796 /* in the descriptor heirarchy then we're done */
797 if ((header->bDescriptorType == USB_DT_ENDPOINT) ||
798 (header->bDescriptorType == USB_DT_INTERFACE) ||
799 (header->bDescriptorType == USB_DT_CONFIG) ||
800 (header->bDescriptorType == USB_DT_DEVICE))
801 break;
802
803 dbg("skipping descriptor 0x%X",
804 header->bDescriptorType);
805 numskipped++;
806
807 buffer += header->bLength;
808 size -= header->bLength;
809 parsed += header->bLength;
810 }
811 if (numskipped)
812 dbg("skipped %d class/vendor specific endpoint descriptors", numskipped);
813
814 /* Copy any unknown descriptors into a storage area for drivers */
815 /* to later parse */
816 len = (int)(buffer - begin);
817 if (!len) {
818 endpoint->extra = NULL;
819 endpoint->extralen = 0;
820 return parsed;
821 }
822
823 endpoint->extra = kmalloc(len, GFP_KERNEL);
824
825 if (!endpoint->extra) {
826 err("couldn't allocate memory for endpoint extra descriptors");
827 endpoint->extralen = 0;
828 return parsed;
829 }
830
831 memcpy(endpoint->extra, begin, len);
832 endpoint->extralen = len;
833
834 return parsed;
835 }
836
837 static int usb_parse_interface(struct usb_device *dev, struct usb_interface *interface, unsigned char *buffer, int size)
838 {
839 int i, len, numskipped, retval, parsed = 0;
840 struct usb_descriptor_header *header;
841 struct usb_interface_descriptor *ifp;
842 unsigned char *begin;
843
844 interface->act_altsetting = 0;
845 interface->num_altsetting = 0;
846 interface->max_altsetting = USB_ALTSETTINGALLOC;
847
848 interface->altsetting = kmalloc(sizeof(struct usb_interface_descriptor) * interface->max_altsetting, GFP_KERNEL);
849
850 if (!interface->altsetting) {
851 err("couldn't kmalloc interface->altsetting");
852 return -1;
853 }
854
855 while (size > 0) {
856 if (interface->num_altsetting >= interface->max_altsetting) {
857 void *ptr;
858 int oldmas;
859
860 oldmas = interface->max_altsetting;
861 interface->max_altsetting += USB_ALTSETTINGALLOC;
862 if (interface->max_altsetting > USB_MAXALTSETTING) {
863 warn("too many alternate settings (max %d)",
864 USB_MAXALTSETTING);
865 return -1;
866 }
867
868 ptr = interface->altsetting;
869 interface->altsetting = kmalloc(sizeof(struct usb_interface_descriptor) * interface->max_altsetting, GFP_KERNEL);
870 if (!interface->altsetting) {
871 err("couldn't kmalloc interface->altsetting");
872 interface->altsetting = ptr;
873 return -1;
874 }
875 memcpy(interface->altsetting, ptr, sizeof(struct usb_interface_descriptor) * oldmas);
876
877 kfree(ptr);
878 }
879
880 ifp = interface->altsetting + interface->num_altsetting;
881 interface->num_altsetting++;
882
883 memcpy(ifp, buffer, USB_DT_INTERFACE_SIZE);
884
885 /* Skip over the interface */
886 buffer += ifp->bLength;
887 parsed += ifp->bLength;
888 size -= ifp->bLength;
889
890 begin = buffer;
891 numskipped = 0;
892
893 /* Skip over any interface, class or vendor descriptors */
894 while (size >= sizeof(struct usb_descriptor_header)) {
895 header = (struct usb_descriptor_header *)buffer;
896
897 if (header->bLength < 2) {
898 err("invalid descriptor length of %d", header->bLength);
899 return -1;
900 }
901
902 /* If we find another descriptor which is at or below */
903 /* us in the descriptor heirarchy then return */
904 if ((header->bDescriptorType == USB_DT_INTERFACE) ||
905 (header->bDescriptorType == USB_DT_ENDPOINT) ||
906 (header->bDescriptorType == USB_DT_CONFIG) ||
907 (header->bDescriptorType == USB_DT_DEVICE))
908 break;
909
910 numskipped++;
911
912 buffer += header->bLength;
913 parsed += header->bLength;
914 size -= header->bLength;
915 }
916
917 if (numskipped)
918 dbg("skipped %d class/vendor specific interface descriptors", numskipped);
919
920 /* Copy any unknown descriptors into a storage area for */
921 /* drivers to later parse */
922 len = (int)(buffer - begin);
923 if (!len) {
924 ifp->extra = NULL;
925 ifp->extralen = 0;
926 } else {
927 ifp->extra = kmalloc(len, GFP_KERNEL);
928
929 if (!ifp->extra) {
930 err("couldn't allocate memory for interface extra descriptors");
931 ifp->extralen = 0;
932 return -1;
933 }
934 memcpy(ifp->extra, begin, len);
935 ifp->extralen = len;
936 }
937
938 /* Did we hit an unexpected descriptor? */
939 header = (struct usb_descriptor_header *)buffer;
940 if ((size >= sizeof(struct usb_descriptor_header)) &&
941 ((header->bDescriptorType == USB_DT_CONFIG) ||
942 (header->bDescriptorType == USB_DT_DEVICE)))
943 return parsed;
944
945 if (ifp->bNumEndpoints > USB_MAXENDPOINTS) {
946 warn("too many endpoints");
947 return -1;
948 }
949
950 ifp->endpoint = (struct usb_endpoint_descriptor *)
951 kmalloc(ifp->bNumEndpoints *
952 sizeof(struct usb_endpoint_descriptor), GFP_KERNEL);
953 if (!ifp->endpoint) {
954 err("out of memory");
955 return -1;
956 }
957
958 memset(ifp->endpoint, 0, ifp->bNumEndpoints *
959 sizeof(struct usb_endpoint_descriptor));
960
961 for (i = 0; i < ifp->bNumEndpoints; i++) {
962 header = (struct usb_descriptor_header *)buffer;
963
964 if (header->bLength > size) {
965 err("ran out of descriptors parsing");
966 return -1;
967 }
968
969 retval = usb_parse_endpoint(dev, ifp->endpoint + i, buffer, size);
970 if (retval < 0)
971 return retval;
972
973 buffer += retval;
974 parsed += retval;
975 size -= retval;
976 }
977
978 /* We check to see if it's an alternate to this one */
979 ifp = (struct usb_interface_descriptor *)buffer;
980 if (size < USB_DT_INTERFACE_SIZE ||
981 ifp->bDescriptorType != USB_DT_INTERFACE ||
982 !ifp->bAlternateSetting)
983 return parsed;
984 }
985
986 return parsed;
987 }
988
989 int usb_parse_configuration(struct usb_device *dev, struct usb_config_descriptor *config, char *buffer)
990 {
991 int i;
992 int retval;
993 int size;
994 struct usb_descriptor_header *header;
995
996 memcpy(config, buffer, USB_DT_CONFIG_SIZE);
997 le16_to_cpus(&config->wTotalLength);
998 size = config->wTotalLength;
999
1000 if (config->bNumInterfaces > USB_MAXINTERFACES) {
1001 warn("too many interfaces");
1002 return -1;
1003 }
1004
1005 config->interface = (struct usb_interface *)
1006 kmalloc(config->bNumInterfaces *
1007 sizeof(struct usb_interface), GFP_KERNEL);
1008 dbg("kmalloc IF %p, numif %i",config->interface,config->bNumInterfaces);
1009 if (!config->interface) {
1010 err("out of memory");
1011 return -1;
1012 }
1013
1014 memset(config->interface, 0,
1015 config->bNumInterfaces * sizeof(struct usb_interface));
1016
1017 buffer += config->bLength;
1018 size -= config->bLength;
1019
1020 for (i = 0; i < config->bNumInterfaces; i++) {
1021 header = (struct usb_descriptor_header *)buffer;
1022 if ((header->bLength > size) || (header->bLength <= 2)) {
1023 err("ran out of descriptors parsing");
1024 return -1;
1025 }
1026
1027 if (header->bDescriptorType != USB_DT_INTERFACE) {
1028 warn("unexpected descriptor 0x%X",
1029 header->bDescriptorType);
1030
1031 buffer += header->bLength;
1032 size -= header->bLength;
1033 continue;
1034 }
1035
1036 retval = usb_parse_interface(dev, config->interface + i, buffer, size);
1037 if (retval < 0)
1038 return retval;
1039
1040 buffer += retval;
1041 size -= retval;
1042 }
1043
1044 return size;
1045 }
1046
1047 void usb_destroy_configuration(struct usb_device *dev)
1048 {
1049 int c, i, j, k;
1050
1051 if (!dev->config)
1052 return;
1053
1054 if (dev->rawdescriptors) {
1055 for (i = 0; i < dev->descriptor.bNumConfigurations; i++)
1056 kfree(dev->rawdescriptors[i]);
1057
1058 kfree(dev->rawdescriptors);
1059 }
1060
1061 for (c = 0; c < dev->descriptor.bNumConfigurations; c++) {
1062 struct usb_config_descriptor *cf = &dev->config[c];
1063
1064 if (!cf->interface)
1065 break;
1066
1067 for (i = 0; i < cf->bNumInterfaces; i++) {
1068 struct usb_interface *ifp =
1069 &cf->interface[i];
1070
1071 if (!ifp->altsetting)
1072 break;
1073
1074 for (j = 0; j < ifp->num_altsetting; j++) {
1075 struct usb_interface_descriptor *as =
1076 &ifp->altsetting[j];
1077
1078 if(as->extra) {
1079 kfree(as->extra);
1080 }
1081
1082 if (!as->endpoint)
1083 break;
1084
1085 for(k = 0; k < as->bNumEndpoints; k++) {
1086 if(as->endpoint[k].extra) {
1087 kfree(as->endpoint[k].extra);
1088 }
1089 }
1090 kfree(as->endpoint);
1091 }
1092
1093 kfree(ifp->altsetting);
1094 }
1095 kfree(cf->interface);
1096 }
1097 kfree(dev->config);
1098 }
1099
1100 void usb_init_root_hub(struct usb_device *dev)
1101 {
1102 dev->devnum = -1;
1103 dev->slow = 0;
1104 dev->actconfig = NULL;
1105 }
1106
1107 /* for returning string descriptors in UTF-16LE */
1108 static int ascii2utf (char *ascii, __u8 *utf, int utfmax)
1109 {
1110 int retval;
1111
1112 for (retval = 0; *ascii && utfmax > 1; utfmax -= 2, retval += 2) {
1113 *utf++ = *ascii++ & 0x7f;
1114 *utf++ = 0;
1115 }
1116 return retval;
1117 }
1118
1119 /*
1120 * root_hub_string is used by each host controller's root hub code,
1121 * so that they're identified consistently throughout the system.
1122 */
1123 int usb_root_hub_string (int id, int serial, char *type, __u8 *data, int len)
1124 {
1125 char buf [30];
1126
1127 // assert (len > (2 * (sizeof (buf) + 1)));
1128 // assert (strlen (type) <= 8);
1129
1130 // language ids
1131 if (id == 0) {
1132 *data++ = 4; *data++ = 3; /* 4 bytes data */
1133 *data++ = 0; *data++ = 0; /* some language id */
1134 return 4;
1135
1136 // serial number
1137 } else if (id == 1) {
1138 sprintf (buf, "%x", serial);
1139
1140 // product description
1141 } else if (id == 2) {
1142 sprintf (buf, "USB %s Root Hub", type);
1143
1144 // id 3 == vendor description
1145
1146 // unsupported IDs --> "stall"
1147 } else
1148 return 0;
1149
1150 data [0] = 2 + ascii2utf (buf, data + 2, len - 2);
1151 data [1] = 3;
1152 return data [0];
1153 }
1154
1155 /*
1156 * __usb_get_extra_descriptor() finds a descriptor of specific type in the
1157 * extra field of the interface and endpoint descriptor structs.
1158 */
1159
1160 int __usb_get_extra_descriptor(char *buffer, unsigned size, unsigned char type, void **ptr)
1161 {
1162 struct usb_descriptor_header *header;
1163
1164 while (size >= sizeof(struct usb_descriptor_header)) {
1165 header = (struct usb_descriptor_header *)buffer;
1166
1167 if (header->bLength < 2) {
1168 err("invalid descriptor length of %d", header->bLength);
1169 return -1;
1170 }
1171
1172 if (header->bDescriptorType == type) {
1173 *ptr = header;
1174 return 0;
1175 }
1176
1177 buffer += header->bLength;
1178 size -= header->bLength;
1179 }
1180 return -1;
1181 }
1182
1183 /*
1184 * Something got disconnected. Get rid of it, and all of its children.
1185 */
1186 void usb_disconnect(struct usb_device **pdev)
1187 {
1188 struct usb_device * dev = *pdev;
1189 int i;
1190
1191 if (!dev)
1192 return;
1193
1194 *pdev = NULL;
1195
1196 info("USB disconnect on device %d", dev->devnum);
1197
1198 if (dev->actconfig) {
1199 for (i = 0; i < dev->actconfig->bNumInterfaces; i++) {
1200 struct usb_interface *interface = &dev->actconfig->interface[i];
1201 struct usb_driver *driver = interface->driver;
1202 if (driver) {
1203 down(&driver->serialize);
1204 driver->disconnect(dev, interface->private_data);
1205 up(&driver->serialize);
1206 usb_driver_release_interface(driver, interface);
1207 }
1208 }
1209 }
1210
1211 /* Free up all the children.. */
1212 for (i = 0; i < USB_MAXCHILDREN; i++) {
1213 struct usb_device **child = dev->children + i;
1214 if (*child)
1215 usb_disconnect(child);
1216 }
1217
1218 /* remove /proc/bus/usb entry */
1219 usbdevfs_remove_device(dev);
1220
1221 /* Free up the device itself, including its device number */
1222 if (dev->devnum > 0)
1223 clear_bit(dev->devnum, &dev->bus->devmap.devicemap);
1224
1225 usb_free_dev(dev);
1226 }
1227
1228 /*
1229 * Connect a new USB device. This basically just initializes
1230 * the USB device information and sets up the topology - it's
1231 * up to the low-level driver to reset the port and actually
1232 * do the setup (the upper levels don't know how to do that).
1233 */
1234 void usb_connect(struct usb_device *dev)
1235 {
1236 int devnum;
1237 // FIXME needs locking for SMP!!
1238 /* why? this is called only from the hub thread,
1239 * which hopefully doesn't run on multiple CPU's simulatenously 8-)
1240 */
1241 dev->descriptor.bMaxPacketSize0 = 8; /* Start off at 8 bytes */
1242 devnum = find_next_zero_bit(dev->bus->devmap.devicemap, 128, 1);
1243 if (devnum < 128) {
1244 set_bit(devnum, dev->bus->devmap.devicemap);
1245 dev->devnum = devnum;
1246 }
1247 }
1248
1249 /*
1250 * These are the actual routines to send
1251 * and receive control messages.
1252 */
1253
1254 #define GET_TIMEOUT 3
1255 #define SET_TIMEOUT 3
1256
1257 int usb_set_address(struct usb_device *dev)
1258 {
1259 return usb_control_msg(dev, usb_snddefctrl(dev), USB_REQ_SET_ADDRESS,
1260 0, dev->devnum, 0, NULL, 0, HZ * GET_TIMEOUT);
1261 }
1262
1263 int usb_get_descriptor(struct usb_device *dev, unsigned char type, unsigned char index, void *buf, int size)
1264 {
1265 int i = 5;
1266 int result;
1267
1268 memset(buf,0,size); // Make sure we parse really received data
1269
1270 while (i--) {
1271 if ((result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
1272 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
1273 (type << 8) + index, 0, buf, size, HZ * GET_TIMEOUT)) >= 0 ||
1274 result == -EPIPE)
1275 break;
1276 }
1277 return result;
1278 }
1279
1280 int usb_get_class_descriptor(struct usb_device *dev, int ifnum,
1281 unsigned char type, unsigned char id, void *buf, int size)
1282 {
1283 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
1284 USB_REQ_GET_DESCRIPTOR, USB_RECIP_INTERFACE | USB_DIR_IN,
1285 (type << 8) + id, ifnum, buf, size, HZ * GET_TIMEOUT);
1286 }
1287
1288 int usb_get_string(struct usb_device *dev, unsigned short langid, unsigned char index, void *buf, int size)
1289 {
1290 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
1291 USB_REQ_GET_DESCRIPTOR, USB_DIR_IN,
1292 (USB_DT_STRING << 8) + index, langid, buf, size, HZ * GET_TIMEOUT);
1293 }
1294
1295 int usb_get_device_descriptor(struct usb_device *dev)
1296 {
1297 int ret = usb_get_descriptor(dev, USB_DT_DEVICE, 0, &dev->descriptor,
1298 sizeof(dev->descriptor));
1299 if (ret >= 0) {
1300 le16_to_cpus(&dev->descriptor.bcdUSB);
1301 le16_to_cpus(&dev->descriptor.idVendor);
1302 le16_to_cpus(&dev->descriptor.idProduct);
1303 le16_to_cpus(&dev->descriptor.bcdDevice);
1304 }
1305 return ret;
1306 }
1307
1308 int usb_get_status(struct usb_device *dev, int type, int target, void *data)
1309 {
1310 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
1311 USB_REQ_GET_STATUS, USB_DIR_IN | type, 0, target, data, 2, HZ * GET_TIMEOUT);
1312 }
1313
1314 int usb_get_protocol(struct usb_device *dev, int ifnum)
1315 {
1316 unsigned char type;
1317 int ret;
1318
1319 if ((ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
1320 USB_REQ_GET_PROTOCOL, USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1321 0, ifnum, &type, 1, HZ * GET_TIMEOUT)) < 0)
1322 return ret;
1323
1324 return type;
1325 }
1326
1327 int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol)
1328 {
1329 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1330 USB_REQ_SET_PROTOCOL, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1331 protocol, ifnum, NULL, 0, HZ * SET_TIMEOUT);
1332 }
1333
1334 int usb_set_idle(struct usb_device *dev, int ifnum, int duration, int report_id)
1335 {
1336 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1337 USB_REQ_SET_IDLE, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1338 (duration << 8) | report_id, ifnum, NULL, 0, HZ * SET_TIMEOUT);
1339 }
1340
1341 void usb_set_maxpacket(struct usb_device *dev)
1342 {
1343 int i, b;
1344
1345 for (i=0; i<dev->actconfig->bNumInterfaces; i++) {
1346 struct usb_interface *ifp = dev->actconfig->interface + i;
1347 struct usb_interface_descriptor *as = ifp->altsetting + ifp->act_altsetting;
1348 struct usb_endpoint_descriptor *ep = as->endpoint;
1349 int e;
1350
1351 for (e=0; e<as->bNumEndpoints; e++) {
1352 b = ep[e].bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
1353 if ((ep[e].bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) ==
1354 USB_ENDPOINT_XFER_CONTROL) { /* Control => bidirectional */
1355 dev->epmaxpacketout[b] = ep[e].wMaxPacketSize;
1356 dev->epmaxpacketin [b] = ep[e].wMaxPacketSize;
1357 }
1358 else if (usb_endpoint_out(ep[e].bEndpointAddress)) {
1359 if (ep[e].wMaxPacketSize > dev->epmaxpacketout[b])
1360 dev->epmaxpacketout[b] = ep[e].wMaxPacketSize;
1361 }
1362 else {
1363 if (ep[e].wMaxPacketSize > dev->epmaxpacketin [b])
1364 dev->epmaxpacketin [b] = ep[e].wMaxPacketSize;
1365 }
1366 }
1367 }
1368 }
1369
1370 /*
1371 * endp: endpoint number in bits 0-3;
1372 * direction flag in bit 7 (1 = IN, 0 = OUT)
1373 */
1374 int usb_clear_halt(struct usb_device *dev, int pipe)
1375 {
1376 int result;
1377 __u16 status;
1378 int endp=usb_pipeendpoint(pipe)|(usb_pipein(pipe)<<7);
1379
1380 /*
1381 if (!usb_endpoint_halted(dev, endp & 0x0f, usb_endpoint_out(endp)))
1382 return 0;
1383 */
1384
1385 result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1386 USB_REQ_CLEAR_FEATURE, USB_RECIP_ENDPOINT, 0, endp, NULL, 0, HZ * SET_TIMEOUT);
1387
1388 /* don't clear if failed */
1389 if (result < 0)
1390 return result;
1391
1392 result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
1393 USB_REQ_GET_STATUS, USB_DIR_IN | USB_RECIP_ENDPOINT, 0, endp,
1394 &status, sizeof(status), HZ * SET_TIMEOUT);
1395 if (result < 0)
1396 return result;
1397
1398 if (status & 1)
1399 return -EPIPE; /* still halted */
1400
1401 usb_endpoint_running(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe));
1402
1403 /* toggle is reset on clear */
1404
1405 usb_settoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe), 0);
1406
1407 return 0;
1408 }
1409
1410 int usb_set_interface(struct usb_device *dev, int interface, int alternate)
1411 {
1412 struct usb_interface *iface;
1413 int ret;
1414
1415 iface = usb_ifnum_to_if(dev, interface);
1416 if (!iface) {
1417 warn("selecting invalid interface %d", interface);
1418 return -EINVAL;
1419 }
1420
1421 if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1422 USB_REQ_SET_INTERFACE, USB_RECIP_INTERFACE, alternate,
1423 interface, NULL, 0, HZ * 5)) < 0)
1424 return ret;
1425
1426 iface->act_altsetting = alternate;
1427 dev->toggle[0] = 0; /* 9.1.1.5 says to do this */
1428 dev->toggle[1] = 0;
1429 usb_set_maxpacket(dev);
1430 return 0;
1431 }
1432
1433 int usb_set_configuration(struct usb_device *dev, int configuration)
1434 {
1435 int i, ret;
1436 struct usb_config_descriptor *cp = NULL;
1437
1438 for (i=0; i<dev->descriptor.bNumConfigurations; i++) {
1439 if (dev->config[i].bConfigurationValue == configuration) {
1440 cp = &dev->config[i];
1441 break;
1442 }
1443 }
1444 if (!cp) {
1445 warn("selecting invalid configuration %d", configuration);
1446 return -1;
1447 }
1448
1449 if ((ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1450 USB_REQ_SET_CONFIGURATION, 0, configuration, 0, NULL, 0, HZ * SET_TIMEOUT)) < 0)
1451 return ret;
1452
1453 dev->actconfig = cp;
1454 dev->toggle[0] = 0;
1455 dev->toggle[1] = 0;
1456 usb_set_maxpacket(dev);
1457
1458 return 0;
1459 }
1460
1461 int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type, unsigned char id, void *buf, int size)
1462 {
1463 return usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
1464 USB_REQ_GET_REPORT, USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1465 (type << 8) + id, ifnum, buf, size, HZ * GET_TIMEOUT);
1466 }
1467
1468 int usb_set_report(struct usb_device *dev, int ifnum, unsigned char type, unsigned char id, void *buf, int size)
1469 {
1470 return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1471 USB_REQ_SET_REPORT, USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1472 (type << 8) + id, ifnum, buf, size, HZ);
1473 }
1474
1475 int usb_get_configuration(struct usb_device *dev)
1476 {
1477 int result;
1478 unsigned int cfgno, length;
1479 unsigned char buffer[8];
1480 unsigned char *bigbuffer;
1481 struct usb_config_descriptor *desc =
1482 (struct usb_config_descriptor *)buffer;
1483
1484 if (dev->descriptor.bNumConfigurations > USB_MAXCONFIG) {
1485 warn("too many configurations");
1486 return -1;
1487 }
1488
1489 if (dev->descriptor.bNumConfigurations < 1) {
1490 warn("not enough configurations");
1491 return -1;
1492 }
1493
1494 dev->config = (struct usb_config_descriptor *)
1495 kmalloc(dev->descriptor.bNumConfigurations *
1496 sizeof(struct usb_config_descriptor), GFP_KERNEL);
1497 if (!dev->config) {
1498 err("out of memory");
1499 return -1;
1500 }
1501 memset(dev->config, 0, dev->descriptor.bNumConfigurations *
1502 sizeof(struct usb_config_descriptor));
1503
1504 dev->rawdescriptors = (char **)kmalloc(sizeof(char *) *
1505 dev->descriptor.bNumConfigurations, GFP_KERNEL);
1506 if (!dev->rawdescriptors) {
1507 err("out of memory");
1508 return -1;
1509 }
1510
1511 for (cfgno = 0; cfgno < dev->descriptor.bNumConfigurations; cfgno++) {
1512 /* We grab the first 8 bytes so we know how long the whole */
1513 /* configuration is */
1514 result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, buffer, 8);
1515 if (result < 8) {
1516 if (result < 0)
1517 err("unable to get descriptor");
1518 else
1519 err("config descriptor too short (expected %i, got %i)", 8, result);
1520 goto err;
1521 }
1522
1523 /* Get the full buffer */
1524 length = le16_to_cpu(desc->wTotalLength);
1525
1526 bigbuffer = kmalloc(length, GFP_KERNEL);
1527 if (!bigbuffer) {
1528 err("unable to allocate memory for configuration descriptors");
1529 result = -ENOMEM;
1530 goto err;
1531 }
1532
1533 /* Now that we know the length, get the whole thing */
1534 result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno, bigbuffer, length);
1535 if (result < 0) {
1536 err("couldn't get all of config descriptors");
1537 kfree(bigbuffer);
1538 goto err;
1539 }
1540
1541 if (result < length) {
1542 err("config descriptor too short (expected %i, got %i)", length, result);
1543 kfree(bigbuffer);
1544 goto err;
1545 }
1546
1547 dev->rawdescriptors[cfgno] = bigbuffer;
1548
1549 result = usb_parse_configuration(dev, &dev->config[cfgno], bigbuffer);
1550 if (result > 0)
1551 dbg("descriptor data left");
1552 else if (result < 0) {
1553 result = -1;
1554 goto err;
1555 }
1556 }
1557
1558 return 0;
1559 err:
1560 dev->descriptor.bNumConfigurations = cfgno;
1561 return result;
1562 }
1563
1564 /*
1565 * usb_string:
1566 * returns string length (> 0) or error (< 0)
1567 */
1568 int usb_string(struct usb_device *dev, int index, char *buf, size_t size)
1569 {
1570 unsigned char *tbuf;
1571 int err;
1572 unsigned int u, idx;
1573
1574 if (size <= 0 || !buf || !index)
1575 return -EINVAL;
1576 buf[0] = 0;
1577 tbuf = kmalloc(256, GFP_KERNEL);
1578 if (!tbuf)
1579 return -ENOMEM;
1580
1581 /* get langid for strings if it's not yet known */
1582 if (!dev->have_langid) {
1583 err = usb_get_string(dev, 0, 0, tbuf, 4);
1584 if (err < 0) {
1585 err("error getting string descriptor 0 (error=%d)", err);
1586 goto errout;
1587 } else if (tbuf[0] < 4) {
1588 err("string descriptor 0 too short");
1589 err = -EINVAL;
1590 goto errout;
1591 } else {
1592 dev->have_langid = -1;
1593 dev->string_langid = tbuf[2] | (tbuf[3]<< 8);
1594 /* always use the first langid listed */
1595 dbg("USB device number %d default language ID 0x%x",
1596 dev->devnum, dev->string_langid);
1597 }
1598 }
1599
1600 /*
1601 * Just ask for a maximum length string and then take the length
1602 * that was returned.
1603 */
1604 err = usb_get_string(dev, dev->string_langid, index, tbuf, 255);
1605 if (err < 0)
1606 goto errout;
1607
1608 size--; /* leave room for trailing NULL char in output buffer */
1609 for (idx = 0, u = 2; u < err; u += 2) {
1610 if (idx >= size)
1611 break;
1612 if (tbuf[u+1]) /* high byte */
1613 buf[idx++] = '?'; /* non-ASCII character */
1614 else
1615 buf[idx++] = tbuf[u];
1616 }
1617 buf[idx] = 0;
1618 err = idx;
1619
1620 errout:
1621 kfree(tbuf);
1622 return err;
1623 }
1624
1625 /*
1626 * By the time we get here, the device has gotten a new device ID
1627 * and is in the default state. We need to identify the thing and
1628 * get the ball rolling..
1629 *
1630 * Returns 0 for success, != 0 for error.
1631 */
1632 int usb_new_device(struct usb_device *dev)
1633 {
1634 int err;
1635
1636 info("USB new device connect, assigned device number %d", dev->devnum);
1637
1638 /* USB v1.1 5.5.3 */
1639 /* We read the first 8 bytes from the device descriptor to get to */
1640 /* the bMaxPacketSize0 field. Then we set the maximum packet size */
1641 /* for the control pipe, and retrieve the rest */
1642 dev->epmaxpacketin [0] = 8;
1643 dev->epmaxpacketout[0] = 8;
1644
1645 err = usb_set_address(dev);
1646 if (err < 0) {
1647 err("USB device not accepting new address (error=%d)", err);
1648 clear_bit(dev->devnum, &dev->bus->devmap.devicemap);
1649 dev->devnum = -1;
1650 return 1;
1651 }
1652
1653 wait_ms(10); /* Let the SET_ADDRESS settle */
1654
1655 err = usb_get_descriptor(dev, USB_DT_DEVICE, 0, &dev->descriptor, 8);
1656 if (err < 8) {
1657 if (err < 0)
1658 err("USB device not responding, giving up (error=%d)", err);
1659 else
1660 err("USB device descriptor short read (expected %i, got %i)",8,err);
1661 clear_bit(dev->devnum, &dev->bus->devmap.devicemap);
1662 dev->devnum = -1;
1663 return 1;
1664 }
1665 dev->epmaxpacketin [0] = dev->descriptor.bMaxPacketSize0;
1666 dev->epmaxpacketout[0] = dev->descriptor.bMaxPacketSize0;
1667
1668 err = usb_get_device_descriptor(dev);
1669 if (err < sizeof(dev->descriptor)) {
1670 if (err < 0)
1671 err("unable to get device descriptor (error=%d)", err);
1672 else
1673 err("USB device descriptor short read (expected %i, got %i)", sizeof(dev->descriptor), err);
1674
1675 clear_bit(dev->devnum, &dev->bus->devmap.devicemap);
1676 dev->devnum = -1;
1677 return 1;
1678 }
1679
1680 err = usb_get_configuration(dev);
1681 if (err < 0) {
1682 err("unable to get configuration (error=%d)", err);
1683 clear_bit(dev->devnum, &dev->bus->devmap.devicemap);
1684 dev->devnum = -1;
1685 return 1;
1686 }
1687
1688 dev->actconfig = dev->config;
1689 usb_set_maxpacket(dev);
1690
1691 /* we set the default configuration here */
1692 err = usb_set_configuration(dev, dev->config[0].bConfigurationValue);
1693 if (err) {
1694 err("failed to set default configuration (error=%d)", err);
1695 return -1;
1696 }
1697
1698 dbg("new device strings: Mfr=%d, Product=%d, SerialNumber=%d",
1699 dev->descriptor.iManufacturer, dev->descriptor.iProduct, dev->descriptor.iSerialNumber);
1700 #ifdef DEBUG
1701 if (dev->descriptor.iManufacturer)
1702 usb_show_string(dev, "Manufacturer", dev->descriptor.iManufacturer);
1703 if (dev->descriptor.iProduct)
1704 usb_show_string(dev, "Product", dev->descriptor.iProduct);
1705 if (dev->descriptor.iSerialNumber)
1706 usb_show_string(dev, "SerialNumber", dev->descriptor.iSerialNumber);
1707 #endif
1708
1709 /* now that the basic setup is over, add a /proc/bus/usb entry */
1710 usbdevfs_add_device(dev);
1711
1712 /* find drivers willing to handle this device */
1713 usb_find_drivers(dev);
1714
1715 return 0;
1716 }
1717
1718 static int usb_open(struct inode * inode, struct file * file)
1719 {
1720 int minor = MINOR(inode->i_rdev);
1721 struct usb_driver *c = usb_minors[minor/16];
1722 int err = -ENODEV;
1723 struct file_operations *old_fops;
1724
1725 if (!c || !c->fops)
1726 return err;
1727 old_fops = file->f_op;
1728 file->f_op = fops_get(c->fops);
1729 if (file->f_op->open)
1730 err = file->f_op->open(inode,file);
1731 if (err) {
1732 fops_put(file->f_op);
1733 file->f_op = fops_get(old_fops);
1734 }
1735 fops_put(old_fops);
1736 return err;
1737 }
1738
1739 static struct file_operations usb_fops = {
1740 owner: THIS_MODULE,
1741 open: usb_open,
1742 };
1743
1744 int usb_major_init(void)
1745 {
1746 if (register_chrdev(USB_MAJOR,"usb",&usb_fops)) {
1747 err("unable to get major %d for usb devices", USB_MAJOR);
1748 return -EBUSY;
1749 }
1750 return 0;
1751 }
1752
1753 void usb_major_cleanup(void)
1754 {
1755 unregister_chrdev(USB_MAJOR, "usb");
1756 }
1757
1758
1759 #ifdef CONFIG_PROC_FS
1760 struct list_head *usb_driver_get_list(void)
1761 {
1762 return &usb_driver_list;
1763 }
1764
1765 struct list_head *usb_bus_get_list(void)
1766 {
1767 return &usb_bus_list;
1768 }
1769 #endif
1770
1771 /*
1772 * USB may be built into the kernel or be built as modules.
1773 * If the USB core [and maybe a host controller driver] is built
1774 * into the kernel, and other device drivers are built as modules,
1775 * then these symbols need to be exported for the modules to use.
1776 */
1777 EXPORT_SYMBOL(usb_ifnum_to_if);
1778
1779 EXPORT_SYMBOL(usb_register);
1780 EXPORT_SYMBOL(usb_deregister);
1781 EXPORT_SYMBOL(usb_scan_devices);
1782 EXPORT_SYMBOL(usb_alloc_bus);
1783 EXPORT_SYMBOL(usb_free_bus);
1784 EXPORT_SYMBOL(usb_register_bus);
1785 EXPORT_SYMBOL(usb_deregister_bus);
1786 EXPORT_SYMBOL(usb_alloc_dev);
1787 EXPORT_SYMBOL(usb_free_dev);
1788 EXPORT_SYMBOL(usb_inc_dev_use);
1789
1790 EXPORT_SYMBOL(usb_driver_claim_interface);
1791 EXPORT_SYMBOL(usb_interface_claimed);
1792 EXPORT_SYMBOL(usb_driver_release_interface);
1793
1794 EXPORT_SYMBOL(usb_init_root_hub);
1795 EXPORT_SYMBOL(usb_root_hub_string);
1796 EXPORT_SYMBOL(usb_new_device);
1797 EXPORT_SYMBOL(usb_reset_device);
1798 EXPORT_SYMBOL(usb_connect);
1799 EXPORT_SYMBOL(usb_disconnect);
1800
1801 EXPORT_SYMBOL(usb_check_bandwidth);
1802 EXPORT_SYMBOL(usb_claim_bandwidth);
1803 EXPORT_SYMBOL(usb_release_bandwidth);
1804
1805 EXPORT_SYMBOL(usb_set_address);
1806 EXPORT_SYMBOL(usb_get_descriptor);
1807 EXPORT_SYMBOL(usb_get_class_descriptor);
1808 EXPORT_SYMBOL(__usb_get_extra_descriptor);
1809 EXPORT_SYMBOL(usb_get_device_descriptor);
1810 EXPORT_SYMBOL(usb_get_string);
1811 EXPORT_SYMBOL(usb_string);
1812 EXPORT_SYMBOL(usb_get_protocol);
1813 EXPORT_SYMBOL(usb_set_protocol);
1814 EXPORT_SYMBOL(usb_get_report);
1815 EXPORT_SYMBOL(usb_set_report);
1816 EXPORT_SYMBOL(usb_set_idle);
1817 EXPORT_SYMBOL(usb_clear_halt);
1818 EXPORT_SYMBOL(usb_set_interface);
1819 EXPORT_SYMBOL(usb_get_configuration);
1820 EXPORT_SYMBOL(usb_set_configuration);
1821
1822 EXPORT_SYMBOL(usb_get_current_frame_number);
1823
1824 EXPORT_SYMBOL(usb_alloc_urb);
1825 EXPORT_SYMBOL(usb_free_urb);
1826 EXPORT_SYMBOL(usb_submit_urb);
1827 EXPORT_SYMBOL(usb_unlink_urb);
1828
1829 EXPORT_SYMBOL(usb_control_msg);
1830 EXPORT_SYMBOL(usb_bulk_msg);
Mirror of the linux-mips.org kernel tree