【分析笔记】Linux input 子系统原理分析

一、input 子系统简介

输入子系统主要用于支持各种输入设备，可大大简化这类设备驱动的开发难度。以下为个人的理解，可能不同的内核版本会略有差异，在这里分析的内核为 linux-4.9。

无论在 Linux 是什么子系统，其目的都是为了将硬件相关的进行解耦，提高代码的复用性，简化设备驱动的开发难度。Input 子系统也是一样，通过构建一个框架(input.c)，分离出硬件相关的(input_dev)和硬件无关的(input_handler)功能实现，内核提供了硬件无关的实现(如 evdev.c)，也提供硬件相关的实现(如 gpio_keys.c)。

Linux 子系统主要分为三部分：input core、input handler、input device

input core(核心层)：linux-4.9\drivers\input\input.c
与硬件无关的核心框架层实现，提供 handler 和 device 相关 API 和数据结构。通过 input_dev_list、input_handler_list 两个链表来记录所有的输入设备驱动和事件处理驱动。

input handler(事件处理层)：linux-4.9\drivers\input\evdev.c
与硬件无关的事件处理层实现，决定如何处理输入事件，不同 handler 有不同的处理方法，如 evdev.c 通过字符设备驱动将事件分发给上层应用程序。

input device(设备驱动层)：linux-4.9\drivers\input\keyboard\gpio_keys.c
与硬件息息相关的设备驱动层，决定如何产生输入事件，不同的 device 有不同的事件产生方法，如 gpio_keys.c 通过 gpio 的中断来产生按键事件。

通常的流程是：
输入事件产生 ---> 设备驱动层 ---> 核心层 ---> 事件处理层 ---> 用户进程 

也有反向的情况：如键盘灯事件 EV_LED
用户进程或其它驱动程序 ---> 事件处理层 ---> 核心层 ---> 设备驱动层 ---> 处理具体事件

二、关键的数据结构

struct input_dev：代表的是一种输入设备
struct input_handler：代表的是一种输入事件处理方式
struct input_handle：用于关联 struct input_dev、struct input_handler

1. 一个 input_handler 通过自己的成员 h_list 可以挂接多个 input_handle ，实现支持多个 input_dev 
2. 一个 input_dev 通过自己的成员 h_list 可以挂接多个 input_handle ，实现支持多个 input_handler

struct input_dev {
    ......
	struct input_id id;
	unsigned long propbit[BITS_TO_LONGS(INPUT_PROP_CNT)];
	unsigned long evbit[BITS_TO_LONGS(EV_CNT)];
	unsigned long keybit[BITS_TO_LONGS(KEY_CNT)];
	unsigned long relbit[BITS_TO_LONGS(REL_CNT)];
	unsigned long absbit[BITS_TO_LONGS(ABS_CNT)];
	unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)];
	unsigned long ledbit[BITS_TO_LONGS(LED_CNT)];
	unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];
	unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];
	unsigned long swbit[BITS_TO_LONGS(SW_CNT)];
    ......
	struct list_head	h_list;  // 链接各个 struct input_handle 
	struct list_head	node;	 // 作为子节点被挂接到 input_dev_list 链表内
    ......
};
 
struct input_handler {
	void *private;
	void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
	void (*events)(struct input_handle *handle, const struct input_value *vals, unsigned int count);
	bool (*filter)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
	bool (*match)(struct input_handler *handler, struct input_dev *dev);
	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 input_device_id *id_table;
	struct list_head	h_list;	// 链接各个 struct input_handle 
	struct list_head	node;	// 作为子节点被挂接到 input_handler_list 链表内
};
 
struct input_handle {
	void *private;
	int open;
	const char *name;
	struct input_dev *dev;			// 指向具体的输入设备驱动
	struct input_handler *handler;	// 指向具体的事件处理驱动
	struct list_head	d_node;		// 作为子节点被挂接到 input_dev->h_list
	struct list_head	h_node;		// 作为子节点被挂接到 input_handler->h_list
};

三、input device 使用模版

这里简单的演示一个通过 GPIO 中断来检测 GPIO 状态，作为电源按键事件的产生来源。

1. 调用 input_allocate_device() 创建一个 input device，它会初始化一些关键的数据成员。
2. 配置好支持的事件类型和具体的事件，如按键事件 EV_KEY，上报的是 KEY_POWER 键值。
3. 调用 input_register_device() 将该输入设备注册到输入子系统中。
4. 在需要的时候，调用 input_event()\input_sync() 上报 KEY_POWER 按下或弹起事件。

