input输入设备驱动

一、简介
input输入子系统是对分散的，多种不同类别的输入设备（鼠标、键盘）等字符设备进行统一的处理的一层抽象，
就是在字符设备驱动上抽象出的一层。

输入子系统由输入子系统核心层(input core)、硬件驱动层(input driver)、事件处理层(input handler)三部分组成。
（1）其中硬件驱动层负责操作具体的硬件设备，这层的代码是针对具体的驱动程序的，需要驱动程序的作者来编写；
（2）子系统核心层是链接其他两个层之间的纽带与桥梁，向下提供驱动层的接口，向上提供事件处理层的接口。
（3）事件处理层负责与用户程序打交道，将硬件驱动层传来的事件报告给用户程序

各层之间通信的基本单位就是事件，任何一个输入设备的动作都可以抽象成一种事件，如键盘的按下，触摸屏的按
下，鼠标的移动等。事件有三种属性：类型（type），编码(code)，值(value)，Input子系统支持的所有事件都定
义在include/input/input.h中，包括所有支持的类型，所属类型支持的编码等。事件传送的方向是硬件驱动层-->
子系统核心-->事件处理层-->用户空间

事件驱动程序是标准的，对所有的输入类都是可用的。设备驱动可以利用一个已经存在的，合适的事件驱动程序，
通过输入核心和用户应用程序接口。

输入子系统的好处：
1）统一了物理形态各异的相似的输入设备的处理功能
2）提供了用于分发输入报告给用户应用程序的简单的事件接口
3）抽取出了输入驱动程序的通用部分，简化了驱动，并引入了一致性

输入子系统的工作流程: 
mini2440的触摸屏驱动所用驱动层对应的模块文件为：s3c2410_ts.c，事件处理层对应的模块文件为evdev.c 
（1）s3c2410_ts模块初始化函数中将触摸屏驱动注册到了输入子系统中，于此同时，注册函数在事件处理层链表中
寻找事件处理器，这里找到的是evdev，并且将驱动与事件处理器挂载。并且在/dev/input中生成设备文件event0，
以后我们访问这个文件就会找到我们的触摸屏驱动程序。 
（2）应用程序打开设备文件/dev/input/event0，读取设备文件，调用evdev模块中read,如果没有事件进程就会睡眠。
（3）当触摸屏按下，驱动层通过输入子系统核心将事件（就是X，Y坐标）,传给事件处理层也就是evdev,evdev唤醒睡眠
的进程，将事件传给进程处理

二、LINUX中对input输入子系统中的数据结构描述
在linux内核中，input设备用input_dev结构体描述，使用input子系统实现输入设备驱动的时候，驱动的核心工作
是向系统报告按键、触摸屏、键盘、鼠标等输入事件（event,通过input_event结构体描述），不再需要关心文件
操作接口，因为input子系统已经完成了文件操作接口。驱动报告的事件经过InputCore和EventHandler最终到达用
户空间。

1、input_dev结构体
linux内核中使用input_dev结构描述一个输入设备，每个input驱动程序都必须分配并初始化这个结构体，
定义在include/linux/input.h中

struct input_dev {
    const char *name;//设备名称
    const char *phys;//设备在系统中的物理路径
    const char *uniq;//设备唯一识别符
    struct input_id id;//设备ID，包含总线ID（PCI、USB）、厂商ID，与input_handler匹配的时会用到

    unsigned long propbit[BITS_TO_LONGS(INPUT_PROP_CNT)];//位图的设备属性

