Linux内核输入子系统框架_输入子系统驱动框架-优快云博客

本文链接：https://blog.youkuaiyun.com/Bin_Watson/article/details/125991683

本文详细剖析了Linux内核输入子系统的工作流程，包括input_handler和input_dev的注册、连接建立以及事件处理机制。输入子系统通过input_handler与input_dev建立多对多的连接，并通过handle结构体进行交互。当设备有事件时，input_event函数被调用，触发相应的handler处理事件。整个框架确保了应用程序能够间接访问并处理设备事件。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

正常的字符设备驱动程序框架：

设置 major 设备号
填充 file_operations 结构体
register_chrdev 注册字符设备驱动程序
编写 init 入口函数和 exit 出口函数

输入子系统驱动程序的大致流程与我们自己写的字符设备驱动程序是一样的。

1. 输入子系统框架分析

1.1 init 函数

static int __init input_init(void)
{
	/*...省略...*/
	err = class_register(&input_class);
	/*...省略...*/
	err = input_proc_init();
	/*...省略...*/
	err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
	/*...省略...*/
}

class_register(&input_class); 注册一个类。（可以在 /sys/class/ 目录下看到）
register_chrdev(INPUT_MAJOR, "input", &input_fops); 注册一个字符设备驱动程序。与我们自己写的字符设备驱动程序一样。
```
static const struct file_operations input_fops = {
	.owner = THIS_MODULE,
	.open = input_open_file,
};
```
input_fops 中只定义了一个 .open 函数。

在 input_fops 中我们没有看到读、写等对设备的操作函数。说明在 input_open_file 函数中可能做了一些特殊的处理工作。

1.2 open函数

static int input_open_file(struct inode *inode, struct file *file)
{
    /* 根据次设备号获取，设备的input_handler */
	struct input_handler *handler = input_table[iminor(inode) >> 5];
	const struct file_operations *old_fops, *new_fops = NULL;
	int err;

	/* No load-on-demand here? */
    /* 获取设备的file_operations对象 */
	if (!handler || !(new_fops = fops_get(handler->fops)))
		return -ENODEV;

	/*...省略...*/
	old_fops = file->f_op;
	file->f_op = new_fops;

    /* 打开设备 */
	err = new_fops->open(inode, file);
	/*...省略...*/
}

input_table[iminor(inode) >> 5]，通过 input_table 获取一个 input_handler。

input_handler 的定义如下：

struct input_handler {
    void *private;

    void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
    int (*connect)(struct input_handler *handler, 
                   struct input_dev *dev, const struct input_device_id *id);
    void (*disconnect)(struct input_handle *handle);
    void (*start)(struct input_handle *handle);

    const struct file_operations *fops;
    int minor;
    const char *name;

    const struct input_device_id *id_table;
    const struct input_device_id *blacklist;

    struct list_head	h_list;
    struct list_head	node;
};

fops_get(handler->fops)：获取了 input_handler 中的 fops；
file->f_op = new_fops：将 input_handler 中的 fops 替换掉原理的 f_op （input_fops）；
new_fops->open(inode, file)：打开了 input_handler 这个设备的 open 函数；

通过上面分析可知，核心在于 input_table 是中的 input_handler 是怎么来的。换言之，input_table 如何构造的？

1.3 input 系统

input_table 是一个全局的静态数组：

static struct input_handler *input_table[8];

input_handler

将 input_handler 填充（注册）进 input_table 使用的是 input_register_handler 这个函数，其定义如下：

int input_register_handler(struct input_handler *handler)
{
	struct input_dev *dev;

	INIT_LIST_HEAD(&handler->h_list);

	if (handler->fops != NULL) {
		if (input_table[handler->minor >> 5])
			return -EBUSY;

		input_table[handler->minor >> 5] = handler;		/* 根据次设备号放入input_table */
	}

	list_add_tail(&handler->node, &input_handler_list);	/* 将该handler放入input_handler_list链表 */

    /* 对于每一个input_dev都会调用input_attach_handler */
	list_for_each_entry(dev, &input_dev_list, node)	
		input_attach_handler(dev, handler);	/* 根据input_handler的id_table判断能否支持某个input_dev */
	/* ...省略... */
}

我们以内核中的 evdev.c 文件为例，来说明 input_register_handler 的使用。