struct input_dev *input = NULL;
 
static irqreturn_t gpio_key_irq_isr(int irq, void *dev_id)
{
    // 4. 上报电源按键事件，根据 GPIO 状态决定是弹起还是按下
	input_event(input, EV_KEY, KEY_POWER, __gpio_get_value(...));
	input_sync(input);
	return IRQ_HANDLED;
}
 
static int __init intpu_device_demo_init(void)
{
    // 1. 必须使用 input_allocate_device() 创建，它会初始化一些关键的数据成员
	input = input_allocate_device();
	input->name = "power-keys";
	input->phys = "power-keys/input0";
	input->dev.parent = &pdev->dev;
	
	input->id.bustype = BUS_HOST;
	input->id.vendor = 0x0001;
	input->id.product = 0x0001;
	input->id.version = 0x0100;
	
    // 2. 设置支持的事件类型, 这里设置支持按键上报类型
	set_bit(EV_KEY | EV_SYN, input->evbit);
    // 2. 设置支持具体哪些按键，这里设置支持 KEY_POWER 键值上报
	set_bit(KEY_POWER, input->keybit);
    // 3. 将该设备注册到输入子系统内部
	input_register_device(input);
	
	request_irq(..., &gpio_key_irq_isr, ..., "powerkey", ...);
	return 0;
}
 
static void __exit intpu_device_demo_exit(void)
{
	free_irq(...);
	input_free_device(input);
}
 
module_init(intpu_device_demo_init);
module_exit(intpu_device_demo_exit);

四、input handler 使用模版

通常不需要我们自己写，内核提供的 evdev.c、mousedev.c 等等，足以应付普通应用。注意，这里涉及到两种名字很像但其意义完全不同的数据结构 struct input_handler、struct input_handle，前者代表事件处理驱动，后者只是用于来关联 struct input_device 和 struct input_handler。

1. 通过 struct input_device_id 指明能支持哪种类型的输入设备驱动产生的事件，这里的 .driver_info=1，表明支持所有输入设备。
2. 设置 handler 与输入设备驱动连接或断开、事件处理的回调。 
3. 将该 handler 注册进入输入子系统。
4. 在与输入设备驱动连接时，构建 input handle 关联 device 和 handler 并注册到输入子系统中.
5. 增加 handle->open 的计数引用，核心层只会给有计数的 handle 转发事件给 handle 关联的 handler。

 
void input_handler_demo_events(struct input_handle *handle, const struct input_value *vals, unsigned int count)
{
	// 6. 处理输入设备驱动传递过来的事件
    // 即输入设备驱动调用 input_event()\input_sync() 传的事件
}
 
static int input_handler_demo_connect(struct input_handler *handler,
			      struct input_dev *dev,
			      const struct input_device_id *id)
{
	// 4. 构建 input handle 关联 device 和 handler 并注册到输入子系统中
	struct input_handle *handle = NULL;
	handle.dev = dev;
	handle.handler = handler;
	handle.name = "demo";
	handle.private = xxx;
	input_register_handle(&handle);
	
	// 5. 增加 handle 的引用
	input_open_device(&handle);
	return 0;
}
 
static void input_handler_demo_disconnect(struct input_handle *handle)
{
	// 减少 handle 的引用
	input_close_device(handle);
	input_unregister_handle(handle);
}
 
// 1. 指明能处理哪种类型的输入设备驱动产生的事件
static const struct input_device_id input_handler_demo_ids[] = {
	{ .driver_info = 1 },	// 表示支持所有的输入设备驱动
	{ },			
};
MODULE_DEVICE_TABLE(input, input_handler_demo_ids);
 
// 2. 设置与输入设备驱动关联或断开、事件处理的回调
static struct input_handler input_handler_demo_handler = {
	.name = "demo",
	.events = input_handler_demo_events,			// 事件处理回调
	.connect = input_handler_demo_connect,       	// 与输入设备驱动关联成功的回调
	.disconnect = input_handler_demo_disconnect, 	// 与输入设备驱动断开的回调
	.id_table = input_handler_demo_ids,            	// 指明能处理哪种类型的输入设备驱动产生的事件
};
 
static int __init input_handler_demo_init(void)
{
	// 3. 将该 handler 注册进入输入子系统
	return input_register_handler(&input_handler_demo_handler);
}
module_init(input_handler_demo_init);
 
static void __exit input_handler_demo_exit(void)
{
	input_unregister_handler(&input_handler_demo_handler);
}
module_exit(input_handler_demo_exit);

五、input handler 分析

