LINUX 输入子系统架构分析

内核的输入子系统是对分散的，多种不同类别的输入设备(如键盘，鼠标，跟踪球，操纵杆，触摸屏，加速计和手写板)等字符设备进行统一处理的一层抽象，就是在字符设备驱动上抽象出的一层。输入子系统包括两类驱动程序：事件驱动程序和设备驱动程序。事件驱动程序负责和应用程序的接口，而设备驱动程序负责和底层输入设备的通信。鼠标事件生成文件mousedev属于事件驱动程序，而PS/2鼠标驱动程序是设备驱动程序。事件驱动程序是标准的，对所有的输入类都是可用的，所以要实现的是设备驱动程序而不是事件驱动程序。设备驱动程序可以利用一个已经存在的，合适的事件驱动程序通过输入核心和用户应用程序接口。
输入子系统带来了如下好处：
1.统一了物理形态各异的相似的输入设备的处理功能
2.提供了用于分发输入报告给用户应用程序的简单的事件接口
3.抽取出了输入驱动程序的通用部分，简化了驱动，并引入了一致性

现在 Android、X windows、qt等众多应用对于linux系统中键盘、鼠标、触摸屏等输入设备的支持都通过、或越来越倾向于标准的input输入子系统。因为input子系统已经完成了字符驱动的文件操作接口，所以编写驱动的核心工作是完成input系统留出的接口，工作量不大。但如果你想更灵活的应用它，就需要好好的分析下input子系统了。

先来看一下输入子系统体系架构图：


再对照 下图（ input输入子系统框架 ），很清楚的知道输入子系统是由输入子系统核心层（ Input Core ），驱动层和事件处理层（Event Handler）三部份组成。一个输入事件，如鼠标移动，键盘按键按下，joystick的移动等等通过 input driver -> Input core -> Event handler -> userspace 到达用户空间传给应用程序。

注意：keyboard.c不会在/dev/input下产生节点，而是作为ttyn终端（不包括串口终端）的输入。

设备描述

在linux内核中，input设备用input_dev结构体描述，使用input子系统实现输入设备驱动的时候，驱动的核心工作是向系统报告按键、触摸屏、键盘、鼠标等输入事件（event,通过input_event结构体描述），一再需要关心文件操作接口，因为input子系统已经完成了文件操作接口。驱动报告的事件经过InputCore和EventHandler最终到达用户空间。
现在了解了input子系统的基本思想，下面来看一下input子系统的3个基本的数据结构：

