linux usb驱动详解

1 数据结构说明
1.1
struct usb_device_id {
        /* which fields to match against? */
        __u16                match_flags;


        /* Used for product specific matches; range is inclusive */
        __u16                idVendor;
        __u16                idProduct;
        __u16                bcdDevice_lo;
        __u16                bcdDevice_hi;


        /* Used for device class matches */
        __u8                bDeviceClass;
        __u8                bDeviceSubClass;
        __u8                bDeviceProtocol;


        /* Used for interface class matches */
        __u8                bInterfaceClass;
        __u8                bInterfaceSubClass;
        __u8                bInterfaceProtocol;


        /* Used for vendor-specific interface matches */
        __u8                bInterfaceNumber;


        /* not matched against */
        kernel_ulong_t        driver_info
                __attribute__((aligned(sizeof(kernel_ulong_t))));
};
成员变量说明：
match_flags ：需要匹配的类型（可以多个或起来），数据定义如下：
        #define USB_DEVICE_ID_MATCH_VENDOR                0x0001 //匹配PID
        #define USB_DEVICE_ID_MATCH_PRODUCT                0x0002 //匹配VID
        #define USB_DEVICE_ID_MATCH_DEV_LO                0x0004 //匹配产品编号低位
        #define USB_DEVICE_ID_MATCH_DEV_HI                0x0008 //匹配产品编号高位
        #define USB_DEVICE_ID_MATCH_DEV_CLASS                0x0010 //匹配设备描述符的class
        #define USB_DEVICE_ID_MATCH_DEV_SUBCLASS        0x0020 //匹配设备描述符的subclass
        #define USB_DEVICE_ID_MATCH_DEV_PROTOCOL        0x0040 //匹配设备描述符的protocol
        #define USB_DEVICE_ID_MATCH_INT_CLASS                0x0080 //匹配接口描述符的class
        #define USB_DEVICE_ID_MATCH_INT_SUBCLASS        0x0100 //匹配接口描述符的subclass
        #define USB_DEVICE_ID_MATCH_INT_PROTOCOL        0x0200 //匹配接口描述符的protocol
        #define USB_DEVICE_ID_MATCH_INT_NUMBER                0x0400 //匹配接口的数量
driver_info ：用来保存用户的私有数据


1.2 
struct usb_driver {
        const char *name;


        int (*probe) (struct usb_interface *intf,
                      const struct usb_device_id *id);


        void (*disconnect) (struct usb_interface *intf);


        int (*unlocked_ioctl) (struct usb_interface *intf, unsigned int code,
                        void *buf);


        int (*suspend) (struct usb_interface *intf, pm_message_t message);
        int (*resume) (struct usb_interface *intf);
        int (*reset_resume)(struct usb_interface *intf);


        int (*pre_reset)(struct usb_interface *intf);
        int (*post_reset)(struct usb_interface *intf);


        const struct usb_device_id *id_table;


        struct usb_dynids dynids;
        struct usbdrv_wrap drvwrap;
        unsigned int no_dynamic_id:1;
        unsigned int supports_autosuspend:1;
        unsigned int disable_hub_initiated_lpm:1;
        unsigned int soft_unbind:1;
};
name：独一无二的设备的名字
probe：回调函数指针，在USB设备插入，且符合struct usb_device_id 定义的匹配条件是被调用。这是如果匹配成功返回0，
disconnect：回调函数指针，当设备拔出时被调用
unlocked_ioctl：
suspend : 设备休眠的时候被调用
resume：设备唤醒的时候被调用
reset_resume：设备在休眠的时候已经reset，唤醒的时候调用
pre_reset：在调用usb_reset_device()的时候这个回调函数被调用，这个函数在reset前调用，该函数必须等到没有有效的URBs才能返回。
post_reset：在调用usb_reset_device()的时候这个回调函数被调用，这个函数在reset完成后调用
id_table：需要匹配的设备信息
dynids：用来保持动态添加的设备列表
drvwrap：Driver-model core structure wrapper
no_dynamic_id：如果设置为1，内核将不允许添加动态设备列表
supports_autosuspend：如果设置为0 内核将不允许设备自动休眠,不知道为什么这个参数设置为0，有时会造成设备访问被拒绝
soft_unbind：如果设置为1 ，在设备拔出前，不允许禁用端点，杀掉URBs
disable_hub_initiated_lpm：
注意：这个结构必须要实现name、probe、disconnect、id_table，其他成员可以根据情况选择是否实现


1.3
struct usb_class_driver {
        char *name;
        char *(*devnode)(struct device *dev, umode_t *mode);
        const struct file_operations *fops;
        int minor_base;
};
name:设备节点的名称，也就是在dev目录下的设备，可以直接Open这个设备进行读写
devnode：？？
fops：设备文件操作结构
minor_base：次设备号的基准值,


1.4
struct urb {
        /* private: usb core and host controller only fields in the urb */
        struct kref kref;                /* reference count of the URB */
        void *hcpriv;                        /* private data for host controller */
        atomic_t use_count;                /* concurrent submissions counter */
        atomic_t reject;                /* submissions will fail */
        int unlinked;                        /* unlink error code */


        /* public: documented fields in the urb that can be used by drivers */
        struct list_head urb_list;        /* list head for use by the urb's  * current owner */
        struct list_head anchor_list;        /* the URB may be anchored */
        struct usb_anchor *anchor;
        struct usb_device *dev;                /* (in) pointer to associated device */
        struct usb_host_endpoint *ep;        /* (internal) pointer to endpoint */
        unsigned int pipe;                /* (in) pipe information */
        unsigned int stream_id;                /* (in) stream ID */
        int status;                        /* (return) non-ISO status */
        unsigned int transfer_flags;        /* (in) URB_SHORT_NOT_OK | ...*/
        void *transfer_buffer;                /* (in) associated data buffer */
        dma_addr_t transfer_dma;        /* (in) dma addr for transfer_buffer */
        struct scatterlist *sg;                /* (in) scatter gather buffer list */
        int num_mapped_sgs;                /* (internal) mapped sg entries */
        int num_sgs;                        /* (in) number of entries in the sg list */
        u32 transfer_buffer_length;        /* (in) data buffer length */
        u32 actual_length;                /* (return) actual transfer length */
        unsigned char *setup_packet;        /* (in) setup packet (control only) */
        dma_addr_t setup_dma;                /* (in) dma addr for setup_packet */
        int start_frame;                /* (modify) start frame (ISO) */
        int number_of_packets;                /* (in) number of ISO packets */
        int interval;                        /* (modify) transfer interval
                                         * (INT/ISO) */
        int error_count;                /* (return) number of ISO errors */
        void *context;                        /* (in) context for completion */
        usb_complete_t complete;        /* (in) completion routine */
        struct usb_iso_packet_descriptor iso_frame_desc[0];
                                        /* (in) ISO ONLY */
};
以下的成员变量是私有的，只能由usb核心和主机控制器访问的字段 
        kref ： urb引用计数 ，当计数引用为0时，系统释放urb
        hcpriv ： 主机控制器私有数据 
        use_count ：   并发传输计数  
        reject : 传输将失败


