Input Subsystem 底层框架浅析

一、绑定 input_dev 和 input_handler

当我们创建一个input_dev其描述一个输入设备的时候，我们需要把这个输入设备通过接口进行注册，会调用 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);
	.................
}

input_register_device做的事情是把input_dev放到input_dev_list的链表尾，然后对input_handler_list进行遍历，
如果对应的input_handler先加入input_handler_list链表，则调用input_attach_handler，
如果是input_dev先加入input_handler_list链表，不用担心，input_register_handler(input_handler)接口也会对input_dev_list进行遍历，同样调用input_attach_handler。

那我们来看看input_register_handler做了什么：

int input_register_handler(struct input_handler *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_attach_handler链表，然后遍历input_dev_list链表，也就是说这个跟平台设备驱动框架一样，各自瞄瞄对方，看来会有激情发生。

// kernel/drivers/input/evdev.c
static const struct input_device_id evdev_ids[] = {
         { .driver_info = 1 },	/* Matches all devices */
         { },	/* Terminating zero entry */
};

static struct input_handler evdev_handler = {
        ........
         .connect	= evdev_connect,    // 具体实现往下拉吧，不拉你会晕
        ........
         .id_table	= evdev_ids,
};

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

// kernel/drivers/input/joydev.c
static struct input_handler joydev_handler = {
	........
	.match	= joydev_match,
	.connect	= joydev_connect,
	........
	.id_table	= joydev_ids,
};

static int __init joydev_init(void)
{
     return  input_register_handler(&joydev_handler);
}
------------------------------------------------------------------------------------------

//kernel/drivers/input/mousedev.c
static struct input_handler mousedev_handler = {
	........
	.connect	= mousedev_connect,
	........
	.id_table	= mousedev_ids,
};
static int __init mousedev_init(void)
{
	........
	error = input_register_handler(&mousedev_handler);
	........
}

看看他们的id_table

// kernel/drivers/input/evdev.c
static const struct input_device_id evdev_ids[] = {
         { .driver_info = 1 },	/* Matches all devices */
         { },	/* Terminating zero entry */
};

// kernel/drivers/input/joydev.c
static const struct input_device_id joydev_ids[] = {
         {
                  .flags = INPUT_DEVICE_ID_MATCH_EVBIT | INPUT_DEVICE_ID_MATCH_ABSBIT,
                  .evbit = { BIT_MASK(EV_ABS) },
                  .absbit = { BIT_MASK(ABS_X) },
         },
        // 太多了，省略省略再省略
         { }	/* Terminating entry */
};

接下来看下 input_attach_handler 的内容:

static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
{
	........
	id = input_match_device(handler, dev);
	if (!id)
  		return -ENODEV;

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

看下 input_match_device 函数

static const  struct  input_device_id  *input_match_device(struct input_handler *handler, struct input_dev *dev)
{
	const struct input_device_id *id;
	for (id = handler->id_table; id->flags || id->driver_info; id++) {
		if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
 			if (id->bustype != dev->id.bustype)
    			continue;

  		if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
   			if (id->vendor != dev->id.vendor)
        		continue;

  		if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
   			if (id->product != dev->id.product)
    			continue;

  		if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
   			if (id->version != dev->id.version)
    			continue;
 		........
  		if (!handler->match || handler->match(handler, dev))
   			return id;
 	}

     return NULL;
}

id_table 内容 如下：

static const struct input_device_id evdev_ids[] = {
         { .driver_info = 1 },	/* Matches all devices */
         { },	/* Terminating zero entry */
};

因此对于joydev和mousedev，会根据id成员包括总线类型(bustype)，厂家(vendor)，产品(product)，版本(version)等来决定是否匹配成功。

匹配成功后，input_attach_handler 会调用 connect ，所传参数为 input_dev 、 input_handler、及 input_handler对应的 id.

static struct input_handler evdev_handler = {
        ...........................
         .connect= evdev_connect,
        ...........................
};

因此调用到了kernel/drivers/input/evdev.c的evdev_connect函数：

static const struct file_operations evdev_fops= {
        .....................
         .read	= evdev_read,
         .write	= evdev_write,
         .poll	= evdev_poll,
         .open	= evdev_open,
        .....................
         .fasync	= evdev_fasync,
         .flush	= evdev_flush,
         .llseek	= no_llseek,
};

static int evdev_connect(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id)
{
        // 忽略各种装逼代码
        .....................
        dev_set_name(&evdev->dev, "event%d", dev_no);
        .....................
        cdev_init(&evdev->cdev, &evdev_fops);
         cdev_add(&evdev->cdev, evdev->dev.devt, 1);
        device_add(&evdev->dev);
}

input_dev， input_handler和input_handle之间的关系：

再看evdev_connect函数

static int evdev_connect(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id)
{
	.....................
	evdev->handle.dev = input_get_device(dev);
 	evdev->handle.name = dev_name(&evdev->dev);
 	evdev->handle.handler = handler;
 	evdev->handle.private = evdev;
    .....................
    input_register_handle(&evdev->handle);
    .....................
}

可以看到，input_dev 被赋值给 evdev->handle.dev，而 input_handler 被赋值给 evdev->handle.handler = handler，
那 input_register_handle 又做了啥呢？

int input_register_handle(struct input_handle *handle)
{
	struct input_handler *handler = handle->handler;
	struct input_dev *dev = handle->dev;
	.....................
	if (handler->filter)
		list_add_rcu(&handle->d_node, &dev->h_list);
	else
		list_add_tail_rcu(&handle->d_node, &dev->h_list);    // 把handle的d_node插入input_dev的h_list的尾部
	.....................
	list_add_tail_rcu(&handle->h_node, &handler->h_list);    // 把handle的h_node插入input_handler的h_list的尾部
	if (handler->start)
		handler->start(handle);
}

原来 input_register_handler 的目的是通过 input_handle 把input_dev 和 input_handler 贯穿起来。

每个dev或handler匹配后都会对应一个handle，所以其实对于input_dev与input_handler是一个多对多的关系，一个dev可以对应多个handler，一个handler也可以对应多个dev。

我们在驱动里上报的接口有如下几种：

static inline void input_report_key(struct input_dev *dev, unsigned int code, int value)
static inline void input_report_rel(struct input_dev *dev, unsigned int code, int value)
static inline void input_report_abs(struct input_dev *dev, unsigned int code, int value)
static inline void input_report_ff_status(struct input_dev *dev, unsigned int code, int value)
static inline void input_report_switch(struct input_dev *dev, unsigned int code, int value)
static inline void input_sync(struct input_dev *dev)

而且他们都是调用共同的接口：
input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)

在 input_event 函数中：

void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
{
        ...............
      input_handle_event(dev, type, code, value);
        ...............
}

static void input_handle_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
{
	...............
	disposition = input_get_disposition(dev, type, code, &value);
	if (disposition & INPUT_PASS_TO_HANDLERS) {
		struct input_value *v;

  		if (disposition & INPUT_SLOT) {         //  如果使用B协议
   			v = &dev->vals[dev->num_vals++];        //  dev->vals地址赋给v，直接把driver上报的数据封装到dev->vals
   			v->type = EV_ABS;
   			v->code = ABS_MT_SLOT;
   			v->value = dev->mt->slot;
  		}

		v = &dev->vals[dev->num_vals++];
  		v->type = type;
  		v->code = code;
  		v->value = value;
 	}
    input_pass_values(dev, dev->vals, dev->num_vals);
    ...............
}

在传给 input_pass_values 之前，我们把驱运输传过来的上报数据封装成 struct input_value 结构体，而且 num_vals 会累加，那么就知道了我们现在总共传了多少数据。

input.h里定义的input_value值如下：

// kernel/include/linux/input.h
struct input_value {
 	__u16 type;
 	__u16 code;
 	__s32 value;
};

static void input_pass_values(struct input_dev *dev, struct input_value *vals, unsigned int count)
{
	...............
 	handle = rcu_dereference(dev->grab);
 	if (handle) {
      	count = input_to_handler(handle, vals, count);
 	} else {
      	list_for_each_entry_rcu(handle, &dev->h_list, d_node)
       	if (handle->open)
        	count = input_to_handler(handle, vals, count);
 	}
    ...............
}

怎么需要进这么多道门，其实已经到了关键地方，
我们通过操作grab获取handle，前面分析了那么多，把input_handle，input_dev和input_handler联系起来，终于用上场了，

我们通过dev找到了对应的handle，也就找到了对应的handler，然后我们把handle传给input_to_handler：

static unsigned int input_to_handler(struct input_handle *handle, struct input_value *vals, unsigned int count)
{
	struct input_handler *handler = handle->handler;
	...............
	if (handler->events)
		handler->events(handle, vals, count);
 	else if (handler->event)
      	for (v = vals; v != end; v++)
			handler->event(handle, v->type, v->code, v->value);
	...............
}

这里的handler就是evdev.c里面的evdev_handler，如果handler->events存在则调用evdev_events，如果不存在但是handler->event存在，则调用evdev_event：

static struct input_handler evdev_handler = {
         .event	= evdev_event,
         .events	= evdev_events,
        ......................
};

// kernel/drivers/input/evdev.c

static void evdev_events(struct input_handle *handle, const struct input_value *vals, unsigned int count)
{
  	struct evdev *evdev = handle->private;
  	struct evdev_client *client;
 	.........................
 	client = rcu_dereference(evdev->grab);
  	if (client)
      	evdev_pass_values(client, vals, count, time_mono, time_real);
  	else
      	list_for_each_entry_rcu(client, &evdev->client_list, node)
   	evdev_pass_values(client, vals, count, time_mono, time_real);
 	.........................
}

static void evdev_pass_values(struct evdev_client *client, const struct input_value *vals, unsigned int count, ktime_t mono, ktime_t real)
{
 	struct evdev *evdev = client->evdev;
 	struct input_event event;
	.......................
 	for (v = vals; v != vals + count; v++) {  
 		// count是从input_handle_event传下来的，目的是为了计算现在是第几次传的数据，
 		// v != vals + count就是针对这次传数据定的条件，避免漏了数据
  		event.type = v->type;
  		event.code = v->code;
  		event.value = v->value;
  		__pass_event(client, &event);
  		if (v->type == EV_SYN && v->code == SYN_REPORT)
       		wakeup = true;
	}
	.......................
}

我们从input_handle_event传下来的的input_value数据赋给event，然后通过__pass_event(client, &event);传给client的buffer。

static void __pass_event(struct evdev_client *client, const struct input_event *event)
{
 	client->buffer[client->head++] = *event;
 	client->head &= client->bufsize - 1;
	.......................
 	if (event->type == && event->code == SYN_REPORT) {
      	client->packet_head = client->head;
      	.......................
      	kill_fasync(&client->fasync, SIGIO, POLL_IN);
 	}	
}

__pass_event 作用是把我们要传的event数据传给client->buffer，而client就是代表这个输入设备，
后面判断传下来的type是EV_SYN 并且code 是SYN_REPORT，也就是调用了input_sync(input_dev)这个接口。

我们可以看看input_sync接口，它是一个内联函数：

static inline void input_sync(struct input_dev *dev)
{
     input_event(dev, EV_SYN, SYN_REPORT, 0);
}

判断到需要sync后会通过异步通知 kill_fasync 的方式通知native层。

evdev_events里 client = rcu_dereference(evdev->grab);，这个是怎么来的，
其实需要追究到我们native层的eventhub.cpp中对我们所有的/dev/input/eventx进行的open操作，当
open的时候，最终通过fops调用到evdev_open：

static int evdev_open(struct inode *inode, struct file *file)
{
 	struct evdev *evdev = container_of(inode->i_cdev, struct evdev, cdev);
 	struct evdev_client *client;
 	............
 	client = kzalloc(size, GFP_KERNEL | __GFP_NOWARN);
 	............
 	client->evdev = evdev;
 	evdev_attach_client(evdev, client);
 	............
 	file->private_data = client;
 	............
}

等等，我只看到创建client，并把client放到file->private_data作为私有数据，但是看不到evdev 究竟是从哪里来的，这个我们要追溯到evdev_connect，看看做了什么事情：

static int evdev_connect(struct input_handler *handler, struct input_dev *dev,  const struct input_device_id *id)
{
	struct evdev *evdev;
	........
	evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
	........
	INIT_LIST_HEAD(&evdev->client_list);
	.........
 	evdev->exist = true;
 	.........
 	evdev->handle.private = evdev;
 	evdev->dev.devt = MKDEV(INPUT_MAJOR, minor);
 	evdev->dev.class = &input_class;
	evdev->dev.parent = &dev->dev;
 	evdev->dev.release = evdev_free;
 	device_initialize(&evdev->dev)
 	cdev_init(&evdev->cdev, &evdev_fops);
 	cdev_add(&evdev->cdev, evdev->dev.devt, 1);
    .........
}

在evdev_connect已经把evdev给创建好，并初始化好evdev->client_list，而且创建好字符设备，
因此open该字符设备的时候通过 container_of(inode->i_cdev, struct evdev, cdev); 可以获取evdev。

在evdev_open创建client后，通过调用 evdev_attach_client(evdev, client);把client插入到client_list链表尾，证明这个设备已经打开了：

static void  evdev_attach_client(struct evdev *evdev,struct evdev_client *client)
{
     .........
     list_add_tail_rcu(&client->node, &evdev->client_list);
     .........
}

eventhub在确定open成功后会进行read操作，而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;
        struct input_event event;
        ........
        for (;;) {
			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();
          	}
            ........
		}
	........
}

client是从 evdev_open后把新建的client赋给 file->private_data作为私有数据，
而evdev则存在client->evdev里，因此所有想要的数据都可以获得，

而且前面有说过，我们上报的数据被封装成input_vals后直接传给client->buffer，因此我们可以从client->buffer里获取数据，获取数据后通过input_event_to_user(buffer + read, &event)往eventhub里传，下面是实现把client里的数据传给event：

static int evdev_fetch_next_event(struct evdev_client *client, struct input_event *event)
{
 	int have_event;
	........
	have_event = client->packet_head != client->tail;
 	if (have_event) {
  		*event = client->buffer[client->tail++];
  		client->tail &= client->bufsize - 1;
		........
 	}
	........
	return have_event;
}

到这里为止，我们上报数据完成，等到我们调用input_sync()接口后，
会调用 __pass_event的kill_fasync(&client->fasync, SIGIO, POLL_IN);，

eventhub收到异步信号后会进行对应的同步，具体过程需要input子系统native层的分析。

————————————————
原文链接：https://blog.csdn.net/gavinlin_dragon/article/details/80603206