    unsigned long evbit[BITS_TO_LONGS(EV_CNT)];//支持的所有事件类型
    //下面是每种类型支持的编码
    unsigned long keybit[BITS_TO_LONGS(KEY_CNT)];//支持的键盘事件
    unsigned long relbit[BITS_TO_LONGS(REL_CNT)];//支持的鼠标相对值事件
    unsigned long absbit[BITS_TO_LONGS(ABS_CNT)];//支持的鼠标绝对值事件
    unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)];//支持的其它事件类型
    unsigned long ledbit[BITS_TO_LONGS(LED_CNT)];//支持的LED灯事件
    unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];//支持的声效事件
    unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];//支持的力反馈事件
    unsigned long swbit[BITS_TO_LONGS(SW_CNT)];//支持的开关事件

    unsigned int hint_events_per_packet;//事件生成的平均数量

    unsigned int keycodemax;//keycode表的大小
    unsigned int keycodesize;//keycode表中元素个数
    void *keycode;//设备的键盘表

    int (*setkeycode)(struct input_dev *dev,const struct input_keymap_entry *ke,
                unsigned int *old_keycode);//配置keycode表
    int (*getkeycode)(struct input_dev *dev,
              struct input_keymap_entry *ke);//获取keycode表

    struct ff_device *ff;//力反馈设备结构

    unsigned int repeat_key;//保存上一个键值
    struct timer_list timer;//软件计时器

    int rep[REP_CNT];//autorepeat参数当前值

    struct input_mt_slot *mt;
    int mtsize;
    int slot;
    int trkid;

    struct input_absinfo *absinfo;//绝对坐标轴的信息

    unsigned long key[BITS_TO_LONGS(KEY_CNT)];//按键有两种状态，按下和抬起，这个字段就是记录这两个状态。
    unsigned long led[BITS_TO_LONGS(LED_CNT)];
    unsigned long snd[BITS_TO_LONGS(SND_CNT)];
    unsigned long sw[BITS_TO_LONGS(SW_CNT)];
    //操作接口
    int (*open)(struct input_dev *dev);
    void (*close)(struct input_dev *dev);
    int (*flush)(struct input_dev *dev, struct file *file);
    int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);

    struct input_handle __rcu *grab;//当前使用的handle

    spinlock_t event_lock;
    struct mutex mutex;

    unsigned int users;
    bool going_away;

    bool sync;

    struct device dev;//这个设备的驱动程序模型的视图

    struct list_head    h_list;//h_list是一个链表头，用来把handle挂载在这个上
    struct list_head    node;//这个node是用来连到input_dev_list上的
};

2、input_handler结构
linux内核中使用input_handler结构描述一个事件处理器，定义在include/linux/input.h中

struct input_handler {
    void *private;//驱动特有的数据
    //当事件处理器接收到了来自input设备传来的事件时调用的处理函数，负责处理事件
    void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
    bool (*filter)(struct input_handle *handle, unsigned int type, unsigned int code, int value);//事件过滤
    bool (*match)(struct input_handler *handler, struct input_dev *dev);
    //当一个input设备模块注册到内核的时候调用的，将事件处理器与输入设备联系起来的函数，
    //也就是将input_dev和input_handler配对的函数
    int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id);
    void (*disconnect)(struct input_handle *handle);//实现connect相反的功能
    void (*start)(struct input_handle *handle);

    const struct file_operations *fops;//文件操作函数集合
    int minor;//次设备号
    const char *name;

    const struct input_device_id *id_table;//事件处理器所支持的input设备
    //这个链表用来链接他所支持的input_handle结构,input_dev与input_handler配对之后就会生成一个input_handle结构
    struct list_head    h_list;
    //链接到input_handler_list，这个链表链接了所有注册到内核的事件处理器
    struct list_head    node;
};

3、input_handle结构
用input_handle结构体代表一个成功配对的input_dev和input_handler
定义在include/linux/input.h中

struct input_handle {
    //每个配对的事件处理器都会分配一个对应的设备结构，如evdev事件处理器的evdev结构，注意这个结构与设备
    //驱动层的input_dev不同，初始化handle时，保存到这里。
    void *private;

    int open;//打开标志，每个input_handle打开后才能操作，这个一般通过事件处理器的open方法间接设置
    const char *name;

