学习目的：
- 熟悉linux输入子系统的框架
前面学习了简单驱动程序的编写，并通过对查询方式的按键驱动程序的不断改进，逐步的在程序中引入了中断、poll、异步通知、同步互斥等机制来完善驱动程序。虽然我们编写的驱动程序也实现了相关功能，但却不能被别人编写好的应用程序无缝的使用，别人的应用程序肯定不知道去打开/dev/button设备。因此，我们还应该去学习内核中现有的驱动框架，将自己的驱动程序融入其中，输入子系统便是属于其中的一类。
1、输入子系统概述
Linux内核为了能够处理不同类型的输入设备，比如说触摸屏、鼠标、键盘、操纵杆，设计实现了为驱动程序的实现提供了统一接口函数；为上层应用提供试图统一的抽象层，即Linux输入子系统。
上图为输入子系统框架，从图中可以看出输入子系统由Input driver（驱动层）、Input core（核心层）、Event handler（事件处理层）三部分组成。
Input driver：主要实现对硬件设备的读写访问，并将硬件产生的事件转换成核心层定义的规范提交给事件处理层
Input core：承上启下，为设备驱动层提供接口，通知事件处理层对事件进行处理
Event handler：提供统一设备节点供应用程序使用，处理驱动层上报事件
一个输入事件，如一个按键按下、鼠标移动等等，通过Input driver -> Input core -> Event handler -> usrspace上报给用户程序
2、输入子系统框架分析
2.1 系统核心层（input core）
系统核心层是在内核的driver/input/input.c文件中实现的，除了提供了Input driver和Event handler注册的接口input_register_device、input_register_handler和两者之前的沟通的桥梁外，还在入口函数处创建input类、注册了主设备号和file_operations结构体。入口函数如下：
static int __init input_init(void) { ... err = class_register(&input_class); //创建一个input类 ... err = input_proc_init(); ... err = register_chrdev(INPUT_MAJOR, "input", &input_fops); //注册主设备号为13输入子系统 ... }
入口函数input_init函数注册的file_operations结构体中只实现了open函数，当应用程序使用系统调用打开主设备号为13的输入子系统设备时，调用到系统核心层的open函数。系统核心层的open函数根据打开设备的次设备号，在input_table数组中找到对应Event handler，并将Event handler中的file_operations成员赋给打开设备的file->f_op，最终调用到handler中的open函数。
static int input_open_file(struct inode *inode, struct file *file) { struct input_handler *handler = input_table[iminor(inode) >> 5]; const struct file_operations *old_fops, *new_fops = NULL; if (!handler || !(new_fops = fops_get(handler->fops))) return -ENODEV; if (!new_fops->open) { fops_put(new_fops); return -ENODEV; } old_fops = file->f_op; file->f_op = new_fops; err = new_fops->open(inode, file); .... }
input_open_file函数中修改打开设备的file->f_op指针，让其指向Event handler中的file_operations成员，那么使用open系统调用返回的文件描述符的read、write函数最终会调用到Event handler定义的file_operation成员对应的read、write函数
2.2 事件处理层（Event handler）
2.2.1 handler数据结构
handler层是纯软件层，包含了不同的解决方案，如键盘、按键、鼠标、游戏手柄等。该层的核心数据结构为input_handler结构体，其主要成员如下：
struct input_handler { ... void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);------------->事件处理函数，input_event被调用 int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id);----------------->dev和handler匹配成功,调用connect函数，在input类中创建设备 void (*disconnect)(struct input_handle *handle); ...const struct file_operations *fops; -------------------->handler的file_operation， int minor; const char *name; ... const struct input_device_id *id_table;----------------->存放该handler所支持的设备id的表，其实内部存放的是EV_XXX事件，用于判断device是否支持该事件 ...struct list_head h_list;------------------->链表指针，指向handle成员h_node struct list_head node;---------------------->链表指针，用以将注册的handler挂入头部为input_handler_list的链表中 };
2.2.2 事件处理层注册函数
handler层中调用input_register_handler注册一个handler，该部分由内核实现，input_register_handler函数
int input_register_handler(struct input_handler *handler) { struct input_dev *dev; ... input_table[handler->minor >> 5] = handler;----------------->① ... list_add_tail(&handler->node, &input_handler_list);------------->② list_for_each_entry(dev, &input_dev_list, node)----------------->③ input_attach_handler(dev, handler); ... }
① 以传入handler成员的次设备号除以32为索引，把传入的handler存放到input_table数组中
② 将handler挂入到input_handler_list为头部的链表中，这样是为了input_register_device可以遍历所有的handler，看是否有handler可以进行匹配支持device，同③类似
③ 遍历所有的input_dev_list链表中挂接的注册的所有device，看是否和handler匹配
input_attach_handler函数
static int input_attach_handler(struct input_dev *dev, struct input_handler *handler) { ... id = input_match_device(handler->id_table, dev); ... error = handler->connect(handler, dev, id); ... }
该函数通过比较device和handler的id_table，判断handler是否支持该device，如果匹配成功，调用handler成员的connect函数
evdev.c中的connect函数
static int evdev_connect(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id) { ... evdev->exist = 1; evdev->minor = minor; evdev->handle.dev = dev; evdev->handle.name = evdev->name; evdev->handle.handler = handler; evdev->handle.private = evdev; sprintf(evdev->name, "event%d", minor);------------------------>① evdev_table[minor] = evdev; devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor), cdev = class_device_create(&input_class, &dev->cdev, devt, dev->cdev.dev, evdev->name); ------------------>② ... error = input_register_handle(&evdev->handle);---------------->③ ... }
① 初始化一个handle成员，并使handle结构体成员handler指针指向当前handler，dev指针指向当前dev。
② 在input入口函数中创建的input_class类中创建了一个设备，udev机制会根据这些信息，自动在/dev目录下创建设备节点
③ 调用input_register_handle函数，使得dev、handler中的h_list指针分别指向handle中的d_node、h_node
其创建关系可由下图表示：
这样每个handler、dev便能通过自己的h_list指针找到handle，并通过handle中的dev或handler指针，找到和自己匹配的另一半，如device部分可以通过handle调用到handler中的成员函数
2.2.2 事件处理层handler实现
事件处理层handler部分已经在内核中实现，内核中根据输入子系统类型抽象出不同handler，我们以evdev.c为例来分析
evdev.c的入口函数中向输入核心层注册了input_handler，其注册input_handler成员如下：
static struct input_handler evdev_handler = { .event = evdev_event,----------------------->① .connect = evdev_connect,------------------->② .disconnect = evdev_disconnect, .fops = &evdev_fops,-------------------->③ .minor = EVDEV_MINOR_BASE, .name = "evdev", .id_table = evdev_ids, };
① handler的event函数，后面进行分析
② handler的connect函数，上文已经以分析过了，该函数实现搭建匹配成功的handler和dev间沟通桥梁
③ handler的file_operations结构体
input.c中注册input子系统字符设备时，其input_fops中的open函数根据打开设备次设备号找到对应handler，将次fops赋给打开文件对应file.f_op，open、read最终会调用到handler中file_operation实现的xxx_open、xxx_read（上文系统核心层以介绍)
evdev.c的read函数
static ssize_t evdev_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos) { ... retval = wait_event_interruptible(evdev->wait,--------------------------------------->① client->head != client->tail || !evdev->exist); ... while (client->head != client->tail && retval + evdev_event_size() <= count) {------->② struct input_event *event = (struct input_event *) client->buffer + client->tail; if (evdev_event_to_user(buffer + retval, event)) ... client->tail = (client->tail + 1) & (EVDEV_BUFFER_SIZE - 1); retval += evdev_event_size(); } ... }
① 环形缓冲区为空，即无数据可读时，将进程挂入到等待队列中进行休眠
② 环形缓存取有数据时，将数据拷贝回用户空间
既然read函处无数据时应用进程被挂入到队列中休眠，那么肯定有在其他地方被唤醒，被唤醒处就是在event函数中
static void evdev_event(struct input_handle *handle, unsigned int type, unsigned int code, int value) { ... list_for_each_entry(client, &evdev->client_list, node) {----------->① do_gettimeofday(&client->buffer[client->head].time); client->buffer[client->head].type = type; client->buffer[client->head].code = code; client->buffer[client->head].value = value; client->head = (client->head + 1) & (EVDEV_BUFFER_SIZE - 1); kill_fasync(&client->fasync, SIGIO, POLL_IN);--------------->② } wake_up_interruptible(&evdev->wait);-------------------------------->③ }
① 将传入的值写入到read读取的环形缓冲区内
② 发送异步通知信号
③ 唤醒挂在read函数中无数据可读进入休眠的应用程序进程
2.3 驱动层（input driver）
2.3.1 驱动层注册接口
设备驱动层是纯硬件操作层，包括不同硬件的接口的处理，该部分由用户自己处理。对于不同的硬件操作，都有一个input_dev结构体，通过input_register_device向输入核心层注册。
input_register_device函数主要内容如下：
int input_register_device(struct input_dev *dev) { ... list_add_tail(&dev->node, &input_dev_list);--------------->① ... list_for_each_entry(handler, &input_handler_list, node)--->② input_attach_handler(dev, handler); ... }
① 将注册的dev挂入Input核心层中定义的以input_dev_list为头部的链表中，input_register_handler中遍历该链表，方便获取所有注册的dev，进行比较匹配
② 同input_register_handler一样，找到所有注册的handler一一进行比较，如果找到支持该设备的handler调用handler中的connect函数，建立同handler中相同的连接
我们可以看出，输入子系统中handler和dev注册时分开的，注册1个dev时侯，并不需要handler已经存在，而1个handler被注册时，也不需要对应的dev已经被注册。dev和handler各自涌向内核，而每个dev和handler涌入内核时，都会寻找自己的另一半，如果匹配成功，将调用handler中的connect函数创建handle建立连接，将其捆绑在一起，匹配成功的dev和handler可以通过handle彼此的访问对方的结构体成员函数。
2.3.2 驱动层的实现
内核中提供了一个实现驱动层的简单例子，源码为gpio_keys.c，我们可以通过分析这个例子，来分析驱动层主要实现的内容
gipo_keys.c的入口函数
static int __devinit gpio_keys_probe(struct platform_device *pdev) { ... input = input_allocate_device(); ... error = request_irq(irq, gpio_keys_isr, IRQF_SAMPLE_RANDOM, button->desc ? button->desc : "gpio_keys", pdev); error = input_register_device(input); ... }
入口函数中主要完成了分配input_dev结构体，初始化相关GPIO、注册按键中断，向内核注册input_dev
按键中断服务程序gpio_keys_isr
static irqreturn_t gpio_keys_isr(int irq, void *dev_id) { ... for (i = 0; i < pdata->nbuttons; i++) { struct gpio_keys_button *button = &pdata->buttons[i]; int gpio = button->gpio; if (irq == gpio_to_irq(gpio)) { unsigned int type = button->type ?: EV_KEY; int state = (gpio_get_value(gpio) ? 1 : 0) ^ button->active_low; input_event(input, type, button->code, !!state); input_sync(input); } } ... }
中断服务程序中分辨中断源，确定按键值，并调用input_event上报相关输入值
input_event函数
void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) { ... switch (type) {------------------>① ... case EV_KEY: if (code > KEY_MAX || !test_bit(code, dev->keybit) || !!test_bit(code, dev->key) == value) return; if (value == 2) break; change_bit(code, dev->key); if (test_bit(EV_REP, dev->evbit) && dev->rep[REP_PERIOD] && dev->rep[REP_DELAY] && dev->timer.data && value) { dev->repeat_key = code; mod_timer(&dev->timer, jiffies + msecs_to_jiffies(dev->rep[REP_DELAY])); } break; ... } list_for_each_entry(handle, &dev->h_list, d_node)-------------->② if (handle->open) handle->handler->event(handle, type, code, value); }
① input_event函数根据输入事件类型，判断输入值的有效性
② 找到所有和dev创建连接的handler，通过两者间交流桥梁handle调用handler中的event函数
结合上文的handler部分evdev.c部分分析，可以看出输入子系统除了软件框架外，数据读写思想和我们之前实现按键驱动程序类似，read时当无数据可读时，应用程序被添加到等待队列中进行休眠，当有数据可读时，休眠应用程序被唤醒，只不过被唤醒时是通过调用input_event函数最终调用到handler的evnet函数实现的唤醒。
3、总结
input子系统调用过程可分为以下部分：
- 当外部应用程序需要调用输入子系统的open函数时，会先通过主设备号进入到核心层，然后通过次设备号进入handler层，再调用.fops内的open函数返回fd；
- 当外部应用程序需要调用输入子系统的read函数时，会通过返回的fd调用.fop内的read函数，然后休眠，等待被.event函数唤醒
- 当外部中断到达的时候，会先确定中断事件，然后用input_event上报事件，再通过h_list里面的所有handle调用对应的handler中的.event函数，对read进行唤醒，然后在read中返回（也就是当device有多个对应的handler的时候,input_event会向所有的handler上报事件）
- 当需要加入新的handler时，需要先构建handler结构体，然后调用input_register_handler对该handler进行注册。input_register_handler的内部实现：往input_handler_list加入新增的handler节点，然后对input_device_list的所有结点（也就是所有的device）进行遍历，通过.id_table查看该device是否支持该handler,对支持的device调用.connect,一一地构建input_handle结构体,连接handler跟device
- 当需要加入新的device时，需要先构建input_dev结构体，然后调用input_register_device对该input_dev进行注册。input_register_dev的内部实现：往input_device_list加入新增的device节点，然后对input_handler_list的所有结点（也就是所有的handler）进行遍历，通过handler 的.id_table查看该handler是否支持该device,对支持的device调用该handler的.connect,一一地构建input_handle结构体,连接handler跟device
在输入子系统框架下，我们一般的编写驱动也就是对device部分进行编写（分配input_dev并配置，驱动入口，出口，中断时进行中断判断，当有数据时然后上报事件等），然后对该device的input_dev进行注册