input子系统学习(2)

下面我们看下handler和input_dev之间是如何联系起来的，handle这个结构体就是联系两者的纽带，在前面分析input_register_handler时曾提到过handle。

struct input_handle {

    void *private;        //私有数据

    int open;        //标志此handle是否正在被使用
    const char *name;    //handle的名字

    struct input_dev *dev;        //此handle关联的input_dev
    struct input_handler *handler;    //此handle关联的handler

    struct list_head    d_node;        //将放置到关联的dev的h_list中
    struct list_head    h_node;        //将放置到关联的handler的h_list中
};

向系统注册一个handle需要调用input_register_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);    //(1)
    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);    //(2)

    if (handler->start)                //(3)
        handler->start(handle);

    return 0;
}

(1)将handle的d_node添加到handle关联的dev的h_list中

(2)将handle的h_node添加到handle关联的handler的h_list中

(3)如果handler中定义了start则调用它

此函数主要就是将d_node和h_node放到相应h_list中。

那handle在什么时候会被注册，会联系设备和handler，差不多应该猜得到handler的connect函数应该与此有关，将在后面介绍

---------------------------------------------------------

至此已经分析了handler这边，也看了device这边。也分析了它们的联系handle。现在我们需要知道当设备有事件产生时如何报告给input核心，以及如何再让handler处理。

这里假使我们是一个键盘设备产生的事件则应该是按键事件，则驱动程序应该调用input_report_key函数报告此事件。

static inline void input_report_key(struct input_dev *dev, unsigned int code, int value)
{
    input_event(dev, EV_KEY, code, !!value);
}

input_report_key函数参数，1.input_dev设备，2。按键值 3.按键的状态（1按下，0松开）

在input.h中定义了按键类code的值，BTN_0,BTN_1,KEY_A KEY_B等等这样的键值

此函数只是调用了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)) {    //(1)

        spin_lock_irqsave(&dev->event_lock, flags);    //(2)
        add_input_randomness(type, code, value);    //(3)
        input_handle_event(dev, type, code, value);    //(4)
        spin_unlock_irqrestore(&dev->event_lock, flags);//(5)
    }
}

参数1.input_dev 2.事件类型(如EV_KEY键盘事件) 3.此类型具体事件code(如KEY_A，键A) 4.此事件的值(如1，按键按下)

(1)设备是否支持该事件类型。下面分析

(2)自旋锁上锁

(3)因为按键时是随机事件，所以对随机熵有贡献，对于驱动无关。具体不懂

(4)进一步处理报告的事件

(5)自旋锁解锁

is_event_supported此函数检查是否支持该事件类型

static inline int is_event_supported(unsigned int code, unsigned long *bm, unsigned int max)
{
    return code <= max && test_bit(code, bm);
}

分析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) {
    ……

    case EV_KEY:
        if (is_event_supported(code, dev->keybit, KEY_MAX) &&    //(1)
         !!test_bit(code, dev->key) != value) {        //(2)

            if (value != 2) {
                __change_bit(code, dev->key);        //(3)
                if (value)
                    input_start_autorepeat(dev, code);    //(4)
                else
                    input_stop_autorepeat(dev);    //(5)
            }

            disposition = INPUT_PASS_TO_HANDLERS;
        }
        break;
    ……

    if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)    //(6)
        dev->sync = 0;

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

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

此函数虽长分支结构而已，但并不复杂。因为是键盘事件，所以看EV_KEY分支。

(1)is_event_supported(code, dev->keybit, KEY_MAX),这句测试此按键code是否被keybit支持

(2)!!test_bit(code, dev->key),key是键盘当前所有键状态，测试code对应键状态，value传来事件的按键状态。此句表示按键状态应有变化

(3)改变key的值以改变按键状态。

(4)如果按键值为按下，则开始重复按键操作。具体会不会重复，input_start_autorepeat还会根据evbit中有没有置位重复事件等判断。

