我对linux理解之input一

我们先看下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中。