1. struct input_dev {
2. constchar *name; //名称
3. constchar *phys; //设备在系统中的物理路径
4. constchar *uniq; //设备唯一识别符
5. struct input_id id; //设备ID，包含总线ID（PCI、USB）、厂商ID，与input_handler匹配的时会用到
7. unsignedlong evbit[BITS_TO_LONGS(EV_CNT)];//支持的所有事件类型
8. unsignedlong keybit[BITS_TO_LONGS(KEY_CNT)];//支持的键盘事件
9. unsignedlong relbit[BITS_TO_LONGS(REL_CNT)];//支持的鼠标相对值事件
10. unsignedlong absbit[BITS_TO_LONGS(ABS_CNT)];//支持的鼠标绝对值事件
11. unsignedlong mscbit[BITS_TO_LONGS(MSC_CNT)];//支持的其它事件类型
12. unsignedlong ledbit[BITS_TO_LONGS(LED_CNT)];//支持的LED灯事件
13. unsignedlong sndbit[BITS_TO_LONGS(SND_CNT)];//支持的声效事件
14. unsignedlong ffbit[BITS_TO_LONGS(FF_CNT)];//支持的力反馈事件
15. unsignedlong swbit[BITS_TO_LONGS(SW_CNT)];//支持的开关事件
17. unsignedint keycodemax;//keycode表的大小
18. unsignedint keycodesize;//keycode表中元素个数
19. void *keycode; //设备的键盘表
20. int (*setkeycode)(struct input_dev *dev, int scancode, int keycode);//配置keycode表
21. int (*getkeycode)(struct input_dev *dev, int scancode, int *keycode);//获取keycode表
23. struct ff_device *ff;
25. unsignedint repeat_key;//保存上一个键值
26. struct timer_list timer;
28. int sync;
30. int abs[ABS_MAX + 1]; //绝对坐标上报的当前值
31. int rep[REP_MAX + 1]; //这个参数主要是处理重复按键，后面遇到再讲
32. unsignedlong key[BITS_TO_LONGS(KEY_CNT)];//按键有两种状态，按下和抬起，这个字段就是记录这两个状态。
33. unsignedlong led[BITS_TO_LONGS(LED_CNT)];
34. unsignedlong snd[BITS_TO_LONGS(SND_CNT)];
35. unsignedlong sw[BITS_TO_LONGS(SW_CNT)];
37. int absmax[ABS_MAX + 1]; //绝对坐标的最大值
38. int absmin[ABS_MAX + 1]; //绝对坐标的最小值
39. int absfuzz[ABS_MAX + 1];
40. int absflat[ABS_MAX + 1];
41. //操作接口
42. int (*open)(struct input_dev *dev);
43. void (*close)(struct input_dev *dev);
44. int (*flush)(struct input_dev *dev, struct file *file);
45. int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);
47. struct input_handle *grab; //当前使用的handle
49. spinlock_t event_lock;
50. struct mutex mutex;
52. unsignedint users;
53. int going_away;
55. struct device dev;
57. struct list_head h_list; //h_list是一个链表头，用来把handle挂载在这个上
58. struct list_head node; //这个node是用来连到input_dev_list上的
59. };
60. //input_dev->evbit表示设备支持的事件类型，可以是下列值的组合
    #define EV_SYN 0x00//同步事件
    #define EV_KEY 0x01//绝对二进制值，如键盘或按钮
    #define EV_REL 0x02//绝对结果，如鼠标设备
    #define EV_ABS 0x03//绝对整数值，如操纵杆或书写板
    #define EV_MSC 0x04//其它类
    #define EV_SW 0x05//开关事件
    #define EV_LED 0x11//LED或其它指示设备
    #define EV_SND 0x12//声音输出，如蜂鸣器
    #define EV_REP 0x14//允许按键自重复
    #define EV_FF 0x15//力反馈
    #define EV_PWR 0x16//电源管理事件
    include/linux/input.h中定义了支持的类型
61. struct input_handler {
63. void *private;
65. void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
66. int (*connect)(struct input_handler *handler, struct input_dev *dev, conststruct input_device_id *id);
67. void (*disconnect)(struct input_handle *handle);
68. void (*start)(struct input_handle *handle);
70. conststruct file_operations *fops;
71. int minor; //次设备号
72. constchar *name;
74. conststruct input_device_id *id_table;
75. conststruct input_device_id *blacklist;
77. struct list_head h_list; //h_list是一个链表头，用来把handle挂载在这个上
78. struct list_head node; //这个node是用来连到input_handler_list上的
79. };
81. struct input_handle {
83. void *private;
85. int open;
86. constchar *name;
88. struct input_dev *dev; //指向input_dev
89. struct input_handler *handler; //指向input_handler
91. struct list_head d_node; //连到input_dev的h_list上
92. struct list_head h_node; //连到input_handler的h_list上
93. };

如下图代表了input_dev，input_handler，input_handle，3者之间的关系。一类handler可以和多个硬件设备相关联，一个硬件设备可以和多个handler相关联。例如：一个触摸屏设备可以作为一个event设备，作为一个鼠标设备，也可以作为一个触摸设备，所以一个设备需要与多个平台驱动进行连接。而一个平台驱动也不只为一个设备服务，一个触摸平台驱动可能要为A,B,C3个触摸设备提供上层驱动，所以需要这样一对多的连接。

下面来看看input字符设备注册过程：

