Linux 驱动开发之USB设备分析7（基于Linux6.6）---USB鼠标驱动介绍
一、概述
1. USB 鼠标的工作原理
USB 鼠标作为一个输入设备，通过 USB 总线与计算机进行通信。它通过 USB 协议与操作系统的驱动程序交互，传递用户的操作数据（如移动、点击、滚动等）。
基本工作流程：
- 设备插入：当鼠标连接到计算机的 USB 端口时，USB 控制器（USB 主机控制器）会通过 USB 总线识别该设备。
- 设备枚举：内核通过 USB 子系统识别设备，并加载相应的驱动程序。USB 鼠标属于 HID 设备类型，Linux 会加载通用的 HID 驱动。
- 数据传输：鼠标传递输入数据（如 X、Y 坐标、按钮状态等）给操作系统，操作系统根据这些数据更新用户界面。
- 用户操作响应：操作系统或应用程序根据接收到的输入数据作出相应的处理。
2. USB 鼠标驱动概述
在 Linux 中，USB 鼠标的驱动程序依赖于 HID 驱动框架。所有支持 HID 协议的设备，包括 USB 鼠标、键盘、游戏手柄等，都通过这个通用框架进行驱动和管理。
主要模块和驱动：
usbcore：这是 Linux USB 子系统的核心模块，负责管理所有 USB 设备的连接、设备枚举以及设备的启动/停止等。usbhid：这是负责 HID 设备（包括 USB 鼠标）的通用驱动模块。当 USB 鼠标插入时，usbhid驱动会被加载。hid：HID 子系统的核心模块，提供对 HID 协议的支持，包括对不同 HID 设备的通用处理（如解析报告描述符、处理输入数据等）。
当 USB 鼠标被连接到计算机时，系统首先通过 usbcore 识别并加载 usbhid 驱动。然后，鼠标的数据会通过 HID 协议传输，并由 Linux 内核中的 HID 子系统处理，最终交给输入子系统（input subsystem），供用户空间的应用程序使用。
3. USB 鼠标驱动的工作流程
-
USB 设备枚举： 当 USB 鼠标插入时，
usbcore负责检测并枚举该设备。如果设备符合 HID 协议，内核会自动加载usbhid驱动。 -
HID 协议解析：
usbhid驱动会读取设备的 报告描述符（Report Descriptor），该描述符定义了设备传输的数据格式。例如，鼠标的数据通常包括位置坐标（X、Y），按钮状态（按下或松开），滚轮状态等。 -
输入事件处理： 一旦鼠标的数据被解析，内核会通过 输入子系统（Input Subsystem） 将数据传递到用户空间。输入子系统负责生成标准化的输入事件（如鼠标移动、点击等），并将其转发给应用程序。
-
设备移除： 当 USB 鼠标被拔出时，内核会通过
usbcore卸载usbhid驱动，并释放相关资源。
4. USB 鼠标驱动的关键部分
-
HID 驱动框架：
hid-core.c：HID 子系统的核心，提供解析 HID 报告描述符和处理 HID 数据流的功能。hid-input.c：负责将 HID 数据转化为标准化的输入事件，并交给 Linux 输入子系统处理。usbhid.c：专门为 USB HID 设备编写的驱动，管理 USB HID 设备的初始化、数据传输等。
-
输入子系统（Input Subsystem）：
- 通过
input子系统，USB 鼠标生成的事件（如鼠标移动、点击等）会被传递到用户空间，通常由 X11、Wayland 或其他图形界面系统进行处理。
- 通过
二、驱动加载部分
drivers/hid/usbhid/usbmouse.c
其中usb_mouse_driver的定义为：
static const struct usb_device_id usb_mouse_id_table[] = {
{ USB_INTERFACE_INFO(USB_INTERFACE_CLASS_HID, USB_INTERFACE_SUBCLASS_BOOT,
USB_INTERFACE_PROTOCOL_MOUSE) },
{ } /* Terminating entry */
};
MODULE_DEVICE_TABLE (usb, usb_mouse_id_table);
static struct usb_driver usb_mouse_driver = {
.name = "usbmouse",
.probe = usb_mouse_probe,
.disconnect = usb_mouse_disconnect,
.id_table = usb_mouse_id_table,
};
module_usb_driver(usb_mouse_driver);如果注册成功的话，将会调用usb_mouse_probe。那么什么时候才算注册成功呢？
和其它驱动注册过程一样，只有在其对应的“总线”上发现匹配的“设备”才会调用probe。总线匹配的方法和具体总线相关，如：platform_bus_type中是判断驱动名称和平台设备名称是否相同；那如何确认usb总线的匹配方法呢？
Usb设备是注册在usb_bus_type总线下的。查看usb_bus_type的匹配方法。
struct bus_type usb_bus_type = {
.name = "usb",
.match = usb_device_match,
.hotplug = usb_hotplug,
.suspend = usb_generic_suspend,
.resume = usb_generic_resume,
};其中usb_device_match定义了匹配方法
static int usb_device_match (struct device *dev, struct device_driver *drv)
{
struct usb_interface *intf;
struct usb_driver *usb_drv;
const struct usb_device_id *id;
/* check for generic driver, which we don't match any device with */
if (drv == &usb_generic_driver)
return 0;
intf = to_usb_interface(dev);
usb_drv = to_usb_driver(drv);
id = usb_match_id (intf, usb_drv->id_table);
if (id)
return 1;
return 0;
}可以看出usb的匹配方法是usb_match_id (intf, usb_drv->id_table)，也就是说通过比对“dev中intf信息”和“usb_drv->id_table信息”，如果匹配则说明驱动所对应的设备已经添加到总线上了，所以接下了就会调用drv中的probe方法注册usb设备驱动。
usb_mouse_id_table的定义为：
static const struct usb_device_id usb_mouse_id_table[] = {
{ USB_INTERFACE_INFO(USB_INTERFACE_CLASS_HID, USB_INTERFACE_SUBCLASS_BOOT,
USB_INTERFACE_PROTOCOL_MOUSE) },
{ } /* Terminating entry */
};
#define USB_INTERFACE_INFO(cl,sc,pr) /
.match_flags = USB_DEVICE_ID_MATCH_INT_INFO, /
.bInterfaceClass = (cl), /
.bInterfaceSubClass = (sc), /
.bInterfaceProtocol = (pr)鼠标设备遵循USB人机接口设备（HID），在HID规范中规定鼠标接口类码为：
接口类：0x03
接口子类：0x01
接口协议：0x02
这样分类的好处是设备厂商可以直接利用标准的驱动程序。除了HID类以外还有Mass storage、printer、audio等
#define USB_DEVICE_ID_MATCH_INT_INFO /
(USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS | USB_DEVICE_ID_MATCH_INT_PROTOCOL)匹配的过程为：
usb_match_id(struct usb_interface *interface, const struct usb_device_id *id)
{
struct usb_host_interface *intf;
struct usb_device *dev;
/* proc_connectinfo in devio.c may call us with id == NULL. */
if (id == NULL)
return NULL;
intf = interface->cur_altsetting;
dev = interface_to_usbdev(interface);
/* It is important to check that id->driver_info is nonzero,
since an entry that is all zeroes except for a nonzero
id->driver_info is the way to create an entry that
indicates that the driver want to examine every
device and interface. */
for (; id->idVendor || id->bDeviceClass || id->bInterfaceClass ||
id->driver_info; id++) {
if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
id->idVendor != le16_to_cpu(dev->descriptor.idVendor))
continue;
if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) &&
id->idProduct != le16_to_cpu(dev->descriptor.idProduct))
continue;
/* No need to test id->bcdDevice_lo != 0, since 0 is never greater than any unsigned number. */
if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) &&
(id->bcdDevice_lo > le16_to_cpu(dev->descriptor.bcdDevice)))
continue;
if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) &&
(id->bcdDevice_hi < le16_to_cpu(dev->descriptor.bcdDevice)))
continue;
if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) &&
(id->bDeviceClass != dev->descriptor.bDeviceClass))
continue;
if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) &&
(id->bDeviceSubClass!= dev->descriptor.bDeviceSubClass))
continue;
if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) &&
(id->bDeviceProtocol != dev->descriptor.bDeviceProtocol))
continue;
//接口类
if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&
(id->bInterfaceClass != intf->desc.bInterfaceClass))
continue;
//接口子类
if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) &&
(id->bInterfaceSubClass != intf->desc.bInterfaceSubClass))
continue;
//遵循的协议
if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) &&
(id->bInterfaceProtocol != intf->desc.bInterfaceProtocol))
continue;
return id;
}
return NULL;
}
从中可以看出，只有当设备的接口类、接口子类、接口协议匹配鼠标驱动时鼠标驱动才会调用probe方法。
三、probe部分
static int usb_mouse_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;
struct usb_mouse *mouse;
int pipe, maxp;
char path[64];
interface = intf->cur_altsetting;
/* 以下是网络的一段对cur_altsettin的解释，下面就借花献佛。usb 设备有一个configuration 的概念,表示配置，一个设备可以有多个配置，但只能同时激活一个，如：一些设备可以下载固件，或可以设置不同的全局模式，就像手机可以被设定为静音模式或响铃模式一样。而这里又有一个setting,咋一看有些奇怪,这两个词不是一回事吗.还是拿我们最熟悉的手机来打比方,configuration 不说了,setting,一个手机可能各种配置都确定了,是振动还是铃声已经确定了,各种功能都确定了,但是声音的大小还可以变吧,通常手机的音量是一格一格的变动,大概也就5,6 格,那么这个可以算一个setting 吧.这里cur_altsetting 就是表示的当前的这个setting,或者说设置。可以查看原码中usb_interface 结构定义的说明部分。从说明中可以看到一个接口可以有多种setting*/
if (interface->desc.bNumEndpoints != 1)
return -ENODEV;
/*根据HID规则，期望鼠标只有一个端点即中断端点bNumEndpoints 就是接口描述符中的成员,表示这个接口有多少个端点，不过这其中不包括0 号端点，0号端点是任何一个usb 设备都必须是提供的,这个端点专门用于进行控制传输,即它是一个控制端点.正因为如此,所以即使一个设备没有进行任何设置，usb 主机也可以开始跟它进行一些通信,因为即使不知道其它的端点，但至少知道它一定有一个0号端点，或者说一个控制端点。
*/
endpoint = &interface->endpoint[0].desc;//端点0描述符，此处的0表示中断端点
if (!(endpoint->bEndpointAddress & 0x80))
return -ENODEV;
/*先看bEndpointAddress,这个struct usb_endpoint_descriptor 中的一个成员,是8个bit，或者说1 个byte，其中bit7 表示 *的是这个端点的方向，0 表示OUT，1 表示IN，OUT 与IN 是对主机而言。OUT 就是从主机到设备，IN 就是从设备到主机。而宏
*USB_DIR_IN 来自
*include/linux/usb_ch9.h
* USB directions
* This bit flag is used in endpoint descriptors' bEndpointAddress field.
* It's also one of three fields in control requests bRequestType.
*#define USB_DIR_OUT 0 /* to device */
*#define USB_DIR_IN 0x80 /* to host */
*/
if ((endpoint->bmAttributes & 3) != 3)? //判断是否是中断类型
return -ENODEV;
/* bmAttributes 表示属性,总共8位,其中bit1和bit0 共同称为Transfer Type,即传输类型,即00 表示控制,01 表示等时,10 表示批量,11 表示中断*/
pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);//构造中断端点的输入pipe
maxp = usb_maxpacket(dev, pipe, usb_pipeout(pipe));
/*跟踪usb_maxpacket
usb_maxpacket(struct usb_device *udev, int pipe, int is_out)
{
struct usb_host_endpoint *ep;
unsigned epnum = usb_pipeendpoint(pipe);
/*
得到的自然就是原来pipe 里边的15 至18 位.一个pipe 的15 位至18 位是endpoint 号,(一共16 个endpoint,)所以很显然,这里就是得到endpoint 号
*/
if (is_out) {
WARN_ON(usb_pipein(pipe));
ep = udev->ep_out[epnum];
} else {
WARN_ON(usb_pipeout(pipe));
ep = udev->ep_in[epnum];
}
if (!ep)
return 0;
/* NOTE:? only 0x07ff bits are for packet size... */
return le16_to_cpu(ep->desc.wMaxPacketSize);
}
*/
//返回对应端点能够传输的最大的数据包，鼠标的返回的最大数据包为4个字节，
第0个字节：bit 0、1、2、3、4分别代表左、右、中、SIDE、EXTRA键的按下情况
第1个字节：表示鼠标的水平位移
第2个字节：表示鼠标的垂直位移
第3个字节：REL_WHEEL位移
if (!(mouse = kmalloc(sizeof(struct usb_mouse), GFP_KERNEL)))
return -ENOMEM;
memset(mouse, 0, sizeof(struct usb_mouse));
mouse->data = usb_buffer_alloc(dev, 8, SLAB_ATOMIC, &mouse->data_dma);
/*
申请用于urb用于数据传输的内存，注意：这里将返回“mouse->data”和“mouse->data_dma”
mouse->data：记录了用于普通传输用的内存指针
mouse->data_dma：记录了用于DMA传输的内存指针
如果是DMA 方式的传输，那么usb core 就应该使用mouse->data_dma
*/
if (!mouse->data) {
kfree(mouse);
return -ENOMEM;
}
mouse->irq = usb_alloc_urb(0, GFP_KERNEL);
if (!mouse->irq) {
usb_buffer_free(dev, 8, mouse->data, mouse->data_dma);
kfree(mouse);
return -ENODEV;
}
mouse->usbdev = dev;
mouse->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_REL);
//设置input系统响应按键和REL（相对结果）事件
mouse->dev.keybit[LONG(BTN_MOUSE)] = BIT(BTN_LEFT) | BIT(BTN_RIGHT) | BIT(BTN_MIDDLE);
mouse->dev.relbit[0] = BIT(REL_X) | BIT(REL_Y);
mouse->dev.keybit[LONG(BTN_MOUSE)] |= BIT(BTN_SIDE) | BIT(BTN_EXTRA);
mouse->dev.relbit[0] |= BIT(REL_WHEEL);
//设置input系统响应的码表及rel表
mouse->dev.private = mouse;
mouse->dev.open = usb_mouse_open;
mouse->dev.close = usb_mouse_close;
usb_make_path(dev, path, 64);
sprintf(mouse->phys, "%s/input0", path);
mouse->dev.name = mouse->name;
mouse->dev.phys = mouse->phys;
usb_to_input_id(dev, &mouse->dev.id);
/*
usb_to_input_id(const struct usb_device *dev, struct input_id *id)
{
id->bustype = BUS_USB;
id->vendor = le16_to_cpu(dev->descriptor.idVendor);
id->product = le16_to_cpu(dev->descriptor.idProduct);
id->version = le16_to_cpu(dev->descriptor.bcdDevice);
}
struct usb_device 中有一个成员struct usb_device_descriptor,而struct usb_device_descriptor 中的成员__u16 bcdDevice,表示的是制造商指定的产品的版本号,制造商id 和产品id 来标志一个设备.bcdDevice 一共16 位,是以bcd码的方式保存的信息,也就是说,每4 位代表一个十进制的数,比如0011 0110 1001 0111 就代表的3697.
业内为每家公司编一个号,这样便于管理,比如三星的编号就是0x0839,那么三星的产品中就会在其设备描述符中idVendor 的烙上0x0839.而三星自己的每种产品也会有个编号,和Digimax 410 对应的编号就是0x000a,而bcdDevice_lo 和bcdDevice_hi 共同组成一个具体设备的编号(device release
number),bcd 就意味着这个编号是二进制的格式.
*/
mouse->dev.dev = &intf->dev;
if (dev->manufacturer)
strcat(mouse->name, dev->manufacturer);
if (dev->product)
sprintf(mouse->name, "%s %s", mouse->name, dev->product);
if (!strlen(mouse->name))
sprintf(mouse->name, "USB HIDBP Mouse %04x:%04x",
mouse->dev.id.vendor, mouse->dev.id.product);
usb_fill_int_urb(mouse->irq, dev, pipe, mouse->data,
(maxp > 8 ? 8 : maxp),
usb_mouse_irq, mouse, endpoint->bInterval);
/*
static inline 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)
{
spin_lock_init(&urb->lock);
urb->dev = dev;
urb->pipe = pipe;
urb->transfer_buffer = transfer_buffer;//如果不使用DMA传输方式，则使用这个缓冲指针。如何用DMA则使用transfer_DMA，这个值会在后面单独给URB赋
urb->transfer_buffer_length = buffer_length;
urb->complete = complete;
urb->context = context;
if (dev->speed == USB_SPEED_HIGH)
urb->interval = 1 << (interval - 1);
else
urb->interval = interval;
urb->start_frame = -1;
}
此处只是构建好一个urb，在open方法中会实现向usb core递交urb
*/
mouse->irq->transfer_dma = mouse->data_dma;
mouse->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
/*
#define URB_NO_TRANSFER_DMA_MAP 0x0004? //urb->transfer_dma valid on submit
#define URB_NO_SETUP_DMA_MAP??? 0x0008? //urb->setup_dma valid on submit
, 这里是两个DMA 相关的flag,一个是URB_NO_SETUP_DMA_MAP,而另一个是
URB_NO_TRANSFER_DMA_MAP.注意这两个是不一样的,前一个是专门为控制传输准备的,因为只有控制传输需要有这么一个setup 阶段需要准备一个setup packet。
transfer_buffer 是给各种传输方式中真正用来数据传输的,而setup_packet 仅仅是在控制传输中发送setup 的包,控制传输除了setup 阶段之外,也会有数据传输阶段,这一阶段要传输数据还是得靠transfer_buffer,而如果使用dma 方式,那么就是使用transfer_dma.
因为这里使用了mouse->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP,所以应该给urb的transfer_dma赋值。所以用了：
mouse->irq->transfer_dma = mouse->data_dma;
*/
input_register_device(&mouse->dev);
//向input系统注册input设备
printk(KERN_INFO "input: %s on %s/n", mouse->name, path);
usb_set_intfdata(intf, mouse);
/*
usb_set_intfdata().的结果就是使得
%intf->dev->driver_data= mouse,而其它函数中会调用usb_get_intfdata(intf)的作用就是把mouse从中取出来
*/
return 0;
}四、open部分
当应用层打开鼠标设备时，usb_mouse_open将被调用
static int usb_mouse_open(struct input_dev *dev)
{
struct usb_mouse *mouse = dev->private;
mouse->irq->dev = mouse->usbdev;
if (usb_submit_urb(mouse->irq, GFP_KERNEL))
return -EIO;
//向usb core递交了在probe中构建好的中断urb，注意：此处是成功递交给usb core以后就返回，而不是等到从设备取得鼠标数据。
return 0;
}五、usb回调函数处理部分
当出现传输错误或获取到鼠标数据后，urb回调函数将被执行
static void usb_mouse_irq(struct urb *urb, struct pt_regs *regs)
{
struct usb_mouse *mouse = urb->context;
//在usb_fill_int_urb中有对urb->context赋值
signed char *data = mouse->data;
struct input_dev *dev = &mouse->dev;
int status;
switch (urb->status) {
case 0: /* success */
break;
case -ECONNRESET: /* unlink */
case -ENOENT:
case -ESHUTDOWN:
return;
/* -EPIPE:? should clear the halt */
default: /* error */
goto resubmit;
}
input_regs(dev, regs);
input_report_key(dev, BTN_LEFT, data[0] & 0x01);
input_report_key(dev, BTN_RIGHT, data[0] & 0x02);
input_report_key(dev, BTN_MIDDLE, data[0] & 0x04);
input_report_key(dev, BTN_SIDE, data[0] & 0x08);
input_report_key(dev, BTN_EXTRA, data[0] & 0x10);
//向input系统报告key事件，分别是鼠标LEFT、RIGHT、MIDDLE、SIDE、EXTRA键,
static inline void input_report_key(struct input_dev *dev, unsigned int code, int value)中的value非0时表示按下，0表示释放
input_report_rel(dev, REL_X, data[1]);
input_report_rel(dev, REL_Y, data[2]);
input_report_rel(dev, REL_WHEEL, data[3]);
//向input系统报告rel事件，分别是x方向位移、y方向位移、wheel值
input_sync(dev);
//最后需要向事件接受者发送一个完整的报告。这是input系统的要求。
resubmit:
status = usb_submit_urb (urb, SLAB_ATOMIC);
//重新递交urb
if (status)
err ("can't resubmit intr, %s-%s/input0, status %d",
mouse->usbdev->bus->bus_name,
mouse->usbdev->devpath, status);
}六、应用层测试代码编写
在应用层编写测试鼠标的测试程序，在我的系统中，鼠标设备为/dev/input/event3. 测试代码如下：
/*
* usb_mouse_test.c
* by lht
*/
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <linux/input.h>
int main (void)
{
int fd,i,count;
struct input_event ev_mouse[2];
fd = open ("/dev/input/event3",O_RDWR);
if (fd < 0) {
printf ("fd open failed/n");
exit(0);
}
printf ("/nmouse opened, fd=%d/n",fd);
while(1)
{
printf(".............................................../n");
count=read(fd, ev_mouse, sizeof(struct input_event));
for(i=0;i<(int)count/sizeof(struct input_event);i++)
{
printf("type=%d/n",ev_mouse[i].type);
if(EV_REL==ev_mouse[i].type)
{
printf("time:%ld.%d",ev_mouse[i].time.tv_sec,ev_mouse[i].time.tv_usec);
printf(" type:%d code:%d value:%d/n",ev_mouse[i].type,ev_mouse[i].code,ev_mouse[i].value);
}
if(EV_KEY==ev_mouse[i].type)
{
printf("time:%ld.%d",ev_mouse[i].time.tv_sec,ev_mouse[i].time.tv_usec);
printf(" type:%d code:%d value:%d/n",ev_mouse[i].type,ev_mouse[i].code,ev_mouse[i].value);
}
}
}
close (fd);
return 0;
}七、总结
1. 设备初始化模块
设备初始化模块负责检测并初始化 USB 鼠标硬件设备，确保设备可以正确地与系统进行交互。
关键模块：
usbcore：这是 Linux USB 子系统的核心模块，负责 USB 设备的管理。它在设备插入时进行设备识别，并在需要时加载适当的驱动模块。usbhid：这是专门为 USB HID 设备（包括 USB 鼠标）提供的驱动模块。usbhid会在 USB 设备插入后被加载，并管理与 HID 设备的通信。hid-core：负责 HID 协议的数据解析和处理。
工作流程：
- 设备插入：USB 鼠标插入时，USB 主机控制器通过
usbcore进行设备检测。 - 驱动加载：
usbcore根据设备信息，自动加载usbhid驱动模块。 - HID 报告解析：
usbhid驱动会解析 USB 鼠标的 HID 报告描述符，确定鼠标的功能。 - 设备注册：通过 HID 子系统，鼠标作为输入设备被注册到 Linux 输入子系统。
2. 数据传输模块
数据传输模块负责从 USB 鼠标获取数据并传输给系统进行处理。
关键模块：
usbhid：负责从 USB 鼠标读取数据并通过 HID 协议与系统进行通信。usbhid使用中断传输方式（Interrupt Transfer）来定期从鼠标获取数据。hid：HID 协议的核心部分，解析来自鼠标的数据，并将其转换为标准输入事件。
工作流程：
- 设备数据传输：USB 鼠标将通过 USB 中断传输模式定期向主机传输数据（如位置坐标、按钮状态等）。
- 数据解析：
hid-core解析鼠标传输的原始数据（根据 HID 报告描述符），然后通过输入子系统转换为标准的输入事件。 - 输入事件处理：鼠标的输入事件（如移动、点击、滚动）被传递到 Linux 输入子系统，然后传递到上层软件（如 X11 或 Wayland）进行处理。
3. 上层软件接口模块
上层软件接口模块负责处理从鼠标传递的输入事件，并根据这些事件进行图形界面的更新或其他用户交互。
关键模块：
- 输入子系统（
input）：这个模块负责接收设备驱动传递的输入事件，将其转化为用户可以理解的标准事件。 xf86-input-evdev：这是 X11 中的输入驱动，负责处理来自各种输入设备（包括 USB 鼠标）的事件，并传递到 X11 服务器。- Wayland/桌面环境：Wayland 或桌面环境中的输入模块（如 GNOME、KDE）会根据输入事件更新光标位置或触发相应的交互操作。
工作流程：
- 输入事件生成：
hid-core生成的标准化输入事件会被传递到 Linux 输入子系统。 - 上层应用处理：输入事件最终会被上层应用（如 X11、Wayland 或桌面环境）接收并做出响应，例如光标的移动、点击的响应等。
4. 设备卸载模块
设备卸载模块负责在 USB 鼠标断开时卸载驱动模块并清理资源。
关键模块：
usbcore：在 USB 鼠标被拔出时，usbcore会负责卸载驱动模块。usbhid：usbhid驱动在设备拔出时会被卸载，并释放所有与设备相关的资源。hid-core：hid-core负责清理 HID 协议相关的数据和结构。
工作流程：
- 设备拔出：当 USB 鼠标被拔出时，
usbcore会识别到设备的断开，并卸载相关驱动模块（如usbhid）。 - 资源释放：
usbhid和hid-core会释放设备占用的资源，例如中断请求和输入事件处理资源。
5. USB 鼠标驱动模块的总结与流程图
驱动模块的整体总结：
- 设备初始化模块：
usbcore和usbhid驱动通过 USB 识别、设备枚举，加载 HID 驱动并初始化鼠标设备。 - 数据传输模块：通过
usbhid和hid-core获取鼠标输入数据，并转换为输入事件。 - 上层软件接口模块：输入事件通过 Linux 输入子系统传递给上层应用（如 X11、Wayland）进行图形界面更新。
- 卸载模块：设备断开后，
usbcore和usbhid会卸载驱动并释放资源。
工作流程图：
+-------------------+ +----------------+ +-----------------------+
| USB 鼠标插入 | ------> | usbcore | ------> | usbhid 驱动加载 |
| (设备检测) | | (设备管理) | | (设备初始化) |
+-------------------+ +----------------+ +-----------------------+
| | |
v v v
+-------------------+ +----------------+ +-----------------------+
| HID 报告描述符解析 | <------ | hid-core | <------ | USB 数据传输（中断） |
| (数据格式解析) | | (协议解析) | | (鼠标输入数据传输) |
+-------------------+ +----------------+ +-----------------------+
| | |
v v v
+-------------------+ +----------------+ +-----------------------+
| 输入事件生成 | <------ | input 子系统 | <------ | 上层软件接口 |
| (光标移动、点击) | | (输入事件处理) | | (X11、Wayland 等) |
+-------------------+ +----------------+ +-----------------------+
| |
v v
+-------------------+ +-----------------------+
| 设备拔出 | ------> | usbcore 卸载驱动 | <------ | usbhid 卸载与资源释放 |
| (设备断开) | | (驱动卸载与清理) | | (释放资源) |
+-------------------+ +----------------+ +-----------------------+
总结：
Linux 系统通过 usbcore、usbhid、hid-core 和 input 等多个模块合作，实现了对 USB 鼠标的支持。从设备插入到驱动加载、数据传输和输入事件的生成，整个流程自动化处理。在设备拔出时，系统也会进行驱动卸载和资源释放。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