以下的成员变量是公共的，可以被驱动使用的字段 
        urb_list ：链表头
        dev ：关联的usb设备 
        pipe ：端点消息,这个变量必须在这个 urb 被发送到 USB 核心之前被 USB 驱动初始化.
               要设置这个结构的成员, 驱动可以使用下面的函数来设置. 注意每个端点只可以是一个类型.
                unsigned int usb_sndctrlpipe(struct usb_device *dev, unsigned int endpoint)
                        指定一个控制 OUT 端点给特定的带有特定端点号的 USB 设备.
                unsigned int usb_rcvctrlpipe(struct usb_device *dev, unsigned int endpoint)
                        指定一个控制 IN 端点给带有特定端点号的特定 USB 设备.
                unsigned int usb_sndbulkpipe(struct usb_device *dev, unsigned int endpoint)
                        指定一个块传输 OUT 端点给带有特定端点号的特定 USB 设备
                unsigned int usb_rcvbulkpipe(struct usb_device *dev, unsigned int endpoint)
                        指定一个块传输 IN 端点给带有特定端点号的特定 USB 设备
                unsigned int usb_sndintpipe(struct usb_device *dev, unsigned int endpoint)
                        指定一个中断传输 OUT 端点给带有特定端点号的特定 USB 设备
                unsigned int usb_rcvintpipe(struct usb_device *dev, unsigned int endpoint)
                        指定一个中断传输 IN 端点给带有特定端点号的特定 USB 设备
                unsigned int usb_sndisocpipe(struct usb_device *dev, unsigned int endpoint)
                        指定一个同步传输 OUT 端点给带有特定端点号的特定 USB 设备
                unsigned int usb_rcvisocpipe(struct usb_device *dev, unsigned int endpoint)
                        指定一个同步传输 IN 端点给带有特定端点号的特定 USB 设备 
        status ： urb的当前状态 
                0        urb 传送是成功的.
                -ENOENT  这个 urb 被 usb_kill_urb调用停止.
                -ECONNRESET urb 被usb_unlink_urb 调用去链, 并且 transfer_flags 变量被设置为 URB_ASYNC_UNLINK.
                -EINPROGRESS  这个 urb 仍然在被 USB 主机控制器处理中. 如果你的驱动曾见到这个值, 它是一个你的驱动中的 bug.
                -EPROTO       一个 bitstuff 错误在传送中发生. 硬件没有及时收到响应帧.
                 -EILSEQ       在这个 urb 传送中 CRC 不匹配.
                -EPIPE        这个端点现在被停止. 如果这个包含的端点不是一个控制端点, 这个错误可被清除通过一个对函数 usb_clear_halt 的调用.
                -ECOMM        在传送中数据接收快于能被写入系统内存. 这个错误值只对 IN urb.
                -ENOSR        在传送中数据不能从系统内存中获取得足够快, 以便可跟上请求的 USB 数据速率. 这个错误只对 OUT urb.
                -EOVERFLOW    这个 urb 发生一个"babble"错误. 一个"babble"错误发生当端点接受数据多于端点的特定最大报文大小.
                -EREMOTEIO    只发生在当 URB_SHORT_NOT_OK 标志被设置在 urb 的 transfer_flags 变量, 并且意味着 urb 请求的完整数量的数据没有收到.
                -ENODEV       这个 USB 设备现在从系统中消失.
                -EXDEV        只对同步 urb 发生, 并且意味着传送只部分完成. 为了决定传送什么, 驱动必须看单独的帧状态.
                -EINVAL       这个 urb 发生了非常坏的事情. USB 内核文档描述了这个值意味着什么:ISO 疯了, 如果发生这个: 退出并回家.
                      它也可发生, 如果一个参数在 urb 结构中被不正确地设置了, 或者如果在提交这个 urb 给 USB 核心的 usb_submit_urb 调用中, 有一个不正确的函数参数.
                -ESHUTDOWN    这个 USB 主机控制器驱动有严重的错误; 它现在已被禁止, 或者设备和系统去掉连接, 并且这个urb 在设备被去除后被提交. 它也可发生当这个设备的配置改变, 而这个 urb 被提交给设备.
                通常, 错误值 -EPROTO, -EILSEQ, 和 -EOVERFLOW 指示设备的硬件问题, 设备固件, 或者连接设备到计算机的线缆.
                
        transfer_flags：这个变量可被设置为不同位值, 根据这个 USB 驱动想这个 urb 发生什么. 可用的值如下：
                URB_SHORT_NOT_OK          当置位, 它指出任何在一个 IN 端点上可能发生的短读, 应当被 USB 核心当作一个错误. 这个值只对从 USB 设备读的 urb 有用, 不是写 urbs.
                URB_ISO_ASAP              如果这个 urb 是同步的, 这个位可被置位如果驱动想这个 urb 被调度, 只要带宽允许它这样, 并且在此点设置这个 urb 中的 start_frame 变量. 如果对于同步 urb 这个位没有被置位, 驱动必须指定 start_frame 值并且必须能够正确恢复, 如果没有在那个时刻启动. 见下面的章节关于同步 urb 更多的消息.
                URB_NO_TRANSFER_DMA_MAP   应当被置位, 当 urb 包含一个要被发送的 DMA 缓冲. USB 核心使用这个被 transfer_dma 变量指向的缓冲, 不是被 transfer_buffer 变量指向的缓冲.
                URB_NO_SETUP_DMA_MAP      象 URB_NO_TRANSFER_DMA_MAP 位, 这个位用来控制有一个 DMA 缓冲已经建立的 urb. 如果它被置位, USB 核心使用这个被 setup_dma 变量而不是 setup_packet 变量指向的缓冲.
                URB_ASYNC_UNLINK          如果置位, 给这个 urb 的对 usb_unlink_urb 的调用几乎立刻返回, 并且这个 urb 在后面被解除连接. 否则, 这个函数等待直到 urb 完全被去链并且在返回前结束. 小心使用这个位, 因为它可有非常难于调试的同步问题.
                URB_NO_FSBR               只有 UHCI USB 主机控制器驱动使用, 并且告诉它不要试图做 Front Side Bus Reclamation 逻辑. 这个位通常应当不设置, 因为有 UHCI 主机控制器的机器创建了许多 CPU 负担, 并且 PCI 总线被等待设置了这个位的 urb 所饱和.
                URB_ZERO_PACKET           如果置位, 一个块 OUT urb 通过发送不包含数据的短报文而结束, 当数据对齐到一个端点报文边界. 这被一些坏掉的 USB 设备所需要(例如一些 USB 到 IR 的设备) 为了正确的工作..
                URB_NO_INTERRUPT          如果置位, 硬件当 urb 结束时可能不产生一个中断. 这个位应当小心使用并且只在排队多个到相同端点的 urb 时使用. USB 核心函数使用这个为了做 DMA 缓冲传送.
        transfer_buffer : 发送数据到设备或从设备接收数据的缓冲区,这个缓冲区它必须被使用 kmalloc来创建, 不是在堆栈或者静态地址，所以不能定义一个大数组来作为缓冲区.
        transfer_dma ： 用来以dma方式向设备传输数据的缓冲区 
        transfer_buffer_length ： transfer_buffer或transfer_dma 指向缓冲区的大小 
        actual_length ： urb结束后，发送或接收数据的实际长度 
        setup_packet ： 指向控制urb的设置数据包的指针
        setup_dma ：控制urb的设置数据包的dma缓冲区
        start_frame ：等时传输中用于设置或返回初始帧
        number_of_packets ：只对同步 urb 有效, 并且指定这个 urb 要处理的同步传送缓冲的编号. 这个值必须被 USB 驱动设置给同步 urb, 在这个 urb 发送给 USB 核心之前.
        interval ： urb被轮询到的时间间隔（对中断和等时urb有效） 
        error_count ： 等时传输错误数量 
        context ：completion函数上下文 ，用来保存用户数据的指针
        complete ： 回调函数指针，当urb被完全传输或发生错误时，被调用 
                usb_complete_t 类型定义 ：typedef void (*usb_complete_t)(struct urb *, struct pt_regs *);
        iso_frame_desc[0] ： 单个urb一次可定义多个等时传输时，描述各个等时传输 
        
        注意：urb 不能静态创建, 或者在另一个结构中, 必须使用 usb_alloc_urb 函数来创建，使用usb_free_urb来释放 。
        
