Linux驱动修炼之道-INPUT子系统(下)

努力成为linux kernel hacker的人李万鹏原创作品，为梦而战。转载请标明出处

http://blog.csdn.net/woshixingaaa/archive/2011/05/19/6433337.aspx

input子系统最重要的部分就是向上层report了。这里还是先介绍几个数据结构：

struct input_event {
	struct timeval time;  //事件发生的时间
	__u16 type;           //事件类型
	__u16 code;           //子事件
	__s32 value;          //事件的value
};

struct evdev_client {
	struct input_event buffer[EVDEV_BUFFER_SIZE];        //可以同时管理EVDEV_BUFFER_SIZE(64)个事件
	int head;                                            //存储事件从head开始
	int tail;                                            //取出事件从tail开始
	spinlock_t buffer_lock; /* protects access to buffer, head and tail */   
	struct fasync_struct *fasync;                        //异步通知事件发生
	struct evdev *evdev;                                 //指向本evdev_client归属的evdev
	struct list_head node;                               //用于挂载到evdev的链表头client_list上
};

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,
};

这里的次设备号是EVDEV_MINOR_BASE(64)，也就是说evdev_handler所表示的设备文件范围(13,64)~(13,64+32)。
如下一个结构体:evdev_handler匹配所有设备。

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

这个是evdev_handler是fops，下面的讲解中会用到其中的open,read函数。

static const struct file_operations evdev_fops = {
	.owner		= THIS_MODULE,
	.read		= evdev_read,
	.write		= evdev_write,
	.poll		= evdev_poll,
	.open		= evdev_open,
	.release	= evdev_release,
	.unlocked_ioctl	= evdev_ioctl,
#ifdef CONFIG_COMPAT
	.compat_ioctl	= evdev_ioctl_compat,
#endif
	.fasync		= evdev_fasync,
	.flush		= evdev_flush
};

在驱动程序中我们会调用input_report_abs等函数：

static inline void input_report_abs(struct input_dev *dev, unsigned int code, int value)
{
	input_event(dev, EV_ABS, code, value);
}

跟踪input_event如下：

void input_event(struct input_dev *dev,
		 unsigned int type, unsigned int code, int value)
{
	unsigned long flags;

	if (is_event_supported(type, dev->evbit, EV_MAX)) {

		spin_lock_irqsave(&dev->event_lock, flags);
		/*利用输入值调正随机数产生器*/
		add_input_randomness(type, code, value);
		input_handle_event(dev, type, code, value);
		spin_unlock_irqrestore(&dev->event_lock, flags);
	}
}

跟踪input_handle_event如下：

static void input_handle_event(struct input_dev *dev,
			       unsigned int type, unsigned int code, int value)
{
	int disposition = INPUT_IGNORE_EVENT;

	switch (type) {
	。。。。。。。。。。。。。。。。
	if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)
		dev->sync = 0;

	if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
		dev->event(dev, type, code, value);

	if (disposition & INPUT_PASS_TO_HANDLERS)
		input_pass_event(dev, type, code, value);
}

如果该事件需要input device来完成，就会将disposition设置成INPUT_PASS_TO_DEVICE，如果需要input handler来完成，就会将disposition设置成INPUT_PASS_TO_DEVICE，如果需要两者都参与，则将disposition设置成INPUT_PASS_TO_ALL。
跟踪input_pass_event如下：

static void input_pass_event(struct input_dev *dev,
			     unsigned int type, unsigned int code, int value)
{
	struct input_handle *handle;

	rcu_read_lock();
	/**/
	handle = rcu_dereference(dev->grab);
	if (handle)
		/*如果input_dev的grab指向了一个handle，就用这个handle关联的handler的event，否则遍历整个挂在input_dev的h_list上的handle关联的handler*/
		handle->handler->event(handle, type, code, value);
	else
		list_for_each_entry_rcu(handle, &dev->h_list, d_node)
			if (handle->open)
				handle->handler->event(handle,
							type, code, value);
	rcu_read_unlock();
}

比如下边的evdev_handler的evdev_event：

