Linux input子系统分析---4、事件处理层分析

二.  事件处理层分析（以evdev事件处理器为例）
    1.事件处理层与用户程序和输入子系统核心打交道，是他们两层的桥梁。一般内核有好几个事件处理器，像evdev mousedev jotdev。evdev事件处理器可以处理所有的事件，触摸屏驱动就是用的这个，所以下面分析这个事件处理器的实现。它也是作为模块注册到内核中的，首先分析它的模块初始化函数。

 

1. static int __init evdev_init(void)  
2. {  
3.     return input_register_handler(&evdev_handler);  
4. }  

   模块初始化函数就调用一个注册handler函数，将evdev_handler注册到系统中。
    2.主要数据结构
    （1） evdev设备结构

 

1. struct evdev {  
2.     int exist;  
3.     int open;           //打开标志   
4.     int minor;          //次设备号   
5.     struct input_handle handle;  //关联的input_handle   
6.     wait_queue_head_t wait;      //等待队列，当进程读取设备，而没有事件产生的时候，进程就会睡在其上面   
7.     struct evdev_client *grab;   //强制绑定的evdev_client结构，这个结构后面再分析   
8.     struct list_head client_list;  //evdev_client 链表，这说明一个evdev设备可以处理多个evdev_client，可以有多个进程访问evdev设备   
9.     spinlock_t client_lock; /* protects client_list */  
10.     struct mutex mutex;  
11.     struct device dev;       //device结构，说明这是一个设备结构   
12. };  

    evdev结构体在配对成功的时候生成，由handler->connect生成，对应设备文件为/class/input/event(n)，如触摸屏驱动的event0，这个设备是用户空间要访问的设备，可以理解它是一个虚拟设备，因为没有对应的硬件，但是通过handle->dev 就可以找到input_dev结构，而它对应着触摸屏，设备文件为/class/input/input0。这个设备结构生成之后保存在evdev_table中，
    索引值是minor
   （2） evdev用户端结构

 

1. struct evdev_client {  
2.     struct input_event buffer[EVDEV_BUFFER_SIZE];    
3.         //这个是一个input_event数据结构的数组，input_event代表一个事件，基本成员：类型（type），编码（code），值（value）   
4.     int head;              //针对buffer数组的索引   
5.     int tail;              //针对buffer数组的索引，当head与tail相等的时候，说明没有事件   
6.     spinlock_t buffer_lock; /* protects access to buffer, head and tail */  
7.     struct fasync_struct *fasync;  //异步通知函数   
8.     struct evdev *evdev;           //evdev设备   
9.     struct list_head node;         // evdev_client 链表项   
10. };  

   这个结构在进程打开event0设备的时候调用evdev的open方法，在open中创建这个结构，并初始化。在关闭设备文件的时候释放这个结构。
   3.主要函数
   （1）evdev设备打开函数

 

1. static int evdev_open(struct inode *inode, struct file *file)  
2. {  
3.     struct evdev *evdev;  
4.     struct evdev_client *client;  
5.     int i = iminor(inode) - EVDEV_MINOR_BASE;  
6.     int error;  
7.   
8.   
9.     if (i >= EVDEV_MINORS)  
10.         return -ENODEV;  
11.   
12.   
13.     error = mutex_lock_interruptible(&evdev_table_mutex);  
14.     if (error)  
15.         return error;  
16.     evdev = evdev_table[i];  
17.         //得到evdev设备结构,每次调用evdev_connect配对成功后都会把分配的evdev结构以minor为索引，保存在evdev_table数组中   
18.     if (evdev)  
19.         get_device(&evdev->dev);  //增加device引用计数   
20.     mutex_unlock(&evdev_table_mutex);  
21.   
22.   
23.     if (!evdev)  
24.         return -ENODEV;  
25.   
26.   
27.     client = kzalloc(sizeof(struct evdev_client), GFP_KERNEL);  //分配用户端结构   
28.     if (!client) {  
29.         error = -ENOMEM;  
30.         goto err_put_evdev;  
31.     }  
32.   
33.   
34.     spin_lock_init(&client->buffer_lock);  
35.     client->evdev = evdev;    //使用户端与evdev设备结构联系起来   
36.     evdev_attach_client(evdev, client);  
37.         //这个函数所做的就是把client连接到evdev的client链表中   
38.     error = evdev_open_device(evdev);  
39.         //这个函数打开设备，有很多层调用，后面详细分析   
40.     if (error)  
41.         goto err_free_client;  
42.   
43.   
44.     file->private_data = client;  
45.     return 0;  
46.   
47.   
48.  err_free_client:  
49.     evdev_detach_client(evdev, client);  
50.     kfree(client);  
51.  err_put_evdev:  
52.     put_device(&evdev->dev);  
53.     return error;  
54. }   

   （2）evdev设备打开函数evdev_open_device，由evdev_open调用。

 

