输入子系统架构分析

短命女 2022-03-26 18:11 285阅读 0赞

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

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

先来看一下输入子系统体系架构图：  
 ![Image 1][]  
  
再对照 下图（ input输入子系统框架 ），很清楚的知道输入子系统是由输入子系统核心层（ Input Core ），驱动层和事件处理层（Event Handler）三部份组成。一个输入事件，如鼠标移动，键盘按键按下，joystick的移动等等通过 input driver -> Input core -> Event handler -> userspace 到达用户空间传给应用程序。  
 ![Image 1][]  
注意：keyboard.c不会在/dev/input下产生节点，而是作为ttyn终端（不包括串口终端）的输入。

设备描述

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

1.  **struct** input\_dev \{  
2.      **const** **char** \*name;     //名称                              
3.      **const** **char** \*phys;  //设备在系统中的物理路径
4.      **const** **char** \*uniq;  //设备唯一识别符
5.      **struct** input\_id id; //设备ID，包含总线ID（PCI、USB）、厂商ID，与input\_handler匹配的时会用到  
6.    
7.      unsigned **long** evbit\[BITS\_TO\_LONGS(EV\_CNT)\];     //支持的所有事件类型  
8.      unsigned **long** keybit\[BITS\_TO\_LONGS(KEY\_CNT)\];   //支持的键盘事件  
9.      unsigned **long** relbit\[BITS\_TO\_LONGS(REL\_CNT)\];   //支持的鼠标相对值事件  
10.     unsigned **long** absbit\[BITS\_TO\_LONGS(ABS\_CNT)\];   //支持的鼠标绝对值事件  
11.     unsigned **long** mscbit\[BITS\_TO\_LONGS(MSC\_CNT)\];   //支持的其它事件类型  
12.     unsigned **long** ledbit\[BITS\_TO\_LONGS(LED\_CNT)\];   //支持的LED灯事件  
13.     unsigned **long** sndbit\[BITS\_TO\_LONGS(SND\_CNT)\];   //支持的声效事件 
14.     unsigned **long** ffbit\[BITS\_TO\_LONGS(FF\_CNT)\];     //支持的力反馈事件  
15.     unsigned **long** swbit\[BITS\_TO\_LONGS(SW\_CNT)\];     //支持的开关事件  
16.   
17.     unsigned **int** keycodemax;  //keycode表的大小
18.     unsigned **int** 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表  
22.   
23.     **struct** ff\_device \*ff;  
24.   
25.     unsigned **int** repeat\_key;//保存上一个键值  
26.     **struct** timer\_list timer;  
27.   
28.     **int** sync;  
29.   
30.     **int** abs\[ABS\_MAX + 1\];             //绝对坐标上报的当前值  
31.     **int** rep\[REP\_MAX + 1\];             //这个参数主要是处理重复按键，后面遇到再讲  
32.     unsigned **long** key\[BITS\_TO\_LONGS(KEY\_CNT)\]; //按键有两种状态，按下和抬起，这个字段就是记录这两个状态。  
33.     unsigned **long** led\[BITS\_TO\_LONGS(LED\_CNT)\];  
34.     unsigned **long** snd\[BITS\_TO\_LONGS(SND\_CNT)\];  
35.     unsigned **long** sw\[BITS\_TO\_LONGS(SW\_CNT)\];  
36.   
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);  
46.   
47.     **struct** input\_handle \*grab;         //当前使用的handle  
48.   
49.     spinlock\_t event\_lock;  
50.     **struct** mutex mutex;  
51.   
52.     unsigned **int** users;  
53.     **int** going\_away;  
54.   
55.     **struct** device dev;  
56.   
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 \{  
62.   
63.     **void** \***private**;  
64.   
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, **const** **struct** input\_device\_id \*id);  
67.     **void** (\*disconnect)(**struct** input\_handle \*handle);  
68.     **void** (\*start)(**struct** input\_handle \*handle);  
69.   
70.     **const** **struct** file\_operations \*fops;  
71.     **int** minor;                               //次设备号  
72.     **const** **char** \*name;  
73.   
74.     **const** **struct** input\_device\_id \*id\_table;  
75.     **const** **struct** input\_device\_id \*blacklist;  
76.   
77.     **struct** list\_head    h\_list;    //h\_list是一个链表头，用来把handle挂载在这个上  
78.     **struct** list\_head    node;      //这个node是用来连到input\_handler\_list上的  
79. \};  
80.   
81. **struct** input\_handle \{  
82.   
83.     **void** \***private**;  
84.   
85.     **int** open;  
86.     **const** **char** \*name;  
87.   
88.     **struct** input\_dev \*dev;              //指向input\_dev  
89.     **struct** input\_handler \*handler;      //指向input\_handler  
90.   
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个触摸设备提供上层驱动，所以需要这样一对多的连接。  
 ![Image 1][]

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

1.  **static** **int** \_\_init input\_init(**void**)  
2.  \{  
3.      **int** err;  
4.    
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.     \}  
22.   
23.     **return** 0;  
24.   
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.  **static** **const** **struct** 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.      **const** **char** \*path;  
6.      **int** error;  
7.    
8.      \_\_set\_bit(EV\_SYN, dev->evbit);  
9.    
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.      \*/  
14.   
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;  
30.   
31.     **if** (!dev->setkeycode)  
32.         dev->setkeycode = input\_default\_setkeycode;  
33.   
34.     dev\_set\_name(&dev->dev, "input%ld",  
35.              (unsigned **long**) atomic\_inc\_return(&input\_no) - 1);  
36.     /\*将input\_dev封装的dev注册到sysfs\*/  
37.     error = device\_add(&dev->dev);  
38.     **if** (error)  
39.         **return** error;  
40.   
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);  
45.   
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);  
56.   
57.     input\_wakeup\_procfs\_readers();  
58.   
59.     mutex\_unlock(&input\_mutex);  
60.   
61.     **return** 0;  
62. \}

