input 子系统架构总结【转】

客官°小女子只卖身不卖艺 2021-12-22 01:19 233阅读 0赞

#  #

# 　　Linux输入子系统(Input Subsystem) #

#  转自：[http://blog.csdn.net/lbmygf/article/details/7360084][http_blog.csdn.net_lbmygf_article_details_7360084] #

Linux 的输入子系统不仅支持鼠标、键盘等常规输入设备,而且还支持蜂鸣器、触摸屏等设备。本章将对 Linux 输

入子系统进行详细的分析。

**一 前言**

输入子系统又叫 input 子系统。其构建非常灵活,只需要调用一些简单的函数,就可以将一个输入设备的功能呈现

给应用程序。

![0_1331868635QkLK.gif][]

**二 设备驱动层**

本节将讲述一个简单的输入设备驱动实例。

这个输入设备只有一个按键,按键被连接到一条中断线上,当按键被按下时,将产生一个中断,内核将检测到这个中

断,并对其进行处理。该实例的代码如下:

\#include <asm/irq.h>

\#include <asm/io.h>

static struct input\_dev \*button\_dev; /\*输入设备结构体\*/  
  
static irqreturn\_t button\_interrupt(int irq, void \*dummy) /\*中断处理函数\*/  
\{  
**input\_report\_key**(button\_dev, BTN\_0, inb(BUTTON\_PORT) & 1); **/\*向输入子系统报告产生按键事件\*/**  
  
input\_sync(button\_dev); **/\*通知接收者,一个报告发送完毕\*/**  
  
return IRQ\_HANDLED;

static int \_\_init button\_init(void) /\*加载函数\*/  
\{  
  
int error;  
  
if (request\_irq(BUTTON\_IRQ, button\_interrupt, 0, "button", NULL)) **/\*申请中断，绑定中断处理函数\*/**  
\{  
printk(KERN\_ERR "button.c: Can't allocate irq %d\\n", button\_irq);  
  
return -EBUSY;  
\}

button\_dev = **input\_allocate\_device();**   **/\*分配一个设备结构体\*/**

**//input\_allocate\_device()函数在内存中为输入设备结构体分配一个空间,并对其主要的成员进行了初始化.**

if (!button\_dev)

\{  
printk(KERN\_ERR "button.c: Not enough memory\\n");  
error = -ENOMEM;  
  
goto err\_free\_irq;

button\_dev->evbit\[0\] = BIT\_MASK(EV\_KEY); **/\*设置按键信息\*/**

button\_dev->keybit\[BIT\_WORD(BTN\_0)\] = BIT\_MASK(BTN\_0);

**//分别用来设置设备所产生的事件以及上报的按键值。Struct iput\_dev中有两个成员，一个是evbit.一个是keybit.分别用**

**//表示设备****所支持的动作和键值。**

error = **input\_register\_device(button\_dev);** **/\*注册一个输入设备\*/**  
if (error)  
\{  
printk(KERN\_ERR "button.c: Failed to register device\\n");  
goto err\_free\_dev;  
\}

return 0;

err\_free\_dev:

input\_free\_device(button\_dev);

err\_free\_irq:  
free\_irq(BUTTON\_IRQ, button\_interrupt);  
return error;

static void \_\_exit button\_exit(void) /\*卸载函数\*/  
\{  
input\_unregister\_device(button\_dev); /\*注销按键设备\*/  
free\_irq(BUTTON\_IRQ, button\_interrupt); /\*释放按键占用的中断线\*/  
\}  
module\_init(button\_init);  
module\_exit(button\_exit);

这个实例程序代码比较简单,在初始化函数 button\_init()中注册了一个中断处理函数,然后调用

input\_allocate\_device()函数分配了一个 input\_dev 结构体,并调用 input\_register\_device()函数对其进行了注册。在中

断处理函数 button\_interrupt()中,实例将接收到的按键信息上报给 input 子系统。从而通过 input 子系统,向用户态程序

提供按键输入信息。本实例采用了中断方式,除了中断相关的代码外,实例中包含了一些 input 子系统提供的函数,现对

其中一些重要的函数进行分析。

**三 核心层**

**input\_allocate\_device()**函数,驱动开发人员为了更深入的了解 input 子系统,应该对其代码有一点的认识,该函数的代码

如下:

struct input\_dev \*input\_allocate\_device(void)  
\{  
struct input\_dev \*dev;  
  
dev = kzalloc(sizeof(struct input\_dev), GFP\_KERNEL); /\*分配一个 input\_dev 结构体,并初始化为 0\*/  
  
if (dev)

\{  
dev->dev.type = &input\_dev\_type; /\*初始化设备的类型\*/

dev->dev.class = &input\_class;

device\_initialize(&dev->dev);

mutex\_init(&dev->mutex); // 初始话互斥锁

spin\_lock\_init(&dev->event\_lock); // 初始化自旋锁

INIT\_LIST\_HEAD(&dev->h\_list); //初始化链表

INIT\_LIST\_HEAD(&dev->node);

\_\_module\_get(THIS\_MODULE);  
\}

return dev;

该函数返回一个指向 input\_dev 类型的指针,该结构体是一个输入设备结构体,包含了输入设备的一些相关信息,如

设备支持的按键码、设备的名称、设备支持的事件等。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

Input设备注册的接口为：**input\_register\_device()**。代码如下：

int input\_register\_device(struct input\_dev \*dev)  
\{  
static atomic\_t input\_no = ATOMIC\_INIT(0);  
struct input\_handler \*handler;  
const char \*path;  
int error;

\_\_set\_bit(EV\_SYN, dev->evbit);

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

调用\_\_set\_bit()函数设置 input\_dev 所支持的事件类型。事件类型由 input\_dev 的evbit 成员来表示,在这里将其 EV\_SYN 置位,表示设

备支持所有的事件。注意,一个设备可以支持一种或者多种事件类型。常用的事件类型如下:

1. \#define EV\_SYN 0x00 /\*表示设备支持所有的事件\*/  
2. \#define EV\_KEY 0x01 /\*键盘或者按键,表示一个键码\*/  
3. \#define EV\_REL 0x02 /\*鼠标设备,表示一个相对的光标位置结果\*/  
4. \#define EV\_ABS 0x03 /\*手写板产生的值,其是一个绝对整数值\*/  
5. \#define EV\_MSC 0x04 /\*其他类型\*/  
6. \#define EV\_LED 0x11 /\*LED 灯设备\*/  
7. \#define EV\_SND 0x12 /\*蜂鸣器,输入声音\*/  
8. \#define EV\_REP 0x14 /\*允许重复按键类型\*/  
9. \#define EV\_PWR 0x16 /\*电源管理事件\*/

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

/\*  
\* If delay and period are pre-set by the driver, then autorepeating  
\* is handled by the driver itself and we don't do it in input.c.  
\*/  
  
init\_timer(&dev->timer); //初始化一个 timer 定时器,这个定时器是为处理重复击键而定义的。  
if (!dev->rep\[REP\_DELAY\] && !dev->rep\[REP\_PERIOD\]) \{  
dev->timer.data = (long) dev;  
dev->timer.function = input\_repeat\_key;  
dev->rep\[REP\_DELAY\] = 250;  
dev->rep\[REP\_PERIOD\] = 33;  
\}  
//如果dev->rep\[REP\_DELAY\]和dev->rep\[REP\_PERIOD\]没有设值，则将其赋默认值。这主要是处理重复按键的.  
  
if (!dev->getkeycode)  
dev->getkeycode = input\_default\_getkeycode;  
  
if (!dev->setkeycode)

dev->setkeycode = input\_default\_setkeycode;

//检查 getkeycode()函数和 setkeycode()函数是否被定义,如果没定义,则使用默认的处理函数,这两个函数为

//input\_default\_getkeycode()和 input\_default\_setkeycode()。input\_default\_getkeycode()函数用来得到指定位置的键

//值。input\_default\_setkeycode()函数用来设置键值。**具体啥用处，我也没搞清楚？**

snprintf(dev->dev.bus\_id, sizeof(dev->dev.bus\_id),  
"input%ld", (unsigned long) atomic\_inc\_return(&input\_no) - 1);

//设置 input\_dev 中的 device 的名字,名字以 input0、input1、input2、input3、input4等的形式出现在 sysfs

//文件系统中.  
  
error = device\_add(&dev->dev);

if (error)

return error;

//使用 device\_add()函数将 input\_dev 包含的 device 结构注册到 Linux 设备模型中,并可以在 sysfs

//文件系统中表现出来。

path = kobject\_get\_path(&dev->dev.kobj, GFP\_KERNEL);  
printk(KERN\_INFO "input: %s as %s/n",  
dev->name ? dev->name : "Unspecified device", path ? path : "N/A");  
kfree(path);  
  
error = mutex\_lock\_interruptible(&input\_mutex);  
if (error) \{  
device\_del(&dev->dev);  
return error;  
\}

list\_add\_tail(&dev->node, &input\_dev\_list);

//调用 list\_add\_tail()函数将 input\_dev 加入 input\_dev\_list 链表中,input\_dev\_list 链

//表中包含了系统中所有的 input\_dev 设备。

list\_for\_each\_entry(handler, &input\_handler\_list, node)

**input\_attach\_handler**(dev, handler);

//将input device 挂到input\_dev\_list链表上.然后，对每一个挂在input\_handler\_list的handler调用

//input\_attach\_handler().在这里的情况有好比设备模型中的device和driver的匹配。所有的input device都挂在

//input\_dev\_list链上。所有的handler都挂在input\_handler\_list上。

input\_wakeup\_procfs\_readers();  
  
mutex\_unlock(&input\_mutex);  
  
return 0;  
\}

====================================================================================

匹配是在**input\_attach\_handler()**中完成的。代码如下：  
static int input\_attach\_handler(struct input\_dev \*dev, struct input\_handler \*handler)  
\{  
const struct input\_device\_id \*id;  
int error;  
  
if (handler->blacklist && input\_match\_device(handler->blacklist, dev))  
return -ENODEV;

//首先判断 handler的 blacklist 是否被赋值,如果被赋值,则匹配 blacklist 中的数据跟 dev->id 的数据是否匹配。blacklist

//是一个 input\_device\_id\*的类型,其指向 input\_device\_ids的一个表,这个表中存放了驱动程序应该忽略的设备。即使在

//id\_table 中找到支持的项,也应该忽略这种设备。  
  
id = **input\_match\_device**(handler->id\_table, dev);

//调用 input\_match\_device()函数匹配 handler->>id\_table 和 dev->id 中的数据。如果不成功则返回。

handle->id\_table 也是一个 input\_device\_id 类型的指针,其表示驱动支持的设备列表。

if (!id)  
return -ENODEV;  
  
error = **handler**\->connect(handler, dev, id);

//如果匹配成功,则调用 handler->connect()函数将 handler 与 input\_dev 连接起来。

// **在connect() 中会调用input\_register\_handle，而这些都需要handler的注册。**

if (error && error != -ENODEV)  
printk(KERN\_ERR  
"input: failed to attach handler %s to device %s, "  
"error: %d/n",  
handler->name, kobject\_name(&dev->dev.kobj), error);  
  
return error;  
\}  
//如果handler的blacklist被赋值。要先匹配blacklist中的数据跟dev->id的数据是否匹配。匹配成功过后再来匹配

//handle->id和dev->id中的数据。如果匹配成功，则调用handler->connect().

====================================================================================

**input\_match\_device()**代码如下：  
static const struct input\_device\_id \*input\_match\_device(const struct input\_device\_id \*id,  
struct input\_dev \*dev)  
\{  
int i;  
  
for (; 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;  
  
MATCH\_BIT(evbit, EV\_MAX);  
MATCH\_BIT(,, KEY\_MAX);  
MATCH\_BIT(relbit, REL\_MAX);  
MATCH\_BIT(absbit, ABS\_MAX);  
MATCH\_BIT(mscbit, MSC\_MAX);  
MATCH\_BIT(ledbit, LED\_MAX);  
MATCH\_BIT(sndbit, SND\_MAX);  
MATCH\_BIT(ffbit, FF\_MAX);

MATCH\_BIT(swbit, SW\_MAX);

\--------------------------------------------------------------------------------------------------------------------------------------

MATCH\_BIT宏的定义如下：  
\#define MATCH\_BIT(bit, max)  
for (i = 0; i < BITS\_TO\_LONGS(max); i++)  
if ((id->bit\[i\] & dev->bit\[i\]) != id->bit\[i\])  
break;  
if (i != BITS\_TO\_LONGS(max))  
continue;

\--------------------------------------------------------------------------------------------------------------------------------------

return id;  
\}  
return NULL;  
\}  
  
//从MATCH\_BIT宏的定义可以看出。只有当iput device和input handler的id成员在evbit, keybit,… swbit项相同才会匹//配成功。而且匹配的顺序是从evbit, keybit到swbit.只要有一项不同，就会循环到id中的下一项进行比较.

//简而言之,注册input device的过程就是为input device设置默认值，并将其挂以input\_dev\_list.与挂载在//input\_handler\_list中的handler相匹配。如果匹配成功，就会调用handler的connect函数.

====================================================================================

**这一条线先讲到这里因为接下去就要讲handler ，那就是事件层的东西了， 我们先把核心层的东西讲完，**

**在前面的设备驱动层中的中断响应函数里面，有****input\_report\_key** **函数 ，下面我们来看看他**。

input\_report\_key()函数向输入子系统报告发生的事件,这里就是一个按键事件。在 button\_interrupt()中断函数中,

不需要考虑重复按键的重复点击情况,input\_report\_key()函数会自动检查这个问题,并报告一次事件给输入子系统。该

函数的代码如下:

static inline void input\_report\_key(struct input\_dev \*dev, unsigned int code, int value)

\{  
**input\_event**(dev, EV\_KEY, code, !!value);

\}  
  
该函数的第 1 个参数是产生事件的输入设备, 2 个参数是产生的事件, 3 个参数是事件的值。需要注意的是, 第2 个

参数可以取类似 BTN\_0、 BTN\_1、BTN\_LEFT、BTN\_RIGHT 等值,这些键值被定义在 include/linux/input.h 文件中。

当第 2 个参数为按键时,第 3 个参数表示按键的状态,value 值为 0 表示按键释放,非 0 表示按键按下。  
  
  
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

在 input\_report\_key()函数中正在起作用的函数是 input\_event()函数,该函数用来向输入子系统报告输入设备产生

的事件,这个函数非常重要,它的代码如下:

void **input\_event**(struct input\_dev \*dev, unsigned int type, unsigned int code, int value)  
\{  
unsigned long flags;  
  
if (is\_event\_supported(type, dev->evbit, EV\_MAX)) \{ //检查输入设备是否支持该事件  
  
spin\_lock\_irqsave(&dev->event\_lock, flags);  
  
add\_input\_randomness(type, code, value);

//函数对事件发送没有一点用处,只是用来对随机数熵池增加一些贡献,因为按键输入是一种随机事件,

//所以对熵池是有贡献的。  
  
**input\_handle\_event**(dev, type, code, value);

//调用 input\_handle\_event()函数来继续输入子系统的相关模块发送数据。  
  
spin\_unlock\_irqrestore(&dev->event\_lock, flags);  
\}  
  
====================================================================================

input\_handle\_event()函数向输入子系统传送事件信息。第 1 个参数是输入设备 input\_dev,第 2 个参数是事件的类

型,第 3 个参数是键码,第 4 个参数是键值。

浏览一下该函数的大部分代码,主要由一个 switch 结构组成。该结构用来对不同的事件类型,分别处理。其中 case

语句包含了 EV\_SYN、 EV\_KEY、EV\_SW、EV\_SW、EV\_SND 等事件类型。在这么多事件中,本例只要关注

EV\_KEY 事件,因为本节的实例发送的是键盘事件。其实,只要对一个事件的处理过程了解后,对其他事件的处理过程也

就清楚了。该函数的代码如下:

static void input\_handle\_event(struct input\_dev \*dev,  
\{  
unsigned int type, unsigned int code, int value)  
int disposition = INPUT\_IGNORE\_EVENT;

//定义了一个 disposition 变量,该变量表示使用什么样的方式处理事件  
  
switch (type) \{  
case EV\_SYN:  
switch (code)

\{  
case SYN\_CONFIG:  
disposition = INPUT\_PASS\_TO\_ALL;  
break;  
case SYN\_REPORT:  
if (!dev->sync)

\{  
dev->sync = 1;  
disposition = INPUT\_PASS\_TO\_HANDLERS;  
\}  
break;  
\}  
break;  
 **case EV\_KEY:  
if (is\_event\_supported(code, dev->keybit, KEY\_MAX) &&!!test\_bit(code, dev->key) != value)**

**//函数判断是否支持该按键**

**\{  
if (value != 2)**

**\{  
\_\_change\_bit(code, dev->key);  
if (value)  
input\_start\_autorepeat(dev, code); //处理重复按键的情况  
\}  
disposition = INPUT\_PASS\_TO\_HANDLERS;**

**//将 disposition变量设置为 INPUT\_PASS\_TO\_HANDLERS,表示事件需要 handler 来处理。**

**---------------------------------------------------------------------------------------------------------------------**

disposition 的取值有如下几种:  
1. \#define INPUT\_IGNORE\_EVENT 0  
2. \#define INPUT\_PASS\_TO\_HANDLERS 1  
3. \#define INPUT\_PASS\_TO\_DEVICE 2  
4. \#define INPUT\_PASS\_TO\_ALL (INPUT\_PASS\_TO\_HANDLERS | INPUT\_PASS\_TO\_DEVICE)

INPUT\_IGNORE\_EVENT 表示忽略事件,不对其进行处理。

INPUT\_PASS\_ TO\_HANDLERS 表示将事件交给 handler 处理。  
INPUT\_PASS\_TO\_DEVICE 表示将事件交给 input\_dev 处理。  
INPUT\_PASS\_TO\_ALL 表示将事件交给 handler 和 input\_dev 共同处理。

**--------------------------------------------------------------------------------------------------------------------**

**\}  
break;**  
case EV\_SW:  
if (is\_event\_supported(code, dev->swbit, SW\_MAX) &&!!test\_bit(code, dev->sw) != value)

\{  
\_\_change\_bit(code, dev->sw);  
disposition = INPUT\_PASS\_TO\_HANDLERS;  
\}  
break;  
case EV\_ABS:  
if (is\_event\_supported(code, dev->absbit, ABS\_MAX))

\{  
value = input\_defuzz\_abs\_event(value,  
dev->abs\[code\], dev->absfuzz\[code\]);  
if (dev->abs\[code\] != value)

\{  
dev->abs\[code\] = value;  
disposition = INPUT\_PASS\_TO\_HANDLERS;

break;  
case EV\_REL:  
if (is\_event\_supported(code, dev->relbit, REL\_MAX) && value)  
disposition = INPUT\_PASS\_TO\_HANDLERS;  
break;  
case EV\_MSC:  
if (is\_event\_supported(code, dev->mscbit, MSC\_MAX))  
disposition = INPUT\_PASS\_TO\_ALL;  
break;  
case EV\_LED:  
if (is\_event\_supported(code, dev->ledbit, LED\_MAX) &&!!test\_bit(code, dev->led) != value)

\{  
\_\_change\_bit(code, dev->led);  
disposition = INPUT\_PASS\_TO\_ALL;  
\}  
break;  
case EV\_SND:  
if (is\_event\_supported(code, dev->sndbit, SND\_MAX))

\{  
if (!!test\_bit(code, dev->snd) != !!value)  
\_\_change\_bit(code, dev->snd);  
disposition = INPUT\_PASS\_TO\_ALL;  
\}  
break;  
case EV\_REP:  
if (code <= REP\_MAX && value >= 0 && dev->rep\[code\] != value)

\{  
dev->rep\[code\] = value;  
disposition = INPUT\_PASS\_TO\_ALL;  
\}  
break;  
case EV\_FF:  
if (value >= 0)  
disposition = INPUT\_PASS\_TO\_ALL;  
break;  
case EV\_PWR:  
disposition = INPUT\_PASS\_TO\_ALL;  
break;  
\}  
if (disposition != INPUT\_IGNORE\_EVENT && type != EV\_SYN)  
dev->sync = 0;  
if ((disposition &INPUT\_PASS\_TO\_DEVICE) && dev->event)  
dev->event(dev, type, code, value);

//首先判断 disposition 等于 INPUT\_PASS\_TO\_DEVICE,然后判断 dev->event 是否对其指定了一个处理函数,如果这些

//条件都满足,则调用自定义的 dev->event()函数处理事件。

//有些事件是发送给设备,而不是发送给 handler 处理的。event()函数用来向输入子系统报告一个将要发送给设备的事

//件,例如让 LED 灯点亮事件、蜂鸣器鸣叫事件等。当事件报告给输入子系统后,就要求设备处理这个事件。

if (disposition & INPUT\_PASS\_TO\_HANDLERS)  
**input\_pass\_event**(dev, type, code, value);  
\}

====================================================================================

**input\_pass\_event()**函数将事件传递到合适的函数,然后对其进行处理,该函数的代码如下:  
  
static void input\_pass\_event(struct input\_dev \*dev, unsigned int type, unsigned int code, int value)  
\{

struct input\_handle \*handle;

rcu\_read\_lock();

handle = rcu\_dereference(dev->grab);

//得到 dev->grab 的指针。grab 是强制为 input device 的 handler,这时要调用 handler的 event 函数。

if (handle)

handle->handler->event(handle, type, code, value);  
else

list\_for\_each\_entry\_rcu(handle, &dev->h\_list, d\_node)  **//一般情况下走这里**  
  
if (handle->open)

handle->handler->event(handle,type, code, value);

//如果该 handle 被打开,表示该设备已经被一个用户进程使用。就会调用与输入设备对应的 handler 的 event()函数。

//注意,只有在 handle 被打开的情况下才会接收到事件,这就是说,只有设备被用户程序使用时,才有必要向用户空间导出

//信息

**//此处亦是用到了handle ，核心层就到此为止，前面也讲过在device和handler connect() 时会调用**

**//input\_register\_handle，而这些都需要handler的注册,所以接下来我们看看事件层**  
rcu\_read\_unlock();  
\}

**四 事件层**

input\_handler 是输入子系统的主要数据结构,一般将其称为 handler 处理器,表示对输入事件的具体处理。

input\_handler 为输入设备的功能实现了一个接口,输入事件最终传递到handler 处理器,handler 处理器根据一定的规则,

然后对事件进行处理,具体的规则将在下面详细介绍。  
  
输入子系统由驱动层、输入子系统核心层(Input Core)和事件处理层(Event Handler)3 部分组成。一个输入事件,

如鼠标移动,键盘按键按下等通过驱动层->系统核心层->事件处理层->用户空间的顺序到达用户空间并传给应用程序使

用。其中 Input Core 即输入子系统核心层由 driver/input/input.c 及相关头文件实现。其对下提供了设备驱动的接口,对

上提供了事件处理层的编程接口。输入子系统主要设计 input\_dev、input\_handler、input\_handle 等数据结构.

struct input\_dev物理输入设备的基本数据结构,包含设备相关的一些信息

struct input\_handler 事件处理结构体,定义怎么处理事件的逻辑

struct input\_handle用来创建 input\_dev 和 input\_handler 之间关系的结构体

在evdev.c 中：

static struct input\_handler evdev\_handler = \{  
.event = evdev\_event, // 前面讲的传递信息是调用，在 input\_pass\_event 中  
.connect = evdev\_connect, //device 和 handler 匹配时调用  
.disconnect = evdev\_disconnect,  
.fops = &evdev\_fops, // event 、connect、 fops 会在后面详细讲  
.minor = EVDEV\_MINOR\_BASE,  
.name = "evdev",  
.id\_table = evdev\_ids,  
\};

\--------------------------------------------------------------------------------------------------------------------------------

struct input\_handler \{

void \*private;

void (\*event)(struct input\_handle \*handle, unsigned int type,

unsigned int code, int value);

int (\*connect)(struct input\_handler \*handler, struct input\_dev\* dev, const struct input\_device\_id \*id);  
  
void (\*disconnect)(struct input\_handle \*handle);  
  
void (\*start)(struct input\_handle \*handle);  
  
const struct file\_operations \*fops;  
  
int minor; //表示设备的次设备号  
  
const char \*name;

const struct input\_device\_id \*id\_table; //定义了一个 name, 表示 handler 的名字,显示在/proc/bus/input/handlers 目录

//中。

const struct input\_device\_id \*blacklist; //指向一个 input\_device\_id 表,这个表包含 handler 应该忽略的设备  
  
struct list\_head h\_list;  
  
struct list\_head node;  
\};

\--------------------------------------------------------------------------------------------------------------------------------

//事件层注册

static int \_\_init evdev\_init(void)  
\{  
return **input\_register\_handler**(&**evdev\_handler**);  
\}

====================================================================================

int input\_register\_handler(struct input\_handler \*handler)

\{  
struct input\_dev \*dev;

int retval;

retval = mutex\_lock\_interruptible(&input\_mutex);  
if (retval)  
return retval;

INIT\_LIST\_HEAD(&handler->h\_list);

//其中的 handler->minor 表示对应 input 设备结点的次设备号。 handler->minor以右移 5 位作为索引值插入到 //input\_table\[ \]中

if (handler->fops != NULL)

if (input\_table\[handler->minor >> 5\])

retval = -EBUSY;  
goto out;  
\}  
input\_table\[handler->minor >> 5\] = handler;

list\_add\_tail(&handler->node, &input\_handler\_list);

//调用 list\_add\_tail()函数,将 handler 加入全局的 input\_handler\_list 链表中,该链表包含了系统中所有的 input\_handler

list\_for\_each\_entry(dev, &input\_dev\_list, node)

input\_attach\_handler(dev, handler);

//主 要 调 用 了 input\_attach\_handler() 函 数 。 该 函 数 在 input\_register\_device()函数的第 35 行曾详细的介绍过。//input\_attach\_handler()函数的作用是匹配 input\_dev\_list 链表中的 input\_dev 与 handler。如果成功会将 input\_dev

//与 handler 联系起来。也就是说在注册handler和dev时都会去调用该函数。

input\_wakeup\_procfs\_readers();  
out:  
mutex\_unlock(&input\_mutex);  
return retval;  
\}

====================================================================================

ok下面我们来看下handle的注册，在前面evdev\_handler结构体中，有一个.connect = evdev\_connect, 在

connect里面会注册handle，在前面注册dev，匹配成功后调用。

static int evdev\_connect(struct input\_handler \*handler, struct input\_dev \*dev,  
const struct input\_device\_id \*id)  
\{  
struct evdev \*evdev;  
int minor;  
int error;  
  
for (minor = 0; minor < EVDEV\_MINORS; minor++)  
if (!evdev\_table\[minor\])  
break;  
  
if (minor == EVDEV\_MINORS) \{  
printk(KERN\_ERR "evdev: no more free evdev devices/n");  
return -ENFILE;  
\}  
  
evdev = kzalloc(sizeof(struct evdev), GFP\_KERNEL);  
if (!evdev)  
return -ENOMEM;  
  
INIT\_LIST\_HEAD(&evdev->client\_list);  
spin\_lock\_init(&evdev->client\_lock);  
mutex\_init(&evdev->mutex);  
init\_waitqueue\_head(&evdev->wait);  
  
snprintf(evdev->name, sizeof(evdev->name), "event%d", minor);  
evdev->exist = 1;  
evdev->minor = minor;  
  
evdev->handle.dev = input\_get\_device(dev);  
evdev->handle.name = evdev->name;  
evdev->handle.handler = handler;  
evdev->handle.private = evdev;

//分配了一个 evdev结构 ,并对这个结构进行初始化 .在这里我们可以看到 ,这个结构封装了一个 handle结构 ,这结构与

//我们之前所讨论的 handler是不相同的 .注意有一个字母的差别哦 .我们可以把 handle看成是 handler和 input device

//的信息集合体 .在这个结构里集合了匹配成功的 handler和 input device

strlcpy(evdev->dev.bus\_id, evdev->name, sizeof(evdev->dev.bus\_id));  
evdev->dev.devt = MKDEV(INPUT\_MAJOR, EVDEV\_MINOR\_BASE + minor);  
evdev->dev.class = &input\_class;  
evdev->dev.parent = &dev->dev;  
evdev->dev.release = evdev\_free;  
device\_initialize(&evdev->dev);

//在这段代码里主要完成 evdev封装的 device的初始化 .注意在这里 ,使它所属的类指向 input\_class.这样在 /sysfs中创

//建的设备目录就会在 /sys/class/input/下面显示 .

error = input\_register\_handle(&evdev->handle);  
if (error)  
goto err\_free\_evdev;  
error = evdev\_install\_chrdev(evdev);  
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);  
return error;  
\}

====================================================================================

int input\_register\_handle(struct input\_handle \*handle)  
\{  
struct input\_handler \*handler = handle->handler;  
struct input\_dev \*dev = handle->dev;  
int error;  
  
/\*  
\* We take dev->mutex here to prevent race with  
\* input\_release\_device().  
\*/  
error = mutex\_lock\_interruptible(&dev->mutex);  
if (error)  
return error;  
list\_add\_tail\_rcu(&handle->d\_node, &dev->h\_list);  
mutex\_unlock(&dev->mutex);  
synchronize\_rcu();  
  
/\*  
\* Since we are supposed to be called from ->connect()  
\* which is mutually exclusive with ->disconnect()  
\* we can't be racing with input\_unregister\_handle()  
\* and so separate lock is not needed here.  
\*/  
list\_add\_tail(&handle->h\_node, &handler->h\_list);  
  
if (handler->start)  
handler->start(handle);  
  
return 0;  
\}  
将handle挂到所对应input device的h\_list链表上.还将handle挂到对应的handler的hlist链表上.如果handler定

义了start函数,将调用之. 到这里,我们已经看到了input device, handler和handle是怎么关联起来的了

====================================================================================

接下来我们看看上报信息是调用的 .event = evdev\_event 。

每当input device上报一个事件时,会将其交给和它匹配的handler的event函数处理.在evdev中.这个event函数

对应的代码为:

static void evdev\_event(struct input\_handle \*handle,  
unsigned int type, unsigned int code, int value)  
\{  
struct evdev \*evdev = handle->private;  
struct evdev\_client \*client;  
struct input\_event event;  
  
do\_gettimeofday(&event.time);  
event.type = type;  
event.code = code;  
event.value = value;  
  
rcu\_read\_lock();  
  
client = rcu\_dereference(evdev->grab);  
if (client)  
evdev\_pass\_event(client, &event);  
else  
list\_for\_each\_entry\_rcu(client, &evdev->client\_list, node)  
evdev\_pass\_event(client, &event);  
  
rcu\_read\_unlock();  
  
wake\_up\_interruptible(&evdev->wait);  
\}

===================================================================================

static void evdev\_pass\_event(struct evdev\_client \*client,  
struct input\_event \*event)  
\{  
/\*  
\* Interrupts are disabled, just acquire the lock  
\*/  
spin\_lock(&client->buffer\_lock);  
client->buffer\[client->head++\] = \*event;  
client->head &= EVDEV\_BUFFER\_SIZE - 1;  
spin\_unlock(&client->buffer\_lock);  
  
kill\_fasync(&client->fasync, SIGIO, POLL\_IN);  
\}

这里的操作很简单.就是将event(上传数据)保存到client->buffer中.而client->head就是当前的数据位置.注意这里

是一个环形缓存区.写数据是从client->head写.而读数据则是从client->tail中读.

====================================================================================

最后我们看下handler的相关操作函数 .fops = &evdev\_fops,

我们知道.对主设备号为INPUT\_MAJOR的设备节点进行操作,会将操作集转换成handler的操作集.在evdev中,这个

操作集就是evdev\_fops.对应的open函数如下示:

static int evdev\_open(struct inode \*inode, struct file \*file)  
\{  
struct evdev \*evdev;  
struct evdev\_client \*client;  
int i = iminor(inode) - EVDEV\_MINOR\_BASE;  
int error;  
  
if (i >= EVDEV\_MINORS)  
return -ENODEV;  
  
error = mutex\_lock\_interruptible(&evdev\_table\_mutex);  
if (error)  
return error;  
evdev = evdev\_table\[i\];  
if (evdev)  
get\_device(&evdev->dev);  
mutex\_unlock(&evdev\_table\_mutex);  
  
if (!evdev)  
return -ENODEV;  
  
client = kzalloc(sizeof(struct evdev\_client), GFP\_KERNEL);  
if (!client) \{  
error = -ENOMEM;  
goto err\_put\_evdev;  
\}  
spin\_lock\_init(&client->buffer\_lock);  
client->evdev = evdev;  
evdev\_attach\_client(evdev, client);  
  
error = evdev\_open\_device(evdev);  
if (error)  
goto err\_free\_client;  
  
file->private\_data = client;  
return 0;  
  
err\_free\_client:  
evdev\_detach\_client(evdev, client);  
kfree(client);  
err\_put\_evdev:  
put\_device(&evdev->dev);  
return error;  
\}

====================================================================================

evdev\_open\_device()函数用来打开相应的输入设备，使设备准备好接收或者发送数据。evdev\_open\_device()函

数先获得互斥锁，然后检查设备是否存在，并判断设备是否已经被打开。如果没有打开，则调用 input\_open\_device()

函数打开设备.

static int evdev\_open\_device(struct evdev \*evdev)  
\{  
int retval;  
  
retval = mutex\_lock\_interruptible(&evdev->mutex);  
if (retval)  
return retval;  
  
if (!evdev->exist)  
retval = -ENODEV;  
else if (!evdev->open++) \{  
retval = input\_open\_device(&evdev->handle);  
if (retval)  
evdev->open--;  
\}  
  
mutex\_unlock(&evdev->mutex);  
return retval;  
\}

====================================================================================

对于evdev设备节点的read操作都会由evdev\_read()完成.它的代码如下:

static ssize\_t evdev\_read(struct file \*file, char \_\_user \*buffer,  
size\_t count, loff\_t \*ppos)  
\{  
struct evdev\_client \*client = file->private\_data;  
struct evdev \*evdev = client->evdev;  
struct input\_event event;  
int retval;  
  
if (count < evdev\_event\_size())  
return -EINVAL;  
  
if (client->head == client->tail && evdev->exist &&  
(file->f\_flags & O\_NONBLOCK))  
return -EAGAIN;  
  
retval = wait\_event\_interruptible(evdev->wait,  
client->head != client->tail || !evdev->exist);  
if (retval)  
return retval;  
  
if (!evdev->exist)  
return -ENODEV;  
  
while (retval + evdev\_event\_size() <= count &&  
evdev\_fetch\_next\_event(client, &event)) \{  
  
if (evdev\_event\_to\_user(buffer + retval, &event))  
return -EFAULT;  
  
retval += evdev\_event\_size();  
\}  
  
return retval;  
\}

首先,它判断缓存区大小是否足够.在读取数据的情况下,可能当前缓存区内没有数据可读.在这里先睡眠等待缓存

区中有数据.如果在睡眠的时候,.条件满足.是不会进行睡眠状态而直接返回的. 然后根据read()提够的缓存区大小.将

client中的数据写入到用户空间的缓存区中.

五 用户空间

到这就没啥讲的了， ok到此为止吧！！！

参考网页：[http://hi.baidu.com/%B7%E8%D7%D3%D6%AE%CD%BD/blog/item/f4ed8135a4258c2d0b55a940.html][http_hi.baidu.com_B7_E8_D7_D3_D6_AE_CD_BD_blog_item_f4ed8135a4258c2d0b55a940.html]

[http://blog.csdn.net/changjiang654/article/details/6154622][http_blog.csdn.net_changjiang654_article_details_6154622]

转载于:https://www.cnblogs.com/sky-heaven/p/4514363.html

[http_blog.csdn.net_lbmygf_article_details_7360084]: http://blog.csdn.net/lbmygf/article/details/7360084
[0_1331868635QkLK.gif]: /images/20211220/3193abf196474e27821cac2b2f791c27.png
[http_hi.baidu.com_B7_E8_D7_D3_D6_AE_CD_BD_blog_item_f4ed8135a4258c2d0b55a940.html]: http://hi.baidu.com/%B7%E8%D7%D3%D6%AE%CD%BD/blog/item/f4ed8135a4258c2d0b55a940.html
[http_blog.csdn.net_changjiang654_article_details_6154622]: http://blog.csdn.net/changjiang654/article/details/6154622