转自：/liangzc1124/article/details/119333357、/lifexy/p/7631900.html

1、Windows USB设备驱动

为什么一插上就会有提示信息？

以windows为例，插上一个没有USB驱动的USB设备，会提示你安装USB驱动；

那USB总线驱动程序是干嘛用的？

识别USB设备；给USB设备找到并安装对应的驱动程序；提供USB的读写函数。

首先，新接入的USB设备的默认地址（编号）为0，再未分配新编号前，PC主机使用0地址和它通信。然后USB总线驱动程序都会给它分配一个地址（编号）。PC机想访问USB总线上某个USB设备时，发出的命令都含有对应的地址（编号）。

USB的结构是怎样的？

USB是一种主从结构。主机叫做Host，从机叫做Device，所有的USB传输，都是从USB主机这方发起；USB设备没有“主动”通知USB主机的能力。例如：USB鼠标滑动一下立刻产生数据，但是它还没有能力通过OC机来读数据，只能被动地等待PC机来读。

USB可以热拔插的硬件原理

在USB集线器（hub）的每个下游端口的D+和D-上，分别接了一个15K欧姆的下拉电阻到地。这样，在集线器的端口悬空时，就被这两个下拉电阻拉到了低电平。而在USB设备端，在D+或者D-上接了1.5k欧姆上拉电阻，对于全速和高速设备，上拉电阻是接在D+上；而低速设备则是上拉电阻接在D-上。这样，当设备插入到集线器时，由1.5k的上拉电阻和15k的下拉电阻分呀，结果就将差分数据线中的一条拉高了。集线器检测到这个状态后，它就报告给USB主控制器（或者通过它上一层的集线器报告给USB主控制器），这样就检测到设备的插入了。USB高速设备先是被识别为全速设备，然后通过HOST和DEVICE两者之间的确认，再切换到告诉模式的。在高速模式下，是电流传输模式，这时将D+上的上拉电阻断开。

USB的4大传输类型：

控制传输是每一个USB设备必须支持的，通常用来获取设备描述符、设置设备的状态等等。一个USB设备从插入到最后的拔出这个过程一定会产生控制传输（即便这个USB设备不能被这个系统支持）。中断传输支持中断传输的典型设备有USB鼠标、USB键盘等等。中断传输不是说我的设备真正发出一个中断，然后主机会来读取数据。它其实是一种轮询的方式来完成数据的通信。USB设备会在设备驱动程序中设置一个参数叫做interval，它是endpoint的一个成员。interval是间隔时间的意思，表示我这个设备希望主机多长时间来轮询自己，只要这个值确定了之后，我主机就会周期性来查看有没有数据需要处理。批量处理支持批量传输最典型的设备就是U盘，它进行大数量的数据传输，能够保证数据的准确性，但是时间不是固定的。实时传输USB摄像头就是实时传输设备的典型代表，它同样进行大量数据的传输，数据的准确性无法保证，但是对传输延迟非常敏感，也就是说对实时性要求比较高

USB端点：

每个USB设备与主机会有若干个通信的“端点”。每个端点都有个端点号，除了端点0外，每一个端点只能工作在一种传输类型（控制传输、中断传输、批量传输、实时传输）下，一个传输方向。传输方向都是基于USB主机的立场说的，比如：鼠标的数据是从鼠标传到PC机，对应的端点称为“中断输入端点”。端点0是设备的默认控制端点，既能输出也能输入，主要用于USB设备的识别过程。

USB驱动整体框架：

USB主机控制器类型

要想成为一个USB主机，硬件上就必须要有USB主机控制器，USB主机控制器又分为4种接口：

OHCI（Open Host Controller Inerface）：微软主导的低速USB1.0（1.5Mbps）和全速USB1.1（12Mbps），OHCI接口的硬件简单，软件复杂。UHCI（Universal Host Controller Interface）：Intel主导的低速USB1.0（1.5Mbps）和全速USB1.1（12Mbps），而UHCI接口的软件简单，硬件复杂。EHCI（Enhace Host Controller Interface）：高速USB2.0（480Mbps）。xHCI（eXtensible Host Controller Interface）：USB3.0（5.0Gbps），采用了9针脚设针，同时也支持USB2.0、1.1等。

2、USB总线驱动分析

2.1 USB描述符的层次及定义 USB设备描述符（usb_device_descriptor） USB配置描述符（usb_config_descriptor） USB接口描述符（usb_interface_descriptor） USB端点描述符（usb_endpoint_descriptor）、

一个设备描述符可以有多个配置描述符；

一个配置描述符可以有多个接口描述符（比如声卡驱动就有两个接口：录音接口和播放接口）

一个接口描述符可以有多个端点描述符；

2.1.1 USB设备描述符（usb_device_descriptor）

USB设备描述符结构体如下所示：

