usb.c (1512300689426cb98bfd7e567ee9fdfaaf61b7c7) | usb.c (782e70c6fc2290a0395850e8e02583b8b62264d8) |
---|---|
1/* 2 * drivers/usb/core/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) --- 82 unchanged lines hidden (view full) --- 91 return NULL; 92 for (i = 0; i < config->desc.bNumInterfaces; i++) 93 if (config->interface[i]->altsetting[0] 94 .desc.bInterfaceNumber == ifnum) 95 return config->interface[i]; 96 97 return NULL; 98} | 1/* 2 * drivers/usb/core/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) --- 82 unchanged lines hidden (view full) --- 91 return NULL; 92 for (i = 0; i < config->desc.bNumInterfaces; i++) 93 if (config->interface[i]->altsetting[0] 94 .desc.bInterfaceNumber == ifnum) 95 return config->interface[i]; 96 97 return NULL; 98} |
99EXPORT_SYMBOL_GPL(usb_ifnum_to_if); |
|
99 100/** 101 * usb_altnum_to_altsetting - get the altsetting structure with a given 102 * alternate setting number. 103 * @intf: the interface containing the altsetting in question 104 * @altnum: the desired alternate setting number 105 * 106 * This searches the altsetting array of the specified interface for --- 14 unchanged lines hidden (view full) --- 121 int i; 122 123 for (i = 0; i < intf->num_altsetting; i++) { 124 if (intf->altsetting[i].desc.bAlternateSetting == altnum) 125 return &intf->altsetting[i]; 126 } 127 return NULL; 128} | 100 101/** 102 * usb_altnum_to_altsetting - get the altsetting structure with a given 103 * alternate setting number. 104 * @intf: the interface containing the altsetting in question 105 * @altnum: the desired alternate setting number 106 * 107 * This searches the altsetting array of the specified interface for --- 14 unchanged lines hidden (view full) --- 122 int i; 123 124 for (i = 0; i < intf->num_altsetting; i++) { 125 if (intf->altsetting[i].desc.bAlternateSetting == altnum) 126 return &intf->altsetting[i]; 127 } 128 return NULL; 129} |
130EXPORT_SYMBOL_GPL(usb_altnum_to_altsetting); |
|
129 130struct find_interface_arg { 131 int minor; 132 struct usb_interface *interface; 133}; 134 135static int __find_interface(struct device * dev, void * data) 136{ --- 28 unchanged lines hidden (view full) --- 165 166 argb.minor = minor; 167 argb.interface = NULL; 168 /* eat the error, it will be in argb.interface */ 169 retval = driver_for_each_device(&drv->drvwrap.driver, NULL, &argb, 170 __find_interface); 171 return argb.interface; 172} | 131 132struct find_interface_arg { 133 int minor; 134 struct usb_interface *interface; 135}; 136 137static int __find_interface(struct device * dev, void * data) 138{ --- 28 unchanged lines hidden (view full) --- 167 168 argb.minor = minor; 169 argb.interface = NULL; 170 /* eat the error, it will be in argb.interface */ 171 retval = driver_for_each_device(&drv->drvwrap.driver, NULL, &argb, 172 __find_interface); 173 return argb.interface; 174} |
175EXPORT_SYMBOL_GPL(usb_find_interface); |
|
173 174/** 175 * usb_release_dev - free a usb device structure when all users of it are finished. 176 * @dev: device that's been disconnected 177 * 178 * Will be called only by the device core when all users of this usb device are 179 * done. 180 */ --- 183 unchanged lines hidden (view full) --- 364 * A pointer to the device with the incremented reference counter is returned. 365 */ 366struct usb_device *usb_get_dev(struct usb_device *dev) 367{ 368 if (dev) 369 get_device(&dev->dev); 370 return dev; 371} | 176 177/** 178 * usb_release_dev - free a usb device structure when all users of it are finished. 179 * @dev: device that's been disconnected 180 * 181 * Will be called only by the device core when all users of this usb device are 182 * done. 183 */ --- 183 unchanged lines hidden (view full) --- 367 * A pointer to the device with the incremented reference counter is returned. 368 */ 369struct usb_device *usb_get_dev(struct usb_device *dev) 370{ 371 if (dev) 372 get_device(&dev->dev); 373 return dev; 374} |
375EXPORT_SYMBOL_GPL(usb_get_dev); |
|
372 373/** 374 * usb_put_dev - release a use of the usb device structure 375 * @dev: device that's been disconnected 376 * 377 * Must be called when a user of a device is finished with it. When the last 378 * user of the device calls this function, the memory of the device is freed. 379 */ 380void usb_put_dev(struct usb_device *dev) 381{ 382 if (dev) 383 put_device(&dev->dev); 384} | 376 377/** 378 * usb_put_dev - release a use of the usb device structure 379 * @dev: device that's been disconnected 380 * 381 * Must be called when a user of a device is finished with it. When the last 382 * user of the device calls this function, the memory of the device is freed. 383 */ 384void usb_put_dev(struct usb_device *dev) 385{ 386 if (dev) 387 put_device(&dev->dev); 388} |
389EXPORT_SYMBOL_GPL(usb_put_dev); |
|
385 386/** 387 * usb_get_intf - increments the reference count of the usb interface structure 388 * @intf: the interface being referenced 389 * 390 * Each live reference to a interface must be refcounted. 391 * 392 * Drivers for USB interfaces should normally record such references in --- 4 unchanged lines hidden (view full) --- 397 * returned. 398 */ 399struct usb_interface *usb_get_intf(struct usb_interface *intf) 400{ 401 if (intf) 402 get_device(&intf->dev); 403 return intf; 404} | 390 391/** 392 * usb_get_intf - increments the reference count of the usb interface structure 393 * @intf: the interface being referenced 394 * 395 * Each live reference to a interface must be refcounted. 396 * 397 * Drivers for USB interfaces should normally record such references in --- 4 unchanged lines hidden (view full) --- 402 * returned. 403 */ 404struct usb_interface *usb_get_intf(struct usb_interface *intf) 405{ 406 if (intf) 407 get_device(&intf->dev); 408 return intf; 409} |
410EXPORT_SYMBOL_GPL(usb_get_intf); |
|
405 406/** 407 * usb_put_intf - release a use of the usb interface structure 408 * @intf: interface that's been decremented 409 * 410 * Must be called when a user of an interface is finished with it. When the 411 * last user of the interface calls this function, the memory of the interface 412 * is freed. 413 */ 414void usb_put_intf(struct usb_interface *intf) 415{ 416 if (intf) 417 put_device(&intf->dev); 418} | 411 412/** 413 * usb_put_intf - release a use of the usb interface structure 414 * @intf: interface that's been decremented 415 * 416 * Must be called when a user of an interface is finished with it. When the 417 * last user of the interface calls this function, the memory of the interface 418 * is freed. 419 */ 420void usb_put_intf(struct usb_interface *intf) 421{ 422 if (intf) 423 put_device(&intf->dev); 424} |
425EXPORT_SYMBOL_GPL(usb_put_intf); |
|
419 | 426 |
420 | |
421/* USB device locking 422 * 423 * USB devices and interfaces are locked using the semaphore in their 424 * embedded struct device. The hub driver guarantees that whenever a 425 * device is connected or disconnected, drivers are called with the 426 * USB device locked as well as their particular interface. 427 * 428 * Complications arise when several devices are to be locked at the same --- 55 unchanged lines hidden (view full) --- 484 return -ENODEV; 485 if (udev->state == USB_STATE_SUSPENDED) 486 return -EHOSTUNREACH; 487 if (iface && iface->condition != USB_INTERFACE_BOUND) 488 return -EINTR; 489 } 490 return 1; 491} | 427/* USB device locking 428 * 429 * USB devices and interfaces are locked using the semaphore in their 430 * embedded struct device. The hub driver guarantees that whenever a 431 * device is connected or disconnected, drivers are called with the 432 * USB device locked as well as their particular interface. 433 * 434 * Complications arise when several devices are to be locked at the same --- 55 unchanged lines hidden (view full) --- 490 return -ENODEV; 491 if (udev->state == USB_STATE_SUSPENDED) 492 return -EHOSTUNREACH; 493 if (iface && iface->condition != USB_INTERFACE_BOUND) 494 return -EINTR; 495 } 496 return 1; 497} |
498EXPORT_SYMBOL_GPL(usb_lock_device_for_reset); |
|
492 | 499 |
493 | |
494static struct usb_device *match_device(struct usb_device *dev, 495 u16 vendor_id, u16 product_id) 496{ 497 struct usb_device *ret_dev = NULL; 498 int child; 499 500 dev_dbg(&dev->dev, "check for vendor %04x, product %04x ...\n", 501 le16_to_cpu(dev->descriptor.idVendor), --- 71 unchanged lines hidden (view full) --- 573 * "scheduling horizons". While one type might support scheduling only 574 * 32 frames into the future, others could support scheduling up to 575 * 1024 frames into the future. 576 */ 577int usb_get_current_frame_number(struct usb_device *dev) 578{ 579 return usb_hcd_get_frame_number(dev); 580} | 500static struct usb_device *match_device(struct usb_device *dev, 501 u16 vendor_id, u16 product_id) 502{ 503 struct usb_device *ret_dev = NULL; 504 int child; 505 506 dev_dbg(&dev->dev, "check for vendor %04x, product %04x ...\n", 507 le16_to_cpu(dev->descriptor.idVendor), --- 71 unchanged lines hidden (view full) --- 579 * "scheduling horizons". While one type might support scheduling only 580 * 32 frames into the future, others could support scheduling up to 581 * 1024 frames into the future. 582 */ 583int usb_get_current_frame_number(struct usb_device *dev) 584{ 585 return usb_hcd_get_frame_number(dev); 586} |
587EXPORT_SYMBOL_GPL(usb_get_current_frame_number); |
|
581 582/*-------------------------------------------------------------------*/ 583/* 584 * __usb_get_extra_descriptor() finds a descriptor of specific type in the 585 * extra field of the interface and endpoint descriptor structs. 586 */ 587 588int __usb_get_extra_descriptor(char *buffer, unsigned size, --- 18 unchanged lines hidden (view full) --- 607 return 0; 608 } 609 610 buffer += header->bLength; 611 size -= header->bLength; 612 } 613 return -1; 614} | 588 589/*-------------------------------------------------------------------*/ 590/* 591 * __usb_get_extra_descriptor() finds a descriptor of specific type in the 592 * extra field of the interface and endpoint descriptor structs. 593 */ 594 595int __usb_get_extra_descriptor(char *buffer, unsigned size, --- 18 unchanged lines hidden (view full) --- 614 return 0; 615 } 616 617 buffer += header->bLength; 618 size -= header->bLength; 619 } 620 return -1; 621} |
622EXPORT_SYMBOL_GPL(__usb_get_extra_descriptor); |
|
615 616/** 617 * usb_buffer_alloc - allocate dma-consistent buffer for URB_NO_xxx_DMA_MAP 618 * @dev: device the buffer will be used with 619 * @size: requested buffer size 620 * @mem_flags: affect whether allocation may block 621 * @dma: used to return DMA address of buffer 622 * --- 18 unchanged lines hidden (view full) --- 641 gfp_t mem_flags, 642 dma_addr_t *dma 643) 644{ 645 if (!dev || !dev->bus) 646 return NULL; 647 return hcd_buffer_alloc(dev->bus, size, mem_flags, dma); 648} | 623 624/** 625 * usb_buffer_alloc - allocate dma-consistent buffer for URB_NO_xxx_DMA_MAP 626 * @dev: device the buffer will be used with 627 * @size: requested buffer size 628 * @mem_flags: affect whether allocation may block 629 * @dma: used to return DMA address of buffer 630 * --- 18 unchanged lines hidden (view full) --- 649 gfp_t mem_flags, 650 dma_addr_t *dma 651) 652{ 653 if (!dev || !dev->bus) 654 return NULL; 655 return hcd_buffer_alloc(dev->bus, size, mem_flags, dma); 656} |
657EXPORT_SYMBOL_GPL(usb_buffer_alloc); |
|
649 650/** 651 * usb_buffer_free - free memory allocated with usb_buffer_alloc() 652 * @dev: device the buffer was used with 653 * @size: requested buffer size 654 * @addr: CPU address of buffer 655 * @dma: DMA address of buffer 656 * --- 9 unchanged lines hidden (view full) --- 666) 667{ 668 if (!dev || !dev->bus) 669 return; 670 if (!addr) 671 return; 672 hcd_buffer_free(dev->bus, size, addr, dma); 673} | 658 659/** 660 * usb_buffer_free - free memory allocated with usb_buffer_alloc() 661 * @dev: device the buffer was used with 662 * @size: requested buffer size 663 * @addr: CPU address of buffer 664 * @dma: DMA address of buffer 665 * --- 9 unchanged lines hidden (view full) --- 675) 676{ 677 if (!dev || !dev->bus) 678 return; 679 if (!addr) 680 return; 681 hcd_buffer_free(dev->bus, size, addr, dma); 682} |
683EXPORT_SYMBOL_GPL(usb_buffer_free); |
|
674 675/** 676 * usb_buffer_map - create DMA mapping(s) for an urb 677 * @urb: urb whose transfer_buffer/setup_packet will be mapped 678 * 679 * Return value is either null (indicating no buffer could be mapped), or 680 * the parameter. URB_NO_TRANSFER_DMA_MAP and URB_NO_SETUP_DMA_MAP are 681 * added to urb->transfer_flags if the operation succeeds. If the device --- 31 unchanged lines hidden (view full) --- 713 // FIXME generic api broken like pci, can't report errors 714 // if (urb->transfer_dma == DMA_ADDR_INVALID) return 0; 715 } else 716 urb->transfer_dma = ~0; 717 urb->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP 718 | URB_NO_SETUP_DMA_MAP); 719 return urb; 720} | 684 685/** 686 * usb_buffer_map - create DMA mapping(s) for an urb 687 * @urb: urb whose transfer_buffer/setup_packet will be mapped 688 * 689 * Return value is either null (indicating no buffer could be mapped), or 690 * the parameter. URB_NO_TRANSFER_DMA_MAP and URB_NO_SETUP_DMA_MAP are 691 * added to urb->transfer_flags if the operation succeeds. If the device --- 31 unchanged lines hidden (view full) --- 723 // FIXME generic api broken like pci, can't report errors 724 // if (urb->transfer_dma == DMA_ADDR_INVALID) return 0; 725 } else 726 urb->transfer_dma = ~0; 727 urb->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP 728 | URB_NO_SETUP_DMA_MAP); 729 return urb; 730} |
731EXPORT_SYMBOL_GPL(usb_buffer_map); |
|
721#endif /* 0 */ 722 723/* XXX DISABLED, no users currently. If you wish to re-enable this 724 * XXX please determine whether the sync is to transfer ownership of 725 * XXX the buffer from device to cpu or vice verse, and thusly use the 726 * XXX appropriate _for_{cpu,device}() method. -DaveM 727 */ 728#if 0 --- 21 unchanged lines hidden (view full) --- 750 ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 751 if (usb_pipecontrol(urb->pipe)) 752 dma_sync_single(controller, 753 urb->setup_dma, 754 sizeof(struct usb_ctrlrequest), 755 DMA_TO_DEVICE); 756 } 757} | 732#endif /* 0 */ 733 734/* XXX DISABLED, no users currently. If you wish to re-enable this 735 * XXX please determine whether the sync is to transfer ownership of 736 * XXX the buffer from device to cpu or vice verse, and thusly use the 737 * XXX appropriate _for_{cpu,device}() method. -DaveM 738 */ 739#if 0 --- 21 unchanged lines hidden (view full) --- 761 ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 762 if (usb_pipecontrol(urb->pipe)) 763 dma_sync_single(controller, 764 urb->setup_dma, 765 sizeof(struct usb_ctrlrequest), 766 DMA_TO_DEVICE); 767 } 768} |
769EXPORT_SYMBOL_GPL(usb_buffer_dmasync); |
|
758#endif 759 760/** 761 * usb_buffer_unmap - free DMA mapping(s) for an urb 762 * @urb: urb whose transfer_buffer will be unmapped 763 * 764 * Reverses the effect of usb_buffer_map(). 765 */ --- 19 unchanged lines hidden (view full) --- 785 dma_unmap_single(controller, 786 urb->setup_dma, 787 sizeof(struct usb_ctrlrequest), 788 DMA_TO_DEVICE); 789 } 790 urb->transfer_flags &= ~(URB_NO_TRANSFER_DMA_MAP 791 | URB_NO_SETUP_DMA_MAP); 792} | 770#endif 771 772/** 773 * usb_buffer_unmap - free DMA mapping(s) for an urb 774 * @urb: urb whose transfer_buffer will be unmapped 775 * 776 * Reverses the effect of usb_buffer_map(). 777 */ --- 19 unchanged lines hidden (view full) --- 797 dma_unmap_single(controller, 798 urb->setup_dma, 799 sizeof(struct usb_ctrlrequest), 800 DMA_TO_DEVICE); 801 } 802 urb->transfer_flags &= ~(URB_NO_TRANSFER_DMA_MAP 803 | URB_NO_SETUP_DMA_MAP); 804} |
805EXPORT_SYMBOL_GPL(usb_buffer_unmap); |
|
793#endif /* 0 */ 794 795/** 796 * usb_buffer_map_sg - create scatterlist DMA mapping(s) for an endpoint 797 * @dev: device to which the scatterlist will be mapped 798 * @is_in: mapping transfer direction 799 * @sg: the scatterlist to map 800 * @nents: the number of entries in the scatterlist --- 28 unchanged lines hidden (view full) --- 829 || !(controller = bus->controller) 830 || !controller->dma_mask) 831 return -1; 832 833 // FIXME generic api broken like pci, can't report errors 834 return dma_map_sg(controller, sg, nents, 835 is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 836} | 806#endif /* 0 */ 807 808/** 809 * usb_buffer_map_sg - create scatterlist DMA mapping(s) for an endpoint 810 * @dev: device to which the scatterlist will be mapped 811 * @is_in: mapping transfer direction 812 * @sg: the scatterlist to map 813 * @nents: the number of entries in the scatterlist --- 28 unchanged lines hidden (view full) --- 842 || !(controller = bus->controller) 843 || !controller->dma_mask) 844 return -1; 845 846 // FIXME generic api broken like pci, can't report errors 847 return dma_map_sg(controller, sg, nents, 848 is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 849} |
850EXPORT_SYMBOL_GPL(usb_buffer_map_sg); |
|
837 838/* XXX DISABLED, no users currently. If you wish to re-enable this 839 * XXX please determine whether the sync is to transfer ownership of 840 * XXX the buffer from device to cpu or vice verse, and thusly use the 841 * XXX appropriate _for_{cpu,device}() method. -DaveM 842 */ 843#if 0 844 --- 17 unchanged lines hidden (view full) --- 862 || !(bus = dev->bus) 863 || !(controller = bus->controller) 864 || !controller->dma_mask) 865 return; 866 867 dma_sync_sg(controller, sg, n_hw_ents, 868 is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 869} | 851 852/* XXX DISABLED, no users currently. If you wish to re-enable this 853 * XXX please determine whether the sync is to transfer ownership of 854 * XXX the buffer from device to cpu or vice verse, and thusly use the 855 * XXX appropriate _for_{cpu,device}() method. -DaveM 856 */ 857#if 0 858 --- 17 unchanged lines hidden (view full) --- 876 || !(bus = dev->bus) 877 || !(controller = bus->controller) 878 || !controller->dma_mask) 879 return; 880 881 dma_sync_sg(controller, sg, n_hw_ents, 882 is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 883} |
884EXPORT_SYMBOL_GPL(usb_buffer_dmasync_sg); |
|
870#endif 871 872/** 873 * usb_buffer_unmap_sg - free DMA mapping(s) for a scatterlist 874 * @dev: device to which the scatterlist will be mapped 875 * @is_in: mapping transfer direction 876 * @sg: the scatterlist to unmap 877 * @n_hw_ents: the positive return value from usb_buffer_map_sg --- 10 unchanged lines hidden (view full) --- 888 || !(bus = dev->bus) 889 || !(controller = bus->controller) 890 || !controller->dma_mask) 891 return; 892 893 dma_unmap_sg(controller, sg, n_hw_ents, 894 is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 895} | 885#endif 886 887/** 888 * usb_buffer_unmap_sg - free DMA mapping(s) for a scatterlist 889 * @dev: device to which the scatterlist will be mapped 890 * @is_in: mapping transfer direction 891 * @sg: the scatterlist to unmap 892 * @n_hw_ents: the positive return value from usb_buffer_map_sg --- 10 unchanged lines hidden (view full) --- 903 || !(bus = dev->bus) 904 || !(controller = bus->controller) 905 || !controller->dma_mask) 906 return; 907 908 dma_unmap_sg(controller, sg, n_hw_ents, 909 is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 910} |
911EXPORT_SYMBOL_GPL(usb_buffer_unmap_sg); |
|
896 897/* format to disable USB on kernel command line is: nousb */ 898__module_param_call("", nousb, param_set_bool, param_get_bool, &nousb, 0444); 899 900/* 901 * for external read access to <nousb> 902 */ 903int usb_disabled(void) 904{ 905 return nousb; 906} | 912 913/* format to disable USB on kernel command line is: nousb */ 914__module_param_call("", nousb, param_set_bool, param_get_bool, &nousb, 0444); 915 916/* 917 * for external read access to <nousb> 918 */ 919int usb_disabled(void) 920{ 921 return nousb; 922} |
923EXPORT_SYMBOL_GPL(usb_disabled); |
|
907 908/* 909 * Init 910 */ 911static int __init usb_init(void) 912{ 913 int retval; 914 if (nousb) { --- 65 unchanged lines hidden (view full) --- 980 usb_hub_cleanup(); 981 usb_host_cleanup(); 982 bus_unregister(&usb_bus_type); 983 ksuspend_usb_cleanup(); 984} 985 986subsys_initcall(usb_init); 987module_exit(usb_exit); | 924 925/* 926 * Init 927 */ 928static int __init usb_init(void) 929{ 930 int retval; 931 if (nousb) { --- 65 unchanged lines hidden (view full) --- 997 usb_hub_cleanup(); 998 usb_host_cleanup(); 999 bus_unregister(&usb_bus_type); 1000 ksuspend_usb_cleanup(); 1001} 1002 1003subsys_initcall(usb_init); 1004module_exit(usb_exit); |
988 989/* 990 * USB may be built into the kernel or be built as modules. 991 * These symbols are exported for device (or host controller) 992 * driver modules to use. 993 */ 994 995EXPORT_SYMBOL(usb_disabled); 996 997EXPORT_SYMBOL_GPL(usb_get_intf); 998EXPORT_SYMBOL_GPL(usb_put_intf); 999 1000EXPORT_SYMBOL(usb_put_dev); 1001EXPORT_SYMBOL(usb_get_dev); 1002EXPORT_SYMBOL(usb_hub_tt_clear_buffer); 1003 1004EXPORT_SYMBOL(usb_lock_device_for_reset); 1005 1006EXPORT_SYMBOL(usb_find_interface); 1007EXPORT_SYMBOL(usb_ifnum_to_if); 1008EXPORT_SYMBOL(usb_altnum_to_altsetting); 1009 1010EXPORT_SYMBOL(__usb_get_extra_descriptor); 1011 1012EXPORT_SYMBOL(usb_get_current_frame_number); 1013 1014EXPORT_SYMBOL(usb_buffer_alloc); 1015EXPORT_SYMBOL(usb_buffer_free); 1016 1017#if 0 1018EXPORT_SYMBOL(usb_buffer_map); 1019EXPORT_SYMBOL(usb_buffer_dmasync); 1020EXPORT_SYMBOL(usb_buffer_unmap); 1021#endif 1022 1023EXPORT_SYMBOL(usb_buffer_map_sg); 1024#if 0 1025EXPORT_SYMBOL(usb_buffer_dmasync_sg); 1026#endif 1027EXPORT_SYMBOL(usb_buffer_unmap_sg); 1028 | |
1029MODULE_LICENSE("GPL"); | 1005MODULE_LICENSE("GPL"); |