基本流程：
input_register_handler()：注册一个 handler 到子系统，将该 handler 加入到 input_handler_list 链表内，并遍历 input_device_list 
        ->input_attach_handler()：
                ->input_match_device()：找出可以被 input_handler 所支持的 input_dev
                        ->input_handler->connect()：建立关联后会调用 input_handler 的 connect() 回调函数
                                ->input_register_handle()：构建 input_handle，关联 input_handler\input_dev，加入双方 h_list 链表。

 input_register_handler：

1. 工作内容主要是初始化用于挂接 struct handle 的 handler->h_list 链表。
2. 将当前的 handler 增加到在全局链表 input_handler_list 内记录，用于输入设备驱动加载时进行匹配。
3. 遍历全局链表 input_dev_list，尝试匹配能被支持的 input_dev。
4. 匹配成功后，就会调用该 input_handler.connect 回调接口。

int input_register_handler(struct input_handler *handler)
{
	struct input_dev *dev;
	int error;
 
	error = mutex_lock_interruptible(&input_mutex);
	if (error)
		return error;
 
    // 1. 初始化链表 h_list，用于挂接 struct handle
	INIT_LIST_HEAD(&handler->h_list);
 
    // 2. 加入事件驱动链表: input_handler_list
	list_add_tail(&handler->node, &input_handler_list);
 
    // 3. 遍历设备驱动链表：input_dev_list，与每一个设备驱动进行比对匹配
	list_for_each_entry(dev, &input_dev_list, node)
		input_attach_handler(dev, handler);
 
	input_wakeup_procfs_readers();
 
	mutex_unlock(&input_mutex);
	return 0;
}
EXPORT_SYMBOL(input_register_handler);
 
static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
{
	const struct input_device_id *id;
	int error;
 
    // 3. 匹配指定的 input_handler 和 input_dev
	id = input_match_device(handler, dev);
	if (!id)
		return -ENODEV;
 
    // 4. 调用该 handler 的 connect 接口
	error = handler->connect(handler, dev, id);
	if (error && error != -ENODEV)
		pr_err("failed to attach handler %s to device %s, error: %d\n",
		       handler->name, kobject_name(&dev->dev.kobj), error);
 
	return error;
}

 input_match_device：

1. 首先检查 input_handler 设置了 id->flags 或者 id->driver_info，没有设置则跳过。
2. 根据 input_handler 的 id->flags 标志位，先后比对总线类型(id.bustype)、厂商信息(id.vendor)、产品型号(id.product)、版本信息(id.version)，有一个比对失败则跳过。
3. 检查 input_dev 产生具体的事件位是否在 intpu_handler 支持的范围，如果不在范围则跳过。产生哪些具体的事件，由 input_dev 调用 set_bit(xxx, input->xxxbit) 确定。
4. 如果 handler 有自己的 match 匹配方法，则使用 handler 自己的匹配方法再进一步判断，如果没有指定自己的 match 方法则表明比对成功。

由此可见：
1. 匹配的前提条件有两个，handler 必须设置 id->flags 或 id->driver_info 且 input_dev 支持的具体事件位在内核支持范围
2. 若需要支持所有的输入设备，只需设置 id->driver_info = 1，且 input_dev 支持的具体事件位在内核支持范围。
3. 若只需支持指定类型的输入设备，可以结合 id->flags 指定 id.bustype、id.vendor、id.product、id.version 作为比对条件。
4. 也可以自行实现 match 接口进行比对，只需要设置 id->driver_info = 1 ，该 match 就会被调用，根据调用的结果作为比对条件。

static const struct input_device_id *input_match_device(struct input_handler *handler,
							struct input_dev *dev)
{
	const struct input_device_id *id;
    
	for (id = handler->id_table; id->flags || id->driver_info; id++) {
 
		if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
			if (id->bustype != dev->id.bustype)
				continue;
 
		if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
			if (id->vendor != dev->id.vendor)
				continue;
 
		if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
			if (id->product != dev->id.product)
				continue;
 
		if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
			if (id->version != dev->id.version)
				continue;
 
		if (!bitmap_subset(id->evbit, dev->evbit, EV_MAX))
			continue;
 
		if (!bitmap_subset(id->keybit, dev->keybit, KEY_MAX))
			continue;
 
		if (!bitmap_subset(id->relbit, dev->relbit, REL_MAX))
			continue;
 
		if (!bitmap_subset(id->absbit, dev->absbit, ABS_MAX))
			continue;
 
		if (!bitmap_subset(id->mscbit, dev->mscbit, MSC_MAX))
			continue;
 
		if (!bitmap_subset(id->ledbit, dev->ledbit, LED_MAX))
			continue;
 
		if (!bitmap_subset(id->sndbit, dev->sndbit, SND_MAX))
			continue;
 
		if (!bitmap_subset(id->ffbit, dev->ffbit, FF_MAX))
			continue;
 
		if (!bitmap_subset(id->swbit, dev->swbit, SW_MAX))
			continue;
 
		if (!handler->match || handler->match(handler, dev))
			return id;
	}
 
