input子系统分析之三:驱动模块

内核版本:3.9.5

本节将以even handler来分析设备的注册和打开的过程,分析之前不妨回顾一下上节介绍的数据结构.

结合前两节分析可知,input子系统分为3层,最上一层是event handler,中间层是input core,底层是input driver.input driver把event report到input core层,input core对event进行分发,传到 event handler,相应的event handler层把event 放到event buffer中,等待应用程序读取!这就是input的基本思想.

那么我我们来看,Linux模块机制告诉我们在设备注册之前必须先初始化INPUT子系统,这个工作由input_init()函数来完成.在drivers/input.c中:

 1 static int __init input_init(void)
 2 {
 3     int err;
 4 
 5     err = class_register(&input_class);//注册input类
 6     if (err) {
 7         pr_err("unable to register input_dev class
");
 8         return err;
 9     }
10 
11     err = input_proc_init();//创建/proc中的项
12     if (err)
13         goto fail1;
14 
15     err = register_chrdev_region(MKDEV(INPUT_MAJOR, 0),
16                      INPUT_MAX_CHAR_DEVICES, "input");/*注册设备,主设备号为INPUT_MAJOR,就是13,后面注册的输入设备都使用该主设备号*/
17     if (err) {
18         pr_err("unable to register char major %d", INPUT_MAJOR);
19         goto fail2;
20     }
21 
22     return 0;
23 
24  fail2:    input_proc_exit();
25  fail1:    class_unregister(&input_class);
26     return err;
27 }
28 
29 static void __exit input_exit(void)
30 {
31     input_proc_exit();
32     unregister_chrdev_region(MKDEV(INPUT_MAJOR, 0),
33                  INPUT_MAX_CHAR_DEVICES);
34     class_unregister(&input_class);
35 }
36 
37 subsys_initcall(input_init);
38 module_exit(input_exit);

subsys_initcall和module_exit宏相信大家都很熟悉,这俩函数也很简单,没什么看的.

在入口函数里面创建了一个input_class类,其实就在/sys/class下创建了一个目录input.当然对于一个新设备,可以注册进一个class也可以不注册进去,如果存在对应class的话注册进去更好.另外在/proc创建了入口项,这样就可以/proc目录看到input的信息,然后就注册设备,可以看出输入子系统的主设备号是13,在这里并没有生成设备文件.只是在/dev/目录下创建了input目录,以后所有注册进系统的输入设备文件都放在这个目录下.

那么接下来看看怎么注册input设备的.我们需要在设备驱动层中完成输入设备的注册,通过调用input_register_device()函数来完成,该函数的一个重要任务就是完成设备与事件驱动的匹配.

 1 int input_register_device(struct input_dev *dev)
 2 {
 3     static atomic_t input_no = ATOMIC_INIT(0);
 4     struct input_devres *devres = NULL;
 5     struct input_handler *handler;
 6     unsigned int packet_size;
 7     const char *path;
 8     int error;
 9 
10     if (dev->devres_managed) {
11         devres = devres_alloc(devm_input_device_unregister,
12                       sizeof(struct input_devres), GFP_KERNEL);
13         if (!devres)
14             return -ENOMEM;
15 
16         devres->input = dev;
17     }
18 
19     /* Every input device generates EV_SYN/SYN_REPORT events. */
20     __set_bit(EV_SYN, dev->evbit);
21 
22     /* KEY_RESERVED is not supposed to be transmitted to userspace. */
23     __clear_bit(KEY_RESERVED, dev->keybit);
24 
25     /* Make sure that bitmasks not mentioned in dev->evbit are clean. */
26     input_cleanse_bitmasks(dev);
27 
28     packet_size = input_estimate_events_per_packet(dev);
29     if (dev->hint_events_per_packet < packet_size)
30         dev->hint_events_per_packet = packet_size;
31 
32     dev->max_vals = max(dev->hint_events_per_packet, packet_size) + 2;
33     dev->vals = kcalloc(dev->max_vals, sizeof(*dev->vals), GFP_KERNEL);
34     if (!dev->vals) {
35         error = -ENOMEM;
36         goto err_devres_free;
37     }
38 
39     /*
40      * If delay and period are pre-set by the driver, then autorepeating
41      * is handled by the driver itself and we don't do it in input.c.
42      */
43     init_timer(&dev->timer);
44     if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
45         dev->timer.data = (long) dev;
46         dev->timer.function = input_repeat_key;
47         dev->rep[REP_DELAY] = 250;
48         dev->rep[REP_PERIOD] = 33;
49     }
50 
51     if (!dev->getkeycode)/*没有定义设备的getkeycode函数，则使用默认的获取键值函数*/
52         dev->getkeycode = input_default_getkeycode;
53 
54     if (!dev->setkeycode)/*没有定义设备的setkeycode函数，则使用默认的设定键值函数*/
55         dev->setkeycode = input_default_setkeycode;
56 
57     dev_set_name(&dev->dev, "input%ld",
58              (unsigned long) atomic_inc_return(&input_no) - 1);/*设定dev的名字*/
59 
60     error = device_add(&dev->dev);/*添加设备*/
61     if (error)
62         goto err_free_vals;
63 
64     path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
65     pr_info("%s as %s
",
66         dev->name ? dev->name : "Unspecified device",
67         path ? path : "N/A");
68     kfree(path);
69 
70     error = mutex_lock_interruptible(&input_mutex);
71     if (error)
72         goto err_device_del;
73 
74     list_add_tail(&dev->node, &input_dev_list);/*将设备添加到input_dev_list设备链表*/
75 
76     list_for_each_entry(handler, &input_handler_list, node)
77         input_attach_handler(dev, handler);/*遍历input_handler_list，试图与每一个handler进行匹配*/
78 
79     input_wakeup_procfs_readers();
80 
81     mutex_unlock(&input_mutex);
82 
83     if (dev->devres_managed) {
84         dev_dbg(dev->dev.parent, "%s: registering %s with devres.
",
85             __func__, dev_name(&dev->dev));
86         devres_add(dev->dev.parent, devres);
87     }
88     return 0;
89 
90 err_device_del:
91     device_del(&dev->dev);
92 err_free_vals:
93     kfree(dev->vals);
94     dev->vals = NULL;
95 err_devres_free:
96     devres_free(devres);
97     return error;
98 }