    struct input_dev *dev;//关联的input_dev结构
    struct input_handler *handler;//关联的input_handler结构

    struct list_head    d_node;//input_handle通过d_node连接到了input_dev上的h_list链表上
    struct list_head    h_node;//input_handle通过h_node连接到了input_handler的h_list链表上
};

4、input_dev，input_handler，input_handle，3者之间的关系
input_dev是硬件驱动层，代表一个input设备
input_handler是事件处理层，代表一个事件处理器
input_handle代表一个配对的input设备与input事件处理器input_dev通过全局的input_dev_list链接在一起。
设备注册的时候实现这个操作。
input_handler通过全局的input_handler_list链接在一起。事件处理器注册的时候实现这个操作.
input_hande没有一个全局的链表，它注册的时候将自己分别挂在了input_dev和input_handler的h_list上了。
通过input_dev和input_handler就可以找到input_handle在设备注册和事件处理器，注册的时候都要进行配对工作，
配对后就会实现链接。通过input_handle也可以找到input_dev和input_handler

三、input输入子系统中对各层的注册过程
input_dev，input_handler，input_handle都代表一类对象，内核对各数据结构都提供了对应的注册方法，
定义在driver/input/input.c中

int input_register_device(struct input_dev *dev)//注册input_dev的方法
int input_register_handler(struct input_handler *handler)//注册input_handler的方法
int input_register_handle(struct input_handle *handle)//注册input_handle的方法

1、input_register_device()注册一个输入设备

int input_register_device(struct input_dev *dev)
{
    //这个原子变量，代表总共注册的input设备，每注册一个加1，因为是静态变量，所以每次调用都不会清零的
    static atomic_t input_no = ATOMIC_INIT(0);
    struct input_handler *handler;
    const char *path;
    int error;

    //EN_SYN这个是设备都要支持的事件类型，所以要设置
    __set_bit(EV_SYN, dev->evbit);

    /* KEY_RESERVED is not supposed to be transmitted to userspace. */
    __clear_bit(KEY_RESERVED, dev->keybit);

    /* Make sure that bitmasks not mentioned in dev->evbit are clean. */
    input_cleanse_bitmasks(dev);

    if (!dev->hint_events_per_packet)
        dev->hint_events_per_packet =
                input_estimate_events_per_packet(dev);

    //这个内核定时器是为了重复按键而设置的
    init_timer(&dev->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;
    }
    //默认函数由input核心提供
    if (!dev->getkeycode)
        dev->getkeycode = input_default_getkeycode;

    if (!dev->setkeycode)
        dev->setkeycode = input_default_setkeycode;
    //设置input_dev中device的名字，这个名字会在/class/input中出现
    dev_set_name(&dev->dev, "input%ld",
         (unsigned long) atomic_inc_return(&input_no) - 1);
    //将device加入到linux设备模型中去
    error = device_add(&dev->dev);
    if (error)
        return error;
    //得到路径名称，并打印出来
    path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
    pr_info("%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;
    }
    //将新分配的input设备连接到input_dev_list链表上
    list_add_tail(&dev->node, &input_dev_list);
    //遍历input_handler_list链表，配对input_dev和input_handler
    list_for_each_entry(handler, &input_handler_list, node)
        input_attach_handler(dev, handler);

    input_wakeup_procfs_readers();

    mutex_unlock(&input_mutex);

    return 0;
}

input_register_device完成的主要功能就是：初始化一些默认的值，将自己的device结构添加到linux设备模型
当中，将input_dev添加到input_dev_list链表中，然后寻找合适的handler与input_handler配对,配对的核心函
数是input_attach_handler

input_attach_handler()函数