在 evdev.c 的 init 函数中：
static int __init evdev_init(void)
{
	return input_register_handler(&evdev_handler);
}
调用了 input_register_handler 注册了 evdev_handler 进入内核的输入子系统。

evdev_handler 的定义如下：
static struct input_handler evdev_handler = {
	.event 		=	evdev_event,		/* dev上有事件时会调用该函数 */
	.connect 	=	evdev_connect,		/* 用于连接dev */
	.disconnect =	evdev_disconnect,
    .fops 		=	&evdev_fops,		/* file_operations结构体 */
    .minor 		=	EVDEV_MINOR_BASE,	/* 次设备号 */
	.name 		=	"evdev",			/* 设备名 */
	.id_table 	=	evdev_ids,			/* 表示这个handler能够支持的输入设备 */
};
evdev_ids：是一个数组，里面存放的是该 handler 所能够支持的所有的 device 类型。定义如下：
static const struct input_device_id evdev_ids[] = {
	{ .driver_info = 1 },	/* Matches all devices */
	{ },					/* Terminating zero entry */
};
input_handler 是一个纯软件的概念，与之对应的是 input_dev，后者是一个硬件相关的实现。

input_handler 中的 id_table 会记录该 handler 所支持的 input_dev 的类型。当两者的符合时，就会调用 input_handler 的 connect 函数与 input_dev 建立一个“连接”。这个工作由 input_attach_handler 来完成：

static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
{
	const struct input_device_id *id;
	int error;

	if (handler->blacklist && input_match_device(handler->blacklist, dev))
		return -ENODEV;

	id = input_match_device(handler->id_table, dev);/* 判断是否匹配 */
	if (!id)
		return -ENODEV;

	error = handler->connect(handler, dev, id);		/* 调用handler的connect建立连接 */
	/* ...省略... */
}

input_dev

而将 input_dev 注册进内核是使用 input_register_device 函数，其功能与 input_register_handler 类似：

int input_register_device(struct input_dev *dev)
{
	/* ...省略... */
	list_add_tail(&dev->node, &input_dev_list);	/* 将该设备放入input_dev_list链表 */

	/* ...省略... */
    /* 对于每一个input_handler都会调用input_attach_handler */
	list_for_each_entry(handler, &input_handler_list, node)
		input_attach_handler(dev, handler);	/* 根据input_handler的id_table判断能否支持这个input_device */

	/* ...省略... */
}

我们可以看到 input_dev 的注册也会调用 input_attach_handler 进行连接的建立；

连接的建立

input_attach_handler 函数内部会调用 handler->connect(handler, dev, id) 建立连接。

我们还是以 evdev.c 文件为例：

static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
			 const struct input_device_id *id)
{
    /* ...省略... */
	evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
	/* ...省略... */
	/* 设置evdev */
	evdev->exist = 1;
	evdev->minor = minor;
	evdev->handle.dev = dev;			/* 指向input_dev结构体 */
	evdev->handle.name = evdev->name;	
	evdev->handle.handler = handler;	/* 指向input_handler结构体 */
	evdev->handle.private = evdev;
	sprintf(evdev->name, "event%d", minor);

	evdev_table[minor] = evdev;

	devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor),
    
	cdev = class_device_create(&input_class, &dev->cdev, devt,	/* 创建一个设备节点 */
				   dev->cdev.dev, evdev->name);
	/* ...省略... */

	error = input_register_handle(&evdev->handle);	/* 注册handle */
	/* ...省略... */
}

input_register_handle 的定义如下：

int input_register_handle(struct input_handle *handle)
{
	struct input_handler *handler = handle->handler;

	list_add_tail(&handle->d_node, &handle->dev->h_list);
	list_add_tail(&handle->h_node, &handler->h_list);

	if (handler->start)
		handler->start(handle);

	return 0;
}

list_add_tail(&handle->d_node, &handle->dev->h_list)：将 handle 添加进 dev 的 h_list 链表中，这样 dev 就可以访问 handle。
list_add_tail(&handle->h_node, &handler->h_list)：同理，将 handle 添加进 handler 的 h_list 链表中。

总结一下连接的建立：

分配一个 input_handle 的结构体
在 input_handle 中记录设备的 dev、处理驱动的 handler
调用 input_register_handle 进行注册，使得：handler->h_list = &input_handle 和 dev->h_list = &input_handle；