2 函数说明


        int usb_register_driver(struct usb_driver *new_driver, struct module *owner,        const char *mod_name)
        函数功能：注册一个USB驱动
        参数说明：new_driver ：struct usb_driver的结构指针 
                  owner      ：模块的所有者名
                  mod_name   ：模块名称
        返回值：0 成功 非0 失败
        说明 ：这个函数通常在驱动的__init函数中调用注册一个USB驱动。为简化调用的参数，我们通常直接用 usb_register这个宏
               usb_register定义如下
               #define usb_register(driver)         usb_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)        
         
               
        void usb_deregister(struct usb_driver * driver);
        函数功能：注销一个USB驱动，这个函数通常在驱动的__exit函数中调用
        参数说明：driver ： struct usb_driver的结构指针 
        返回值：无
        
        
        int usb_register_dev(struct usb_interface *intf, struct usb_class_driver *class_driver)
        函数功能：注册一个USB设备，注册成功后可以在/dev目录下看到相应的设备节点,这个函数通常是在struct usb_driver中定义的probe回调函数中被调用
        参数说明：intf ：USB接口描述符
                  class_driver ： struct usb_class_driver 这个结构将指定设备的名称和  file_operations结构
        返回值：0成功 非0 失败 
        
        void usb_deregister_dev(struct usb_interface *intf, struct usb_class_driver *class_driver)
        函数功能： 注销一个USB设备，这个函数通常是在struct usb_driver中定义的disconnect回调函数中被调用
        参数说明：intf ：USB接口描述符
                  class_driver ： struct usb_class_driver 这个结构将指定设备的名称和  file_operations结构
        返回值： 无
        
        struct urb *usb_alloc_urb(int iso_packets, gfp_t mem_flags)
        函数功能：动态分配一个urb，并初始化
        参数说明：iso_packets ： usb_iso_packet_descriptor的个数，这个参数只对同步传输有效。对于控制、中断、块传输，这个参数必须为0
                  mem_flags ： 和kmalloc 函数调用来从内核分配内存的标志类型相同
        返回值：成功返回分配的urb的指针，失败返回NULL
        
        void usb_free_urb(struct urb *urb)
        函数功能：释放usb_alloc_urb分配的urb
        参数说明：urb : 要释放的urb
        返回值：无
        
        void usb_fill_bulk_urb(struct urb *urb,   struct usb_device *dev, unsigned int pipe, void *transfer_buffer, int buffer_length, usb_complete_t complete_fn, void *context)
        void usb_fill_int_urb(struct urb *urb,    struct usb_device *dev, unsigned int pipe, void *transfer_buffer, int buffer_length, usb_complete_t complete_fn, void *context, int interval)
        void usb_fill_control_urb(struct urb *urb,struct usb_device *dev, unsigned int pipe, unsigned char *setup_packet,void *transfer_buffer,int buffer_length,usb_complete_t complete_fn,void *context)
        函数功能：用来填充用于块传输、中断传输、控制传输的urb
        参数说明：Urb:是要初始化的urb
                  Dev:表示消息要被发送到的USB设备
                  Pipe:表示消息被发送到的端点
                  transfer_buffer:表示发送或接收数据的缓冲区
                  length:就是transfer_buffer所表示的缓冲区大小
                  context:完成处理函数的上下文
                  complete_fn:传输完了之后的回调函数.
                  interval：中断传输被调度的间隔
                  setup_packet:将被发送到端点的设置数据包
        返回值：无
        
        int usb_submit_urb(struct urb *urb, gfp_t mem_flags)
        函数功能：用来递交urb,该函数以非阻塞的方式发送，也就是这个函数将不等发送完成就返回。
        参数说明：urb ：指向urb的指针
                  mem_flags ：可以有下面三种取值
                              GFP_ATOMIC：在中断处理函数、底半部、tasklet、定时器处理函数以及urb完成函数中，在调用者持有自旋锁或者读写锁时以及当驱动将current->state修改为非 TASK_ RUNNING时，应使用此标志。
                                GFP_NOIO：在存储设备的块I/O和错误处理路径中，应使用此标志；
                              GFP_KERNEL：如果没有任何理由使用GFP_ATOMIC和GFP_NOIO，就使用GFP_ KERNEL。
        返回值：0成功 非0 失败
        
        void usb_kill_urb(struct urb *urb)
        函数功能：取消一个urb传输，并且等待他结束
        参数说明：要取消的urb的指针
        返回值：无
        
        int usb_unlink_urb(struct urb *urb)
        函数功能：停止 urb传输. 这个函数 不等待这个 urb 完全停止就返回
        参数说明：要取消的urb的指针
        返回值：无
        
        int usb_control_msg(struct usb_device *dev, unsigned int pipe, u8 request, u8 requesttype, u16 value, u16 index, void *data, u16 size, int timeout)
        函数功能：以阻塞的方式进行控制传输，直到超时或urb传输完成函数才返回
        参数说明：Dev:表示消息要被发送到的USB设备
                  Pipe:表示消息被发送到的端点
                  request：命令的序号(其实就是命令)
                  requesttype：D7=0主机到设备， =1设备到主机；
                            D6D5 =00标准请求命令， 01 类请求命令，10用户定义的命令，11保留值
                            D4D3D2D1D0= 0表示接收者为设备，1表示接收者为接口，2表示接收者为端点，3表示接收者为其他
              value：2个字节，用来传送当前请求的参数，随请求不同而变。
              index：索引字段同样是2个字节，描述的是接口号 
              data ：数据缓冲区的指针
              size：数据缓冲区的长度
              timeout：超时时间   
    返回值：0成功，非0 失败           
        
        int usb_interrupt_msg(struct usb_device *usb_dev, unsigned int pipe, void *data, int len, int *actual_length, int timeout)        
        int usb_bulk_msg(struct usb_device *usb_dev, unsigned int pipe, void *data, int len, int *actual_length, int timeout)
        函数功能：以阻塞的方式进行中断或者块传输，直到超时或urb传输完成函数才返回
        参数说明：Dev:表示消息要被发送到的USB设备
                  Pipe:表示消息被发送到的端点             
              data ：数据缓冲区的指针
              len ：数据缓冲区的长度
              actual_length ：实际发送或者接收的数据长度
              timeout：超时时间   
    返回值：0成功，非0 失败  
    
    void usb_anchor_urb(struct urb *urb, struct usb_anchor *anchor)
    函数功能：当urb在处理的时候锁定该urb ，urb被使用时是不能被删除的。在删除一个urb时需要调用usb_wait_anchor_empty_timeout来等待urb传输完全结束
    参数说明：urb：要锁定的urb
              anchor:   
        返回值：无
        
        void usb_unanchor_urb(struct urb *urb) 
        函数功能：解锁一个urb
    参数说明：urb：要解锁的urb 
        返回值：无
        
        int usb_wait_anchor_empty_timeout(struct usb_anchor *anchor,unsigned int timeout)
        函数功能：等待urb传输完全结束
    参数说明：urb：要等待的urb
              anchor: 
              timeout :超时设置  
        返回值：0传输完成，非0 超时
        
        void usb_kill_anchored_urbs(struct usb_anchor *anchor)
        函数功能：撤销一个urb传输
        参数说明:anchor:
        
        