static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
{
    const struct input_device_id *id;
    int error;
    //配对，比较id中的各项
    id = input_match_device(handler, dev);
    if (!id)
        return -ENODEV;
    //配对成功调用handler的connect函数，这个函数在事件处理器中定义，主要生成一个input_handle结构，
    //并初始化，还生成一个事件处理器相关的设备结构
    error = handler->connect(handler, dev, id);
    if (error && error != -ENODEV)
        pr_err("failed to attach handler %s to device %s, error: %d\n",
               handler->name, kobject_name(&dev->dev.kobj), error);

    return error;
}

input_attach_handler的主要功能就是调用了两个函数，一个input_match_device进行配对，一个connect处理
配对成功后续工作

input_match_device()函数

static const struct input_device_id *input_match_device(struct input_handler *handler,
                            struct input_dev *dev)
{
    const struct input_device_id *id;
    int i;
    //函数传入的参数是所要配对handler的id_table，下面遍历这个id_table寻找合适的id进行配对
    for (id = handler->id_table; id->flags || id->driver_info; id++) {
        //针对handler->id->flag，比较不同的类型
        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;
        //如果比较成功进入下面的宏，否则进入下一个id
        MATCH_BIT(evbit, EV_MAX);
        MATCH_BIT(keybit, 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);

        if (!handler->match || handler->match(handler, dev))
            return id;
    }

    return NULL;
}

此函数主要是比较input_dev中的id和handler支持的id,这个存放在handler的id_table中。首先看id->driver_info
有没有设置，如果设置了说明它匹配所有的id，evdev就是这个样的handler
然后依据id->flag来比较内容，如果都比较成功进入MATCH_BIT，这个宏是用来按位进行比较的，功能是比较所支持
事件的类型，只有所有的位都匹配才成功返回，否则进行下一个id的比较

对于connect函数，每种事件处理器的实现都有差异，但原理都相同，因为触摸屏用的事件处理器为evdev，
下面分析evdev的connect函数evdev_connect

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;
    //EVDEV_MINORS为32，说明evdev这个handler可以同时有32个输入设备和他配对，evdev_table中以minor（非次设
    //备号，但是有一个换算关系）存放evdev结构体
    for (minor = 0; minor < EVDEV_MINORS; minor++)
        if (!evdev_table[minor])
            break;
    //32个位置全都被占用了，连接失败
    if (minor == EVDEV_MINORS) {
        pr_err("no more free evdev devices\n");
        return -ENFILE;
    }
    //分配一个evdev结构体，这个结构体是evdev事件处理器特有的
    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);
    //设置evdev中device的名字，将出现在/class/input中
    dev_set_name(&evdev->dev, "event%d", minor);
    evdev->exist = true;
    evdev->minor = minor;
    //因为evdev中包含handle了，所以初始化它就可以了，这样就连接了input_handler与input_dev
    evdev->handle.dev = input_get_device(dev);
    evdev->handle.name = dev_name(&evdev->dev);
    evdev->handle.handler = handler;
    evdev->handle.private = evdev;
    //minor不是真正的次设备号，还要加上EVDEV_MINOR_BASE
    evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);
    evdev->dev.class = &input_class;
    //配对生成的device，父设备是与他相关连的input_dev
    evdev->dev.parent = &dev->dev;
    evdev->dev.release = evdev_free;
    device_initialize(&evdev->dev);
    //注册handle结构体
    error = input_register_handle(&evdev->handle);
    if (error)
        goto err_free_evdev;
    //把evdev结构保存到evdev_table中，这个数组以minor为索引
    error = evdev_install_chrdev(evdev);
    if (error)
        goto err_unregister_handle;
    //注册到linux设备模型中
    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;
}

evdev_connect函数做配对后的善后工作，分配一个evdev结构体，并初始化相关成员，evdev结构体中有
input_handle结构，初始化并注册