第76，77行对于每个input_dev,遍历input_handler_list,调用input_attach_handler,根据input_handler的id_table判断能否支持这个input_dev.

 1 static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
 2 {
 3     const struct input_device_id *id;
 4     int error;
 5 
 6     id = input_match_device(handler, dev);
 7     if (!id)
 8         return -ENODEV;
 9 
10     error = handler->connect(handler, dev, id);/*执行handler的connect,建立handler与设备之间的联系*/
11     if (error && error != -ENODEV)
12         pr_err("failed to attach handler %s to device %s, error: %d
",
13                handler->name, kobject_name(&dev->dev.kobj), error);
14 
15     return error;
16 }

匹配的具体过程如下:

 1 static const struct input_device_id *input_match_device(struct input_handler *handler,
 2                             struct input_dev *dev)
 3 {
 4     const struct input_device_id *id;
 5 
 6     /*遍历handler的id_table与device进行匹配*/
 7     for (id = handler->id_table; id->flags || id->driver_info; id++) {
 8 
 9         /*根据flags的标志位，按需要匹配相应的字段*/
10         if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
11             if (id->bustype != dev->id.bustype)//总线类型不匹配
12                 continue;
13 
14         if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
15             if (id->vendor != dev->id.vendor)//生产厂商不匹配
16                 continue;
17 
18         if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
19             if (id->product != dev->id.product)//产品不匹配
20                 continue;
21 
22         if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
23             if (id->version != dev->id.version)//版本不匹配
24                 continue;
25 
26         if (!bitmap_subset(id->evbit, dev->evbit, EV_MAX))//匹配所有的事件类型
27             continue;
28 
29         /*匹配所有事件的子事件*/
30         if (!bitmap_subset(id->keybit, dev->keybit, KEY_MAX))
31             continue;
32 
33         if (!bitmap_subset(id->relbit, dev->relbit, REL_MAX))
34             continue;
35 
36         if (!bitmap_subset(id->absbit, dev->absbit, ABS_MAX))
37             continue;
38 
39         if (!bitmap_subset(id->mscbit, dev->mscbit, MSC_MAX))
40             continue;
41 
42         if (!bitmap_subset(id->ledbit, dev->ledbit, LED_MAX))
43             continue;
44 
45         if (!bitmap_subset(id->sndbit, dev->sndbit, SND_MAX))
46             continue;
47 
48         if (!bitmap_subset(id->ffbit, dev->ffbit, FF_MAX))
49             continue;
50 
51         if (!bitmap_subset(id->swbit, dev->swbit, SW_MAX))
52             continue;
53 
54         if (!handler->match || handler->match(handler, dev))
55             return id;//匹配成功,返回id
56     }
57 
58     return NULL;
59 }