static void evdev_event(struct input_handle *handle,
			unsigned int type, unsigned int code, int value)
{
	struct evdev *evdev = handle->private;
	struct evdev_client *client;
	struct input_event event;

	do_gettimeofday(&event.time);
	event.type = type;
	event.code = code;
	event.value = value;

	rcu_read_lock();
	client = rcu_dereference(evdev->grab);
	if (client)
	/*如果evdev->grab指向一个当前使用的client就将event放到这个client的buffer中，否则放到整个client_list上的client的链表中*/
		evdev_pass_event(client, &event);
	else
		list_for_each_entry_rcu(client, &evdev->client_list, node)
			evdev_pass_event(client, &event);

	rcu_read_unlock();

	wake_up_interruptible(&evdev->wait);
}

static void evdev_pass_event(struct evdev_client *client,
			     struct input_event *event)
{
	/*
	 * Interrupts are disabled, just acquire the lock
	 */
	spin_lock(&client->buffer_lock);
	/*将event装入client的buffer中，buffer是一个环形缓存区*/
	client->buffer[client->head++] = *event;
	client->head &= EVDEV_BUFFER_SIZE - 1;
	spin_unlock(&client->buffer_lock);

	kill_fasync(&client->fasync, SIGIO, POLL_IN);
}

这里总结一下事件的传递过程：首先在驱动层中，调用inport_report_abs，然后他调用了input core层的input_event，input_event调用了input_handle_event对事件进行分派，调用input_pass_event，在这里他会把事件传递给具体的handler层，然后在相应handler的event处理函数中，封装一个event，然后把它投入evdev的那个client_list上的client的事件buffer中，等待用户空间来读取。

下边看一下用户程序打开文件时的过程，首先调用了input_open_file:

static int input_open_file(struct inode *inode, struct file *file)
{
	struct input_handler *handler;
	const struct file_operations *old_fops, *new_fops = NULL;
	int err;

	lock_kernel();
	/* No load-on-demand here? */
	/*因为32个input_dev公共一个handler所以低5位应该是相同的*/
	handler = input_table[iminor(inode) >> 5];
	if (!handler || !(new_fops = fops_get(handler->fops))) {
		err = -ENODEV;
		goto out;
	}

	/*
	 * That's _really_ odd. Usually NULL ->open means "nothing special",
	 * not "no device". Oh, well...
	 */
	if (!new_fops->open) {
		fops_put(new_fops);
		err = -ENODEV;
		goto out;
	}
	/*保存以前的fops，使用相应的handler的fops*/
	old_fops = file->f_op;
	file->f_op = new_fops;

	err = new_fops->open(inode, file);

	if (err) {
		fops_put(file->f_op);
		file->f_op = fops_get(old_fops);
	}
	fops_put(old_fops);
out:
	unlock_kernel();
	return err;
}

这里还是假设handler是evdev_handler。

static int evdev_open(struct inode *inode, struct file *file)
{
	struct evdev *evdev;
	struct evdev_client *client;
	/*因为次设备号是从EVDEV_MINOR_BASE开始的*/
	int i = iminor(inode) - EVDEV_MINOR_BASE;
	int error;
	
	if (i >= EVDEV_MINORS)
		return -ENODEV;

	error = mutex_lock_interruptible(&evdev_table_mutex);
	if (error)
		return error;
	/*evdev_table一共可容纳32个成员，找到次设备号对应的那个*/
	evdev = evdev_table[i];
	if (evdev)
		get_device(&evdev->dev);
	mutex_unlock(&evdev_table_mutex);

	if (!evdev)
		return -ENODEV;
	/*打开的时候创建一个client*/
	client = kzalloc(sizeof(struct evdev_client), GFP_KERNEL);
	if (!client) {
		error = -ENOMEM;
		goto err_put_evdev;
	}

	spin_lock_init(&client->buffer_lock);
	/*下边两句的作用就是将evdev和client绑定到一起*/
	client->evdev = evdev;
	evdev_attach_client(evdev, client);

	error = evdev_open_device(evdev);
	if (error)
		goto err_free_client;
	/*将file->private_data指向刚刚建的client，后边会用到的*/
	file->private_data = client;
	return 0;

 err_free_client:
	evdev_detach_client(evdev, client);
	kfree(client);
 err_put_evdev:
	put_device(&evdev->dev);
	return error;
}