2、input_register_handle()函数注册一个input_handle

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;

    /*
     * Filters go to the head of the list, normal handlers
     * to the tail.
     */
    if (handler->filter)
        //将handle的d_node，链接到其相关的input_dev的h_list链表中
        list_add_rcu(&handle->d_node, &dev->h_list);
    else
        list_add_tail_rcu(&handle->d_node, &dev->h_list);

    mutex_unlock(&dev->mutex);

    /*
     * 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.
     */
     //将handle的d_node，链接到其相关的input_handler的h_list链表中
    list_add_tail_rcu(&handle->h_node, &handler->h_list);

    if (handler->start)
        handler->start(handle);

    return 0;
}

这个函数基本没做什么事，就是把一个handle结构体通过d_node链表项，分别链接到input_dev的h_list,
input_handler的h_list上。以后通过这个h_list就可以遍历相关的input_handle了

3、input_register_handler()函数注册一个input_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);

    if (handler->fops != NULL) {
        if (input_table[handler->minor >> 5]) {
            retval = -EBUSY;
            goto out;
        }
        input_table[handler->minor >> 5] = handler;
    }
    //连接到input_handler_list链表中
    list_add_tail(&handler->node, &input_handler_list);
    //配对，遍历input_dev，和注册input_dev过程一样的
    list_for_each_entry(dev, &input_dev_list, node)
        input_attach_handler(dev, handler);

    input_wakeup_procfs_readers();

 out:
    mutex_unlock(&input_mutex);
    return retval;
}

这个函数其实和input_register_device类似，都是要注册、配对

四、input输入子系统核心层
1、input输入子系统初始化定义在driver/input/input.c中，如下

static int __init input_init(void)
{
    int err;
    //向内核注册一个类，用于linux设备模型。注册后会在/sys/class下面出现input目录
    err = class_register(&input_class);
    if (err) {
        pr_err("unable to register input_dev class\n");
        return err;
    }
    //在/proc下创建入口项
    err = input_proc_init();
    if (err)
        goto fail1;
    //注册字符设备，设备号INPUT_MAJOR为13，设备名为input
    err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
    if (err) {
        pr_err("unable to register char major %d", INPUT_MAJOR);
        goto fail2;
    }

    return 0;

 fail2:    input_proc_exit();
 fail1:    class_unregister(&input_class);
    return err;
}
//子系统初始化时调用
subsys_initcall(input_init);

这个函数主要是注册了字符设备，这里和杂项设备的原理是一样，所以input设备也是一类字符设备，只不过操作
方法交给了输入子系统。从这里可以看出无论linux设备驱动这块有多复杂，他们都是由一些基本的组件构成的

2.输入子系统的核心其他部分都是提供的接口，向上连接事件处理层，向下连接驱动层。
向下对驱动层的接口主要有：
input_allocate_device这个函数主要是分配一个input_dev接口，并初始化一些基本的成员
input_unregister_device注册一个input设备input_event这个函数很重要，是驱动层向input子系统核心报告事件
的函数。
input_allocate_device分配并初始化一个input_dev结构
向上对事件处理层接口主要有：
input_register_handler注册一个事件处理器
input_register_handle注册一个input_handle结构

五、事件处理层
事件处理层与用户程序和输入子系统核心打交道，是他们两层的桥梁。一般内核有好几个事件处理器，
像evdev、mousedev、jotdev。evdev事件处理器可以处理所有的事件，触摸屏驱动就是用的这个。

1、evdev_init()事件处理层初始化

static int __init evdev_init(void)
{
    return input_register_handler(&evdev_handler);
}

调用一个注册handler函数，将evdev_handler注册到系统中

2、主要的数据结构
1）evdev设备结构

struct evdev {
    int open;//打开标志
    int minor;//次设备号
    struct input_handle handle;//关联的input_handle
    wait_queue_head_t wait;//等待队列，当进程读取设备，而没有事件产生的时候，进程就会睡在其上面
    struct evdev_client __rcu *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结构，说明这是一个设备结构
    bool exist;
};

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

2）evdev用户端结构

