linux内核gipo定义路径,linux输入子系统分析

学习目的：

熟悉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结构体，其主要成员如下：

structinput_handler {...void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, intvalue);------------->事件处理函数，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，intminor;const char *name;

...const struct input_device_id *id_table;----------------->存放该handler所支持的设备id的表，其实内部存放的是EV_XXX事件，用于判断device是否支持该事件

...structlist_head h_list;------------------->链表指针，指向handle成员h_nodestructlist_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, intvalue)

{

...

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)) {

unsignedint 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, intvalue)

{

...switch(type) {------------------>①

...caseEV_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进行注册

原文：https://www.cnblogs.com/053179hu/p/13746644.html