第二期驱动篇——2.1 输入子系统—框架分析

输入子系统——框架分析

• 硬件平台：韦东山嵌入式Linxu开发板（S3C2440.v3）
• 软件平台：运行于VMware Workstation 12 Player下UbuntuLTS16.04_x64 系统
• 参考资料：《嵌入式Linux应用开发手册》、《嵌入式Linux应用开发手册第2版》
• 开发环境：Linux 2.6.22.6 内核、arm-linux-gcc-3.4.5-glibc-2.3.6工具链
• 源码仓库：https://gitee.com/d_1254436976/Embedded-Linux-Phase-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: %d\n",
			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成员。