(5)如果是松开按键则应停止重复按键相关操作。

(6)?

(7)如果在上面分支结构中设置了发送给device处理事件INPUT_PASS_TO_DEVICE，则调用dev->event处理相关事件

(8)如果在上面分支结构中设置了发送给handler处理事件INPUT_PASS_TO_HANDLERS，则调用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);    //(1)
    if (handle)
        handle->handler->event(handle, type, code, value);    //(2)
    else
        list_for_each_entry_rcu(handle, &dev->h_list, d_node)
            if (handle->open)
                handle->handler->event(handle,            //(3)
                            type, code, value);
    rcu_read_unlock();
}

(1)grab是给设备强制绑定的handle，此句是取出grab表示的handle，但具体有没有handle，还要看有没有设置grab

(2)如果grab有，则调用此handle中的handler的event函数处理事件。

(3)如果grab没有，则遍历dev中h_list上所有的handle，这些handle如果打开(open为1)，则进一步处理，将调用其hanlde中的

handler的event处理事件。h_list中的d_node成员会通过container_of找到其handle变量。

----------------------------------------------------------------------------------------

现在需要一个input的实例，来看看整个input子系统是怎么联系和运作的。evdev是一个input类型的设备，输入事件驱动，为输入子系统提供了一个默认的事件处理方法，我们以此为例分析一下。

在driver/input/evdev.c文件中，入口函数evdev_init

static int __init evdev_init(void)
{
    return input_register_handler(&evdev_handler);
}

入口函数调用了input_register_handler(&evdev_handler)

evdev_handler如下，

static struct input_handler evdev_handler = {
    .event        = evdev_event,
    .connect    = evdev_connect,
    .disconnect    = evdev_disconnect,
    .fops        = &evdev_fops,
    .minor        = EVDEV_MINOR_BASE,    //EVDEV_MINOR_BASE是64，除32是2，则应在input_table[2]
    .name        = "evdev",
    .id_table    = evdev_ids,        //支持的设备的集合
};

我们前面分析了input_register_handler,此函数主要的一个任务是input_table[handler->minor >> 5] = handler这句，在这里将会将evdev_handler放入input_table[2]中。

此函数另一个任务是遍历所有input_dev_list上的设备，并调用input_attach_handler(dev, handler)，之前我们看了此函数会在匹配相关信息，我们看下evdev_handler中的id_table

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

根据之前input_match_device函数的分析，不设置所有标志，所有bit位都为0且driver_info = 1，

evdev_ids这样的设置会匹配到所有的设备,而我们也知道如果设备匹配了，input_attach_handler函数中会调用handler的connect函数关联两者，所以此handler会关联上所有的设备，之前我们一直没有分析到究竟它们如何关联起来，现在终于可以分析到connect函数了，evdev_handler的connect函数是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++)    //(1)
        if (!evdev_table[minor])
            break;

    if (minor == EVDEV_MINORS) {            //(2)
        printk(KERN_ERR "evdev: no more free evdev devices\n");
        return -ENFILE;
    }

    evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);    //(3)
    if (!evdev)
        return -ENOMEM;

    INIT_LIST_HEAD(&evdev->client_list);            //(4)
    spin_lock_init(&evdev->client_lock);
    mutex_init(&evdev->mutex);
    init_waitqueue_head(&evdev->wait);

    dev_set_name(&evdev->dev, "event%d", minor);        //(5)
    evdev->exist = 1;
    evdev->minor = minor;

    evdev->handle.dev = input_get_device(dev);        //(6)
    evdev->handle.name = dev_name(&evdev->dev);
    evdev->handle.handler = handler;
    evdev->handle.private = evdev;

    evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);    //(7)
    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);        //(8)
    if (error)
        goto err_free_evdev;

    error = evdev_install_chrdev(evdev);            //(9)
    if (error)
        goto err_unregister_handle;

    error = device_add(&evdev->dev);            //(10)
    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;
}

