在input子系统中事件处理层有很多evdev，joydev，evbug，mousedev。但是他们的实现基本上是一样的，对于触摸屏来说，事件处理器是evdev，现在就来分析一下evdev的代码。
首先还是evdev的入口和出口
static int __init evdev_init(void)
{
/*将evdev_handler注册到系统中*/
return input_register_handler(&evdev_handler);
}
static void __exit evdev_exit(void)
{
input_unregister_handler(&evdev_handler);
}
module_init(evdev_init);
module_exit(evdev_exit);
由于evdev是事件处理器，给用户空间提供接口，所以必须对它进行注册。
static struct input_handler evdev_handler = {
.event = evdev_event,//当有事件来的时候调用,把事件放入input_event数组，为用户空间读写事件做准备
.connect = evdev_connect,//在input_dev和input_handler注册过程最终都会调用这个函数，完成handle的注册
.disconnect = evdev_disconnect,//在input_dev和input_handler注销过程最终会调用这个函数，完成handle的注销
.fops = &evdev_fops,//对事件的操作函数集
.minor = EVDEV_MINOR_BASE,//次设备号基数
.name = "evdev",
.id_table = evdev_ids,
};
这里有一个id_table成员，这个成员在注册input_dev和input_handler的里面，都需要通过 evdev_ids来筛选出同种类型的ID和比较支持的事件，然后建立device和handler关联。
static const struct input_device_id evdev_ids[] = {
{ .driver_info = 1 }, /* Matches all devices *///适合所有的类型的设备
{ }, /* Terminating zero entry */
};
对于event和connect函数在我的事件上报过程和input重要结构体分析的日志中有讲，这里不再分析。
现在主要来看提供给用户空间的操作函数集，这有点像标准的字符设备驱动
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,
.llseek = no_llseek,
};
先来看两个结构体
/*在进程打开event0设备的时候调用evdev的open方法，在open中创建和初始化*/
struct evdev_client {
unsigned int head;//针对buffer数组的索引
unsigned int tail;//针对buffer数组的索引，当head和tail相等的时候，说明没有事件
unsigned int packet_head; /* [future] position of the first element of next packet */
spinlock_t buffer_lock; /* protects access to buffer, head and tail */
struct fasync_struct *fasync;//异步通知函数
struct evdev *evdev;//evdev设备
struct list_head node;//evdev_client链表项
unsigned int bufsize;
struct input_event buffer[];//一个input_event数据结构的数组，input_event代表一个事件，基本成员：类型（type）编码（code）值（value）
};
/*evdev结构体再配对成功的时候生成，由handler->connect生成*/
struct evdev {
int open;//打开引用计数
int minor;//次设备号
struct input_handle handle;//关联的input_handle
wait_queue_head_t wait;//等待队列
struct evdev_client __rcu *grab;
struct list_head client_list;//evdev_client链表，说明一个evdev设备可以处理多个evdev_client，可以有多个进程访问
spinlock_t client_lock; /* protects client_list */
struct mutex mutex;
struct device dev;
bool exist;
};
同字符设备一样先来看open函数
static int evdev_open(struct inode *inode, struct file *file)
{
struct evdev *evdev;
struct evdev_client *client;
int i = iminor(inode) - EVDEV_MINOR_BASE;
unsigned int bufsize;
int error;
if (i >= EVDEV_MINORS)//判断是否超出了能处理的最大设备数
return -ENODEV;
error = mutex_lock_interruptible(&evdev_table_mutex);
if (error)
return error;
evdev = evdev_table[i];//得到evdev设备结构，每次调用evdev_connect配对成功后都会把分配的evdev结构以minor为索引保存在evdev_table中
if (evdev)
get_device(&evdev->dev);//增加device引用计数
mutex_unlock(&evdev_table_mutex);
if (!evdev)
return -ENODEV;
bufsize = evdev_compute_buffer_size(evdev->handle.dev);
client = kzalloc(sizeof(struct evdev_client) +
bufsize * sizeof(struct input_event),
GFP_KERNEL);//分配用户端结构
if (!client) {
error = -ENOMEM;
goto err_put_evdev;
}
client->bufsize = bufsize;
spin_lock_init(&client->buffer_lock);
client->evdev = evdev;//使用户端与evdev设备结构关联起来
evdev_attach_client(evdev, client);//把client链接到evdev的client链表上
error = evdev_open_device(evdev);//打开设备
if (error)
goto err_free_client;
file->private_data = client;
nonseekable_open(inode, file);
return 0;
err_free_client:
evdev_detach_client(evdev, client);
kfree(client);
err_put_evdev:
put_device(&evdev->dev);
return error;
}
evdev_attach_client就是把client关联到evdev->client_list的链表上
static void evdev_attach_client(struct evdev *evdev,
struct evdev_client *client)
{
spin_lock(&evdev->client_lock);
list_add_tail_rcu(&client->node, &evdev->client_list);
spin_unlock(&evdev->client_lock);
}
evdev_open_device主要通过evdev的exist标志判断是否已经获得了evdev结构体
static int evdev_open_device(struct evdev *evdev)
{
int retval;
retval = mutex_lock_interruptible(&evdev->mutex);
if (retval)
return retval;
if (!evdev->exist)//判断evdev结构体是否存在，在evdev_connect中初始化成员为1
retval = -ENODEV;
else if (!evdev->open++) {
retval = input_open_device(&evdev->handle);
if (retval)
evdev->open--;
}
mutex_unlock(&evdev->mutex);
return retval;
}
真正的打开是在input.c中 input_open_device这个函数完成的。
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) {//判断设备是否在open期间被注销
retval = -ENODEV;
goto out;
}
handle->open++;//handle的打开计数加一
if (!dev->users++ && dev->open)//如果输入设备没有进程引用，并定义了open方法，就调用open方法
retval = dev->open(dev);
if (retval) {//retval=1，说明没有打开成功
dev->users--;
if (!--handle->open) {//说明有其它进程打开了这个handle
/*
* Make sure we are not delivering any more events
* through this handle
*/
synchronize_rcu();
}
}
out:
mutex_unlock(&dev->mutex);
return retval;
}
到这里，如果input_dev有定义open方法，打开函数最终会调用到input_dev下面的open函数，否者只是简单的增加打开引用计数。
这里read函数也在事件上报过程的那片日志有分析到，我们来看write函数。
static ssize_t evdev_write(struct file *file, const 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;
int retval = 0;
if (count < input_event_size())//write操作的数据大小至少要大于一个事件的大小
return -EINVAL;
retval = mutex_lock_interruptible(&evdev->mutex);//上锁
if (retval)
return retval;
if (!evdev->exist) {
retval = -ENODEV;
goto out;
}
do {
if (input_event_from_user(buffer + retval, &event)) {//得到用户空间的数据
retval = -EFAULT;
goto out;
}
retval += input_event_size();//累加事件长度，计算得到用户空间的数据长度
input_inject_event(&evdev->handle,
event.type, event.code, event.value);//从input handler发送一个input事件
} while (retval + input_event_size() <= count);
out:
mutex_unlock(&evdev->mutex);
return retval;
}
看看发送事件的实现
void input_inject_event(struct input_handle *handle,
unsigned int type, unsigned int code, int value)
{
struct input_dev *dev = handle->dev;
struct input_handle *grab;
unsigned long flags;
if (is_event_supported(type, dev->evbit, EV_MAX)) {
spin_lock_irqsave(&dev->event_lock, flags);
rcu_read_lock();
grab = rcu_dereference(dev->grab);
if (!grab || grab == handle)
input_handle_event(dev, type, code, value);
rcu_read_unlock();
spin_unlock_irqrestore(&dev->event_lock, flags);
}
}
EXPORT_SYMBOL(input_inject_event);
input_inject_event->input_handle_event->input_pass_event->handler下的event
最终还是由evdev中的event完成的发送.所以这个事件就不是有具体设备驱动发出的，而是我们从用户空间直接写一个事件到evdev中，然后通过input core最终调用event发送，一般提供给测试用的接口。
接下来看poll的实现，允许进程决定是否可以完成非阻塞的操作
static unsigned int evdev_poll(struct file *file, poll_table *wait)
{
struct evdev_client *client = file->private_data;
struct evdev *evdev = client->evdev;
unsigned int mask;
poll_wait(file, &evdev->wait, wait);//添加等待队列到evdev->wait
mask = evdev->exist ? POLLOUT | POLLWRNORM : POLLHUP | POLLERR;//设置位掩码
if (client->packet_head != client->tail)
mask |= POLLIN | POLLRDNORM;
return mask;
}
ioctl的实现
static long evdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
return evdev_ioctl_handler(file, cmd, (void __user *)arg, 0);
}
static long evdev_ioctl_handler(struct file *file, unsigned int cmd,
void __user *p, int compat_mode)
{
struct evdev_client *client = file->private_data;
struct evdev *evdev = client->evdev;
int retval;
retval = mutex_lock_interruptible(&evdev->mutex);
if (retval)
return retval;
if (!evdev->exist) {
retval = -ENODEV;
goto out;
}
retval = evdev_do_ioctl(file, cmd, p, compat_mode);
out:
mutex_unlock(&evdev->mutex);
return retval;
}
static long evdev_do_ioctl(struct file *file, unsigned int cmd,
void __user *p, int compat_mode)
{
struct evdev_client *client = file->private_data;
struct evdev *evdev = client->evdev;
struct input_dev *dev = evdev->handle.dev;
struct input_absinfo abs;
struct ff_effect effect;
int __user *ip = (int __user *)p;
unsigned int i, t, u, v;
unsigned int size;
int error;
/* First we check for fixed-length commands */
switch (cmd) {
case EVIOCGVERSION:
return put_user(EV_VERSION, ip);
case EVIOCGID:
if (copy_to_user(p, &dev->id, sizeof(struct input_id)))
return -EFAULT;
return 0;
case EVIOCGREP:
if (!test_bit(EV_REP, dev->evbit))
return -ENOSYS;
if (put_user(dev->rep[REP_DELAY], ip))
return -EFAULT;
if (put_user(dev->rep[REP_PERIOD], ip + 1))
return -EFAULT;
return 0;
case EVIOCSREP:
if (!test_bit(EV_REP, dev->evbit))
return -ENOSYS;
if (get_user(u, ip))
return -EFAULT;
if (get_user(v, ip + 1))
return -EFAULT;
input_inject_event(&evdev->handle, EV_REP, REP_DELAY, u);
input_inject_event(&evdev->handle, EV_REP, REP_PERIOD, v);
return 0;
case EVIOCRMFF:
return input_ff_erase(dev, (int)(unsigned long) p, file);
case EVIOCGEFFECTS:
i = test_bit(EV_FF, dev->evbit) ?
dev->ff->max_effects : 0;
if (put_user(i, ip))
return -EFAULT;
return 0;
case EVIOCGRAB:
if (p)
return evdev_grab(evdev, client);
else
return evdev_ungrab(evdev, client);
case EVIOCGKEYCODE:
return evdev_handle_get_keycode(dev, p);
case EVIOCSKEYCODE:
return evdev_handle_set_keycode(dev, p);
case EVIOCGKEYCODE_V2:
return evdev_handle_get_keycode_v2(dev, p);
case EVIOCSKEYCODE_V2:
return evdev_handle_set_keycode_v2(dev, p);
}
size = _IOC_SIZE(cmd);
/* Now check variable-length commands */
#define EVIOC_MASK_SIZE(nr) ((nr) & ~(_IOC_SIZEMASK << _IOC_SIZESHIFT))
switch (EVIOC_MASK_SIZE(cmd)) {
case EVIOCGPROP(0):
return bits_to_user(dev->propbit, INPUT_PROP_MAX,
size, p, compat_mode);
case EVIOCGKEY(0):
return bits_to_user(dev->key, KEY_MAX, size, p, compat_mode);
case EVIOCGLED(0):
return bits_to_user(dev->led, LED_MAX, size, p, compat_mode);
case EVIOCGSND(0):
return bits_to_user(dev->snd, SND_MAX, size, p, compat_mode);
case EVIOCGSW(0):
return bits_to_user(dev->sw, SW_MAX, size, p, compat_mode);
case EVIOCGNAME(0):
return str_to_user(dev->name, size, p);
case EVIOCGPHYS(0):
return str_to_user(dev->phys, size, p);
case EVIOCGUNIQ(0):
return str_to_user(dev->uniq, size, p);
case EVIOC_MASK_SIZE(EVIOCSFF):
if (input_ff_effect_from_user(p, size, &effect))
return -EFAULT;
error = input_ff_upload(dev, &effect, file);
if (put_user(effect.id, &(((struct ff_effect __user *)p)->id)))
return -EFAULT;
return error;
}
/* Multi-number variable-length handlers */
if (_IOC_TYPE(cmd) != 'E')
return -EINVAL;
if (_IOC_DIR(cmd) == _IOC_READ) {
if ((_IOC_NR(cmd) & ~EV_MAX) == _IOC_NR(EVIOCGBIT(0, 0)))
return handle_eviocgbit(dev,
_IOC_NR(cmd) & EV_MAX, size,
p, compat_mode);
if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0))) {
if (!dev->absinfo)
return -EINVAL;
t = _IOC_NR(cmd) & ABS_MAX;
abs = dev->absinfo[t];
if (copy_to_user(p, &abs, min_t(size_t,
size, sizeof(struct input_absinfo))))
return -EFAULT;
return 0;
}
}
if (_IOC_DIR(cmd) == _IOC_WRITE) {
if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCSABS(0))) {
if (!dev->absinfo)
return -EINVAL;
t = _IOC_NR(cmd) & ABS_MAX;
if (copy_from_user(&abs, p, min_t(size_t,
size, sizeof(struct input_absinfo))))
return -EFAULT;
if (size < sizeof(struct input_absinfo))
abs.resolution = 0;
/* We can't change number of reserved MT slots */
if (t == ABS_MT_SLOT)
return -EINVAL;
/*
* Take event lock to ensure that we are not
* changing device parameters in the middle
* of event.
*/
spin_lock_irq(&dev->event_lock);
dev->absinfo[t] = abs;
spin_unlock_irq(&dev->event_lock);
return 0;
}
}
return -EINVAL;
}
ioctl主要通过cmd的不同来完成不同的操作，这里不再详细分析.