	return NULL;
}

 input_handler->connect：

这里以 evdev.c 实现的 input_handler 驱动为例
1. 首先获取新的输入设备的次设备号，为了创建字符设备准备
2. 创建新的 struct evdev，内部包含有 input_handle，struct list_head client_list，并初始化自旋锁、互斥体和等待队列。
3. 初始化 input_handle ，关联 input_handler、input_dev，并设置私有数据成员 private 
4. 初始化设备信息，为创建字符设备准备
5. 注册构建好的 input_handle 到输入子系统
6. 创建字符设备，为上层提供设备节点，多个 intput_dev 被匹配成功，就会创建多个设备节点。

由此可见：
1. 每匹配到一个 input_dev 都会有一个与之对应的 input_handle、list_head client_list、字符设备。
2. 必须要构建 input_handle ，它存在的意义，就是为了将 input_handler 和 input_dev 建立关联。
3. client_list 链表是 evdev 自有的链表，主要是维护用户线程存储事件的数据结构，有多少个线程打开，就会有多少个 client。
4. 创建字符设备是体现 evdev 驱动处理输入事件的方法，通过字符设备来给应用层提供事件获取渠道，即 /dev/input/eventX。

static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
			 const struct input_device_id *id)
{
	struct evdev *evdev;
	int minor;
	int dev_no;
	int error;
 
    // 1. 获取新的次设备号
	minor = input_get_new_minor(EVDEV_MINOR_BASE, EVDEV_MINORS, true);
	if (minor < 0) {
		error = minor;
		pr_err("failed to reserve new minor: %d\n", error);
		return error;
	}
 
    // 2. 创建新的 struct evdev, 包含 struct handle 
	evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
	if (!evdev) {
		error = -ENOMEM;
		goto err_free_minor;
	}
 
	INIT_LIST_HEAD(&evdev->client_list);
	spin_lock_init(&evdev->client_lock);
	mutex_init(&evdev->mutex);
	init_waitqueue_head(&evdev->wait);
	evdev->exist = true;
 
	dev_no = minor;
	/* Normalize device number if it falls into legacy range */
	if (dev_no < EVDEV_MINOR_BASE + EVDEV_MINORS)
		dev_no -= EVDEV_MINOR_BASE;
	dev_set_name(&evdev->dev, "event%d", dev_no);
 
    // 3. 初始化 handle , 关联 input_dev 和 input_handler
	evdev->handle.dev = input_get_device(dev);
	evdev->handle.name = dev_name(&evdev->dev);
	evdev->handle.handler = handler;
	evdev->handle.private = evdev;
 
    // 4. 初始化设备，为创建字符设备准备
	evdev->dev.devt = MKDEV(INPUT_MAJOR, minor);
	evdev->dev.class = &input_class;
	evdev->dev.parent = &dev->dev;
	evdev->dev.release = evdev_free;
	device_initialize(&evdev->dev);
 
    // 5. 注册构建好的 input_handle 到输入子系统
	error = input_register_handle(&evdev->handle);
	if (error)
		goto err_free_evdev;
 
    // 6. 创建字符设备，为上层提供设备节点，节点路径：/dev/input/eventX
	cdev_init(&evdev->cdev, &evdev_fops);
	evdev->cdev.kobj.parent = &evdev->dev.kobj;
	error = cdev_add(&evdev->cdev, evdev->dev.devt, 1);
	if (error)
		goto err_unregister_handle;
 
	error = device_add(&evdev->dev);
	if (error)
		goto err_cleanup_evdev;
 
	return 0;
 
 err_cleanup_evdev:
	evdev_cleanup(evdev);
 err_unregister_handle:
	input_unregister_handle(&evdev->handle);
 err_free_evdev:
	put_device(&evdev->dev);
 err_free_minor:
	input_free_minor(minor);
	return error;
}

 input_register_handle：

