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");