1. staticint __init input_init(void)
2. {
3. int err;
5. input_init_abs_bypass();
6. /*创建一个类input_class*/
7. err = class_register(&input_class);
8. if (err) {
9. printk(KERN_ERR"input: unable to register input_dev class/n");
10. return err;
11. }
12. /*在/proc下创建入口项*/
13. err = input_proc_init();
14. if (err)
15. goto fail1;
16. /*注册设备号INPUT_MAJOR的设备，记住input子系统的设备的主设备号都是13，即INPUT_MAJOR为13，并与input_fops相关联*/
17. err = register_chrdev(INPUT_MAJOR,"input", &input_fops);
18. if (err) {
19. printk(KERN_ERR"input: unable to register char major %d", INPUT_MAJOR);
20. goto fail2;
21. }
23. return 0;
25. fail2: input_proc_exit();
26. fail1: class_unregister(&input_class);
27. return err;
28. }
29. subsys_initcall(input_init);

下面来看input子系统的file_operations，这里只有一个打开函数input_open_file，这个在事件传递部分讲解。

1. staticconststruct file_operations input_fops = {
2. .owner = THIS_MODULE,
3. .open = input_open_file,
4. };

下边来看input_dev设备的注册：

1. int input_register_device(struct input_dev *dev)
2. {
3. static atomic_t input_no = ATOMIC_INIT(0);
4. struct input_handler *handler;
5. constchar *path;
6. int error;
8. __set_bit(EV_SYN, dev->evbit);
10. /*
11. * If delay and period are pre-set by the driver, then autorepeating
12. * is handled by the driver itself and we don't do it in input.c.
13. */
15. init_timer(&dev->timer);
16. /*
17. *rep主要是处理重复按键，如果没有定义dev->rep[REP_DELAY]和dev->rep[REP_PERIOD],
18. *则将其赋值为默认值。dev->rep[REP_DELAY]是指第一次按下多久算一次，这里是250ms，
19. *dev->rep[REP_PERIOD]指如果按键没有被抬起，每33ms算一次。
20. */
21. if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
22. dev->timer.data = (long) dev;
23. dev->timer.function = input_repeat_key;
24. dev->rep[REP_DELAY] = 250;
25. dev->rep[REP_PERIOD] = 33;
26. }
27. /*如果dev没有定义getkeycode和setkeycode，则赋默认值。他们的作用一个是获得键的扫描码，一个是设置键的扫描码*/
28. if (!dev->getkeycode)
29. dev->getkeycode = input_default_getkeycode;
31. if (!dev->setkeycode)
32. dev->setkeycode = input_default_setkeycode;
34. dev_set_name(&dev->dev,"input%ld",
35. (unsignedlong) atomic_inc_return(&input_no) - 1);
36. /*将input_dev封装的dev注册到sysfs*/
37. error = device_add(&dev->dev);
38. if (error)
39. return error;
41. path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
42. printk(KERN_INFO"input: %s as %s/n",
43. dev->name ? dev->name :"Unspecified device", path ? path :"N/A");
44. kfree(path);
46. error = mutex_lock_interruptible(&input_mutex);
47. if (error) {
48. device_del(&dev->dev);
49. return error;
50. }
51. /*将input_dev挂在input_dev_list上*/
52. list_add_tail(&dev->node, &input_dev_list);
53. /*匹配所有的input_handler，这个就是刚才那幅图里的一个设备对应多个handler的由来*/
54. list_for_each_entry(handler, &input_handler_list, node)
55. input_attach_handler(dev, handler);
57. input_wakeup_procfs_readers();
59. mutex_unlock(&input_mutex);
61. return 0;
62. }

跟踪程序，来看看input_attach_handler的实现：

1. staticint input_attach_handler(struct input_dev *dev, struct input_handler *handler)
2. {
3. conststruct input_device_id *id;
4. int error;
5. /*handler有一个黑名单，如果存在黑名单，并且这个id匹配就退出*/
6. if (handler->blacklist && input_match_device(handler->blacklist, dev))
7. return -ENODEV;
8. /*匹配id，实现在下边可以看到*/
9. id = input_match_device(handler->id_table, dev);
10. if (!id)
11. return -ENODEV;
12. /*如果匹配，则调用具体的handler的connect函数*/
13. error = handler->connect(handler, dev, id);
14. if (error && error != -ENODEV)
15. printk(KERN_ERR
16. "input: failed to attach handler %s to device %s, "
17. "error: %d/n",
18. handler->name, kobject_name(&dev->dev.kobj), error);
20. return error;
21. }