3注册一个USB驱动的流程
        1 定义一个 struct usb_device_id的结构。
        2 定义一个 struct usb_driver，并实现probe和disconnect函数
        3 在模块的init函数中调用usb_register函数注册一个驱动
        4 定义一个usb_class_driver 
        5 在probe函数中调用usb_register_dev注册一个USB设备，这样在dev目录下就可以看到我们的USB设备了
        
下面是示例代码：
。。。。
static const struct file_operations usbdev_fops = {
        .owner =        THIS_MODULE,
        .read =                usbdev_read,
        .write =        usbdev_write,
        .open =                usbdev_open,
        .release =        usbdev_release,
        .flush =        usbdev_flush,
        .llseek =        noop_llseek,
};
static struct usb_class_driver usbdev_class = {
        .name =                "USBTestDevice%d",//这里一次插上多个USB时候，将在dev目录下看到USBTestDevice0、USBTestDevice1 ....
        .fops =                &usbdev_fops,
        .minor_base =        USB_DEV_MINOR_BASE,
};
static int usbdev_probe(struct usb_interface *interface, const struct usb_device_id *id)
{
        ......
        retval = usb_register_dev(interface, &usbdev_class);
        ......
}
static void usbdev_disconnect(struct usb_interface *interface)
{
        ................
        usb_deregister_dev(interface, &usbdev_class);
        ................
}
static const struct usb_device_id usbdev_table[] = {
        { USB_DEVICE(USB_MATCH_VENDOR_ID, USB_MATCH_PRODUCT_ID) },
        { USB_DEVICE(USB_MATCH_VENDOR_ID, USB_MATCH_PRODUCT_ID_1) },
        { }                                        /* Terminating entry */
};
MODULE_DEVICE_TABLE(usb, usbdev_table);
static struct usb_driver usbdev_driver = {
        .name =                "usbtest",
        .probe =        usbdev_probe,
        .disconnect =        usbdev_disconnect,
        .id_table =        usbdev_table,
};
static int __init usbdev_init(void)
{
         
        return usb_register(&usbdev_driver);
         
}
module_init(usbdev_init);
static void __exit usbdev_exit(void)
{
        usb_deregister(&usbdev_driver);
}
module_exit(usbdev_exit);




4 urb的操作流程：
  1 调用usb_alloc_urb分配一个urb
  2 调用kmalloc分配缓冲区
  3 调用usb_fill_XXX_urb初始化urb
  4 调用usb_submit_urb提交
  5 在回调函数（complete）中处理，接收的数据，判断是否还要继续接收，如果还要接收，重复第三步。
    如果是发送数据，判断是否还有数据要发送，填充数据
  6 如果传输完成调用usb_free_urb释放urb,释放缓冲区
  
  下面是示例代码
  //回调函数
