Linux input子系统分析_4_事件处理层分析

二.  事件处理层分析（以evdev事件处理器为例）
    1.事件处理层与用户程序和输入子系统核心打交道，是他们两层的桥梁。一般内核有好几个事件处理器，像evdev mousedev jotdev。

    evdev事件处理器可以处理所有的事件，触摸屏驱动就是用的这个，所以下面分析这个事件处理器的实现。它也是作为模块注册到内核中的，首先分析它的模块初始化函数。

    static int __init evdev_init(void)
    {
        return input_register_handler(&evdev_handler);  //模块初始化函数就调用一个注册handler函数，将evdev_handler注册到系统中。

    }
    static void __exit evdev_exit(void)
    {
        input_unregister_handler(&evdev_handler);
    }
    module_init(evdev_init);
    module_exit(evdev_exit);
    MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
    MODULE_DESCRIPTION("Input driver event char devices");
    MODULE_LICENSE("GPL");

     2.主要数据结构
    （1） evdev设备结构

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

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

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

        struct wake_lock wake_lock;     
        char name[28];
    };

   这个结构在进程打开event0设备的时候调用evdev的open方法，在open中创建这个结构，并初始化。在关闭设备文件的时候释放这个结构。
   3.主要函数
   （1）evdev设备打开函数 evdev_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];     //得到evdev设备结构,每次调用evdev_connect配对成功后都会把分配的evdev结构以minor为索引，保存在evdev_table数组中  
        if (evdev)
            get_device(&evdev->dev);   //增加device引用计数
        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);
        snprintf(client->name, sizeof(client->name), "%s-%d",
                dev_name(&evdev->dev), task_tgid_vnr(current));
        wake_lock_init(&client->wake_lock, WAKE_LOCK_SUSPEND, client->name);
        client->evdev = evdev;         //使用户端与evdev设备结构联系起来
        evdev_attach_client(evdev, client);   //这个函数所做的就是把client连接到evdev的client链表中
        error = evdev_open_device(evdev);    //这个函数打开设备，有很多层调用，后面详细分析
        if (error)
            goto err_free_client;
        file->private_data = client;
        nonseekable_open(inode, file);
        return 0;
     err_free_client:
        evdev_detach_client(evdev, client);
        kfree(client);
     err_put_evdev:
        put_device(&evdev->dev);
        return error;
    }

 

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

    static int evdev_open_device(struct evdev *evdev)
    {
        int retval;
        retval = mutex_lock_interruptible(&evdev->mutex);
        if (retval)
            return retval;
        if (!evdev->exist)   //判断设备结构是否存在，在evdev_connect中初始话此成员为1
            retval = -ENODEV;     
        else if (!evdev->open++) {
            retval = input_open_device(&evdev->handle);
            if (retval)
                evdev->open--;   //evdev->open分配结构的时候没有初始化，默认为0，也就是没有打开，每次打开都会加1
        }
        mutex_unlock(&evdev->mutex);
        return retval;
    }

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

    /**
     * input_open_device - open input device
     * @handle: handle through which device is being accessed
     *
     * This function should be called by input handlers when they
     * want to start receive events from given input device.
     */
    int input_open_device(struct input_handle *handle)
    {
     struct input_dev *dev = handle->dev;
     int retval;
     retval = mutex_lock_interruptible(&dev->mutex);
     if (retval)
      return retval;
     if (dev->going_away) {
      retval = -ENODEV;
      goto out;
     }
     handle->open++;    //将handle的打开计数加1，注意和evdev的open的区别
     if (!dev->users++ && dev->open)    //如果此input_dev没有进程在引用，并且定义了open方法，就调用open方法
      retval = dev->open(dev);
     if (retval) {      //retval = 1 说明没有打开成功  
      dev->users--;
      if (!--handle->open) {   //说明有其他的进程已经打开了这个handle   
       /*
        * Make sure we are not delivering any more events
        * through this handle
        */
       synchronize_rcu();
      }
     }
     out:
     mutex_unlock(&dev->mutex);
     return retval;
    }
    EXPORT_SYMBOL(input_open_device);

 

（3）读操作函数 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;   //这个客户端结构在打开的时候分配并保存在file->private_data中   
        struct evdev *evdev = client->evdev;
        struct input_event event;
        int retval;
        if (count < input_event_size())   //这条语句提示，用户进程每次读取设备的字节数，不要少于input_event结构的大小
            return -EINVAL;
        if (client->head == client->tail && evdev->exist && 
         (file->f_flags & O_NONBLOCK))   //head等于tail说明目前还没有事件传回来，如果设置了非阻塞操作，则会立刻返回
            return -EAGAIN;
        retval = wait_event_interruptible(evdev->wait,
            client->head != client->tail || !evdev->exist);  //没有事件就会睡在evdev的等待队列上了，等待条件是有事件到来或者设备不存在了（设备关闭的时候，清这个标志）
        if (retval) 
            return retval;  //如果能执行上面这条语句说明有事件传来或者，设备被关闭了，或者内核发过来终止信号
        if (!evdev->exist)
            return -ENODEV;
        while (retval + input_event_size() <= count &&
         evdev_fetch_next_event(client, &event)) {  // evdev_fetch_next_event这个函数遍历client里面的input_event buffer数组
            if (input_event_to_user(buffer + retval, &event))   //将事件复制到用户空间
                return -EFAULT;
            retval += input_event_size();
        }
        return retval;   //返回复制的数据字节数
    }