下边来看看这个匹配函数：如果id->flags存在，并且相应的标志为被设定则进行比较。

1. staticconststruct input_device_id *input_match_device(conststruct input_device_id *id,
2. struct input_dev *dev)
3. {
4. int i;
6. for (; id->flags || id->driver_info; id++) {
8. if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
9. if (id->bustype != dev->id.bustype)
10. continue;
12. if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
13. if (id->vendor != dev->id.vendor)
14. continue;
16. if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
17. if (id->product != dev->id.product)
18. continue;
20. if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
21. if (id->version != dev->id.version)
22. continue;
24. MATCH_BIT(evbit, EV_MAX);
25. MATCH_BIT(keybit, KEY_MAX);
26. MATCH_BIT(relbit, REL_MAX);
27. MATCH_BIT(absbit, ABS_MAX);
28. MATCH_BIT(mscbit, MSC_MAX);
29. MATCH_BIT(ledbit, LED_MAX);
30. MATCH_BIT(sndbit, SND_MAX);
31. MATCH_BIT(ffbit, FF_MAX);
32. MATCH_BIT(swbit, SW_MAX);
34. return id;
35. }
37. return NULL;
38. }

1. #define MATCH_BIT(bit, max) /
2. for (i = 0; i < BITS_TO_LONGS(max); i++) /
3. if ((id->bit[i] & dev->bit[i]) != id->bit[i]) /
4. break; /
5. if (i != BITS_TO_LONGS(max)) /
6. continue;

Input_dev和input_handler匹配后调用input_handler的connect。以evdev_handler为例： 如果匹配上了就会创建一个evdev，它里边封装了一个handle，会把input_dev和input_handler关联到一起。

1. /*
2. * Create new evdev device. Note that input core serializes calls
3. * to connect and disconnect so we don't need to lock evdev_table here.
4. */
5. staticint evdev_connect(struct input_handler *handler, struct input_dev *dev,
6. conststruct input_device_id *id)
7. {
8. struct evdev *evdev;
9. int minor;
10. int error;
11. /*
12. *首先补充几个知识点：
13. *static struct input_handler *input_table[8];
14. *#define INPUT_DEVICES 256
15. *一共有8个input_handler，对应256个设备，所以一个handler对应32个设备。
16. *这个问题在我参加的一次linux驱动的面试中被问到，当时真是汗啊！！！
17. *static struct evdev *evdev_table[EVDEV_MINORS];
18. *#define EVDEV_MINORS 32
19. *evdev理论上可对应32个设备，其对应的设备节点一般位于/dev/input/event0~/dev/input/event4
20. *下边的for循环，在evdev_table数组中找一个未使用的地方
21. */
22. for (minor = 0; minor < EVDEV_MINORS; minor++)
23. if (!evdev_table[minor])
24. break;
26. if (minor == EVDEV_MINORS) {
27. printk(KERN_ERR"evdev: no more free evdev devices/n");
28. return -ENFILE;
29. }
30. /*下边的代码是为每一个匹配的设备分配一个evdev结构体，并对成员进行初始化*/
31. evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
32. if (!evdev)
33. return -ENOMEM;
35. INIT_LIST_HEAD(&evdev->client_list);
36. spin_lock_init(&evdev->client_lock);
37. mutex_init(&evdev->mutex);
38. init_waitqueue_head(&evdev->wait);
40. snprintf(evdev->name,sizeof(evdev->name),"event%d", minor);
41. evdev->exist = 1;
42. evdev->minor = minor;
44. evdev->handle.dev = input_get_device(dev);
45. evdev->handle.name = evdev->name;
46. evdev->handle.handler = handler;
47. evdev->handle.private = evdev;
49. dev_set_name(&evdev->dev, evdev->name);
50. evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);
51. evdev->dev.class = &input_class; /*调用函数创建字符设备节点*/
52. evdev->dev.parent = &dev->dev;
53. evdev->dev.release = evdev_free;
54. /**/
55. device_initialize(&evdev->dev);
56. /*
57. *input_register_handle完成的主要功能是:
58. *list_add_tail_rcu(&handle->d_node, &dev->h_list);
59. *list_add_tail(&handle->h_node, &handler->h_list);
60. */
61. error = input_register_handle(&evdev->handle);
62. if (error)
63. goto err_free_evdev;
64. /*evdev_install_chrdev完成的功能是evdev_table[evdev->minor]=evdev;*/
65. error = evdev_install_chrdev(evdev);
66. if (error)
67. goto err_unregister_handle;
69. error = device_add(&evdev->dev);
70. if (error)
71. goto err_cleanup_evdev;
73. return 0;
74. 。。。。。。。。。。
75. }