负责真正实现 input_handler 和 input_dev 两者关联
1. 如果 handler->filter 则将 handle 加到 input_dev->h_list 的头部，否则加到尾部，这样后续有事件产生可以优先调用 handler->filter 接口。
2. 将 handle 加到 handler->h_list 尾部，如果 handler->start 有被实现，就会传入 handle 并调用。

由此可见：
1. input_handler 创建的  input_handle 会被分别挂接到 input_handler 和 input_dev 的 h_list 链表内。
2. 有实现 filter 接口的 input_handler，在处理事件时会优先被调用执行。
3. 无论是 input_hander 还是 input_dev，都可以通过各自的 h_list 找到彼此。

int input_register_handle(struct input_handle *handle)
{
	struct input_handler *handler = handle->handler;
	struct input_dev *dev = handle->dev;
	int error;
 
	error = mutex_lock_interruptible(&dev->mutex);
	if (error)
		return error;
 
    // 1. 如果 handler->filter 则将 handle 加到 input_dev->h_list 的头部，否则加到尾部
	if (handler->filter)
		list_add_rcu(&handle->d_node, &dev->h_list);
	else
		list_add_tail_rcu(&handle->d_node, &dev->h_list);
 
	mutex_unlock(&dev->mutex);
 
	// 2. 将 handle 加到 handler->h_list 尾部
	list_add_tail_rcu(&handle->h_node, &handler->h_list);
 
    // 2. 如果 handler->start 有被实现，传入 handle 并调用。
	if (handler->start)
		handler->start(handle);
 
	return 0;
}
EXPORT_SYMBOL(input_register_handle);

 六、input device 分析

设备注册流程：
input_register_device()：注册一个输入设备到输入子系统内，加入 input_dev_list 链表中，并遍历 input_handler_list 
                ->input_attach_handler()：
                        ->input_match_device()：找出可以被 input_handler 所支持的 input_dev
                                ->input_handler->connect()：建立关联后会调用 input_handler 的 connect() 回调函数
                                        ->input_register_handle()：构建 input_handle，关联 input_handler\input_dev，加入双方 h_list 链表。

事件上报流程：
input_event()：上报指定事件类型的指定具体事件
        -> input_handle_event()
                -> input_get_disposition()：通过事件类型和具体事件来确定该事件的去向
                -> input_dev->event()：如果需要传递给输入设备，就通过 input_dev->event 传递
                -> input_pass_values()：如果不是被独占，那么就遍历 input_dev 下所有的 handle
                        -> input_to_handler()
                                -> handler->filter()：如果该接口被实现的话，则通过调用此接口决定某些事件是否被过滤
                                -> handler->events()：如果没有被过滤且有实现的话，则通过 events 将事件传递给 handler
                                -> handler->event()：如果events 没有实现的话，则通过 events 将事件传递给 handler

input_register_device：

1. 将该 input_dev 追加到全局输入设备链表 input_dev_list 中，便于有新的 input_handler 驱动加入可以触发匹配动作。
2. 遍历全局事件驱动链表：input_handler_list，与每一个事件驱动进行比对匹配，匹配过程已经在 input_handler 分析过。

