好贷网好贷款

Linux设备驱动之usb设备驱动详解

发布时间:2016-12-3 2:08:14 编辑:www.fx114.net 分享查询网我要评论
本篇文章主要介绍了"Linux设备驱动之usb设备驱动详解",主要涉及到Linux设备驱动之usb设备驱动详解方面的内容,对于Linux设备驱动之usb设备驱动详解感兴趣的同学可以参考一下。

http://blog.csdn.net/chenjin_zhong/article/details/6329316 1.Linux usb设备驱动框架 USB是通用串行总线的总称,Linux内核几乎支持所有的usb设备,包括键盘,鼠标,打印机,modem,扫描仪。Linux的usb驱动分为主机驱动与gadget驱动。前者是设备连接到计算机上,通过主机驱动扫描usb设备,控制所连接的设备。而gadget驱动一般用于嵌入式设备,gadget驱动用于控制嵌入式设备。Linux的usb驱动两种类型图如下: 左侧是usb的主机驱动,右侧是gadget驱动。下面着重介绍一下usb的主机驱动: (1)usb主机控制器-直接与硬件设备交互。 (2)usb core-向usb设备驱动提供API以及usb主机控制器驱动的程序。使用usb core所提供的函数,宏来完成数据处理的功能。 (3)usb设备驱动,即usb接口驱动,一般所说的usb驱动指的是usb接口驱动   2.usb系统的组成部分 usb系统一般由三个部分组成,主机,一个或多个usb hub,以及与之些hub连接的usb设备。 (1)主机 在任何的usb系统中仅有一个主机,主机系统中的usb接口即上图中的主机控制器,主机控制器可由硬件,软件或固件组成。主机主要负责: a.检测usb设备的连接与拆除 b.管理主机与usb设备之间的控制流 c.管理主机与usb设备之间的数据流 d.收集状态和活动的统计 e.为连接的usb设备提供电源     (2)usb设备 所有的usb设备都是通过地址来存取的,这个地址在连接或枚举时分配。usb设备对usb系统来说是端点的集合,一组端点实现一个接口。设备端点是usb设备中唯一可寻址的部分。它是主机与设备之间通信流的结束点。一系列的相互独立的端点构成了usb逻辑设备。每个端点支持流进设备或者是流出设备。 主机与设备端点上的usb数据传输是通过管道的方式。   (3)hub 所有的usb device都连接在hub端口上。       3. usb传输模式   (1)控制传输模式(Control) 控制传输模式支持双向传输,用来处理从usb主机端口到usb设备端口的数据传输,用于控制指令,设备状态查询以及确认命令。   (2)等时传输方式(lsochronous ) 等时传输是一种周期性的连续性的意向传输模式,通常用于对时间有着密切关系的信息的传输,对准确性要求不高,但对时间要求极为敏感的设备,如视频,音频的传输。   (3)中断传输模式(Interrupt) 中断传输模式用于非周期性的,自然发生的,数据量小的传输,数据传输的方向是从设备到主机。如usb键盘和鼠标   (4)批量传输模式(bulk) 批量传输模式是一种单向的,用于大量数据传输的模式,该方式用来传输正确无误的数据。通常打印机,扫描仪,数码相机以这种方式与主机连接     4. usb设备组成 (1)一个usb设备由可以有一个或多个配置 (2)一个配置通常可以有一个或多个接口 (3)一个接口通常可以有一个或多个端点 通常所尽的usb设备驱动是指接口驱动,即一个接口对应一个驱动。 所以Linux usb设备有四大描述符,分别为设备描述符,配置描述符,接口描述符,端点描述符。下面看一个这几个描述符的相关数据结构:     struct usb_device_descriptor {       _u8 bLength;  //此描述符的字节数       _u8  bDescriptorType; //描述符的种类为设备       _u16 bcdUSB;  //此设备与描述符兼容的usb设备说明版本号(BCD码)       _u8   bDeviceClass; //设备类码       _u8   bDeviceSubClass; //设备子类码       _u8   bDeviceProtocol; //协议码       _u8   bMaxPacketSize0; //端点0的最大包大小       _u16 idVendor; //厂商标志       _u16  idProduct; //产品标志       _u16 bcdDevice; //设备发行号       _u8   iManufacturer; //描述厂商的字串索引       _u8   iProduct; //描述产品信息的字串索引       _u8  iSerialNumber; //描述设备序列号信息的字串索引       _u8  bNumConfigurations;//此设备支持的配置数   }_attribute_ ((packed));   设备类码的典型值如下:   #define USB_CLASS_PER_INTERFACE 0 #define USB_CLAS_AUDIO 1     //声音设备 #define USB_CLASS_COMM 2   // 调制解调器,网卡,ISDN连接 #define USB_CLASS_HID  3    //HID设备,如鼠标,键盘 #define USB_CLASS_PHYSICAL 5 //物理设备 #define USB_CLASS_STILL_IMAGE 6 //静止图像捕捉设备 #define USB_CLASS_PRINTER 7//打印机 #define USB_CLASS_MASS_STORAGE //8 批量存储设备 #define USB_CLASS_HUB 9   //USB HUBS #define USB_CLASS_CSCID 0x0B  //智能卡 #define USB_CLASS_VIDEO 0X0E //视频设备,如网络摄像头 #define USB_CLASS_VENDOR_SPEC 0xFF //厂商自定义的设备     struct usb_config_descriptor{    _u8 bLength ;//此描述符的字节数 _u8 bDescriptorType; //配置描述符类型 _u16 wTotalLength; //此配置信息的总长(包括配置,接口,端点和设备类型及厂商定义的描述符) _u8 bNumInterfaces; //此配置所支持的接口数 _u8 bConfigurationValue ;//在setConfiguration()请求中用作参数来选定此配置 _u8 iConfiguration; //描述此配置的字串描述符索引 _u8 bmAttributes; //电源配置特性 _u8 bMaxpowe;r //此配置下的总线电源耗电量 }_attribute_ ((packed));     配置描述符给出了usb设备配置信息,以及此配置下的接口数。每个接口可能的独立操作。       struct usb_interface_descriptor{   _u8 bLength ;//此描述符的字节数 _u8 bDescriptorType;//接口描述符类 _u8 bInterfacNumber;//接口号,当前配置所支持的接口数组索引,从0开始 _u8 bNumEndpoints ;//此接口用的端点数量,如果是0,说明此接口只有缺省控制通道 _u8 bAlernateSetting;//可选设备的索引值 _u8 bInterfaceClass;// 类值,0值作为将来保留使用如果是0FFH,此接口由厂商说明 _u8 bInterfaceSubClass;//子类码 _u8 bInterfaceProtocol;//协议码 _u8 iInterface;//描述此接口的字串描述符索引   }_attribute_ ((packed));   struct usb_endpoint_descriptor{ _u8 bLength ;//此描述符的字节数 _u8 bDescriptorType;//端点描述符类 _u8 bEndpointAddress;此描述符所描述的端点的地址 _u8 bmAtrributes;//所指定的端点的特性,如果是00=控制传送,01=等时传送,10=批传送,11=中断传送 _u8 wMaxPacketSize;//当前配置下端点能够发送与接收的最大数据包大小 _u8 bInterval;//轮询数据传送端点的时间间隙 _u8 bRefresh _u8 bSynchAddress }_attribute_ ((packed));   以上给出了usb中的设备描述符,配置描述符,接口描述符和端点描述符。     5. usb设备驱动的几个重要的数据结构   usb_driver,usb_device,usb_bus.     /**  788 * stru ct usb_driver - identifies U SB interface driver to u sbcore  789 * @name: The driver name shou ld be u niqu e among U SB drivers,  790 *      and shou ld normally be the same as the modu le name.  791 * @probe: Called to see if the driver is willing to manage a particu lar  792 *      interface on a device.  If it is, probe retu rns zero and u ses  793 *      u sb_set_intfdata() to associate driver-specific data with the  794 *      interface.  It may also u se u sb_set_interface() to specify the  795 *      appropriate altsetting.  If u nwilling to manage the interface,  796 *      retu rn -ENODEV, if genu ine IO errors occu red, an appropriate  797 *      negative errno valu e.  798 * @disconnect: Called when the interface is no longer accessible, u su ally  799 *      becau se its device has been (or is being) disconnected or the  800 *      driver modu le is being u nloaded.  801 * @u nlocked_ioctl: U sed for drivers that want to talk to u serspace throu gh  802 *      the "u sbfs" filesystem.  This lets devices provide ways to  803 *      expose information to u ser space regardless of where they  804 *      do (or don't) show u p otherwise in the filesystem.  805 * @su spend: Called when the device is going to be su spended by the system.  806 * @resu me: Called when the device is being resu med by the system.  807 * @reset_resu me: Called when the su spended device has been reset instead  808 *      of being resu med.  809 * @pre_reset: Called by u sb_reset_device() when the device  810 *      is abou t to be reset.  811 * @post_reset: Called by u sb_reset_device() after the device  812 *      has been reset  813 * @id_table: U SB drivers u se ID table to su pport hotplu gging.  814 *      Export this with MODU LE_DEVICE_TABLE(u sb,...).  This mu st be set  815 *      or you r driver's probe fu nction will never get called.  816 * @dynids: u sed internally to hold the list of dynamically added device  817 *      ids for this driver.  818 * @drvwrap: Driver-model core stru ctu re wrapper.  819 * @no_dynamic_id: if set to 1, the U SB core will not allow dynamic ids to be  820 *      added to this driver by preventing the sysfs file from being created.  821 * @su pports_au tosu spend: if set to 0, the U SB core will not allow au tosu spend  822 *      for interfaces bou nd to this driver.  823 * @soft_u nbind: if set to 1, the U SB core will not kill U RBs and disable  824 *      endpoints before calling the driver's disconnect method.  825 *  826 * U SB interface drivers mu st provide a name, probe() and disconnect()  827 * methods, and an id_table.  Other driver fields are optional.  828 *  829 * The id_table is u sed in hotplu gging.  It holds a set of descriptors,  830 * and specialized data may be associated with each entry.  That table  831 * is u sed by both u ser and kernel mode hotplu gging su pport.  832 *  833 * The probe() and disconnect() methods are called in a context where  834 * they can sleep, bu t they shou ld avoid abu sing the privilege.  Most  835 * work to connect to a device shou ld be done when the device is opened,  836 * and u ndone at the last close.  The disconnect code needs to address  837 * concu rrency issu es with respect to open() and close() methods, as  838 * well as forcing all pending I/O requ ests to complete (by u nlinking  839 * them as necessary, and blocking u ntil the u nlinks complete).  840 */  841 stru ct usb_driver { 842          const char *name ; 843  844          int (*probe ) (stru ct u sb_interface *intf , 845                        const stru ct u sb_device_id *id ); 846  847          void (*disconnect ) (stru ct u sb_interface *intf ); 848  849          int (*u nlocked_ioctl) (stru ct u sb_interface *intf , u nsigned int code , 850                          void *bu f ); 851  852          int (*su spend ) (stru ct u sb_interface *intf , pm_message_t message ); 853          int (*resu me ) (stru ct u sb_interface *intf ); 854          int (*reset_resu me)(stru ct u sb_interface *intf ); 855  856          int (*pre_reset )(stru ct u sb_interface *intf ); 857          int (*post_reset)(stru ct u sb_interface *intf ); 858  859          const stru ct u sb_device_id *id_table ; 860  861          stru ct u sb_dynids dynids; 862          stru ct u sbdrv_wrap drvwrap; 863          u nsigned int no_dynamic_id:1; 864          u nsigned int su pports_au tosu spend:1; 865          u nsigned int soft_u nbind:1; 866 };   usb_driver中的probe函数扫描连接到主机上的usb设备,并且注册usb接口驱动。   disconnect函数是当usb设备移除时调用。     /*  310 * Allocated per bu s (tree of devices) we have:  311 */  312 stru ct u sb_bu s { 313          stru ct device *controller ;      /* host/master side hardware */  314          int bu snu m;                     /* Bu s nu mber (in order of reg) */  315          const char *bu s_name;           /* stable id (PCI slot_name etc) */  316          u 8 u ses_dma;                    /* Does the host controller u se DMA? */  317          u 8 u ses_pio_for_control;        /*  318                                          * Does the host controller u se PIO  319                                          * for control transfers?  320                                          */  321          u 8 otg_port;                    /* 0, or nu mber of OTG/HNP port */  322          u nsigned is_b_host:1;           /* tru e du ring some HNP roleswitches */  323          u nsigned b_hnp_enable:1;        /* OTG: did A-Host enable HNP? */  324          u nsigned sg_tablesize ;          /* 0 or largest nu mber of sg list entries */  325  326          int devnu m_next;                /* Next open device nu mber in  327                                          * rou nd-robin allocation */  328  329          stru ct u sb_devmap  devmap;       /* device address allocation map */  330          stru ct usb_device * root_hu b;    /* Root hu b */  331          stru ct u sb_bu s *hs_companion;   /* Companion EHCI bu s, if any */  332          stru ct list_head bu s_list;      /* list of bu sses */  333  334          int bandwidth_allocated;        /* on this bu s: how mu ch of the time  335                                          * reserved for periodic (intr/iso)  336                                          * requ ests is u sed, on average?  337                                          * U nits: microseconds/frame.  338                                          * Limits: Fu ll/low speed reserve 90%,  339                                          * while high speed reserves 80%.  340                                          */  341          int bandwidth_int_reqs;         /* nu mber of Interru pt requ ests */  342          int bandwidth_isoc_reqs;        /* nu mber of Isoc. requ ests */  343  344 #ifdef CONFIG_USB_DEVICE FS 345          stru ct dentry *u sbfs_dentry;    /* u sbfs dentry entry for the bu s */  346 #endif 347  348 #if defined (CONFIG_U SB_MON) || defined (CONFIG_U SB_MON_MODU LE) 349          stru ct mon_bu s *mon_bu s ;        /* non-nu ll when associated */  350          int monitored;                  /* non-zero when monitored */  351 #endif 352 }; 353     **  370 * stru ct usb_device - kernel's representation of a U SB device  371 * @devnu m: device nu mber; address on a U SB bu s  372 * @devpath: device ID string for u se in messages (e.g., /port/...)  373 * @rou te: tree topology hex string for u se with xHCI  374 * @state: device state: configu red, not attached, etc.  375 * @speed: device speed: high/fu ll/low (or error)  376 * @tt: Transaction Translator info; u sed with low/fu ll speed dev, highspeed hu b  377 * @ttport: device port on that tt hu b  378 * @toggle: one bit for each endpoint, with ([0] = IN, [1] = OU T) endpoints  379 * @parent: ou r hu b, u nless we're the root  380 * @bu s: bu s we're part of  381 * @ep0: endpoint 0 data (defau lt control pipe)  382 * @dev: generic device interface  383 * @descriptor: U SB device descriptor  384 * @config: all of the device's configs  385 * @actconfig: the active configu ration  386 * @ep_in: array of IN endpoints  387 * @ep_ou t: array of OU T endpoints  388 * @rawdescriptors: raw descriptors for each config  389 * @bu s_mA: Cu rrent available from the bu s  390 * @portnu m: parent port nu mber (origin 1)  391 * @level: nu mber of U SB hu b ancestors  392 * @can_su bmit: U RBs may be su bmitted  393 * @persist_enabled:  U SB_PERSIST enabled for this device  394 * @have_langid: whether string_langid is valid  395 * @au thorized: policy has said we can u se it;  396 *      (u ser space) policy determines if we au thorize this device to be  397 *      u sed or not. By defau lt, wired U SB devices are au thorized.  398 *      WU SB devices are not, u ntil we au thorize them from u ser space.  399 *      FIXME -- complete doc  400 * @au thenticated: Crypto au thentication passed  401 * @wu sb: device is Wireless U SB  402 * @string_langid: langu age ID for strings  403 * @produ ct: iProdu ct string, if present (static)  404 * @manu factu rer: iManu factu rer string, if present (static)  405 * @serial: iSerialNu mber string, if present (static)  406 * @filelist: u sbfs files that are open to this device  407 * @u sb_classdev: U SB class device that was created for u sbfs device  408 *      access from u serspace  409 * @u sbfs_dentry: u sbfs dentry entry for the device  410 * @maxchild: nu mber of ports if hu b  411 * @children: child devices - U SB devices that are attached to this hu b  412 * @qu irks: qu irks of the whole device  413 * @u rbnu m: nu mber of U RBs su bmitted for the whole device  414 * @active_du ration: total time device is not su spended  415 * @connect_time: time device was first connected  416 * @do_remote_wakeu p:  remote wakeu p shou ld be enabled  417 * @reset_resu me: needs reset instead of resu me  418 * @wu sb_dev: if this is a Wireless U SB device, link to the WU SB  419 *      specific data for the device.  420 * @slot_id: Slot ID assigned by xHCI  421 *  422 * Notes:  423 * U sbcore drivers shou ld not set u sbdev->state directly.  Instead u se  424 * u sb_set_device_state().  425 */  426 stru ct usb_device { 427          int             devnu m; 428          char            devpath[16]; 429          u 32              rou te; 430          enu m usb_device _state    state ; 431          enu m usb_device _speed    speed ; 432  433          stru ct u sb_tt    *tt; 434          int             ttport; 435  436          u nsigned int toggle [2]; 437  438          stru ct usb_device *parent ; 439          stru ct u sb_bu s *bu s ; 440          stru ct u sb_host_endpoint ep0; 441  442          stru ct device dev ; 443  444          stru ct usb_device _descriptor descriptor ; 445          stru ct u sb_host_config *config ; 446  447          stru ct u sb_host_config *actconfig; 448          stru ct u sb_host_endpoint *ep_in[16]; 449          stru ct u sb_host_endpoint *ep_ou t[16]; 450  451          char **rawdescriptors; 452  453          u nsigned short bu s_mA; 454          u 8 portnu m; 455          u 8 level; 456  457          u nsigned can_su bmit:1; 458          u nsigned persist_enabled:1; 459          u nsigned have_langid:1; 460          u nsigned au thorized:1; 461          u nsigned au thenticated:1; 462          u nsigned wu sb:1; 463          int string_langid; 464  465          /* static strings from the device */  466          char *produ ct ; 467          char *manu factu rer ; 468          char *serial ; 469  470          stru ct list_head filelist; 471 #ifdef CONFIG_USB_DEVICE _CLASS 472          stru ct device *u sb_classdev; 473 #endif 474 #ifdef CONFIG_USB_DEVICE FS 475          stru ct dentry *u sbfs_dentry; 476 #endif 477  478          int maxchild; 479          stru ct usb_device *children[U SB_MAXCHILDREN ]; 480  481          u 32 qu irks ; 482          atomic_t u rbnu m; 483  484          u nsigned long active_du ration; 485  486 #ifdef CONFIG_PM  487          u nsigned long connect_time; 488  489          u nsigned do_remote_wakeu p:1; 490          u nsigned reset_resu me:1; 491 #endif 492          stru ct wu sb_dev *wu sb_dev ; 493          int slot_id; 494 }; 495 #define to_usb_device (d ) container_of (d , stru ct usb_device , dev ) 496  497 static inline stru ct usb_device *interface_to_u sbdev (stru ct u sb_interface *intf ) 498 { 499          retu rn to_usb_device (intf ->dev .parent ); 500 } 501   以上三个结构体分别是usb_driver,usb_bus,usb_device设备结构体。       usb_interface结构体:   struct usb_interface { 160          /* array of alternate settings for this interface,  161          * stored in no particular order */  162          struct usb_host_interface *altsetting ; 163  164          struct usb_host_interface *cur_altsetting;      /* the currently  165                                          * active alternate setting */  166          unsigned num_altsetting;        /* number of alternate settings */  167  168          /* If there is an interface association descriptor then it will list  169          * the associated interfaces */  170          struct usb_interface_assoc_descriptor *intf_assoc; 171  172          int minor ;                      /* minor number this interface is  173                                          * bound to */  174          enum usb_interface_condition condition;         /* state of binding */  175          unsigned sysfs_files_created:1; /* the sysfs attributes exist */  176          unsigned ep_devs_created:1;     /* endpoint "devices" exist */  177          unsigned unregistering:1;       /* unregistration is in progress */  178          unsigned needs_remote_wakeup:1; /* driver requires remote wakeup */  179          unsigned needs_altsetting0:1;   /* switch to altsetting 0 is pending */  180          unsigned needs_binding:1;       /* needs delayed unbind/rebind */  181          unsigned reset_running:1; 182          unsigned resetting_device:1;    /* true: bandwidth alloc after reset */  183  184          struct device dev ;              /* interface specific device info */  185          struct device *usb_dev ; 186          atomic_t pm_usage_cnt;          /* usage counter for autosuspend */  187          struct work_struct reset_ws;    /* for resets in atomic context */  188 };  struct usb_host_interface *altsetting包含了usb interface的所有可选设置。  struct usb_host _interface *cur_altsetting是usb interface的当前可选设置。   下面看一个struct usb_host_interface     /* host-side wrapper for one interface setting's parsed descriptors */  77 stru ct usb_host_interface { 78          stru ct u sb_interface_descriptor desc ; 79  80          /* array of desc.bNu mEndpoint endpoints associated with this  81          * interface setting.  these will be in no particu lar order.  82          */  83          stru ct u sb_host_endpoint *endpoint ; 84  85          char *string ;           /* iInterface string, if present */  86          u nsigned char *extra;   /* Extra descriptors */  87          int extralen; 88 };   其中struct usb_interface_descriptor即是usb接口描述符。 struct usb_host_endpoint代表的是设备端点。 可以在desc中改变接口包含的端点数。   接下来看一下usb_host_endpoint这个结构体:   /**  50 * stru ct usb_host_endpoint - host-side endpoint descriptor and qu eu e  51 * @desc: descriptor for this endpoint, wMaxPacketSize in native byteorder  52 * @ss_ep_comp: Su perSpeed companion descriptor for this endpoint  53 * @u rb_list: u rbs qu eu ed to this endpoint; maintained by u sbcore  54 * @hcpriv: for u se by HCD; typically holds hardware dma qu eu e head (QH)  55 *      with one or more transfer descriptors (TDs) per u rb  56 * @ep_dev: ep_device for sysfs info  57 * @extra: descriptors following this endpoint in the configu ration  58 * @extralen: how many bytes of "extra" are valid  59 * @enabled: U RBs may be su bmitted to this endpoint  60 *  61 * U SB requ ests are always qu eu ed to a given endpoint, identified by a  62 * descriptor within an active interface in a given U SB configu ration.  63 */  64 stru ct usb_host_endpoint { 65          stru ct u sb_endpoint_descriptor           desc ; 66          stru ct u sb_ss_ep_comp_descriptor        ss_ep_comp; 67          stru ct list_head               u rb_list ; 68          void                            *hcpriv; 69          stru ct ep_device              *ep_dev;        /* For sysfs info */  70  71          u nsigned char *extra;   /* Extra descriptors */  72          int extralen; 73          int enabled ; 74 };     其中struct usb_endpoint_descriptor是端点描述符。     urb(usb reqeust block): urb主要用于Linux host与设备进行数据传输.   urb的生命周期: (1)由usb设备驱动创建 (2)分配到usb设备的指定端点 (3)由Usb设备驱动提交到usb core (4)由Usb core提交到usb 主机控制器 (5)由Usb主机控制器控制设备进行数据传输 (6)当urb完成的时候,usb主机控制器驱动通知usb 设备驱动         /**  1006 * stru ct urb - U SB Requ est Block  1007 * @urb _list: For u se by cu rrent owner of the URB .  1008 * @anchor_list: membership in the list of an anchor  1009 * @anchor: to anchor URB s to a common mooring  1010 * @ep: Points to the endpoint's data stru ctu re.  Will eventu ally  1011 *      replace @pipe.  1012 * @pipe: Holds endpoint nu mber, direction, type, and more.  1013 *      Create these valu es with the eight macros available;  1014 *      u sb_{snd,rcv}TYPEpipe(dev,endpoint), where the TYPE is "ctrl"  1015 *      (control), "bu lk", "int" (interru pt), or "iso" (isochronou s).  1016 *      For example u sb_sndbu lkpipe() or u sb_rcvintpipe().  Endpoint  1017 *      nu mbers range from zero to fifteen.  Note that "in" endpoint two  1018 *      is a different endpoint (and pipe) from "ou t" endpoint two.  1019 *      The cu rrent configu ration controls the existence, type, and  1020 *      maximu m packet size of any given endpoint.  1021 * @stream_id: the endpoint's stream ID for bu lk streams  1022 * @dev: Identifies the U SB device to perform the requ est.  1023 * @statu s: This is read in non-iso completion fu nctions to get the  1024 *      statu s of the particu lar requ est.  ISO requ ests only u se it  1025 *      to tell whether the URB was u nlinked; detailed statu s for  1026 *      each frame is in the fields of the iso_frame-desc.  1027 * @transfer_flags: A variety of flags may be u sed to affect how URB  1028 *      su bmission, u nlinking, or operation are handled.  Different  1029 *      kinds of URB can u se different flags.  1030 * @transfer_bu ffer:  This identifies the bu ffer to (or from) which the I/O  1031 *      requ est will be performed u nless URB _NO_TRANSFER_DMA_MAP is set  1032 *      (however, do not leave garbage in transfer_bu ffer even then).  1033 *      This bu ffer mu st be su itable for DMA; allocate it with  1034 *      kmalloc() or equ ivalent.  For transfers to "in" endpoints, contents  1035 *      of this bu ffer will be modified.  This bu ffer is u sed for the data  1036 *      stage of control transfers.  1037 * @transfer_dma: When transfer_flags inclu des URB _NO_TRANSFER_DMA_MAP,  1038 *      the device driver is saying that it provided this DMA address,  1039 *      which the host controller driver shou ld u se in preference to the  1040 *      transfer_bu ffer.  1041 * @sg: scatter gather bu ffer list  1042 * @nu m_sgs: nu mber of entries in the sg list  1043 * @transfer_bu ffer_length: How big is transfer_bu ffer.  The transfer may  1044 *      be broken u p into chu nks according to the cu rrent maximu m packet  1045 *      size for the endpoint, which is a fu nction of the configu ration  1046 *      and is encoded in the pipe.  When the length is zero, neither  1047 *      transfer_bu ffer nor transfer_dma is u sed.  1048 * @actu al_length: This is read in non-iso completion fu nctions, and  1049 *      it tells how many bytes (ou t of transfer_bu ffer_length) were  1050 *      transferred.  It will normally be the same as requ ested, u nless  1051 *      either an error was reported or a short read was performed.  1052 *      The URB _SHORT_NOT_OK transfer flag may be u sed to make su ch  1053 *      short reads be reported as errors.  1054 * @setu p_packet: Only u sed for control transfers, this points to eight bytes  1055 *      of setu p data.  Control transfers always start by sending this data  1056 *      to the device.  Then transfer_bu ffer is read or written, if needed.  1057 * @setu p_dma: DMA pointer for the setu p packet.  The caller mu st not u se  1058 *      this field; setu p_packet mu st point to a valid bu ffer.  1059 * @start_frame: Retu rns the initial frame for isochronou s transfers.  1060 * @nu mber_of_packets: Lists the nu mber of ISO transfer bu ffers.  1061 * @interval: Specifies the polling interval for interru pt or isochronou s  1062 *      transfers.  The u nits are frames (milliseconds) for fu ll and low  1063 *      speed devices, and microframes (1/8 millisecond) for highspeed  1064 *      and Su perSpeed devices.  1065 * @error_cou nt: Retu rns the nu mber of ISO transfers that reported errors.  1066 * @context: For u se in completion fu nctions.  This normally points to  1067 *      requ est-specific driver context.  1068 * @complete: Completion handler. This URB is passed as the parameter to the  1069 *      completion fu nction.  The completion fu nction may then do what  1070 *      it likes with the URB , inclu ding resu bmitting or freeing it.  1071 * @iso_frame_desc: U sed to provide arrays of ISO transfer bu ffers and to  1072 *      collect the transfer statu s for each bu ffer.  1073 *  1074 * This stru ctu re identifies U SB transfer requ ests.  URB s mu st be allocated by  1075 * calling u sb_alloc_urb () and freed with a call to u sb_free_urb ().  1076 * Initialization may be done u sing variou s u sb_fill_*_urb () fu nctions.  URB s  1077 * are su bmitted u sing u sb_su bmit_urb (), and pending requ ests may be canceled  1078 * u sing u sb_u nlink_urb () or u sb_kill_urb ().  1079 *  1080 * Data Transfer Bu ffers:  1081 *  1082 * Normally drivers provide I/O bu ffers allocated with kmalloc() or otherwise  1083 * taken from the general page pool.  That is provided by transfer_bu ffer  1084 * (control requ ests also u se setu p_packet), and host controller drivers  1085 * perform a dma mapping (and u nmapping) for each bu ffer transferred.  Those  1086 * mapping operations can be expensive on some platforms (perhaps u sing a dma  1087 * bou nce bu ffer or talking to an IOMMU ),  1088 * althou gh they're cheap on commodity x86 and ppc hardware.  1089 *  1090 * Alternatively, drivers may pass the URB _NO_TRANSFER_DMA_MAP transfer flag,  1091 * which tells the host controller driver that no su ch mapping is needed for  1092 * the transfer_bu ffer since  1093 * the device driver is DMA-aware.  For example, a device driver might  1094 * allocate a DMA bu ffer with u sb_alloc_coherent() or call u sb_bu ffer_map().  1095 * When this transfer flag is provided, host controller drivers will  1096 * attempt to u se the dma address fou nd in the transfer_dma  1097 * field rather than determining a dma address themselves.  1098 *  1099 * Note that transfer_bu ffer mu st still be set if the controller  1100 * does not su pport DMA (as indicated by bu s.u ses_dma) and when talking  1101 * to root hu b. If you have to trasfer between highmem zone and the device  1102 * on su ch controller, create a bou nce bu ffer or bail ou t with an error.  1103 * If transfer_bu ffer cannot be set (is in highmem) and the controller is DMA  1104 * capable, assign NU LL to it, so that u sbmon knows not to u se the valu e.  1105 * The setu p_packet mu st always be set, so it cannot be located in highmem.  1106 *  1107 * Initialization:  1108 *  1109 * All URB s su bmitted mu st initialize the dev, pipe, transfer_flags (may be  1110 * zero), and complete fields.  All URB s mu st also initialize  1111 * transfer_bu ffer and transfer_bu ffer_length.  They may provide the  1112 * URB _SHORT_NOT_OK transfer flag, indicating that short reads are  1113 * to be treated as errors; that flag is invalid for write requ ests.  1114 *  1115 * Bu lk URB s may  1116 * u se the URB _ZERO_PACKET transfer flag, indicating that bu lk OU T transfers  1117 * shou ld always terminate with a short packet, even if it means adding an  1118 * extra zero length packet.  1119 *  1120 * Control URB s mu st provide a valid pointer in the setu p_packet field.  1121 * U nlike the transfer_bu ffer, the setu p_packet may not be mapped for DMA  1122 * beforehand.  1123 *  1124 * Interru pt URB s mu st provide an interval, saying how often (in milliseconds  1125 * or, for highspeed devices, 125 microsecond u nits)  1126 * to poll for transfers.  After the URB has been su bmitted, the interval  1127 * field reflects how the transfer was actu ally schedu led.  1128 * The polling interval may be more frequ ent than requ ested.  1129 * For example, some controllers have a maximu m interval of 32 milliseconds,  1130 * while others su pport intervals of u p to 1024 milliseconds.  1131 * Isochronou s URB s also have transfer intervals.  (Note that for isochronou s  1132 * endpoints, as well as high speed interru pt endpoints, the encoding of  1133 * the transfer interval in the endpoint descriptor is logarithmic.  1134 * Device drivers mu st convert that valu e to linear u nits themselves.)  1135 *  1136 * Isochronou s URB s normally u se the URB _ISO_ASAP transfer flag, telling  1137 * the host controller to schedu le the transfer as soon as bandwidth  1138 * u tilization allows, and then set start_frame to reflect the actu al frame  1139 * selected du ring su bmission.  Otherwise drivers mu st specify the start_frame  1140 * and handle the case where the transfer can't begin then.  However, drivers  1141 * won't know how bandwidth is cu rrently allocated, and while they can  1142 * find the cu rrent frame u sing u sb_get_cu rrent_frame_nu mber () they can't  1143 * know the range for that frame nu mber.  (Ranges for frame cou nter valu es  1144 * are HC-specific, and can go from 256 to 65536 frames from "now".)  1145 *  1146 * Isochronou s URB s have a different data transfer model, in part becau se  1147 * the qu ality of service is only "best effort".  Callers provide specially  1148 * allocated URB s, with nu mber_of_packets worth of iso_frame_desc stru ctu res  1149 * at the end.  Each su ch packet is an individu al ISO transfer.  Isochronou s  1150 * URB s are normally qu eu ed, su bmitted by drivers to arrange that  1151 * transfers are at least dou ble bu ffered, and then explicitly resu bmitted  1152 * in completion handlers, so  1153 * that data (su ch as au dio or video) streams at as constant a rate as the  1154 * host controller schedu ler can su pport.  1155 *  1156 * Completion Callbacks:  1157 *  1158 * The completion callback is made in_interru pt(), and one of the first  1159 * things that a completion handler shou ld do is check the statu s field.  1160 * The statu s field is provided for all URB s.  It is u sed to report  1161 * u nlinked URB s, and statu s for all non-ISO transfers.  It shou ld not  1162 * be examined before the URB is retu rned to the completion handler.  1163 *  1164 * The context field is normally u sed to link URB s back to the relevant  1165 * driver or requ est state.  1166 *  1167 * When the completion callback is invoked for non-isochronou s URB s, the  1168 * actu al_length field tells how many bytes were transferred.  This field  1169 * is u pdated even when the URB terminated with an error or was u nlinked.  1170 *  1171 * ISO transfer statu s is reported in the statu s and actu al_length fields  1172 * of the iso_frame_desc array, and the nu mber of errors is reported in  1173 * error_cou nt.  Completion callbacks for ISO transfers will normally  1174 * (re)su bmit URB s to ensu re a constant transfer rate.  1175 *  1176 * Note that even fields marked "pu blic" shou ld not be tou ched by the driver  1177 * when the urb is owned by the hcd, that is, since the call to  1178 * u sb_su bmit_urb () till the entry into the completion rou tine.  1179 */  1180 stru ct urb { 1181          /* private: u sb core and host controller only fields in the urb */  1182          stru ct kref kref ;               /* reference cou nt of the URB */  1183          void *hcpriv;                   /* private data for host controller */  1184          atomic_t u se_cou nt ;             /* concu rrent su bmissions cou nter */  1185          atomic_t reject;                /* su bmissions will fail */  1186          int u nlinked;                   /* u nlink error code */  1187  1188          /* pu blic: docu mented fields in the urb that can be u sed by drivers */  1189          stru ct list_head urb _list ;      /* list head for u se by the urb 's  1190                                          * cu rrent owner */  1191          stru ct list_head anchor_list;   /* the URB may be anchored */  1192          stru ct u sb_anchor *anchor; 1193          stru ct u sb_device *dev ;         /* (in) pointer to associated device */  1194          stru ct u sb_host_endpoint *ep ;   /* (internal) pointer to endpoint */  1195          u nsigned int pipe ;              /* (in) pipe information */  1196          u nsigned int stream_id ;         /* (in) stream ID */  1197          int statu s ;                     /* (retu rn) non-ISO statu s */  1198          u nsigned int transfer_flags;    /* (in) URB _SHORT_NOT_OK | ...*/  1199          void *transfer_bu ffer;          /* (in) associated data bu ffer */  1200          dma_addr_t transfer_dma;        /* (in) dma addr for transfer_bu ffer */  1201          stru ct scatterlist *sg;         /* (in) scatter gather bu ffer list */  1202          int nu m_sgs;                    /* (in) nu mber of entries in the sg list */  1203          u 32 transfer_bu ffer_length;     /* (in) data bu ffer length */  1204          u 32 actu al_length;              /* (retu rn) actu al transfer length */  1205          u nsigned char *setu p_packet ;    /* (in) setu p packet (control only) */  1206          dma_addr_t setu p_dma ;           /* (in) dma addr for setu p_packet */  1207          int start_frame;                /* (modify) start frame (ISO) */  1208          int nu mber_of_packets;          /* (in) nu mber of ISO packets */  1209          int interval ;                   /* (modify) transfer interval  1210                                          * (INT/ISO) */  1211          int error_cou nt ;                /* (retu rn) nu mber of ISO errors */  1212          void *context ;                  /* (in) context for completion */  1213          u sb_complete_t complete ;        /* (in) completion rou tine */  1214          stru ct u sb_iso_packet_descriptor iso_frame_desc[0]; 1215                                          /* (in) ISO ONLY */  1216 }; 1217  1218 /* ----------------------------------------------------------------------- */     6. Linux usb 驱动的相关操作函数    int usb_register(struct usb_driver *d); void usb_deregister(struct usb_driver *d); Functions used to register and unregister a USB driver from the USB core.    这两个函数主要用来注册usb driver与解注册usb driver.   struct usb_device *interface_to_usbdev(struct usb_interface *intf); Retrieves the controlling struct usb_device * out of a struct usb_interface *.     返回一个usb接口返回一个usb_device.   void usb_set_intfdata(struct usb_interface *intf, void *data); void *usb_get_intfdata(struct usb_interface *intf); Functions to set and get access to the private data pointer section within the struct usb_interface.     设置private data和是返回private data.   int usb_register_dev(struct usb_interface *intf, struct usb_class_driver *class_driver); void usb_deregister_dev(struct usb_interface *intf, struct usb_class_driver *class_driver); Functions used to register and unregister a specific struct usb_interface * structure with a struct usb_class_driver * structure.   注册usb接口驱动和解注册usb接口驱动,接口驱动也就是设备驱动。       struct urb *usb_alloc_urb(int iso_packets, int mem_flags); void usb_free_urb(struct urb *urb); Functions used to create and destroy a struct usb urb *.   分配和释放urb.   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, void *context, int interval); 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, void *context); 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, void *context); Functions used to initialize a struct urb before it is submitted to the USB core.     这三个函数是用来初始化urb.   参数: struct urb* urb 要初始化的urb结构体。 struct usb_device *dev urb发送到的设备 unsigned int pipe  usb_sndintpipe和usb_rcvintpipe分别是usb发送端点管道和接收端点管道 void *transfer_buffer 接收或发送数据的缓冲区 int buffer_length 缓冲区的长度 usb_complete_t  urb完成时的回调函数   int usb_bulk_msg(struct usb_device *usb_dev, unsigned int pipe, void *data, int len, int *actual_length, int timeout); 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); Functions used to send or receive USB data without having to use a struct urb.   这两个函数的usb接收或发送数据没有使用urb结构体。     7. skelton程序   /*  * USB Skeleton driver - 2.2  *  * Copyright (C) 2001-2004 Greg Kroah-Hartman ([email protected])  *  *    This program is free software; you can redistribute it and/or  *    modify it under the terms of the GNU General Public License as  *    published by the Free Software Foundation, version 2.  *  * This driver is based on the 2.6.3 version of drivers/usb/usb-skeleton.c  * but has been rewritten to be easier to read and use.  *  */ #include <linux/kernel.h> #include <linux/errno.h> #include <linux/init.h> #include <linux/slab.h> #include <linux/module.h> #include <linux/kref.h> #include <asm/uaccess.h> #include <linux/usb.h> #include <linux/mutex.h> /* Define these values to match your devices */ #define USB_SKEL_VENDOR_ID    0xfff0 #define USB_SKEL_PRODUCT_ID    0xfff0 /* table of devices that work with this driver */ static struct usb_device_id skel_table [] = {     { USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) },     { }                    /* Terminating entry */ }; MODULE_DEVICE_TABLE(usb, skel_table); /* Get a minor range for your devices from the usb maintainer */ #define USB_SKEL_MINOR_BASE    192 //次设备号 /* our private defines. if this grows any larger, use your own .h file */ #define MAX_TRANSFER        (PAGE_SIZE - 512) #define WRITES_IN_FLIGHT    8 /* Structure to hold all of our device specific stuff */ struct usb_skel {       size_t udev;     struct usb_device       *dev;            /* 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 */     unsigned char           *bulk_in_buffer;    /* the buffer to receive data */     size_t            bulk_in_size;        /* the size of the receive buffer */     __u8            bulk_in_endpointAddr;    /* the address of the bulk in endpoint */     __u8            bulk_out_endpointAddr;    /* the address of the bulk out endpoint */     struct kref        kref;     struct mutex        io_mutex;        /* synchronize I/O with disconnect */ }; #define to_skel_dev(d) container_of(d, struct usb_skel, kref) static struct usb_driver skel_driver; static void skel_delete(struct kref *kref) {     struct usb_skel *dev = to_skel_dev(kref);     usb_put_dev(dev->udev);     kfree(dev->bulk_in_buffer);     kfree(dev); } static int skel_open(struct inode *inode, struct file *file) {     struct usb_skel *dev;     struct usb_interface *interface;     int subminor;     int retval = 0;     subminor = iminor(inode);      interface = usb_find_interface(&skel_driver, subminor);     if (!interface) {         err ("%s - error, can't find device for minor %d",              __FUNCTION__, subminor);         retval = -ENODEV;         goto exit;     }     dev = usb_get_intfdata(interface);     if (!dev) {         retval = -ENODEV;         goto exit;     }     /* prevent the device from being autosuspended */     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; exit:     return retval; } static int skel_release(struct inode *inode, struct file *file) {     struct usb_skel *dev;     dev = (struct usb_skel *)file->private_data;     if (dev == NULL)         return -ENODEV;     /* allow the device to be autosuspended */     mutex_lock(&dev->io_mutex);     if (dev->interface)         usb_autopm_put_interface(dev->interface);     mutex_unlock(&dev->io_mutex);     /* decrement the count on our device */     kref_put(&dev->kref, skel_delete);     return 0; } static ssize_t skel_read(struct file *file, char *buffer, size_t count, loff_t *ppos) {     struct usb_skel *dev;     int retval;     int bytes_read;     dev = (struct usb_skel *)file->private_data;     mutex_lock(&dev->io_mutex);     if (!dev->interface) {        /* disconnect() was called */         retval = -ENODEV;         goto exit;     }     /* do a blocking bulk read to get data from the device */   //usb_bulk_msg没有使用urb      retval = usb_bulk_msg(dev->udev,                   usb_rcvbulkpipe(dev->udev, dev->bulk_in_endpointAddr),                   dev->bulk_in_buffer,                   min(dev->bulk_in_size, count),                   &bytes_read, 10000);     /* if the read was successful, copy the data to userspace */     if (!retval) {         if (copy_to_user(buffer, dev->bulk_in_buffer, bytes_read)) //复制到用户空间             retval = -EFAULT;         else             retval = bytes_read;     } exit:     mutex_unlock(&dev->io_mutex);     return retval; } static void skel_write_bulk_callback(struct urb *urb) {     struct usb_skel *dev;     dev = (struct usb_skel *)urb->context;     /* sync/async unlink faults aren't errors */     if (urb->status &&         !(urb->status == -ENOENT ||           urb->status == -ECONNRESET ||           urb->status == -ESHUTDOWN)) {         err("%s - nonzero write bulk status received: %d",             __FUNCTION__, urb->status);     }     /* free up our allocated buffer */     usb_buffer_free(urb->dev, urb->transfer_buffer_length,             urb->transfer_buffer, urb->transfer_dma);     up(&dev->limit_sem); } //首先创建一个urb和buffer,初始化urb,然后提交urb. static ssize_t skel_write(struct file *file, const char *user_buffer, size_t count, loff_t *ppos) {     struct usb_skel *dev;     int retval = 0;     struct urb *urb = NULL;     char *buf = NULL;     size_t writesize = min(count, (size_t)MAX_TRANSFER);     dev = (struct usb_skel *)file->private_data;     /* 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 (down_interruptible(&dev->limit_sem)) {         retval = -ERESTARTSYS;         goto exit;     }     mutex_lock(&dev->io_mutex);     if (!dev->interface) {        /* disconnect() was called */         retval = -ENODEV;         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_buffer_alloc(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;     }     /* initialize the urb properly */     usb_fill_bulk_urb(urb, dev->udev,               usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr),               buf, writesize, skel_write_bulk_callback, dev);     urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;     /* send the data out the bulk port */     retval = usb_submit_urb(urb, GFP_KERNEL);     if (retval) {         err("%s - failed submitting write urb, error %d", __FUNCTION__, retval);         goto error;     }     /* release our reference to this urb, the USB core will eventually free it entirely */     usb_free_urb(urb);     mutex_unlock(&dev->io_mutex);     return writesize; error:     if (urb) {         usb_buffer_free(dev->udev, writesize, buf, urb->transfer_dma);         usb_free_urb(urb);     }     mutex_unlock(&dev->io_mutex);     up(&dev->limit_sem); exit:     return retval; } static const struct file_operations skel_fops = {     .owner =    THIS_MODULE,     .read =        skel_read,     .write =    skel_write,     .open =        skel_open,     .release =    skel_release, }; /*  * 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 skel_class = {     .name =        "skel%d",     .fops =        &skel_fops,     .minor_base =    USB_SKEL_MINOR_BASE, }; static int skel_probe(struct usb_interface *interface, const struct usb_device_id *id) {     struct usb_skel *dev;     struct usb_host_interface *iface_desc; //usb_host_interface包含usb interface的所有设置     struct usb_endpoint_descriptor *endpoint; //这个结构体是usb端点描述符     size_t buffer_size;     int i;     int retval = -ENOMEM;     /* allocate memory for our device state and initialize it */     dev = kzalloc(sizeof(*dev), GFP_KERNEL);     if (!dev) {         err("Out of memory");         goto error;     }     kref_init(&dev->kref);     sema_init(&dev->limit_sem, WRITES_IN_FLIGHT);     mutex_init(&dev->io_mutex);     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 = le16_to_cpu(endpoint->wMaxPacketSize);             dev->bulk_in_size = buffer_size;             dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;             dev->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);             if (!dev->bulk_in_buffer) {                 err("Could not allocate bulk_in_buffer");                 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)) {         err("Could not find both bulk-in and bulk-out endpoints");         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 */     retval = usb_register_dev(interface, &skel_class);  //注册usb设备     if (retval) {         /* something prevented us from registering this driver */         err("Not able to get a minor for this device.");         usb_set_intfdata(interface, NULL);         goto error;     }     /* let the user know what node this device is now attached to */     info("USB Skeleton device now attached to USBSkel-%d", interface->minor);     return 0; error:     if (dev)         kref_put(&dev->kref, skel_delete);     return retval; } static void skel_disconnect(struct usb_interface *interface) {     struct usb_skel *dev;     int minor = interface->minor;     /* prevent skel_open() from racing skel_disconnect() */     lock_kernel();     dev = usb_get_intfdata(interface);     usb_set_intfdata(interface, NULL);     /* give back our minor */     usb_deregister_dev(interface, &skel_class);     /* prevent more I/O from starting */     mutex_lock(&dev->io_mutex);     dev->interface = NULL;     mutex_unlock(&dev->io_mutex);     unlock_kernel();     /* decrement our usage count */     kref_put(&dev->kref, skel_delete);     info("USB Skeleton #%d now disconnected", minor); } static struct usb_driver skel_driver = {     .name =        "skeleton",     .probe =    skel_probe,     .disconnect =    skel_disconnect,     .id_table =    skel_table, }; static int __init usb_skel_init(void) {     int result;         /* register this driver with the USB subsystem */     result = usb_register(&skel_driver);     if (result)         err("usb_register failed. Error number %d", result);     return result; } static void __exit usb_skel_exit(void) { //向usb子系统注册这个驱动     /* deregister this driver with the USB subsystem */     usb_deregister(&skel_driver); } module_init(usb_skel_init); module_exit(usb_skel_exit); MODULE_LICENSE("GPL");     分析: skeleton.c 在/driver/usb/ 目录下,它是一个骨架驱动程序。 skeleton首先向usb子系统中注册驱动,然后注册设备。通常所说的usb驱动是指usb接口驱动。即完成一定的功能,数据处理。面 usb driver通过扫描确定usb设备是否在本驱动的设备列表中,即一个usb driver可能对应多个usb设备,它是用来辨别usb设备的。当usb设备移除时,调用disconnect函数。usb driver用于识别usb interface driver. 最后记住,一个接口对应一个设备驱动,主机与设备之间的数据传输是通过端点来实现的。urb是设备与主机之间数据交换的中介。 关于usb 主机驱动就介绍到这里了。  

上一篇:lex yacc 学习
下一篇:[33期] 兄弟连-我的归宿“相见恨晚”的她

相关文章

相关评论