input子系统最重要的部分就是向上层report了。这里还是先介绍几个数据结构：

1. struct input_event {
2. struct timeval time; //事件发生的时间
3. __u16 type;//事件类型
4. __u16 code;//子事件
5. __s32 value;//事件的value
6. };

1. struct evdev_client {
2. struct input_event buffer[EVDEV_BUFFER_SIZE]; //可以同时管理EVDEV_BUFFER_SIZE(64)个事件
3. int head; //存储事件从head开始
4. int tail; //取出事件从tail开始
5. spinlock_t buffer_lock;/* protects access to buffer, head and tail */
6. struct fasync_struct *fasync; //异步通知事件发生
7. struct evdev *evdev; //指向本evdev_client归属的evdev
8. struct list_head node; //用于挂载到evdev的链表头client_list上
9. };

1. staticstruct input_handler evdev_handler = {
2. .event = evdev_event, //向系统报告input事件，系统通过read方法读取
3. .connect = evdev_connect,//和input_dev匹配后调用connect构建
4. .disconnect = evdev_disconnect,
5. .fops = &evdev_fops,//event设备文件的操作方法
6. .minor = EVDEV_MINOR_BASE,//次设备号基准值
7. .name ="evdev",
8. .id_table = evdev_ids,//匹配规则
9. };

这里的次设备号是EVDEV_MINOR_BASE(64)，也就是说evdev_handler所表示的设备文件范围(13,64)~(13,64+32)。
如下一个结构体:evdev_handler匹配所有设备。

1. staticconststruct input_device_id evdev_ids[] = {
2. { .driver_info = 1 },/* Matches all devices */
3. { },/* Terminating zero entry */
4. };

看一下这张图会对上边的结构有清楚的认知了：

这个是evdev_handler是fops，下面的讲解中会用到其中的open,read函数。

1. staticconststruct file_operations evdev_fops = {
2. .owner = THIS_MODULE,
3. .read = evdev_read,
4. .write = evdev_write,
5. .poll = evdev_poll,
6. .open = evdev_open,
7. .release = evdev_release,
8. .unlocked_ioctl = evdev_ioctl,
9. #ifdef CONFIG_COMPAT
10. .compat_ioctl = evdev_ioctl_compat,
11. #endif
12. .fasync = evdev_fasync,
13. .flush = evdev_flush
14. };

在驱动程序中我们会调用input_report_abs等函数：

设备驱动通过宏set_bit()告诉input子系统它支持哪些事件，如下所示

set_bit(EV_KEY, input_dev->keybit); //EV_KEY事件支持的事件码
struct input_dev中有两个成员，一个是 unsigned long evbit ，一个是 unsigned long keybit ，分别用来表示设备所支持的事件类型和按键类型。

用于报告EV_KEY、EV_REL、EV_ABS、EV_FF、EV_SW等事件的函数有：

void input_report_key(struct input_dev *dev, unsigned int code, int value)
void input_report_rel(struct input_dev *dev, unsigned int code, int value)
void input_report_abs(struct input_dev *dev, unsigned int code, int value)
void input_report_ff_status(struct input_dev *dev, unsigned int code, int value)

void input_report_switch(struct input_dev *dev, unsigned int code, int value)

如果你觉得麻烦，你也可以只记住1个函数（因为上述函数都是通过它实现的）

void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)

相关参数介绍：
code：