int input_register_device(struct input_dev *dev)
{
	struct input_devres *devres = NULL;
	struct input_handler *handler;
	unsigned int packet_size;
	const char *path;
	int error;
 
	// 表示设备被 devres 框架管理，不需要显式取消和释放，类似于 C++ 的智能指针
    // 即调用 devm_input_allocate_device() 创建的输入设备
	if (dev->devres_managed) {
		devres = devres_alloc(devm_input_device_unregister, sizeof(struct input_devres), GFP_KERNEL);
		if (!devres)
			return -ENOMEM;
		devres->input = dev;
	}
	// 强制启用 EV_SYN 事件, 每一个设备都应该支持 EV_SYN 事件，通常作为事件结束的标记
	__set_bit(EV_SYN, dev->evbit);
	// 强制清除 KEY_RESERVED 事件，该事件发送给用户空间没有意义
	__clear_bit(KEY_RESERVED, dev->keybit);
	// 确保除了显式支持的事件以外，其它事件都清空，保持干净的事件
	input_cleanse_bitmasks(dev);
	
	packet_size = input_estimate_events_per_packet(dev);
	if (dev->hint_events_per_packet < packet_size)
		dev->hint_events_per_packet = packet_size;
 
    // 申请指定数量的具体事件的缓冲区
	dev->max_vals = dev->hint_events_per_packet + 2;
	dev->vals = kcalloc(dev->max_vals, sizeof(*dev->vals), GFP_KERNEL);
	if (!dev->vals) {
		error = -ENOMEM;
		goto err_devres_free;
	}
 
	// 如果重复上报和延迟未被设置，那么初始化定时器实现 默认按下超过 250ms 开启每 33ms 自动重复发送按键
	// 如果 input_dev 已经设置了，那就由它自己实现这个长时间按下自动发送按键的功能
	if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD])
		input_enable_softrepeat(dev, 250, 33);
 
	// 如果 input_dev 没有实现获取按键值回调接口，则提供默认的获取按键值回调
	if (!dev->getkeycode)
		dev->getkeycode = input_default_getkeycode;
 
	// 如果 input_dev 没有实现获取按键值回调接口，则提供默认的获取按键值回调
	if (!dev->setkeycode)
		dev->setkeycode = input_default_setkeycode;
 
	error = device_add(&dev->dev);
	if (error)
		goto err_free_vals;
	
	path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
	pr_info("%s as %s\n",
		dev->name ? dev->name : "Unspecified device",
		path ? path : "N/A");
	kfree(path);
 
	error = mutex_lock_interruptible(&input_mutex);
	if (error)
		goto err_device_del;
 
	// 1. 将该 input_dev 追加到全局输入设备链表 input_dev_list 中
	list_add_tail(&dev->node, &input_dev_list);
	
	// 2. 遍历全局事件驱动链表：input_handler_list，与每一个事件驱动进行比对匹配
	list_for_each_entry(handler, &input_handler_list, node)
		input_attach_handler(dev, handler);
 
	input_wakeup_procfs_readers();
 
	mutex_unlock(&input_mutex);
 
	if (dev->devres_managed) {
		dev_dbg(dev->dev.parent, "%s: registering %s with devres.\n",
			__func__, dev_name(&dev->dev));
		devres_add(dev->dev.parent, devres);
	}
	return 0;
 
err_device_del:
	device_del(&dev->dev);
err_free_vals:
	kfree(dev->vals);
	dev->vals = NULL;
err_devres_free:
	devres_free(devres);
	return error;
}
EXPORT_SYMBOL(input_register_device);

input_event()\input_sync()：

1. 判断要上报的事件类型是否是输入设备指定的事件类型，即是否在 input_dev 通过 set_bit(xxx, input->evbit) 设置。
2. 将产生的具体事件 ，发给 input 核心层

void input_event(struct input_dev *dev,
		 unsigned int type, unsigned int code, int value)
{
	unsigned long flags;
 
	// 1. 判断该事件类型是否被支持，即是否在 input_dev 通过 set_bit(xxx, input->evbit) 设置
	if (is_event_supported(type, dev->evbit, EV_MAX)) {
		spin_lock_irqsave(&dev->event_lock, flags);
		// 2. 将产生的事件发给 input 核心层
		input_handle_event(dev, type, code, value);
		spin_unlock_irqrestore(&dev->event_lock, flags);
	}
}
EXPORT_SYMBOL(input_event);
 
static inline int is_event_supported(unsigned int code,
				     unsigned long *bm, unsigned int max)
{
	return code <= max && test_bit(code, bm);
}
 
static inline void input_sync(struct input_dev *dev)
{
	input_event(dev, EV_SYN, SYN_REPORT, 0);
}

input_handle_event：

1. 通过事件类型决定事件派发的方向，主要方向是 input_dev、input_handler。
2. 如果需要派发给 input_dev 且该 input_dev 实现了 event 回调，则将事件传入并调用。
3. 如果需要派发给 input_handler，则对该事件进行缓存(入队列)，如果该事件于多点触摸屏有关，则还会多缓存一个触摸屏ID的事件。
4. 若 INPUT_FLUSH 置位或缓冲区已满, 才会正式传给 input_handler，INPUT_FLUSH 只有在 EV_SYN->SYN_REPORT 中会被置位。

由此可见：
1. 输入事件不但可以给 input_handler 处理，也可以给 input_dev 处理，如键盘上的按键灯，取决于事件类型和具体的事件。
2. 上报的事件会被缓存入队，只有收到 EV_SYN->SYN_REPORT 或者队列将满才会正式转发给 input_handler。
3. 输入设备驱动每产生一次数据，就应该调用 input_sync() 上报，避免出现某些事件上报很慢(要等 dev->vals 队列已满)或不上报的问题( dev->vals 队列一直未满)。

