【分析笔记】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 就会通过设备节点传递给应用层。