这里接下来就到input_handler的connect了,看来注册input_handler是一道绕不过去的坎儿.那么我们来看具体的event handler的注册,在drivers/input/evdev.c中:

 1 static const struct input_device_id evdev_ids[] = {
 2     { .driver_info = 1 },    /* Matches all devices */
 3     { },            /* Terminating zero entry */
 4 };
 5 
 6 MODULE_DEVICE_TABLE(input, evdev_ids);
 7 
 8 static struct input_handler evdev_handler = {
 9     .event        = evdev_event,
10     .events        = evdev_events,
11     .connect    = evdev_connect,
12     .disconnect    = evdev_disconnect,
13     .legacy_minors    = true,
14     .minor        = EVDEV_MINOR_BASE,
15     .name        = "evdev",
16     .id_table    = evdev_ids,
17 };
18 
19 static int __init evdev_init(void)
20 {
21     return input_register_handler(&evdev_handler);
22 }
23 
24 static void __exit evdev_exit(void)
25 {
26     input_unregister_handler(&evdev_handler);
27 }
28 
29 module_init(evdev_init);
30 module_exit(evdev_exit);

这里一些相关的代码我也顺便贴出来了,再来一个:

 1 int input_register_handler(struct input_handler *handler)
 2 {
 3     struct input_dev *dev;
 4     int error;
 5 
 6     error = mutex_lock_interruptible(&input_mutex);
 7     if (error)
 8         return error;
 9 
10     INIT_LIST_HEAD(&handler->h_list);
11 
12     list_add_tail(&handler->node, &input_handler_list);
13 
14     list_for_each_entry(dev, &input_dev_list, node)
15         input_attach_handler(dev, handler);
16 
17     input_wakeup_procfs_readers();
18 
19     mutex_unlock(&input_mutex);
20     return 0;
21 }