1. static int evdev_open_device(struct evdev *evdev)  
2. {  
3.     int retval;  
4.   
5.   
6.     retval = mutex_lock_interruptible(&evdev->mutex);  
7.     if (retval)  
8.         return retval;  
9.   
10.   
11.     if (!evdev->exist)  
12.         retval = -ENODEV;  
13.         //判断设备结构是否存在，在evdev_connect中初始话此成员为1   
14.     else if (!evdev->open++) {  
15.         retval = input_open_device(&evdev->handle);  
16.         if (retval)  
17.             evdev->open--;  
18.     }  
19.         //evdev->open分配结构的时候没有初始化，默认为0，也就是没有打开，每次打开都会加1  
20.     mutex_unlock(&evdev->mutex);  
21.     return retval;  
22. }  

    此函数在判断结构存在与否后，主要调用了input_open_device，这个函数是子系统核心函数，定义在input.c中，下面分析这个函数：

 

1. int input_open_device(struct input_handle *handle)  
2. {  
3.     struct input_dev *dev = handle->dev;  
4.     int retval;  
5.   
6.   
7.     retval = mutex_lock_interruptible(&dev->mutex);  
8.     if (retval)  
9.         return retval;  
10.   
11.   
12.     if (dev->going_away) {  
13.         retval = -ENODEV;  
14.         goto out;  
15.     }  
16.   
17.   
18.     handle->open++;  
19.         //将handle的打开计数加1，注意和evdev的open的区别   
20.     if (!dev->users++ && dev->open)  
21.         retval = dev->open(dev);  
22.         //如果此input_dev没有进程在引用，并且定义了open方法，就调用open方法   
23.     if (retval) {    //retval = 1 说明没有打开成功   
24.         dev->users--;    
25.         if (!--handle->open) {  //说明有其他的进程已经打开了这个handle   
26.             /* 
27.              * Make sure we are not delivering any more events 
28.              * through this handle 
29.              */  
30.             synchronize_rcu();  
31.         }  
32.     }  
33.   
34.   
35.  out:  
36.     mutex_unlock(&dev->mutex);  
37.     return retval;  
38. }  

   （3）读操作函数 evdev_read

 

1. static ssize_t evdev_read(struct file *file, char __user *buffer,  
2.               size_t count, loff_t *ppos)  
3. {  
4.     struct evdev_client *client = file->private_data;    //这个客户端结构在打开的时候分配并保存在file->private_data中   
5.     struct evdev *evdev = client->evdev;  
6.     struct input_event event;  
7.     int retval;  
8.   
9.   
10.     if (count < input_event_size())  
11.         return -EINVAL;  
12.         //这条语句提示，用户进程每次读取设备的字节数，不要少于input_event结构的大小   
13.     if (client->head == client->tail && evdev->exist &&  
14.         (file->f_flags & O_NONBLOCK))  
15.         return -EAGAIN;  
16.         //head等于tail说明目前还没有事件传回来，如果设置了非阻塞操作，则会立刻返回   
17.     retval = wait_event_interruptible(evdev->wait,  
18.         client->head != client->tail || !evdev->exist);  
19.         //没有事件就会睡在evdev的等待队列上了，等待条件是有事件到来或者设备不存在了（设备关闭的时候，清这个标志）   
20.     if (retval)  
21.         return retval;  
22.         //如果能执行上面这条语句说明有事件传来或者，设备被关闭了，或者内核发过来终止信号  
23.     if (!evdev->exist)  
24.         return -ENODEV;  
25.   
26.   
27.     while (retval + input_event_size() <= count &&  
28.            evdev_fetch_next_event(client, &event)) {  
29.         // evdev_fetch_next_event这个函数遍历client里面的input_event buffer数组   
30.         if (input_event_to_user(buffer + retval, &event))  
31.         //将事件复制到用户空间   
32.             return -EFAULT;  
33.   
34.   
35.         retval += input_event_size();  
36.     }  
37.   
38.     return retval;   //返回复制的数据字节数   
39. }