struct usb_device_descriptor {__u8 bLength;//本描述符的size__u8 bDescriptorType; //描述符的类型，这里是设备描述符DEVICE__u16 bcdUSB; //指明usb的版本，比如usb2.0__u8 bDeviceClass; //类__u8 bDeviceSubClass; //子类__u8 bDeviceProtocol; //指定协议__u8 bMaxPacketSize0; //端点0对应的最大包大小__u16 idVendor;//厂家ID__u16 idProduct;//产品ID__u16 bcdDevice;//设备的发布号__u8 iManufacturer; //字符串描述符中厂家ID的索引__u8 iProduct;//字符串描述符中产品ID的索引__u8 iSerialNumber; //字符串描述符中设备序列号的索引__u8 bNumConfigurations;//配置描述符的个数,表示有多少个配置描述符} __attribute__ ((packed));

USB设备描述符位于USB设备结构体usb_device中的成员descriptor中。同样地,配置、接口、端点描述符也是位于USB配置、接口、端点结构体中,不过这3个对于我们写驱动的不是很常用。

usb_device结构体如下所示：

struct usb_device {int devnum; //设备号，是在USB总线的地址char devpath [16]; //用于消息的设备ID字符串enum usb_device_state state; //设备状态：已配置、未连接等等enum usb_device_speed speed; //设备速度：高速、全速、低速或错误struct usb_tt *tt; //处理传输者信息；用于低速、全速设备和高速HUBint ttport; //位于tt HUB的设备口unsigned int toggle[2]; //每个端点占一位，表明端点的方向([0] = IN, [1] = OUT)struct usb_device *parent; //上一级HUB指针struct usb_bus *bus; //总线指针struct usb_host_endpoint ep0; //端点0数据struct device dev; //一般的设备接口数据结构struct usb_device_descriptor descriptor; //USB设备描述符,struct usb_host_config *config; //设备的所有配置结构体,配置结构体里包含了配置描述符struct usb_host_config *actconfig; //被激活的设备配置struct usb_host_endpoint *ep_in[16]; //输入端点数组struct usb_host_endpoint *ep_out[16]; //输出端点数组char **rawdescriptors; //每个配置的raw描述符unsigned short bus_mA; //可使用的总线电流u8 portnum; //父端口号u8 level; //USB HUB的层数unsigned can_submit:1; //URB可被提交标志unsigned discon_suspended:1; //暂停时断开标志unsigned persist_enabled:1; //USB_PERSIST使能标志unsigned have_langid:1; //string_langid存在标志unsigned authorized:1; unsigned authenticated:1;unsigned wusb:1; //无线USB标志int string_langid; //字符串语言ID/* static strings from the device */ //设备的静态字符串char *product; //产品名char *manufacturer; //厂商名char *serial; //产品串号struct list_head filelist; //此设备打开的usbfs文件#ifdef CONFIG_USB_DEVICE_CLASSstruct device *usb_classdev;//用户空间访问的为usbfs设备创建的USB类设备#endif#ifdef CONFIG_USB_DEVICEFSstruct dentry *usbfs_dentry; //设备的usbfs入口#endifint maxchild; //（若为HUB）接口数struct usb_device *children[USB_MAXCHILDREN];//连接在这个HUB上的子设备int pm_usage_cnt; //自动挂起的使用计数u32 quirks; atomic_t urbnum; //这个设备所提交的URB计数unsigned long active_duration; //激活后使用计时#ifdef CONFIG_PM //电源管理相关struct delayed_work autosuspend; //自动挂起的延时struct work_struct autoresume; //（中断的）自动唤醒需求struct mutex pm_mutex; //PM的互斥锁unsigned long last_busy; //最后使用的时间int autosuspend_delay; unsigned long connect_time; //第一次连接的时间unsigned auto_pm:1; //自动挂起/唤醒unsigned do_remote_wakeup:1; //远程唤醒unsigned reset_resume:1; //使用复位替代唤醒unsigned autosuspend_disabled:1; //挂起关闭unsigned autoresume_disabled:1; //唤醒关闭unsigned skip_sys_resume:1; //跳过下个系统唤醒#endifstruct wusb_dev *wusb_dev; //（如果为无线USB）连接到WUSB特定的数据结构};

2.1.2 USB配置描述符

struct usb_config_descriptor {__u8 bLength; //描述符的长度__u8 bDescriptorType; //描述符类型的编号__le16 wTotalLength;//配置所返回的所有数据的大小__u8 bNumInterfaces; //配置所支持的接口个数, 表示有多少个接口描述符__u8 bConfigurationValue; //Set_Configuration命令需要的参数值__u8 iConfiguration; //描述该配置的字符串的索引值__u8 bmAttributes;//供电模式的选择__u8 bMaxPower; //设备从总线提取的最大电流} __attribute__ ((packed));

2.1.3 接口描述符（逻辑设备）

USB接口只处理一种USB逻辑连接。一个USB接口代表一个逻辑上的设备，比如声卡驱动就有两个接口：录音接口和播放接口。这可以在windows系统中看出，有时插入一个USB设备后，系统会识别出多个设备，并安装相应多个的驱动。

struct usb_interface_descriptor {__u8 bLength;//描述符的长度__u8 bDescriptorType; //描述符类型的编号__u8 bInterfaceNumber; //接口的编号__u8 bAlternateSetting;//备用的接口描述符编号,提供不同质量的服务参数.__u8 bNumEndpoints; //要使用的端点个数(不包括端点0), 表示有多少个端点描述符,比如鼠标就只有一个端点__u8 bInterfaceClass; //接口类型,与驱动的id_table对应__u8 bInterfaceSubClass; //接口子类型__u8 bInterfaceProtocol; //接口所遵循的协议__u8 iInterface; //描述该接口的字符串索引值} __attribute__ ((packed)

它位于usb_interface->cur_altsetting->desc 这个成员结构体里.

struct usb_interface {/* 包含所有可用于该接口的可选设置的接口结构数组。每个 struct usb_host_interface 包含一套端点配置（即struct usb_host_endpoint结构所定义的端点配置。这些接口结构没有特别的顺序。*/struct usb_host_interface *altsetting;/* 指向altsetting内部的指针，表示当前激活的接口配置*/struct usb_host_interface *cur_altsetting; unsigned num_altsetting; /* 可选设置的数量*//* If there is an interface association descriptor then it will list the associated interfaces */ struct usb_interface_assoc_descriptor *intf_assoc;/* 如果绑定到这个接口的 USB 驱动使用 USB 主设备号, 这个变量包含由 USB 核心分配给接口的次设备号. 这只在一个成功的调用 usb_register_dev后才有效。*/ int minor; ... ...}

cur_altsetting成员的结构体是usb_host_interface,如下:

struct usb_host_interface {struct usb_interface_descriptor desc; //当前被激活的接口描述符struct usb_host_endpoint *endpoint; /* 这个接口的所有端点结构体的联合数组*/char *string; /* 接口描述字符串 */unsigned char *extra; /* 额外的描述符 */int extralen;};

2.1.4 端点描述符

struct usb_endpoint_descriptor {__u8 bLength; //描述符的长度__u8 bDescriptorType; //描述符类型的编号__u8 bEndpointAddress; //端点编号,比如端点1,就是1__u8 bmAttributes; //端点的属性, 比如中断传输类型,输入类型__le16 wMaxPacketSize; //一个端点的最大包大小,__u8 bInterval;//间隔时间,用在中断传输上,比如间隔时间查询鼠标的数据/* NOTE: these two are _only_ in audio endpoints. *//* use USB_DT_ENDPOINT*_SIZE in bLength, not sizeof. */__u8 bRefresh;__u8 bSynchAddress;} __attribute__ ((packed));

比如端点0就位于usb_interface->cur_altsetting->desc->endpoint[0].desc

struct usb_host_endpoint {struct usb_endpoint_descriptor desc; //端点描述符struct usb_ss_ep_comp_descriptor ss_ep_comp; //超快速端点描述符struct list_head urb_list; //本端口对应的urb链表void *hcpriv;struct ep_device *ep_dev; /* For sysfs info */unsigned char *extra; /* Extra descriptors */int extralen;int enabled;//使能的话urb才能被提交到此端口};

2.2 USB总线驱动如何识别设备

由于内核自带了USB驱动,所以我们先插入一个USB键盘到开发板上看打印信息发现以下字段:

如下图,找到第一段话是位于drivers/usb/core/hub.c的第2186行：

这个hub其实就是我们的USB主机控制器的集线器,用来管理多个USB接口

2.2.1 drivers/usb/core/hub.c的第2186行位于hub_port_init()函数里

它又是被谁调用的,如下图所示，我们搜索到它是通过hub_thread()函数调用的

hub_thread()函数如下:

static int hub_thread(void *__unused){do {hub_events(); //执行一次hub事件函数wait_event_interruptible(khubd_wait,!list_empty(&hub_event_list) ||kthread_should_stop()); //(1).每次执行一次hub事件,都会进入一次等待事件中断函数try_to_freeze(); } while (!kthread_should_stop() || !list_empty(&hub_event_list));pr_debug("%s: khubd exiting\n", usbcore_name);return 0;}

从上面函数中得到, 要想执行hub_events(),都要等待khubd_wait这个中断唤醒才行。

2.2.2 搜索”khubd_wait”，看看是被谁唤醒

找到该中断在kick_khubd()函数中唤醒,代码如下:

static void kick_khubd(struct usb_hub *hub){unsigned long flags;to_usb_interface(hub->intfdev)->pm_usage_cnt = 1;spin_lock_irqsave(&hub_event_lock, flags);if (list_empty(&hub->event_list)) {list_add_tail(&hub->event_list, &hub_event_list);wake_up(&khubd_wait); //唤醒khubd_wait这个中断}spin_unlock_irqrestore(&hub_event_lock, flags);}

2.2.3 继续搜索kick_khubd,发现被hub_irq()函数中调用

显然,就是当USB设备插入后,D+或D-就会被拉高,然后USB主机控制器就会产生一个hub_irq中断.

2.2.4 分析hub_port_connect_change()函数如何连接端口

static void hub_port_connect_change(struct usb_hub *hub, int port1,u16 portstatus, u16 portchange){... ...udev = usb_alloc_dev(hdev, hdev->bus, port1); //(1)注册一个usb_device,然后会放在usb总线上usb_set_device_state(udev, USB_STATE_POWERED); //设置注册的USB设备的状态标志... ...choose_address(udev); //(2)给新的设备分配一个地址编号status = hub_port_init(hub, udev, port1, i); //(3)初始化端口,与USB设备建立连接... ...status = usb_new_device(udev); //(4)创建USB设备,与USB设备驱动连接... ...}

所以最终流程图如下:

hub_irqkick_khubd // 唤醒hub_thread线程hub_threadhub_events // 处理USB设备插入事件hub_port_connect_changeudev = usb_alloc_dev(hdev, hdev->bus, port1);dev->dev.bus = &usb_bus_type;choose_address(udev); // 给新设备分配编号(地址)hub_port_init // usb 1-1: new full speed USB device using s3c2410-ohci and address 3hub_set_address // 把编号(地址)告诉USB设备usb_get_device_descriptor(udev, 8); // 获取设备描述符retval = usb_get_device_descriptor(udev, USB_DT_DEVICE_SIZE);usb_new_device(udev) err = usb_get_configuration(udev); // 把所有的描述符都读出来，并解析usb_parse_configurationdevice_add // 把device放入usb_bus_type的dev链表, // 从usb_bus_type的driver链表里取出usb_driver，// 把usb_interface和usb_driver的id_table比较// 如果能匹配，调用usb_driver的probe

2.2.5 进入hub_port_connect_change()->usb_alloc_dev()，看它是怎么设置usb_device

usb_alloc_dev(struct usb_device *parent, struct usb_bus *bus, unsigned port1){struct usb_device *dev;dev = kzalloc(sizeof(*dev), GFP_KERNEL); //分配一个usb_device设备结构体... ...device_initialize(&dev->dev); //初始化usb_devicedev->dev.bus = &usb_bus_type; //(1)设置usb_device的成员device->bus等于usb_bus总线dev->dev.type = &usb_device_type; //设置usb_device的成员device->type等于usb_device_type... ...return dev;//返回一个usb_device结构体}

其中usb_bus_type是一个全局变量, 它和我们之前学的platform平台总线相似,属于USB总线, 是Linux中bus的一种.

如下图所示,每当创建一个USB设备,或者USB设备驱动时,USB总线都会调用match成员来匹配一次,使USB设备和USB设备驱动联系起来.

usb_bus_type结构体如下:

struct bus_type usb_bus_type = {.name ="usb",//总线名称,存在/sys/bus下.match = usb_device_match,//匹配函数,匹配成功就会调用usb_driver驱动的probe函数成员.uevent = usb_uevent,//事件函数.suspend = usb_suspend, //休眠函数.resume = usb_resume, //唤醒函数};

2.2.6 进入hub_port_connect_change()->choose_address()，看它是怎么分配地址编号的

static void choose_address(struct usb_device *udev){int devnum;struct usb_bus *bus = udev->bus;devnum = find_next_zero_bit(bus->devmap.devicemap, 128,bus->devnum_next);//在bus->devnum_next~128区间中,循环查找下一个非0(没有设备)的编号if (devnum >= 128) //若编号大于等于128,说明没有找到空余的地址编号,从头开始找devnum = find_next_zero_bit(bus->devmap.devicemap, 128, 1);bus->devnum_next = ( devnum >= 127 ? 1 : devnum + 1); //设置下次寻址的区间+1if (devnum < 128) {set_bit(devnum, bus->devmap.devicemap); //设置位udev->devnum = devnum; }}

从上面代码中分析到每次的地址编号是连续加的,USB接口最大能接127个设备,我们连续插拔两次USB键盘,也可以看出,如下图所示:

2.2.7 再看hub_port_connect_change()->hub_port_init()函数是如何来实现连接USB设备的

static int hub_port_init (struct usb_hub *hub, struct usb_device *udev, int port1,int retry_counter){... ...for (j = 0; j < SET_ADDRESS_TRIES; ++j){retval = hub_set_address(udev);//(1)设置地址,告诉USB设备新的地址编号if (retval >= 0)break;msleep(200);}retval = usb_get_device_descriptor(udev, 8); //(2)获得USB设备描述符前8个字节... ...retval = usb_get_device_descriptor(udev, USB_DT_DEVICE_SIZE); //重新获取设备描述符信息... ...}

hub_set_address()函数主要是用来告诉USB设备新的地址编号，hub_set_address()函数如下:

static int hub_set_address(struct usb_device *udev){int retval;... ...retval = usb_control_msg(udev, usb_sndaddr0pipe(),USB_REQ_SET_ADDRESS,0, udev->devnum, 0,NULL, 0, USB_CTRL_SET_TIMEOUT); //(1.1)等待传输完成if (retval == 0) {//设置新的地址,传输完成,返回0usb_set_device_state(udev, USB_STATE_ADDRESS); //设置状态标志ep0_reinit(udev);}return retval;}

usb_control_msg()函数就是用来让USB主机控制器把一个控制报文发给USB设备,如果传输完成就返回0.其中参数udev表示目标设备;使用的管道为usb_sndaddr0pipe(),也就是默认的地址0加上控制端点号0; USB_REQ_SET_ADDRESS表示命令码,既设置地址; udev->devnum表示要设置目标设备的设备号;允许等待传输完成的时间为5秒,因为USB_CTRL_SET_TIMEOUT定义为5000。上面第12行中,usb_get_device_descriptor()函数主要是获取目标设备描述符前8个字节,为什么先只开始读取8个字节？是因为开始时还不知道对方所支持的信包容量,这8个字节是每个设备都有的,后面再根据设备的数据,通过usb_get_device_descriptor()重读一次目标设备的设备描述结构.

其中USB设备描述符结构体如下所示:

struct usb_device_descriptor {__u8 bLength;//本描述符的size__u8 bDescriptorType; //描述符的类型，这里是设备描述符DEVICE__u16 bcdUSB; //指明usb的版本，比如usb2.0__u8 bDeviceClass; //类__u8 bDeviceSubClass;//子类__u8 bDeviceProtocol; //指定协议__u8 bMaxPacketSize0;//端点0对应的最大包大小__u16 idVendor;//厂家ID__u16 idProduct; //产品ID__u16 bcdDevice; //设备的发布号__u8 iManufacturer;//字符串描述符中厂家ID的索引__u8 iProduct;//字符串描述符中产品ID的索引__u8 iSerialNumber; //字符串描述符中设备序列号的索引__u8 bNumConfigurations;//可能的配置的数目} __attribute__ ((packed));

2.2.8 再看hub_port_connect_change()->usb_new_device()函数是如何来创建USB设备的

int usb_new_device(struct usb_device *udev){... ...err = usb_get_configuration(udev); //(1)获取配置描述块... ...err = device_add(&udev->dev);// (2)把device放入bus的dev链表中,并寻找对应的设备驱动}

其中usb_get_configuration()函数如下,就是获取各个配置

int usb_get_configuration(struct usb_device *dev){... .../* USB_MAXCONFIG 定义为8,表示设备描述块下有最多不能超过8个配置描述块 *//*ncfg表示 设备描述块下 有多少个配置描述块 */if (ncfg > USB_MAXCONFIG) {dev_warn(ddev, "too many configurations: %d, ""using maximum allowed: %d\n", ncfg, USB_MAXCONFIG);dev->descriptor.bNumConfigurations = ncfg = USB_MAXCONFIG;}... ...for (cfgno = 0; cfgno < ncfg; cfgno++){//for循环,从USB设备里依次读入所有配置描述块//每次先读取USB_DT_CONFIG_SIZE个字节,也就是9个字节,暂放到buffer中result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno,buffer, USB_DT_CONFIG_SIZE);... ...//通过wTotalLength,知道实际数据大小length = max((int) le16_to_cpu(desc->wTotalLength),USB_DT_CONFIG_SIZE); bigbuffer = kmalloc(length, GFP_KERNEL); //然后再来分配足够大的空间... ...//在调用一次usb_get_descriptor,把整个配置描述块读出来,放到bigbuffer中result = usb_get_descriptor(dev, USB_DT_CONFIG, cfgno,bigbuffer, length);... ...//再将bigbuffer地址放在rawdescriptors所指的指针数组中dev->rawdescriptors[cfgno] = bigbuffer; result = usb_parse_configuration(&dev->dev, cfgno,&dev->config[cfgno],bigbuffer, length); //最后在解析每个配置块}... ...}

其中device_add ()函数如下

int usb_get_configuration(struct usb_device *dev){dev = get_device(dev); //使dev等于usb_device下的device成员... ...if ((error = bus_add_device(dev))) // 把这个设备添加到dev->bus的device表中goto BusError;... ...bus_attach_device(dev); //来匹配对应的驱动程序... ...}

当bus_attach_device()函数匹配成功,就会调用驱动的probe函数

2.2.9 再看usb_bus_type这个的成员usb_device_match函数是如何匹配的

usb_device_match函数如下所示:

static int usb_device_match(struct device *dev, struct device_driver *drv){if (is_usb_device(dev)) {//判断是不是USB设备if (!is_usb_device_driver(drv))return 0;return 1;}else{//否则就是USB驱动或者USB设备的接口struct usb_interface *intf;struct usb_driver *usb_drv;const struct usb_device_id *id; if (is_usb_device_driver(drv)) //如果是USB驱动,就不需要匹配,直接returnreturn 0; intf = to_usb_interface(dev);//获取USB设备的接口usb_drv = to_usb_driver(drv);//获取USB驱动id = usb_match_id(intf, usb_drv->id_table); //匹配USB驱动的成员id_tableif (id)return 1;id = usb_match_dynamic_id(intf, usb_drv);if (id)return 1;}return 0;}

显然就是匹配USB驱动的id_table

2.2.10 USB驱动的id_table该如何定义

id_table的结构体为usb_device_id,如下所示：

参考/drivers/hid/usbhid/usbmouse.c(内核自带的USB鼠标驱动)，看它是如何使用的：

发现，它是通过**USB_INTERFACE_INFO()**这个宏定义的.该宏如下所示:

#define USB_INTERFACE_INFO(cl,sc,pr) \.match_flags = USB_DEVICE_ID_MATCH_INT_INFO, \ //设置id_table的.match_flags成员.bInterfaceClass = (cl), .bInterfaceSubClass = (sc), .bInterfaceProtocol = (pr)//设置id_table的3个成员,用于与匹配USB设备的3个成员

然后将上图里的usb_mouse_id_table []里的3个值代入宏**USB_INTERFACE_INFO(cl,sc,pr)**中：

.bInterfaceClass =USB_INTERFACE_CLASS_HID; //设置匹配USB的接口类型为HID类, 因为USB_INTERFACE_CLASS_HID=0x03//HID类是属于人机交互的设备,比如:USB键盘,USB鼠标,USB触摸板,USB游戏操作杆都要填入0X03.bInterfaceSubClass =USB_INTERFACE_SUBCLASS_BOOT; //设置匹配USB的接口子类型为启动设备.bInterfaceProtocol=USB_INTERFACE_PROTOCOL_MOUSE;//设置匹配USB的接口协议为USB鼠标的协议,等于2//当.bInterfaceProtocol=1也就是USB_INTERFACE_PROTOCOL_KEYBOARD时,表示USB键盘的协议

如下图,我们也可以通过windows上也可以找到鼠标的协议号,也是2:

其中VID:表示厂家(vendor)ID

PID:表示产品(Product) ID

总结：当我们插上USB设备时,系统就会获取USB设备的设备、配置、接口、端点的数据,并创建新设备,所以我们的驱动就需要写id_table来匹配该USB设备。

3、USB设备（鼠标）驱动编写

达到的目的：鼠标左键=按键L，鼠标右键=按键S，鼠标中键=回车键

.probe函数的结构：

1 分配input_dev2 设置3 注册硬件操作 使用USB总线驱动函数的读写函数来收发数据

怎么写USB设备驱动程序：

1 分配/设置usb_driver结构体 .name.id_table.probe.disconnect 2 注册

代码编写步骤如下：

0 定义全局变量：usb_driver结构体、input_dev指针结构体 、虚拟地址缓存区、DMA地址缓存区

1 在入口函数中

通过usb_register()函数注册usb_driver结构体

2 在usb_driver的probe函数中

分配一个input_dev结构体

设置input_dev支持L、S、回车、3个按键事件

注册input_dev结构体

设置USB数据传输:

->4.1)通过usb_rcvintpipe()创建一个接收中断类型的端点管道pipe，用于端点和数据缓冲区之间的连接

->4.2)通过usb_buffer_alloc()申请USB缓冲区

->4.3)申请并初始化urb结构体（urb:用来传输数据）

->4.4) 因为我们2440支持DMA,所以要告诉urb结构体,使用DMA缓冲区地址

->4.5)使用usb_submit_urb()提交urb

3 在鼠标中断函数中

1）判断缓存区数据是否改变，若改变则上传鼠标事件

2）使用usb_submit_urb()提交urb

4 在usb_driver的disconnect函数中

1)通过usb_kill_urb()杀掉提交到内核中的urb

2)释放urb

3)释放USB缓存区

4）注销input_device,释放input_device

5 在出口函数中

1）通过usb_deregister ()函数注销usb_driver结构体

3.1 先写驱动主框架

/** drivers\hid\usbhid\usbmouse.c*/#include <linux/kernel.h>#include <linux/slab.h>#include <linux/module.h>#include <linux/init.h>#include <linux/usb/input.h>#include <linux/hid.h>/* 1. 分配/设置usb_driver */static struct usb_driver usbmouse_as_key_driver = {.name= "usbmouse_as_key_",.probe= usbmouse_as_key_probe,.disconnect= usbmouse_as_key_disconnect,.id_table= usbmouse_as_key_id_table,};static int usbmouse_as_key_init(void){/* 2. 注册 */usb_register(&usbmouse_as_key_driver);return 0;}static void usbmouse_as_key_exit(void){usb_deregister(&usbmouse_as_key_driver);}module_init(usbmouse_as_key_init);module_exit(usbmouse_as_key_exit);MODULE_LICENSE("GPL");

3.2 编写.id_table

该USB设备驱动匹配的是接口描述符中的HID类 & BOOT子类 & MOUSE协议的设备。

static struct usb_device_id usbmouse_as_key_id_table[] = {{USB_INTERFACE_INFO(USB_INTERFACE_CLASS_HID,\USB_INTERFACE_SUBCLASS_BOOT,USB_INTERFACE_PROTOCOL_MOUSE)},//如果需要匹配USB设备的厂家和产品ID，可以添加{USB_DEVICE(0x1234,0x5678)},{}/* Terminating entry */};

3.3 编写.probe函数

开始的时候可以仅在该函数中打印一条语句，待整个架构测试通过后再逐步添加 。

static int usbmouse_as_key_probe(struct usb_interface *intf, const struct usb_device_id *id){struct usb_device *dev = interface_to_usbdev(intf);//获得usb设备信息/* 以下语句可以用来打印USB设备的厂家及产品id信息*printk("Found usbmouse!\n");*printk("bcdUSB = %x\n",dev->descriptor.bcdUSB); *printk("VID = 0X%x\n",dev->descriptor.idVendor); *printk("PID = 0X%x\n",dev->descriptor.idProduct); */struct usb_host_interface *interface;struct usb_endpoint_descriptor *endpoint;int pipe; interface = intf->cur_altsetting;if (interface->desc.nNumEndpoints != 1)//除了端点0之外，鼠标的端点数如果不是1的话，则返回错误return -ENODEV;endpoint = &interface->endpoint[0].desc;//得到第一个非零endpoint的描述符if (!usb_endpoint_is_int_in(endpoint))//如果不是中断输入型端点的话，返回错误return -ENODEV;/* a. 分配一个input_dev */uk_dev = input_allocate_device();//在文件开头先定义输入设备（input_dev）指针uk_dev/* b. 设置 *//* b.1 能产生哪类事件 */set_bit(EV_KEY, uk_dev->evbit);//能产生按键类事件set_bit(EV_REP, uk_dev->evbit);//能产生按键的重复类事件/* b.2 能产生哪些事件 */set_bit(KEY_L, uk_dev->keybit);set_bit(KEY_S, uk_dev->keybit);set_bit(KEY_ENTER, uk_dev->keybit);/* c. 注册 */input_register_device(uk_dev);/* d. 硬件相关操作 *//* 数据传输“三要素”: 源,目的,长度 *//* 1源: USB设备的某个端点 */pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);/* 2长度: 要在文件开头定义一个长度变量,int len*/len = endpoint->wMaxPacketSize;/* 3目的: (1.在文件开头定义一个字符串指针,char * usb_buf) * (2.在文件开头定义一个usb_buf的物理地址，dma_addr_t * usb_buf_phys)*/usb_buf = usb_alloc_coherent(dev, len, GFP_ATOMIC, &usb_buf_phys);/* 使用"3要素" *//* 1分配usb request block */uk_urb = usb_alloc_urb(0, GFP_KERNEL);//先要在文件开头定义一个urb指针,即urb * uk_urb/* 2使用之前的三要素设置urb" */usb_fill_int_urb(uk_urb, dev, pipe, usb_buf, len, usbmouse_as_key_irq, NULL, endpoint->bInterval);uk_urb->transfer_dma = usb_buf_phys;uk_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;/* 3使用URB */usb_submit_urb(uk_urb, GFP_KERNEL);return 0;}

3.4 编写USB中断函数

当USB主机周期性（j间隔endpoint->bInterval）的从设备获得数据，并存入到usb buffer中，同时USB主机控制器会向CPU产生中断，并调用usb中断处理函数：

static void usbmouse_as_key_irq(struct urb *urb){//为了调试，先打印usb_buf中的数据#if 0int i;static int cnt = 0;printk("data cnt %d: ", ++cnt);//usb_buf[]里存放的是鼠标按键值、x坐标、y坐标和滚轮的值for (i = 0; i < len; i++){printk("%02x ", usb_buf[i]);}printk("\n");#endif//上报事件（USB总线驱动是不知道usb数据含义的，只有在USB设备驱动中加以解析）#if 1/* USB鼠标数据含义* data[0]: bit0-左键(1-按下, 0-松开)*bit1-右键(1-按下, 0-松开)*bit2-中键(1-按下, 0-松开)*/static unsigned char pre_val;if ((pre_val & (1<<0)) != (usb_buf[0] & (1<<0)))//如果上次数据的Bit0不等于现在的值{/* 左键发生了变化 */input_event(uk_dev, EV_KEY, KEY_L, (usb_buf[0] & (1<<0)) ? 1 : 0);input_sync(uk_dev);}if ((pre_val & (1<<1)) != (usb_buf[0] & (1<<1))){/* 右键发生了变化 */input_event(uk_dev, EV_KEY, KEY_S, (usb_buf[0] & (1<<1)) ? 1 : 0);input_sync(uk_dev);}if ((pre_val & (1<<2)) != (usb_buf[0] & (1<<2))){/* 中键发生了变化 */input_event(uk_dev, EV_KEY, KEY_ENTER, (usb_buf[0] & (1<<2)) ? 1 : 0);input_sync(uk_dev);}pre_val = usb_buf[0];#endif/* 重新提交urb */usb_submit_urb(uk_urb, GFP_KERNEL);}

3.5 编写.disconnect函数

开始的时候可以仅在该函数中打印一条语句，待整个架构测试通过后再逐步添加。

static void usbmouse_as_key_disconnect(struct usb_interface *intf){struct usb_device *dev = interface_to_usbdev(intf);//printk("disconnect usbmouse!\n");usb_kill_urb(uk_urb);//杀死urbusb_free_urb(uk_urb);//释放urbusb_free_coherent(dev, len, usb_buf, usb_buf_phys);//释放usb bufferinput_unregister_device(uk_dev);input_free_device(uk_dev);}

4、测试

4.1 去掉内核鼠标驱动支持

cd linux3.4.2make menuconfig->Device Drivers->HID Devices-> <>USB Human Interface Device (full HID) supportmake uImage

4.2 使用新内核启动开发板

tftp 30000000 uImage//将新的内核复制到tftp共享目录后，下载到开发板内核//nfs 30000000 主机IP:/nfs_root/uImage//或者使用nfs命令下载新内核bootm 30000000//从内核的30000000地址处启动内核

4.3 安装自己编译的USB设备驱动

mount -t nfs -o nolock 主机IP:/nfs_root /mnt//挂接网络文件系统insmod usbmouse_as_key.ko//内核启动后，安装自己编译的USB设备驱动

4.4 测试

在开发板上接入、拔出USB鼠标，观察串口输出将鼠标当作键盘，输入ls+回车命令

# ls /dev/event*//观察当前系统有没有其它event设备ls:/dev/event*:No such file or directory接上USB鼠标usb 1-1:configuration #1 chosen from 1 choiceinput:Unspecified device as /class/input/input0# ls /dev/event*/dev/event0//对应我们刚接上去的鼠标# cat /dev/tty1 //将鼠标作为键盘，观察tty1口输出l(按下左键)s(按下右键)（按下回车）llllll（按住左键）

5、整体代码

usbmouse_as_key.c

/** drivers\hid\usbhid\usbmouse.c*/#include <linux/kernel.h>#include <linux/slab.h>#include <linux/module.h>#include <linux/init.h>#include <linux/usb/input.h>#include <linux/hid.h>static struct input_dev *uk_dev;static char *usb_buf;//使用虚拟地址的usb bufferstatic dma_addr_t usb_buf_phys;//使用物理地址的DMA缓冲区static int len;//usb buffer 的大小static struct urb *uk_urb;//usb请求块static struct usb_device_id usbmouse_as_key_id_table [] = {{USB_INTERFACE_INFO(USB_INTERFACE_CLASS_HID, USB_INTERFACE_SUBCLASS_BOOT,USB_INTERFACE_PROTOCOL_MOUSE) },//{USB_DEVICE(0x1234,0x5678)},{}/* Terminating entry */};static void usbmouse_as_key_irq(struct urb *urb){static unsigned char pre_val;#if 0int i;static int cnt = 0;printk("data cnt %d: ", ++cnt);for (i = 0; i < len; i++){printk("%02x ", usb_buf[i]);}printk("\n");#endif/* USB鼠标数据含义* data[0]: bit0-左键, 1-按下, 0-松开*bit1-右键, 1-按下, 0-松开*bit2-中键, 1-按下, 0-松开 **/if ((pre_val & (1<<0)) != (usb_buf[0] & (1<<0))){/* 左键发生了变化 */input_event(uk_dev, EV_KEY, KEY_L, (usb_buf[0] & (1<<0)) ? 1 : 0);input_sync(uk_dev);}if ((pre_val & (1<<1)) != (usb_buf[0] & (1<<1))){/* 右键发生了变化 */input_event(uk_dev, EV_KEY, KEY_S, (usb_buf[0] & (1<<1)) ? 1 : 0);input_sync(uk_dev);}if ((pre_val & (1<<2)) != (usb_buf[0] & (1<<2))){/* 中键发生了变化 */input_event(uk_dev, EV_KEY, KEY_ENTER, (usb_buf[0] & (1<<2)) ? 1 : 0);input_sync(uk_dev);}pre_val = usb_buf[0];/* 重新提交urb */usb_submit_urb(uk_urb, GFP_KERNEL);}static int usbmouse_as_key_probe(struct usb_interface *intf, const struct usb_device_id *id){struct usb_device *dev = interface_to_usbdev(intf);struct usb_host_interface *interface;struct usb_endpoint_descriptor *endpoint;int pipe;interface = intf->cur_altsetting;endpoint = &interface->endpoint[0].desc;/* a. 分配一个input_dev */uk_dev = input_allocate_device();/* b. 设置 *//* b.1 能产生哪类事件 */set_bit(EV_KEY, uk_dev->evbit);set_bit(EV_REP, uk_dev->evbit);/* b.2 能产生哪些事件 */set_bit(KEY_L, uk_dev->keybit);set_bit(KEY_S, uk_dev->keybit);set_bit(KEY_ENTER, uk_dev->keybit);/* c. 注册 */input_register_device(uk_dev);/* d. 硬件相关操作 *//* 数据传输3要素: 源,目的,长度 *//* 源: USB设备的某个端点 */pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);/* 长度: */len = endpoint->wMaxPacketSize;/* 目的: */usb_buf = usb_alloc_coherent(dev, len, GFP_ATOMIC, &usb_buf_phys);/* 使用"3要素" *//* 分配usb request block */uk_urb = usb_alloc_urb(0, GFP_KERNEL);/* 使用"3要素设置urb" */usb_fill_int_urb(uk_urb, dev, pipe, usb_buf, len, usbmouse_as_key_irq, NULL, endpoint->bInterval);uk_urb->transfer_dma = usb_buf_phys;uk_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;/* 使用URB */usb_submit_urb(uk_urb, GFP_KERNEL);return 0;}static void usbmouse_as_key_disconnect(struct usb_interface *intf){struct usb_device *dev = interface_to_usbdev(intf);//printk("disconnect usbmouse!\n");usb_kill_urb(uk_urb);usb_free_urb(uk_urb);usb_free_coherent(dev, len, usb_buf, usb_buf_phys);input_unregister_device(uk_dev);input_free_device(uk_dev);}/* 1. 分配/设置usb_driver */static struct usb_driver usbmouse_as_key_driver = {.name= "usbmouse_as_key_",.probe= usbmouse_as_key_probe,.disconnect= usbmouse_as_key_disconnect,.id_table= usbmouse_as_key_id_table,};static int usbmouse_as_key_init(void){/* 2. 注册 */usb_register(&usbmouse_as_key_driver);return 0;}static void usbmouse_as_key_exit(void){usb_deregister(&usbmouse_as_key_driver);}module_init(usbmouse_as_key_init);module_exit(usbmouse_as_key_exit);MODULE_LICENSE("GPL");

Makefile文件：

KERN_DIR = /home/leon/linux-3.4.2all:make -C $(KERN_DIR) M=`pwd` modules clean:make -C $(KERN_DIR) M=`pwd` modules cleanrm -rf modules.orderobj-m+= usbmouse_as_key.o