(1)EVDEV_MINORS是32，代表了evdev可关联最多32个设备，input_table数组有8个成员，而一个主设备有256个次设备。所以一个input_table也应最多关联32个设备。这句是在evdev_table的32成员中，顺序找到为空的项，然后出来。

(2)minor累加到和EVDEV_MINORS，说明evdev_table中成员已经满了。

(3)分配一个evdev

struct evdev {
    int exist;
    int open;
    int minor;
    struct input_handle handle;
    wait_queue_head_t wait;
    struct evdev_client *grab;
    struct list_head client_list;
    spinlock_t client_lock; /* protects client_list */
    struct mutex mutex;
    struct device dev;
};

(4)初始化evdev的一些变量

(5)设置evdev的名字等，会在/dev/input目录下

(6)设置evdev的handle成员（包括关联的设备，关联的handler，名字，私有数据为evdev），为注册其做准备。

(7)设置evdev中的dev，包括设备号，所属类，父设备（驱动中input_dev设备的device结构变量）,释放函数。

(8)将evdev中的handle，注册，input_register_handle函数在上面已经分析。即使将handle中关联的handler和设备之间，添加进两者的h_list中。

(9)此函数只一句evdev_table[evdev->minor] = evdev;

(10)将evdev中的dev添加进内核核心。这样connect函数就将相关的关联全部搞好了。

结构体中的.fops，&evdev_fops提供了基本操作函数。

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核心的open函数input_open_file会调用相应新的handler中的open函数，再次打开设备。

我们看下evdev的open函数evdev_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;    //(1)
    int error;

    error = mutex_lock_interruptible(&evdev_table_mutex);

    evdev = evdev_table[i];            //(2)
    if (evdev)
        get_device(&evdev->dev);    //(3)
    mutex_unlock(&evdev_table_mutex);

    if (!evdev)
        return -ENODEV;
    client = kzalloc(sizeof(struct evdev_client), GFP_KERNEL);    //(4)
    spin_lock_init(&client->buffer_lock);
    client->evdev = evdev;            //(5)
    evdev_attach_client(evdev, client);    //(6)
    error = evdev_open_device(evdev);    //(7)
    file->private_data = client;
    return 0;
}

(1)根据打开的次设备号，减去evdev起始次设备号，得到evdev_table的索引

(2)从evdev_table中取出evdev

(3)增加evdev中dev的引用计数

(4)申请一个evdev_client

struct evdev_client {
    struct input_event buffer[EVDEV_BUFFER_SIZE];
    int head;
    int tail;
    spinlock_t buffer_lock; /* protects access to buffer, head and tail */
    struct fasync_struct *fasync;
    struct evdev *evdev;
    struct list_head node;
};

(5)给client的evdev赋值

(6)将client挂到evdev的client_list上

(7)打开evdev设备。

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;
    else if (!evdev->open++) {            //(1)
        retval = input_open_device(&evdev->handle); //(2)
        if (retval)
            evdev->open--;
    }
    mutex_unlock(&evdev->mutex);
    return retval;
}

(1)evdev是否第一次打开，是则进入

(2)打开evdev中handle中的设备

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

    handle->open++;                //(1)

    if (!dev->users++ && dev->open)        //(2)
        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();
        }
    }
}

(1)handle的打开计数加1

(2)user为0且input_dev的open函数定义。则调用它的open函数。

input子系统总的来说，input核心的入口函数input_init，注册了register_chrdev，主设备号13的字符设备驱动。input_register_device注册一个包含device结构的input_dev变量（device_add添加device成员名字形如input1，input2，input_dev的变量被加入input_dev_list全局列表）。input_register_handler注册一个handler在input_table中（input_handler被加入input_handler_list全局列表），设备和handler在注册中都会依靠handler中的input_device_id匹配dev中的信息，来匹配对方，匹配将调用hanlder中的connect函数，此函数会产生一个handle来关联两者。

......