这个函数不用多说了,注册event handler这个input_haner的实例,并且在注册之后迅速遍历了一下input_dev_list链表,查找所有的input_dev设备,看这个input_handler是否支持它.那么回到我们上面的遗留问题看看input_handler的connect函数.对于event handler来说,这个函数就是evdev_connect.在drivers/input/evdev.c中:

 1 static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
 2              const struct input_device_id *id)
 3 {
 4     struct evdev *evdev;
 5     int minor;
 6     int dev_no;
 7     int error;
 8 
 9     minor = input_get_new_minor(EVDEV_MINOR_BASE, EVDEV_MINORS, true);
10     if (minor < 0) {
11         error = minor;
12         pr_err("failed to reserve new minor: %d
", error);
13         return error;
14     }
15 
16     evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
17     if (!evdev) {
18         error = -ENOMEM;
19         goto err_free_minor;
20     }
21 
22     INIT_LIST_HEAD(&evdev->client_list);
23     spin_lock_init(&evdev->client_lock);
24     mutex_init(&evdev->mutex);
25     init_waitqueue_head(&evdev->wait);
26     evdev->exist = true;
27 
28     dev_no = minor;
29     /* Normalize device number if it falls into legacy range */
30     if (dev_no < EVDEV_MINOR_BASE + EVDEV_MINORS)
31         dev_no -= EVDEV_MINOR_BASE;
32     dev_set_name(&evdev->dev, "event%d", dev_no);
33 
34     /*初始化handle,每个evdev中都有一个handle*/
35     evdev->handle.dev = input_get_device(dev);/*这里就将handle的dev指针指向了input_dev*/
36     evdev->handle.name = dev_name(&evdev->dev);
37     evdev->handle.handler = handler;/*这里将handle的handler指向了当前的input_handler.注意本函数evdev_connect,可能是在在输入设备注册的时候
38     在input_register_device函数中调用input_attach_handler的时候调用;也可能是在输入设备的处理方法input_handler时在input_register_handler
39     函数中也会用到input_attach_handler函数,就会调用本函数.这里就很明显了,本函数就将input_handler和input_dev都放在input_handle中统一管理*/
40     evdev->handle.private = evdev;
41 
42     /*初始化evdev中的内嵌device*/
43     evdev->dev.devt = MKDEV(INPUT_MAJOR, minor);
44     evdev->dev.class = &input_class;
45     evdev->dev.parent = &dev->dev;
46     evdev->dev.release = evdev_free;
47     device_initialize(&evdev->dev);
48 
49     /*注册handle,主要将handle链接到input_dev和handler的h_list链表中去*/
50     error = input_register_handle(&evdev->handle);
51     if (error)
52         goto err_free_evdev;
53 
54     cdev_init(&evdev->cdev, &evdev_fops);
55     evdev->cdev.kobj.parent = &evdev->dev.kobj;
56     error = cdev_add(&evdev->cdev, evdev->dev.devt, 1);
57     if (error)
58         goto err_unregister_handle;
59 
60     error = device_add(&evdev->dev);
61     if (error)
62         goto err_cleanup_evdev;
63 
64     return 0;
65 
66  err_cleanup_evdev:
67     evdev_cleanup(evdev);
68  err_unregister_handle:
69     input_unregister_handle(&evdev->handle);
70  err_free_evdev:
71     put_device(&evdev->dev);
72  err_free_minor:
73     input_free_minor(minor);
74     return error;
75 }

至此设备的注册完成!对应event handler,在/dev/input中将多出一个event(x)设备文件,对应一个evdev实例,应用程序打开它的话也就意味着通过event handler来和设备驱动层传递事件.

第54~60行这几行字符设备初始化,这里之后再将字符设备注册,然后我们打开event(x)设备文件的时候实际上就调用evdev_fops里定义的open回调函数.相应的操作函数也在evdev_fops中定义了.我们来看看evdev_fops.同样在drivers/input/evdev.c中:

 1 static const struct file_operations evdev_fops = {
 2     .owner        = THIS_MODULE,
 3     .read        = evdev_read,
 4     .write        = evdev_write,
 5     .poll        = evdev_poll,
 6     .open        = evdev_open,
 7     .release    = evdev_release,
 8     .unlocked_ioctl    = evdev_ioctl,
 9 #ifdef CONFIG_COMPAT
10     .compat_ioctl    = evdev_ioctl_compat,
11 #endif
12     .fasync        = evdev_fasync,
13     .flush        = evdev_flush,
14     .llseek        = no_llseek,
15 };

首先来看打开event(x)设备文件,evdev_open函数.

 1 static int evdev_open(struct inode *inode, struct file *file)
 2 {
 3     struct evdev *evdev = container_of(inode->i_cdev, struct evdev, cdev);
 4     unsigned int bufsize = evdev_compute_buffer_size(evdev->handle.dev);
 5     struct evdev_client *client;
 6     int error;
 7 
 8     /*每当一个应用程序打开该文件都会生成一个client*/
 9     client = kzalloc(sizeof(struct evdev_client) +
10                 bufsize * sizeof(struct input_event),
11              GFP_KERNEL);
12     if (!client)
13         return -ENOMEM;
14 
15     client->bufsize = bufsize;
16     spin_lock_init(&client->buffer_lock);
17     client->evdev = evdev;
18     evdev_attach_client(evdev, client);/*将client链入evdev的client_list中*/
19 
20     error = evdev_open_device(evdev);
21     if (error)
22         goto err_free_client;
23 
24     file->private_data = client;
25     nonseekable_open(inode, file);
26 
27     return 0;
28 
29  err_free_client:
30     evdev_detach_client(evdev, client);
31     kfree(client);
32     return error;
33 }

第20行调用evdev_open_device来打开evdev(如果将inpit_dev抽象为一个父对象,这其实就是一个子对象,或者说这个结构封装了一个具体的实例化的input_dev).

 1 static int evdev_open_device(struct evdev *evdev)
 2 {
 3     int retval;
 4 
 5     retval = mutex_lock_interruptible(&evdev->mutex);
 6     if (retval)
 7         return retval;
 8 
 9     if (!evdev->exist)
10         retval = -ENODEV;
11     else if (!evdev->open++) {/*如果是第一次打开该设备,则要执行输入设备的open*/
12         retval = input_open_device(&evdev->handle);
13         if (retval)
14             evdev->open--;
15     }
16 
17     mutex_unlock(&evdev->mutex);
18     return retval;
19 }

这里终于看到了输入子系统核心层的接口input_open_device,此函数就是内核为我们做好的初始化input_dev的函数接口.

 1 int input_open_device(struct input_handle *handle)
 2 {
 3     struct input_dev *dev = handle->dev;
 4     int retval;
 5 
 6     retval = mutex_lock_interruptible(&dev->mutex);
 7     if (retval)
 8         return retval;
 9 
10     if (dev->going_away) {
11         retval = -ENODEV;
12         goto out;
13     }
14 
15     handle->open++;
16 
17     if (!dev->users++ && dev->open)/*如果是第一次打开此设备(当前input_dev的使用者数为0),并且input_dev中定义的open函数不为空*/
18         retval = dev->open(dev);//执行input_dev中定义的open,完成设备的初始化
19 
20     if (retval) {
21         dev->users--;
22         if (!--handle->open) {
23             /*
24              * Make sure we are not delivering any more events
25              * through this handle
26              */
27             synchronize_rcu();
28         }
29     }
30 
31  out:
32     mutex_unlock(&dev->mutex);
33     return retval;
34 }

至于具体的如何初始化input_dev,这个是具体的输入设备去实现的.我们这里不分析了.现在来看看,对于一个event(x)设备文件的.

 1 static ssize_t evdev_read(struct file *file, char __user *buffer,
 2               size_t count, loff_t *ppos)
 3 {
 4     struct evdev_client *client = file->private_data;
 5     struct evdev *evdev = client->evdev;
 6     struct input_event event;
 7     size_t read = 0;
 8     int error;
 9 
10     if (count != 0 && count < input_event_size())
11         return -EINVAL;
12 
13     for (;;) {
14         if (!evdev->exist)/*evdev没有定义返回函数,直接返回吧,因为我们下面必须要用到这个函数*/
15             return -ENODEV;
16 
17         if (client->packet_head == client->tail &&
18             (file->f_flags & O_NONBLOCK))/*无数据并且是非阻塞状态,则直接返回,说明没什么要处理的*/
19             return -EAGAIN;
20 
21         /*
22          * count == 0 is special - no IO is done but we check
23          * for error conditions (see above).
24          */
25         if (count == 0)
26             break;
27 
28         while (read + input_event_size() <= count &&
29                evdev_fetch_next_event(client, &event)) {
30 
31             if (input_event_to_user(buffer + read, &event))
32                 return -EFAULT;
33 
34             read += input_event_size();
35         }
36 
37         if (read)
38             break;
39 
40         if (!(file->f_flags & O_NONBLOCK)) {/*如果是可阻塞状态的话,则等待在wait队列上.直到有数据要被处理,当前进程才被唤醒.这很好理解,既然是
41         输入设备,读的话比如读按键,那么必须要有硬件设备有按键按下才会返回按键值,这里还是处于事件处理层,应用程序在这里休眠,那么谁来唤醒?
42         当然是有按键按下才去唤醒,因此这个工作就交给了设备驱动层,那么找到这个唤醒呢,直接去找不好找,那么可以直接搜索evdev->wait,搜索结果
43         可知evdev->wait在evdev_event()函数中被唤醒*/
44             error = wait_event_interruptible(evdev->wait,
45                     client->packet_head != client->tail ||
46                     !evdev->exist);
47             if (error)
48                 return error;
49         }
50     }
51 
52     return read;
53 }

注释中说的很清楚,evdev_event()会唤醒此处的读按键进程.那么evdev_event()又是被谁调用?显然是设备驱动层,现在看一个设备层例子,内核中有个按键的例子,gpiokey.c,这只是个例子不针对任何设备,在gpiokey.c终端处理函数里面.

 1 static void evdev_pass_values(struct evdev_client *client,
 2             const struct input_value *vals, unsigned int count,
 3             ktime_t mono, ktime_t real)
 4 {
 5     struct evdev *evdev = client->evdev;
 6     const struct input_value *v;
 7     struct input_event event;
 8     bool wakeup = false;
 9 
10     event.time = ktime_to_timeval(client->clkid == CLOCK_MONOTONIC ?
11                       mono : real);
12 
13     /* Interrupts are disabled, just acquire the lock. */
14     spin_lock(&client->buffer_lock);
15 
16     for (v = vals; v != vals + count; v++) {
17         event.type = v->type;
18         event.code = v->code;
19         event.value = v->value;
20         __pass_event(client, &event);
21         if (v->type == EV_SYN && v->code == SYN_REPORT)
22             wakeup = true;
23     }
24 
25     spin_unlock(&client->buffer_lock);
26 
27     if (wakeup)
28         wake_up_interruptible(&evdev->wait);
29 }
30 
31 /*
32  * Pass incoming events to all connected clients.
33  */
34 static void evdev_events(struct input_handle *handle,
35              const struct input_value *vals, unsigned int count)
36 {
37     struct evdev *evdev = handle->private;
38     struct evdev_client *client;
39     ktime_t time_mono, time_real;
40 
41     time_mono = ktime_get();
42     time_real = ktime_sub(time_mono, ktime_get_monotonic_offset());
43 
44     rcu_read_lock();
45 
46     client = rcu_dereference(evdev->grab);
47 
48     if (client)
49         evdev_pass_values(client, vals, count, time_mono, time_real);
50     else
51         list_for_each_entry_rcu(client, &evdev->client_list, node)
52             evdev_pass_values(client, vals, count,
53                       time_mono, time_real);
54 
55     rcu_read_unlock();
56 }
57 
58 /*
59  * Pass incoming event to all connected clients.
60  */
61 static void evdev_event(struct input_handle *handle,
62             unsigned int type, unsigned int code, int value)
63 {
64     struct input_value vals[] = { { type, code, value } };
65 
66     evdev_events(handle, vals, 1);
67 }

好了,就贴到这里,input子系统的大体脉络以及比较清楚了.