输入子系统——框架分析

/*
 *硬件平台：韦东山嵌入式Linxu开发板（S3C2440.v3）
 *软件平台：运行于VMware Workstation 12 Player下UbuntuLTS16.04_x64 系统
 *参考资料：《嵌入式Linux应用开发手册》、《嵌入式Linux应用开发手册第2版》

一、前言

  对于之前写驱动的时候，我们都是在APP文件中打开了一个特定的设备文件如/dev/buttons，但是一般在实际应用过程中不会打开/dev/buttons。一般是直接scanf()就去获得了按键的输入。
  以前写的那些驱动程序有一下缺点：

1. 不通用，只能自已使用而非通用。
2. 耦合性不高，无法让其他应用程序“无缝”的使用。

  解决这个问题的答案就需要：使用现成的驱动——输入子系统（input 子系统），把自已的设备相关的驱动放到内核中这种驱动架构中去。
  在使用之前，我们需要分析输入子系统（input 子系统）的大致框架。

二、框架分析

对于输入子系统，其主要文件在/driver/input.c

1、入口函数input_init()

分析：在这个入口函数中，通过register_chrdev(INPUT_MAJOR, "input", &input_fops);注册了一个设备。

/* 入口函数   3. 注册了一个设备  */ static int __init input_init(void) { /*........*/  err = register_chrdev(INPUT_MAJOR, "input", &input_fops); /*........*/ } 

2、file_operation结构体

分析：只有open函数，没有其他的函数，肯定在open函数中进行了其他的操作。

static const struct file_operations input_fops = { .owner = THIS_MODULE, .open = input_open_file, }; 

3、input_open_file函数

分析：在input_open_file()函数中

1. 根据inode的此设备号找到对应的句柄hander
2. 把该hander->fops赋值给新建的file_operations结构体new_fops
3. 保存file->f_op，并将其赋值为new_fops
4. 调用new_fops->open()函数

可以看出这个函数属于被调用函数，而且是通过一个设备的次设备号作为索引找到对应的句柄。

static int input_open_file(struct inode *inode, struct file *file) { /* 根据此设备号，在input_table[]数组里面找到对应的input_handler句柄 */ struct input_handler *handler = input_table[iminor(inode) >> 5]; const struct file_operations *old_fops, *new_fops = NULL; int err; /* 通过上面得到的input_handler句柄找到对应的file_operation的fops结构体，并赋值给新建的new_fops */ if (!handler || !(new_fops = fops_get(handler->fops))) return -ENODEV; /* 判断new_fops结构体的open函数是否为空 */ if (!new_fops->open) { fops_put(new_fops); return -ENODEV; } /* 把打开文件的file_operation结构体赋值给old_fops */  old_fops = file->f_op; /* 把新得到的new_fops赋值给打开文件的fops: 起中转作用 */  file->f_op = new_fops; /* 根据这个new_fops结构体调用open函数 */  err = new_fops->open(inode, file); if (err) { fops_put(file->f_op);   file->f_op = fops_get(old_fops); } fops_put(old_fops); return err; } 

4、谁负责存储input_table[]这个数组的项——input_register_handler()函数

input_table[]原型

static struct input_handler *input_table[8]; 

input_register_handler()函数
分析：

1. 句柄的的次设备号作为索引，存储在对应的input_table[ ]项中
2. 把该句柄的node放入链表
3. 对于每一个input_dev，都调用input_attach_handler()，根据input_handler的id_table判断能否支持这个input_dev

