开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
usb.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：65k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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