static void async_ctrl_callback(struct urb *urb)
{
        struct usb_ctrlrequest *req = (struct usb_ctrlrequest *)urb->context;
        int status = urb->status;


        if (status < 0)
        {
                printk("error\n");
        }
                 
        kfree(req);
        kfree(urb->transfer_buffer);
        usb_free_urb(urb);
}
        struct urb *urb;
        struct usb_ctrlrequest *req;
        void *data;
        urb = usb_alloc_urb(0, GFP_KERNEL);
        req = kmalloc(sizeof(struct usb_ctrlrequest), GFP_ATOMIC);
        /*根据协议设置reg*/
        req->bRequestType = RequestType;
        req->bRequest = Request;
        req->wValue = Value;
        req->wIndex = Index;
        req->wLength = Length;
        data = kmalloc(Length, GFP_KERNEL);
         
        usb_fill_control_urb(urb, dev, usb_sndctrlpipe(dev, 0),reg, data, Length,  usb_ctrl_complete, req);
        usb_submit_urb(urb, GFP_ATOMIC);
        
        对于其他的传输，方法差不多。
        最后需要注意的是中断传输接收，不需要每次调用usb_submit_urb，调用一次usb_submit_urb之后，系统会按照指定的间隔，不断接收数据的。
        
5 下面是完成的驱动的示例代码




#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/kref.h>
#include <linux/uaccess.h>
#include <linux/usb.h>
#include <linux/mutex.h>
#include <linux/moduleparam.h>
#define BUF_PER_PAGE 10240
#define MAX_PAGE 5
   
typedef struct
{
        volatile int iReadIndex;
        volatile int iWriteIndex;
        unsigned char *PackgeBuf[MAX_PAGE];//[BUF_PER_PAGE];
        int iLen[MAX_PAGE];
}cachebuf  ;


 
/* Define these values to match your devices */
#define USB_MATCH_VENDOR_ID            0x1234
#define USB_MATCH_PRODUCT_ID        0x5678
 
/* table of devices that work with this driver */
static const struct usb_device_id usbdev_table[] = {
        { USB_DEVICE(USB_MATCH_VENDOR_ID, USB_MATCH_PRODUCT_ID) },
        { }                                        /* Terminating entry */
};
MODULE_DEVICE_TABLE(usb, usbdev_table);




/* Get a minor range for your devices from the usb maintainer */
#define USB_DEV_MINOR_BASE        192


/* our private defines. if this grows any larger, use your own .h file */
#define MAX_TRANSFER                (PAGE_SIZE - 512)
/* MAX_TRANSFER is chosen so that the VM is not stressed by
   allocations > PAGE_SIZE and the number of packets in a page
   is an integer 512 is the largest possible packet on EHCI */
#define WRITES_IN_FLIGHT        8
/* arbitrarily chosen */


/* Structure to hold all of our device specific stuff */
struct usb_devinfo {
        struct usb_device        *udev;                        /* the usb device for this device */
        struct usb_interface        *interface;                /* the interface for this device */
        struct semaphore        limit_sem;                /* limiting the number of writes in progress */
        struct usb_anchor        submitted;                /* in case we need to retract our submissions */
        struct urb                *bulk_in_urb;                /* the urb to read data with */
        unsigned char           *bulk_in_buffer;        /* the buffer to receive data */
        size_t                        bulk_in_size;                /* the size of the receive buffer */
        size_t                        bulk_in_filled;                /* number of bytes in the buffer */
        size_t                        bulk_in_copied;                /* already copied to user space */
        __u8                        bulk_in_endpointAddr;        /* the address of the bulk in endpoint */
        __u8                        bulk_out_endpointAddr;        /* the address of the bulk out endpoint */
        int                        errors;                        /* the last request tanked */


        spinlock_t                err_lock;                /* lock for errors */
        struct kref                kref;
        struct mutex                io_mutex;                /* synchronize I/O with disconnect */


        cachebuf UsbBuffer; 
        wait_queue_head_t   wqReadOK; /* buf is not empty*/
        struct work_struct work;
        struct mutex                read_mutex;
        int isOpen;
};
 


static struct usb_driver usbdev_driver;
static void usbdev_emptyurb(struct usb_devinfo *dev);
static int devusb_do_read_io(struct usb_devinfo *dev, size_t count);
 
static void work_func(struct work_struct *work)
{
        struct usb_devinfo *dev = container_of(work, struct usb_devinfo, work);
         
        if(dev->isOpen==0)
        {
                return ;
        }
        
        
        if(dev->bulk_in_filled>0)
        {
                int iWriteIndex = dev->UsbBuffer.iWriteIndex;
                mutex_lock(&dev->read_mutex); 
                //memcpy(dev->UsbBuffer.PackgeBuf[iWriteIndex],dev->bulk_in_buffer  ,dev->bulk_in_filled);
                 
                dev->UsbBuffer.iLen[iWriteIndex] = dev->bulk_in_filled;
                mutex_unlock(&dev->read_mutex); 
                iWriteIndex++;
                if(iWriteIndex>=MAX_PAGE)
                {
                        iWriteIndex = 0;
                }
                while(iWriteIndex ==dev->UsbBuffer.iReadIndex)
                {
                        if(iRetry==0)
                                printk(KERN_ALERT"usbdev_overflow(%d %d) \n",dev->UsbBuffer.iReadIndex,dev->UsbBuffer.iWriteIndex);
                         
                         
                }
                mutex_lock(&dev->read_mutex); 
                dev->UsbBuffer.iWriteIndex = iWriteIndex;
                mutex_unlock(&dev->read_mutex); 
                dev->bulk_in_filled = 0;
                //printk("write w=%d r=%d \n",dev->UsbBuffer.iWriteIndex,dev->UsbBuffer.iReadIndex);
                
                devusb_do_read_io(dev,BUF_PER_PAGE);
                wake_up_interruptible(&dev->wqReadOK);         
        }
         
         
}
static void usbdev_delete(struct kref *kref)
{
        struct usb_devinfo *dev = container_of(kref, struct usb_devinfo, kref);
        int i; 


        usb_free_urb(dev->bulk_in_urb);
        usb_put_dev(dev->udev);
        kfree(dev->bulk_in_buffer);
        for(i=0;i<MAX_PAGE;i++)
        {
                kfree(dev->UsbBuffer.PackgeBuf[i]);
        }
        kfree(dev);
        
        
}


