input子系统二 驱动层input设备注册

以i2c总线接口的edt-ft5x06.c触摸屏驱动为例

一 input设备注册

1 主要数据结构

[cpp]
view plain
copy

static struct i2c_driver edt_ft5x06_ts_driver = {  
    .driver = {  
        .owner = THIS_MODULE,  
        .name = "edt_ft5x06",  
        .pm = &edt_ft5x06_ts_pm_ops,  
    },  
    .id_table = edt_ft5x06_ts_id,  
    .probe    = edt_ft5x06_ts_probe,  
    .remove   = edt_ft5x06_ts_remove,  
};  

标准的驱动框架，主要字段的意义：

owner：模块的所有者，THIS_MODULE宏类似于进程的CURRENT，指向当前的模块；

name：driver的name，register的过程中，会根据driver->name和driver->bus判断该driver是否已经注册过，出现在/sys/bus/i2c/drivers/；
pm：电源管理睡眠唤醒时调用；

[cpp]
view plain
copy

static SIMPLE_DEV_PM_OPS(edt_ft5x06_ts_pm_ops,  
             edt_ft5x06_ts_suspend, edt_ft5x06_ts_resume);  

include/Linux/pm.h

[cpp]
view plain
copy

#define SIMPLE_DEV_PM_OPS(name, suspend_fn, resume_fn) \  
const struct dev_pm_ops name = { \  
    SET_SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn) \  
}  

