Liunx input子系统框架

框架

Liunx Input 框架 包含三部分：

1. 核心层(input.c)：起到乘上启下的作用，接收来次底层的事件，传递给上层的handler
2. handler层： 处理核心层上传的事件，分发给上层应用
3. 设备层：硬件相关的驱动，从硬件上读取输入事件，并上报给核心层

重要结构体

input_dev 表示输入设备

input_handler 表示处理程序

上面两者匹配成功之后，用 input_handle 保存两者之间的联系

获取和上报的事件：input_event

注册流程

input_dev 注册流程:input_register_device

list_add_tail(&dev->node, &input_dev_list);

list_for_each_entry(handler, &input_handler_list, node)
		input_attach_handler(dev, handler);

将 inpput_dev 放入input_dev_list链表 ，并且 对 input_handler_list 链表中的的每个handler，调用input_attach_handler 函数

id = input_match_device(handler, dev);
if (!id)
	return -ENODEV;

error = handler->connect(handler, dev, id);

匹配成功的话，则调用 input_handler 的 connect 函数

input_handler 注册流程：

list_add_tail(&handler->node, &input_handler_list);

list_for_each_entry(dev, &input_dev_list, node)
	input_attach_handler(dev, handler);

将 input_handler 放入input_handler_list链表，并且对 input_dev_list 链表中的每个input_dev ，也调用input_attach_handler 函数， 最终匹配成功的话，也会调用handler的 connect 函数

connect 流程

以evdev.c 为例，connect 主要是创建 注册一个 input_handle，并将其分别放入 input_dev 和 input_handler 的链表中。 另外 注册字符设备驱动程序

evdev->handle.dev = input_get_device(dev);
evdev->handle.name = dev_name(&evdev->dev);
evdev->handle.handler = handler;
evdev->handle.private = evdev;

error = input_register_handle(&evdev->handle);//放入链表
	if (handler->filter)
		list_add_rcu(&handle->d_node, &dev->h_list);
	else
		list_add_tail_rcu(&handle->d_node, &dev->h_list);
	list_add_tail_rcu(&handle->h_node, &handler->h_list);

//创建字符设备驱动程序
cdev_init(&evdev->cdev, &evdev_fops);
evdev->cdev.kobj.parent = &evdev->dev.kobj;
error = cdev_add(&evdev->cdev, evdev->dev.devt, 1);

读取事件流程分析

1. APP调用open函数 打开 dev/input/eventX 节点 ,在evdev_open函数中，创建
   evdev_client

struct evdev_client *client;
client = kzalloc(size, GFP_KERNEL | __GFP_NOWARN);
client->evdev = evdev;
evdev_attach_client(evdev, client);

2. APP 调用read 函数 无数据时，在 evdev_wait队列上休眠

if (!(file->f_flags & O_NONBLOCK)) {
   		error = wait_event_interruptible(evdev->wait,
   				client->packet_head != client->tail ||
   				!evdev->exist || client->revoked);
   		if (error)
   			return error

3. 点击设备，产生中断，在中断服务程序中，使用input_event上报数据

list_for_each_entry_rcu(handle, &dev->h_list, d_node)
			if (handle->open) {
				count = input_to_handler(handle, vals, count);
				if (!count)
					break;
			}

从input_dev 的 list 链表中 ，取出 handle,调用 input_to_handler 函数

struct input_handler *handler = handle->handler;
if (handler->filter) {
		for (v = vals; v != vals + count; v++) {
			if (handler->filter(handle, v->type, v->code, v->value))
				continue;
			if (end != v)
				*end = *v;
			end++;
		}
		count = end - vals;
}
if (handler->events)
		handler->events(handle, vals, count);
else if (handler->event)
		for (v = vals; v != vals + count; v++)
			handler->event(handle, v->type, v->code, v->value);

从 handle 中取出 input_hander ,如果提供了 filter 函数，则优先调用 filter ，如果提供了 events 函数，则调用 events 函数，否则调用 event 函数，唤醒每个client

list_for_each_entry_rcu(client, &evdev->client_list, node)
			evdev_pass_values(client, vals, count, ev_time);

		event.type = v->type;
		event.code = v->code;
		event.value = v->value;
		__pass_event(client, &event);//将数据放到client 的 buffer 中


		if (wakeup)
		wake_up_interruptible(&evdev->wait); //唤醒正在读事件的进程

4. 唤醒之后,evdev_read 继续执行，将数据拷贝至用户空间

while (read + input_event_size() <= count &&
		       evdev_fetch_next_event(client, &event)) {

			if (input_event_to_user(buffer + read, &event))
				return -EFAULT;

			read += input_event_size();

总结

• 调用input_register_device或者input_register_handler 都会导致 判断是否匹配，匹配成功，调用input_handler 的 connect 函数
• 在connect 函数中，会分配设置 input_handle 结构体，用于保存它们之间的联系，并分别放入input_handler 和 input_dev 的 h_list 链表中。最终可以通过 h_list 链表找到 input_handle,进而找到与之匹配的 hander/input_dev
• 每个APP 调用 open 的 时候，都会 分配一个 client
• 写一个liunx 的 输入设备的驱动程序，就是 分配，设置，注册一个 input_dev结构体