事件的代码。如果事件的类型是EV_KEY,该代码code为设备键盘代码。代码值0-127为键盘上的按键代码，0x110-0x116为鼠标上按键代码，其中0x110(BTN_LEFT)为鼠标左键，0x111(BTN_RIGHT)为鼠标右键，0x112(BTN_MIDDLE)为鼠标中键。其它代码含义请参看include/linux/input.h文件。

value：

事件的值。如果事件的类型是EV_KEY，当按键按下时值为1,松开时值为0.

事件报告完毕后，设备驱动需要使用input_sync函数告诉输入子系统一个完整的报告已经发送。
void input_sync(struct input_dev *dev)
{
input_event(dev,EV_SYN,SYN_REPORT,0);
}
这一点在鼠标移动处理中很重要，因为鼠标坐标的X分量和Y分量是分开传送的，需要利用 input_sync函数来同步。
跟踪input_event如下：

1. void input_event(struct input_dev *dev,
2. unsignedint type, unsignedint code, int value)
3. {
4. unsignedlong flags;
6. if (is_event_supported(type, dev->evbit, EV_MAX)) {
8. spin_lock_irqsave(&dev->event_lock, flags);
9. /*利用输入值调正随机数产生器*/
10. add_input_randomness(type, code, value);
11. input_handle_event(dev, type, code, value);
12. spin_unlock_irqrestore(&dev->event_lock, flags);
13. }
14. }

跟踪input_handle_event如下：

1. staticvoid input_handle_event(struct input_dev *dev,
2. unsignedint type, unsignedint code, int value)
3. {
4. int disposition = INPUT_IGNORE_EVENT;
6. switch (type) {
7. 。。。。。。。。。。。。。。。。
8. if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)
9. dev->sync = 0;
11. if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
12. dev->event(dev, type, code, value);
14. if (disposition & INPUT_PASS_TO_HANDLERS)
15. input_pass_event(dev, type, code, value);
16. }

如果该事件需要input device来完成，就会将disposition设置成INPUT_PASS_TO_DEVICE，如果需要input handler来完成，就会将disposition设置成INPUT_PASS_TO_DEVICE，如果需要两者都参与，则将disposition设置成INPUT_PASS_TO_ALL。
跟踪input_pass_event如下：

1. staticvoid input_pass_event(struct input_dev *dev,
2. unsignedint type, unsignedint code, int value)
3. {
4. struct input_handle *handle;
6. rcu_read_lock();
7. /**/
8. handle = rcu_dereference(dev->grab);
9. if (handle)
10. /*如果input_dev的grab指向了一个handle，就用这个handle关联的handler的event，否则遍历整个挂在input_dev的h_list上的handle关联的handler*/
11. handle->handler->event(handle, type, code, value);
12. else
13. list_for_each_entry_rcu(handle, &dev->h_list, d_node)
14. if (handle->open)
15. handle->handler->event(handle,
16. type, code, value);
17. rcu_read_unlock();
18. }

比如下边的evdev_handler的evdev_event：

1. staticvoid evdev_event(struct input_handle *handle,
2. unsignedint type, unsignedint code, int value)
3. {
4. struct evdev *evdev = handle->private;
5. struct evdev_client *client;
6. struct input_event event;
8. do_gettimeofday(&event.time);
9. event.type = type;
10. event.code = code;
11. event.value = value;
13. rcu_read_lock();
14. client = rcu_dereference(evdev->grab);
15. if (client)
16. /*如果evdev->grab指向一个当前使用的client就将event放到这个client的buffer中，否则放到整个client_list上的client的链表中*/
17. evdev_pass_event(client, &event);
18. else
19. list_for_each_entry_rcu(client, &evdev->client_list, node)
20. evdev_pass_event(client, &event);
22. rcu_read_unlock();
24. wake_up_interruptible(&evdev->wait);
25. }

1. staticvoid evdev_pass_event(struct evdev_client *client,
2. struct input_event *event)
3. {
4. /*
5. * Interrupts are disabled, just acquire the lock
6. */
7. spin_lock(&client->buffer_lock);
8. /*将event装入client的buffer中，buffer是一个环形缓存区*/
9. client->buffer[client->head++] = *event;
10. client->head &= EVDEV_BUFFER_SIZE - 1;
11. spin_unlock(&client->buffer_lock);
13. kill_fasync(&client->fasync, SIGIO, POLL_IN);
14. }