const struct dev_pm_ops edt_ft5x06_ts_pm_ops= { 
SET_SYSTEM_SLEEP_PM_OPS(edt_ft5x06_ts_suspend, edt_ft5x06_ts_resum) 

[cpp]
view plain
copy

#define SET_SYSTEM_SLEEP_PM_OPS(suspend_fn, resume_fn) \  
    .suspend = suspend_fn, \  
    .resume = resume_fn, \  
    .freeze = suspend_fn, \  
    .thaw = resume_fn, \  
    .poweroff = suspend_fn, \  
    .restore = resume_fn,  

相当于定义了const struct dev_pm_ops edt_ft5x06_ts_pm_ops= {

.resume = edt_ft5x06_ts_resum,

.suspend = edt_ft5x06_ts_suspend,

}

这样一个结构。

id_table：用于device和driver的匹配；

[cpp]
view plain
copy

static const struct i2c_device_id edt_ft5x06_ts_id[] = {  
    { "edt-ft5x06", 0 },  
    { }  
};  

[cpp]
view plain
copy

MODULE_DEVICE_TABLE(i2c, edt_ft5x06_ts_id);  

include/linux/module.h

[cpp]
view plain
copy

#define MODULE_DEVICE_TABLE(type,name)<span style="white-space:pre">        </span>\  
  MODULE_GENERIC_TABLE(type##_device,name)  

上述宏展开为 MODULE_GENERIC_TABLE(i2c_device,edt_ft5x06_ts_id)；

[cpp]
view plain
copy

#define MODULE_GENERIC_TABLE(gtype,name)            \  
extern const struct gtype##_id __mod_##gtype##_table        \  
  __attribute__ ((unused, alias(__stringify(name))))  

再展开为

extern const struct i2c_device_id __mod_i2c_device_table

  __attribute__ ((unused, alias("edt_ft5x06_ts_id")))

最终生成一个i2c_device_id类型的外部变量__mod_i2c_device_table；被alias到了本驱动专用的由用户自定义的变量。之后的内核构建中，depmod程序会在所以的模块中搜索符号__mod_i2c_device_table，找到后把数据重模块中抽出，利用这些数据在/lib/modules/‘uname -r’/下生成modules.i2cmap文件，该文件包含了各核心模块和它所支持硬件设备的对应关系。depmod程序结束后，内核模块支持的所以i2c设备连同他们的模块名都在该文件中列出。当内核告知热插拔系统一个新的i2c设备被发现时，热插拔系统会使用modules.i2cmap文件来寻找要加载的驱动程序。

一般i2c_device_id需要导出到用户空间时，才使用MODULE_DEVICE_TABLE宏，使模块加载系统在加载模块时
4000
知道模块和硬件的对应关系。

probe：device和driver匹配成功会执行的探测函数；
remove：驱动卸载时执行。

2  i2c驱动加载卸载

2.1 驱动加载

[cpp]
view plain
copy

module_i2c_driver(edt_ft5x06_ts_driver);  

include/linux/i2c.h

[cpp]
view plain
copy

#define module_i2c_driver(__i2c_driver) \  
    module_driver(__i2c_driver, i2c_add_driver, \  
            i2c_del_driver)  

展开为module_driver(edt_ft5x06_ts_driver, i2c_add_driver, i2c_del_driver)
include/linux/device.h

[cpp]
view plain
copy

#define module_driver(__driver, __register, __unregister, ...) \  
static int __init __driver##_init(void) \  
{ \  
    return __register(&(__driver) , ##__VA_ARGS__); \  
} \  
module_init(__driver##_init); \  
static void __exit __driver##_exit(void) \  
{ \  
    __unregister(&(__driver) , ##__VA_ARGS__); \  
} \  
module_exit(__driver##_exit);  

module_i2c_driver(edt_ft5x06_ts_driver);做了很多事情：

static int __init edt_ft5x06_ts_driver_init(void)

{

return i2c_add_driver(&edt_ft5x06_ts_driver);

}

module_init(edt_ft5x06_ts_driver_init);

static void __exit edt_ft5x06_ts_driver_exit(void)

{

return i2c_del_driver(&edt_ft5x06_ts_driver);

}
module_exit(edt_ft5x06_ts_driver_exit);

[cpp]
view plain
copy

#define i2c_add_driver(driver) \  
    i2c_register_driver(THIS_MODULE, driver)  

[cpp]
view plain
copy

int i2c_register_driver(struct module *owner, struct i2c_driver *driver)  
{  
    int res;  
  
    /* Can't register until after driver model init */  
    if (unlikely(WARN_ON(!i2c_bus_type.p)))  
        return -EAGAIN;  
  
    /* add the driver to the list of i2c drivers in the driver core */  
    driver->driver.owner = owner;  
    driver->driver.bus = &i2c_bus_type;  
  
    /* When registration returns, the driver core 
     * will have called probe() for all matching-but-unbound devices. 
     */  
    res = driver_register(&driver->driver);  
    if (res)  
        return res;  
  
    /* Drivers should switch to dev_pm_ops instead. */  
    if (driver->suspend)  
        pr_warn("i2c-core: driver [%s] using legacy suspend method\n",  
            driver->driver.name);  
    if (driver->resume)  
        pr_warn("i2c-core: driver [%s] using legacy resume method\n",  
            driver->driver.name);  
  
    pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);  
  
    INIT_LIST_HEAD(&driver->clients);  
    /* Walk the adapters that are already present */  
    i2c_for_each_dev(driver, __process_new_driver);  
  
    return 0;  
}  

设置driver->driver.bus = &i2c_bus_type;

[cpp]
view plain
copy

struct bus_type i2c_bus_type = {  
    .name       = "i2c",  
    .match      = i2c_device_match,  
    .probe      = i2c_device_probe,  
    .remove     = i2c_device_remove,  
    .shutdown   = i2c_device_shutdown,  
    .pm     = &i2c_device_pm_ops,  
};  

关键函数res = driver_register(&driver->driver);(在这个函数中会执行探测函数driver->probe)，接着初始化driver->clients list，i2c_for_each_dev(driver, __process_new_driver);会遍历每个adapter执行i2c_detect、driver->attach_adapter(adap);将adapter和i2c_device的信息相关联，这个过程是双向的register adapter时也会走一遍；现在的driver一般不需要实现attach_adapter，基本被probe取代了。

[cpp]
view plain
copy

int driver_register(struct device_driver *drv)  
{  
    int ret;  
    struct device_driver *other;  
  
    BUG_ON(!drv->bus->p);  
  
    if ((drv->bus->probe && drv->probe) ||  
        (drv->bus->remove && drv->remove) ||  
        (drv->bus->shutdown && drv->shutdown))  
        printk(KERN_WARNING "Driver '%s' needs updating - please use "  
            "bus_type methods\n", drv->name);  
  
    other = driver_find(drv->name, drv->bus);  
    if (other) {  
        printk(KERN_ERR "Error: Driver '%s' is already registered, "  
            "aborting...\n", drv->name);  
        return -EBUSY;  
    }  
  
    ret = bus_add_driver(drv);  
    if (ret)  
        return ret;  
    ret = driver_add_groups(drv, drv->groups);  
    if (ret) {  
        bus_remove_driver(drv);  
        return ret;  
    }  
    kobject_uevent(&drv->p->kobj, KOBJ_ADD);  
  
    return ret;  
}  

这是所有driver的注册都要走的流程。先确认该driver没有被注册过，然后注册，添加sysfs接口，向用户空间发送uevent。
bus_add_driver()->driver_attach(drv)->__driver_attach()->driver_match_device()->i2c_match_id()

[cpp]
view plain
copy

int driver_attach(struct device_driver *drv)  
{  
    return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);  
}  

遍历每个i2c device，match client->name, id->name；如果match成功i2c_match_id会返回id，driver_match_device返回1，如果该device没有绑定driver，__driver_attach继续执行driver_probe_device(drv, dev);->really_probe()->(dev->bus->probe(dev))->(drv->probe(dev));终于执行到probe了。really_probe中还会执行driver_bound(dev);

bus_add_driver()->klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);添加到bus->p->klist_drivers，那么register device执行bind的时候才能够遍历到。

[cpp]
view plain
copy

static void driver_bound(struct device *dev)  
{  
    if (klist_node_attached(&dev->p->knode_driver)) {  
        printk(KERN_WARNING "%s: device %s already bound\n",  
            __func__, kobject_name(&dev->kobj));  
        return;  
    }  
  
    pr_debug("driver: '%s': %s: bound to device '%s'\n", dev_name(dev),  
         __func__, dev->driver->name);  
  
    klist_add_tail(&dev->p->knode_driver, &dev->driver->p->klist_devices);  
  
    /* 
     * Make sure the device is no longer in one of the deferred lists and 
     * kick off retrying all pending devices 
     */  
    driver_deferred_probe_del(dev);  
    driver_deferred_probe_trigger();  
  
    if (dev->bus)  
        blocking_notifier_call_chain(&dev->bus->p->bus_notifier,  
                         BUS_NOTIFY_BOUND_DRIVER, dev);  
}  

主要是把dev->p->knode_driver添加到dev->driver->p->klist_devices上。
driver能够bound的前提是device已经建立了；如果没有建立呢？那就等到device建立的时候bound driver吧。

i2c_new_device()->device_register()->device_add(dev)->bus_add_device(dev)->klist_add_tail(&dev->p->knode_bus, &bus->p->klist_devices)添加到bus->p->klist_devices，那么register driver 执行bound的时候才能够遍历到。

device_add()->bus_probe_device()->device_attach()

[cpp]
view plain
copy

int device_attach(struct device *dev)  
{  
    int ret = 0;  
  
    device_lock(dev);  
    if (dev->driver) {  
        if (klist_node_attached(&dev->p->knode_driver)) {  
            ret = 1;  
            goto out_unlock;  
        }  
        ret = device_bind_driver(dev);  
        if (ret == 0)  
            ret = 1;  
        else {  
            dev->driver = NULL;  
            ret = 0;  
        }  
    } else {  
        ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);  
        pm_runtime_idle(dev);  
    }  
out_unlock:  
    device_unlock(dev);  
    return ret;  
}  

如果dev->driver已经存在了，判断是否执行了bind，没有执行，也会调用device_bind_driver()->driver_bound()执行bind；
否则

[cpp]
view plain
copy

ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);  

遍历每个i2c driver，__device_attach()->driver_match_device()同样是match，如果成功继续执行，driver_probe_device()->really_probe()。
总结：driver和device的bind过程是双向的；热插拔设备可以动态地bind driver。

2.2 驱动卸载

[cpp]
view plain
copy

void i2c_del_driver(struct i2c_driver *driver)  
{  
    i2c_for_each_dev(driver, __process_removed_driver);  
  
    driver_unregister(&driver->driver);  
    pr_debug("i2c-core: driver [%s] unregistered\n", driver->driver.name);  
}  

遍历i2c device，执行__process_removed_driver()->i2c_do_del_adapter()->(driver->detach_adapter(adapter))解除对应关系。

[cpp]
view plain
copy

void driver_unregister(struct device_driver *drv)  
{  
    if (!drv || !drv->p) {  
        WARN(1, "Unexpected driver unregister!\n");  
        return;  
    }  
    driver_remove_groups(drv, drv->groups);  
    bus_remove_driver(drv);  
}  

remove sysfs接口，remove driver。

[cpp]
view plain
copy

void bus_remove_driver(struct device_driver *drv)  
{  
    if (!drv->bus)  
        return;  
  
    if (!drv->suppress_bind_attrs)  
        remove_bind_files(drv);  
    driver_remove_attrs(drv->bus, drv);  
    driver_remove_file(drv, &driver_attr_uevent);  
    klist_remove(&drv->p->knode_bus);  
    pr_debug("bus: '%s': remove driver %s\n", drv->bus->name, drv->name);  
    driver_detach(drv);  
    module_remove_driver(drv);  
    kobject_put(&drv->p->kobj);  
    bus_put(drv->bus);  
}  

[cpp]
view plain
copy

void driver_detach(struct device_driver *drv)  
{  
    struct device_private *dev_prv;  
    struct device *dev;  
  
    for (;;) {  
        spin_lock(&drv->p->klist_devices.k_lock);  
        if (list_empty(&drv->p->klist_devices.k_list)) {  
            spin_unlock(&drv->p->klist_devices.k_lock);  
            break;  
        }  
        dev_prv = list_entry(drv->p->klist_devices.k_list.prev,  
                     struct device_private,  
                     knode_driver.n_node);  
        dev = dev_prv->device;  
        get_device(dev);  
        spin_unlock(&drv->p->klist_devices.k_lock);  
  
        if (dev->parent) /* Needed for USB */  
            device_lock(dev->parent);  
        device_lock(dev);  
        if (dev->driver == drv)  
            __device_release_driver(dev);  
        device_unlock(dev);  
        if (dev->parent)  
            device_unlock(dev->parent);  
        put_device(dev);  
    }<pre name="code" class="cpp"></pre>}  

drv->p->klist_devices.k_list.prev是对应&dev->p->knode_driver的list，是bound的时候加进去的；klist_add_tail(&dev->p->knode_driver, &dev->driver->p->klist_devices);

通过这个list可以找到dev->p的p，即dev_prv；

device_register()->device_add()->device_private_init()->(dev->p->device = dev;)

通过dev_prv可以找到device了，如果这个device匹配的driver是要del的，就执行__device_release_driver。

__device_release_driver()->(dev->bus->remove)->(driver->remove(client))
__device_release_driver()->devres_release_all()->klist_remove(&dev->p->knode_driver)->klist_del(n)->klist_put(n, true)->klist_dec_and_del()->klist_release()->list_del(&n->n_node);终于把自己给del了，所以drv->p->klist_devices.k_list.prev会自然向前移动，之前被删除list的前驱。用了for (;;)循环，保证drv->p->klist_devices.k_list全都删除，driver关联的每个dev都做del处理，一份driver可以对应多个device，每个device只能对应一个driver。如果dev->driver
!= drv，那__device_release_driver(dev);就不会执行drv->p->klist_devices.k_list.prev也不会移动了，岂不是死在看for循环了；drv->p->klist_devices.k_list挂的其实是deive，要保证不死循环，这个device对应的driver一定是bound的drvier，事实也是如此。

3 input设备注册

执行到driver->probe函数就开始了input设备的注册，简化后的probe函数如下。

[cpp]
view plain
copy

static int edt_ft5x06_ts_probe(struct i2c_client *client,  
                     const struct i2c_device_id *id)  
{  
    const struct edt_ft5x06_platform_data *pdata =  
                        client->dev.platform_data;  
    struct input_dev *input;  
  
    input = input_allocate_device();  
    if (!tsdata || !input) {  
        dev_err(&client->dev, "failed to allocate driver data.\n");  
        error = -ENOMEM;  
        goto err_free_mem;  
    }  
  
    input->name = tsdata->name;  
    input->id.bustype = BUS_I2C;  
    input->dev.parent = &client->dev;  
  
    __set_bit(EV_SYN, input->evbit);  
    __set_bit(EV_KEY, input->evbit);  
    __set_bit(EV_ABS, input->evbit);  
    __set_bit(BTN_TOUCH, input->keybit);  
    input_set_abs_params(input, ABS_X, 0, tsdata->num_x * 64 - 1, 0, 0);  
    input_set_abs_params(input, ABS_Y, 0, tsdata->num_y * 64 - 1, 0, 0);  
    input_set_abs_params(input, ABS_MT_POSITION_X,  
                 0, tsdata->num_x * 64 - 1, 0, 0);  
    input_set_abs_params(input, ABS_MT_POSITION_Y,  
                 0, tsdata->num_y * 64 - 1, 0, 0);  
    error = input_mt_init_slots(input, MAX_SUPPORT_POINTS, 0);  
    if (error) {  
        dev_err(&client->dev, "Unable to init MT slots.\n");  
        goto err_free_mem;  
    }  
  
    error = request_threaded_irq(client->irq, NULL, edt_ft5x06_ts_isr,  
                     IRQF_TRIGGER_FALLING | IRQF_ONESHOT,  
  
    error = input_register_device(input);  
    if (error)  
        goto err_remove_attrs;  
  
    return 0;  
  
err_remove_attrs:  
    sysfs_remove_group(&client->dev.kobj, &edt_ft5x06_attr_group);  
err_free_irq:  
    free_irq(client->irq, tsdata);  
err_free_mem:  
    input_free_device(input);  
    kfree(tsdata);  
  
    if (gpio_is_valid(pdata->irq_pin))  
        gpio_free(pdata->irq_pin);  
  
    return error;<pre name="code" class="cpp">}</pre>  

input_dev结构代表一个具体的input设备，getevent –p可以查看到，如果用到idc文件，也可以根据这个name匹配。
set_bit这些函数是填充input_dev的一些位掩码，代表支持的事件，寻找handler处理器的时候要做匹配。

[cpp]
view plain
copy

static inline void __set_bit(int nr, volatile unsigned long *addr)  
{  
    unsigned long mask = BIT_MASK(nr);  
    unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr);  
  
    *p  |= mask;  
}  
#define BIT_MASK(nr)        (1UL << ((nr) % BITS_PER_LONG))  
#define BIT_WORD(nr)        ((nr) / BITS_PER_LONG)  
#define BITS_PER_LONG 32  

例如：
__set_bit(EV_SYN, input->evbit); 等价于input->evbit[0] = 0;
__set_bit(EV_KEY, input->evbit); 等价于input->evbit[0] = 1;
__set_bit(EV_ABS, input->evbit); 等价于input->evbit[0] = 2;
__set_bit(BTN_TOUCH, input->keybit); 等价于input->keybit[0x14a/32] = 1<< (0x14a%32) 
也有直接input->evbit[ xx ] = xx 形式进行初始化的，这样初始化的时候注意要用或”1“。
input_set_abs_params()是初始化absinfo[]和absbit[]，前者是信息；后者同样是位掩码，支持的事件。

也就是说如果input_set_abs_params(input, ABS_Y, 0, tsdata->num_y * 64 - 1, 0, 0);就不需要再调用set_bit(ABS_Y, input->absbit);了，因为它已经执行了这个动作。
现在的很多代码会set_bit(INPUT_PROP_DIRECT, input->propbit);这个位，目的是让上层直接识别为input设备。

input_mt_init_slots()用于type B上报的初始化，有两个参数，slot num和flag。slot num用于初始化dev->mt->slots的size，也就是最大手指数。flag用于mt task任务的处理，一般不设置。
input_dev初始化好了之后，就开始关键的注册函数了。

[cpp]
view plain
copy

int input_register_device(struct input_dev *dev)  
{  
    static atomic_t input_no = ATOMIC_INIT(0);  
    struct input_devres *devres = NULL;  
    struct input_handler *handler;  
    unsigned int packet_size;  
    const char *path;  
    int error;  
  
    if (dev->devres_managed) {  
        devres = devres_alloc(devm_input_device_unregister,  
                      sizeof(struct input_devres), GFP_KERNEL);  
        if (!devres)  
            return -ENOMEM;  
  
        devres->input = dev;  
    }  
  
    /* Every input device generates EV_SYN/SYN_REPORT events. */  
    __set_bit(EV_SYN, dev->evbit);  
  
    /* KEY_RESERVED is not supposed to be transmitted to userspace. */  
    __clear_bit(KEY_RESERVED, dev->keybit);  
  
    /* Make sure that bitmasks not mentioned in dev->evbit are clean. */  
    input_cleanse_bitmasks(dev);  
  
    packet_size = input_estimate_events_per_packet(dev);  
    if (dev->hint_events_per_packet < packet_size)  
        dev->hint_events_per_packet = packet_size;  
  
    dev->max_vals = max(dev->hint_events_per_packet, packet_size) + 2;  
    dev->vals = kcalloc(dev->max_vals, sizeof(*dev->vals), GFP_KERNEL);  
    if (!dev->vals) {  
        error = -ENOMEM;  
        goto err_devres_free;  
    }  
  
    /* 
     * 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);  
  
    error = device_add(&dev->dev);  
    if (error)  
        goto err_free_vals;  
  
    path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);  
    pr_info("%s as %s\n",  
        dev->name ? dev->name : "Unspecified device",  
        path ? path : "N/A");  
    kfree(path);  
  
    error = mutex_lock_interruptible(&input_mutex);  
    if (error)  
        goto err_device_del;  
  
    list_add_tail(&dev->node, &input_dev_list);  
  
    list_for_each_entry(handler, &input_handler_list, node)  
        input_attach_handler(dev, handler);  
  
    input_wakeup_procfs_readers();  
  
    mutex_unlock(&input_mutex);  
  
    if (dev->devres_managed) {  
        dev_dbg(dev->dev.parent, "%s: registering %s with devres.\n",  
            __func__, dev_name(&dev->dev));  
        devres_add(dev->dev.parent, devres);  
    }  
    return 0;  
  
err_device_del:  
    device_del(&dev->dev);  
err_free_vals:  
    kfree(dev->vals);  
    dev->vals = NULL;  
err_devres_free:  
    devres_free(devres);  
    return error;  
}  

　　重新set了EV_SYN，因为么给input设备都要产生EV_SYN/SYN_REPORT事件，还要clear KEY_RESERVED，这个事件不允许传入到用户空间，是个保留事件。clean位掩码是说如果test出evbit[]中该type事件类型没有设置，那么相应位掩码对应的code事件编码就无效；自然需要清除了。比如说没有设置EV_KEY(这是一个type)；那么keybit[]就清0了。hint_events_per_packet是一个packet里事件的平均值，被事件处理器用于估计hold event需要的buffer
size。这个均值的计算分为几种情况，

如果初始化了dev->mt，mt_slots = dev->mt->num_slots。

否则，如果设置了ABS_MT_TRACKING_ID，那么

mt_slots = dev->absinfo[ABS_MT_TRACKING_ID].maximum -

dev->absinfo[ABS_MT_TRACKING_ID].minimum + 1,并且限制在2到32之间。

再否则，如果设置了ABS_MT_POSITION_X为2。

再否则为0。

此时计算的事件值为events = mt_slots + 1;//count SYN_MT_REPORT and SYN_REPORT

此后ABS_MT_FIRST和ABS_MT_LAST之间以及ABS_MT_SLOT的事件代码events += mt_slots;其余0到ABS_CNT之间的events++;0到REL_CNT之间的也是events++;；最后还要为KEY和MSC时间放大一些空间，最后计算出这么一个平均值。

　　初始化了一个timer，这个timer干什么用？是为了处理重复按键的。

input_repeat_key()->mod_timer(&dev->timer, jiffies +

msecs_to_jiffies(dev->rep[REP_PERIOD]));针对repeat_key，每33ms会处理一次。

input_repeat_key()->input_pass_values()->input_start_autorepeat()把定时器的到期时间改为dev->rep[REP_DELAY]。如果设置EV_REP，非repeat_key会设置为repeat_key，每250ms处理一次。总结一下重复按键：当按键按下的时候，如果设置EV_REP，把非repeat_key设置为repeat_key；到期时间还是250ms；到期后会执行input_repeat_key()；更改timer到期时间为33ms；每33ms处理一次；抬手的时候，input_stop_autorepeat()->del_timer(&dev->timer);。

dev->rep[REP_DELAY]是指第一次按下多久算一次，这里是250ms， dev->rep[REP_PERIOD]指如果按键没有被抬起，每33ms算一次。

　　input%ld，这个名字一般出现在./sys/devices/virtual/input/input2和/sys/class/input/input2。

　　所有register的input device都会挂到全局的input_dev_list上。

　　遍历input_handler_list处理器的list，为input device匹配handler，它们是多对多的关系。

[cpp]
view plain
copy

static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)  
{  
    const struct input_device_id *id;  
    int error;  
  
    id = input_match_device(handler, dev);  
    if (!id)  
        return -ENODEV;  
  
    error = handler->connect(handler, dev, id);  
    if (error && error != -ENODEV)  
        pr_err("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(input_device_id)的设置与input device的设置进行匹配，触摸屏对应的handler是evdev..c。

[cpp]
view plain
copy

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

[cpp]
view plain
copy

static inline int bitmap_subset(const unsigned long *src1,  
            const unsigned long *src2, int nbits)  
{  
    if (small_const_nbits(nbits))  
        return ! ((*src1 & ~(*src2)) & BITMAP_LAST_WORD_MASK(nbits));  
    else  
        return __bitmap_subset(src1, src2, nbits);  
}  

[cpp]
view plain
copy

#define small_const_nbits(nbits) \  
    (__builtin_constant_p(nbits) && (nbits) <= BITS_PER_LONG)  

　　做匹配时，主要是位图的匹配。例如：

bitmap_subset(id->absbit, dev->absbit, ABS_MAX)；就是比较dev->absbit的设置与id->absbit设置是否完全一致，一致就算匹配成功。

　　__builtin_constant_p(x)gcc的内建函数,当x为常数时返回1, x为变量时返回0。常数是指编译时常数。int len = sizeof(struct ...);紧接着的__builtin_constant_p(len)返回值就是1，len虽然为变量，但编译时可确定其值。

　　走到最后要调用handler->match(handler, dev)；貌似evdev.c没有实现这个match。

　　匹配成功就要进行连接了。

[cpp]
view plain
copy

static int evdev_connect(struct input_handler *handler, struct input_dev *dev,  
             const struct input_device_id *id)  
{  
    struct evdev *evdev;  
    int minor;  
    int dev_no;  
    int error;  
  
    minor = input_get_new_minor(EVDEV_MINOR_BASE, EVDEV_MINORS, true);  
    if (minor < 0) {  
        error = minor;  
        pr_err("failed to reserve new minor: %d\n", error);  
        return error;  
    }  
  
    evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);  
    if (!evdev) {  
        error = -ENOMEM;  
        goto err_free_minor;  
    }  
  
    INIT_LIST_HEAD(&evdev->client_list);  
    spin_lock_init(&evdev->client_lock);  
    mutex_init(&evdev->mutex);  
    init_waitqueue_head(&evdev->wait);  
    evdev->exist = true;  
  
    dev_no = minor;  
    /* Normalize device number if it falls into legacy range */  
    if (dev_no < EVDEV_MINOR_BASE + EVDEV_MINORS)  
        dev_no -= EVDEV_MINOR_BASE;  
    dev_set_name(&evdev->dev, "event%d", dev_no);  
  
    evdev->handle.dev = input_get_device(dev);  
    evdev->handle.name = dev_name(&evdev->dev);  
    evdev->handle.handler = handler;  
    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);  
  
    error = input_register_handle(&evdev->handle);  
    if (error)  
        goto err_free_evdev;  
  
    cdev_init(&evdev->cdev, &evdev_fops);  
    evdev->cdev.kobj.parent = &evdev->dev.kobj;  
    error = cdev_add(&evdev->cdev, evdev->dev.devt, 1);  
    if (error)  
        goto err_unregister_handle;  
  
    error = device_add(&evdev->dev);  
    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);  
 err_free_minor:  
    input_free_minor(minor);  
    return error;  
}  

为每个匹配的设备，分配一个evdev结构，并初始化，注意handle.dev是当前的input device，handle.handler是匹配上的handler，这个信息在事件处理的时候还要用。evdev对应的eventx，是一个char设备。

input_register_handle(&evdev->handle)；

　　list_add_tail_rcu(&handle->d_node, &dev->h_list);把handle挂在dev->h_list上

　　list_add_tail_rcu(&handle->h_node, &handler->h_list);把handle挂在handler->h_list上

这样通过handle就可以把handler和dev联系到一起了，本来handle就是个纽带。

至此，把一个input设备注册到了input子系统中；并为其匹配了handler，为时间处理做准备。前面关于i2c device注册和input子系统本身没有关系；也可以理解为touch即是一个i2c client，也是一个input device。