------------------------------------------
本文系本站原创,欢迎转载!
------------------------------------------我们先看下input的注册过程：
input_register_device(input_dev)：
int input_register_device(struct input_dev *dev)
{
static atomic_t input_no = ATOMIC_INIT(0);
struct input_handler *handler;
const char *path;
int error;
__set_bit(EV_SYN, dev->evbit);//支持同步事件
/*
* If delay and period are pre-set by the driver, then autorepeating
* is handled by the driver itself and we don't do it in input.c.
*/
init_timer(&dev->timer);//为重复按键做准备
if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
dev->timer.data = (long) dev;
dev->timer.function = input_repeat_key;
dev->rep[REP_DELAY] = 250;
dev->rep[REP_PERIOD] = 33;
}
if (!dev->getkeycode)//如果没设置,则设置成默认的
dev->getkeycode = input_default_getkeycode;
if (!dev->setkeycode)
dev->setkeycode = input_default_setkeycode;
dev_set_name(&dev->dev, "input%ld",
(unsigned long) atomic_inc_return(&input_no) - 1);//按顺序地去定义input序号
error = device_add(&dev->dev);//将input dev添加到sys系统中,包括创建一些input的属性文件
if (error)
return error;
path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);//这里路径是上面device_add产生的
printk(KERN_INFO "input: %s as %s\n",
dev->name ? dev->name : "Unspecified device", path ? path : "N/A");
kfree(path);
error = mutex_lock_interruptible(&input_mutex);
if (error) {
device_del(&dev->dev);
return error;
}
list_add_tail(&dev->node, &input_dev_list);//添加到input设备列表里面
list_for_each_entry(handler, &input_handler_list, node)//对input handler列表中的每个handler都进行匹配,这里input_handler_list怎么来的呢？我们在input_register_handler找到它的形成过程
input_attach_handler(dev, handler);//匹配dev和handler
input_wakeup_procfs_readers();
mutex_unlock(&input_mutex);
return 0;
}
我们看下input_attach_handler(dev, handler)：
static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
{
const struct input_device_id *id;
int error;
if (handler->blacklist && input_match_device(handler->blacklist, dev))//如果在黑名单里面就返回
return -ENODEV;
id = input_match_device(handler->id_table, dev);//匹配handler->id_table和dev
if (!id)
return -ENODEV;
error = handler->connect(handler, dev, id);//调用handler的connect连接handler、 dev,这个函数很重要，起到了承上启下的作用。
if (error && error != -ENODEV)
printk(KERN_ERR
"input: failed to attach handler %s to device %s, "
"error: %d\n",
handler->name, kobject_name(&dev->dev.kobj), error);
return error;
}
input_match_device(handler->id_table, dev)：
static const struct input_device_id *input_match_device(const struct input_device_id *id,
struct input_dev *dev)
{
int i;
for (; id->flags || id->driver_info; id++) {//对handler中的每个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;
MATCH_BIT(evbit, EV_MAX);
MATCH_BIT(keybit, KEY_MAX);
MATCH_BIT(relbit, REL_MAX);
MATCH_BIT(absbit, ABS_MAX);
MATCH_BIT(mscbit, MSC_MAX);
MATCH_BIT(ledbit, LED_MAX);
MATCH_BIT(sndbit, SND_MAX);
MATCH_BIT(ffbit, FF_MAX);
MATCH_BIT(swbit, SW_MAX);
return id;
}
return NULL;
}
该函数会对handler中的每个id都进行查询，先根据id->flags设置去比较，然后比较具体的位，MATCH_BIT定义如下：
#define MATCH_BIT(bit, max) \
for (i = 0; i < BITS_TO_LONGS(max); i++) \
if ((id->bit[i] & dev->bit[i]) != id->bit[i]) \
break; \
if (i != BITS_TO_LONGS(max)) \
continue;
可以看出来是id->bit[i]与dev->bit[i]比较。
从整体上看，匹配的过程还算比较简单。分析中有几个新的地方input_handler_list和handler->connect。
其实这些都是input子系统最顶层做的工作，最顶层可以有evdev，joydev，mousedev等，当然用户完全可以构建一个自己的dev。我们就挑选evdev做分析吧，也是最常用的一种。
static const struct input_device_id evdev_ids[] = {//还记得上面匹配函数里面用到的id吗？就是它哦
{ .driver_info = 1 }, /* Matches all devices */
{ }, /* Terminating zero entry */
};
MODULE_DEVICE_TABLE(input, evdev_ids);
static struct input_handler evdev_handler = {
.event = evdev_event,
.connect = evdev_connect,//看到了吧，匹配函数中的handler->connect
.disconnect = evdev_disconnect,
.fops = &evdev_fops,
.minor = EVDEV_MINOR_BASE,
.name = "evdev",
.id_table = evdev_ids,
};
static int __init evdev_init(void)
{
return input_register_handler(&evdev_handler);
}
evdev初始化是注册了handler：
int input_register_handler(struct input_handler *handler)
{
struct input_dev *dev;
int retval;
retval = mutex_lock_interruptible(&input_mutex);
if (retval)
return retval;
INIT_LIST_HEAD(&handler->h_list);
if (handler->fops != NULL) {
if (input_table[handler->minor >> 5]) {
retval = -EBUSY;
goto out;
}
input_table[handler->minor >> 5] = handler;//放到input_table
}
list_add_tail(&handler->node, &input_handler_list);//添加到handler列表中，这样就形成了input_handler_list
list_for_each_entry(dev, &input_dev_list, node)
input_attach_handler(dev, handler);//这边也进行匹配了，所以无论是handler还是dev注册都会调用匹配函数
input_wakeup_procfs_readers();
out:
mutex_unlock(&input_mutex);
return retval;
}
我们下面分析一下evdev_connect：
static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
const struct input_device_id *id)
{
struct evdev *evdev;
int minor;
int error;
for (minor = 0; minor < EVDEV_MINORS; minor++)//找到一个空的minor
if (!evdev_table[minor])
break;
if (minor == EVDEV_MINORS) {
printk(KERN_ERR "evdev: no more free evdev devices\n");
return -ENFILE;
}
evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
if (!evdev)
return -ENOMEM;
INIT_LIST_HEAD(&evdev->client_list);
spin_lock_init(&evdev->client_lock);
mutex_init(&evdev->mutex);
init_waitqueue_head(&evdev->wait);
dev_set_name(&evdev->dev, "event%d", minor);//evdev的名字，即event*
evdev->exist = 1;
evdev->minor = minor;
evdev->handle.dev = input_get_device(dev);//将dev赋值给handle
evdev->handle.name = dev_name(&evdev->dev);
evdev->handle.handler = handler;//将handler赋值给handle
evdev->handle.private = evdev;
//可以看出handle将dev和handler联系到一块了
evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);
evdev->dev.class = &input_class;
evdev->dev.parent = &dev->dev;
evdev->dev.release = evdev_free;
device_initialize(&evdev->dev);
error = input_register_handle(&evdev->handle);//注册handle,其实就是将handle再跟dev和handler分别联系起来,这样三者就真正地互相联系到一块了
if (error)
goto err_free_evdev;
error = evdev_install_chrdev(evdev);//把evdev添加到evdev_table中
if (error)
goto err_unregister_handle;
error = device_add(&evdev->dev);//将evdev添加到/sys/中
if (error)
goto err_cleanup_evdev;
return 0;
err_cleanup_evdev:
evdev_cleanup(evdev);
err_unregister_handle:
input_unregister_handle(&evdev->handle);
err_free_evdev:
put_device(&evdev->dev);
return error;
}
我们先解释input_register_handle(&evdev->handle)：
int input_register_handle(struct input_handle *handle)
{
struct input_handler *handler = handle->handler;
struct input_dev *dev = handle->dev;
int error;
/*
* We take dev->mutex here to prevent race with
* input_release_device().
*/
error = mutex_lock_interruptible(&dev->mutex);
if (error)
return error;
list_add_tail_rcu(&handle->d_node, &dev->h_list);//将handle添加到dev的h_list
mutex_unlock(&dev->mutex);
/*
* Since we are supposed to be called from ->connect()
* which is mutually exclusive with ->disconnect()
* we can't be racing with input_unregister_handle()
* and so separate lock is not needed here.
*/
list_add_tail(&handle->h_node, &handler->h_list);//将handle添加到handler的h_list
if (handler->start)
handler->start(handle);
return 0;
}
将handle分别添加到dev和handler的h_list中，这样三者真正地联系起来了，可以互相访问。
我们可以看到evdev才是真正用户可以操作的设备，evdev中的handle把handler和dev联系到了一块，同时将evdev添加到了sys中。