/* 注册handle函数 */ int input_register_handler(struct input_handler *handler) { /*.....*/ /* 判断是否为空，则进行放入数组 */ if (handler->fops != NULL) { if (input_table[handler->minor >> 5]) return -EBUSY;    input_table[handler->minor >> 5] = handler; } // 放入链表 list_add_tail(&handler->node, &input_handler_list); // 对于每个input_dev，调用input_attach_handler list_for_each_entry(dev, &input_dev_list, node) input_attach_handler(dev, handler); // 根据input_handler的id_table判断能否支持这个input_dev /*.....*/ return 0; } 

5、谁使用这个input_register_handler()函数——evdev.c

通过搜索可以查询到如下文件会调用input_register_handler()，拿去其中的evdev.c驱动文件进行说明。

5.1 入口函数evdev_init()

在这个入口函数只调用了input_register_handler()，并且看见有evdev_handler这个变量。

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

5.2 input_handler类型的结构体evdev_handler

对于这个结构体中的函数，我们下面会进行分析。

static struct input_handler evdev_handler = { .event   = evdev_event, //事件 .connect  = evdev_connect, //联系 .disconnect = evdev_disconnect, //不联系 .fops   = &evdev_fops, //file_operation结构体 .minor   = EVDEV_MINOR_BASE, //次设备号 .name   = "evdev", //设备名字 .id_table = evdev_ids, //用来绑定设备和驱动 }; 

6、大致框架

到目前为止，我们可以分析出大致的框架，目前分析的是在纯软件中，那么对于实际的硬件呢？下面就来分析下在input.c文件中的input_register_device()函数。

7、input_register_device()函数

分析：

1. 把该设备的node放入链表
2. 对于每一个input_handler，都调用input_attach_handler()，根据input_handler的id_table判断能否支持这个input_dev

int input_register_device(struct input_dev *dev) { /*......*/ // 放入链表 list_add_tail(&dev->node, &input_dev_list); // 对于每一个input_handler，都调用input_attach_handler list_for_each_entry(handler, &input_handler_list, node) input_attach_handler(dev, handler); // 根据input_handler的id_table判断能否支持这个input_dev input_wakeup_procfs_readers(); return 0; } 

8、谁使用这个input_register_device()函数——具体的设备文件

通过搜索可以查询到如下文件会调用input_register_device()，对于一个驱动文件可以支持多个设备文件，而input_register_device()函数就是把这些设备注册进驱动文件中。

9、大致框架2

10、input_attach_handler()函数

分析：可以发现到input_register_device()和input_register_handle()的处理过程很相似，而且都调用了input_attach_handler()函数。

input_attach_handler()函数

分析：

1. 进行匹配: 注册input_dev或input_handler时，会两两比较左边的input_dev和右边的input_handler
2. 根据input_handler的id_table判断这个input_handler能否支持这个input_dev
3. 如果能支持，则调用input_handler的connect函数建立”连接”

static int input_attach_handler(struct input_dev *dev, struct input_handler *handler) { const struct input_device_id *id; int error; /* 进行匹配:注册input_dev或input_handler时，会两两比较左边的input_dev和右边的input_handler */ if (handler->blacklist && input_match_device(handler->blacklist, dev)) return -ENODEV; /* 根据input_handler的id_table判断这个input_handler能否支持这个input_dev */  id = input_match_device(handler->id_table, dev); if (!id) return -ENODEV; /* 如果能支持，则调用input_handler的connect函数建立"连接" */  error = handler->connect(handler, dev, id); if (error && error != -ENODEV) printk(KERN_ERR    "input: failed to attach handler %s to device %s, " "error: %dn",    handler->name, kobject_name(&dev->cdev.kobj), error); return error; } 

11、如何建立连接——分析驱动文件evdev.c

对于不同的驱动，建立连接的方式都不一样，这里分析驱动文件evdev.c的evdev_connect()函数

分析：

1. 分配一个input_handle结构体
2. 设置
   input_handle.dev = input_dev; // 指向左边的input_dev
   input_handle.handler = input_handler; // 指向右边的input_handler
3. 注册：调用input_register_handle()函数
   input_handler->h_list = &input_handle;
   inpu_dev->h_list = &input_handle;

int input_register_handle(struct input_handle *handle) { struct input_handler *handler = handle->handler; //放入链表尾部 list_add_tail(&handle->d_node, &handle->dev->h_list); //dev->h_list list_add_tail(&handle->h_node, &handler->h_list); //handler->h_list if (handler->start)   handler->start(handle); return 0; } 

static int evdev_connect(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id) { /*...........*/   evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL); // 分配一个input_handle /*...........*/ // 设置  evdev->handle.dev = dev; // 指向左边的input_dev  evdev->handle.name = evdev->name;  evdev->handle.handler = handler; // 指向右边的input_handler  evdev->handle.private = evdev; sprintf(evdev->name, "event%d", minor); //放入到构建的数组中  evdev_table[minor] = evdev; /*......*/ // 注册  error = input_register_handle(&evdev->handle); /*......*/ }(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id) { /*...........*/   evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL); // 分配一个input_handle /*...........*/ // 设置  evdev->handle.dev = dev; // 指向左边的input_dev  evdev->handle.name = evdev->name;  evdev->handle.handler = handler; // 指向右边的input_handler  evdev->handle.private = evdev; sprintf(evdev->name, "event%d", minor); //放入到构建的数组中  evdev_table[minor] = evdev; /*......*/ // 注册  error = input_register_handle(&evdev->handle); /*......*/ } 

12、大致框架3

此时对于整个输入子系统，它的大致框架如下：

1. 分上下两层：对于核心层：将纯软件（input_handler）部分和硬件部分（ input_dev）联系起来。
2. 在下层中，纯软部分通过input_register_handler()向上注册处理方式——驱动文件， 硬件部分是input_register_device()向上注册硬件层——即具体的设备文件。
3. 二者注册之后，会两两进行比较，查看其中的handler是否支持dev
4. 若支持，则调用input_handler()结构体中的.connect函数进行连接。
5. 连接的方式：｛
   ①、分配一个input_handle结构体
   ②、设置
   input_handle.dev = input_dev; // 指向左边的input_dev
   input_handle.handler = input_handler; // 指向右边的input_handler
   ③、注册：调用input_register_handle()函数
   input_handler->h_list = &input_handle;
   inpu_dev->h_list = &input_handle;
   ｝
6. 连接之后，可用通过两边的结构体中的.h_list链表中的任一一边找到对方。
   

三、实际APP的read函数

也是引用evdec.c文件来说明
对于APP中调用read()函数，最终会调用到设备的evdev_read()函数

1、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; struct evdev *evdev = client->evdev; int retval; if (count < evdev_event_size()) return -EINVAL; // 无数据并且是非阻塞方式打开，则立刻返回 if (client->head == client->tail && evdev->exist && (file->f_flags & O_NONBLOCK)) return -EAGAIN; // 否则休眠  retval = wait_event_interruptible(evdev->wait,   client->head != client->tail || !evdev->exist); /*........*/ return retval; } 

2、evdev_event()事件函数

在这个函数进行对休眠函数进行激活

static void evdev_event(struct input_handle *handle, unsigned int type, unsigned int code, int value) { /*.............*/ wake_up_interruptible(&evdev->wait); //激活 } 

3、谁调用evdev_event()事件函数

猜：应该是硬件相关的代码，input_dev那层调用的
在设备的中断服务程序里，确定事件是什么，然后调用相应的input_handler的event处理函数

static irqreturn_t gpio_keys_isr(int irq, void *dev_id) { /*.............*/ 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); } } return IRQ_HANDLED; } 

4、input_event()函数

void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value) { /*.....*/ if (dev->grab)   dev->grab->handler->event(dev->grab, type, code, value); else list_for_each_entry(handle, &dev->h_list, d_node) /* 如果handle打开，则调用该handle->handler->event */ if (handle->open)     handle->handler->event(handle, type, code, value); } 

5、过程总结

1. 应用程序读，最终会导致 handler 中的read函数。
2. 没有数据可读时就休眠，有休眠就会唤醒，搜索的结果是even函数来唤醒。
3. 猜测是input_dev层的设备中断服务程序调用了event函数。
4. 通过这个event函数可以最终追踪到纯软件部分的input_handler结构体中的.event成员。