static int usbdev_open(struct inode *inode, struct file *file)
{
        struct usb_devinfo *dev;
        struct usb_interface *interface;
        int subminor;
        int retval = 0;
        printk(KERN_ALERT"usbdev_open \n");
        subminor = iminor(inode);


        interface = usb_find_interface(&usbdev_driver, subminor);
        if (!interface) {
                pr_err("%s - error, can't find device for minor %d\n",
                        __func__, subminor);
                retval = -ENODEV;
                goto exit;
        }


        dev = usb_get_intfdata(interface);
        if (!dev) {
                retval = -ENODEV;
                goto exit;
        }


        retval = usb_autopm_get_interface(interface);
        if (retval)
                goto exit;


        /* increment our usage count for the device */
        kref_get(&dev->kref);
         
        
        /* save our object in the file's private structure */
        file->private_data = dev;
        dev->UsbBuffer.iReadIndex=dev->UsbBuffer.iWriteIndex=0;
        devusb_do_read_io(dev,BUF_PER_PAGE);
        dev->isOpen = 1 ;
exit:
        return retval;
}


static int usbdev_release(struct inode *inode, struct file *file)
{
        struct usb_devinfo *dev;
         
        dev = file->private_data;
        if (dev == NULL)
                return -ENODEV;


        /* allow the device to be autosuspended */
        mutex_lock(&dev->io_mutex);
        usbdev_emptyurb(dev);
        if (dev->interface)
                usb_autopm_put_interface(dev->interface);
        mutex_unlock(&dev->io_mutex);
        dev->isOpen = 0 ; 
        wake_up_interruptible(&dev->wqReadOK);         
        /* decrement the count on our device */
        kref_put(&dev->kref, usbdev_delete);
        return 0;
}


static int usbdev_flush(struct file *file, fl_owner_t id)
{
        struct usb_devinfo *dev;
        int res;


        dev = file->private_data;
        if (dev == NULL)
                return -ENODEV;


        /* wait for io to stop */
        mutex_lock(&dev->io_mutex);
        usbdev_emptyurb(dev);


        /* read out errors, leave subsequent opens a clean slate */
        spin_lock_irq(&dev->err_lock);
        res = dev->errors ? (dev->errors == -EPIPE ? -EPIPE : -EIO) : 0;
        dev->errors = 0;
        spin_unlock_irq(&dev->err_lock);


        mutex_unlock(&dev->io_mutex);


        return res;
}


static void usbdev_read_callback(struct urb *urb)
{
        struct usb_devinfo *dev;


        dev = urb->context;
        //printk(KERN_ALERT"usbdev_read_callback\n");
        spin_lock(&dev->err_lock);
        /* sync/async unlink faults aren't errors */
        if (urb->status) {
                if (!(urb->status == -ENOENT ||
                    urb->status == -ECONNRESET ||
                    urb->status == -ESHUTDOWN))
                        dev_err(&dev->interface->dev,
                                "%s - nonzero write bulk status received: %d\n",
                                __func__, urb->status);


                dev->errors = urb->status;
        } else {
                dev->bulk_in_filled = urb->actual_length;
                if(dev->isOpen==1)
                {
                        schedule_work(&(dev->work));
                }
                 
                
        }


        spin_unlock(&dev->err_lock);
        


}


static int devusb_do_read_io(struct usb_devinfo *dev, size_t count)
{
        int rv;
 
        /* prepare a read */
        usb_fill_bulk_urb(dev->bulk_in_urb,
                        dev->udev,
                        usb_rcvbulkpipe(dev->udev,
                                dev->bulk_in_endpointAddr),
                        dev->UsbBuffer.PackgeBuf[dev->UsbBuffer.iWriteIndex],//dev->bulk_in_buffer,//
                        min(dev->bulk_in_size, count),
                        usbdev_read_callback,
                        dev);
 
        /* tell everybody to leave the URB alone */
        //spin_lock_irq(&dev->err_lock);


        //spin_unlock_irq(&dev->err_lock);


        /* submit bulk in urb, which means no data to deliver */
        dev->bulk_in_filled = 0;
        dev->bulk_in_copied = 0;


        /* do it */
        rv = usb_submit_urb(dev->bulk_in_urb, GFP_KERNEL);
        if (rv < 0) {
                //dev_err(&dev->interface->dev,
                //        "%s - failed submitting read urb, error %d\n",
                //        __func__, rv);
                rv = (rv == -ENOMEM) ? rv : -EIO;
                spin_lock_irq(&dev->err_lock);


                spin_unlock_irq(&dev->err_lock);
        }
        //printk(KERN_ALERT"devusb_do_read_io\n");
        return rv;
}


static ssize_t usbdev_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
{
        struct usb_devinfo *dev;
         
         
        int copyed=0;
        dev = file->private_data;
        if(dev->isOpen != 1 )
        {
                //printk(KERN_ALERT"close read err\n");
                return -1;
        }
        if ( !count)
                return 0;
        if(dev->UsbBuffer.iReadIndex==dev->UsbBuffer.iWriteIndex)
        {
                if (file->f_flags & O_NONBLOCK) 
                {
                        return copyed;
                }
                else
                {
                        
                        wait_event_interruptible(dev->wqReadOK, (dev->UsbBuffer.iReadIndex!=dev->UsbBuffer.iWriteIndex)||(dev->isOpen != 1 ) );
                }
        }
        if(dev->isOpen != 1 )
        {
                //printk(KERN_ALERT"close read err1\n");
                return -1;
        } 
        //下一步加锁
        mutex_lock(&dev->read_mutex); 
        while( dev->UsbBuffer.iReadIndex!=dev->UsbBuffer.iWriteIndex )
        {
                int iLen = dev->UsbBuffer.iLen[dev->UsbBuffer.iReadIndex];
                if( count>=iLen )
                {
                         
                         
                        if(copy_to_user(buffer+copyed, &dev->UsbBuffer.PackgeBuf[dev->UsbBuffer.iReadIndex][0],         iLen)!=0)
                        {
                                copyed = -EFAULT;
                                break;
                        }
                        dev->UsbBuffer.iReadIndex++;
                        if(dev->UsbBuffer.iReadIndex>=MAX_PAGE)
                        {
                                dev->UsbBuffer.iReadIndex = 0;
                        }
                        count-=iLen;
                        copyed+=iLen;
                        //printk("read r=%d w=%d\n",dev->UsbBuffer.iReadIndex,dev->UsbBuffer.iWriteIndex );
                        if(iLen<BUF_PER_PAGE)
                        {
                                break; 
                                
                        }
                         
                         
                }
                else
                {
                        break;
                }
                
        }
        mutex_unlock(&dev->read_mutex); 
        return copyed;
}