这里总结一下事件的传递过程：首先在驱动层中，调用inport_report_abs，然后他调用了input core层的input_event，input_event调用了input_handle_event对事件进行分派，调用input_pass_event，在这里他会把事件传递给具体的handler层，然后在相应handler的event处理函数中，封装一个event，然后把它投入evdev的那个client_list上的client的事件buffer中，等待用户空间来读取。

当用户空间打开设备节点/dev/input/event0~/dev/input/event4的时候，会使用input_fops中的input_open_file()函数，input_open_file()->evdev_open()(如果handler是evdev的话)->evdev_open_device()->input_open_device()->dev->open()。也就是struct file_operations input_fops提供了通用接口，最终会调用具体input_dev的open函数。下边看一下用户程序打开文件时的过程，首先调用了input_open_file:

1. staticint input_open_file(struct inode *inode, struct file *file)
2. {
3. struct input_handler *handler;
4. conststruct file_operations *old_fops, *new_fops = NULL;
5. int err;
7. lock_kernel();
8. /* No load-on-demand here? */
9. /*因为32个input_dev公共一个handler所以低5位应该是相同的*/
10. handler = input_table[iminor(inode) >> 5];
11. if (!handler || !(new_fops = fops_get(handler->fops))) {
12. err = -ENODEV;
13. gotoout;
14. }
16. /*
17. * That's _really_ odd. Usually NULL ->open means "nothing special",
18. * not "no device". Oh, well...
19. */
20. if (!new_fops->open) {
21. fops_put(new_fops);
22. err = -ENODEV;
23. gotoout;
24. }
25. /*保存以前的fops，使用相应的handler的fops*/
26. old_fops = file->f_op;
27. file->f_op = new_fops;
29. err = new_fops->open(inode, file);
31. if (err) {
32. fops_put(file->f_op);
33. file->f_op = fops_get(old_fops);
34. }
35. fops_put(old_fops);
36. out:
37. unlock_kernel();
38. return err;
39. }

这里还是假设handler是evdev_handler。

1. staticint evdev_open(struct inode *inode, struct file *file)
2. {
3. struct evdev *evdev;
4. struct evdev_client *client;
5. /*因为次设备号是从EVDEV_MINOR_BASE开始的*/
6. int i = iminor(inode) - EVDEV_MINOR_BASE;
7. int error;
9. if (i >= EVDEV_MINORS)
10. return -ENODEV;
12. error = mutex_lock_interruptible(&evdev_table_mutex);
13. if (error)
14. return error;
15. /*evdev_table一共可容纳32个成员，找到次设备号对应的那个*/
16. evdev = evdev_table[i];
17. if (evdev)
18. get_device(&evdev->dev);
19. mutex_unlock(&evdev_table_mutex);
21. if (!evdev)
22. return -ENODEV;
23. /*打开的时候创建一个client*/
24. client = kzalloc(sizeof(struct evdev_client), GFP_KERNEL);
25. if (!client) {
26. error = -ENOMEM;
27. goto err_put_evdev;
28. }
30. spin_lock_init(&client->buffer_lock);
31. /*下边两句的作用就是将evdev和client绑定到一起*/
32. client->evdev = evdev;
33. evdev_attach_client(evdev, client);
35. error = evdev_open_device(evdev);
36. if (error)
37. goto err_free_client;
38. /*将file->private_data指向刚刚建的client，后边会用到的*/
39. file->private_data = client;
40. return 0;
42. err_free_client:
43. evdev_detach_client(evdev, client);
44. kfree(client);
45. err_put_evdev:
46. put_device(&evdev->dev);
47. return error;
48. }

1. staticint evdev_open_device(struct evdev *evdev)
2. {
3. int retval;
5. retval = mutex_lock_interruptible(&evdev->mutex);
6. if (retval)
7. return retval;
8. /*如果设备不存在，返回错误*/
9. if (!evdev->exist)
10. retval = -ENODEV;
11. /*如果是被第一次打开，则调用input_open_device*/
12. elseif (!evdev->open++) {
13. retval = input_open_device(&evdev->handle);
14. if (retval)
15. evdev->open--;
16. }
18. mutex_unlock(&evdev->mutex);
19. return retval;
20. }