static void input_handle_event(struct input_dev *dev,
			       unsigned int type, unsigned int code, int value)
{
	// 1. 通过事件类型决定事件派发的方向，如 EV_LED(键盘灯) 会派发给 input_dev 和 input_handler
	int disposition = input_get_disposition(dev, type, code, &value);
 
	// 将输入事件作为随机事件, 为随机数熵池贡献, 尽量让伪随机往更真实的随机靠近
	if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)
		add_input_randomness(type, code, value);
 
	// 2. 如果需要派发给 input_dev 且该 input_dev 实现了 event 回调，则将事件传入并调用。
	if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
		dev->event(dev, type, code, value);
 
	// 检查在 input_register_device() 申请事件队列是否有效
	if (!dev->vals)
		return;
 
	// 3. 如果需要派发给 input_handler, 则对事件进行缓存(入队列)
	if (disposition & INPUT_PASS_TO_HANDLERS) {
		struct input_value *v;
		// 针对多点触摸屏，指定的是触摸屏点的 ID
		if (disposition & INPUT_SLOT) {
			v = &dev->vals[dev->num_vals++];
			v->type = EV_ABS;
			v->code = ABS_MT_SLOT;
			v->value = dev->mt->slot;
		}
		// 将具体事件入队缓存
		v = &dev->vals[dev->num_vals++];
		v->type = type;
		v->code = code;
		v->value = value;
	}
 
	// 4. 若 INPUT_FLUSH 置位或缓冲区已满, 才会正式传给 input_handler 
	// INPUT_FLUSH 只有在 EV_SYN->SYN_REPORT 中会被置位
	if (disposition & INPUT_FLUSH) {
		if (dev->num_vals >= 2)
			input_pass_values(dev, dev->vals, dev->num_vals);
		dev->num_vals = 0;
	} else if (dev->num_vals >= dev->max_vals - 2) {
		dev->vals[dev->num_vals++] = input_value_sync;
		input_pass_values(dev, dev->vals, dev->num_vals);
		dev->num_vals = 0;
	}
 
}

input_pass_values：

1. 如果该设备有被 grab 指定 handle，则只由 handle 关联的 handler 处理事件，实现独占输入设备的功能。
2. 遍历所有的 handle 并根据是否引用计数将事件组转交给对应的 handler 处理.
3. 主要实现检测按键长按时，通过定时器实现自动重复上报键值。

由此可见：
1. 可以独占某个输入设备，让该设备的事件只流向当前的 handler，通过调用 input_grab_device() 实现。
2. 在此位置会检查 handle->open 的计数，所以自行实现 handler 中要在合适的位置调用 input_open_device()。

static void input_pass_values(struct input_dev *dev,
			      struct input_value *vals, unsigned int count)
{
	struct input_handle *handle;
	struct input_value *v;
 
	if (!count)
		return;
 
	rcu_read_lock();
	// 1. 如果该设备有被 grab 指定 handle，则只由 handle 关联的 handler 处理事件
    // 通过调用 input_grab_device() 实现。
	handle = rcu_dereference(dev->grab);
	if (handle) {
		count = input_to_handler(handle, vals, count);
	} else {
		// 2. 遍历所有的 handle 并根据是否引用计数将事件组转交给对应的 handler 处理
		list_for_each_entry_rcu(handle, &dev->h_list, d_node)
			if (handle->open) {
				count = input_to_handler(handle, vals, count);
				if (!count)
					break;
			}
	}
	rcu_read_unlock();
 
	// 3. 主要实现检测按键长按时，通过定时器实现自动重复上报键值
	if (test_bit(EV_REP, dev->evbit) && test_bit(EV_KEY, dev->evbit)) {
		for (v = vals; v != vals + count; v++) {
			if (v->type == EV_KEY && v->value != 2) {
				if (v->value)
					input_start_autorepeat(dev, v->code);
				else
					input_stop_autorepeat(dev);
			}
		}
	}
}

input_to_handler：

1. 如果 input_handler 有实现 filter 接口则优先调用，filter 返回 0 表示该事件得到处理。
2. 如果所有的事件都被 filter 处理，就不再继续往下传递
3. 如果还有事件未被处理则优先传递给 handler->events, 如果没有实现再传递给 handler->event 接口。

由此可见：
1. input_handler 的 filter 成员函数可用于过滤某些事件，如需要过滤返回 0 即可，不需要过滤的返回非 0 值。
2. input_handler 的 events 和 event 两个成员函数任意实现其中一个即可，不必全都实现。
3. 事件处理回调接口的优先级：handler->filter >>>>> handler->events >>>>> handler->event

static unsigned int input_to_handler(struct input_handle *handle,
			struct input_value *vals, unsigned int count)
{
	struct input_handler *handler = handle->handler;
	struct input_value *end = vals;
	struct input_value *v;
 