struct evdev_client {
    unsigned int head;//针对buffer数组的索引
    unsigned int tail;//针对buffer数组的索引，当head与tail相等的时候，说明没有事件
    unsigned int packet_head; /* [future] position of the first element of next packet */
    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链表项
    unsigned int bufsize;
    struct input_event buffer[];//这个是一个input_event数据结构的数组，input_event代表一个事件，基本成员：类型（type），编码（code），值（value）
};

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

3、主要的函数
1）evdev设备打开函数

static int evdev_open(struct inode *inode, struct file *file)
{
    struct evdev *evdev;
    struct evdev_client *client;
    int i = iminor(inode) - EVDEV_MINOR_BASE;
    unsigned int bufsize;
    int error;

    if (i >= EVDEV_MINORS)
        return -ENODEV;

    error = mutex_lock_interruptible(&evdev_table_mutex);
    if (error)
        return error;
    //得到evdev设备结构,每次调用evdev_connect配对成功后都会把分配的evdev结构以minor为索引，保存在evdev_table数组中
    evdev = evdev_table[i];
    if (evdev)
        get_device(&evdev->dev);//增加device引用计数
    mutex_unlock(&evdev_table_mutex);

    if (!evdev)
        return -ENODEV;

    bufsize = evdev_compute_buffer_size(evdev->handle.dev);
//分配用户端结构
    client = kzalloc(sizeof(struct evdev_client) +
                bufsize * sizeof(struct input_event),
             GFP_KERNEL);
    if (!client) {
        error = -ENOMEM;
        goto err_put_evdev;
    }

    client->bufsize = bufsize;
    spin_lock_init(&client->buffer_lock);
    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_open_device()函数

static int evdev_open_device(struct evdev *evdev)
{
    int retval;

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

    mutex_unlock(&evdev->mutex);
    return retval;
}

3）input_open_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的打开计数加1，注意和evdev的open的区别
    handle->open++;
    //如果此input_dev没有进程在引用，并且定义了open方法，就调用open方法
    if (!dev->users++ && dev->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;
}

4）evdev_read()函数

static ssize_t evdev_read(struct file *file, char __user *buffer,
              size_t count, loff_t *ppos)
{
    //这个客户端结构在打开的时候分配并保存在file->private_data中
    struct evdev_client *client = file->private_data;
    struct evdev *evdev = client->evdev;
    struct input_event event;
    int retval;
    //用户进程每次读取设备的字节数，不要少于input_event结构的大小
    if (count < input_event_size())
        return -EINVAL;
    //head等于tail说明目前还没有事件传回来，如果设置了非阻塞操作，则会立刻返回
    if (client->packet_head == client->tail && evdev->exist &&
     (file->f_flags & O_NONBLOCK))
        return -EAGAIN;
    //没有事件就会睡在evdev的等待队列上了，等待条件是有事件到来或者设备不存在了
    retval = wait_event_interruptible(evdev->wait,
        client->packet_head != client->tail || !evdev->exist);

    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_eventbuffer数组
        if (input_event_to_user(buffer + retval, &event))//将事件复制到用户空间
            return -EFAULT;

        retval += input_event_size();
    }

    return retval;
}

六、事件传递过程
1.事件产生
当按下触摸屏时，进入触摸屏按下中断，开始ad转换，ad转换完成进入ad完成中断，在这个中端中将事件发送出去，调用
input_report_abs(dev,ABS_X,xp);
input_report_abs(dev,ABS_Y,yp);
这两个函数调用了input_event(dev,EV_ABS,code,value)
所有的事件报告函数都调用这个函数。

2、事件报告
1）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);
        spin_unlock_irqrestore(&dev->event_lock, flags);
    }
}

2）input_handle_event()函数