static void usbdev_write_callback(struct urb *urb)
{
        struct usb_devinfo *dev;


        dev = urb->context;


        /* sync/async unlink faults aren't errors */
        if (urb->status) {
                if (!(urb->status == -ENOENT ||
                    urb->status == -ECONNRESET ||
                    urb->status == -ESHUTDOWN))
                        dev_err(&dev->interface->dev,
                                "%s - nonzero write bulk status received: %d\n",
                                __func__, urb->status);


                spin_lock(&dev->err_lock);
                dev->errors = urb->status;
                spin_unlock(&dev->err_lock);
        }


        /* free up our allocated buffer */
        usb_free_coherent(urb->dev, urb->transfer_buffer_length,
                          urb->transfer_buffer, urb->transfer_dma);
        up(&dev->limit_sem);
}


static ssize_t usbdev_write(struct file *file, const char *user_buffer,
                          size_t count, loff_t *ppos)
{
        struct usb_devinfo *dev;
        int retval = 0;
        struct urb *urb = NULL;
        char *buf = NULL;
        size_t writesize = min(count, (size_t)MAX_TRANSFER);


        dev = file->private_data;
        if(dev->isOpen != 1 )
        {
                return -1;
        }
        /* verify that we actually have some data to write */
        if (count == 0)
                goto exit;


        /*
         * limit the number of URBs in flight to stop a user from using up all
         * RAM
         */
        if (!(file->f_flags & O_NONBLOCK)) {
                int ret = down_timeout(&dev->limit_sem,10);
                if (ret!=0) {
                        retval = -ERESTARTSYS;
                        goto exit;
                }
        } else {
                if (down_trylock(&dev->limit_sem)) {
                        retval = -EAGAIN;
                        goto exit;
                }
        }


        spin_lock_irq(&dev->err_lock);
        retval = dev->errors;
        if (retval < 0) {
                /* any error is reported once */
                dev->errors = 0;
                /* to preserve notifications about reset */
                retval = (retval == -EPIPE) ? retval : -EIO;
        }
        spin_unlock_irq(&dev->err_lock);
        if (retval < 0)
                goto error;


        /* create a urb, and a buffer for it, and copy the data to the urb */
        urb = usb_alloc_urb(0, GFP_KERNEL);
        if (!urb) {
                retval = -ENOMEM;
                goto error;
        }


        buf = usb_alloc_coherent(dev->udev, writesize, GFP_KERNEL,
                                 &urb->transfer_dma);
        if (!buf) {
                retval = -ENOMEM;
                goto error;
        }


        if (copy_from_user(buf, user_buffer, writesize)) {
                retval = -EFAULT;
                goto error;
        }


        /* this lock makes sure we don't submit URBs to gone devices */
        mutex_lock(&dev->io_mutex);
        if (!dev->interface) {                /* disconnect() was called */
                mutex_unlock(&dev->io_mutex);
                retval = -ENODEV;
                goto error;
        }


        /* initialize the urb properly */
        usb_fill_bulk_urb(urb, dev->udev,
                          usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),
                          buf, writesize, usbdev_write_callback, dev);
        urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
        usb_anchor_urb(urb, &dev->submitted);


        /* send the data out the bulk port */
        retval = usb_submit_urb(urb, GFP_KERNEL); 
        mutex_unlock(&dev->io_mutex);
        if (retval) {
                dev_err(&dev->interface->dev,
                        "%s - failed submitting write urb, error %d\n",
                        __func__, retval);
                goto error_unanchor;
        }


        /*
         * release our reference to this urb, the USB core will eventually free
         * it entirely
         */
        usb_free_urb(urb);
         


        return writesize;


error_unanchor:
        usb_unanchor_urb(urb);
error:
        if (urb) {
                usb_free_coherent(dev->udev, writesize, buf, urb->transfer_dma);
                usb_free_urb(urb);
        }
        up(&dev->limit_sem);


exit:
        return retval;
}


static const struct file_operations usbdev_fops = {
        .owner =        THIS_MODULE,
        .read =                usbdev_read,
        .write =        usbdev_write,
        .open =                usbdev_open,
        .release =        usbdev_release,
        .flush =        usbdev_flush,
        .llseek =        noop_llseek,
};


/*
 * usb class driver info in order to get a minor number from the usb core,
 * and to have the device registered with the driver core
 */