	// 1. 如果 input_handler 有实现 filter 接口则优先调用，filter 返回 0 表示该事件得到处理
	if (handler->filter) {
		for (v = vals; v != vals + count; v++) {
			if (handler->filter(handle, v->type, v->code, v->value))
				continue;
			if (end != v)
				*end = *v;
			end++;
		}
		count = end - vals;
	}
	// 2. 如果所有的事件都被 filter 处理，就不再继续往下传递
	if (!count)
		return 0;
 
	// 3. 如果还有事件未被处理则优先传递给 handler->events, 如果没有实现再传递给 handler->event 接口
	if (handler->events)
		handler->events(handle, vals, count);
	else if (handler->event)
		for (v = vals; v != vals + count; v++)
			handler->event(handle, v->type, v->code, v->value);
 
	return count;
}

handler->events：

这里以 evdev.c 实现的 input_handler 驱动为例
1. 为事件加上时间戳，应用层拿到事件时可以根据时间戳来还原事件产生，例如键盘记录器功能等。
2. 这里和 input_pass_values() 一样，可以让某个线程独占所有的事件处理权。
3. 将事件传递给所有的 client，拷贝所有事件到各个 client 缓存内，唤醒所有 read() 阻塞的用户线程，拷贝事件给应用层。
这里只是简单介绍 evdev.c 是如何处理这些事件，内部实现的细节其实也很简单，这里就不再叙述。

static void evdev_events(struct input_handle *handle,
			 const struct input_value *vals, unsigned int count)
{
	struct evdev *evdev = handle->private;
	struct evdev_client *client;
	ktime_t ev_time[EV_CLK_MAX];
 
	// 1. 为事件加上时间戳
	ev_time[EV_CLK_MONO] = ktime_get();
	ev_time[EV_CLK_REAL] = ktime_mono_to_real(ev_time[EV_CLK_MONO]);
	ev_time[EV_CLK_BOOT] = ktime_mono_to_any(ev_time[EV_CLK_MONO], TK_OFFS_BOOT);
 
	rcu_read_lock();
	// 2. 这里和 input_pass_values() 一样，可以让某个线程独占所有的事件处理权
	client = rcu_dereference(evdev->grab);
	if (client)
		evdev_pass_values(client, vals, count, ev_time);
	else{
		// 3. 将事件传递给所有的 client, 即每一个打开此输入设备的线程
		list_for_each_entry_rcu(client, &evdev->client_list, node)
			evdev_pass_values(client, vals, count, ev_time);
	}
 
	rcu_read_unlock();
}

七、input 子系统分析总结

一、驱动框架结构

Input 驱动框架主要包含：核心层、事件处理层、设备驱动层。
1. 核心层：提供设备驱动和事件处理驱动所需要的 API 以及相关数据结构。并通过两个链表来维护所有的设备驱动和事件处理驱动。
2. 设备驱动层：决定如何产生输入事件，不同的输入设备会有不同的输入事件来源，如 gpio_keys.c 通过 gpio 的中断来产生按键事件。
3. 事件处理层：决定如何处理输入事件，根据应用场景会有不同的事件处理方式，如 evdev.c 通过字符设备节点将事件传给应用层。

二、他们是如何协同工作

1. 设备驱动会先声明可以支持哪些事件类型以及具体的事件，再注册到核心层
2. 核心层将其加入到设备驱动链表内，并遍历事件驱动链表，找到合适的事件处理驱动
3. 事件处理驱动通过构建 input_handle 来关联设备驱动，并注册到核心层
4. 核心层会将 input_handle 分别加入到所关联的事件处理驱动和设备驱动的链表内。 

三、设备驱动和事件驱动关联的条件

1. 该事件处理驱动是否设置 id->flags 或 id->driver_info
2. 该事件处理驱动决定是否需要比对总线类型、厂商信息、产品型号、版本信息
3. 该事件处理驱动是否可以支持设备驱动产生的事件
4. 该事件处理驱动是否实现 match 来进一步确认
5. 以上条件有一个不满足都不会建立关联关系

四、设备驱动事件上报处理流程

1. 设备驱动通过调用 input_event() 将事件传给核心层
2. 核心层会将这些事件缓存到该设备驱动的队列内
3. 当缓存已满，或调用 input_sync()，就会将缓存的所有事件传递给关联的事件处理驱动。
4. 事件处理驱动收到这些事件后，如 evdev.c 就会通过设备节点传递给应用层。