跟踪程序，来看看input\_attach\_handler的实现：

1.  **static** **int** input\_attach\_handler(**struct** input\_dev \*dev, **struct** input\_handler \*handler)  
2.  \{  
3.      **const** **struct** 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);  
19.   
20.     **return** error;  
21. \}

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

1.  **static** **const** **struct** input\_device\_id \*input\_match\_device(**const** **struct** input\_device\_id \*id,  
2.                              **struct** input\_dev \*dev)  
3.  \{  
4.      **int** i;  
5.    
6.      **for** (; id->flags || id->driver\_info; id++) \{  
7.    
8.          **if** (id->flags & INPUT\_DEVICE\_ID\_MATCH\_BUS)  
9.              **if** (id->bustype != dev->id.bustype)  
10.                 **continue**;  
11.   
12.         **if** (id->flags & INPUT\_DEVICE\_ID\_MATCH\_VENDOR)  
13.             **if** (id->vendor != dev->id.vendor)  
14.                 **continue**;  
15.   
16.         **if** (id->flags & INPUT\_DEVICE\_ID\_MATCH\_PRODUCT)  
17.             **if** (id->product != dev->id.product)  
18.                 **continue**;  
19.   
20.         **if** (id->flags & INPUT\_DEVICE\_ID\_MATCH\_VERSION)  
21.             **if** (id->version != dev->id.version)  
22.                 **continue**;  
23.   
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);  
33.   
34.         **return** id;  
35.     \}  
36.   
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.  **static** **int** evdev\_connect(**struct** input\_handler \*handler, **struct** input\_dev \*dev,  
6.               **const** **struct** 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**;  
25.   
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;  
34.   
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);  
39.   
40.     snprintf(evdev->name, **sizeof**(evdev->name), "event%d", minor);  
41.     evdev->exist = 1;  
42.     evdev->minor = minor;  
43.   
44.     evdev->handle.dev = input\_get\_device(dev);  
45.     evdev->handle.name = evdev->name;  
46.     evdev->handle.handler = handler;  
47.     evdev->handle.**private** = evdev;  
48.   
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;  
68.   
69.     error = device\_add(&evdev->dev);  
70.     **if** (error)  
71.         **goto** err\_cleanup\_evdev;  
72.   
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.  **static** **struct** 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.  **static** **const** **struct** input\_device\_id evdev\_ids\[\] = \{  
2.      \{ .driver\_info = 1 \},   /\* Matches all devices \*/  
3.      \{ \},            /\* Terminating zero entry \*/  
4.  \};

看一下这张图会对上边的结构有清楚的认知了：  
 ![Image 1][]   
这个是evdev\_handler是fops，下面的讲解中会用到其中的open,read函数。

