Linux驱动修炼之道-INPUT子系统(下)

努力成为linux kernel hacker的人李万鹏原创作品，为梦而战。转载请标明出处

http://blog.csdn.net/woshixingaaa/archive/2011/05/19/6433337.aspx

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

C-sharp代码 

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

C-sharp代码 

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. };  

C-sharp代码 

1. static struct input_handler evdev_handler = {  
2.     .event      = evdev_event,  
3.     .connect    = evdev_connect,  
4.     .disconnect = evdev_disconnect,  
5.     .fops       = &evdev_fops,  
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匹配所有设备。

C-sharp代码 

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

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

C-sharp代码 

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等函数：

C-sharp代码 

1. static inline void input_report_abs(struct input_dev *dev, unsigned int code, int value)  
2. {  
3.     input_event(dev, EV_ABS, code, value);  
4. }  

跟踪input_event如下：

C-sharp代码 

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如下：

C-sharp代码 

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如下：

C-sharp代码 

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：

C-sharp代码 

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. }  

C-sharp代码 

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中，等待用户空间来读取。

下边看一下用户程序打开文件时的过程，首先调用了input_open_file:

C-sharp代码 

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。

C-sharp代码 

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. }  

C-sharp代码 

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. }  

C-sharp代码 

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的底层实现：

C-sharp代码 

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. }  

C-sharp代码 

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. }  

C-sharp代码 

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中。这样所有打开同一个设备的进程都会收到这个消息而唤醒。