1. int input_open_device(struct input_handle *handle)
2. {
3. struct input_dev *dev = handle->dev;
4. int retval;
6. retval = mutex_lock_interruptible(&dev->mutex);
7. if (retval)
8. return retval;
10. if (dev->going_away) {
11. retval = -ENODEV;
12. gotoout;
13. }
15. handle->open++;
17. if (!dev->users++ && dev->open)
18. retval = dev->open(dev);
20. if (retval) {
21. dev->users--;
22. if (!--handle->open) {
23. /*
24. * Make sure we are not delivering any more events
25. * through this handle
26. */
27. synchronize_rcu();
28. }
29. }
31. out:
32. mutex_unlock(&dev->mutex);
33. return retval;
34. }

下面是用户进程读取event的底层实现：

1. static ssize_t evdev_read(struct file *file, char __user *buffer,
2. size_t count, loff_t *ppos)
3. {
4. /*这个就是刚才在open函数中*/
5. struct evdev_client *client = file->private_data;
6. struct evdev *evdev = client->evdev;
7. struct input_event event;
8. int retval;
10. if (count < input_event_size())
11. return -EINVAL;
12. /*如果client的环形缓冲区中没有数据并且是非阻塞的，那么返回-EAGAIN，也就是try again*/
13. if (client->head == client->tail && evdev->exist &&
14. (file->f_flags & O_NONBLOCK))
15. return -EAGAIN;
16. /*如果没有数据，并且是阻塞的，则在等待队列上等待吧*/
17. retval = wait_event_interruptible(evdev->wait,
18. client->head != client->tail || !evdev->exist);
19. if (retval)
20. return retval;
22. if (!evdev->exist)
23. return -ENODEV;
24. /*如果获得了数据则取出来，调用evdev_fetch_next_event*/
25. while (retval + input_event_size() <= count &&
26. evdev_fetch_next_event(client, &event)) {
27. /*input_event_to_user调用copy_to_user传入用户程序中，这样读取完成*/
28. if (input_event_to_user(buffer + retval, &event))
29. return -EFAULT;
31. retval += input_event_size();
32. }
34. return retval;
35. }

1. staticint evdev_fetch_next_event(struct evdev_client *client,
2. struct input_event *event)
3. {
4. int have_event;
6. spin_lock_irq(&client->buffer_lock);
7. /*先判断一下是否有数据*/
8. have_event = client->head != client->tail;
9. /*如果有就从环形缓冲区的取出来，记得是从head存储，tail取出*/
10. if (have_event) {
11. *event = client->buffer[client->tail++];
12. client->tail &= EVDEV_BUFFER_SIZE - 1;
13. }
15. spin_unlock_irq(&client->buffer_lock);
17. return have_event;
18. }

1. int input_event_to_user(char __user *buffer,
2. conststruct input_event *event)
3. {
4. /*如果设置了标志INPUT_COMPAT_TEST就将事件event包装成结构体compat_event*/
5. if (INPUT_COMPAT_TEST) {
6. struct input_event_compat compat_event;
8. compat_event.time.tv_sec =event->time.tv_sec;
9. compat_event.time.tv_usec =event->time.tv_usec;
10. compat_event.type =event->type;
11. compat_event.code =event->code;
12. compat_event.value =event->value;
13. /*将包装成的compat_event拷贝到用户空间*/
14. if (copy_to_user(buffer, &compat_event,
15. sizeof(struct input_event_compat)))
16. return -EFAULT;
18. }else {
19. /*否则，将event拷贝到用户空间*/
20. if (copy_to_user(buffer, event,sizeof(struct input_event)))
21. return -EFAULT;
22. }
24. return 0;
25. }

这里总结一下：如果两个进程打开同一个文件，每个进程在打开时都会生成一个evdev_client，evdev_client被挂在evdev的client_list，在handle收到一个事件的时候，会把事件copy到挂在client_list上的所有evdev_client的buffer中。这样所有打开同一个设备的进程都会收到这个消息而唤醒。