1.  **static** **const** **struct** 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.           unsigned **int** type, unsigned **int** code, **int** value)  
3.  \{  
4.      unsigned **long** flags;  
5.    
6.      **if** (is\_event\_supported(type, dev->evbit, EV\_MAX)) \{  
7.    
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.  **static** **void** input\_handle\_event(**struct** input\_dev \*dev,  
2.                     unsigned **int** type, unsigned **int** code, **int** value)  
3.  \{  
4.      **int** disposition = INPUT\_IGNORE\_EVENT;  
5.    
6.      **switch** (type) \{  
7.      。。。。。。。。。。。。。。。。  
8.      **if** (disposition != INPUT\_IGNORE\_EVENT && type != EV\_SYN)  
9.          dev->sync = 0;  
10.   
11.     **if** ((disposition & INPUT\_PASS\_TO\_DEVICE) && dev->**event**)  
12.         dev->**event**(dev, type, code, value);  
13.   
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.  **static** **void** input\_pass\_event(**struct** input\_dev \*dev,  
2.                   unsigned **int** type, unsigned **int** code, **int** value)  
3.  \{  
4.      **struct** input\_handle \*handle;  
5.    
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.  **static** **void** evdev\_event(**struct** input\_handle \*handle,  
2.              unsigned **int** type, unsigned **int** code, **int** value)  
3.  \{  
4.      **struct** evdev \*evdev = handle->**private**;  
5.      **struct** evdev\_client \*client;  
6.      **struct** input\_event **event**;  
7.    
8.      do\_gettimeofday(&**event**.time);  
9.      **event**.type = type;  
10.     **event**.code = code;  
11.     **event**.value = value;  
12.   
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**);  
21.   
22.     rcu\_read\_unlock();  
23.   
24.     wake\_up\_interruptible(&evdev->wait);  
25. \}

1.  **static** **void** 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);  
12.   
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.  **static** **int** input\_open\_file(**struct** inode \*inode, **struct** file \*file)  
2.  \{  
3.      **struct** input\_handler \*handler;  
4.      **const** **struct** file\_operations \*old\_fops, \*new\_fops = NULL;  
5.      **int** err;  
6.    
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.         **goto** **out**;  
14.     \}  
15.   
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.         **goto** **out**;  
24.     \}  
25.     /\*保存以前的fops，使用相应的handler的fops\*/  
26.     old\_fops = file->f\_op;  
27.     file->f\_op = new\_fops;  
28.   
29.     err = new\_fops->open(inode, file);  
30.   
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.  **static** **int** 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;  
8.        
9.      **if** (i >= EVDEV\_MINORS)  
10.         **return** -ENODEV;  
11.   
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);  
20.   
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.     \}  
29.   
30.     spin\_lock\_init(&client->buffer\_lock);  
31.     /\*下边两句的作用就是将evdev和client绑定到一起\*/  
32.     client->evdev = evdev;  
33.     evdev\_attach\_client(evdev, client);  
34.   
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;  
41.   
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.  **static** **int** evdev\_open\_device(**struct** evdev \*evdev)  
2.  \{  
3.      **int** retval;  
4.    
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.     **else** **if** (!evdev->open++) \{  
13.         retval = input\_open\_device(&evdev->handle);  
14.         **if** (retval)  
15.             evdev->open--;  
16.     \}  
17.   
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;  
5.    
6.      retval = mutex\_lock\_interruptible(&dev->mutex);  
7.      **if** (retval)  
8.          **return** retval;  
9.    
10.     **if** (dev->going\_away) \{  
11.         retval = -ENODEV;  
12.         **goto** **out**;  
13.     \}  
14.   
15.     handle->open++;  
16.   
17.     **if** (!dev->users++ && dev->open)  
18.         retval = dev->open(dev);  
19.   
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.     \}  
30.   
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;  
9.    
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;  
21.   
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;  
30.   
31.         retval += input\_event\_size();  
32.     \}  
33.   
34.     **return** retval;  
35. \}

1.  **static** **int** evdev\_fetch\_next\_event(**struct** evdev\_client \*client,  
2.                    **struct** input\_event \***event**)  
3.  \{  
4.      **int** have\_event;  
5.    
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.     \}  
14.   
15.     spin\_unlock\_irq(&client->buffer\_lock);  
16.   
17.     **return** have\_event;  
18. \}

1.  **int** input\_event\_to\_user(**char** \_\_user \*buffer,  
2.              **const** **struct** input\_event \***event**)  
3.  \{  
4.      /\*如果设置了标志INPUT\_COMPAT\_TEST就将事件event包装成结构体compat\_event\*/  
5.      **if** (INPUT\_COMPAT\_TEST) \{  
6.          **struct** input\_event\_compat compat\_event;  
7.    
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;  
17.   
18.     \} **else** \{  
19.         /\*否则，将event拷贝到用户空间\*/  
20.         **if** (copy\_to\_user(buffer, **event**, **sizeof**(**struct** input\_event)))  
21.             **return** -EFAULT;  
22.     \}  
23.   
24.     **return** 0;  
25. \}

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

[Image 1]: