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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
usb.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：67k
源码类别：

嵌入式Linux

开发平台：

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