static int evdev_open_device(struct evdev *evdev)
{
	int retval;

	retval = mutex_lock_interruptible(&evdev->mutex);
	if (retval)
		return retval;
	/*如果设备不存在，返回错误*/
	if (!evdev->exist)
		retval = -ENODEV;
	/*如果是被第一次打开，则调用input_open_device*/
	else if (!evdev->open++) {
		retval = input_open_device(&evdev->handle);
		if (retval)
			evdev->open--;
	}

	mutex_unlock(&evdev->mutex);
	return retval;
}

int input_open_device(struct input_handle *handle)
{
	struct input_dev *dev = handle->dev;
	int retval;

	retval = mutex_lock_interruptible(&dev->mutex);
	if (retval)
		return retval;

	if (dev->going_away) {
		retval = -ENODEV;
		goto out;
	}

	handle->open++;

	if (!dev->users++ && dev->open)
		retval = dev->open(dev);

	if (retval) {
		dev->users--;
		if (!--handle->open) {
			/*
			 * Make sure we are not delivering any more events
			 * through this handle
			 */
			synchronize_rcu();
		}
	}

 out:
	mutex_unlock(&dev->mutex);
	return retval;
}

下面是用户进程读取event的底层实现：

static ssize_t evdev_read(struct file *file, char __user *buffer,
			  size_t count, loff_t *ppos)
{
	/*这个就是刚才在open函数中*/
	struct evdev_client *client = file->private_data;
	struct evdev *evdev = client->evdev;
	struct input_event event;
	int retval;

	if (count < input_event_size())
		return -EINVAL;
	/*如果client的环形缓冲区中没有数据并且是非阻塞的，那么返回-EAGAIN，也就是try again*/
	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);
	if (retval)
		return retval;

	if (!evdev->exist)
		return -ENODEV;
	/*如果获得了数据则取出来，调用evdev_fetch_next_event*/
	while (retval + input_event_size() <= count &&
	       evdev_fetch_next_event(client, &event)) {
		/*input_event_to_user调用copy_to_user传入用户程序中，这样读取完成*/
		if (input_event_to_user(buffer + retval, &event))
			return -EFAULT;

		retval += input_event_size();
	}

	return retval;
}

static int evdev_fetch_next_event(struct evdev_client *client,
				  struct input_event *event)
{
	int have_event;

	spin_lock_irq(&client->buffer_lock);
	/*先判断一下是否有数据*/
	have_event = client->head != client->tail;
	/*如果有就从环形缓冲区的取出来，记得是从head存储，tail取出*/
	if (have_event) {
		*event = client->buffer[client->tail++];
		client->tail &= EVDEV_BUFFER_SIZE - 1;
	}

	spin_unlock_irq(&client->buffer_lock);

	return have_event;
}

int input_event_to_user(char __user *buffer,
			const struct input_event *event)
{
	/*如果设置了标志INPUT_COMPAT_TEST就将事件event包装成结构体compat_event*/
	if (INPUT_COMPAT_TEST) {
		struct input_event_compat compat_event;

		compat_event.time.tv_sec = event->time.tv_sec;
		compat_event.time.tv_usec = event->time.tv_usec;
		compat_event.type = event->type;
		compat_event.code = event->code;
		compat_event.value = event->value;
		/*将包装成的compat_event拷贝到用户空间*/
		if (copy_to_user(buffer, &compat_event,
				 sizeof(struct input_event_compat)))
			return -EFAULT;

	} else {
		/*否则，将event拷贝到用户空间*/
		if (copy_to_user(buffer, event, sizeof(struct input_event)))
			return -EFAULT;
	}

	return 0;
}

这里总结一下：如果两个进程打开同一个文件，每个进程在打开时都会生成一个evdev_client，evdev_client被挂在evdev的client_list，在handle收到一个事件的时候，会把事件copy到挂在client_list上的所有evdev_client的buffer中。这样所有打开同一个设备的进程都会收到这个消息而唤醒。