1.4 读操作

当设备 dev 上可读时，最终会调用 evdev_read 函数进行处理：

static ssize_t evdev_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
{
	struct evdev_client *client = file->private_data;
	struct evdev *evdev = client->evdev;
	int retval;

	if (count < evdev_event_size())
		return -EINVAL;

	if (client->head == client->tail && evdev->exist && (file->f_flags & O_NONBLOCK))
		return -EAGAIN;

    /* 无数据、并且是非阻塞方式打开，则立刻返回，否则休眠 */
	retval = wait_event_interruptible(evdev->wait,
		client->head != client->tail || !evdev->exist);
	if (retval)
		return retval;
	/* ...省略... */
}

在14行，调用了 wait_event_interruptible 使得读操作进入阻塞。那么谁来唤醒？

在 evdev_event 函数：

static void evdev_event(struct input_handle *handle, unsigned int type, unsigned int code, int value)
{
	/* ...省略... */
	wake_up_interruptible(&evdev->wait);
}

有一个 wake_up_interruptible 的唤醒操作。

我们重新看到 evdev_handler 的定义：

static struct input_handler evdev_handler = {
	.event 		=	evdev_event,		/* 事件处理函数 */
	.connect 	=	evdev_connect,
	.disconnect =	evdev_disconnect,
    .fops 		=	&evdev_fops,		/* file_operations结构体 */
    .minor 		=	EVDEV_MINOR_BASE,	/* 次设备号 */
	.name 		=	"evdev",			/* 设备名 */
	.id_table 	=	evdev_ids,			/* 表示这个handler能够支持的输入设备 */
};

里面还有一个 .event 函数。从函数名字可以猜测，当有设备 dev 上事件发送时，该函数就会被调用。

那么 evdev_event 是被谁调用的？

猜测，应该是 input_dev 来调用的。这里我们以 gpio_keys.c 这个文件内的设备为例。该文件并不是实际的设备驱动，只是内核中的一个例子。

我们看到它的中断处理函数 gpio_keys_isr 函数：

static irqreturn_t gpio_keys_isr(int irq, void *dev_id)
{
	/* ...省略... */
	for (i = 0; i < pdata->nbuttons; i++) {	/* 遍历所有的按键 */
		struct gpio_keys_button *button = &pdata->buttons[i];
		int gpio = button->gpio;

		if (irq == gpio_to_irq(gpio)) {	/* 确认按键的值 */
			unsigned int type = button->type ?: EV_KEY;
			int state = (gpio_get_value(gpio) ? 1 : 0) ^ button->active_low;

			input_event(input, type, button->code, !!state); /* 调用input_event处理函数 */
			input_sync(input);
		}
	}
	/* ...省略... */
}

input_event 用于向 handler 上报事件，其函数的定义如下：

void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
{
	struct input_handle *handle;	/* handle */

	/* ...省略... */

	if (dev->grab)
		dev->grab->handler->event(dev->grab, type, code, value);
	else
		list_for_each_entry(handle, &dev->h_list, d_node)	/* 对链表里的每一个input_handle */
			if (handle->open)
				handle->handler->event(handle, type, code, value);	/* 调用 handle 中的 event函数 */
}

list_for_each_entry 从这个函数我们也可以知道，对于 dev 而言，一个 dev 可能有多个 handler 与之进行绑定。同理一个 handler 也可以处理多个 dev 设备。它们之间的关系是多对多的关系。

2. 总结

在这里插入图片描述
整个输入子系统的框架就如上图所示：

输入子系统分为两层，上层为 input 层，也就是核心层。应用程序操作时与核心层进行交互。

核心层会将自己的 file_operations 结构体替换成下层 input_handler 中的 file_operations。从而使应用程序可以间接访问到 input_handler 的 file_operations 。
下层分为两个部分：
- handler：该部分负责完成驱动的处理操作；
- dev：该部分负责与硬件设备进行交互工作；
它们之间通过一个 handle 的数据结构相连在一起。
当设备端有事件发生时：

dev 部分负责完成与设备的交互。例如：获取数据，判断按键的值等。

然后 dev 通过其 h_list 中记录的 handle，对每一个 handle 都调用 event 函数。最终会调用 handler 中实现的 event 函数，从而触发 handler 端完成相关的处理工作。