static struct usb_class_driver usbdev_class = {
        .name =                "USBDev%d",
        .fops =                &usbdev_fops,
        .minor_base =        USB_DEV_MINOR_BASE,
};
static struct usb_class_driver usbdevother_class = {
        .name =                "USBOther%d",
        .fops =                &usbdev_fops,
        .minor_base =        USB_DEV_MINOR_BASE,
};
static int usbdev_probe(struct usb_interface *interface,
                      const struct usb_device_id *id)
{
        struct usb_devinfo *dev;
        struct usb_host_interface *iface_desc;
        struct usb_endpoint_descriptor *endpoint;
        size_t buffer_size;
        int i;
        int retval = -ENOMEM;
        int iInterfaceType=0;
        if(interface->cur_altsetting->desc.bInterfaceClass==0xff)
        {
                if(interface->cur_altsetting->desc.bInterfaceSubClass==0xff)
                {
                        iInterfaceType=1;
                }
                else
                {
                        iInterfaceType=2;
                }
        }
        if(iInterfaceType==0)
        {
                return ;
        } 
         
        /* allocate memory for our device state and initialize it */
        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
        if (!dev) {
                dev_err(&interface->dev, "Out of memory\n");
                goto error;
        }
        kref_init(&dev->kref);
        sema_init(&dev->limit_sem, WRITES_IN_FLIGHT);
        mutex_init(&dev->io_mutex);
        spin_lock_init(&dev->err_lock);
        init_usb_anchor(&dev->submitted);




        dev->udev = usb_get_dev(interface_to_usbdev(interface));
        dev->interface = interface;


        /* set up the endpoint information */
        /* use only the first bulk-in and bulk-out endpoints */
        iface_desc = interface->cur_altsetting;
        for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
                endpoint = &iface_desc->endpoint[i].desc;


                if (!dev->bulk_in_endpointAddr &&
                    usb_endpoint_is_bulk_in(endpoint)) {
                        /* we found a bulk in endpoint */
                        buffer_size = usb_endpoint_maxp(endpoint);
                        dev->bulk_in_size = BUF_PER_PAGE;//buffer_size*100;
                        dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;
                        dev->bulk_in_buffer = kmalloc(dev->bulk_in_size, GFP_KERNEL);
                        if (!dev->bulk_in_buffer) {
                                dev_err(&interface->dev,
                                        "Could not allocate bulk_in_buffer\n");
                                goto error;
                        }
                        dev->bulk_in_urb = usb_alloc_urb(0, GFP_KERNEL);
                        if (!dev->bulk_in_urb) {
                                dev_err(&interface->dev,
                                        "Could not allocate bulk_in_urb\n");
                                goto error;
                        }
                }


                if (!dev->bulk_out_endpointAddr &&
                    usb_endpoint_is_bulk_out(endpoint)) {
                        /* we found a bulk out endpoint */
                        dev->bulk_out_endpointAddr = endpoint->bEndpointAddress;
                }
        }
        if (!(dev->bulk_in_endpointAddr && dev->bulk_out_endpointAddr)) {
                dev_err(&interface->dev,
                        "Could not find both bulk-in and bulk-out endpoints\n");
                goto error;
        }


        /* save our data pointer in this interface device */
        usb_set_intfdata(interface, dev);


        /* we can register the device now, as it is ready */
        if(iInterfaceType==1)
        {
                retval = usb_register_dev(interface, &usbdev_class);
        }
        else
        {
                retval = usb_register_dev(interface, &usbdevother_class);
        }
        if (retval) {
                /* something prevented us from registering this driver */
                dev_err(&interface->dev,
                        "Not able to get a minor for this device.\n");
                usb_set_intfdata(interface, NULL);
                goto error;
        }


        memset(&dev->UsbBuffer,0,sizeof(cachebuf));
         init_waitqueue_head(&dev->wqReadOK);
         INIT_WORK(&(dev->work), work_func);
         mutex_init(&dev->read_mutex);
         dev->isOpen = 0 ;
         for(i=0;i< MAX_PAGE;i++)
         {
                 dev->UsbBuffer.PackgeBuf[i] = kmalloc(dev->bulk_in_size, GFP_KERNEL);
         }
        /* let the user know what node this device is now attached to */
        dev_info(&interface->dev,
                 "USB Skeleton device now attached to USBSkel-%d",
                 interface->minor);
         
        return 0;


error:
        if (dev)
                /* this frees allocated memory */
                kref_put(&dev->kref, usbdev_delete);
        return retval;
}


static void usbdev_disconnect(struct usb_interface *interface)
{
        struct usb_devinfo *dev;
        int minor = interface->minor;
        int iInterfaceType=0;
         
        if(interface->cur_altsetting->desc.bInterfaceClass==0xff)
        {
                if(interface->cur_altsetting->desc.bInterfaceSubClass==0xff)
                {
                        iInterfaceType=1;
                }
                else
                {
                        iInterfaceType=2;
                }
        }
        if(iInterfaceType==0)
        {
                return ;
        }
        
        dev = usb_get_intfdata(interface);
        dev->isOpen = 0 ;
         wake_up_interruptible(&dev->wqReadOK);         
        usb_set_intfdata(interface, NULL);


        /* give back our minor */
        if(iInterfaceType==1)
        {
                usb_deregister_dev(interface, &usbdev_class);
        }
        else
        {
                usb_deregister_dev(interface, &usbdevother_class);
        }


        /* prevent more I/O from starting */
        mutex_lock(&dev->io_mutex);
        dev->interface = NULL;
        mutex_unlock(&dev->io_mutex);


        usb_kill_anchored_urbs(&dev->submitted);


        /* decrement our usage count */
        kref_put(&dev->kref, usbdev_delete);
         
        dev_info(&interface->dev, "USB  #%d now disconnected", minor);
}


static void usbdev_emptyurb(struct usb_devinfo *dev)
{
        int time;


        time = usb_wait_anchor_empty_timeout(&dev->submitted, 1000);
        if (!time)
                usb_kill_anchored_urbs(&dev->submitted);
        usb_kill_urb(dev->bulk_in_urb);
}


static int usbdev_suspend(struct usb_interface *intf, pm_message_t message)
{
        struct usb_devinfo *dev = usb_get_intfdata(intf);


        if (!dev)
                return 0;
        usbdev_emptyurb(dev);
        return 0;
}


static int usbdev_resume(struct usb_interface *intf)
{
        return 0;
}


static int usbdev_pre_reset(struct usb_interface *intf)
{
        struct usb_devinfo *dev = usb_get_intfdata(intf);


        mutex_lock(&dev->io_mutex);
        usbdev_emptyurb(dev);


        return 0;
}


static int usbdev_post_reset(struct usb_interface *intf)
{
        struct usb_devinfo *dev = usb_get_intfdata(intf);


        /* we are sure no URBs are active - no locking needed */
        dev->errors = -EPIPE;
        mutex_unlock(&dev->io_mutex);


        return 0;
}


static struct usb_driver usbdev_driver = {
        .name =                "usbtest",
        .probe =        usbdev_probe,
        .disconnect =        usbdev_disconnect,
        .suspend =        usbdev_suspend,
        .resume =        usbdev_resume,
        .pre_reset =        usbdev_pre_reset,
        .post_reset =        usbdev_post_reset,
        .id_table =        usbdev_table,
        .supports_autosuspend = 1,
};


 
static int __init usbdev_init(void)
{
         
                return usb_register(&usbdev_driver);
        
}
module_init(usbdev_init);
static void __exit usbdev_exit(void)
{
        usb_deregister(&usbdev_driver);
}
module_exit(usbdev_exit);
MODULE_LICENSE("GPL");