static void input_handle_event(struct input_dev *dev,
                   unsigned int type, unsigned int code, int value)
{
    int disposition = INPUT_IGNORE_EVENT;

    switch (type) {

    case EV_SYN:
        switch (code) {
        case SYN_CONFIG:
            disposition = INPUT_PASS_TO_ALL;
            break;

        case SYN_REPORT:
            if (!dev->sync) {
                dev->sync = true;
                disposition = INPUT_PASS_TO_HANDLERS;
            }
            break;
        case SYN_MT_REPORT:
            dev->sync = false;
            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);
                else
                    input_stop_autorepeat(dev);
            }

            disposition = INPUT_PASS_TO_HANDLERS;
        }
        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))
            disposition = input_handle_abs_event(dev, code, &value);

        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 = false;

    if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
        dev->event(dev, type, code, value);

    if (disposition & INPUT_PASS_TO_HANDLERS)
        input_pass_event(dev, type, code, value);
}

这个函数主要是根据事件类型的不同，做相应的处理。disposition这个是事件处理的方式，默认的是
INPUT_IGNORE_EVENT，忽略这个事件，如果是INPUT_PASS_TO_HANDLERS则是传递给事件处理器，如果是
INPUT_PASS_TO_DEVICE，则是传递给设备处理。

3）input_pass_event()函数

static void input_pass_event(struct input_dev *dev,
                 unsigned int type, unsigned int code, int value)
{
    struct input_handler *handler;
    struct input_handle *handle;

    rcu_read_lock();
//如果是绑定的handle，则调用绑定的handler->event函数
    handle = rcu_dereference(dev->grab);
    if (handle)
        handle->handler->event(handle, type, code, value);
    else {
        bool filtered = false;
//如果没有绑定，则遍历dev的h_list链表，寻找handle，如果handle已经打开，说明有进程读取设备关联的evdev
        list_for_each_entry_rcu(handle, &dev->h_list, d_node) {
            if (!handle->open)
                continue;

            handler = handle->handler;
            if (!handler->filter) {
                if (filtered)
                    break;
//调用相关的事件处理器的event函数，进行事件的处理
                handler->event(handle, type, code, value);

            } else if (handler->filter(handle, type, code, value))
                filtered = true;
        }
    }

    rcu_read_unlock();
}

4）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;
//将传过来的事件，赋值给input_event结构
    do_gettimeofday(&event.time);
    event.type = type;
    event.code = code;
    event.value = value;

    rcu_read_lock();
    //如果evdev绑定了client那么，处理这个客户端
    client = rcu_dereference(evdev->grab);
    if (client)
        evdev_pass_event(client, &event);
    else
        //遍历client链表，调用evdev_pass_event函数
        list_for_each_entry_rcu(client, &evdev->client_list, node)
            evdev_pass_event(client, &event);

    rcu_read_unlock();
    if (type == EV_SYN && code == SYN_REPORT)
    {//唤醒等待的进程
        wake_up_interruptible(&evdev->wait);
    }
}

5）evdev_pass_event()函数

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);
//将事件赋值给客户端的input_event数组
    client->buffer[client->head++] = *event;
    client->head &= client->bufsize - 1;

    if (unlikely(client->head == client->tail)) {
        /*
         * This effectively "drops" all unconsumed events, leaving
         * EV_SYN/SYN_DROPPED plus the newest event in the queue.
         */
        client->tail = (client->head - 2) & (client->bufsize - 1);

        client->buffer[client->tail].time = event->time;
        client->buffer[client->tail].type = EV_SYN;
        client->buffer[client->tail].code = SYN_DROPPED;
        client->buffer[client->tail].value = 0;

        client->packet_head = client->tail;
    }

    if (event->type == EV_SYN && event->code == SYN_REPORT) {
        client->packet_head = client->head;
        kill_fasync(&client->fasync, SIGIO, POLL_IN);
    }

    spin_unlock(&client->buffer_lock);
}

可以看出，evdev_pass_event函数最终将事件传递给了用户端的client结构中的input_event数组中，
只需将这个input_event数组复制给用户空间，进程就能收到触摸屏按下的信息了。具体处理由具体的应用程序来完成。